solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k, a, b, temp, min, max, sum;
vector<int> v1, v2;
cin >> t;
while (t) {
v1.clear();
v2.clear();
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> temp;
v1.push_back(temp);
}
for (int i = 0; i < n; i++) {
cin >> temp;
v2.push_back(temp);
}
for (int i = 0; i < k; i++) {
int i_min = 0;
int i_max = 0;
for (int j = 1; j < n; j++) {
if (v1[j] < v1[i_min]) i_min = j;
if (v2[j] > v2[i_max]) i_max = j;
}
if (v1[i_min] < v2[i_max]) swap(v1[i_min], v2[i_max]);
}
sum = 0;
for (int i : v1) sum += i;
cout << endl;
cout << sum << endl;
t--;
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T, typename TT>
inline ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T>
inline istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &is, pair<T1, T2> &t) {
is >> t.first >> t.second;
return is;
}
const long long mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
vector<int> v(n);
cin >> v;
vector<vector<int> > g(n), lvl(n + 1);
vector<int> s;
for (int i = 0; i < n; i++) {
if (v[i] != -1 and v[i] <= n) g[v[i] - 1].push_back(i);
s.push_back(i + 1);
}
vector<int> dp(n), ans(n);
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (auto x : g[i]) dp[i] = max(dp[i], dp[x] + 1);
if (v[i] != -1) dp[i] += v[i] - i - 2;
lvl[dp[i]].push_back(i);
}
for (int i = n; i > 0; i--) {
for (auto x : lvl[i]) {
ans[x] = s.back();
s.pop_back();
}
}
s.clear();
s.push_back(n + 1);
for (int i = n - 1; i >= 0; i--) {
while (s.back() != n + 1 and ans[i] >= ans[s.back() - 1]) s.pop_back();
if (v[i] != -1 and v[i] != s.back()) {
cout << -1 << '\n';
return;
}
s.push_back(i + 1);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
int T = 1;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 2,100 | CPP |
t = int(input())
while t != 0:
n = int(input())
a = list(map(int, input().split()))[:n]
net = 0
for i in a:
net += i
if net < 0:
net = 0
print(net)
t -= 1
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t;
cin >> n >> m >> t;
n *= t;
if (n % 100 != 0) n += 100;
n /= 100;
if (m > n) {
cout << 0;
return 0;
}
cout << n - m;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << (n + 1) / 2 - 1 << endl;
sort(a, a + n);
for (int i = 0; i < n / 2; i++) {
cout << a[n - 1 - i] << " " << a[i] << " ";
}
if (n % 2 == 1) cout << a[n / 2];
}
| 1,000 | CPP |
n=input()
s=n.lower()
s1=[s[i] for i in range(len(n)) if s[i] not in ['a','e','i','o','u','y']]
s2=['.'+s1[i] for i in range(len(s1))]
l=''
for i in range(len(s2)):
l=l+s2[i]
print(l) | 1,000 | PYTHON3 |
#
# Author: eloyhz
# Date: Sep/09/2020
#
def form_teams(g, colors, c, s):
# print(f'{s = }, {c = }')
colors[s] = c
for v in g[s]:
if colors[v] is None:
form_teams(g, colors, 1 - c, v)
elif colors[v] == c:
colors[s] = -1
def solve(n, m, g):
colors = [None] * (n + 1)
for i in range(1, n + 1):
if colors[i] == None:
form_teams(g, colors, 0, i)
# print(colors)
cont = colors.count(-1)
if (n - cont) % 2 == 0:
return cont
else:
return cont + 1
if __name__ == '__main__':
n, m = [int(x) for x in input().split()]
g = [[] for _ in range(n + 1)]
for _ in range(m):
a, b = [int(x) for x in input().split()]
g[a].append(b)
g[b].append(a)
print(solve(n, m, g))
| 1,700 | PYTHON3 |
import math
for t in range(int(input())):
n = int(input())
#a,b = (int(i) for i in input().split())
#a = list(input())
#a = [int(i) for i in input().split()]
N = int(math.log(n,2))+1
#print(N,'-')
m = 0.5*N*N+0.5*N-1
print(int(sum([n//(2**i) for i in range(int(N))])))
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> id(n, 0);
map<int, bool> ct;
int m = 0;
for (int i = 0; i < n; i++) {
cin >> id[i];
if (ct.find(id[i]) == ct.end()) m++;
ct[id[i]] = 1;
}
int mres = min(m, k);
vector<int> a(k, 0);
int d = -1;
map<int, bool> ck;
for (int i = 0; i < n; i++) {
if (ck.find(id[i]) == ck.end()) {
ck.erase(a[(d + 1) % mres]);
d = (d + 1) % mres;
a[d] = id[i];
ck[id[i]] = 1;
}
}
cout << mres << endl;
for (int t = mres; t > 0; t--) cout << a[(d + t) % mres] << ' ';
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j, c1, c2;
c1 = c2 = 0;
char s[10];
for (i = 0; i < 8; i++) {
cin >> s;
for (j = 0; j < 8; j++) {
if (s[j] == 'Q')
c1 += 9;
else if (s[j] == 'R')
c1 += 5;
else if (s[j] == 'B')
c1 += 3;
else if (s[j] == 'N')
c1 += 3;
else if (s[j] == 'P')
c1 += 1;
else if (s[j] == 'q')
c2 += 9;
else if (s[j] == 'r')
c2 += 5;
else if (s[j] == 'b')
c2 += 3;
else if (s[j] == 'n')
c2 += 3;
else if (s[j] == 'p')
c2 += 1;
}
}
if (c1 > c2)
cout << "White" << endl;
else if (c2 > c1)
cout << "Black" << endl;
else
cout << "Draw" << endl;
return 0;
}
| 900 | CPP |
n = int(input())
listT = list(map(int, input().split()))
i = k = 1
ma = mi = listT[0]
while i < n:
if listT[i] > ma:
ma = listT[i]
k += 1
if listT[i] < mi:
mi = listT[i]
k += 1
i += 1
print(k - 1) | 800 | PYTHON3 |
class node:
def __init__(self, value, parent, respect):
self.value = value
self.children = []
self.parent = parent
self.respect = respect
all_nodes = {}
root = -1
not_respectors = []
import sys
n = int(sys.stdin.readline())
for i in range(n):
line = sys.stdin.readline()[:-1]
node_parent, node_res = line.split(" ")
if i+1 in all_nodes:
all_nodes[i+1].parent = int(node_parent)
all_nodes[i+1].respect = int(node_res)
else:
all_nodes[i+1] = node(i+1, int(node_parent), int(node_res))
if int(node_parent) == -1:
root = all_nodes[i+1]
else:
int_node_parent = int(node_parent)
if int_node_parent not in all_nodes:
all_nodes[int_node_parent] = node(int_node_parent, -1, -1)
all_nodes[int_node_parent].children.append(all_nodes[i+1])
if int(node_res) == 1:
not_respectors.append(all_nodes[i+1])
def get_val(n):
return n.value
not_respecters = sorted(not_respectors, key=get_val)
tot = []
for n in not_respectors:
b = True
for c in n.children:
if c.respect == 0:
b = False
break
if b:
tot.append(n)
if len(tot) == 0:
print("-1")
else:
print(" ".join(map(str, map(get_val, tot))))
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
const string DICT = "RGB";
int diff[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int Q;
cin >> Q;
while (Q--) {
int n, k;
string ss;
cin >> n >> k >> ss;
if (n == 1) {
cout << "0" << endl;
continue;
}
int ans = k;
for (int start_ch = 0; start_ch < 3; start_ch++) {
diff[0] = (DICT[start_ch] == ss[0] ? 0 : 1);
for (int i = 1, picker = (start_ch + 1) % 3; i < ss.size();
i++, picker = (picker + 1) % 3) {
if (ss[i] == DICT[picker])
diff[i] = diff[i - 1];
else
diff[i] = diff[i - 1] + 1;
if (i + 1 >= k)
ans = min(ans, diff[i] - ((i - k) >= 0 ? diff[i - k] : 0));
}
}
cout << ans << endl;
}
return 0;
}
| 1,500 | CPP |
n = int(input())
room = set()
maximum = 0
for _ in range(n):
t, r = input().split()
r = int(r)
if t == '+':
room.add(r)
maximum = max(maximum, len(room))
else:
if r in room:
room.remove(r)
else:
maximum += 1
print(maximum) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a;
scanf("%d", &n);
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
sum += abs(a);
}
printf("%d\n", sum);
}
| 800 | CPP |
m,s = 1, 0
m, s = [int(x) for x in input().split(' ')]
if (s == 0 and m != 1) or m*9 < s:
print('-1 -1')
exit(0)
target = s
result_max = ''
for i in range(m):
for digit in reversed(range(0, 10)):
if target >= digit:
target -= digit
result_max += str(digit)
break
if target == 0:
break
if len(result_max) != i +1:
result_max += '0'
target = s
result_min = ''
for i in range(m):
for digit in reversed(range(0, 10)):
if (target -1) >= digit:
target -= digit
result_min = str(digit) + result_min
break
if target == 0:
break
if len(result_min) != i+1:
result_min = '0'+result_min
if target == 1:
result_min = str(int(result_min[0]) + 1) + result_min[1:]
print('{} {}'.format(result_min, result_max))
| 1,400 | PYTHON3 |
n = int(input())
counts = 4 * [0]
for a in map(int, input().split()):
counts[a] += 1
result = n - max(counts)
print(result)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> a;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
a.push_back(s);
}
vector<int> g;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
g.push_back(x);
}
vector<int> ans;
while (1) {
int i = 0;
for (i = 0; i < n; ++i) {
if (!g[i]) {
break;
}
}
if (i == n) {
break;
}
ans.push_back(i);
for (int j = 0; j < n; ++j) {
if (a[i][j] == '1') {
--g[j];
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i] + 1 << " ";
}
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.);
const long long mod = 1000000007;
inline void prep() {
cin.tie(0);
cin.sync_with_stdio(0);
};
int main() {
prep();
long long h, n;
cin >> h >> n;
long long nums[n];
long long changes[n];
long long lowest = 0;
for (int i = 0; i < n; i++) {
cin >> nums[i];
if (i > 0) {
changes[i] = nums[i] + changes[i - 1];
} else {
changes[i] = nums[i];
}
if (changes[i] < lowest) {
lowest = changes[i];
}
}
if (changes[n - 1] >= 0) {
for (int i = 0; i < n; i++) {
if (changes[i] + h <= 0) {
cout << i + 1;
return 0;
}
}
cout << -1;
return 0;
}
long long time = 0;
if (h + lowest > 0) {
if ((h + lowest) % abs(changes[n - 1]) != 0) {
long long many = abs((h + lowest) / changes[n - 1]) + 1;
time = n * many;
h += changes[n - 1] * many;
} else {
long long many = abs((h + lowest) / changes[n - 1]);
time = n * many;
h += changes[n - 1] * many;
}
}
for (int i = 0; i < n; i++) {
if (h + changes[i] <= 0) {
cout << time + i + 1;
return 0;
}
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T& x) {
stringstream ss;
ss << x;
return ss.str();
}
const double EPS = 1e-6;
const int INF = 1000 * 1000 * 1000;
const char CINF = 102;
const long long LINF = INF * 1ll * INF;
const double PI = 3.1415926535897932384626433832795;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
unsigned int gcd(unsigned int a, unsigned int b) {
return a ? gcd(b % a, a) : b;
}
int n;
pair<int, long long> ar[110000];
long long res;
void turn() {
for (int i = 0; i < (n); ++i) {
ar[i] = make_pair(ar[i].second, -ar[i].first);
}
}
void half() {
sort(ar, ar + n);
multiset<long long> st;
for (int i = 0; i < (n); ++i) {
st.insert(ar[i].second);
}
int j = 0;
for (int i = 0; i < (n); ++i) {
while (true) {
long long d1;
if (j <= i)
d1 = -1;
else
d1 = ar[j - 1].first - ar[i].first;
long long d2;
if (st.empty())
d2 = 0;
else
d2 = *st.rbegin() - *st.begin();
if (d2 > d1) {
if (j == n) return;
st.erase(st.lower_bound(ar[j].second));
++j;
} else {
res = min(res, d1);
break;
}
}
st.insert(ar[i].second);
}
}
int main() {
cin >> n;
for (int i = 0; i < (n); ++i) {
int x, y;
scanf("%d%d", &x, &y);
ar[i] = make_pair(x + y, x - y);
}
res = LINF;
half();
turn();
half();
printf("%.15lf", res / 2.);
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool check(int n, int pos) { return (bool)(n & (1 << pos)); }
int off(int n, int pos) { return n & ~(1 << pos); }
int x[32010], A[310], c[310], n;
int dp[310][310][600];
vector<int> p, factors[310];
void seive() {
int i, j;
for (i = 0; i < 32010; i++) x[i] = true;
for (i = 2; i < 32010; i++) {
if (x[i]) {
p.push_back(i);
for (j = i; j < 32010; j += i) x[j] = false;
}
}
}
void _primes(int i, int n) {
int j;
for (j = 0; j < p.size(); j++) {
if (n % p[j] == 0) {
factors[i].push_back(p[j]);
while (n % p[j] == 0) n /= p[j];
}
}
if (n > 1) factors[i].push_back(n);
}
int min_cost(int i, int base, int mask) {
int a = 1 << 30, b = 1 << 30, j, temp = mask;
if (mask == 0)
return 0;
else if (i == n + 1)
return 1 << 30;
if (dp[i][base][mask] != -1) return dp[i][base][mask];
a = min_cost(i + 1, base, mask);
if (base == 0)
b = c[i] + min_cost(i + 1, i, (1 << factors[i].size()) - 1);
else {
for (j = 0; j < factors[base].size(); j++)
if (A[i] % factors[base][j] != 0 && check(mask, j)) mask = off(mask, j);
b = c[i] + min_cost(i + 1, base, mask);
}
return dp[i][base][temp] = (((a) < (b)) ? (a) : (b));
}
int main() {
int i, j, k, temp;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &A[i]);
for (i = 1; i <= n; i++) scanf("%d", &c[i]);
seive();
for (i = 1; i <= n; i++) {
_primes(i, A[i]);
}
for (i = 0; i < 310; i++)
for (j = 0; j < 310; j++)
for (k = 0; k < 600; k++) dp[i][j][k] = -1;
k = min_cost(1, 0, 511);
k == 1 << 30 ? printf("%d\n", -1) : printf("%d\n", k);
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace ::std;
const int N = 3000 + 5;
vector<int> g[N];
int d[N][N];
int main() {
int n, m;
int i, j, k;
cin >> n >> m;
memset(d, -1, sizeof d);
for (i = 0; i < m; i++) {
cin >> j >> k;
g[j - 1].push_back(k - 1);
g[k - 1].push_back(j - 1);
}
for (i = 0; i < n; i++) {
queue<int> q;
q.push(i);
d[i][i] = 0;
while (!q.empty()) {
j = q.front();
q.pop();
for (k = 0; k < g[j].size(); k++) {
if (d[i][g[j][k]] == -1) {
d[i][g[j][k]] = d[i][j] + 1;
q.push(g[j][k]);
}
}
}
}
int s[2], t[2];
int l1, l2;
cin >> s[0] >> t[0] >> l1;
cin >> s[1] >> t[1] >> l2;
s[0]--;
t[0]--;
s[1]--;
t[1]--;
int ans = m + 1;
for (int it = 0; it < 2; it++) {
swap(s[0], t[0]);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
int v[] = {d[s[0]][i] + d[i][j] + d[j][t[0]],
d[s[1]][i] + d[i][j] + d[j][t[1]]};
if (v[0] <= l1 && v[1] <= l2) ans = min(ans, v[0] + v[1] - d[i][j]);
}
}
}
if (d[s[0]][t[0]] <= l1 && d[s[1]][t[1]] <= l2)
ans = min(ans, d[s[0]][t[0]] + d[s[1]][t[1]]);
if (ans > m)
cout << "-1";
else
cout << m - ans;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
long long a[MAXN];
map<long long, long long> vis;
int main() {
int n, x;
long long ans = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
vis[a[i]]++;
}
for (int i = 1; i <= n; i++) {
if (x == 0) {
ans += vis[a[i]] - 1;
} else
ans += vis[a[i] ^ x];
}
cout << ans / 2 << endl;
return 0;
}
| 1,500 | CPP |
n = input()
n = int(n)
limit = int(n/2)
final = 0
for i in range(limit):
numteamleaders = i+1
restemployees = n-numteamleaders
if restemployees%numteamleaders == 0:
final += 1
print(final) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int MAX = 500000;
double eps = 1e-9;
const long long BIG_INF = 7000000000000000000LL;
const int INF = 2000000000;
double PI = 3.1415926535897932384626433832795;
string inttostring(int n) {
stringstream a;
a << n;
string A;
a >> A;
return A;
}
int stringtoint(string A) {
stringstream a;
a << A;
int p;
a >> p;
return p;
}
int main() {
int n, m;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
int w, h, gx, gh;
long long x = -INF;
while (m--) {
cin >> w >> h;
x = max(x, a[w - 1]);
cout << x << "\n";
x += h;
}
}
| 1,500 | CPP |
def solve(ls):
l=[0,0]
pos = 'North'
for a,b in ls:
if (pos == 'North' and b!='South'):
return False
if (pos == 'South' and b!='North'):
return False
if b=='South':
if a>20000 or a<0:
return False
l[0]+=a
if l[0]>20000:
return False
pos=''
if l[0]==20000:
pos='South'
elif b=='North':
if a>20000 or a<0:
return False
l[0]-=a
if l[0]<0:
return False
pos=''
if l[0]==0:
pos='North'
if l[0]==0:
return True
return False
ls=[]
t=int(input())
while t:
a,b = input().split()
a = int(a)
ls.append([a,b])
t-=1
x = solve(ls)
print('YES' if x else 'NO') | 1,300 | PYTHON3 |
a = input().split()
limaWeight = int(a[0])
brotherWeight = int(a[1])
i = 0
while limaWeight<=brotherWeight:
limaWeight *= 3
brotherWeight *= 2
i += 1
print (i) | 800 | PYTHON3 |
# Author Name: Ajay Meena
# Codeforce : https://codeforces.com/profile/majay1638
# -------- IMPORTANT ---------#
# SUN BHOS**KE AGAR MERA TEMPLATE COPY KAR RHA HAI NA TOH KUCH CHANGES BHI KAR DENA ESS ME, VARNA MUJEHY WARNING AAYEGI BAAD ME, PLEASE YAAR KAR DENA, OK :).
import sys
import bisect
from bisect import bisect_right
import math
from sys import stdin, stdout
# //Most Frequently Used Number Theory Concepts
# VAISE MEIN JAYDA USE KARTA NHI HU ENHE BUT COOL BANNE KE LIYE LIKH LEYA TEMPLATE ME VARNA ME YE TOH DUSRI FILE MAI SE BHI COPY PASTE KAR SAKTA THA :).
def sieve(N):
primeNumbers = [True]*(N+1)
primeNumbers[0] = False
primeNumbers[1] = False
i = 2
while i*i <= N:
j = i
if primeNumbers[j]:
while j*i <= N:
primeNumbers[j*i] = False
j += 1
i += 1
return primeNumbers
def getPrime(N):
primes = sieve(N)
result = []
for i in range(len(primes)):
if primes[i]:
result.append(i)
return result
def factor(N):
factors = []
i = 1
while i*i <= N:
if N % i == 0:
factors.append(i)
if i != N//i:
factors.append(N//i)
i += 1
return sorted(factors)
def gcd(a, b):
if a < b:
return gcd(b, a)
if b == 0:
return a
return gcd(b, a % b)
def extendedGcd(a, b):
if a < b:
return extendedGcd(b, a)
if b == 0:
return [a, 1, 0]
res = extendedGcd(b, a % b)
x = res[2]
y = res[1]-(math.floor(a/b)*res[2])
res[1] = x
res[2] = y
return res
def iterativeModularFunc(a, b, c):
res = 1
while b > 0:
if b & 1:
res = (res*a) % c
a = (a*a) % c
b = b//2
return res
# TAKE INPUT
# HAAN YE BHUT KAAM AATA HAI INPUT LENE ME
def get_ints_in_variables():
return map(int, sys.stdin.readline().strip().split())
def get_int(): return int(input())
def get_ints_in_list(): return list(
map(int, sys.stdin.readline().strip().split()))
def get_list_of_list(n): return [list(
map(int, sys.stdin.readline().strip().split())) for _ in range(n)]
def get_string(): return sys.stdin.readline().strip()
def getFirst(arr, n, x):
for i in range(n):
if arr[i] > x:
return i
return -1
def swap(arr, idx, b):
tmp = arr[idx]
arr[idx] = b
b = tmp
def isSorted(arr, n):
for i in range(n-1):
if arr[i] > arr[i+1]:
return False
return True
def Solution(arr, n, x):
ans = 0
while not isSorted(arr, n):
idx = getFirst(arr, n, x)
if idx < 0:
break
tmp = arr[idx]
arr[idx] = x
x = tmp
ans += 1
print(ans) if isSorted(arr, n) else print(-1)
def main():
# //Write Your Code Here
for _ in range(get_int()):
n, x = get_ints_in_variables()
arr = get_ints_in_list()
Solution(arr, n, x)
# calling main Function
if __name__ == "__main__":
main()
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
scanf("%d", &test);
getchar();
while (test--) {
char s[100002], k[100002];
scanf("%s%s", s, k);
int tmp = 0;
for (int i = strlen(k) - 1; i >= 0; i--) {
if (k[i] == '1') {
tmp = strlen(k) - i - 1;
break;
}
}
for (int i = strlen(s) - 1 - tmp; i >= 0; i--) {
if (s[i] == '1') {
printf("%d\n", int(strlen(s)) - tmp - 1 - i);
break;
}
}
}
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
long long POW(long long x, long long n) {
long long ret = x, ans = 1;
while (n) {
if (n & 1) {
ans *= ret;
ans %= MOD;
}
n /= 2;
ret *= ret;
ret %= MOD;
}
return ans;
}
int main() {
int n, m;
long long ans = 1;
cin >> n >> m;
for (int i = m; i >= m - n + 2; --i) {
ans *= i;
ans %= MOD;
}
long long t = 1;
for (int i = 1; i <= n - 1; ++i) {
t *= i;
t %= MOD;
}
ans *= POW(t, MOD - 2);
ans %= MOD;
ans *= n - 2;
ans %= MOD;
ans *= POW(2, n - 3);
ans %= MOD;
cout << ans << '\n';
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[3000003], b[3000003], x;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
for (int j = i + 1; j < n; j++) {
if (b[j] == a[i]) {
x = j;
break;
}
}
while (x > i) {
cout << x << " " << x + 1 << "\n";
swap(b[x], b[x - 1]);
x--;
}
}
}
}
| 1,100 | CPP |
can = {1: [0, 1, 3, 4, 7, 8, 9], 2: [2, 8], 3: [3, 8, 9], 4: [4, 8, 9], 5: [5, 6, 8, 9], 6: [6, 8], 7: [0, 3, 7, 8, 9], 8: [8], 9 : [8, 9], 0: [0, 8]}
n = int(input())
a, b = n // 10, n % 10
print(len(can[a]) * len(can[b])) | 1,100 | PYTHON3 |
n = input()
count = 1
ans = 0
j = 1
while j < len(n):
if n[j] == n[j-1]:
while j<len(n) and n[j] == n[j-1]:
count += 1
j += 1
if count%2 == 0:
ans += 1
count = 1
else:
j += 1
print(ans) | 0 | PYTHON3 |
import math
def stabilize(arr):
arr.sort()
if len(arr) < 3:
return 0
if (arr[1] - arr[0]) > (arr[-1] - arr[-2]):
return arr[-1] - arr[1]
else:
return arr[-2] - arr[0]
if __name__ == '__main__':
input()
arr = list(map(int, input().strip().split()))
print(stabilize(arr))
| 900 | PYTHON3 |
n,m,a=map(int,input().strip().split(' '))
if n%a!=0:
e=(n//a)+1
else:
e=n//a
if m%a!=0:
d=m//a+1
else:
d=m//a
print(d*e)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
char s[1024];
scanf("%s", s);
int n = 0, a = 0;
char* t = s + 0;
n = (int)t[0] - '0';
++t;
while (*t != 0 && *t != '+' && *t != '-') n = n * 10 + *t++ - '0';
for (int i = 0; s[i]; ++i) {
if (s[i] == '+') {
t = s + i;
a = (int)*t - '0';
++t;
while (*t != 0 && *t != '+' && *t != '-') a = a * 10 + *t++ - '0';
n += a;
} else if (s[i] == '-') {
t = s + i;
a = (int)*t - '0';
++t;
while (*t != 0 && *t != '+' && *t != '-') a = a * 10 + *t++ - '0';
n -= a;
}
}
printf("%d\n", n);
return 0;
}
| 2,400 | CPP |
q=int(input())
for i in range(q):
n=int(input())
ans=0
while n>9:
ans+=10*(n//10)
k=n//10
n%=10
n+=k
ans+=n
print(ans) | 900 | PYTHON3 |
// in the name of God
// 8dPRvhQ3Hr
#include <bits/stdc++.h>
#define pb push_back
#define F first
#define S second
#define debug(a) cout << (&a) << " : " << a << '\n'
#define fast ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0)
typedef long long ll;
typedef long double ld;
using namespace std;
const int MAX_N = 3e5 + 10, MOD = 998244353;
int dp[MAX_N], two[MAX_N];
int main() {
fast;
two[0] = 1;
for (int i = 1; i < MAX_N; i++)
two[i] = (2 * two[i - 1]) % MOD;
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i < MAX_N; i++)
dp[i] = ((((ll)two[i - 2] * (ll)(i - 1)) % MOD) - (ll)dp[i - 1] + (ll)MOD) % MOD;
int n, m;
cin >> n >> m;
string s[n + 10];
ll ans = 0, open = 0;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == 'o')
open++;
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < m; j++) {
if (s[i][j] == 'o') cnt++;
else {
ans = (ans + (((ll)dp[cnt] * (ll)two[open - cnt]) % MOD)) % MOD;
cnt = 0;
}
}
ans = (ans + (((ll)dp[cnt] * (ll)two[open - cnt]) % MOD)) % MOD;
}
for (int i = 0; i < m; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == 'o') cnt++;
else {
ans = (ans + (((ll)dp[cnt] * (ll)two[open - cnt]) % MOD)) % MOD;
cnt = 0;
}
}
ans = (ans + (((ll)dp[cnt] * (ll)two[open - cnt]) % MOD)) % MOD;
}
cout << ans;
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
multiset<int> gd[300005];
int vis[300005];
bool dfs(int x, int y, int vi) {
if (x == y) {
return true;
}
vis[x] = vi;
for (int xx : gd[x]) {
if (vis[xx] != vi) {
if (dfs(xx, y, vi)) return true;
}
}
return false;
}
class DSU {
public:
int p[300005];
int r[300005];
DSU(int n) { init(n); }
void init(int n) {
for (int i = 0; i <= n + 4; i++) {
p[i] = i;
r[i] = 0;
}
}
int par(int x) { return (p[x] == x) ? p[x] : (p[x] = par(p[x])); }
bool sameComponenet(int a, int b) { return par(a) != par(b); }
int unite(int a, int b) {
a = par(a);
b = par(b);
if (a == b) return 0;
if (r[a] > r[b])
p[b] = a;
else
p[a] = b;
if (r[a] == r[b]) r[b]++;
return 1;
}
};
class FForcedOnlineQueriesProblem {
public:
void solve(std::istream& cin, std::ostream& cout) {
int n, k;
cin >> n >> k;
DSU d(n);
int op[k];
memset(vis, 0, 300005 * sizeof(int));
pair<int, int> edg[k];
int erasureTime[k];
map<pair<int, int>, int> mpe;
for (int i = 0; i < k; i++) erasureTime[i] = INT_MAX;
for (int i = 0; i < k; i++) {
int c;
cin >> c;
switch (c) {
case 1:
op[i] = 1;
cin >> edg[i].first >> edg[i].second;
break;
case 2:
op[i] = 2;
cin >> edg[i].first >> edg[i].second;
break;
}
}
int last = -1, ct = 1;
int ans = 0;
const int blockSize = 900;
while (last < k - 1) {
if (last != -1) d.init(n);
int cc = n;
while (last < k - 1 && op[last + 1] != 2) {
last++;
int x = (edg[last].first + ans - 1) % n + 1;
int y = (edg[last].second + ans - 1) % n + 1;
if (x > y) swap(x, y);
auto it = mpe.find({x, y});
if (it != mpe.end()) {
erasureTime[it->second] = last;
erasureTime[last] = -1;
mpe.erase(it);
} else {
mpe[{x, y}] = last;
}
}
vector<pair<int, int>> ttp;
set<pair<int, int>> eds;
for (auto it : mpe) {
eds.insert(it.first);
}
for (int i = last + 1; i <= min(last + blockSize, k - 1); i++) {
if (op[i] == 1) {
int x = edg[i].first;
int y = edg[i].second;
if (x > y) swap(x, y);
auto it = eds.find({x, y});
if (it != eds.end()) {
ttp.push_back({x, y});
eds.erase(it);
}
int nx = x % n + 1, ny = y % n + 1;
if (nx > ny) swap(nx, ny);
it = eds.find({nx, ny});
if (it != eds.end()) {
ttp.push_back({nx, ny});
eds.erase(it);
}
}
}
for (pair<int, int> p : eds) d.unite(p.first, p.second);
for (pair<int, int> x : ttp) {
int a = d.par(x.first);
int b = d.par(x.second);
gd[a].insert(b);
gd[b].insert(a);
}
for (int i = last + 1; i <= min(last + blockSize, k - 1); i++) {
if (op[i] == 2) {
int realx = d.par((edg[i].first + ans - 1) % n + 1);
int realy = d.par((edg[i].second + ans - 1) % n + 1);
if (dfs(realx, realy, ct)) {
ans = 1;
} else
ans = 0;
ct++;
cout << ans;
} else if (op[i] == 1) {
int a = (edg[i].first + ans - 1) % n + 1;
int b = (edg[i].second + ans - 1) % n + 1;
if (a > b) swap(a, b);
edg[i] = {a, b};
auto it = mpe.find(edg[i]);
if (it == mpe.end()) {
mpe[edg[i]] = i;
a = d.par(a);
b = d.par(b);
gd[a].insert(b);
gd[b].insert(a);
} else {
erasureTime[it->second] = i;
erasureTime[i] = -1;
mpe.erase(it);
a = d.par(a);
b = d.par(b);
gd[a].erase(gd[a].find(b));
gd[b].erase(gd[b].find(a));
}
}
}
for (int i = 1; i <= n; i++) gd[i].clear();
last = min(last + blockSize, k - 1);
}
cout << endl;
}
};
int main() {
FForcedOnlineQueriesProblem solver;
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 998244353;
int fact[N];
int inv[N];
int mul(int a, int b) { return ((long long)(a % mod) * (b % mod)) % mod; }
int add(int a, int b) { return ((a % mod) + (b % mod)) % mod; }
int fastpow(int base, int power) {
if (!power) return 1;
int ret = fastpow(base, power / 2);
ret = mul(ret, ret);
if (power & 1) ret = mul(ret, base);
return ret;
}
int npr(int n, int r) { return mul(fact[n], inv[n - r]); }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
fact[0] = fact[1] = inv[0] = inv[1] = 1;
for (int i = 1; i < N; i++) fact[i] = mul(fact[i - 1], i);
inv[N - 1] = fastpow(fact[N - 1], mod - 2);
for (int i = N - 2; i > 1; i--) inv[i] = mul((i + 1), inv[i + 1]);
int n;
cin >> n;
int ans = n;
int mult = n - 2;
int r = 1;
for (int i = 2; i <= n - 1; i++) {
ans = add(ans, mul(i, mul(mult, npr(n, r))));
r++;
mult--;
}
cout << ans;
return 0;
}
| 1,700 | CPP |
n=int(input())
for i in range(n):
f=int(input())
s=list(map(int,input().split()))
fl=0
t=f
for j in range(f):
if s[j]<j:
t=j
break
for j in range(t,f):
if s[j]<f-j-1:
fl=1
break
if fl==0:
if s[f//2]==f//2-1 and s[f//2-1]==f//2-1 and f%2==0:
print("No")
else:
print("Yes")
else:
print("No") | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int arr[100001];
int n, tmp1, tmp2;
scanf("%d", &n);
for (int i = 0; i < 100001; ++i) {
arr[i] = -1;
}
for (int i = 0; i < n; ++i) {
scanf("%d%d", &tmp2, &tmp1);
if (++arr[tmp1] < tmp2) {
printf("NO");
return 0;
}
if (tmp2 < arr[tmp1]) --arr[tmp1];
}
printf("YES");
return 0;
}
| 1,400 | CPP |
n=int(input())
chars=input().split(' ')
money=[]
for i in chars:
money.append(int(i))
for i in range(len(money)):
element=money[i]
j=i
while(j>0 and money[j-1]<element):
money[j]=money[j-1]
j-=1
money[j]=element
s=0
mine=0
k=0
for i in money:
s+=i
while(mine<=s):
mine+=money[k]
s-=money[k]
k+=1
print(k)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, char> m;
m['A'] = 'A', m['H'] = 'H', m['I'] = 'I', m['M'] = 'M', m['O'] = 'O',
m['T'] = 'T', m['U'] = 'U', m['V'] = 'V', m['W'] = 'W', m['X'] = 'X';
m['b'] = 'd';
m['d'] = 'b';
m['o'] = 'o';
m['p'] = 'q';
m['q'] = 'p';
m['v'] = 'v';
m['w'] = 'w';
m['x'] = 'x';
m['Y'] = 'Y';
string s;
cin >> s;
int len;
if (s.size() % 2 == 0)
len = (int)s.size() / 2;
else
len = ((int)s.size() / 2) + 1;
for (int i = 0; i < len; i++) {
if (s[i] != m[s[s.size() - 1 - i]]) {
cout << "NIE\n";
return 0;
}
}
cout << "TAK\n";
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
long long a[maxn];
long long dp[2][maxn][maxn][maxn];
long long ans[maxn][maxn];
int main() {
ios_base::sync_with_stdio(0);
int n;
string s;
cin >> n >> s;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
a[i] = max(a[i], a[i - j] + a[j]);
}
}
for (int i = 1; i <= n; i++) {
for (int k = 1; k <= n; k++) {
dp[0][i][i][k] = -1e18;
dp[1][i][i][k] = -1e18;
dp[0][i + 1][i][k] = -1e18;
dp[1][i + 1][i][k] = -1e18;
}
if (s[i - 1] == '0') {
dp[0][i][i][1] = 0;
} else {
dp[1][i][i][1] = 0;
}
dp[0][i][i][0] = a[1];
dp[1][i][i][0] = a[1];
ans[i][i] = a[1];
}
for (int d = 1; d < n; d++) {
for (int le = 1; le <= n; le++) {
int ri = le + d;
if (ri > n) continue;
for (int k = 1; k <= n; k++) {
for (int dig = 0; dig < 2; dig++) {
dp[dig][le][ri][k] = -1e18;
for (int i = le; i <= ri; i++) {
if (s[i - 1] - '0' == dig) {
dp[dig][le][ri][k] =
max(dp[dig][le][ri][k],
ans[le][i - 1] + dp[dig][i + 1][ri][k - 1]);
}
}
}
}
ans[le][ri] = -1e18;
for (int k = 1; k <= n; k++) {
ans[le][ri] =
max(ans[le][ri], max(dp[0][le][ri][k], dp[1][le][ri][k]) + a[k]);
}
dp[0][le][ri][0] = ans[le][ri];
dp[1][le][ri][0] = ans[le][ri];
}
}
cout << ans[1][n] << "\n";
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
int main() {
int n, m, d[101] = {}, a, b, cnt, sol = -1;
bool c[101][101] = {};
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
++d[a];
++d[b];
c[a][b] = 1;
c[b][a] = 1;
}
do {
int del[101] = {};
cnt = 0;
for (int i = 1; i <= n; ++i)
if (d[i] == 1) {
del[cnt++] = i;
--d[i];
}
for (int i = 0; i < cnt; ++i)
for (int j = 1; j <= n; ++j)
if (c[del[i]][j]) --d[j];
++sol;
} while (cnt > 0);
printf("%d", sol);
return 0;
}
| 1,200 | CPP |
import math
t=int(input())
while(t>0):
t-=1
ab=input().split()
a=int(ab[0])
b=int(ab[1])
c=0
x=1
i=1
while(i<=b):
if (i==math.pow(10,x)-1):
c+=1
i=i+9*math.pow(10,x)
x+=1
else:
i+=1
print(c*a) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
if (s.size() >= 5) {
for (int i = 0; i < s.size(); i++) {
if (s[i] <= 'z' && s[i] >= 'a') {
for (int j = 0; j < s.size(); j++) {
if (s[j] <= 'Z' && s[j] >= 'A') {
for (int k = 0; k < s.size(); k++)
if (s[k] <= '9' && s[k] >= '0') {
cout << "Correct" << endl;
return 0;
}
}
}
}
}
}
cout << "Too weak" << endl;
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2005;
long long n, k, a[N][N];
long long R[N], C[N], sum[N][N];
long long ans[N][N], Col[N], pre[N], cc[N][N];
long long get(long long x, long long y, long long u, long long v) {
return sum[u][v] - sum[x - 1][v] - sum[u][y - 1] + sum[x - 1][y - 1];
}
void prepare() {
for (long long i = (long long)1; i <= (long long)n; i++)
for (long long j = (long long)1; j <= (long long)n; j++)
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
for (long long i = (long long)1; i <= (long long)n; i++) {
R[i] = R[i - 1] + (get(i, 1, i, n) == 0);
C[i] = C[i - 1] + (get(1, i, n, i) == 0);
}
}
void solve() {
memset(sum, 0, sizeof sum);
for (long long i = (long long)1; i <= (long long)n; i++)
for (long long j = (long long)1; j <= (long long)n; j++)
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
for (long long x = (long long)1; x <= (long long)n - k + 1; x++) {
long long u = x + k - 1;
for (long long y = (long long)1; y <= (long long)k; y++) {
Col[y] = (get(1, y, x - 1, y) == 0 && get(u + 1, y, n, y) == 0);
pre[y] = pre[y - 1] + Col[y];
}
ans[x][1] = pre[k];
for (long long y = (long long)2; y <= (long long)n - k + 1; y++) {
long long v = y + k - 1;
Col[v] = (get(1, v, x - 1, v) == 0 && get(u + 1, v, n, v) == 0);
pre[v] = pre[v - 1] + Col[v];
ans[x][y] = (pre[v] - pre[y - 1]);
}
for (long long i = (long long)1; i <= (long long)n; i++)
Col[i] = pre[i] = 0;
}
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("main.in", "r")) freopen("main.in", "r", stdin);
cin >> n >> k;
cerr << n << ' ' << k << '\n';
for (long long i = (long long)1; i <= (long long)n; i++) {
string s;
cin >> s;
for (long long j = (long long)1; j <= (long long)n; j++)
a[i][j] = (s[j - 1] == 'W' ? 0 : 1);
}
prepare();
solve();
for (long long i = (long long)1; i <= (long long)n; i++)
for (long long j = (long long)1; j <= (long long)n; j++)
cc[i][j] = ans[i][j], ans[i][j] = 0;
for (long long i = (long long)1; i <= (long long)n; i++)
for (long long j = (long long)i; j <= (long long)n; j++)
swap(a[i][j], a[j][i]);
solve();
long long res = 0;
for (long long x = (long long)1; x <= (long long)n - k + 1; x++)
for (long long y = (long long)1; y <= (long long)n - k + 1; y++) {
long long u = x + k - 1, v = y + k - 1;
long long val = ans[y][x] + cc[x][y] + (R[x - 1] + (R[n] - R[u])) +
(C[y - 1] + (C[n] - C[v]));
if (x == 2 && y == 3) cerr << val << '\n';
res = max(res, val);
}
cout << res << '\n';
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
struct Point {
int x, y, id;
} p[MAXN];
bool cmp(Point a, Point b) {
if (a.x != b.x)
return a.x < b.x;
else
return a.y < b.y;
}
struct BIT {
int min_val, pos;
void init() {
min_val = INF;
pos = -1;
}
} bit[MAXN << 2];
struct Edge {
int u, v, d;
} edge[MAXN << 2];
bool cmpedge(Edge a, Edge b) { return a.d < b.d; }
int tot, F[MAXN];
int Find(int x) {
if (F[x] == -1)
return x;
else
return F[x] = Find(F[x]);
}
void addedge(int u, int v, int d) {
edge[tot].u = u;
edge[tot].v = v;
edge[tot++].d = d;
}
int lowbit(int x) { return x & (-x); }
void update(int i, int val, int pos) {
while (i > 0) {
if (val < bit[i].min_val) {
bit[i].min_val = val;
bit[i].pos = pos;
}
i -= lowbit(i);
}
}
int ask(int i, int m) {
int min_val = INF, pos = -1;
while (i <= m) {
if (bit[i].min_val < min_val) {
min_val = bit[i].min_val;
pos = bit[i].pos;
}
i += lowbit(i);
}
return pos;
}
int dis(Point a, Point b) { return abs(a.x - b.x) + abs(a.y - b.y); }
int a[MAXN];
void MST(int n, Point p[]) {
tot = 0;
for (int dir = 0; dir < 4; dir++) {
if (dir == 1 || dir == 3) {
for (int i = 0; i < n; i++) swap(p[i].x, p[i].y);
} else if (dir == 2) {
for (int i = 0; i < n; i++) p[i].x = -p[i].x;
}
sort(p, p + n, cmp);
for (int i = 0; i < n; i++) a[i] = p[i].y - p[i].x + 2000001;
for (int i = 1; i <= 4000001; i++) bit[i].init();
for (int i = n - 1; i >= 0; i--) {
int ans = ask(a[i], 4000001);
if (ans != -1) addedge(p[i].id, p[ans].id, dis(p[i], p[ans]));
update(a[i], p[i].x + p[i].y, i);
}
}
}
struct EdgeList {
int to, next;
} Edge[MAXN << 1];
int tol, head[MAXN];
void AddEdge(int u, int v) {
Edge[tol].to = v;
Edge[tol].next = head[u];
head[u] = tol++;
}
int Scan() {
char ch;
while ((ch = getchar()) < '0' || ch > '9')
;
int res = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') res = res * 10 + ch - '0';
return res;
}
char s[15];
void Print(int x) {
int now = 0;
while (x) {
s[now++] = x % 10 + '0';
x /= 10;
}
for (int i = now - 1; i >= 0; i--) putchar(s[i]);
putchar(' ');
}
void dfs(int u, int fa) {
for (int i = head[u]; i != -1; i = Edge[i].next) {
if (Edge[i].to == fa) continue;
dfs(Edge[i].to, u);
}
Print(u + 1);
}
int main() {
int n;
n = Scan();
for (int i = 0; i < n; i++) {
p[i].x = Scan();
p[i].y = Scan();
p[i].id = i;
}
MST(n, p);
sort(edge, edge + tot, cmpedge);
memset(F, -1, sizeof(F));
int dif = n;
memset(head, -1, sizeof(head));
for (int i = 0; i < tot; i++) {
int u = edge[i].u;
int v = edge[i].v;
int t1 = Find(u);
int t2 = Find(v);
if (t1 != t2) {
F[t1] = t2;
AddEdge(u, v);
AddEdge(v, u);
dif--;
if (dif == 1) break;
}
}
dfs(0, -1);
return 0;
}
| 2,100 | CPP |
def check(s):
x = list(map(ord,sorted(s)))
p = len(x)
for i in range(p-1) :
if not (x[i+1]-x[i])==1:
return 'NO'
return 'YES'
n = int(input())
for i in range(n):
l = input()
print(check(l)) | 800 | PYTHON3 |
t=int(input())
for x in range(0,t):
a1=input()
l=a1.split(" ")
a=int(l[0])
b=int(l[1])
c=int((a+b)/3)
d=min(a,b,c)
print(d) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 150000;
const int maxk = 20;
vector<int> e[maxn];
int tim = 0;
int tin[maxn], par[maxn], d[maxn];
int jump[maxk][maxn];
int N, K;
void dfs(int v, int p) {
tin[v] = tim++;
par[v] = p;
d[v] = p == -1 ? 0 : d[p] + 1;
for (int i = 0; i < (int)(e[v].size()); ++i) {
int u = e[v][i];
if (u == p) {
continue;
}
dfs(u, v);
}
}
void build_jump() {
for (int i = 0; i < (int)(N); ++i) {
jump[0][i] = par[i];
}
for (int k = 1; k < maxk; ++k) {
for (int i = 0; i < (int)(N); ++i) {
jump[k][i] = jump[k - 1][i] == -1 ? -1 : jump[k - 1][jump[k - 1][i]];
}
}
}
int make_jump(int v, int dd) {
for (int i = maxk - 1; i >= 0; --i) {
if ((1 << i) <= dd) {
v = jump[i][v];
dd -= (1 << i);
}
}
return v;
}
int lca(int u, int v) {
if (d[u] < d[v]) {
swap(u, v);
}
u = make_jump(u, d[u] - d[v]);
if (u == v) {
return u;
}
for (int k = maxk - 1; k >= 0; --k) {
if (jump[k][u] != jump[k][v]) {
u = jump[k][u];
v = jump[k][v];
}
}
return par[u];
}
int path(int u, int v) { return d[u] + d[v] - 2 * d[lca(u, v)]; }
set<pair<int, int> >::iterator next(const set<pair<int, int> >& inst,
set<pair<int, int> >::iterator it) {
++it;
return it == inst.end() ? inst.begin() : it;
}
set<pair<int, int> >::iterator prev(const set<pair<int, int> >& inst,
set<pair<int, int> >::iterator it) {
if (it == inst.begin()) {
it = inst.end();
}
--it;
return it;
}
int main() {
scanf("%d%d", &N, &K);
for (int i = 0; i < (int)(N - 1); ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
e[u].push_back(v);
e[v].push_back(u);
}
dfs(0, -1);
build_jump();
int l = 1, r = N + 1;
while (r - l > 1) {
int m = (l + r) / 2;
cerr << m << '\n';
set<pair<int, int> > vert;
bool ok = false;
for (int i = 0; i < (int)(m); ++i) {
vert.insert(make_pair(tin[i], i));
}
int sd = 0;
for (auto it = vert.begin(); it != vert.end(); ++it) {
sd += path(it->second, next(vert, it)->second);
}
if (sd <= 2 * (K - 1)) {
ok = true;
}
for (int i = m; i < N; ++i) {
vert.insert(make_pair(tin[i], i));
auto it = vert.find(make_pair(tin[i], i));
auto pit = prev(vert, it), nit = next(vert, it);
sd += path(it->second, pit->second) + path(it->second, nit->second) -
path(pit->second, nit->second);
it = vert.find(make_pair(tin[i - m], i - m));
pit = prev(vert, it), nit = next(vert, it);
sd -= path(it->second, pit->second) + path(it->second, nit->second) -
path(pit->second, nit->second);
vert.erase(it);
if (sd <= 2 * (K - 1)) {
ok = true;
}
}
if (ok) {
l = m;
} else {
r = m;
}
}
cout << l << '\n';
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int(i) = 0; (i) < (t.size()); ++(i)) s << t[i] << " ";
return s;
}
double px[105], py[105], pz[105], dx, dy, dz;
const double eps = 1e-7;
int n;
inline double sqr(double x) { return x * x; }
double dist() {
double ans = 0;
for (int(i) = 0; (i) < (n); ++(i))
(ans) = max((ans), (sqr(px[i] - dx) + sqr(py[i] - dy) + sqr(pz[i] - dz)));
return -ans;
}
void tz(double from, double to) {
if (abs(from - to) < eps) {
dz = from;
return;
}
double mid1 = (2 * from + to) / 3, mid2 = (from + 2 * to) / 3;
dz = mid1;
double wyn1 = dist();
dz = mid2;
double wyn2 = dist();
if (wyn1 < wyn2)
tz(mid1, to);
else
tz(from, mid2);
}
void ty(double from, double to) {
if (abs(from - to) < eps) {
dy = from;
return;
}
double mid1 = (2 * from + to) / 3, mid2 = (from + 2 * to) / 3;
dy = mid1;
tz(-10000, 10000);
double wyn1 = dist();
dy = mid2;
tz(-10000, 10000);
double wyn2 = dist();
if (wyn1 < wyn2)
ty(mid1, to);
else
ty(from, mid2);
}
void tx(double from, double to) {
if (abs(from - to) < eps) {
dx = from;
return;
}
double mid1 = (2 * from + to) / 3, mid2 = (from + 2 * to) / 3;
dx = mid1;
ty(-10000, 10000);
double wyn1 = dist();
dx = mid2;
ty(-10000, 10000);
double wyn2 = dist();
if (wyn1 < wyn2)
tx(mid1, to);
else
tx(from, mid2);
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (n); ++(i)) {
int(a), (b), (c);
scanf("%d %d %d", &(a), &(b), &(c));
px[i] = a;
py[i] = b;
pz[i] = c;
}
tx(-10000, 10000);
printf("%.9lf %.9lf %.9lf\n", dx, dy, dz);
}
| 2,100 | CPP |
import math
M,N = [int(x) for x in input().split()]
output= math.floor(M*N/2)
print(output)
| 800 | PYTHON3 |
n,m=map(int,input().split())
a=[int(i) for i in input().split()]
ch=0
m=m-1
for i in a:
if i>=a[m] and i>0:
ch+=1
print(ch) | 800 | PYTHON3 |
import collections
T = int(input())
test = 0
while test<T:
N = int(input())
arr = input()
arr = [int(num) for num in arr.split(' ')]
if len(arr)==1:
print(1)
test += 1
continue
res = 0
counter = collections.Counter(arr)
k = list(counter.values())
k.sort(reverse=True)
#print(k)
m = max(k)
L = len(k)
idx = 0
while m>0 and idx<L:
m = min(m,k[idx])
res += m
m -= 1
idx += 1
print(res)
test += 1 | 1,400 | PYTHON3 |
n=int(input())
r=0
for i in range(n):
a,b=list(map(int,input().split()))
if a%b==0:
print(0)
else:
r=a%b
print(b-r)
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename C>
void MA(C& a, C b) {
if (a < b) a = b;
}
template <typename C>
void MI(C& a, C b) {
if (a > b) a = b;
}
int n, m;
bitset<151> pom;
struct mac {
bitset<151> t[151];
void dod(int a, int b) { t[a][b] = 1; }
void mnu(mac& a, mac& b) {
for (int i = 0; i < n; i++) {
t[i] = pom;
for (int j = 0; j < n; j++) {
if (a.t[i][j]) t[i] |= b.t[j];
}
}
}
} ak, dm, lo[35], kan;
int t = 0;
int odp(int i) {
while (i) {
i--;
kan.mnu(dm, lo[i]);
if (kan.t[0][n - 1] == 0) {
dm = kan;
t += 1 << i;
}
}
printf("%d\n", t + 1);
exit(0);
}
vector<pair<int, pair<int, int> > > w;
void pot(int wyk) {
lo[0] = ak;
int i = 0;
while (wyk) {
if (wyk & 1) {
kan.mnu(dm, lo[i]);
if (kan.t[0][n - 1]) {
odp(i);
}
dm = kan;
t += 1 << i;
}
wyk /= 2;
lo[i + 1].mnu(lo[i], lo[i]);
i++;
}
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
ak.dod(n - 1, n - 1);
for (int i = 0; i < n; i++) {
dm.dod(i, i);
}
for (int i = 0; i < m; i++) {
int a, b, d;
scanf("%d%d", &a, &b);
a--;
b--;
scanf("%d", &d);
w.push_back({d, make_pair(a, b)});
}
sort((w).begin(), (w).end());
int i = 0;
w.push_back({(int)1e9 + 200, {0, 0}});
while (i < m) {
while (i < m && w[i].first == t) {
ak.dod(w[i].second.first, w[i].second.second);
i++;
}
pot(w[i].first - t);
}
puts("Impossible");
}
| 2,700 | CPP |
N, S = map(int,input().split())
if 2 * N <= S:
print('YES')
out = [2] * N
out[-1] += (S - 2 * N)
print(*out, sep = ' ')
print(1)
else:
print('NO')
| 1,400 | PYTHON3 |
n=int(input())
for i in range(9,0,-1):
if n%i==0:
a=[i]*(n//i)
break
print(len(a))
print(*a)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a, b, sz;
int P[400005][20], cost[400005][20];
int v[400005], p[400005], l[400005], st[400005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &p[i], &l[i]);
for (int i = n; i > 0; i--) {
v[i] = p[i] + l[i];
while (sz != 0 && v[i] >= p[st[sz - 1]])
v[i] = max(v[i], v[st[sz - 1]]), sz--;
st[sz++] = i;
}
for (int i = 1; i <= n; i++) {
P[i][0] = lower_bound(p + 1, p + 1 + n, v[i]) - p;
cost[i][0] = p[P[i][0]] - v[i];
}
for (int i = 1; i <= 18; i++) {
for (int h = 1; h <= n; h++) {
if (P[h][i - 1]) {
P[h][i] = P[P[h][i - 1]][i - 1];
cost[h][i] = cost[h][i - 1] + cost[P[h][i - 1]][i - 1];
}
}
}
scanf("%d", &m);
while (m--) {
scanf("%d%d", &a, &b);
int ans = 0;
for (int i = 18; i >= 0; i--)
if (P[a][i] && P[a][i] <= b) ans += cost[a][i], a = P[a][i];
printf("%d\n", ans);
}
}
| 2,300 | CPP |
import math
n,k=map(int,input().split())
if k<=n//2:
print(2*k-1)
else:
i=k-math.ceil(n/2)
if i!=0:
print(2*i)
else:
print(n)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int tab[100100];
unsigned long long int mod = 1000000007;
unsigned long long int fastPow(unsigned long long int a,
unsigned long long int b) {
unsigned long long int ans = 1;
while (b) {
if (b & 1) ans = (1ll * a * ans) % mod;
a = (1ll * a * a) % mod;
b /= 2;
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
bool pair = false;
bool notOne = false;
for (int i = 0; i < n; i++) {
unsigned long long int a;
scanf("%lld", &a);
if (a != 1) notOne = true;
if (a % 2 == 0) pair = true;
tab[i] = a;
}
unsigned long long int q = 2;
for (int i = 0; i < n; i++) {
q = (fastPow(q, tab[i])) % mod;
}
q = (q * fastPow(2, mod - 2)) % mod;
unsigned long long int p;
if (pair)
p = ((q + 1) * fastPow(3, mod - 2)) % mod;
else
p = ((q - 1) * fastPow(3, mod - 2)) % mod;
cout << p << "/" << q << endl;
return 0;
}
| 2,000 | CPP |
*s,a=[int(input())for i in' '*5];print(a-sum(all(i%x for x in s)for i in range(1,a+1)))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long ara[25];
long long fact[25];
long long BM(long long a, long long b, long long m) {
if (b == 0) return 1;
long long ret = BM(a, b / 2, m);
ret *= ret;
ret %= m;
if (b % 2) ret *= a;
return ret % m;
}
long long call(long long n, long long k) {
if (n < k) return 0;
long long ret = 1;
ret *= BM(fact[k], 1000000007 - 2, 1000000007);
ret %= 1000000007;
for (long long i = 1; i <= k; i++) {
ret *= (n % 1000000007);
ret %= 1000000007;
n--;
}
return ret;
}
int main() {
long long n, k, i, mask, l, u, ans, x, cnt, j;
fact[0] = 1;
for (i = 1; i <= 24; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
scanf("%lld %lld", &k, &n);
for (i = 0; i < k; i++) {
scanf("%lld", &ara[i]);
ara[i]++;
}
if (n >= 0) {
mask = (1 << k) - 1;
ans = call(n + k - 1, k - 1);
for (i = 1; i <= mask; i++) {
x = n;
cnt = 0;
for (j = 0; j < k; j++) {
if ((i & (1 << j)) != 0) {
x -= ara[j];
cnt++;
}
}
if (x >= 0) {
if (cnt % 2) {
ans -= call(x + k - 1, k - 1);
ans %= 1000000007;
} else {
ans += call(x + k - 1, k - 1);
ans %= 1000000007;
}
}
}
} else {
ans = 0;
}
ans += 1000000007;
ans %= 1000000007;
printf("%lld\n", ans);
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int a[N], n, m;
struct Seg {
int l, r, mx;
long long sum;
} tree[N * 4];
void BTree(int l, int r, int idx) {
tree[idx].l = l;
tree[idx].r = r;
tree[idx].mx = a[l];
tree[idx].sum = a[l];
if (l == r) return;
int mid = (l + r) >> 1;
BTree(l, mid, idx << 1);
BTree(mid + 1, r, idx << 1 | 1);
tree[idx].mx = max(tree[idx << 1].mx, tree[idx << 1 | 1].mx);
tree[idx].sum = tree[idx << 1].sum + tree[idx << 1 | 1].sum;
}
void Insert(int l, int r, int x, int idx) {
if (tree[idx].l == l && tree[idx].r == r) {
if (tree[idx].mx < x) return;
if (tree[idx].l != tree[idx].r) {
int mid = (tree[idx].l + tree[idx].r) >> 1;
Insert(l, mid, x, idx << 1);
Insert(mid + 1, r, x, idx << 1 | 1);
tree[idx].mx = max(tree[idx << 1].mx, tree[idx << 1 | 1].mx);
tree[idx].sum = tree[idx << 1].sum + tree[idx << 1 | 1].sum;
} else {
tree[idx].sum %= x;
tree[idx].mx %= x;
}
return;
}
int mid = (tree[idx].l + tree[idx].r) >> 1;
if (r <= mid)
Insert(l, r, x, idx << 1);
else if (l > mid)
Insert(l, r, x, idx << 1 | 1);
else
Insert(l, mid, x, idx << 1), Insert(mid + 1, r, x, idx << 1 | 1);
tree[idx].mx = max(tree[idx << 1].mx, tree[idx << 1 | 1].mx);
tree[idx].sum = tree[idx << 1].sum + tree[idx << 1 | 1].sum;
}
void Insert(int id, int x, int idx) {
if (tree[idx].l == tree[idx].r) {
tree[idx].mx = x;
tree[idx].sum = x;
return;
}
int mid = (tree[idx].l + tree[idx].r) >> 1;
if (id <= mid)
Insert(id, x, idx << 1);
else
Insert(id, x, idx << 1 | 1);
tree[idx].mx = max(tree[idx << 1].mx, tree[idx << 1 | 1].mx);
tree[idx].sum = tree[idx << 1].sum + tree[idx << 1 | 1].sum;
}
long long query(int l, int r, int idx) {
if (tree[idx].l == l && tree[idx].r == r) return tree[idx].sum;
int mid = (tree[idx].l + tree[idx].r) >> 1;
long long ret = 0;
if (r <= mid)
ret += query(l, r, idx << 1);
else if (l > mid)
ret += query(l, r, idx << 1 | 1);
else
ret += query(l, mid, idx << 1), ret += query(mid + 1, r, idx << 1 | 1);
tree[idx].mx = max(tree[idx << 1].mx, tree[idx << 1 | 1].mx);
tree[idx].sum = tree[idx << 1].sum + tree[idx << 1 | 1].sum;
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
BTree(1, n, 1);
for (int i = 0; i < m; i++) {
int t, l, r, k, x;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &l, &r);
cout << query(l, r, 1) << endl;
} else if (t == 2) {
scanf("%d%d%d", &l, &r, &x);
Insert(l, r, x, 1);
} else {
scanf("%d%d", &k, &x);
Insert(k, x, 1);
}
}
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
int cnt[50];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
cin >> n;
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 30; j >= 0; j--) {
cnt[j] += a[i] >> j & 1;
}
}
bool win = 0, lose = 0;
for (int j = 30; j >= 0; j--) {
if (cnt[j] & 1) {
if ((cnt[j] & 3) == 3 && n - cnt[j] & 1 ^ 1)
lose = 1;
else
win = 1;
break;
}
}
if (win) cout << "WIN\n";
if (lose) cout << "LOSE\n";
if (!win && !lose) cout << "DRAW\n";
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, c = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++)
if (x % i == 0 && x / i <= n) c++;
cout << c;
}
| 1,000 | CPP |
import math
t=int(input())
ans=[]
for i in range(t):
n,x=map(int,input().split())
n=n-2
if n<0:
ans.append(1)
else:
p=math.ceil(n/x)
ans.append(p+1)
for k in ans:
print(k) | 800 | PYTHON3 |
n = int(input())
a = []
for i in range(n):
a.append([int(j) for j in input().split()])
def isThere(mas,i,j,n):
for ii in range(n):
for jj in range(n):
if (mas[ii][j] + mas[i][jj]) == mas[i][j]:
return True
return False
res = "Yes"
for i in range(n):
for j in range(n):
if not a[i][j] == 1:
if not isThere(a,i,j,n):
res = "No"
print(res)
| 800 | PYTHON3 |
n=int(input())
kam=list(map(int,input().split()))
query=int(input())
prefix_sum=[]
sum=0
for x in range(n):
sum+=kam[x]
prefix_sum.append(sum)
for x in range(query):
l,r=list(map(int,input().split()))
l=l-1
r=r-1
jam=prefix_sum[l]
kam=prefix_sum[r]
if l==0:
pass
else:
kam-=prefix_sum[l-1]
print(int(kam//10))
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2000000000000000000LL;
const int inf = 0x3f3f3f3f;
const long double EPS = 1e-9;
const long long MOD = 1e9 + 7;
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int test;
cin >> test;
while (test--) {
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
return 0;
}
| 800 | CPP |
#include <cmath>
#include <iostream>
#include <map>
#include <string>
using namespace std;
#define rd(x) cin >> x;
#define wr(x) cout << x;
#define wrn(x) cout << x << "\n";
typedef long long ll;
typedef long double ld;
#define usettt
ll ans;
ll n, m, t, tp, a, b;
ll i, j, k;
char c;
const ll MOD = 998244353;
ll fac[100001];
ll inv[100001];
void solution() {
rd(n);
m = 0;
t = 0;
for (i = 0; i < n; i++) {
rd(c);
if (c == '0') {
if (t % 2 == 1) {
t--;
}
m++;
} else {
t++;
}
}
t /= 2;
m += t;
ans = (((fac[m] * inv[m - t]) % MOD) * inv[t]) % MOD;
wrn(ans);
}
ll binpow(ll a, ll k) {
if (k == 0) {
return 1;
}
if (k % 2) {
return (binpow(a, k - 1) * a) % MOD;
} else {
ll t = binpow(a, k / 2);
return (t * t) % MOD;
}
}
int main() {
fac[0] = fac[1] = 1;
inv[0] = inv[1] = 1;
for (i = 2; i < 100001; i++) {
fac[i] = (fac[i - 1] * i) % MOD;
inv[i] = binpow(fac[i], MOD - 2);
}
ios::sync_with_stdio(false);
#ifdef usettt
ll ttt;
rd(ttt);
while (ttt--) {
solution();
}
#endif
#ifndef usettt
solution();
#endif
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
char s[MAXN];
int main() {
int n, pos = 0;
read(n);
scanf("\n%s", s + 1);
for (int i = 1; i <= n; i++)
if (s[i] == '(') pos = i;
if (pos != 0) {
for (int i = pos; i >= 2; i--) s[i] = s[i - 1];
s[1] = '(';
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '(')
cnt++;
else
cnt--;
if (cnt < 0) {
puts("No");
return 0;
}
}
if (cnt == 0)
puts("Yes");
else
puts("No");
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int N = 10005;
int tab[N], D[N][1005], i, j, res, g, r, n, m;
deque<pair<int, int> > Q;
void dijkstra() {
int v1, v2, cost, i, j;
for (i = 0; i < m; i++)
for (j = 0; j < g; j++) D[i][j] = INF;
D[0][0] = 0;
Q.push_back(pair<int, int>(0, 0));
while (!Q.empty()) {
v1 = Q.front().first;
v2 = Q.front().second;
Q.pop_front();
if (v1 != 0) {
int diff = tab[v1] - tab[v1 - 1];
if (v2 + diff <= g) {
int newV2 = (v2 + diff) % g;
int addedCost = (newV2 != 0 ? diff : diff + r);
if (D[v1 - 1][newV2] == INF) {
D[v1 - 1][newV2] = D[v1][v2] + addedCost;
if (newV2 == 0)
Q.push_back(pair<int, int>(v1 - 1, newV2));
else
Q.push_front(pair<int, int>(v1 - 1, newV2));
}
}
}
if (v1 < m - 1) {
int diff = tab[v1 + 1] - tab[v1];
if (v2 + diff <= g) {
int newV2 = (v2 + diff) % g;
int addedCost = ((newV2 != 0 || v1 + 1 == m - 1) ? diff : diff + r);
if (D[v1 + 1][newV2] == INF) {
D[v1 + 1][newV2] = D[v1][v2] + addedCost;
if (newV2 == 0)
Q.push_back(pair<int, int>(v1 + 1, newV2));
else
Q.push_front(pair<int, int>(v1 + 1, newV2));
}
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) scanf("%d", &tab[i]);
sort(tab, tab + m);
scanf("%d %d", &g, &r);
dijkstra();
res = INF;
for (j = 0; j < g; j++) res = min(res, D[m - 1][j]);
if (res == INF)
printf("-1\n");
else
printf("%d\n", res);
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4, n, m;
cin >> c1 >> c2 >> c3 >> c4 >> n >> m;
int temp1, temp2, temp3, val;
temp1 = 0;
while (n > 0) {
cin >> val;
if (val * c1 < c2)
temp1 += val * c1;
else
temp1 += c2;
n--;
}
if (temp1 > c3) temp1 = c3;
temp2 = 0;
while (m > 0) {
cin >> val;
if (val * c1 < c2)
temp2 += val * c1;
else
temp2 += c2;
m--;
}
if (temp2 > c3) temp2 = c3;
if (temp1 + temp2 > c4)
cout << c4 << endl;
else
cout << temp1 + temp2 << endl;
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, ans = 1;
cin >> n >> a;
int x = 1, y = n;
while (x != a && y != a) {
x += 2;
y -= 2;
ans++;
}
cout << ans << endl;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 114514;
int m, n, t, k;
bool dp[105][105][5005];
char a[105][105];
int main() {
scanf("%d", &t);
for (int j = 0; j <= 100; j += 2) {
for (int i = 1; i <= 100; i++) {
if ((i * j) % 2 == 1) continue;
int maxn = (i * j) / 2;
int minn = (i % 2) * (j / 2);
for (int l = maxn; l >= minn; l -= 2) {
dp[i][j][l] = true;
dp[i][j + 1][l] = true;
}
}
}
for (int q = 1; q <= t; q++) {
scanf("%d%d%d", &n, &m, &k);
if (dp[n][m][k]) {
memset(a, 0, sizeof(a));
printf("YES\n");
int x = n, y = m, z = k;
int mod = 23;
if (n % 2 == 1) {
for (int j = 1; j <= m; j += 2) {
if (((j + 1) / 2) % 2 == 1)
a[n][j] = a[n][j + 1] = 'y';
else
a[n][j] = a[n][j + 1] = 'z';
z--;
}
x = n - 1;
}
if (m % 2 == 1) {
for (int i = 1; i <= n; i += 2) {
if (((i + 1) / 2) % 2 == 1)
a[i][m] = a[i + 1][m] = 'y';
else
a[i][m] = a[i + 1][m] = 'z';
}
y = m - 1;
}
char ch = 'a';
for (int i = 1; i <= x; i += 2) {
for (int j = 1; j <= y; j += 2) {
if (z) {
if (a[i - 1][j] == ch || a[i - 1][j + 1] == ch + 1) {
ch += 2;
}
if (ch >= 'a' + mod) ch = 'a';
a[i][j] = a[i][j + 1] = ch++;
if (ch >= 'a' + mod) ch = 'a';
a[i + 1][j] = a[i + 1][j + 1] = ch++;
if (ch >= 'a' + mod) ch = 'a';
z -= 2;
} else {
if (a[i - 1][j] == ch || a[i - 1][j + 1] == ch + 1) ch += 2;
if (ch >= 'a' + mod) ch = 'a';
a[i][j] = a[i + 1][j] = ch++;
if (ch >= 'a' + mod) ch = 'a';
a[i][j + 1] = a[i + 1][j + 1] = ch++;
if (ch >= 'a' + mod) ch = 'a';
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
putchar(a[i][j]);
}
putchar('\n');
}
} else
printf("NO\n");
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n;
cin >> n;
vector<long long> a(n);
vector<long long> sl(n + 1);
for (long long i = 0; i < n; ++i) cin >> a[i];
sl[0] = 3;
for (long long i = 0; i < n; ++i) {
if (a[i] == sl[i]) {
cout << "NO";
return 0;
} else {
set<long long> s;
s.insert(1);
s.insert(2);
s.insert(3);
s.erase(a[i]);
s.erase(sl[i]);
sl[i + 1] = *s.begin();
}
}
cout << "YES";
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[1010];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &arr[i]);
bool possible = true;
int minVal = arr[0];
for (int i = 1; i < m; i++) {
if (arr[i] % minVal != 0) possible = false;
}
if (possible) {
printf("%d\n", 2 * m);
for (int i = 0; i < m; i++) {
printf("%d %d ", minVal, arr[i]);
}
printf("\n");
} else {
printf("-1\n");
}
return 0;
}
| 1,900 | CPP |
stones={'purple':'Power','green':'Time','blue':'Space','orange':'Soul','red':'Reality','yellow':'Mind'}
s=set()
t=int(input())
for i in range(t):
inp = input()
s.add(inp)
print(6-t)
for (key,value) in stones.items():
if key not in s:
print(value) | 800 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
for i in range(n - 1):
print(a[i] + a[i + 1], '', end='')
print(a[-1])
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
char s[N];
int n, nxt[N], stk[N], top, f[N];
int main() {
int i, k;
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 2, k = 0; i <= n; ++i) {
while (k && s[i] != s[k + 1]) k = nxt[k];
if (s[i] == s[k + 1]) ++k;
nxt[i] = k;
}
for (i = n; i >= 1; --i) {
++f[i];
f[nxt[i]] += f[i];
}
for (i = n; i; i = nxt[i]) stk[++top] = i;
printf("%d\n", top);
while (top) {
printf("%d %d\n", stk[top], f[stk[top]]);
--top;
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, R[1000100], a[1000100], k, x, L[1001000], y, C1, C2;
long long c1[1001000], c2[1001000];
double ans[1001000];
inline long long read() {
long long cnt = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
cnt = cnt * 10 + ch - 48;
ch = getchar();
}
return cnt * f;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
a[n + 1] = -((long long)1 << 60);
a[0] = -((long long)1 << 60);
for (int i = n; i; i--) {
if (a[i + 1] <= a[i])
R[i] = i + 1;
else
for (int j = R[i + 1]; j <= n + 1; j = R[j])
if (a[j] <= a[i]) {
R[i] = j;
break;
}
}
for (int i = 1; i <= n; i++) {
if (a[i - 1] < a[i])
L[i] = i - 1;
else
for (int j = L[i - 1]; j >= 0; j = L[j])
if (a[j] < a[i]) {
L[i] = j;
break;
}
}
for (int i = 1; i <= n; i++) {
L[i] = i - L[i];
R[i] = R[i] - i;
}
for (int i = 1; i <= n; i++) {
x = L[i];
y = R[i];
if (x > y) swap(x, y);
c1[1] += a[i];
c1[x + 1] -= a[i];
c2[x + 1] += a[i] * x;
c2[y + 1] -= a[i] * x;
c2[y + 1] += a[i] * (x + y);
c2[x + y] -= a[i] * (x + y);
c1[y + 1] -= a[i];
c1[x + y] += a[i];
}
for (int i = 1; i <= n; i++) {
C1 += c1[i];
C2 += c2[i];
ans[i] = ((C1 * i + C2) * 1.0) / ((n - i + 1) * 1.0);
}
m = read();
for (int i = 1; i <= m; i++) {
k = read();
printf("%.9lf\n", ans[k]);
}
return 0;
}
| 2,500 | CPP |
a=input()
b=input()
c=input()
d=a+b
c=sorted(c)
d=sorted(d)
if c==d :
print('YES')
else :
print('NO')
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[200000];
long long b[200000];
long long sum[200000];
long long ans[200000];
long long num[200000];
int main(int argc, char *argv[]) {
int N, l, r, mid;
while (cin >> N) {
for (int i = 1; i <= N; i++) {
cin >> a[i];
}
for (int i = 1; i <= N; i++) {
cin >> b[i];
sum[i] = sum[i - 1] + b[i];
}
for (int i = 1; i <= N; i++) {
l = i - 1;
r = N;
while (l != r) {
mid = (l + r + 1) / 2;
if (a[i] >= sum[mid] - sum[i - 1])
l = mid;
else
r = mid - 1;
}
num[i]++;
num[l + 1]--;
ans[l + 1] += a[i] - (sum[l] - sum[i - 1]);
}
for (int i = 1; i <= N; i++) {
num[i] += num[i - 1];
cout << (num[i] * b[i] + ans[i]) << " ";
}
}
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e7;
long long B[N] = {0};
long long M = -1;
vector<long long> store;
void call(long long x, long long n, long long cnt, long long lim) {
long long k = 2, prod = 1;
while (prod <= lim) {
prod = x * k;
if (B[prod] == 1 || B[prod] == -1) {
cnt++;
B[prod] = -1;
call(prod, n, cnt, lim);
cnt--;
}
k++;
}
if (M <= cnt) M = cnt;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long A[101] = {0};
A[1] = 1;
A[2] = 5;
for (long long i = 3; i <= 100; i++) {
A[i] = 4 + A[i - 1] + A[i - 1] - A[i - 2];
}
long long n;
cin >> n;
cout << A[n] << "\n";
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> last(26, -1);
for (int i = 0; i < s.size(); i++) {
last[s[i] - 'A'] = i;
}
vector<int> beg(26, -1);
for (int i = s.size() - 1; i >= 0; i--) {
beg[s[i] - 'A'] = i;
}
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (i == beg[s[i] - 'A']) cnt++;
if (cnt > k) {
cout << "YES";
return 0;
}
if (i == last[s[i] - 'A']) cnt--;
}
cout << "NO";
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n;
cin >> n;
vector<long long> piles(n + 1), temp(n + 1);
vector<long long> melted(n + 1), freq(n + 2, 0);
for (long long i = 1; i <= n; ++i) {
cin >> piles[i];
}
temp[0] = 0;
long long preSum = 0;
for (long long i = 1; i <= n; ++i) {
cin >> temp[i];
preSum += temp[i];
temp[i] = preSum;
}
for (long long i = 1; i <= n; ++i) {
if (piles[i] != 0) {
long long beg = i, end = n, pos = n + 1;
while (beg <= end) {
long long mid = (beg + end) / 2;
if (temp[mid] - temp[i - 1] >= piles[i]) {
end = mid - 1;
pos = mid;
} else {
beg = mid + 1;
}
}
freq[i]++;
freq[pos]--;
if (pos <= n) {
melted[pos] += piles[i] - (temp[pos - 1] - temp[i - 1]);
}
}
}
preSum = 0;
for (long long i = 0; i <= n; ++i) {
preSum += freq[i];
freq[i] = preSum;
}
for (long long i = 1; i <= n; ++i) {
cout << freq[i] * (temp[i] - temp[i - 1]) + melted[i] << " ";
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
set<char> se;
for (int i = 0; i < s.length(); i++) {
se.insert(s[i]);
}
if (se.size() == 1) {
cout << s;
} else {
for (int i = 0; i < s.length(); i++) {
cout << "01";
}
}
cout << endl;
}
return 0;
}
| 1,100 | CPP |
n, k = input().split(" ")
for i in range(int(k)):
n = str(n)
if str(n[-1]) != "0":
n = int(n) - 1
else:
n = int(str(n[0:-1]))
print(n) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool mark[1000004];
int main() {
long long int n, q, x;
long long int arr[300];
scanf("%lld", &q);
while (q--) {
memset(mark, 0, sizeof(mark));
x = 0;
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
mark[arr[i]] = 1;
}
sort(arr, arr + n);
long long val = arr[0] * arr[n - 1];
long long len = (sqrt(val));
long long co = 0;
for (int i = 2; i <= len; i++) {
if (val % i == 0) {
if (i != (val / i))
co += 2;
else
co++;
if (mark[i] == 0 || mark[(val / i)] == 0) {
x = 1;
break;
}
}
}
if (x || co != n)
printf("-1\n");
else
printf("%lld\n", val);
}
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int read() {
int w = 0, flg = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
flg = -1;
}
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
w = w * 10 + ch - '0', ch = getchar();
}
return w * flg;
}
int Sum(int a, int b, int c, int d, int e, int f) {
int ret = b * c + d * e + a * f - a * d - b * e - c * f;
return (ret % 4 + 4) % 4;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int n, x[6010], y[6010], cnt[4][4][4];
long long re1, re2;
int main() {
n = read();
for (int i = (1); i <= (n); i++) x[i] = read(), y[i] = read();
for (int i = (1); i <= (n); i++) {
memset(cnt, 0, sizeof(cnt));
for (int j = (1); j <= (n); j++) {
if (i == j) continue;
cnt[x[j] % 4][y[j] % 4][gcd(abs(x[j] - x[i]), abs(y[j] - y[i])) % 4]++;
}
for (int x1 = (0); x1 <= (3); x1++) {
for (int y1 = (0); y1 <= (3); y1++) {
for (int g1 = (0); g1 <= (3); g1++) {
long long p1 = cnt[x1][y1][g1];
cnt[x1][y1][g1]--;
for (int x2 = (x1 & 1); x2 < 4; x2 += 2) {
for (int y2 = (y1 & 1); y2 < 4; y2 += 2) {
for (int g2 = (g1 & 1); g2 < 4; g2 += 2) {
long long p2 = cnt[x2][y2][g2];
int S = Sum(x[i], y[i], x1, y1, x2, y2);
if (S & 1) break;
S >>= 1;
int g3 = gcd(abs(x2 - x1), abs(y2 - y1));
if ((S - (g1 + g2 + g3) / 2 + 1) & 1) {
if (g1 & 1)
re1 += p1 * p2;
else
re2 += p1 * p2;
}
}
}
}
cnt[x1][y1][g1]++;
}
}
}
}
printf("%lld\n", re1 / 2 + re2 / 6);
return 0;
}
| 3,300 | CPP |
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
def answer(ax,ay,bx,by,cx,cy):
journey=[[ax,ay]]
distb=abs(ax-bx)+abs(ay-by)
distc=abs(ax-cx)+abs(ay-cy)
while ax!=bx or ay!=by:
tempcor=[[ax+1,ay],[ax,ay+1],[ax-1,ay],[ax,ay-1]]
for i in range(4):
f=0
if tempcor[i][0]>=0 and tempcor[i][1]>=0:
ndistb=abs(tempcor[i][0]-bx)+abs(tempcor[i][1]-by)
ndistc=abs(tempcor[i][0]-cx)+abs(tempcor[i][1]-cy)
if ndistb<distb and ndistc<distc:
ax=tempcor[i][0]
ay=tempcor[i][1]
distb=ndistb
distc=ndistc
f=1
break
elif ndistb<distb:
tax=tempcor[i][0]
tay=tempcor[i][1]
tdistb=ndistb
tdistc=ndistc
if f==0:
ax=tax
ay=tay
distb=tdistb
distc=tdistc
journey.append([ax,ay])
md=999999999999999999
for plot in journey:
distfromc=abs(cx-plot[0])+abs(cy-plot[1])
if distfromc<md:
md=distfromc
kahase=plot
ax,ay=kahase
distc=abs(ax-cx)+abs(ay-cy)
while ax!=cx or ay!=cy:
tempcor=[[ax+1,ay],[ax,ay+1],[ax-1,ay],[ax,ay-1]]
for i in range(4):
f=0
if tempcor[i][0]>=0 and tempcor[i][1]>=0:
ndistc=abs(tempcor[i][0]-cx)+abs(tempcor[i][1]-cy)
if ndistc<distc:
ax=tempcor[i][0]
ay=tempcor[i][1]
distc=ndistc
f=1
break
journey.append([ax,ay])
return journey
def main():
# mod=1000000007
# InverseofNumber(mod)
# InverseofFactorial(mod)
# factorial(mod)
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
tc=1
for _ in range(tc):
ax,ay=ria()
bx,by=ria()
cx,cy=ria()
answer1=answer(ax,ay,bx,by,cx,cy)
answer2=answer(ax,ay,cx,cy,bx,by)
answer3=answer(bx,by,cx,cy,ax,ay)
m=9999999999999999999999999999
for i in [answer1,answer2,answer3]:
if len(i)<m:
ans=i
m=len(i)
wi(m)
for i in ans:
wia(i)
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
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, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
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()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T x, T y) {
while (y > 0) {
x %= y;
swap(x, y);
}
return x;
}
template <class _T>
inline _T sqr(const _T &x) {
return x * x;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
template <typename T>
inline void input(T &a) {
static int c;
a = 0;
while (!isdigit(c = getchar()) && c != '-') {
}
char neg = 0;
if (c == '-') {
neg = 1;
c = getchar();
}
while (isdigit(c)) {
a = 10 * a + c - '0';
c = getchar();
}
if (neg) a = -a;
}
template <typename T = int>
inline T nxt() {
T res;
input(res);
return res;
}
struct S {
int x, y, cost;
};
struct Edge {
int from, to, cap, flow;
long long len;
};
const int N = 22;
char s[N][N + 1];
vector<S> le;
vector<S> ri;
const int NM = N * N;
int dist[NM][NM];
int qu[NM];
char used[NM];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
long long distle[NM][NM];
long long distri[NM][NM];
vector<Edge> edges;
vector<int> g[4 * NM + 5];
int us[4 * NM + 5];
int phase = 1;
int que[4 * NM + 5];
int p[4 * NM + 5];
void addEdge(int from, int to, int cap, long long len) {
g[from].push_back(edges.size());
edges.push_back(Edge{from, to, cap, 0, len});
g[to].push_back(edges.size());
edges.push_back(Edge{to, from, 0, 0, len});
}
int vertSize;
int ptr[5 * NM + 5];
int ddd[5 * NM + 5];
bool bfs(int s, int t, long long len) {
++phase;
int q1 = 0, q2 = 0;
que[q2++] = s;
us[s] = phase;
ddd[s] = 0;
p[s] = -1;
while (q1 < q2) {
int v = que[q1++];
for (int ed : g[v]) {
Edge &e = edges[ed];
if (e.len > len) break;
if (e.cap > e.flow) {
if (us[e.to] != phase) {
us[e.to] = phase;
que[q2++] = e.to;
p[e.to] = ed;
ddd[e.to] = ddd[v] + 1;
}
}
}
}
return us[t] == phase;
}
int dfs(int v, int t, int flow, long long len) {
if (!flow) return 0;
if (v == t) return flow;
for (; ptr[v] < (int)g[v].size(); ++ptr[v]) {
int id = g[v][ptr[v]], to = edges[id].to;
if (edges[id].len > len) {
break;
}
if (ddd[to] != ddd[v] + 1) continue;
int pushed = dfs(to, t, min(flow, edges[id].cap - edges[id].flow), len);
if (pushed) {
edges[id].flow += pushed;
edges[id ^ 1].flow -= pushed;
return pushed;
}
}
return 0;
}
int dinic(int s, int t, long long len) {
int flow = 0;
for (;;) {
if (!bfs(s, t, len)) break;
memset(ptr, 0, vertSize * sizeof(int));
while (int pushed = dfs(s, t, 1000, len)) flow += pushed;
}
return flow;
}
void clearFlow(long long len) {
for (int i = 0; i < vertSize; ++i) {
for (int ed : g[i]) {
if (edges[ed].len > len) {
break;
}
edges[ed].flow = 0;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, B, G;
n = nxt();
m = nxt();
B = nxt();
G = nxt();
if (abs(B - G) != 1) {
puts("-1");
return 0;
}
int emptyCell = 0;
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < m; ++j) {
emptyCell += s[i][j] == '.';
}
}
if ((B + G + 1) / 2 > emptyCell) {
puts("-1");
return 0;
}
{
int r = nxt() - 1;
int c = nxt() - 1;
int t = nxt();
if (B < G) {
le.push_back(S{r, c, t});
} else {
ri.push_back(S{r, c, t});
}
}
for (int i = 0; i < B; ++i) {
int r = nxt() - 1;
int c = nxt() - 1;
int t = nxt();
le.push_back(S{r, c, t});
}
for (int i = 0; i < G; ++i) {
int r = nxt() - 1;
int c = nxt() - 1;
int t = nxt();
ri.push_back(S{r, c, t});
}
memset(dist, 0x3f, sizeof(dist));
int inf = dist[0][0];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int st = i * m + j;
if (s[i][j] == '#') continue;
dist[st][st] = 0;
int q1 = 0, q2 = 0;
qu[q2++] = st;
memset(used, 0, sizeof(used));
used[st] = 1;
while (q1 < q2) {
int id = qu[q1++];
int vx = id / m;
int vy = id % m;
for (int k = 0; k < 4; ++k) {
int x = vx + dx[k];
int y = vy + dy[k];
if (x < 0 || x >= n || y < 0 || y >= m) continue;
if (s[x][y] == '#') continue;
int nid = x * m + y;
if (!used[nid]) {
used[nid] = 1;
qu[q2++] = nid;
dist[st][nid] = dist[st][id] + 1;
}
}
}
}
}
long long maxdist = 0;
for (int i = 0; i < int(le.size()); ++i) {
int ii = le[i].x * m + le[i].y;
for (int jj = 0; jj < n * m; ++jj) {
if (dist[ii][jj] != inf) {
distle[i][jj] = dist[ii][jj] * 1ll * le[i].cost;
maxdist = max(maxdist, distle[i][jj]);
} else {
distle[i][jj] = LLONG_MAX;
}
}
}
for (int i = 0; i < int(ri.size()); ++i) {
int ii = ri[i].x * m + ri[i].y;
for (int jj = 0; jj < n * m; ++jj) {
if (dist[ii][jj] != inf) {
distri[i][jj] = dist[ii][jj] * 1ll * ri[i].cost;
maxdist = max(maxdist, distri[i][jj]);
} else {
distri[i][jj] = LLONG_MAX;
}
}
}
for (int i = 0; i < n * m; ++i) {
addEdge(2 * i, 2 * i + 1, 1, 0);
}
int curv = 2 * n * m;
int source = curv + le.size() + ri.size();
int sink = curv + le.size() + ri.size() + 1;
for (int i = 0; i < (int)le.size(); ++i) {
for (int j = 0; j < n * m; ++j) {
if (distle[i][j] != LLONG_MAX) addEdge(curv + i, 2 * j, 1, distle[i][j]);
}
addEdge(source, curv + i, 1, 0);
}
curv += le.size();
for (int i = 0; i < int(ri.size()); ++i) {
for (int j = 0; j < n * m; ++j) {
if (distri[i][j] != LLONG_MAX)
addEdge(2 * j + 1, curv + i, 1, distri[i][j]);
}
addEdge(curv + i, sink, 1, 0);
}
for (int i = 0; i <= sink; ++i) {
sort((g[i]).begin(), (g[i]).end(),
[&](int l, int r) { return edges[l].len < edges[r].len; });
}
long long l = 0, r = maxdist;
int needFlow = le.size();
vertSize = sink + 1;
while (l < r) {
long long mid = (l + r) >> 1;
int flow = dinic(source, sink, mid);
clearFlow(mid);
if (flow < needFlow) {
l = mid + 1;
} else {
r = mid;
}
}
int flow = dinic(source, sink, l);
if (flow != needFlow) {
cout << "-1" << endl;
return 0;
}
cout << l << endl;
return 0;
};
| 2,700 | CPP |
x,y,z=map(int,input().split())
if x>y+z:
print("+")
elif x+z<y:
print('-')
elif x==y and z==0:
print(0)
else:
print('?') | 800 | PYTHON3 |
t=int(input())
n=str(input())
c=0
for i in range(t-1):
if n[i]==n[i+1]:
c+=1
print(c) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, n, m, a, b;
while (cin >> n >> m >> a >> b) {
i = a % m;
if (i == 0) i = m;
j = m - i;
if ((a + j) >= b || (i == 1 && (b % m) == 0)) {
printf("1\n");
} else {
if (b == n) {
if (i == 1)
printf("1\n");
else
printf("2\n");
} else {
a += j;
k = b % m;
if (k == 0) k = m;
if ((b % m) == 0 || i == 1 || (a + m) >= b || (k + 1) == (i))
printf("2\n");
else {
printf("3\n");
}
}
}
}
return 0;
}
| 1,700 | CPP |
x=input()
l=len(x)
s=[]
for i in range(l-6):
y=x[i:i+7:1]
z=set(y)
s.append(len(z))
if 1 in s:
print("YES")
else:
print("NO")
| 900 | PYTHON3 |
Subsets and Splits