solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
struct mydata {
int left;
int right;
double _mid;
double _left;
double _right;
double _total;
int calmid() { return (left + right) / 2; }
} Stree[700000];
double a[200000];
double x[200000];
double p[200000];
void build(int left, int right, int index) {
Stree[index].left = left;
Stree[index].right = right;
if (left == right) {
Stree[index]._left = Stree[index]._mid = Stree[index]._right =
Stree[index]._total = a[left];
return;
}
int mid = Stree[index].calmid();
build(left, mid, index << 1);
build(mid + 1, right, (index << 1) + 1);
Stree[index]._total =
Stree[index << 1]._total + Stree[(index << 1) + 1]._total;
Stree[index]._mid =
max(Stree[index << 1]._right + Stree[(index << 1) + 1]._left,
max(Stree[index << 1]._mid, Stree[(index << 1) + 1]._mid));
Stree[index]._left =
max(Stree[index << 1]._left,
Stree[index << 1]._total + Stree[(index << 1) + 1]._left);
Stree[index]._right =
max(Stree[(index << 1) + 1]._right,
Stree[index << 1]._right + Stree[(index << 1) + 1]._total);
}
double querytotal(int left, int right, int index) {
if (Stree[index].left >= left && Stree[index].right <= right) {
return Stree[index]._total;
}
int mid = Stree[index].calmid();
if (left > mid)
return querytotal(left, right, (index << 1) + 1);
else if (right <= mid)
return querytotal(left, right, index << 1);
return querytotal(left, mid, index << 1) +
querytotal(mid + 1, right, (index << 1) + 1);
}
double queryleft(int left, int right, int index) {
if (Stree[index].left >= left && Stree[index].right <= right) {
return Stree[index]._left;
}
int mid = Stree[index].calmid();
if (left > mid)
return queryleft(left, right, (index << 1) + 1);
else if (right <= mid)
return queryleft(left, right, index << 1);
else
return max(queryleft(left, mid, index << 1),
queryleft(mid + 1, right, (index << 1) + 1) +
querytotal(left, mid, index << 1));
}
double queryright(int left, int right, int index) {
if (Stree[index].left >= left && Stree[index].right <= right) {
return Stree[index]._right;
}
int mid = Stree[index].calmid();
if (left > mid)
return queryright(left, right, (index << 1) + 1);
else if (right <= mid)
return queryright(left, right, index << 1);
else
return max(queryright(mid + 1, right, (index << 1) + 1),
queryright(left, mid, index << 1) +
querytotal(mid + 1, right, (index << 1) + 1));
}
double querymid(int left, int right, int index) {
if (left > right) return 0;
if (Stree[index].left >= left && Stree[index].right <= right) {
return Stree[index]._mid;
}
int mid = Stree[index].calmid();
if (left > mid)
return querymid(left, right, (index << 1) + 1);
else if (right <= mid)
return querymid(left, right, index << 1);
else {
double ret = max(querymid(left, mid, index << 1),
querymid(mid + 1, right, (index << 1) + 1));
return max(ret, queryright(left, mid, index << 1) +
queryleft(mid + 1, right, (index << 1) + 1));
}
}
int main() {
int n, m;
double c;
int i;
cin >> n >> m >> c;
for (i = 1; i <= n; i++) {
cin >> x[i];
}
for (i = 1; i < n; i++) {
cin >> p[i];
a[i] = 0 - p[i] * c + (x[i + 1] - x[i]) * 50;
}
build(1, n - 1, 1);
double ret = 0;
for (i = 0; i < m; i++) {
int aa, b;
cin >> aa >> b;
double t = max(0.0, querymid(aa, b - 1, 1));
ret += t;
}
printf("%.12lf\n", ret / 100);
return 0;
}
| 9 | CPP |
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#define MAXN 14
using namespace std;
char str[MAXN+3][20+5];
int dp[MAXN+3][MAXN+3][(1 << MAXN)+3], cps[MAXN+3][MAXN+3], len[MAXN+5];
bool included[MAXN+5];
bool judge(int h, int t, int num) {
for (int i = 0; i < num; i++) {
if (str[h][len[h]+i-num] != str[t][i]) {
return false;
}
}
return true;
}
int main() {
int n, min_len, nows;
while (scanf("%d", &n) == 1) {
if (n == 0) break;
memset(dp, 0x3f, sizeof(dp));
//cout << "%%%" << endl;
memset(cps, 0, sizeof(cps));
memset(included, false, sizeof(included));
for (int i = 0; i < n; i++) {
scanf("%s", str[i]);
len[i] = strlen(str[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
min_len = min(len[i], len[j]);
for (int k = min_len; k > 0; k--) {
if (judge(i, j, k)) {
cps[i][j] = k;
break;
}
}
if (strstr(str[i], str[j]) != NULL) {
included[j] = true;
}
}
dp[i][i][1 << i] = len[i];
}
//cout << "&&&" << endl;
int maxs = (1 << n);
int finaln = maxs-1;
for (int s = 0; s < maxs; s++) {
for (int i = 0; i < n; i++) {
if (included[i] || (!(1&(s >> i)))) continue;
for (int j = 0; j < n; j++) {
if (included[j] || (!(1&(s >> j)))) continue;
for (int k = 0; k < n; k++) {
if (included[k] || (1&(s >> k))) continue;
nows = (1 << k);
dp[k][i][s|nows] = min(dp[k][i][s|nows], dp[j][i][s]+len[k]-cps[k][j]);
dp[j][k][s|nows] = min(dp[j][k][s|nows], len[k]-cps[i][k]+dp[k][j][s]);
}
}
}
}
for (int i = 0; i < n; i++) {
if (included[i]) {
finaln ^= (1 << i);
}
}
int ans = 0x7fffffff;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ans = min(ans, dp[i][j][finaln]);
}
}
printf("%d\n", ans);
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
string S1[10002], an[] = {"aabb", "abab", "abba", "aaaa", "NO"}, S;
int ar[5], n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < 4 * n; i++) {
int l = 0, k;
cin >> S;
for (k = S.size(); k >= 0 && l != m;) {
k--;
if (S[k] == 'a' || S[k] == 'e' || S[k] == 'i' || S[k] == 'o' ||
S[k] == 'u')
l++;
}
if (l != m) ar[4]++;
if (k == -1) k = 0;
S1[i] = S.substr(k);
}
for (int i = 0; i < 4 * n; i += 4) {
if (S1[i] == S1[i + 1] && S1[i + 1] == S1[i + 2] && S1[i + 2] == S1[i + 3])
ar[3]++;
if (S1[i] == S1[i + 1] && S1[i + 2] == S1[i + 3]) ar[0]++;
if (S1[i] == S1[i + 2] && S1[i + 1] == S1[i + 3]) ar[1]++;
if (S1[i] == S1[i + 3] && S1[i + 1] == S1[i + 2]) ar[2]++;
}
if (ar[4])
cout << an[4] << endl;
else {
int t = 0, k1 = -1;
for (int i = 0; i < 4; i++)
if (ar[i] == n) k1 = i;
if (k1 != -1)
cout << an[k1] << endl;
else
cout << an[4] << endl;
}
}
| 9 | CPP |
num = int(input())
pix = [0]*6
for i in range(6):
pix[-i-1] = (num % 2)
num = num // 2
ref = [0]*6
ref[0] = pix[0]
ref[5] = pix[1]
ref[3] = pix[2]
ref[1] = pix[3]
ref[4] = pix[4]
ref[2] = pix[5]
ref[0] = pix[0]
ref[5] = pix[1]
ref[3] = pix[2]
ref[2] = pix[3]
ref[4] = pix[4]
ref[1] = pix[5]
num = 0
for i in range(6):
num = num*2 + ref[i]
print(num) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
struct Point {
double x, y;
bool operator<(const Point &rhs) const {
return (x == rhs.x && y < rhs.y) || (x < rhs.x);
}
bool operator>(const Point &rhs) const {
return (x == rhs.x && y > rhs.y) || (x > rhs.x);
}
bool operator==(const Point &rhs) const { return x == rhs.x && y == rhs.y; }
bool operator!=(const Point &rhs) const { return x != rhs.x || y != rhs.y; }
bool operator<=(const Point &rhs) const {
return *this < rhs || *this == rhs;
}
bool operator>=(const Point &rhs) const {
return *this > rhs || *this == rhs;
}
Point operator+(const Point &rhs) const { return {x + rhs.x, y + rhs.y}; }
Point operator-(const Point &rhs) const { return {x - rhs.x, y - rhs.y}; }
Point operator*(const Point &rhs) const { return {x * rhs.x, y * rhs.y}; }
Point operator/(const Point &rhs) const { return {x / rhs.x, y / rhs.y}; }
Point operator+(const double &rhs) const { return {x + rhs, y + rhs}; }
Point operator-(const double &rhs) const { return {x - rhs, y - rhs}; }
Point operator*(const double &rhs) const { return {x * rhs, y * rhs}; }
Point operator/(const double &rhs) const { return {x / rhs, y / rhs}; }
};
struct Line {
double a, b, c;
Line() {}
Line(const double &_a, const double &_b, const double &_c)
: a{_a}, b{_b}, c{_c} {}
Line(const Point &p1, const Point &p2) {
a = p1.y - p2.y;
b = -(p1.x - p2.x);
c = -(a * p1.x + b * p1.y);
}
};
template <class T>
inline bool inRange(T a, T b, T c) {
return min(b, c) <= a && a <= max(b, c);
}
inline double distance(Point a, Point b) {
a = (a - b) * (a - b);
return sqrt(a.x + a.y);
}
inline bool onLine(Point p, Point b, Point c) {
return (p.y - c.y) * (c.x - b.x) == (c.y - b.y) * (p.x - c.x);
}
inline bool onSegment(Point p, Point b, Point c) {
return inRange(p.x, b.x, c.x) && inRange(p.y, b.y, c.y);
}
inline double crossProduct(Point a, Point b, Point c) {
return (b.y - a.y) * (c.x - b.x) - (b.x - a.x) * (c.y - b.y);
}
inline double orientation(Point a, Point b, Point c) {
double cr = crossProduct(a, b, c);
return (cr != 0) * (cr / abs(cr));
}
inline double distanceToLine(const Point &p, const Line &l) {
return (-(l.a * p.x + l.b * p.y + l.c)) / (l.a * l.a + l.b * l.b);
}
inline Point projectToLine(const Point &p, const Line &l) {
double d = distanceToLine(p, l);
return {p.x + d * l.a, p.y + d * l.b};
}
inline double polygonArea(const vector<Point> &v) {
double a = 0;
int n = v.size();
for (int i = 0; i < n; i++)
a += v[i].x * v[(i + 1) % n].y - v[i].y * v[(i + 1) % n].x;
return abs(a) / 2;
}
inline bool isSegmentIntersect(const Point &a, const Point &b, const Point &c,
const Point &d) {
double o1 = orientation(a, b, c);
double o2 = orientation(a, b, d);
double o3 = orientation(c, d, a);
double o4 = orientation(c, d, b);
return (o1 != o2 && o3 != o4) || (!o1 && onSegment(a, c, b)) ||
(!o2 && onSegment(a, d, b)) || (!o3 && onSegment(c, a, d)) ||
(!o4 && onSegment(c, b, d));
}
inline double pointToSegment(const Point &p, const Point &p1, const Point &p2) {
Line L(p1, p2);
Point pr = projectToLine(p, L);
return (inRange(pr.x, p1.x, p2.x) && (inRange(pr.y, p1.y, p2.y))
? abs(L.a * p.x + L.b * p.y + L.c) / sqrt(L.a * L.a + L.b * L.b)
: min(distance(p, p1), distance(p, p2)));
}
inline double segmentToSegment(const Point &p1, const Point &q1,
const Point &p2, const Point &q2) {
if (isSegmentIntersect(p1, q1, p2, q2)) return 0;
double a, b, c, d;
a = pointToSegment(p1, p2, q2);
b = pointToSegment(q1, p2, q2);
c = pointToSegment(p2, p1, q1);
d = pointToSegment(q2, p1, q1);
return min(min(a, b), min(c, d));
}
inline vector<Point> monotoneChain(vector<Point> v) {
sort(v.begin(), v.end());
int n = v.size(), k = 0;
vector<Point> CH(2 * n);
for (int i = 0; i < n; i++) {
while (k >= 2 && crossProduct(CH[k - 2], CH[k - 1], v[i]) < 0) k--;
CH[k++] = v[i];
}
for (int i = n - 1, t = k + 1; i > 0; i--) {
while (k >= t && crossProduct(CH[k - 2], CH[k - 1], v[i - 1]) < 0) k--;
CH[k++] = v[i - 1];
}
CH.resize(k - 1);
return CH;
}
inline Point lineIntersection(Line a, Line b) {
double x, y, det;
det = a.a * b.b - b.a * a.b;
if (det == 0) return {FLT_MAX, FLT_MAX};
x = (b.b * a.c - a.b * b.c) / det;
y = (a.a * b.c - b.a * a.c) / det;
return {x, y};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n;
vector<Point> a(n), ab(n);
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].y;
ab[i] = a[i];
}
cin >> m;
vector<Point> b(m);
for (int i = 0; i < m; i++) {
cin >> b[i].x >> b[i].y;
ab.push_back(b[i]);
}
vector<Point> res = monotoneChain(ab);
sort(a.begin(), a.end());
sort(res.begin(), res.end());
puts(res == a ? "YES" : "NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500009;
int a[maxn];
queue<int> Q[7];
int main() {
int n, good = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 4)
Q[1].push(i);
else if (a[i] == 8)
Q[2].push(i);
else if (a[i] == 15)
Q[3].push(i);
else if (a[i] == 16)
Q[4].push(i);
else if (a[i] == 23)
Q[5].push(i);
else if (a[i] == 42)
Q[6].push(i);
}
while (1) {
int x = Q[1].front();
for (int i = 2; i <= 6; i++) {
while (Q[i].front() < x && !Q[i].empty()) {
Q[i].pop();
}
if (Q[i].empty())
break;
else if (i == 6 && !Q[i].empty()) {
good += 6;
Q[6].pop();
} else {
x = Q[i].front();
Q[i].pop();
}
}
if (Q[1].empty())
break;
else
Q[1].pop();
}
cout << n - good << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, flag = 0;
cin >> n >> k;
char arr1[n];
int arr2[k];
for (int i = 0; i < n; i++) cin >> arr1[i];
for (int i = 0; i < k; i++) arr2[i] = 0;
for (int i = 0; i < n; i++) {
arr2[(int(arr1[i])) - 65]++;
}
int min = arr2[0];
for (int i = 1; i < k; i++)
if (arr2[i] < min) min = arr2[i];
for (int i = 0; i < k; i++)
if (arr2[i] == 0) flag = 1;
if (flag != 1)
cout << min * k;
else
cout << "0";
}
| 7 | CPP |
a,b,c=[int(x) for x in input().split(' ')]
temp=min(a,b)
a=a-temp
b=b-temp
c=c+temp
print(2*c+(1 if (a or b) else 0)) | 7 | PYTHON3 |
from collections import Counter
testCases = int(input())
for t in range(testCases):
n = int(input())
nums = list(map(int, input().split(" ")))
ls1 = []
ls2 = []
index = 0
for num in nums:
if index < len(ls1) and num == ls1[index]:
ls2.append(num)
index += 1
else:
ls1.append(num)
print(" ".join(map(str, ls1)))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int Tst;
cin >> Tst;
while (Tst--) {
string S, T;
cin >> S >> T;
if (T == S) {
cout << "Yes\n";
continue;
}
if (T.size() > S.size()) {
cout << "No\n";
continue;
}
long long int ind = S.size() - 1;
for (long long int i = T.size() - 1; i >= 0; --i) {
while (ind >= 0 && T[i] != S[ind]) {
ind -= 2;
}
if (ind < 0) {
cout << "No\n";
goto end_test;
}
ind--;
}
cout << "Yes\n";
end_test:;
}
}
| 10 | CPP |
x = int(input())
while True:
flg = True
for i in range(2,x):
if x % i == 0:
flg = False
break
if flg == True: break
x += 1
print(x) | 0 | PYTHON3 |
n, k = input().split()
n = int(n)
k = int(k)
s = input()
alphabets = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
i = 0
al = alphabets[i]
while(k > 0):
z = s.count(al)
s = s.replace(al, "", min(z, k))
if k <= z:
break
k -= z
i += 1
al = alphabets[i]
print(s) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T& val) {
std::fill((T*)array, (T*)(array + N), val);
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <unsigned int mod>
class ModInt {
private:
unsigned int v;
static unsigned int norm(const unsigned int& x) {
return x < mod ? x : x - mod;
}
static ModInt make(const unsigned int& x) {
ModInt m;
return m.v = x, m;
}
static ModInt inv(const ModInt& x) { return make(inverse(x.v, mod)); }
static unsigned int inverse(int a, int m) {
int u[] = {a, 1, 0}, v[] = {m, 0, 1}, t;
while (*v) {
t = *u / *v;
swap(u[0] -= t * v[0], v[0]), swap(u[1] -= t * v[1], v[1]),
swap(u[2] -= t * v[2], v[2]);
}
return (u[1] % m + m) % m;
}
public:
ModInt() : v{0} {}
ModInt(const long long val) : v{norm(val % mod + mod)} {}
ModInt(const ModInt<mod>& n) : v{n()} {}
explicit operator bool() const noexcept { return v != 0; }
bool operator!() const noexcept { return !static_cast<bool>(*this); }
ModInt& operator=(const ModInt& n) { return v = n(), (*this); }
ModInt& operator=(const long long val) {
return v = norm(val % mod + mod), (*this);
}
ModInt operator+() const { return *this; }
ModInt operator-() const { return v == 0 ? make(0) : make(mod - v); }
ModInt operator+(const ModInt& val) const { return make(norm(v + val())); }
ModInt operator-(const ModInt& val) const {
return make(norm(v + mod - val()));
}
ModInt operator*(const ModInt& val) const {
return make((long long)v * val() % mod);
}
ModInt operator/(const ModInt& val) const { return *this * inv(val); }
ModInt& operator+=(const ModInt& val) { return *this = *this + val; }
ModInt& operator-=(const ModInt& val) { return *this = *this - val; }
ModInt& operator*=(const ModInt& val) { return *this = *this * val; }
ModInt& operator/=(const ModInt& val) { return *this = *this / val; }
ModInt operator+(const long long val) const { return ModInt{v + val}; }
ModInt operator-(const long long val) const { return ModInt{v - val}; }
ModInt operator*(const long long val) const {
return ModInt{(long long)v * (val % mod)};
}
ModInt operator/(const long long val) const {
return ModInt{(long long)v * inv(val)};
}
ModInt& operator+=(const long long val) { return *this = *this + val; }
ModInt& operator-=(const long long val) { return *this = *this - val; }
ModInt& operator*=(const long long val) { return *this = *this * val; }
ModInt& operator/=(const long long val) { return *this = *this / val; }
bool operator==(const ModInt& val) const { return v == val.v; }
bool operator!=(const ModInt& val) const { return !(*this == val); }
bool operator==(const long long val) const {
return v == norm(val % mod + mod);
}
bool operator!=(const long long val) const { return !(*this == val); }
unsigned int operator()() const { return v; }
friend ModInt operator+(const long long val, const ModInt& n) {
return n + val;
}
friend ModInt operator-(const long long val, const ModInt& n) {
return ModInt{val - n()};
}
friend ModInt operator*(const long long val, const ModInt& n) {
return n * val;
}
friend ModInt operator/(const long long val, const ModInt& n) {
return ModInt{val} / n;
}
friend bool operator==(const long long val, const ModInt& n) {
return n == val;
}
friend bool operator!=(const long long val, const ModInt& n) {
return !(val == n);
}
friend istream& operator>>(istream& is, ModInt& n) {
unsigned int v;
return is >> v, n = v, is;
}
friend ostream& operator<<(ostream& os, const ModInt& n) {
return (os << n());
}
friend ModInt mod_pow(ModInt x, long long n) {
ModInt ans = 1;
while (n) {
if (n & 1) ans *= x;
x *= x, n >>= 1;
}
return ans;
}
};
using mod = ModInt<1000000007>;
mod inv[200000], fac[200000], finv[200000];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 200000; i++) {
inv[i] = 1000000007 - inv[1000000007 % i] * (1000000007 / i);
fac[i] = fac[i - 1] * i;
finv[i] = finv[i - 1] * inv[i];
}
}
mod comb(int a, int b) {
if (a < b) return 0;
return fac[a] * finv[b] * finv[a - b];
}
class UnionFind {
private:
int sz;
vector<int> par, size_;
public:
UnionFind() {}
UnionFind(int node_size) : sz(node_size), par(sz), size_(sz, 1) {
iota(par.begin(), par.end(), 0);
}
int find(int x) {
if (par[x] == x)
return x;
else
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (size_[x] < size_[y]) swap(x, y);
par[y] = x;
size_[x] += size_[y];
}
int size(int x) {
x = find(x);
return size_[x];
}
bool same(int x, int y) { return find(x) == find(y); }
};
int main() {
int n;
cin >> n;
vector<pair<pair<int, int>, int> > a, b;
for (int i = 0; i < (int)(n); ++i) {
int x, y;
cin >> x >> y;
a.push_back(make_pair(make_pair(x, y), i));
b.push_back(make_pair(make_pair(y, x), i));
}
UnionFind uf(n);
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
for (int i = 0; i < (int)(n - 1); ++i) {
if (a[i].first.first == a[i + 1].first.first) {
uf.unite(a[i].second, a[i + 1].second);
}
if (b[i].first.first == b[i + 1].first.first) {
uf.unite(b[i].second, b[i + 1].second);
}
}
map<int, set<int> > mpx, mpy;
for (int i = 0; i < (int)(n); ++i) {
mpx[uf.find(a[i].second)].insert(a[i].first.first);
mpy[uf.find(a[i].second)].insert(a[i].first.second);
}
mod res = 1;
for (auto& x : mpx) {
int k = x.first;
int line = 0;
line += x.second.size();
line += mpy[k].size();
int sz = uf.size(k);
if (sz >= line) {
res *= mod_pow((mod)2, line);
} else {
res *= mod_pow((mod)2, line) - 1;
}
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50 + 5, inf = 1e9;
int n, s[maxn][maxn];
int main() {
int i, j, k;
int odd = 1, even = 2;
cin >> n;
int x = n / 2 + 1;
for (i = 1, j = 0; j < x; i++, j++)
for (k = x - j; k <= x + j; k++) s[i][k] = 1;
for (i = x + 1, j = x - 2; i <= n; i++, j--)
for (k = x - j; k <= x + j; k++) s[i][k] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (s[i][j])
s[i][j] = odd, odd += 2;
else
s[i][j] = even, even += 2;
for (i = 1; i <= n; i++, cout << endl)
for (j = 1; j <= n; j++) cout << s[i][j] << " ";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
const int maxn = 2e5 + 10;
const int maxm = 1e6 + 10;
const long long mod = 998244353;
int p[maxn], b[maxn], du[maxn];
vector<int> vec;
int vis[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
b[i] = p[i];
if (i != p[i])
du[i]++;
else
vec.push_back(i);
}
if (vec.size() == 0) {
int now = 1;
while (!vis[p[now]]) {
vis[now] = 1;
now = p[now];
}
p[now] = now;
int rt = now;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
now = i;
while (1) {
vis[now] = i;
if (vis[p[now]] && vis[p[now]] != i)
break;
else if (vis[p[now]] == i) {
p[now] = rt;
break;
}
now = p[now];
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (p[i] != b[i]) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
return 0;
}
int rt = -1;
for (int i = 0; i < vec.size(); i++)
if (du[vec[i]] == 0) rt = vec[i];
if (rt == -1) {
for (int i = 1; i <= n; i++)
if (du[i] == 0) rt = i;
}
p[rt] = rt;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
int now = i;
while (1) {
vis[now] = i;
if (vis[p[now]] && vis[p[now]] != i)
break;
else if (vis[p[now]] == i) {
p[now] = rt;
break;
}
now = p[now];
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (p[i] != b[i]) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int64_t seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline int64_t rnd(int64_t l = 0, int64_t r = INT_MAX) {
return uniform_int_distribution<int64_t>(l, r)(rng);
}
template <typename T, typename G>
ostream& operator<<(ostream& out, const pair<T, G>& a) {
return out << "( " << a.first << ", " << a.second << ")";
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
out << "[ ";
for (const auto& i : a) out << i << ", ";
return out << "]" << endl;
}
template <typename T>
ostream& operator<<(ostream& out, const set<T>& a) {
out << "{ ";
for (const auto& i : a) out << i << ", ";
return out << "}" << endl;
}
template <typename T, typename G>
ostream& operator<<(ostream& out, const map<T, G>& a) {
out << "< ";
for (const auto& i : a) out << i << ", ";
return out << ">" << endl;
}
template <typename T, size_t N>
typename enable_if<!is_same<typename remove_cv<T>::type, char>::value,
ostream&>::type
operator<<(ostream& out, T (&a)[N]) {
out << "[ ";
for (size_t i = 0; i < N; ++i) out << a[i] << ", ";
out << "]" << endl;
return out;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << (H) << " ";
debug_out(T...);
}
int64_t go(int64_t n) {
int64_t pow = 1, ans = 0;
while (n) {
int64_t d = n % 4;
n /= 4;
int64_t mul = (d == 0 ? d : d % 3 + 1);
ans += (mul * pow);
pow *= 4;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t t;
cin >> t;
while (t--) {
int64_t n, i, ans = 0;
cin >> n;
n--;
int64_t block = n / 3;
int64_t off = n % 3;
int64_t a[3];
for (i = 0;; i++) {
int64_t beg = (1ll << (2 * i));
int64_t end = 2 * beg;
if (end - beg <= block) {
block -= (end - beg);
continue;
}
a[0] = beg + block;
a[1] = end + go(block);
a[2] = a[0] ^ a[1];
ans = a[off];
break;
}
cout << ans << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
while (cin >> s >> t) {
map<char, int> mps;
bool ok = 0;
for (int i(0); i < s.size(); ++i) mps[s[i]]++;
for (int i(0); i < t.size(); ++i) {
--mps[t[i]];
if (mps[t[i]] < 0) {
ok = 1;
puts("need tree");
break;
}
}
if (ok) continue;
if (s.size() == t.size())
puts("array");
else {
int s1 = 0, t1 = 0;
while (t1 < t.size()) {
while (s1 < s.size() && s[s1] != t[t1]) ++s1;
if (s1 == s.size()) break;
++t1;
++s1;
}
if (t1 == t.size()) {
puts("automaton");
} else
puts("both");
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > g[300100];
int dep[300100];
vector<int> op[30];
int ans1;
void dfs(int x, int r) {
dep[x] = r;
for (int i = 0; i < g[x].size(); i++) {
int ver = g[x][i].first;
if (dep[ver] == 0) dfs(ver, r + 1);
}
return;
}
void dfs1(vector<int> p[], int r) {
vector<int> opp[30];
for (int i = 0; i < 26; i++) {
if (p[i].size()) {
for (int j = 0; j < 26; j++) {
opp[j].clear();
}
ans1++;
if (p[i].size() > 1) {
for (int j = 0; j < p[i].size(); j++) {
int ver = p[i][j];
for (int z = 0; z < g[ver].size(); z++) {
int ver1 = g[ver][z].first;
if (dep[ver1] == r + 1) {
ans1--;
opp[g[ver][z].second].push_back(ver1);
}
}
}
}
dfs1(opp, r + 1);
}
}
}
vector<int> v[300100];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v1;
char x;
scanf("%d %d %c", &u, &v1, &x);
int x1 = x - 'a';
g[u].push_back({v1, x1});
g[v1].push_back({u, x1});
}
dfs(1, 1);
for (int i = 1; i <= n; i++) {
v[dep[i]].push_back(i);
}
int ans = n;
int p = 0;
for (int i = 1;; i++) {
if (v[i].size() == 0) break;
ans1 = n;
for (int j = 0; j < v[i].size(); j++) {
int ver = v[i][j];
for (int z = 0; z < 26; z++) {
op[z].clear();
}
for (int z = 0; z < g[ver].size(); z++) {
int ver1 = g[ver][z].first;
if (dep[ver1] == i + 1) {
ans1--;
for (int z1 = 0; z1 < g[ver1].size(); z1++) {
int ver2 = g[ver1][z1].first;
if (dep[ver2] == i + 2) {
ans1--;
op[g[ver1][z1].second].push_back(ver2);
}
}
}
}
dfs1(op, i + 2);
}
if (ans1 < ans) {
ans = ans1;
p = i;
}
}
printf("%d\n%d", ans, p);
return 0;
}
| 12 | CPP |
#include <vector>
#include <iostream>
#include <algorithm>
#pragma warning(disable : 4996)
using namespace std;
int D, Q, x[131072], ls, rs, es; vector<int> seg[262144];
int query1(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return 999999999;
if (a <= l && r <= b) return seg[k].size() ? seg[k][0] : 999999999;
int lc = query1(a, b, 2 * k, l, (l + r) / 2);
int rc = query1(a, b, 2 * k + 1, (l + r) / 2, r);
return min(lc, rc);
}
int query2(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return -999999999;
if (a <= l && r <= b) return seg[k].size() ? seg[k][seg[k].size() - 1] : -999999999;
int lc = query2(a, b, 2 * k, l, (l + r) / 2);
int rc = query2(a, b, 2 * k + 1, (l + r) / 2, r);
return max(lc, rc);
}
int query3(int a, int b, int x1, int x2, int k, int l, int r) {
if (r <= a || b <= l) return 0;
if (a <= l && r <= b) return lower_bound(seg[k].begin(), seg[k].end(), x2) - lower_bound(seg[k].begin(), seg[k].end(), x1);
int lc = query3(a, b, x1, x2, 2 * k, l, (l + r) / 2);
int rc = query3(a, b, x1, x2, 2 * k + 1, (l + r) / 2, r);
return lc + rc;
}
int main() {
scanf("%d", &D);
for (int i = 0; i < D; i++) {
scanf("%d", &x[i]);
int t = i + 131072;
while (t > 0) {
seg[t].push_back(x[i]);
t >>= 1;
}
}
for (int i = 1; i < 262144; i++) {
if (seg[i].size() > 1) {
sort(seg[i].begin(), seg[i].end());
}
}
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
scanf("%d%d%d", &ls, &rs, &es);
int a = min(x[ls - 1], x[rs - 1]);// query1(ls - 1, rs, 1, 0, 131072);
int b = max(x[ls - 1], x[rs - 1]);// query2(ls - 1, rs, 1, 0, 131072);
printf("%d\n", rs - ls + 1 - query3(ls - 1, rs, a - es, b + es + 1, 1, 0, 131072));
}
return 0;
} | 0 | CPP |
from sys import stdin
from sys import setrecursionlimit as SRL; SRL(10**7)
rd = stdin.readline
rrd = lambda: map(int, rd().strip().split())
n = int(rd())
a = list(rrd())
m = int(rd())
b = list(rrd())
for i in range(n):
for j in range(m):
if a[i] + b[j] not in a and a[i] + b[j] not in b:
print(a[i],b[j])
exit(0) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> visited;
vector<vector<pair<int, int>>> G;
long long sum = 0;
long long diff(pair<long long, long long> p) {
return p.first * p.second - p.first * (p.second / 2);
}
struct classcomp {
bool operator()(const pair<long long, long long>& lhs,
const pair<long long, long long>& rhs) const {
return (diff(lhs) > diff(rhs));
}
};
multiset<pair<long long, long long>, classcomp> cont;
long long dfs(int v) {
visited[v] = 1;
long long num = 0;
for (auto i : G[v]) {
if (!visited[i.first]) {
long long curr = dfs(i.first);
cont.insert({curr, i.second});
sum += curr * i.second;
num += curr;
}
}
return (num ? num : 1);
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long S;
cin >> S;
visited.assign(n + 1, 0);
cont.clear();
G.assign(n + 1, vector<pair<int, int>>(0));
sum = 0;
for (int i = 0; i < n - 1; i++) {
int a, b, w;
cin >> a >> b >> w;
G[a].push_back({b, w});
G[b].push_back({a, w});
}
dfs(1);
int moves = 0;
while (sum > S) {
auto rem = cont.begin();
sum -= rem->first * rem->second;
sum += rem->first * (rem->second / 2);
cont.erase(rem);
cont.insert({rem->first, rem->second / 2});
moves++;
}
cout << moves << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a, b, sum[100009], vis[100009], m, n, d, k, mn, mx, ans = 1;
vector<long long> v[100009];
map<long long, long long> mp;
char par[1000009];
int main() {
cin >> n;
mp[n]++;
n++;
while (1) {
if (n % 10 == 0) {
n /= 10;
} else {
if (mp[n] > 0) {
break;
} else {
mp[n]++;
n++;
}
}
}
cout << mp.size();
}
| 7 | CPP |
N = int(input())
As = [int(input()) for _ in range(N)]
if all([a%2==0 for a in As]):
print('second')
else:
print('first') | 0 | PYTHON3 |
n,k=map(int,input().split())
for i in range(k):
if n%10==0:
n=n/10
else:
n=n-1
m=int(n)
print(m)
| 7 | PYTHON3 |
input()
coins = [0] * 100
for c in input().split():
coins[int(c) - 1] += 1
print(max(coins))
| 7 | PYTHON3 |
import sys
input=sys.stdin.readline
T=int(input())
for _ in range(T):
n,x,y=map(int,input().split())
v=y-x
diff=v
npts=0
A=[]
for i in range(n-1,0,-1):
if (v%i==0):
diff=v//i
npts=i
break
for i in range(x,y+1,diff):
A.append(i)
for i in range(x-diff,0,-diff):
if (len(A)>=n):
break
A.append(i)
for i in range(y+diff,(10**9)+1,diff):
if (len(A)>=n):
break
A.append(i)
print(*A)
| 9 | PYTHON3 |
import sys
# sys.setrecursionlimit(200005)
int1 = lambda x: int(x)-1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
# inf = 10**16
inf = 10**4*(1 << 10)
md = 10**9+7
# md = 998244353
def ok():
s = SI()
n = len(s)
si = s.find("a")
if si == -1: return False
l, r = si-1, si+1
c = 98
while c-97 < n:
if l >= 0 and s[l] == chr(c):
l -= 1
elif r < n and s[r] == chr(c):
r += 1
else:
return False
c += 1
return True
for testcase in range(II()):
print("YES" if ok() else "NO")
| 8 | PYTHON3 |
import sys
chars='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'
mp={}
for i in range(len(chars)):
mp[chars[i]]=i
zero=0
s=sys.stdin.readline()
for i in range(len(s)-1):
zero+=sum([i=='0' for i in format(mp[s[i]],'06b')])
sys.stdout.write(str(pow(3,zero,int(1e9+7))))
| 9 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
seen = []
for i in arr:
if i not in seen:
seen.append(i)
print(*seen) | 8 | PYTHON3 |
n=int(input())
if n>0:
print(n)
else:
n=str(0-n)
l=[n[0:-2]+n[-1],n[0:-1]]
for j in l:
if j[0]=='0' and int(j)!=0:
l.remove(j)
l=list(map(int,l))
print(0-min(l)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
struct Tnode {
int l, r, key;
} T[524288];
int N;
void build(int i, int l, int r) {
int mid;
T[i].l = l;
T[i].r = r;
T[i].key = 0;
if (l < r) {
mid = (l + r) / 2;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
}
}
void init(int n) {
N = 1 << int(ceil(log(n) / log(2)));
build(1, 1, N);
}
void modify(int i, int x, int d) {
int mid;
if (T[i].l == T[i].r)
T[i].key = d;
else {
mid = (T[i].l + T[i].r) / 2;
if (x <= mid)
modify(i * 2, x, d);
else
modify(i * 2 + 1, x, d);
T[i].key = max(T[i * 2].key, T[i * 2 + 1].key);
}
}
int query(int i, int l, int r) {
int mid, ans;
if (l > r) return 0;
if ((T[i].l >= l) && (T[i].r <= r)) return T[i].key;
mid = (T[i].l + T[i].r) / 2;
ans = 0;
if (l <= mid) ans = max(ans, query(i * 2, l, r));
if (r >= mid + 1) ans = max(ans, query(i * 2 + 1, l, r));
return ans;
}
} S1, S2;
priority_queue<int, deque<int>, greater<int> > Q;
int a[200100], b[200100];
int seq[15];
int n, m;
int main() {
int i, j, x, y, z, len;
scanf("%d%d", &n, &m);
S1.init(n);
S2.init(m + 50);
for (i = 1; i <= m; i++) {
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &y, &z);
z += m - i;
a[y] = z;
b[z] = y;
for (j = m - i; j <= z - 1; j++)
if (b[j]) S1.modify(1, b[j], 0);
len = S1.query(1, y + 1, S1.N) + 1;
S1.modify(1, y, len);
S2.modify(1, z, len);
for (j = z - 1; j >= m - i; j--)
if (b[j]) {
len = S1.query(1, b[j] + 1, S1.N) + 1;
S1.modify(1, b[j], len);
S2.modify(1, j, len);
}
Q.push(y);
} else {
scanf("%d", &y);
for (j = 1; j <= y - 1; j++) {
seq[j] = Q.top();
Q.pop();
S2.modify(1, a[seq[j]], 0);
}
z = Q.top();
Q.pop();
b[a[z]] = 0;
S1.modify(1, z, 0);
S2.modify(1, a[z], 0);
for (j = y - 1; j >= 1; j--) {
len = S2.query(1, a[seq[j]] + 1, S2.N) + 1;
S2.modify(1, a[seq[j]], len);
S1.modify(1, seq[j], len);
Q.push(seq[j]);
}
}
printf("%d\n", S1.T[1].key);
}
return 0;
}
| 11 | CPP |
score= [int(input()) for _ in range(6)]
print(sum(sorted(score[:4], reverse=True)[:3])+max(score[4], score[5])) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct sort_pred {
bool operator()(const std::pair<int, int> &left,
const std::pair<int, int> &right) {
return left.second < right.second;
}
};
int gcd(int a, int b) { return (a == 0) ? b : gcd(b % a, a); }
long long powmod(long long a, long long b) {
if (b == 0) return 1;
long long x = powmod(a, b / 2);
long long y = (x * x) % 1000000007;
if (b % 2) return (a * y) % 1000000007;
return y % 1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
pair<int, int> a[5001];
cin >> n;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
int u, v;
cin >> u >> v;
a[i] = make_pair(u, v);
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] == a[i + 1]) {
int j = i;
while (a[j].first == a[j + 1].first) j++;
sort(a + i, a + j + 1, sort_pred());
i = j;
}
}
int ans = min(a[0].first, a[0].second);
for (__typeof(n) i = (1) - ((1) > (n)); i != (n) - ((1) > (n));
i += 1 - 2 * ((1) > (n))) {
if (a[i].second >= ans)
ans = a[i].second;
else
ans = a[i].first;
}
cout << ans << "\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#define rep(a, b, c) for(int a = (b); a <= (c); ++ a)
#define per(a, b, c) for(int a = (b); a >= (c); -- a)
using namespace std;
const int maxn = 2e5 + 5;
int n;
char s[maxn];
struct automaton{
int son[maxn][26], lst[maxn];
int dp[maxn], nxt[maxn];
void build(){
per(i, n, 0){
rep(j, 0, 25) son[i][j] = lst[j];
lst[s[i] - 'a'] = i;
}
}
void dfs(int u){
printf("%c", 'a' + nxt[u]);
if(dp[u] == 0) return ;
dfs(son[u][nxt[u]]);
}
void sol(){
per(i, n, 0){
dp[i] = n;
rep(j, 0, 25){
if(son[i][j] == 0){
dp[i] = 0;
nxt[i] = j;
break;
}
else{
if(dp[son[i][j]] + 1 < dp[i]){
dp[i] = dp[son[i][j]] + 1;
nxt[i] = j;
}
}
}
}
dfs(0);
puts("");
}
}am;
int main(){
scanf("%s", s + 1);
n = strlen(s + 1);
am.build();
am.sol();
return 0;
}
| 0 | CPP |
#include <iostream>
#include <string>
using namespace std;
int main() {
int k; cin >> k;
string s; cin >> s;
cout << (k < s.size() ? s.substr(0, k) + "..." : s) << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
char str[11111];
char space = false;
for (; scanf("%s", str) == 1;) {
int len = strlen(str);
char isWord = false;
for (int i = 0; i < len; ++i) {
if (str[i] >= 'a' && str[i] <= 'z' || str[i] >= 'A' && str[i] <= 'Z') {
if (isWord)
printf("%c", str[i]);
else {
if (space) printf(" ");
printf("%c", str[i]);
isWord = true;
space = true;
}
} else {
printf("%c ", str[i]);
space = false;
isWord = false;
}
}
}
}
int main() {
solve();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long OO = 1e8;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
int n = 0, m = 0, x = 0, q = 0, r = 0;
char c;
char arr[31][31];
vector<pair<int, int>> vec;
map<char, bool> ma;
map<char, bool> ex;
map<char, bool> vis;
bool valid(int i, int j) {
if (i < n && i >= 0 && j < m && j >= 0) {
return 1;
} else {
return 0;
}
}
void dfs(int a, int y, int px, int py, int m) {
if (valid(a, y) && ((px - a) * (px - a)) + ((py - y) * (py - y)) <= x * x) {
}
if (((px - a) * (px - a)) + ((py - y) * (py - y)) > x * x || !valid(a, y) ||
vis[char(arr[a][y])] == 1) {
} else {
vis[char(arr[a][y])] = 1;
ma[char(arr[a][y] - 32)] = 1;
m++;
dfs(a + 1, y, px, py, m);
dfs(a - 1, y, px, py, m);
dfs(a, y + 1, px, py, m);
dfs(a, y - 1, px, py, m);
dfs(a + 1, y + 1, px, py, m);
dfs(a - 1, y - 1, px, py, m);
dfs(a - 1, y + 1, px, py, m);
dfs(a + 1, y - 1, px, py, m);
}
}
int main() {
cin >> n >> m >> x;
for (int i = 0; i < (int)(n); ++i)
for (int p = 0; p < (int)(m); ++p) {
cin >> arr[i][p];
ex[arr[i][p]] = 1;
if (arr[i][p] == 'S') {
vec.push_back(make_pair(i, p));
}
}
for (int i = 0; i < ((int)((vec).size())); ++i)
for (int z = 0; z < (int)(x); ++z) {
vis.clear();
dfs(vec[i].first, vec[i].second, vec[i].first, vec[i].second, 1);
}
cin >> q;
for (int i = 0; i < (int)(q); ++i) {
cin >> c;
if (int(c) >= 65 && int(c) <= 90) {
if (((int)((vec).size())) == 0 || !ex[char(c + 32)]) {
cout << -1;
return 0;
}
if (!ma[c]) {
r++;
}
} else {
if (ex[c] == 0) {
cout << -1;
return 0;
}
}
}
cout << r;
return 0;
}
| 8 | CPP |
w = int(input())
if w >=1 and w <= 100:
if w % 2 == 0 and w != 2:
print("YES")
else:
print("NO")
else:
print('Error') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
printf("%d\n", n);
for (int i = 1; i <= n; ++i) printf("%d ", i);
puts("");
}
return 0;
}
| 7 | CPP |
word = input()
if len(word) == 1:
if word.islower():
word = word.upper()
elif word.isupper():
word = word.lower()
elif word.isupper():
word = word.lower()
else:
if word[1:len(word):1].isupper():
word = word [0].upper() + word[1:len(word):1].lower()
print(word) | 7 | PYTHON3 |
import math
t = int(input())
for _ in range(t):
n = int(input())
ans = []
while n != 2:
s = int(math.ceil(math.sqrt(n)))
for j in range(s + 1, n):
ans.append((j, n))
ans.append((n, s))
ans.append((n, s))
n = s
print(len(ans))
for i in ans:
print(i[0], i[1])
| 10 | PYTHON3 |
s1=input()
s2=input()
s3=input()
s4=input()
l1=len(s1)-2
l2=len(s2)-2
l3=len(s3)-2
l4=len(s4)-2
ll=[[l1,"A"],[l2,"B"],[l3,"C"],[l4,"D"]]
ll.sort()
if(ll[0][0]<=ll[1][0]/2 and ll[-1][0]>=ll[-2][0]*2):
print("C")
elif(ll[0][0]<=ll[1][0]/2):
print(ll[0][1])
elif(ll[-1][0]>=ll[-2][0]*2):
print(ll[-1][1])
else:
print("C") | 7 | PYTHON3 |
n, m = map(int,input().split())
astr = input().split()
mina = int(astr[0])
maxa = int(astr[0])
for s in astr:
temp = int(s)
if temp < mina:
mina = temp
elif temp > maxa:
maxa = temp
res = max(maxa, 2*mina)
b = [int(x) for x in input().split()]
minb = min(b)
if minb<=res:
print(-1)
else:
print(res) | 7 | PYTHON3 |
n, k, l = map(int, input().split())
ps = input().split()
r = 0
for p in ps:
if p == '1':
if k > 0:
k -= 1
else:
r += 1
elif p == '2':
if l > 0:
l -= 1
elif k > 0:
k -= 1
else:
r += 1
print(r)
| 7 | PYTHON3 |
for i in range(int(input())):
a,b=map(int,input().split())
c,d=map(int,input().split())
x=abs(a-b)
y=min(a,b)
z=a+b
print(min(c*x +d*y,z*c)) | 7 | PYTHON3 |
#include <iostream>
#define int long long
using namespace std;
int n;
int c[1000];
int q;
int t[100000], x[100000], d[100000];
int cnt[1000];
signed main() {
int i;
cin >> n;
for (i = 0; i < n; i++) cin >> c[i];
cin >> q;
for (i = 0; i < q; i++) {
cin >> t[i] >> x[i] >> d[i]; x[i]--;
}
for (i = 0; i < q; i++) {
if (t[i] == 1) { cnt[x[i]] += d[i]; }
else { cnt[x[i]] -= d[i]; }
if (cnt[x[i]] > c[x[i]] || cnt[x[i]] < 0) {
cout << x[i] + 1 << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
| 0 | CPP |
s=input()
l=[]
for i in range(len(s)):
if i%2==0:
l.append(s[i])
l.sort()
# if len(l)==1:
# print(l[0])
# else:
for i in range(len(l)):
if i<len(l)-1:
print(l[i],"+",sep="",end="")
else:
print(l[i]) | 7 | PYTHON3 |
w = int(input())
if 100>=w>2 and w%2==0:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int x;
scanf("%d", &x);
int a[x];
for (int i = 1; i <= x; i++) {
scanf("%d", &a[i]);
}
int n = 0, t = 0, l = 0;
int r = 1, j = 2, k = 3;
while (r <= x) {
n += a[r];
r += 3;
}
while (j <= x) {
t += a[j];
j += 3;
}
while (k <= x) {
l += a[k];
k += 3;
}
if (n > t && n > l) {
printf("chest");
} else if (t > n && t > l) {
printf("biceps");
} else if (l > t && l > n) {
printf("back");
}
return 0;
}
| 7 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef long long ll;
typedef pair<int,int> P;
int main(){
int n,m,a[200001],b[200001],c[1001][13];
cin>>n>>m;
rep(i,m){
cin>>a[i]>>b[i];
rep(j,b[i]) cin>>c[i][j];
}
int dp[1<<n],INF=1e9;
fill(dp,dp+(1<<n),INF);
dp[(1<<n)-1]=0;
for(int i=(1<<n)-2;i>=0;i--)rep(j,m){
int x=0;
rep(k,b[j]) x=x|1<<c[j][k]-1;
if(~i&x) dp[i]=min(dp[i],dp[i|x]+a[j]);
}
if(dp[0]==INF) cout<<-1;
else cout<<dp[0];
} | 0 | CPP |
import sys
def swap(x, y, a):
temp = a[x]
a[x] = a[y]
a[y] = temp
return a
def solve():
return None
def main():
q = []
for line in sys.stdin.readlines():
q.append(line)
for i in range(len(q)):
q[i] = q[i].rstrip().split(' ')
q[i] = [int(x) for x in q[i]]
for i in range(1, len(q),2):
flags = q[i][0]
road = q[i][1]
a = q[i+1]
# print(flags, road, a)
da = 0 # distance a
db = road
time = 0
ma = 1 # mps for a
mb = 1
ta = 0 # time to next flag
tb = 0
i = 0 # index for flags
j = len(a) -1 # index for flags in reverse
prev_i = 0
prev_j = road
temp = 0
# check has intersected yet or has not intersected yet
while (i <= j):
da = a[i] - prev_i
db = prev_j - a[j]
ta = da / ma # ma = m/s; ta = time traveled
tb = db / mb
# if time to next flagpost is the same
if ta == tb:
time += (1 / ma * da)
# increment mps
ma+=1
mb+=1
# prev location / # distance travelled until next flapost
prev_i = a[i]
prev_j = a[j]
# increment pointers
i+=1
j-=1
if (prev_i > prev_j):
prev_i -= da
prev_j += db
break
# if A got there faster than B
elif ta < tb:
temp = (1 / ma * da)
time += temp
ma += 1
prev_i = a[i]
prev_j -= (temp * mb) # distance traveled by a timesspeed of b
i+=1
if (prev_i > prev_j):
prev_i -= da
prev_j -= (temp * mb)
break
else: # do a only, not b
temp = (1 / mb * db)
time += temp
mb+=1
prev_j = a[j]
prev_i += (temp * ma)
j-=1
if (prev_i > prev_j):
prev_i -= (temp * ma)
prev_j -= db
break
# this means that we crossed so maintain speed until we reach each other
# print(i, j, time, prev_i, prev_j, ma, mb)
# if i >= j:
# add distance left divided by time both cards take to see each other
time += ( (prev_j - prev_i) / (ma + mb) )
# this means that the distance exceeded each other
print(time)
# solve(q[i])
if __name__ == '__main__':
main() | 9 | PYTHON3 |
#include <cstdio>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <algorithm>
#include <cmath>
#include <queue>
#include <map>
#include <set>
#include <cstdlib>
#include <bitset>
#include <tuple>
#include <assert.h>
#include <deque>
#include <bitset>
#include <iomanip>
#include <limits>
#include <chrono>
#include <random>
#include <array>
#include <unordered_map>
#include <functional>
#include <complex>
#include <numeric>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
//constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 60;
constexpr int inf = 1000000007;
constexpr long long mod = 1000000007LL;
//constexpr long long mod = 998244353LL;
const long double PI = acos((long double)(-1));
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
void solve() {
int n, l; cin >> n >> l; if (n == 0) exit(0);
vector<int> d(n), p(n);
for (int i = 0; i < n; i++) {
char c; cin >> c >> p[i];
if (c == 'R') d[i] = 1;
else d[i] = -1;
}
int lv = 0;
int lp = p[0];
for (int t = 1;; t++) {
for (int i = 0; i < n; i++) {
p[i] += d[i];
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (p[i] == p[j]) {
d[i] *= -1;
d[j] *= -1;
}
}
}
bool ok = true;
for (int i = 0; i < n; i++) {
if (p[i] > 0 and p[i] < l) {
ok = false;
}
}
if (ok) {
cout << t << " "<< lv + 1 <<"\n";
return;
}
else {
lv = -1;
lp = inf;
for (int i = 0; i < n; i++) {
if (p[i] > 0 and p[i] < l) {
if (chmin(lp, p[i])) {
lv = i;
}
else if (lp == p[i] and d[i] == -1) lv = i;
}
}
}
}
}
int main()
{
cin.tie(nullptr);
ios::sync_with_stdio(false);
int kkt = 89;
while (kkt) {
solve();
}
return 0;
}
| 0 | CPP |
a = [0] * 100
a[0]= 1
a[1]= 2
a[2]= 4
a[3]= 8
a[4]= 16
a[5]= 32
a[6]= 64
a[7]= 128
a[8]= 256
a[9]= 512
a[10 ]=1024
a[11 ]=2048
a[12 ]=4096
a[13 ]=8092
a[14 ]=16184
a[15 ]=32368
a[16 ]=64736
a[17 ]=129472
a[18 ]=258944
a[19 ]=517888
a[20 ]=1035776
a[21 ]=2071552
a[22 ]=4143104
a[23 ]=8286208
a[24 ]=16572416
a[25 ]=33144832
a[26 ]=66289664
a[27 ]=132579328
a[28 ]=265158656
a[29 ]=530317312
a[30 ]=1060634624
a[31 ]=2121269248
a[32 ]=4242538496
a[33 ]=8485076992
a[34 ]=16970153984
a[35 ]=33940307968
n = int(input())
print(a[n])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1234567;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, val, flag = 0;
cin >> n;
long long ans = 1e18;
for (int i = 1; i <= n; i++) {
int val = (n / i) + (n % i > 0);
ans = min(ans, 1ll * 2 * (i + val));
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
n = int(input())
count = 0
d = {"Tetrahedron":4,"Cube":6,"Octahedron":8,"Dodecahedron":12,"Icosahedron":20}
face = 0
shape_list=[]
while count < n :
k = input()
shape_list.append(k)
count+=1
for a in shape_list :
face += d[a]
print (face)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace red {
inline long long read() {
long long x = 0;
char ch, f = 1;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') f = 0, ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return f ? x : -x;
}
const long long N = 2e5 + 10, inf = 1ll << 60;
long long n, tmp[N];
struct node {
long long x, y;
} s[N];
inline bool cmp(const node &a, const node &b) {
return a.x == b.x ? a.y < b.y : a.x < b.x;
}
inline bool cmps(const long long &a, const long long &b) {
return s[a].y < s[b].y;
}
inline long long dist(long long i, long long j) {
return (s[i].x - s[j].x) * (s[i].x - s[j].x) +
(s[i].y - s[j].y) * (s[i].y - s[j].y);
}
inline long long solve(long long l, long long r) {
long long d = inf;
if (l == r) return d;
if (l + 1 == r) return dist(l, r);
long long mid = (l + r) >> 1;
long long d1 = solve(l, mid);
long long d2 = solve(mid + 1, r);
d = min(d1, d2);
long long top = 0;
for (long long i = l; i <= r; ++i)
if ((s[mid].x - s[i].x) * (s[mid].x - s[i].x) <= d) tmp[++top] = i;
sort(tmp + 1, tmp + top + 1, cmps);
for (long long i = 1; i <= top; ++i)
for (long long j = i + 1;
j <= top &&
(s[tmp[j]].y - s[tmp[i]].y) * (s[tmp[j]].y - s[tmp[i]].y) < d;
++j)
d = min(d, dist(tmp[i], tmp[j]));
return d;
}
inline void main() {
n = read();
for (long long i = 1; i <= n; ++i) {
s[i].x = i, s[i].y = s[i - 1].y + read();
}
printf("%lld\n", solve(1, n));
}
} // namespace red
signed main() {
red::main();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using dd = long double;
namespace {
static bool constexpr dbg = 0;
ll constexpr N = -999;
ll n;
void solve() {
cin >> n;
ll const k = n / 2 + 1;
cout << k << '\n';
int x = 1, y = 1;
for (ll _ = 0, ii_ = (n); _ < ii_; ++_) {
cout << x << ' ' << y << '\n';
if (y < k)
++y;
else
++x;
}
}
} // namespace
int main() {
if (!dbg) {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
cout << fixed << setprecision(20);
solve();
return 0;
}
| 8 | CPP |
from collections import deque as d
n,m,q=int(input()),0,d()
for i in map(int, input().split()):
if q:
if i == q[-1]:q.pop()
elif i > q[-1]:q.append(i);break
else:q.append(i)
else:q.append(i)
m=max(m,i)
if len(q)==0 or len(q)==1 and q[0]==m:print('YES')
else:print('NO') | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
const long long int mod = 1000000007;
long long int f(long long int x, long long int k) {
long long int res = 1;
while (k) {
if (k & 1) res = res * x % mod;
x = x * x % mod;
k >>= 1;
}
return res;
}
int main() {
cin >> n;
n++;
if (n == 1)
cout << "1";
else {
long long int a = f(4, n - 2);
long long int b = f(2, n - 2);
a = a * 2 % mod;
cout << (a + b) % mod;
}
return 0;
}
| 7 | CPP |
s = input()
t = s
has_ab = has_ba = False
if 'AB' in t:
has_ab = True
t = t.replace('AB', ' ', 1)
if 'BA' in t:
has_ba = True
if not (has_ab and has_ba):
has_ab = has_ba = False
if 'BA' in s:
has_ba = True
s = s.replace('BA', ' ', 1)
if 'AB' in s:
has_ab = True
print('YES' if has_ab and has_ba else 'NO') | 7 | PYTHON3 |
################### <---------------------- Quicksilver_ ---------------------> ####################
n,m=[int(i) for i in input().split()]
arr=[]
for i in range(n):
l=[a for a in input()]
arr.append(l)
row=set()
col=set()
for i in range(n):
for j in range(m):
if arr[i][j]=='S':
row.add(i)
col.add(j)
print(n*m-len(row)*len(col))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
string st;
cin >> st;
for (int i = 0; i < st.size() / 2; ++i) {
if (st[i] != st[st.size() - 1 - i]) ++ans;
}
if (st.size() % 2 == 1 && ans == 0)
cout << "YES" << endl;
else if (ans == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 7 | CPP |
a=input()
count=0;
n=len(a)
for i in range(0,len(a)):
if ord(a[i])<91:
count+=1;
if count>n/2:
print(a.upper())
else:
print(a.lower()) | 7 | PYTHON3 |
n = int(input())
l = []
for _ in range(n):
l1 = list(input().split())
l.append(l1)
for i in l:
if int(i[1]) >= 2400 and int(i[2]) - int(i[1]) > 0:
print('YES')
exit()
print('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
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];
sort(a, a + n);
for (int i = 0; i < n; ++i) cout << a[i] << " ";
return 0;
}
| 7 | CPP |
# https://codeforces.com/problemset/problem/388/A
# n = int(input())
# arr = list(map(int, input().split()))
# arr = sorted(arr, reverse=True)
# i = 0
# c = 0
# while i < n - 1:
# s = sum(arr[i + 1:])
# j = n - 1
# while s >= arr[i]:
# print(i, j)
# s -= arr[j]
# j -= 1
# i = j + 1
# c += 1
# print(c)
n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
k = 0
for i in range(n):
if k * (a[i] + 1) <= i:
k += 1
print(k)
| 9 | PYTHON3 |
import sys
input=sys.stdin.readline
l= list(map(int,input().split()))
n=l[0]
m=l[1]
list1={}
l1=[]
dict={}
for i in range(m):
dict[i]={}
for i in range(n):
s=input()
for j in range(m):
dict[j][s[j]]=dict[j].get(s[j],0)+1
# print(dict)
for j in range(m):
max1=0
for k in dict[j]:
max1=max(max1,dict[j][k])
l1.append(max1)
l2= list(map(int,input().split()))
ans=0
# print(l1)
for j in range(m):
ans+=l2[j]*l1[j]
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
vector<int> g[N], h[N];
int din[N], dout[N];
int n, m, k, r[N];
int ma[N], mi[N];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", r + i);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
h[v].push_back(u);
dout[u]++;
din[v]++;
}
stack<int> st;
for (int i = 1; i <= n; i++) {
if (din[i] == 0) st.push(i);
}
vector<int> topo;
while (!st.empty()) {
int v = st.top();
st.pop();
topo.push_back(v);
for (int u : g[v]) {
din[u]--;
if (din[u] == 0) st.push(u);
}
}
for (int i = 1; i <= n; i++) {
if (r[i] == 0)
ma[i] = k, mi[i] = 1;
else
ma[i] = mi[i] = r[i];
}
if (topo.size() != n) {
puts("-1");
return 0;
}
for (int v : topo) {
for (int u : g[v]) {
ma[u] = min(ma[u], ma[v] - 1);
}
}
for (int i = n - 1; i >= 0; i--) {
int v = topo[i];
for (int u : g[v]) mi[v] = max(mi[v], mi[u] + 1);
}
for (int i = 1; i <= n; i++) {
if (ma[i] < mi[i]) {
puts("-1");
return 0;
}
}
set<int> col;
for (int i = 1; i <= k; i++) {
col.insert(i);
}
set<pair<int, int> > sst;
for (int i = 1; i <= n; i++)
if (dout[i] == 0) {
sst.insert(make_pair(ma[i], i));
}
while (!sst.empty()) {
auto it = sst.begin();
int v = it->second;
sst.erase(it);
r[v] = mi[v];
for (int u : g[v]) {
r[v] = max(r[v], r[u] + 1);
}
auto rm = col.lower_bound(r[v]);
if (rm != col.end() && *rm <= ma[v]) {
r[v] = *rm;
}
col.erase(r[v]);
for (int u : h[v]) {
dout[u]--;
if (dout[u] == 0) sst.insert(make_pair(ma[u], u));
}
}
if (!col.empty())
puts("-1");
else {
for (int i = 1; i <= n; i++) printf("%d%c", r[i], i == n ? '\n' : ' ');
}
return 0;
}
| 8 | CPP |
N = int(input())
A = list(map(int, input().split()))
count = 0
sum = 0
for i in range(N-1):
if sum * (A[i+1]-A[i]) >= 0:
sum += A[i+1] - A[i]
else:
count += 1
sum = 0
print(count+1)
| 0 | PYTHON3 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class t>
using table = vector<vector<t>>;
const ld eps = 1e-9;
const int mod = 1000003;
struct Mod {
public:
int num;
Mod() : Mod(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) {
static_assert(mod<INT_MAX / 2, "mod is too big, please make num 'long long int' from 'int'");
}
Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator+(const Mod a, const long long int b) { return b + a; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator*(const long long int a, const Mod b) { return Mod(a)*b; }
Mod operator*(const Mod a, const long long int b) { return Mod(b)*a; }
Mod operator*(const Mod a, const int b) { return Mod(b)*a; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator*=(Mod& a, const long long int &b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
Mod mod_pow(const Mod a, const long long int n) {
if (n == 0) return Mod(1);
Mod res = mod_pow((a * a), (n / 2));
if (n % 2) res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) {
return Mod(a) / b;
}
Mod operator/=(Mod &a, const Mod b) {
return a = a / b;
}
#define MAX_MOD_N 1024000
Mod fact[MAX_MOD_N], factinv[MAX_MOD_N];
void init(const int amax = MAX_MOD_N) {
fact[0] = Mod(1); factinv[0] = 1;
for (int i = 0; i < amax - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
long long int gcd(long long int l, long long int r) {
assert(l > 0 && r > 0);
if (l > r)return gcd(r, l);
else {
const long long int num = r%l;
if (num) {
return gcd(l, num);
}
else {
return l;
}
}
}
Mod dp[1002][1002][2];
int main() {
while (1) {
int N, K; cin >> N >> K;
if (!N)break;
for (int i = 0; i < 1002; ++i) {
for (int j = 0; j < 1002; ++j) {
for (int k = 0; k < 2; ++k) {
dp[i][j][k] = 0;
}
}
}
dp[1][1][0] = 1;
for (int i = 1; i <= 1000; ++i) {
for (int j = 1; j <= 1000; ++j) {
for (int k = 0; k < 2; ++k) {
if (j + 1 <= K) {
dp[i + 1][j + 1][k] += dp[i][j][k];
}
dp[i + 1][1][!k] += dp[i][j][k];
}
}
}
Mod ans = 0;
for (int l = 0; l < N; ++l) {
int num;
if (l)num = gcd(l, N);
else num = N;
Mod nans = 0;
for (int i = 0; i < min(num,K); ++i) {
for (int j = 1; j <= min(num,K-i); ++j) {
nans += dp[num - i][j][1];
}
}
ans += nans;
}
ans *= 2;
ans /= N;
if (N <= K)ans += 2;
cout << ans << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
struct Edge {
int to, c, id;
};
int N, M, ans[MX], sum[MX], done[MX];
pair<int, int> edge[MX];
vector<Edge> E[MX];
inline void set_edge(int u, int v, int i) {
assert((edge[i].first == u and edge[i].second == v) or
(edge[i].first == v and edge[i].second == u));
if (edge[i].first == u)
ans[i] = 0;
else
ans[i] = 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> N >> M;
for (int i = (1); i <= (M); i++) {
int a, b, c;
cin >> a >> b >> c;
E[a].push_back({b, c, i});
E[b].push_back({a, c, i});
edge[i] = {a, b};
sum[a] += c;
sum[b] += c;
}
for (int i = (1); i <= (N); i++) sum[i] /= 2;
queue<int> que;
que.push(1);
done[1] = 1;
while (!que.empty()) {
int u = que.front();
que.pop();
for (auto it : E[u]) {
int v = it.to, c = it.c, id = it.id;
if (done[v]) continue;
set_edge(u, v, id);
sum[v] -= c;
if (v != 1 and v != N and sum[v] == 0) {
que.push(v);
done[v] = 1;
}
}
}
for (int i = (1); i <= (M); i++) cout << ans[i] << "\n";
return 0;
}
| 11 | CPP |
A,B,C,X,Y=map(int,input().split())
v=10**10
for i in range(0,max(X,Y)*2+2):
v=min(v,A*max(X-i,0)+B*max(Y-i,0)+C*i*2)
print(v) | 0 | PYTHON3 |
n, m = map(int, input().split())
if m == 0:
print(n, n)
exit(0)
if m == n * (n - 1) // 2:
print(0, 0)
exit(0)
L = 0
R = n + 1
while R - L > 1:
m1 = (L + R) // 2
if m1 * (m1 - 1) // 2 < m:
L = m1
else:
R = m1
ans_max = n - R
ans_min = max(0, n - 2 * m)
print(ans_min, ans_max) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int U[202];
int match(pair<int, int> x, pair<int, int> y) {
int ret = 0;
if (x.first < y.first && y.first < x.second) ret++;
if (x.first < y.second && y.second < x.second) ret++;
return ret % 2;
}
void solve() {
int n, k;
cin >> n >> k;
vector<pair<int, int>> E;
vector<int> v;
for (int i = 1; i <= 2 * n; i++) U[i] = 0;
for (int i = 1; i <= k; i++) {
int x, y;
cin >> x >> y;
if (x > y) swap(x, y);
E.push_back({x, y});
U[x] = 1;
U[y] = 1;
}
for (int i = 1; i <= 2 * n; i++) {
if (!U[i]) v.push_back(i);
}
int m = v.size();
for (int i = 0; i < m / 2; i++) {
E.push_back({v[i], v[i + m / 2]});
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans += match(E[i], E[j]);
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 9 | CPP |
n = int(input())
s = ''
for i in range(n):
s += input()
if s == ''.join(list(reversed(s))) and s.count(s[0]) == (n*2) - 1:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long ans = n / 2LL / (k + 1LL);
cout << ans << " " << k * ans << " " << n - k * ans - ans << endl;
return 0;
}
| 7 | CPP |
n = int(input())
a = list(input())
left = 0
right = 0
for i in range(0, n):
if (a[i] == '<'):
left += 1
else:
break
for i in reversed(range(0, n)):
if (a[i] == '>'):
right += 1
else:
break
print(left + right) | 7 | PYTHON3 |
t=int(input())
import math
while t:
t-=1
n=int(input())
a=[int(i) for i in input().split()]
a.sort()
ans=[]
ans.append(a[n-1])
del a[n-1]
curg=ans[0]
while len(a):
ma=0
inl=0
flag=0
mi=1
for i in range(len(a)):
if math.gcd(curg,a[i])>mi:
ma=a[i]
inl=i
mi=math.gcd(curg,a[i])
flag+=1
if flag==0:
break
else:
ans.append(ma)
del a[inl]
curg=math.gcd(curg,ans[-1])
ans+=a
print(*ans,sep=" ")
| 8 | PYTHON3 |
import math
N,X = map(int,input().split())
xl = [abs(x-X)for x in map(int,input().split())]
ans = xl[0]
for x in xl[1:]:
ans = math.gcd(ans,x)
print(ans) | 0 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 18;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
| 12 | CPP |
def main():
n = int(input())
_input = list(map(int, input().split()))
_start = _input[0]
_end = _input[1]
Alexey = []
for _ in range(_start, _end):
Alexey.append(0)
for _ in range(n - 1):
_input = list(map(int, input().split()))
start = _input[0]
end = _input[1]
for _index in range(start - _start, end - _start):
if _index >=0 and _index < len(Alexey):
Alexey[_index] = 1
# print(Alexey)
print(Alexey.count(0))
if __name__ == '__main__':
main() | 7 | PYTHON3 |
n = int(input())
for item in range(n):
k = list(map(int,input().split()))
print(sum(k)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000010;
int n, ans, q[N], x[N], y[N];
struct node {
int a, b, m, id;
};
vector<node> a[N];
bool cmp(node x, node y) { return x.a < y.a; }
void Work() {
scanf("%d", &n);
for (int i = 1, x, y, z; i <= n; i++) {
scanf("%d%d%d", &x, &y, &z);
a[x + y - z].push_back((node){x, y, z, i});
q[i] = x + y - z;
}
ans = 0;
for (int i = 1; i <= n; i++)
if (a[q[i]].size()) {
sort(a[q[i]].begin(), a[q[i]].end(), cmp);
for (int j = 0, px = -1e9; j < (int)a[q[i]].size(); j++) {
node b = a[q[i]][j];
if (b.b < q[i] - px) px = min(b.a, q[i]), ans++;
x[b.id] = b.a - px;
y[b.id] = b.m - x[b.id];
}
a[q[i]].clear();
}
cout << ans << "\n";
for (int i = 1; i <= n; i++) cout << x[i] << " " << y[i] << "\n";
}
int main() {
int T = 1;
scanf("%d", &T);
while (T--) Work();
return 0;
}
| 14 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int N = 2019;
char m[N][N];
int f[N], d[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", m[i]);
int ans = 0;
for (int i = 0; i < n; i++) {
int inv = 0;
for (int j = n - 1; j > i; j--) {
if ((inv ^ f[j]) != m[i][j] - '0') {
fprintf(stderr, "%d %d\n", i, j);
ans++;
inv ^= 1;
f[j] ^= 1;
}
}
d[i] = inv ^ f[i];
}
memset(f, 0, sizeof(f));
for (int i = n - 1; i >= 0; i--) {
int inv = 0;
for (int j = 0; j < i; j++) {
if ((inv ^ f[j]) != m[i][j] - '0') {
fprintf(stderr, "%d %d\n", i, j);
ans++;
inv ^= 1;
f[j] ^= 1;
}
}
d[i] ^= inv ^ f[i];
}
for (int i = 0; i < n; i++) {
ans += (d[i] != m[i][i] - '0');
if (d[i] != m[i][i] - '0') fprintf(stderr, "%d %d\n", i, i);
}
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, i, t, n, a[100005];
int u[100005], v[100005];
cin >> n;
for (__typeof(0) i = 0; i <= n - 1 - 1; i++) {
cin >> x >> y;
u[i + 1] = (y);
v[i + 1] = (x);
}
for (__typeof(0) i = 0; i <= n - 1; i++) {
cin >> a[i + 1];
}
int roots = 0;
int root[100005];
for (__typeof(0) i = 0; i <= n - 1 - 1; i++) {
if (a[u[i + 1]] != a[v[i + 1]]) {
roots++;
root[u[i + 1]]++;
root[v[i + 1]]++;
}
}
for (__typeof(0) i = 0; i <= n - 1; i++) {
if (root[i + 1] == roots) {
cout << "YES" << '\n' << i + 1;
return 0;
}
}
cout << "NO" << '\n';
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
if (s1 == s2)
cout << -1;
else if (s1.size() >= s2.size())
cout << s1.size();
else
cout << s2.size();
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int n, a[N], b[N], vi[N][N];
bool com(int x, int y) { return a[x] < a[y]; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) b[i] = i;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(b + 1, b + n + 1, com);
for (int i = 1; i <= n + 1; i++) {
int x = a[b[i]];
for (int j = i; j && x; j--, x--) vi[j][b[i]] = 1;
for (int j = n + 1; x; j--, x--) vi[j][b[i]] = 1;
}
printf("%d\n", n + 1);
for (int i = 1; i <= n + 1; i++) {
for (int j = 1; j <= n; j++) printf("%d", vi[i][j]);
printf("\n");
}
return 0;
}
| 11 | CPP |
l=input().split()
a=int(l[0])
b=int(l[1])
p=a*b
s=0
while p>0:
a=a-1
b=b-1
p=a*b
s=s+1
if s%2==0:
print("Malvika")
else:
print("Akshat") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e+9;
long long n, m, k, l, r, mid, pos, pos2;
long long get2(long long x) {
long long res = 0;
for (long long i = 1; i <= n; i++) res += min(x / i, m);
return res;
}
long long get(long long x) {
long long res = 0;
for (long long i = 1; i <= n; i++) res += min((x - 1) / i, m);
return res + 1;
}
bool ok(long long x) {
for (long long i = 1; i * i <= x; i++)
if (x % i == 0) return 1;
return 0;
}
int main() {
cin >> n >> m >> k;
l = 1;
r = n * m + 1;
while (1) {
mid = (r + l) / 2;
pos = get(mid);
pos2 = get2(mid);
if (pos <= k && k <= pos2) {
if (ok(mid)) {
cout << mid;
return 0;
} else
r = mid;
}
if (k > pos2)
l = mid;
else
r = mid;
}
return 0;
}
| 10 | CPP |
n = int(input().strip())
stones = list(input().strip())
count = 0
for i in range(1,len(stones)):
if stones[i] == stones[i-1]:
count += 1
# del stones[i-1]
print(count)
| 7 | PYTHON3 |
m,n=[int(x) for x in input().split()]
if m*n%2==0:
print("{0:.0f}".format(m*n/2))
else:
print("{0:.0f}".format((m*n-1)/2))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool use[105][105];
bool bge[105][105][4];
int n, m, gs, nm;
vector<int> v;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
inline void dfs(int x, int y) {
if (x < 0 || y < 0 || x == n || y == m || use[x][y]) return;
use[x][y] = 1;
nm++;
for (int i = 0; i < 4; i++)
if (!bge[x][y][i]) dfs(x + dx[i], y + dy[i]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> gs;
int i, j, k, x1, y1, x2, y2;
for (k = 0; k < gs; k++) {
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
for (i = y1; i < y2; i++) bge[x1 - 1][i][0] = bge[x1][i][1] = 1;
} else {
for (i = x1; i < x2; i++) bge[i][y1 - 1][2] = bge[i][y1][3] = 1;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (!use[i][j]) {
nm = 0;
dfs(i, j);
v.push_back(nm);
}
}
}
sort(v.begin(), v.end());
for (i = 0; i < v.size(); i++)
cout << v[i] << (i == v.size() - 1 ? '\n' : ' ');
cout << endl;
return 0;
}
| 10 | CPP |
import math
def ncr(n,r):
f = math.factorial
return f(n) / f(r) / f(n-r)
s0 = input()
s1 = input()
p0 = 0
p1 = 0
l = len(s0)
r = 0
for c in s0:
if c == '+': p0+=1
elif c == '-': p0-=1
for c in s1:
if c == '+': p1+=1
elif c == '-': p1-=1
else : r+=1
if abs(p1-p0)>r :
print(0)
else :
h = r-abs(p1-p0)
if h%2 == 0 :
print((ncr(r,(h//2))/(2**r)))
else :
print(0)
| 8 | PYTHON3 |
n = int(input())
ans = 0
for i in range(n):
s = input()
if "++" in s:
ans += 1
elif "--" in s:
ans -= 1
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[101][101];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
map<int, int> mp;
while (m--) {
int x, y, c;
cin >> x >> y >> c;
mp[c] = 1;
adj[c][x].push_back(y);
adj[c][y].push_back(x);
}
int qu;
cin >> qu;
while (qu--) {
int x, y;
cin >> x >> y;
int cc = 0;
for (auto c : mp) {
int col = c.first;
queue<int> q;
q.push(x);
int vis[n + 1];
for (int i = 1; i <= n; i++) {
vis[i] = 0;
}
while (!q.empty()) {
int f = q.front();
q.pop();
if (f == y) {
cc++;
break;
}
for (auto ele : adj[col][f]) {
if (vis[ele] == 1)
continue;
else {
q.push(ele);
vis[ele] = 1;
}
}
}
}
cout << cc << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long P = 29;
int n1, n2;
vector<vector<int> > chi2;
vector<int> par2;
vector<unsigned long long> vhs1, vps1, vhs2;
const int HSZ = 1 << 15;
const int HMSK = HSZ - 1;
vector<pair<unsigned long long, int> > htbl[2][HSZ];
int hver[2][HSZ];
int lhver[2];
void addTbl(int id, unsigned long long h, int k) {
int pos = h & HMSK;
if (hver[id][pos] < lhver[id]) {
htbl[id][pos].clear();
hver[id][pos] = lhver[id];
}
for (vector<pair<unsigned long long, int> >::iterator it =
htbl[id][pos].begin();
it != htbl[id][pos].end(); it++)
if (it->first == h) {
it->second += k;
return;
}
htbl[id][pos].push_back(make_pair(h, k));
}
int getTbl(int id, unsigned long long h) {
int pos = h & HMSK;
if (hver[id][pos] < lhver[id]) {
htbl[id][pos].clear();
hver[id][pos] = lhver[id];
}
for (vector<pair<unsigned long long, int> >::iterator it =
htbl[id][pos].begin();
it != htbl[id][pos].end(); it++)
if (it->first == h) return it->second;
return 0;
}
unsigned long long toFind, findK;
int dfs(int v) {
unsigned long long curFind = toFind + vhs2[v] * findK;
addTbl(1, curFind, 1);
int res = 0;
res += getTbl(1, vhs2[v]);
for (int i = 0; i < ((int)(chi2[v]).size()); i++) res += dfs(chi2[v][i]);
addTbl(1, curFind, -1);
return res;
}
int solve(unsigned long long h, unsigned long long k) {
toFind = h;
findK = k;
lhver[1]++;
return dfs(0);
}
int main() {
int ops;
while (scanf("%d", &ops) >= 1) {
vhs1 = vector<unsigned long long>(1, 0);
vps1 = vector<unsigned long long>(1, 1);
vhs2 = vector<unsigned long long>(1, 0);
par2 = vector<int>(1, -1);
n1 = n2 = 1;
memset(hver, 0, sizeof hver);
memset(lhver, 0, sizeof lhver);
for (int i = 0; i < HSZ; i++) {
htbl[0][i].clear();
htbl[0][i].reserve(10);
}
for (int i = 0; i < HSZ; i++) {
htbl[1][i].clear();
htbl[1][i].reserve(10);
}
addTbl(0, 0, 1);
long long cans = 1;
chi2 = vector<vector<int> >(1);
while (ops-- > 0) {
int t, v;
char c;
scanf(" %d%d %c", &t, &v, &c), v--;
if (t == 1) {
assert(v <= n1);
vhs1.push_back(vhs1[v] + vps1[v] * c);
vps1.push_back(vps1[v] * P);
addTbl(0, vhs1[n1], 1);
cans += solve(vhs1[n1], vps1[n1]);
n1++;
} else {
assert(v <= n2);
vhs2.push_back(vhs2[v] * P + c);
chi2[v].push_back(n2);
chi2.push_back(vector<int>());
par2.push_back(v);
unsigned long long ck = 1;
for (int x = n2; x >= 0; x = par2[x], ck *= P) {
unsigned long long ch = vhs2[n2] - vhs2[x] * ck;
cans += getTbl(0, ch);
}
n2++;
}
printf("%I64d\n", cans);
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2E5 + 5;
struct map {
int x, w;
} tr[N];
int n, m, p[N], l[N], x, y, f[N][20], c[N][20], ans;
void add(int x, int w, int c) {
for (; x <= n; x += x & -x)
if (tr[x].x < w || (tr[x].x == w && tr[x].w > c)) {
tr[x].x = w;
tr[x].w = c;
}
}
int get(int x, int y) {
int maxi = 0, cost = 2E9;
for (int pp = y; pp; pp -= pp & -pp)
if (tr[pp].x > maxi || (tr[pp].x == maxi && tr[pp].w < cost)) {
maxi = tr[pp].x;
cost = tr[pp].w;
}
if (!maxi) {
f[x][0] = x + 1;
c[x][0] = p[x + 1] - (p[x] + l[x]);
} else {
f[x][0] = maxi;
c[x][0] = min(p[maxi] - (p[x] + l[x]), cost);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d%d", &p[i], &l[i]);
memset(f, 10, sizeof(f));
add(n, n + 1, 0);
for (int i = n - 1; i; i--) {
y = lower_bound(p + 1, p + n + 1, p[i] + l[i] + 1) - p - 1;
get(i, y);
for (int j = 1; j < 20; j++)
if (f[i][j - 1] <= n)
f[i][j] = f[f[i][j - 1]][j - 1],
c[i][j] = c[i][j - 1] + c[f[i][j - 1]][j - 1];
add(i, f[i][0], c[i][0]);
}
cin >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
ans = 0;
for (int j = 19; j >= 0; j--)
if (f[x][j] <= y) {
ans += c[x][j];
x = f[x][j];
}
printf("%d\n", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h = 0;
int a = 0, b = 0, c = 0, d = 0;
int widh = 0, height = 0, x = 0, y = 0, temp = 0;
cin >> h;
int ans[h];
int ar[4];
int m = 0;
for (int i = 1; i <= h; i++) {
cin >> widh >> height >> x >> y;
a = widh - (x + 1);
b = widh - (a + 1);
c = height - (y + 1);
d = height - (c + 1);
ar[0] = a;
ar[1] = b;
ar[2] = c;
ar[3] = d;
m = ar[0];
for (int j = 0; j < 4; j++) {
if (ar[j] > m) {
m = ar[j];
}
}
ans[i] = max(max(a, b) * height, max(c, d) * widh);
}
for (int i = 1; i <= h; i++) {
cout << ans[i] << endl;
}
}
| 7 | CPP |
# referenced dukkha
def cross(i, j, k, b, cost):
return (cost[i] - cost[j]) * (b[i] - b[k]) - (b[i] - b[j]) * (cost[i] - cost[k])
def dot(i, j, a, b, cost):
return cost[j] + a[i] * b[j]
def CF319C():
N = int(input())
a = tuple(map(int, input().split()))
b = tuple(map(int, input().split()))
cost = [0] * N
hull = [0] * N # Make hull considering total minimum cost and charge of individual trees
left = 0
right = 1 # Index of items in hull
for i in range(1, N):
# Find the last cut tree which incurs minimum cost for ith tree
while left + 1 < right and dot(i, hull[left], a, b, cost) >= dot(i, hull[left + 1], a, b, cost):
# Only increase left when it decreases cutting cost
left += 1
cost[i] = dot(i, hull[left], a, b, cost)
while right >= 2 and cross(hull[right], hull[right - 1], i, b, cost) >= 0:
right -= 1
right += 1
hull[right] = i
return cost[-1]
if __name__ == '__main__':
res = CF319C()
print(res) | 9 | PYTHON3 |
n=int(input())
l=list(map(int,input().split()))
c=0
r=0
for i in range(n):
if(l[i]>0):
r+=l[i]-1
l[i]=1
elif(l[i]<0):
r+=abs(l[i]+1)
l[i]=-1
c+=1
k=l.count(0)
if(k!=0):
print(r+k)
else:
if(c%2==0):
print(r)
else:
print(r+2) | 8 | PYTHON3 |
Subsets and Splits