solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
double delta(int x) { return sqrt(1.0 + 8.0 * x); }
int main(void) {
int a00, a01, a10, a11;
cin >> a00 >> a01 >> a10 >> a11;
int n = (1 + delta(a00)) / 2 + 0.5, m = (1 + delta(a11)) / 2 + 0.5;
bool flag = true;
if (n * (n - 1) / 2 != a00) flag = false;
if (m * (m - 1) / 2 != a11) flag = false;
if (n == 1 && a10 == 0 && a01 == 0)
n = 0;
else if (m == 1 && a10 == 0 && a01 == 0)
m = 0;
if (a01 + a10 != n * m) flag = false;
int len = n + m;
if (flag) {
for (int i = 0; i < len; i++) {
if (a01 >= m) {
printf("0");
a01 -= m;
n--;
} else if (a10 >= n) {
printf("1");
a10 -= n;
m--;
}
}
puts("");
} else {
printf("Impossible\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int home[100007];
int away[100007];
void vin(vector<long long> &v, int n) {
long long temp;
while (n--) {
cin >> temp;
v.push_back(temp);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
vector<long long> v;
vin(v, m);
sort((v).begin(), (v).end());
if (m > 0 && (v[0] == 1 || v[m - 1] == n))
cout << "NO";
else {
int flag = 1;
long long i = 0;
for (; i < m - 2; i++) {
long long a = v[i + 1] - v[i] - 1;
long long b = v[i + 2] - v[i] - 2;
if (!a && !b) {
flag = 0;
break;
}
}
if (flag)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int n;
int p[N << 1];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) p[i] = i;
int l = 0;
for (int k = 2; k <= n; ++k) {
int first = p[l];
for (int i = l + k; i < l + n; i += k) swap(first, p[i]);
p[l + n] = first;
++l;
}
for (int i = n - 1; i < 2 * n - 1; ++i)
printf("%d%c", p[i] + 1, " \n"[i == 2 * n - 2]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, x[110], y[110], i, j, k, l, max = 0, x1, x2;
scanf("%i", &n);
for (i = 0; i < n; i++) {
scanf("%i%i", &x[i], &y[i]);
}
for (i = 0; i < n - 1; i++) {
x1 = x[i] + y[i];
for (j = i + 1; j < n; j++) {
if (x[j] == x1 && x[j] + y[j] == x[i]) {
printf("YES");
return 0;
}
}
}
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize "trapv"
long long int power(long long int x, long long int b) {
long long int p = 1;
while (b > 0) {
if (b & 1) {
p = p * x;
p %= 998244353;
}
b >>= 1;
x *= x;
x %= 998244353;
}
return p % 998244353;
}
using namespace std;
struct ppp {
char a;
long long int b, c, d;
};
long long int N;
struct lex_compare {
bool operator()(ppp p1, ppp p2) {
if (p1.a == p2.a) {
if (p1.b == p2.b)
return p1.c < p2.c;
else
return p1.b < p2.b;
} else {
return p1.a < p2.a;
}
}
};
bool comp(pair<long long int, long long int> p1,
pair<long long int, long long int> p2) {
return p1.second < p2.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int n;
cin >> n;
pair<long long int, long long int> arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i].first;
arr[i].second = i;
}
sort(arr, arr + n);
long long int freeRoots = 1;
long long int freq[1001] = {0};
for (long long int i = 0; i < n; i++) freq[arr[i].first]++;
for (long long int i = 999; i >= 0; i--) {
freq[i] += freq[i + 1];
}
queue<string> q;
q.push("");
long long int i = 0;
map<long long int, string> fans;
while (i < n) {
if (q.size() == 0) {
cout << "NO"
<< "\n";
return 0;
}
if (arr[i].first == q.front().size()) {
fans[arr[i].second] = q.front();
q.pop();
i++;
} else {
string temp = q.front();
q.pop();
if (freq[temp.size()] >= q.size()) {
q.push(temp + '0');
q.push(temp + '1');
}
}
}
for (long long int i = 0; i < n; i++) {
if (fans.count(i) == 0) {
cout << "NO"
<< "\n";
return 0;
}
}
cout << "YES"
<< "\n";
for (long long int i = 0; i < n; i++) {
cout << fans[i] << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, v1, v2, t1, t2, s, f;
cin >> n >> v1 >> v2 >> t1 >> t2;
f = 2 * t1 + n * v1;
s = 2 * t2 + n * v2;
if (f < s)
cout << "First";
else if (s < f)
cout << "Second";
else
cout << "Friendship";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll power(ll x, ll y);
const ll MOD = 1000003;
ll convert(string s) {
ll ans = 0;
ll n = s.size();
reverse(s.begin(), s.end());
for (ll i = 0; i < n; i++) {
if (s[i] == '1') ans = ans + power(2, i);
ans = ans % MOD;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll t;
t = 1;
while (t--) {
vector<pair<char, string>> v;
v.push_back(make_pair('>', "1000"));
v.push_back(make_pair('<', "1001"));
v.push_back(make_pair('+', "1010"));
v.push_back(make_pair('-', "1011"));
v.push_back(make_pair('.', "1100"));
v.push_back(make_pair(',', "1101"));
v.push_back(make_pair('[', "1110"));
v.push_back(make_pair(']', "1111"));
string a;
cin >> a;
string res = "";
for (ll i = 0; i < ll((a).size()); i++) {
for (ll j = 0; j < ll((v).size()); j++) {
if (a[i] == v[j].first) {
res += v[j].second;
break;
}
}
}
cerr << "> "
<< "res"
<< " : " << res << "\n";
ll ans = convert(res);
cout << ans << "\n";
}
}
ll power(ll x, ll y) {
ll res = 1;
x %= MOD;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1, x = (x * x) % MOD;
}
return res;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long MOD = 1e9 + 7;
long long n, a[N], l, r, mn = 1e18, t1, t2, ans;
long long check(long long x) {
long long len = 0;
for (int i = 1; i <= n; i++) {
len += abs(x - a[i] + 1);
}
return len;
}
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
sort(a + 1, a + n + 1);
printf("%I64d", a[(n + 1) / 2]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
char a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (n == 1) {
if (k == 1) {
a[0] = '0';
}
} else {
if ((k > 0) && a[0] != '1') {
a[0] = '1';
--k;
}
for (int i = 1; ((i < n) && (k > 0)); ++i) {
if (a[i] != '0') {
a[i] = '0';
--k;
}
}
}
for (int i = 0; i < n; ++i) {
cout << a[i];
}
cout << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define LL long long
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, ans = 0; string s; cin >> n >> s;
for(int i = 1; i < n; i++) {
int d = 1;
for(int j = 0; i + j < n; j++) {
if(s[j] == s[i+j]) ans = max(ans, min(i, d++));
else d = 1;
}
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int v[n];
for (int i = 0; i < n; i++) scanf("%d", v + i);
int zero[n];
int left = 2 * 1e9 + 1;
for (int i = n - 1; i >= 0; i--) {
if (v[i] == 0) left = i;
zero[i] = left - i;
}
int right = -2 * 1e9 - 1;
for (int i = 0; i < n; i++) {
if (v[i] == 0) right = i;
zero[i] = min(zero[i], i - right);
}
for (int i = 0; i < n; i++) printf("%d ", zero[i]);
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <string>
#include <sstream>
using namespace std;
double x[4], y[4];
bool solve() {
if(x[0] > x[1]) swap(x[0], x[1]);
if(y[0] > y[1]) swap(y[0], y[1]);
if(x[2] > x[3]) swap(x[2], x[3]);
if(y[2] > y[3]) swap(y[2], y[3]);
if(x[1] < x[2]) return false;
if(y[1] < y[2]) return false;
if(x[3] < x[0]) return false;
if(y[3] < y[0]) return false;
return true;
}
int main() {
string line;
while(getline(cin, line)) {
stringstream ss;
ss << line;
for(int i = 0; i < 4; ++i) ss >> x[i] >> y[i];
cout << (solve() ? "YES" : "NO") << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
char ch[100001];
int main() {
scanf("%s", ch);
string s = ch;
char x = 'a';
int r = 0, cnt = 0, can = 0;
while (r < (int)s.size()) {
if (s[r] <= x) {
cnt++;
s[r] = x;
x++;
if (x > 'z') x--;
}
if (cnt == 26) can = 1;
r++;
}
if (can)
cout << s;
else
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
const int mod = 1000000007;
const int MAXN = 3006;
char s[MAXN][MAXN];
int DP[MAXN][MAXN][2];
int solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (n); ++i) scanf("%s", s[i]);
if (s[0][1] == '#' || s[1][0] == '#') return 0;
if (s[n - 1][m - 2] == '#' || s[n - 2][m - 1] == '#') return 0;
DP[0][1][0] = 1;
DP[1][0][1] = 1;
for (int sum = 2; sum <= n + m - 2; sum++)
for (int i = max(0, sum - m + 1); i < n; i++) {
int j = sum - i;
for (int h = 0; h < (2); ++h) {
if (i - 1 >= 0) DP[i][j][h] = DP[i - 1][j][h];
if (j - 1 >= 0) DP[i][j][h] += DP[i][j - 1][h];
if (DP[i][j][h] >= mod) DP[i][j][h] -= mod;
if (s[i][j] == '#') DP[i][j][h] = 0;
}
}
return (1LL * DP[n - 1][m - 2][1] * DP[n - 2][m - 1][0] % mod -
1LL * DP[n - 1][m - 2][0] * DP[n - 2][m - 1][1] % mod + mod) %
mod;
}
int main() {
int te = 1;
for (int ti = 0; ti < (te); ++ti) cout << solve() << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a[100001];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
scanf("%d", &m);
int Left = 1;
for (; m--;) {
int x, y;
scanf("%d%d", &x, &y);
while (Left < x) {
a[Left + 1] = max(a[Left + 1], a[Left]);
++Left;
}
printf("%I64d\n", a[Left]);
a[Left] += y;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7FFFFFFF;
const long long LINF = 0x7FFFFFFFFFFFFF;
void guan() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long mod = 998244353;
const int maxn = 1010101;
char s[1111];
char ts[1111];
const int N = 111;
long long a[N][N], b[N][N], ta[N][N];
int check(int pos) {
int len = 0;
for (int i = 1; i <= pos; i++) {
int ok = 1;
for (int j = i; j <= pos && ok; j++) {
if (s[j - i + 1] != ts[j]) ok = 0;
}
if (ok) return pos - i + 1;
}
return 0;
}
void matrix_mul(long long a[N][N], long long b[N][N], int n) {
long long c[N][N];
memset(c, 0, sizeof(c));
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= n; k++) {
c[i][j] += a[i][k] * b[k][j];
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
a[i][j] = c[i][j];
}
}
}
void matrix_qpow(long long a[N][N], int n, int x) {
long long c[N][N];
memset(c, 0, sizeof(c));
for (int i = 0; i <= n; i++) c[i][i] = 1;
int temp = x;
for (int i = 1; i <= temp; i++) matrix_mul(c, a, n);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
a[i][j] = c[i][j];
}
}
}
void Copy(long long a[][N], long long b[][N], int n) {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) a[i][j] = b[i][j];
}
int main() {
guan();
int d, h, k, p;
int n, m;
while (cin >> n >> s + 1) {
int len = strlen(s + 1);
memset(a, 0, sizeof(a));
memset(ta, 0, sizeof(ta));
for (int i = 0, to; i < len; i++) {
ts[i + 1] = '1';
to = check(i + 1);
a[i][to] = ta[i][to] = 1;
ts[i + 1] = '0';
to = check(i + 1);
a[i][to] = ta[i][to] = 1;
ts[i + 1] = s[i + 1];
}
long long ans = 0;
for (int i = 0, to; i < len; i++) {
Copy(a, ta, len);
matrix_qpow(a, len, n);
memset(b, 0, sizeof(b));
b[0][i] = 1;
matrix_mul(b, a, len);
ans += b[0][i];
}
cout << (long long)pow(2ll, n) - ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, x, y, z;
int A[N], a;
int B[N], b;
int r, u, v;
void qry(int* A, int a) {
if (!a) {
z = 0;
return;
}
printf("? %d ", a);
for (int i = 0; i < a; i++) printf("%d%c", A[i], " \n"[i == a - 1]);
fflush(stdout);
scanf("%d", &z);
}
void solve(int l, int r) {
if (l == r) {
u = A[l];
return;
}
int mid = l + r >> 1;
b = 0;
for (int i = l; i < mid + 1; i++) B[b++] = A[i];
qry(B, b);
if (b & 1) {
if (z == y)
solve(l, mid);
else
solve(mid + 1, r);
} else {
if (z == (x ^ y))
solve(l, mid);
else
solve(mid + 1, r);
}
}
int main() {
scanf("%d%d%d", &n, &x, &y);
for (int i = 0; i < 10; i++) {
a = 0;
for (int j = 1; j < n + 1; j++)
if (j >> i & 1) A[a++] = j;
qry(A, a);
if (z == ((a & 1) ? y : (x ^ y))) {
r |= 1 << i;
u = i;
}
}
a = 0;
for (int i = 1; i < n + 1; i++)
if (i >> u & 1) A[a++] = i;
solve(0, a - 1);
v = u ^ r;
if (u > v) swap(u, v);
printf("! %d %d\n", u, v);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long choose[110][51];
unsigned long long difficulty;
int bits[1100];
int bc;
void convert(unsigned long long dd) {
while (dd) {
bits[bc++] = dd % 6;
dd /= 6;
}
}
void solve() {
scanf("%llu", &difficulty);
convert(difficulty);
int size = 1 + 2 * (bc) + 1;
int cornerx = 1, cornery = 1;
vector<pair<pair<int, int>, pair<int, int> > > walls;
for (int i = 0; i < bc; i++) {
walls.emplace_back(pair<int, int>{cornerx - 1, cornery + 1},
pair<int, int>{cornerx, cornery + 1});
walls.emplace_back(pair<int, int>{cornerx - 1, cornery + 2},
pair<int, int>{cornerx, cornery + 2});
walls.emplace_back(pair<int, int>{cornerx + 1, cornery - 1},
pair<int, int>{cornerx + 1, cornery});
walls.emplace_back(pair<int, int>{cornerx + 2, cornery - 1},
pair<int, int>{cornerx + 2, cornery});
walls.emplace_back(pair<int, int>{cornerx - 2, cornery + 2},
pair<int, int>{cornerx - 1, cornery + 2});
walls.emplace_back(pair<int, int>{cornerx - 2, cornery + 3},
pair<int, int>{cornerx - 1, cornery + 3});
walls.emplace_back(pair<int, int>{cornerx + 2, cornery - 2},
pair<int, int>{cornerx + 2, cornery - 1});
walls.emplace_back(pair<int, int>{cornerx + 3, cornery - 2},
pair<int, int>{cornerx + 3, cornery - 1});
if (i == bc - 1) {
walls.emplace_back(pair<int, int>{cornerx + 2, cornery + 2},
pair<int, int>{cornerx + 3, cornery + 2});
walls.emplace_back(pair<int, int>{cornerx + 2, cornery + 2},
pair<int, int>{cornerx + 2, cornery + 3});
}
if (bits[i] == 0) {
walls.emplace_back(pair<int, int>{cornerx, cornery + 2},
pair<int, int>{cornerx, cornery + 3});
walls.emplace_back(pair<int, int>{cornerx + 1, cornery + 2},
pair<int, int>{cornerx + 1, cornery + 3});
} else if (bits[i]) {
if (bits[i] >= 3)
bits[i] -= 3;
else {
walls.emplace_back(pair<int, int>{cornerx + 1, cornery + 2},
pair<int, int>{cornerx + 1, cornery + 3});
}
if (bits[i] >= 1)
bits[i]--;
else {
walls.emplace_back(pair<int, int>{cornerx, cornery + 2},
pair<int, int>{cornerx, cornery + 3});
}
}
if (bits[i])
bits[i]--;
else {
walls.emplace_back(pair<int, int>{cornerx + 2, cornery},
pair<int, int>{cornerx + 3, cornery});
}
walls.emplace_back(pair<int, int>{cornerx + 2, cornery + 1},
pair<int, int>{cornerx + 3, cornery + 1});
cornerx += 2, cornery += 2;
}
printf("%d %d\n", size, size);
vector<pair<pair<int, int>, pair<int, int> > > filtered;
for (pair<pair<int, int>, pair<int, int> > pp : walls) {
if (min(pp.first.first,
min(pp.first.second, min(pp.second.first, pp.second.second))) < 1)
continue;
if (max(pp.first.first, max(pp.first.second,
max(pp.second.first, pp.second.second))) > size)
continue;
filtered.push_back(pp);
}
printf("%d\n", (int)filtered.size());
for (pair<pair<int, int>, pair<int, int> > pp : filtered) {
printf("%d %d %d %d\n", pp.first.first, pp.first.second, pp.second.first,
pp.second.second);
}
}
int main() { solve(); }
| 4 |
#include <iostream>
using namespace std;
double f(double x1, double y1, double x2, double y2, double xp, double yp) {
return (y2 - y1) * xp + (-x2 + x1) * yp - x1 * (y2 - y1) + y1 * (x2 - x1);
}
int main(void) {
double x1, y1, x2, y2, x3, y3, xp, yp;
double a, b, c;
while(cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp) {
a = f(x1, y1, x2, y2, xp, yp);
b = f(x2, y2, x3, y3, xp, yp);
c = f(x3, y3, x1, y1, xp, yp);
if((a > 0 && b > 0 && c > 0) || (a < 0 && b < 0 && c < 0)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<ll>;
using vs = vector<string>;
using ii = pair<ll, ll>;
using ss = pair<string, string>;
using ldld = pair<ld, ld>;
template <typename X>
istream& operator>>(istream& stream, vector<X>& vec) {
for (auto& e : vec) stream >> e;
return stream;
}
template <typename X, typename Y>
istream& operator>>(istream& stream, pair<X, Y>& p) {
stream >> p.first >> p.second;
return stream;
}
template <typename X, typename Y>
Y& operator<<(Y& str, const vector<X>& vec) {
for (auto& e : vec) str << e;
return str;
}
template <typename X, typename Y>
Y& operator<<(Y& str, const set<X>& vec) {
for (auto& e : vec) str << e;
return str;
}
template <typename X, typename Y>
Y& operator<<(Y& str, const list<X>& vec) {
for (auto& e : vec) str << e;
return str;
}
template <typename X, typename Y>
Y& operator<<(Y& str, const deque<X>& vec) {
for (auto& e : vec) str << e;
return str;
}
template <typename X, typename Y, typename Z>
Z& operator<<(Z& str, const pair<X, Y>& p) {
str << p.first << p.second;
return str;
}
struct sep {
sep(string sep) : _(sep) {}
string _;
};
struct sep_ostream {
sep_ostream(ostream& str, string sep) : _str(str), _sep(sep) {}
template <typename X>
sep_ostream& operator<<(const X& a) {
if (_step-- > 1) {
*this << a;
} else
_str << (_step ? _sep : "") << a;
return *this;
}
sep_ostream& operator<<(ostream& (*manip)(ostream&)) {
manip(_str);
return *this;
}
private:
ostream& _str;
string _sep;
int _step = 2;
};
sep_ostream operator<<(ostream& str, sep s) { return sep_ostream(str, s._); }
struct debug_stream {
debug_stream(sep_ostream str) : _str(str) {}
~debug_stream() {}
template <typename X>
debug_stream& operator<<(const X& a) {
return *this;
}
debug_stream& operator<<(ostream& (*manip)(ostream&)) { return *this; }
debug_stream& operator()(string pre) { return *this; }
private:
sep_ostream _str;
};
using namespace chrono;
struct debug_time {
debug_time(sep_ostream str) : _str(str), start(system_clock::now()) {}
~debug_time() {}
private:
sep_ostream _str;
time_point<system_clock> start;
};
struct X {
ll low;
ll high;
ll sum;
};
ll kad(vi& x, ll low, ll high) {
ll res = x[low], sum = 0;
for (ll i = low; i < high; ++i) {
sum += x[i];
sum = max(sum, 0ll);
res = max(res, sum);
}
return res;
}
int main() {
ll n;
cin >> n;
vi a(n);
cin >> a;
auto calc = [&](bool x) {
auto elem = [&](ll i, ll l) {
return abs(a[i] - a[i + 1]) * pow(-1, i - l);
};
ll res = elem(0, 0);
ll sum = 0;
ll left = !x;
for (ll i = 0; i < n - 1; ++i) {
debug_stream(sep_ostream(cout, " ")) << i << left << sum << elem(i, left);
sum += elem(i, left);
if (sum <= 0ll) {
left = i + 1;
if (left % 2 == x) {
i++;
left++;
}
sum = 0;
}
res = max(res, sum);
}
return res;
};
cout << max(calc(true), calc(false));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9;
ll n, m, k;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int sc;
cin >> n >> m >> k >> sc;
vector<pair<pair<ll, ll>, pair<ll, ll>>> dp(n + 1);
vector<pair<ll, ll>> tr(n + 1, {1e9, -1e9});
for (int i = 0; i < k; i++) {
ll x, y;
cin >> x >> y;
tr[x].first = min(tr[x].first, y);
tr[x].second = max(tr[x].second, y);
}
vector<int> safe;
for (int i = 0; i < sc; i++) {
int x;
cin >> x;
safe.push_back(x);
}
sort(safe.begin(), safe.end());
dp[0].first = {0, 1};
dp[0].second = {0, 1};
ll ans = 0;
for (int i = 1; i < n + 1; i++) {
if (tr[i].first == 1e9) {
dp[i] = dp[i - 1];
continue;
}
ll mdist = abs(tr[i].first - tr[i].second);
ll golr = 1e18, gorl = 1e18;
int sind;
if (i == 1) {
dp[i].first = {tr[i].second - 1 + mdist, tr[i].first};
dp[i].second = {tr[i].first - 1 + mdist, tr[i].second};
ans = min(dp[i].first.first, dp[i].second.first);
continue;
}
sind = lower_bound(safe.begin(), safe.end(), tr[i].first) - safe.begin();
if (sind != safe.size()) {
golr =
abs(safe[sind] - tr[i].first) +
min(abs(safe[sind] - dp[i - 1].first.second) + dp[i - 1].first.first,
abs(safe[sind] - dp[i - 1].second.second) +
dp[i - 1].second.first);
}
sind--;
if (sind >= 0) {
golr = min(golr, abs(safe[sind] - tr[i].first) +
min(abs(safe[sind] - dp[i - 1].first.second) +
dp[i - 1].first.first,
abs(safe[sind] - dp[i - 1].second.second) +
dp[i - 1].second.first));
}
golr += mdist;
sind = lower_bound(safe.begin(), safe.end(), tr[i].second) - safe.begin();
if (sind != safe.size()) {
gorl =
abs(safe[sind] - tr[i].second) +
min(abs(safe[sind] - dp[i - 1].first.second) + dp[i - 1].first.first,
abs(safe[sind] - dp[i - 1].second.second) +
dp[i - 1].second.first);
}
sind--;
if (sind >= 0) {
gorl = min(gorl, abs(safe[sind] - tr[i].second) +
min(abs(safe[sind] - dp[i - 1].first.second) +
dp[i - 1].first.first,
abs(safe[sind] - dp[i - 1].second.second) +
dp[i - 1].second.first));
}
gorl += mdist;
dp[i].first = {gorl, tr[i].first};
dp[i].second = {golr, tr[i].second};
ans = min(gorl, golr) + i;
ans--;
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long x, long long y, long long m) {
if (x >= m) x %= m;
if (y == 0) return 1 % m;
long long z = modpow(x, y >> 1, m);
z = z * z % m;
if (y & 1) z = z * x % m;
return z;
}
long long tower(long long x, long long y, long long m) {
if (x >= m) x %= m;
if (!x) return 0;
long long z = modpow(2, y, m - 1);
return modpow(x, z, m);
}
long long squares(long long x, long long y, long long m) {
if (x >= m) x %= m;
if (x == 0) return 1;
if (x == 1) return modpow(2, y, m);
long long z = (tower(x, y, m) + m - 1) % m;
z = z * modpow(x - 1, m - 2, m) % m;
return z;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int t;
cin >> t;
while (t--) {
long long k, l, r, p;
cin >> k >> l >> r >> p;
if (p == 2) {
cout << 1 - k % 2 << '\n';
} else {
long long q = tower(k, l, p);
q = squares(q, r - l + 1, p);
if (k % 2) q = q * modpow(modpow(2, r - l, p), p - 2, p) % p;
cout << q << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 11234;
void scan(long long &n) { scanf("%lld", &n); }
void scan(long long &n, long long &m) { scanf("%lld%lld", &n, &m); }
void scan(vector<long long> &v) {
long long n = v.size();
for (long long i = 0; i < n; i++) scanf("%lld", &v[i]);
}
vector<long long> adj[N];
long long vis[N], lvl[N], lvl1[N], vis1[N];
void edge(long long u, long long v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
long long good[N];
int main() {
long long n;
scan(n);
long long i, res = 0, cnt = 0;
vector<long long> a(n), b(n);
scan(a);
scan(b);
map<long long, long long> mp, last;
vector<pair<long long, long long> > v;
for (i = 0; i < n; i++) {
if (mp[a[i]]) {
good[last[a[i]]] = 1;
good[i] = 1;
}
mp[a[i]]++;
last[a[i]] = i;
}
for (i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (i == j) continue;
if (good[j] and (a[j] & a[i]) == a[i]) {
res += b[i];
break;
}
}
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (scanf("%d%d", &m, &n) != EOF) {
double ans = 0;
for (int i = m; i >= 1; i--) {
ans += (pow(1.0 * i / m, n) - pow(1.0 * (i - 1) / m, n)) * i;
}
printf("%.4lf\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define en "\n";
#define all(x) (x).begin(), (x).end()
ll mod = 1000000007;
//ull n = 1e8;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin >> t;
//cout<<"as.size()"<<en;
while (t--)
{
ll n,m;
cin>>n>>m;
ll d = abs(n-m);
if (n==m)
{
cout<<"0"<<" 0"<<en;
continue;
}
ll k= n/d;
if (n%d!=0)
{
k++;
}
// if (n==1)
// { k--;
// ll p = abs(d*k-n);
// cout<<d<<" "<<"0"<<en;
// continue;
// }
ll p = abs(d*k-n);
if (p>d/2)
{
p = d-p;
}
//cout<<p<<"."<<en;
cout<<d<<" "<<p<<en;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, temp, count = 0, flag;
cin >> n >> x;
if (n >= x) {
temp = x;
flag = 0;
} else {
temp = n;
flag = 1;
}
while (temp > flag) {
if ((x % temp) == 0 && (temp * n) >= x) {
count++;
}
temp--;
}
cout << count << endl;
return 0;
}
| 1 |
#include<stdio.h>
#include<iostream>
using namespace std;
int main()
{
long double a,b;
cin>>a>>b;
cout<<(long long)(a*b)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, a, b;
vector<int> v;
cin >> n;
cin >> a;
v.push_back(a);
for (int i = 1; i < n; i++) {
cin >> b;
v.push_back(b);
if (a < b) swap(a, b);
a = gcd(a, b);
}
sort(v.begin(), v.end());
if (*(lower_bound(v.begin(), v.end(), a)) == a)
cout << a;
else
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const int maxn = 1e5 + 10, N = 3e6, SQ = 1000, base = 800287, mod = 1e9 + 7,
INF = 1e9 + 10, lg = 22;
const long double eps = 1e-4;
int n, m, q;
unordered_map<int, int> par[maxn], res[maxn];
inline int root(int v, int x) {
return (par[v][x] <= 0 ? v : par[v][x] = root(par[v][x], x));
}
void merge(int v, int u, int x) {
if ((v = root(v, x)) == (u = root(u, x))) {
return;
}
par[u][x] = v;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y, z;
cin >> x >> y >> z;
merge(x, y, z);
}
cin >> q;
while (q--) {
int v, u;
cin >> v >> u;
int ans = 0;
if ((int)par[v].size() < (int)par[u].size()) {
swap(v, u);
}
if (res[v].find(u) != res[v].end()) {
cout << res[v][u] << '\n';
continue;
}
for (auto i : par[u]) {
if (par[v].find(i.first) == par[v].end()) {
continue;
}
if (root(v, i.first) == root(u, i.first)) {
ans++;
}
}
res[v][u] = res[u][v] = ans;
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e18;
const double eps = 1e-10;
const int inf = 0x3f3f3f3f;
const int mif = 0xcfcfcfcf;
const double PI = 3.14159265358979323846264338;
long long mul_mod(long long first, long long second) {
long long t = 0;
while (second) {
if (second & 1) t = (t + first) % mod;
first = (first + first) % mod;
second >>= 1;
}
return t;
}
long long pow_mod(long long first, long long second) {
long long t = 1;
while (second) {
if (second & 1) t = mul_mod(t, first);
first = mul_mod(first, first);
second >>= 1;
}
return t;
}
long long quick_pow(long long first, long long second) {
long long t;
for (t = 1; second; second >>= 1, first *= first)
if (second & 1) t *= first;
return t;
}
long long gcd(long long first, long long second) {
return second ? gcd(second, first % second) : first;
}
double LG(double s, double k) { return log(k) / log(s); }
long long read() {
long long c = 0, f = 1ll;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
c = c * 10 + ch - '0';
ch = getchar();
}
return c * f;
}
const int N = 1100000;
int n, m, p[25][25];
bool check() {
for (int i = 1; i < n + 1; ++i) {
int cnt = 0;
for (int j = 1; j < m + 1; ++j)
if (p[i][j] != j) ++cnt;
if (cnt > 2) return 0;
}
return 1;
}
int main() {
cin >> n >> m;
for (int i = 1; i < n + 1; ++i)
for (int j = 1; j < m + 1; ++j) p[i][j] = read();
if (check()) {
puts("YES");
return 0;
}
for (int i = 1; i <= m; ++i)
for (int j = i + 1; j <= m; ++j) {
for (int k = 1; k <= n; ++k) swap(p[k][i], p[k][j]);
if (check()) {
puts("YES");
return 0;
}
for (int k = 1; k <= n; ++k) swap(p[k][i], p[k][j]);
}
puts("NO");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 55;
const int inf = 2147483647;
const double pi = acos(-1.0);
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int n, a[Maxn], tmp[Maxn], lb, pos[Maxn];
vector<int> ans[Maxn];
int cnt = 0;
struct T {
int c, v, l, r;
} b[Maxn];
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
while (1) {
int cur = 1;
b[lb = 1].l = b[1].r = b[1].c = 1;
b[1].v = a[1];
for (int i = 2; i <= n; i++) {
if (a[i] == a[i - 1] + 1)
b[lb].c++, b[lb].r = i;
else
b[++lb].c = 1, b[lb].l = b[lb].r = i, b[lb].v = a[i];
}
if (lb == 1) break;
cnt++;
for (int i = 1; i <= lb; i++) {
int p, mn = inf;
for (int j = 1; j <= lb; j++)
if (b[j].v >= i && b[j].v <= mn) mn = b[j].v, p = j;
b[p].v = i;
pos[i] = p;
}
for (int i = 2; i <= lb; i++)
if (pos[i] < pos[i - 1]) {
if (b[pos[i]].l != 1) ans[cnt].push_back(b[pos[i]].l - 1);
ans[cnt].push_back(b[pos[i]].r - b[pos[i]].l + 1);
ans[cnt].push_back(b[pos[i - 1]].r - b[pos[i]].r);
if (b[pos[i - 1]].r != n) ans[cnt].push_back(n - b[pos[i - 1]].r);
break;
}
int t = 0;
for (int i = 0; i < ans[cnt].size(); i++) {
for (int j = t + 1; j <= t + ans[cnt][i]; j++)
tmp[n - t - ans[cnt][i] + j - t] = a[j];
t += ans[cnt][i];
}
for (int i = 1; i <= n; i++) a[i] = tmp[i];
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) {
printf("%d ", ans[i].size());
for (int j = 0; j < ans[i].size(); j++) printf("%d ", ans[i][j]);
puts("");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char tmp[400005];
vector<string> ans;
string s;
bool canprint;
bool check(string n) {
int pos = n.find('.');
if (pos == n.size() - 1) return false;
if (pos > 8 || pos == 0 || n.size() - pos - 1 > 3) return false;
return true;
}
int main() {
scanf("%s", tmp);
s = tmp;
bool lad = false;
if (s[0] == '.') {
puts("NO");
return 0;
} else if (s[s.size() - 1] == '.') {
puts("NO");
return 0;
}
int i = 0;
int lastd = s.size() - 1;
while (s[lastd] != '.' && lastd >= 0) lastd--;
if (lastd == -1) {
puts("NO");
return 0;
}
string now = "";
while (i < s.size() && s[i] != '.') now += s[i], i++;
ans.push_back(now + '.');
while (i < lastd) {
if (s[i] == '.' && !lad) {
i++;
lad = true;
continue;
}
if (s[i] == '.' && lad) {
puts("NO");
return 0;
}
lad = false;
int t = i;
int l;
while (s[i] != '.') i++;
if (i - t > 11 || i - t < 2 || i == s.size()) {
puts("NO");
return 0;
}
string now = "";
while (t < i - 1 && now.size() < 3) {
now.push_back(s[t]);
t++;
}
ans[ans.size() - 1] += now;
now = "";
while (t != i) now += s[t], t++;
ans.push_back(now + '.');
i++;
}
if (lad) {
puts("NO");
return 0;
}
if (ans.back()[ans.back().size() - 1] == '.' && s[i] == '.') i++;
now = "";
for (; i < s.size(); i++) now += s[i];
ans[ans.size() - 1] += now;
canprint = true;
for (int i = 0; i < ans.size(); i++) {
canprint = canprint && check(ans[i]);
}
if (canprint) {
puts("YES");
for (int i = 0; i < ans.size(); i++) puts(ans[i].c_str());
} else {
puts("NO");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
vector<long long> g[111111];
bool u[111111];
long long a[111111];
long long b[111111];
queue<long long> q;
void dfs(long long i) {
for (long long j = 0; j < (long long)(g[i].size()); j++) {
long long k = g[i][j];
if (u[k]) continue;
b[k]++;
if (a[i] == 2)
a[k] += 3;
else
a[k] += a[i];
if (b[k] == g[k].size() - 1) {
u[k] = true;
if (b[k] == 1) {
return dfs(k);
} else {
q.push(k);
}
}
}
}
int main(void) {
long long n;
cin >> n;
for (long long i = 0; i < (long long)(n - 1); i++) {
long long x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (long long i = 0; i < (long long)(n); i++) {
if (g[i].size() == 1) {
q.push(i);
u[i] = true;
a[i] = 1;
}
}
while (q.size()) {
long long i = q.front();
q.pop();
for (long long j = 0; j < (long long)(g[i].size()); j++) {
long long k = g[i][j];
if (u[k]) continue;
b[k]++;
if (a[i] == 2)
a[k] += 3;
else
a[k] += a[i];
if (b[k] == g[k].size() - 1) {
u[k] = true;
if (b[k] == 1) {
dfs(k);
} else {
q.push(k);
}
}
}
}
for (long long i = 0; i < (long long)(n); i++) {
if (a[i] < 3) continue;
long long res = 0;
for (long long j = 0; j < (long long)(g[i].size()); j++) {
if (a[g[i][j]] >= 3) {
res++;
}
}
if (res >= 3) {
cout << "No" << '\n';
return 0;
}
}
cout << "Yes" << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <int MOD = 998244353>
struct mint {
int value;
static const int MOD_value = MOD;
mint(long long v = 0) {
value = v % MOD;
if (value < 0) value += MOD;
}
mint(long long a, long long b) : value(0) {
*this += a;
*this /= b;
}
friend mint mexp(mint a, int e) {
mint res = 1;
while (e) {
if (e & 1) res *= a;
a *= a;
e >>= 1;
}
return res;
}
friend mint inv(mint a) { return mexp(a, MOD - 2); }
mint& operator+=(mint const& b) {
value += b.value;
if (value >= MOD) value -= MOD;
return *this;
}
mint& operator-=(mint const& b) {
value -= b.value;
if (value < 0) value += MOD;
return *this;
}
mint& operator*=(mint const& b) {
value = (long long)value * b.value % MOD;
return *this;
}
mint& operator/=(mint const& b) { return *this *= inv(b); }
friend mint operator+(mint a, mint const b) { return a += b; }
friend mint operator-(mint a, mint const b) { return a -= b; }
friend mint operator-(mint const a) { return 0 - a; }
friend mint operator*(mint a, mint const b) { return a *= b; }
friend mint operator/(mint a, mint const b) { return a /= b; }
friend bool operator==(mint const& a, mint const& b) {
return a.value == b.value;
}
friend bool operator!=(mint const& a, mint const& b) {
return a.value != b.value;
}
};
mint<> inv(int a) { return inv(mint<>(a)); }
int n, m, a[100], b[100], iv[100000];
mint<> x[2][2][110][110][110];
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12) << fixed;
int w0 = 0, w1 = -52;
for (int i = 1; i < 100000; ++i) {
iv[i] = inv(i).value;
}
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
if (a[i] == 1)
w1 += b[i];
else
w0 += b[i];
}
int p = 0, q = -1, t = 1;
for (int i = 0; i < 2; ++i) {
if (i) {
p = 1, q = 1;
}
for (int w = 0; w < 110; ++w) {
for (int k = 0; k < 105; ++k) {
for (int l = 0; l < 105; ++l) {
x[p][0][w][k][l] = w;
}
}
}
for (int j = 1; j <= m; ++j) {
t = j % 2;
for (int w = 1; w < 102 - j; ++w) {
for (int k = 0; k < 105 - j && k <= w0; ++k) {
for (int l = max(0, -w1); l < 105 - j; ++l) {
x[p][t][w][k][l] = 0;
int ks = w0 - k, ls = w1 + l;
mint<> d = iv[w + ks + ls];
if (w + q >= 0 && w + q < 102 - j)
x[p][t][w][k][l] = w * d * x[p][1 - t][w + q][k][l];
if (k < 104) x[p][t][w][k][l] += ks * d * x[p][1 - t][w][k + 1][l];
if (l < 104) x[p][t][w][k][l] += ls * d * x[p][1 - t][w][k][l + 1];
}
}
}
}
}
for (int i = 0; i < n; ++i) {
int q0 = 0, q1 = 52;
if (a[i])
q1 = 52 - b[i];
else
q0 = b[i];
cout << x[a[i]][t][b[i]][q0][q1].value << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, f;
string s;
char cap[15] = {'A', 'H', 'I', 'M', 'O', 'T', 'U', 'V',
'W', 'X', 'Y', 'o', 'v', 'w', 'x'};
cin >> s;
i = 0;
j = s.length() - 1;
while (i <= j) {
if (s[i] == s[j]) {
for (k = 0; k < 15; k++) {
if (s[i] == cap[k]) break;
}
if (k >= 15) {
break;
}
} else {
if ((s[i] == 'b' && s[j] == 'd') || (s[i] == 'd' && s[j] == 'b'))
;
else if ((s[i] == 'p' && s[j] == 'q') || (s[i] == 'q' && s[j] == 'p'))
;
else
break;
}
i++;
j--;
}
if (i <= j)
cout << "NIE\n";
else
cout << "TAK\n";
return 0;
}
| 2 |
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
const int INF = INT_MAX / 2;
int main()
{
for(;;){
int n, start, goal, m;
cin >> n >> start >> goal >> m;
if(n == 0)
return 0;
vector<vector<pair<int, int> > > edges(n+1);
for(int i=0; i<m; ++i){
int a, b;
cin >> a >> b;
edges[a].push_back(make_pair(b, 0));
edges[b].push_back(make_pair(a, i+1));
}
multimap<pair<int, int>, int> mm;
vector<vector<pair<int, int> > > check(n+1, vector<pair<int, int> >(2, make_pair(INF, INF)));
mm.insert(make_pair(make_pair(0, 0), start));
check[start][0] = make_pair(0, 0);
for(;;){
int t = mm.begin()->first.first;
int rev = mm.begin()->first.second;
int curr = mm.begin()->second;
mm.erase(mm.begin());
if(check[curr][rev?1:0] != make_pair(t, rev))
continue;
if(curr == goal){
cout << t << ' ' << rev << endl;
break;
}
for(unsigned i=0; i<edges[curr].size(); ++i){
if(rev != 0 && edges[curr][i].second != 0)
continue;
int t2 = t + 1;
int rev2 = rev + edges[curr][i].second;
int next = edges[curr][i].first;
if(make_pair(t2, rev2) < check[next][rev2?1:0]){
mm.insert(make_pair(make_pair(t2, rev2), next));
check[next][rev2?1:0] = make_pair(t2, rev2);
}
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A,B,C,K;
cin>>A>>B>>C>>K;
int kai=0;
while(A>=B){
B=B*2;
kai++;
}
while(B>=C){
C=C*2;
kai++;
}
if(kai<=K) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, ca = 0, cb = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
if (x == 100)
++ca;
else
++cb;
sum += x;
}
if (sum % 2 == 1)
cout << "NO\n";
else {
bool ok = 0;
for (int i = 0; i <= ca; ++i)
for (int j = 0; j <= cb; ++j)
if (i * 100 + j * 200 == sum / 2) ok = 1;
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 69, base = 1024 * 1024, mod = 1e9 + 7;
int n;
tuple<int, int, int, int> pref[N];
tuple<int, int, int, int> suma(tuple<int, int, int, int> a,
tuple<int, int, int, int> b) {
tuple<int, int, int, int> re;
get<0>(a) = max(get<0>(a), get<0>(b));
get<1>(a) = max(get<1>(a), get<1>(b));
get<2>(a) = min(get<2>(a), get<2>(b));
get<3>(a) = min(get<3>(a), get<3>(b));
return a;
}
void pisz(tuple<int, int, int, int> a) {
if (get<0>(a) > get<2>(a)) return;
if (get<1>(a) > get<3>(a)) return;
cout << get<0>(a) << " ";
cout << get<1>(a) << " ";
exit(0);
}
int32_t main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<tuple<int, int, int, int>> vek;
for (int i = 0; i <= n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
vek.push_back({a, b, c, d});
pref[i] = vek[i];
if (i != 0) pref[i] = suma(pref[i], pref[i - 1]);
}
tuple<int, int, int, int> suf = vek.back();
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
pisz(pref[i - 1]);
} else {
suf = suma(suf, vek[i + 1]);
if (i == 0)
pisz(suf);
else
pisz(suma(suf, pref[i - 1]));
}
}
}
| 3 |
#include <iostream>
#include <cstdlib>
#include <string>
#include <cmath>
#include <algorithm>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
const int INF = 1 << 29;
int t[1000];
int l[1000];
int main(){
int n,m;
while(cin >> n >> m && (n || m)){
rep(i, n){
cin >> t[i];
}
rep(i, n){
int least = INF;
int c = INF;
rep(j, i){
least = min(least, l[j]);
}
rep(j, i){
if(l[j] == least) c = min(c, t[j]);
}
int p = m / t[i] * t[i];
int q = (least + t[i] - 1) / t[i] * t[i];
int r = min(p, q);
l[i] = r;
if(r == least && c > t[i] && r + t[i] <= m) l[i] += t[i];
}
int less = INF;
rep(i, n) less = min(less, l[i]);
int cnt = 0, id;
rep(i, n){
if(l[i] == less) cnt++, id = i;
}
if(cnt == 1) {
cout << id + 1 << endl;
}else{
cnt = 0;
id = 0;
int dif = INF;
rep(i, n){
if(l[i] == less) dif = min(dif, t[i]);
}
rep(i, n){
if(l[i] == less && dif == t[i]) cnt++, id = i;;
}
if(cnt== 1){
cout << id + 1 << endl;
}else{
cout << n << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void start() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
int a[10];
for (int i = 0; i < 10; i++) a[i] = 0;
for (int i = 0; i < n; i++)
for (int j = 2; j <= (s[i] - '0'); j++) a[j]++;
for (int j = 0; j < a[7]; j++)
for (int h = 6; h > 1; h--) a[h]--;
for (int j = 0; j < a[5]; j++)
for (int h = 4; h > 1; h--) a[h]--;
a[3] += 2 * a[9] + a[6];
a[9] = 0;
a[2] += 3 * a[8] + 2 * a[4] + a[6];
a[8] = 0;
a[6] = 0;
a[4] = 0;
a[2] -= a[3];
for (int i = 9; i > 1; i--)
for (int j = 0; j < a[i]; j++) cout << i;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int n, a[11111], m, ans, ans1, b[11111], leaf, jolt, flar,
umbr, glac, sylv;
bool used[11111];
vector<int> v;
int main() {
string s;
cin >> n;
cin >> s;
if (s.size() == 8) {
cout << "vaporeon";
return 0;
}
if (s.size() == 6) {
cout << "espeon";
return 0;
}
s.erase(4, 3);
for (int i = 0; i <= 3; ++i) {
if (s[0] == 's') {
sylv++;
}
if (s[0] == 'g') {
glac++;
}
if (s[0] == 'u') {
umbr++;
}
if (s[0] == 'l') {
leaf++;
}
if (s[0] == 'j') {
jolt++;
}
if (s[0] == 'f') {
flar++;
}
if (s[1] == 'y') {
sylv++;
}
if (s[1] == 'l') {
glac++;
}
if (s[1] == 'm') {
umbr++;
}
if (s[1] == 'e') {
leaf++;
}
if (s[1] == 'o') {
jolt++;
}
if (s[1] == 'l') {
flar++;
}
if (s[2] == 's') {
sylv++;
}
if (s[2] == 'a') {
glac++;
}
if (s[2] == 'b') {
umbr++;
}
if (s[2] == 'a') {
leaf++;
}
if (s[2] == 'l') {
jolt++;
}
if (s[2] == 'a') {
flar++;
}
if (s[3] == 'v') {
sylv++;
}
if (s[3] == 'c') {
glac++;
}
if (s[3] == 'r') {
umbr++;
}
if (s[3] == 'f') {
leaf++;
}
if (s[3] == 't') {
jolt++;
}
if (s[3] == 'r') {
flar++;
}
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == glac) {
cout << "glaceon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == flar) {
cout << "flareon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == sylv) {
cout << "sylveon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == leaf) {
cout << "leafeon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == umbr) {
cout << "umbreon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == jolt) {
cout << "jolteon";
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
int n, t;
int main() {
scanf("%d", &n);
n == 1 << (t = log2(n)) ? puts("YES") : puts("NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int pos[500005][25], arr[500005], fa[500005][25], bit[500005];
inline int calc(int x, int y) {
if (arr[x] <= arr[y]) return x;
return y;
}
inline int query(int l, int r) {
int len = bit[r - l + 1];
return calc(pos[l][len], pos[r - (1 << len) + 1][len]);
}
int main() {
for (int i = 2; i < 500005; i++) bit[i] = bit[i >> 1] + 1;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", arr + i);
arr[i + n] = arr[i];
}
for (int i = 0; i < n << 1; i++) {
arr[i] = i - arr[i];
pos[i][0] = i;
}
for (int i = 1; i < 20; i++) {
for (int j = 0; j + (1 << i) <= n + n; j++)
pos[j][i] = calc(pos[j][i - 1], pos[j + (1 << i - 1)][i - 1]);
}
for (int i = 0; i < n << 1; i++) fa[i][0] = query(arr[i], i);
for (int i = 1; i < 20; i++) {
for (int j = 0; j < n << 1; j++) fa[j][i] = fa[fa[j][i - 1]][i - 1];
}
long long ans = 0;
for (int i = n; i < n << 1; i++) {
int x = i;
ans += (arr[i] > i - n + 1) + 1;
for (int j = 19; j >= 0; j--) {
if (arr[fa[x][j]] > i - n + 1) {
x = fa[x][j];
ans += 1 << j;
}
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n;
cin>>n;
vector<int> a(n);
priority_queue<int> q;
ll extra=0,ans=0;
for(int i=0;i<n;i++) cin>>a[i];
for(int i=0;i<n;i++){
int b;
cin>>b;
if(a[i]<b) ans++,extra+=b-a[i];
else q.push(a[i]-b);
}
while(extra>0){
if(q.empty()){
cout<<-1<<endl;
return 0;
}
int x=q.top();
q.pop();
extra-=x;
if(x!=0) ans++;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 123;
int neg = 0;
int pos = 0;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
pair<int, int> p;
cin >> p.first >> p.second;
if (p.first > 0)
pos++;
else
neg++;
}
if (pos <= 1 || neg <= 1) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = (int)1e5 + 11;
string second;
int main() {
getline(cin, second);
if (second[0] == '#') {
cout << -1 << endl;
return 0;
}
vector<int> ans;
int last = 0;
int cur = 0;
for (int i = 0; i < (int)second.size(); i++) {
if (second[i] == '(')
cur++;
else if (second[i] == ')') {
if (cur)
cur--;
else {
while (last < (int)ans.size() && ans[last] == 1) last++;
if (last >= (int)ans.size()) {
cout << -1 << endl;
return 0;
}
ans[last]--;
}
} else {
if (cur == 0) {
while (last < (int)ans.size() && ans[last] == 1) last++;
if (last >= (int)ans.size()) {
cout << -1 << endl;
return 0;
}
ans[last]--;
ans.push_back(1);
} else {
ans.push_back(cur);
cur = 0;
}
}
}
if (cur) return cout << -1 << endl, 0;
for (__typeof(ans.begin()) it = ans.begin(); it != ans.end(); it++)
printf("%d\n", *it);
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 10;
const int N = 5e2 + 10;
using namespace std;
long long gcd(long long p, long long q) { return q == 0 ? p : gcd(q, p % q); }
long long qpow(long long p, long long q) {
long long f = 1;
while (q) {
if (q & 1) f = f * p % 1000000007;
p = p * p % 1000000007;
q >>= 1;
}
return f;
}
int n, m, k, t;
vector<int> d[4][11][10];
char a[maxn], b[maxn];
int gao(char p) {
if (p == 'A')
return 0;
else if (p == 'T')
return 1;
else if (p == 'G')
return 2;
else
return 3;
}
void add(vector<int>& d, int x, int y) {
while (x < d.size()) d[x] += y, x += x & (-x);
}
int get(vector<int>& d, int x) {
int ret = 0;
while (x) ret += d[x], x -= x & (-x);
return ret;
}
int main() {
int i, j;
scanf("%s", a + 1);
n = strlen(a + 1);
for (i = 0; i <= (int)3; i++)
for (j = 1; j <= (int)10; j++)
for (k = 0; k <= (int)j - 1; k++) d[i][j][k].resize((n + j - 1) / j + 1);
for (i = 1; i <= n; i++) {
for (j = 1; j <= 10; j++) {
add(d[gao(a[i])][j][(i - 1) % j], (i - 1) / j + 1, 1);
}
}
int q;
scanf("%d", &q);
while (q--) {
int op, x, y;
scanf("%d%d", &op, &x);
if (op == 1) {
scanf("%s", b);
for (i = 1; i <= (int)10; i++)
add(d[gao(a[x])][i][(x - 1) % i], (x - 1) / i + 1, -1);
for (i = 1; i <= (int)10; i++)
add(d[gao(b[0])][i][(x - 1) % i], (x - 1) / i + 1, 1);
a[x] = b[0];
} else {
scanf("%d%s", &y, b);
int len = strlen(b), ret = 0;
for (i = 0; i < len && i < y - x + 1; i++) {
int mo = (i + x - 1) % len;
ret += get(d[gao(b[i])][len][mo], (y - 1 - mo) / len + 1) -
get(d[gao(b[i])][len][mo], (x - 1 + len - 1 - mo) / len);
}
printf("%d\n", ret);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> e[50001];
bool xet[50001];
int cha[50001];
int n, r1, r2;
void dfs(int u) {
xet[u] = true;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (!xet[v]) {
cha[v] = u;
dfs(v);
}
}
}
int main() {
scanf("%d%d%d", &n, &r1, &r2);
for (int i = 1; i <= n; i++)
if (i != r1) {
int cha;
scanf("%d", &cha);
e[cha].push_back(i);
e[i].push_back(cha);
}
dfs(r2);
for (int i = 1; i <= n; i++)
if (i != r2) printf("%d ", cha[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const long long Inf = 3000000000000000000ll;
int n;
long long x[N] = {}, y[N] = {}, z[N] = {}, mx, my, mz;
long long m1[4] = {}, m2[4] = {}, v[4] = {};
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%I64d%I64d%I64d", x + i, y + i, z + i);
for (int i = 0; i < 4; ++i) m1[i] = Inf, m2[i] = -Inf;
for (int i = 1; i <= n; ++i) {
v[0] = x[i] + y[i] + z[i];
v[1] = x[i] + y[i] - z[i];
v[2] = x[i] - y[i] + z[i];
v[3] = -x[i] + y[i] + z[i];
for (int j = 0; j < 4; ++j)
m1[j] = min(m1[j], v[j]), m2[j] = max(m2[j], v[j]);
}
}
bool check(long long mid) {
long long l[4] = {}, r[4] = {};
for (int d = 0; d <= 1; ++d) {
r[0] = m1[0] + mid - d * 3, l[0] = m2[0] - mid - d * 3;
for (int j = 1; j <= 3; ++j) r[j] = m1[j] + mid - d, l[j] = m2[j] - mid - d;
bool flag = true;
for (int j = 0; j <= 3; ++j) {
if (l[j] < 0)
l[j] = l[j] / 2 * 2;
else
l[j] = (l[j] + 1) / 2 * 2;
if (r[j] < 0)
r[j] = (r[j] - 1) / 2 * 2;
else
r[j] = r[j] / 2 * 2;
}
for (int j = 0; j <= 3; ++j) flag &= (l[j] <= r[j]);
if (!flag) continue;
long long now = accumulate(l + 1, l + 4, 0ll);
if (now > r[0]) continue;
for (int j = 1; j <= 3; ++j)
if (now < l[0]) {
long long add = min(l[0] - now, r[j] - l[j]);
now += add, l[j] += add;
}
if (now < l[0]) continue;
mx = (l[1] + l[2]) / 2 + d, my = (l[1] + l[3]) / 2 + d,
mz = (l[2] + l[3]) / 2 + d;
return true;
}
return false;
}
void work() {
long long l = 0, r = Inf;
while (l != r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
check(l);
printf("%I64d %I64d %I64d\n", mx, my, mz);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
init();
work();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, m, q;
int grid[100][100];
int base[100][100];
int cross[100][100][100];
int fp[50][50][50][50];
int sp[50][50][50][50];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) grid[i][j] = 1;
for (int i = 1; i <= n; i++) {
char str[100];
scanf("%s", str);
for (int j = 1; j <= m; j++)
if (str[j - 1] == '0')
grid[i][j] = 0;
else
grid[i][j] = 1;
}
memset(base, 0, sizeof(base));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (grid[i][j])
base[i][j] = 0;
else
base[i][j] = base[i - 1][j] + 1;
memset(cross, 0, sizeof(cross));
for (int s = 1; s <= n; s++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (base[i][j] >= s)
cross[s][i][j] = cross[s][i][j - 1] + 1;
else
cross[s][i][j] = 0;
}
memset(fp, 0, sizeof(fp));
for (int s = 1; s <= n; s++)
for (int t = 1; t <= m; t++)
for (int i = s; i <= n; i++)
for (int j = t; j <= m; j++) {
int w = i - s + 1, l = j - t + 1;
fp[s][t][i][j] = fp[s][t][i][j - 1];
for (int k = 1; k <= w; k++)
fp[s][t][i][j] += std::min(l, cross[k][i][j]);
}
memset(sp, 0, sizeof(sp));
for (int s = 1; s <= n; s++)
for (int t = 1; t <= m; t++)
for (int i = s; i <= n; i++)
for (int j = t; j <= m; j++) {
int w = i - s + 1, l = j - t + 1;
sp[s][t][i][j] = sp[s][t][i - 1][j] + fp[s][t][i][j];
}
for (int i = 1; i <= q; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", sp[a][b][c][d]);
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) { return (a.first > b.first); }
struct mycomp {
bool operator()(const int& a, const int& b) const { return (a > b); }
};
int main() {
int n, s;
cin >> n >> s;
map<int, int, mycomp> m1;
map<int, int> m2;
int q, p;
string tmp;
for (int i = 0; i < n; i++) {
cin >> tmp >> p >> q;
if (tmp[0] == 'B')
m1[p] += q;
else
m2[p] += q;
}
vector<pair<int, int> > a1, a2;
int count = 0;
for (auto it = m2.begin(); it != m2.end() && count < s; it++) {
a1.push_back({it->first, it->second});
count++;
}
count = 0;
for (auto it = m1.begin(); it != m1.end() && count < s; it++) {
a2.push_back({it->first, it->second});
count++;
}
sort(a1.begin(), a1.end(), comp);
sort(a2.begin(), a2.end(), comp);
for (auto& elem : a1)
cout << "S " << elem.first << " " << elem.second << endl;
for (auto& elem : a2)
cout << "B " << elem.first << " " << elem.second << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5009, MOD = 998244353;
template <unsigned _MOD_>
struct modint {
static const int MOD = _MOD_;
int v;
modint(int _v = 0) {
v = _v % MOD;
if (v < 0) v += MOD;
}
explicit operator int() const { return v; }
static int mod_inv(int a) {
int g = MOD, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + MOD : x;
}
modint &operator+=(const modint &other) {
v += other.v;
if (v >= MOD) v -= MOD;
return *this;
}
modint &operator-=(const modint &other) {
v -= other.v;
if (v < 0) v += MOD;
return *this;
}
modint &operator*=(const modint &other) {
v = ((uint64_t)v * other.v) % MOD;
return *this;
}
modint &operator/=(const modint &other) { return *this *= other.inv(); }
friend modint operator+(const modint &a, const modint &b) {
return modint(a) += b;
}
friend modint operator-(const modint &a, const modint &b) {
return modint(a) -= b;
}
friend modint operator*(const modint &a, const modint &b) {
return modint(a) *= b;
}
friend modint operator/(const modint &a, const modint &b) {
return modint(a) /= b;
}
modint &operator++() {
v = v == MOD - 1 ? 0 : v + 1;
return *this;
}
modint &operator--() {
v = v == 0 ? MOD - 1 : v - 1;
return *this;
}
modint operator++(int32_t) {
modint before = *this;
++*this;
return before;
}
modint operator--(int32_t) {
modint before = *this;
--*this;
return before;
}
modint operator-() const { return v == 0 ? 0 : MOD - v; }
bool operator==(const modint &other) const { return v == other.v; }
bool operator!=(const modint &other) const { return v != other.v; }
modint inv() const { return mod_inv(v); }
modint pow(int p) const {
modint a = *this, result = 1;
while (p > 0) {
if (p & 1) result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &out, const modint &m) {
return out << m.v;
}
};
using mint = modint<MOD>;
int n, a[N];
mint dp[N][N];
mint sm[N], ds[N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; ++i) {
dp[i][1] = 1;
}
for (int i = 0; i < n; ++i) {
int ct = upper_bound(a, a + n, a[i] / 2) - a;
int up = lower_bound(a, a + n, a[i] * 2) - a;
for (int j = 1; j <= n; ++j) {
sm[j] += ds[j][i];
dp[i][j] += sm[j];
dp[i][j + 1] += dp[i][j] * (ct - j + 1);
ds[j + 1][up] += dp[i][j];
}
}
mint ans = 0;
for (int i = 0; i < n; ++i) {
ans += dp[i][n];
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > upd;
struct query {
int l, r, t, id, ans;
query() {}
query(int _l, int _r, int _t, int _id) {
l = _l;
r = _r;
t = _t;
id = _id;
}
};
vector<query> que;
stack<pair<int, int> > S;
vector<int> V;
int M[1005][105];
int sz[1005];
int cnt[300005];
int data[100005];
int B;
int l = 1, r = 0, t = 0, Ans = 1;
int cmp(query a, query b) {
if (a.l / B != b.l / B) return a.l < b.l;
if (a.r / B != b.r / B) return a.r < b.r;
return a.t < b.t;
}
int cmpid(query a, query b) { return a.id < b.id; }
int Upd() {
for (int i = (Ans / 100); i < (1000); i++)
if (sz[i] < 100) {
for (int j = (0); j < (100); j++)
if (!M[i][j]) {
return i * 100 + j;
}
}
}
void Add(int a) {
if (!M[a / 100][a % 100]) sz[a / 100]++;
M[a / 100][a % 100]++;
if (Ans == a) Ans = Upd();
}
void Del(int a) {
M[a / 100][a % 100]--;
if (!M[a / 100][a % 100]) {
sz[a / 100]--;
if (Ans > a) Ans = a;
}
}
void add(int a) {
Del(cnt[a]);
Add(++cnt[a]);
}
void del(int a) {
Del(cnt[a]);
Add(--cnt[a]);
}
int main() {
M[0][0] = 1e9;
int n, m;
scanf("%d%d", &n, &m);
B = pow(n, 2.0 / 3);
for (int i = (1); i < (n + 1); i++)
scanf("%d", &data[i]), V.push_back(data[i]);
while (m--) {
int co, a, b;
scanf("%d%d%d", &co, &a, &b);
if (co == 1)
que.push_back(query(a, b, (int)(upd).size(), (int)(que).size()));
else
upd.push_back(make_pair(a, b)), V.push_back(b);
}
sort(V.begin(), V.end());
V.erase(unique(V.begin(), V.end()), V.end());
for (int i = (1); i < (n + 1); i++)
data[i] = lower_bound(V.begin(), V.end(), data[i]) - V.begin() + 1;
for (int i = (0); i < ((int)(upd).size()); i++)
upd[i].second =
lower_bound(V.begin(), V.end(), upd[i].second) - V.begin() + 1;
sort(que.begin(), que.end(), cmp);
for (int i = (0); i < ((int)(que).size()); i++) {
while (l > que[i].l) {
l--;
add(data[l]);
}
while (r < que[i].r) {
r++;
add(data[r]);
}
while (r > que[i].r) {
del(data[r]);
r--;
}
while (l < que[i].l) {
del(data[l]);
l++;
}
while (t < que[i].t) {
int pos = upd[t].first;
S.push(make_pair(pos, data[pos]));
if (l <= pos && pos <= r) del(data[pos]);
data[pos] = upd[t].second;
if (l <= pos && pos <= r) add(data[pos]);
t++;
}
while (t > que[i].t) {
t--;
int pos = S.top().first;
if (l <= pos && pos <= r) del(data[pos]);
data[pos] = S.top().second;
if (l <= pos && pos <= r) add(data[pos]);
S.pop();
}
que[i].ans = Ans;
}
sort(que.begin(), que.end(), cmpid);
for (int i = (0); i < ((int)(que).size()); i++) printf("%d\n", que[i].ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int st[1005], ed[1005], wei[1005], hp[1005], val[1005];
vector<int> lk[1005];
int dp[505][1005];
int sub[1005];
int func(int id, int L) {
if (L > hp[id]) L = hp[id];
if (dp[id][L] != -1) return dp[id][L];
for (int i = (st[id] + 1); i <= (ed[id]); i++) {
for (int j = (0); j < (lk[i].size()); j++) {
int k = lk[i][j];
if (st[k] >= st[id] && L >= wei[k] && k != id) func(k, L - wei[k]);
}
}
sub[st[id]] = 0;
for (int i = (st[id] + 1); i <= (ed[id]); i++) {
sub[i] = sub[i - 1];
for (int j = (0); j < (lk[i].size()); j++) {
int k = lk[i][j];
if (st[k] >= st[id] && L >= wei[k] && k != id) {
sub[i] = max(sub[i], sub[st[k]] + func(k, L - wei[k]));
}
}
}
dp[id][L] = sub[ed[id]] + val[id];
return dp[id][L];
}
int solve() {
for (int i = (0); i < (n); i++)
if (m >= wei[i]) func(i, m - wei[i]);
sub[0] = 0;
for (int i = (1); i <= (n + n); i++) {
sub[i] = sub[i - 1];
for (int j = (0); j < (lk[i].size()); j++) {
int k = lk[i][j];
if (m >= wei[k]) {
sub[i] = max(sub[i], sub[st[k]] + func(k, m - wei[k]));
}
}
}
return sub[n + n];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); i++) {
scanf("%d%d%d%d%d", &st[i], &ed[i], &wei[i], &hp[i], &val[i]);
lk[ed[i]].push_back(i);
}
memset(dp, -1, sizeof(dp));
printf("%d\n", solve());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], dp[maxn], n;
int lis() {
int len = 1;
dp[1] = a[1];
for (int i = 2; i <= n; i++) {
if (a[i] >= dp[len]) {
dp[++len] = a[i];
} else {
int pos = upper_bound(dp + 1, dp + len + 1, a[i]) - dp;
dp[pos] = a[i];
}
}
return len;
}
int main() {
int k1, k2, k3, tmp;
scanf("%d%d%d", &k1, &k2, &k3);
n = k1 + k2 + k3;
for (int i = 1; i <= k1; i++) scanf("%d", &tmp), a[tmp] = 1;
for (int i = 1; i <= k2; i++) scanf("%d", &tmp), a[tmp] = 2;
for (int i = 1; i <= k3; i++) scanf("%d", &tmp), a[tmp] = 3;
int ans = n - lis();
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
/*{{{*/ //template
#define rep(i,n) for(int i=0;i<n;i++)
constexpr int INF = numeric_limits<int>::max()/2;
constexpr long long LINF = numeric_limits<long long>::max()/3;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
#define sz(x) (int)(x).size()
#define debug(x) cerr<<#x<<":"<<x<<endl
#define debug2(x,y) cerr<<#x<<","<<#y":"<<x<<","<<y<<endl
//struct fin{ fin(){ cin.tie(0); ios::sync_with_stdio(false); } } fin_;
struct Double{ double d; explicit Double(double x) : d(x){} };
ostream& operator<<(ostream& os,const Double x){ os << fixed << setprecision(20) << x.d; return os; }
template<typename T> ostream& operator<<(ostream& os,const vector<T>& vec){ os << "["; for(const auto& v : vec){ os << v << ","; } os << "]"; return os; }
template<typename T,typename U> ostream& operator<<(ostream& os,const pair<T,U>& p){ os << "(" << p.first << ","<< p.second <<")"; return os; }
template<typename T> ostream& operator<<(ostream& os,const set<T>& st){ os<<"{"; for(T v:st) os<<v<<","; os <<"}"; return os; }
template<typename T,typename U> inline void chmax(T &x,U y){ if(y>x) x = y; }
template<typename T,typename U> inline void chmin(T &x,U y){ if(y<x) x = y; }
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
ll gcd(ll a,ll b){ if(b==0) return a; else return gcd(b,a%b); }
//constexpr double eps = 1e-14;
constexpr double eps = 1e-10;
constexpr ll mod = 1e9+7;
const int dx[]={1,0,-1,0} ,dy[] = {0,1,0,-1};
/*}}}*/
int main(){
double th;
cin >> th;
int h = th /30;
double re = th - 30 * h;
int m = re / 0.5;
cout << h << " " << m << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int MOD = 1000000007;
vector<pii> ree;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = (0); i < (n); i++) {
int x, v;
cin >> x >> v;
ree.push_back({x + v, x - v});
}
sort(ree.begin(), ree.end());
int cl = -2e9, a = 0;
for (int i = (0); i < (n); i++)
if (cl <= ree[i].second) cl = ree[i].first, a++;
cout << a << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const int N = 5 * (int)1e5 + 100;
long long n, m, k;
unsigned long long p2[N], c[N];
class UFDS {
public:
vector<long long> p, rank;
UFDS(int n) {
rank.assign(n, 0);
p.assign(n, 0);
for (int i = 0; i < n; i++) p[i] = i;
}
long long findSet(long long i) {
return (p[i] == i) ? i : p[i] = findSet(p[i]);
}
bool isSameSet(long long i, long long j) { return findSet(i) == findSet(j); }
bool unionSet(long long i, long long j) {
if (!isSameSet(i, j)) {
long long x = findSet(i), y = findSet(j);
if (x == y) return false;
if (rank[x] > rank[y]) {
p[y] = x;
} else {
p[x] = y;
if (rank[x] == rank[y]) rank[y]++;
}
return true;
}
return false;
}
};
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) cin >> c[i];
p2[0] = 1;
for (long long i = 0; i < N; i++)
if (i) p2[i] = (p2[i - 1] * 2LL) % MOD;
long long ans = p2[n + k];
map<long long, vector<pair<long long, long long> > > gr;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b, a--, b--;
gr[c[a] ^ c[b]].push_back(pair<long long, long long>(a, b));
}
map<long long, long long> id;
for (auto e : gr) {
vector<pair<long long, long long> > cur = e.second;
long long cc = n;
long long m = 1;
id.clear();
UFDS ufds(cur.size() * 2 + 100);
for (auto ee : cur) {
long long a = ee.first, b = ee.second;
if (id.count(a))
a = id[a];
else
id[a] = m++, a = m - 1;
if (id.count(b))
b = id[b];
else
id[b] = m++, b = m - 1;
if (ufds.unionSet(a, b)) cc--;
}
ans = (ans - p2[n] + MOD) % MOD;
ans = (ans + p2[cc]) % MOD;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ul = std::uint32_t;
using li = std::int32_t;
using ull = std::uint64_t;
using ll = std::int64_t;
using vul = std::vector<ul>;
using vvul = std::vector<vul>;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using vvvb = std::vector<vvb>;
using vull = std::vector<ull>;
using vvull = std::vector<vull>;
using vli = std::vector<li>;
using vll = std::vector<ll>;
using pulul = std::pair<ul, ul>;
using vpulul = std::vector<pulul>;
const ul mod = 998244353;
const ul base = 1234234;
ul n, m;
class point {
public:
ll x = 0;
ll y = 0;
point() = default;
point(ll a, ll b) : x(a), y(b) {}
};
point operator-(const point& a, const point& b) {
return point(a.x - b.x, a.y - b.y);
}
point operator+(const point& a, const point& b) {
return point(a.x + b.x, a.y + b.y);
}
ll det(const point& a, const point& b) { return a.x * b.y - a.y * b.x; }
bool lesslean(const point& a, const point& b) { return det(a, b) > 0; }
std::vector<point> datas(1e5);
std::vector<point> top;
std::vector<point> but;
std::vector<point> hull;
std::vector<ul> hash1;
std::vector<ul> hash2;
vul hashn1, hashn2, hashm1, hashm2;
void exgcd(li a, li b, li& x, li& y) {
if (b) {
exgcd(b, a % b, y, x);
y -= x * (a / b);
} else {
x = 1;
y = 0;
}
}
ul inverse(ul a) {
li x, y;
exgcd(mod, a, x, y);
return y < 0 ? li(mod) + y : y;
}
ul plus(ul a, ul b) { return a + b < mod ? a + b : a + b - mod; }
ul minus(ul a, ul b) { return a < b ? a + mod - b : a - b; }
ul times(ul a, ul b) { return ull(a) * b % mod; }
void gethull() {
std::sort(datas.begin(), datas.end(), [](const point& a, const point& b) {
return a.x != b.x ? a.x < b.x : a.y > b.y;
});
top.resize(0);
for (const point& p : datas) {
while (top.size() > 1) {
const point& a = *(top.end() - 2);
const point& b = *(top.end() - 1);
if (!lesslean(p - b, b - a)) {
top.pop_back();
} else {
break;
}
}
top.push_back(p);
}
std::reverse(datas.begin(), datas.end());
but.resize(0);
for (const point& p : datas) {
while (but.size() > 1) {
const point& a = *(but.end() - 2);
const point& b = *(but.end() - 1);
if (!lesslean(p - b, b - a)) {
but.pop_back();
} else {
break;
}
}
but.push_back(p);
}
hull.resize(0);
for (ul i = 1; i != top.size(); ++i) {
hull.push_back(top[i]);
}
for (ul i = 1; i != but.size(); ++i) {
hull.push_back(but[i]);
}
ul inv = inverse(hull.size());
point cen;
for (ul i = 0; i != hull.size(); ++i) {
cen.x = plus(cen.x, times(hull[i].x, inv));
cen.y = plus(cen.y, times(hull[i].y, inv));
}
hash1.resize(hull.size());
hash2.resize(hull.size());
hull.push_back(hull.front());
for (ul i = 0; i + 1 != hull.size(); ++i) {
hash1[i] = plus(times(minus(hull[i].x, cen.x), minus(hull[i].x, cen.x)),
times(minus(hull[i].y, cen.y), minus(hull[i].y, cen.y)));
hash2[i] = plus(
times(minus(hull[i].x, hull[i + 1].x), minus(hull[i].x, hull[i + 1].x)),
times(minus(hull[i].y, hull[i + 1].y),
minus(hull[i].y, hull[i + 1].y)));
}
}
vul fhashn;
vul fhashm;
vul basepow(1e5 + 1, 1);
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
for (ul i = 1; i != basepow.size(); ++i) {
basepow[i] = times(basepow[i - 1], base);
}
std::cin >> n >> m;
datas.resize(n);
for (ul i = 0; i != n; ++i) {
std::cin >> datas[i].x >> datas[i].y;
}
gethull();
hashn1 = hash1;
hashn2 = hash2;
datas.resize(m);
for (ul i = 0; i != m; ++i) {
std::cin >> datas[i].x >> datas[i].y;
}
gethull();
hashm1 = hash1;
hashm2 = hash2;
if (hashn1.size() != hashm1.size()) {
std::cout << "NO" << std::endl;
return 0;
}
fhashn.resize(hashn1.size() * 2 + 1);
fhashm.resize(hashm1.size() + 1);
for (ul i = 0; i != hashn1.size(); ++i) {
fhashn[i + 1] =
plus(plus(hashn1[i], times(hashn2[i], 2)), times(fhashn[i], base));
fhashm[i + 1] =
plus(plus(hashm1[i], times(hashm2[i], 2)), times(fhashm[i], base));
}
ul t = hashn1.size();
for (ul i = hashn1.size(); i != 2 * hashn1.size(); ++i) {
fhashn[i + 1] = plus(plus(hashn1[i - t], times(hashn2[i - t], 2)),
times(fhashn[i], base));
}
for (ul i = 0; i != t; ++i) {
if (minus(fhashn[i + t], times(fhashn[i], basepow[t])) ==
minus(fhashm[t], times(fhashm[0], basepow[t]))) {
std::cout << "YES" << std::endl;
return 0;
}
}
std::cout << "NO" << std::endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
stack<int> s;
int a[n + 1], b[m];
long long ans = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < m; i++) {
int j = b[i];
stack<int> f;
while (!s.empty()) {
int z = s.top();
if (z == j) {
s.pop();
break;
}
f.push(z);
ans += a[z];
s.pop();
}
while (!f.empty()) {
int x = f.top();
s.push(x);
f.pop();
}
s.push(j);
}
cout << ans << "\n";
}
| 3 |
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <numeric>
#include <utility>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
#define INF (1 << 30)
#define INFL (1LL << 62)
#define MOD7 1000000007
#define MOD9 1000000009
#define EPS 1e-10
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pul pair<ull, ull>
#define all(a) (a).begin(), (a).end()
#define mp make_pair
#define pb push_back
#define FOR(i,a,b) for (int i=(a);i<(b);++i)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);--i)
#define REP(i,n) for (int i=0;i<(n);++i)
#define RREP(i,n) for (int i=(n)-1;i>=0;--i)
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void yes() { cout << "yes" << endl; }
void no() { cout << "no" << endl; }
void Taka() { cout << "Takahashi" << endl; }
void Aoki() { cout << "Aoki" << endl; }
void digit(int d) { cout << fixed << setprecision(d); }
void IOup() { cin.tie(0); ios::sync_with_stdio(false); }
int main() {
int a[12];
for (int i = 0; i < 12; ++i)
cin >> a[i];
sort(a, a + 12);
if (!(a[0] == a[1] && a[0] == a[2] && a[0] == a[3])) {
no();
return 0;
}
if (!(a[4] == a[5] && a[4] == a[6] && a[4] == a[7])) {
no();
return 0;
}
if (!(a[8] == a[9] && a[8] == a[10] && a[8] == a[11])) {
no();
return 0;
}
yes();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int pow(long long int x, long long int y, long long int m) {
long long int res = 1;
x = x % m;
while (y > 0) {
if (y & 1) res = ((res % m) * (x % m)) % m;
y = y >> 1;
x = ((x % m) * (x % m)) % m;
}
return res % m;
}
template <typename Arg1>
void ZZ(const char* name, Arg1&& arg1) {
std::cerr << name << " = " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void ZZ(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " = " << arg1;
ZZ(comma, args...);
}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
clock_t time_p = clock();
void abhigyan10() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
const long long int mod = 1000000007;
int a[200005];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i;
cin >> n;
set<int> s, p, o;
vector<int> ans;
for (i = 1; i <= n; i++) {
s.insert(i);
}
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) {
p.insert(i);
ans.push_back(i);
} else {
s.erase(a[i]);
}
}
while (!p.empty()) {
auto x = p.begin();
auto y = s.begin();
if (*y == *x) {
y++;
if (y == s.end()) y = s.begin();
a[*x] = *y;
} else
a[*x] = *y;
s.erase(*y);
p.erase(*x);
}
for (i = 1; i <= n; i++) {
if (a[i] == i) {
swap(a[i], a[ans[0]]);
}
}
for (i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k, l;
cin >> n;
while (n--) {
long long int n1, k1;
cin >> n1 >> k1;
string s;
cin >> s;
sort(s.begin(), s.end());
if (s[0] != s[k1 - 1]) {
cout << s[k1 - 1] << "\n";
} else {
cout << s[0];
if (s[k1] != s[n1 - 1]) {
for (i = k1; i < n1; i++) cout << s[i];
cout << "\n";
} else {
for (i = 0; i < (n1 - k1 + k1 - 1) / k1; i++) {
cout << s[n1 - 1];
}
cout << "\n";
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);
int n, a, b;
cin >> n >> a >> b;
string str;
cin >> str;
str.push_back('*');
int cnt = 0;
int ans = 0;
for (auto i : str) {
if (i == '.') {
++cnt;
} else {
while (cnt && (a || b)) {
if (a >= b) {
--cnt;
if (a) --a, ++ans;
if (cnt) {
--cnt;
if (b) --b, ++ans;
}
} else {
--cnt;
if (b) --b, ++ans;
if (cnt) {
--cnt;
if (a) --a, ++ans;
}
}
}
cnt = 0;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long zero = 0;
const double PI = 3.14159265358979323846;
void solve() {
long long n, m;
string s;
cin >> n;
long long a, b;
if (n % 2 == 0) {
b = 4;
a = b + n;
} else {
b = 9;
a = b + n;
}
cout << a << " " << b;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
string s, s2 = "";
cin >> n >> k >> s;
for (int i = 0; i < n; i++) {
if (k == 0) {
s2.push_back(s[i]);
} else if (i == 0 && s[i] == '1' && n > 1 || s[i] == '0') {
s2.push_back(s[i]);
} else if (i == 0 && n > 1) {
s2.push_back('1');
k--;
} else {
s2.push_back('0');
k--;
}
}
cout << s2 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double pi = 3.14159265358979;
struct pt {
double x;
double y;
};
struct line {
double a;
double b;
double c;
};
line to(pt a, pt b) {
line l;
l.a = (b.y - a.y);
l.b = (a.x - b.x);
l.c = (-a.x * l.a - a.y * l.b);
return l;
}
pt perec(line l1, line l2) {
pt o;
o.y = (l2.c * l1.a - l1.c * l2.a) / (l2.a * l1.b - l1.a * l2.b);
o.x = (l2.c * l1.b - l1.c * l2.b) / (l2.b * l1.a - l1.b * l2.a);
return o;
}
double dist(pt a, pt b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15) << "";
long long n;
cin >> n;
if (n <= 4) {
cout << "No solution";
return 0;
}
vector<pt> u;
for (long long i = 0; i < n; ++i) {
double f = (2.0 * pi * i / (n + 0.0));
pt z;
z.x = sin(f);
z.y = cos(f);
u.push_back(z);
}
vector<line> z;
for (long long i = 0; i < n; ++i) {
z.push_back(to(u[i], u[(i + 1) % n]));
}
if (n >= 10) {
for (long long i = 0; i < n; ++i) {
z[i].c *= 1000;
z[i].c += (i / (1000.0));
}
} else {
for (long long i = 0; i < n; ++i) {
z[i].c *= 500;
z[i].c += (i / (1.0));
}
}
vector<pt> ans(n);
for (long long i = 0; i < n; ++i) {
ans[i] = perec(z[i], z[(i + 1) % n]);
}
reverse(ans.begin(), ans.end());
for (long long i = 0; i < n; ++i) {
cout << ans[i].x << ' ' << ans[i].y << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int t[60], v[60];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
int nrOfStonesTakenAway = 0;
for (int i = 1; i <= n; i++) {
if (t[i] > v[i]) nrOfStonesTakenAway += (t[i] - v[i]);
}
for (int i = 1; i <= n; i++)
if (t[i] < v[i]) {
nrOfStonesTakenAway -= (v[i] - t[i]);
}
if (nrOfStonesTakenAway < 0)
puts("No");
else
puts("Yes");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<double, int> > B[2];
const double yy = 100000 - 0.000001;
int hl, hr, n;
int debug;
int getscore(int ud, double pos, double t) {
int ret = 0, flag, cnt;
{
vector<pair<double, int> > tmp = B[ud];
for (double tp = pos; tp < yy; tp += t + t) {
tmp.push_back(make_pair(tp, 0));
}
sort(tmp.begin(), tmp.end());
if (debug) {
for (int i = 0; i < (int)(tmp.size()); i++)
cout << tmp[i].first << " " << tmp[i].second << endl;
}
flag = 0;
cnt = 0;
for (int i = 0; i < (int)(tmp.size()); i++) {
if (tmp[i].second == 0 && flag == 0) return 0;
if (tmp[i].second < 0) {
flag = 1;
cnt = 0;
} else if (tmp[i].second > 0)
flag = 0;
else {
if (cnt) return 0;
ret += -tmp[i - 1].second;
cnt++;
}
}
}
{
vector<pair<double, int> > tmp = B[!ud];
for (double tp = pos + t; tp < yy; tp += t + t) {
tmp.push_back(make_pair(tp, 0));
}
sort(tmp.begin(), tmp.end());
if (debug) {
cout << ud << endl;
for (int i = 0; i < (int)(tmp.size()); i++)
cout << tmp[i].first << " " << tmp[i].second << endl;
}
flag = 0;
cnt = 0;
for (int i = 0; i < (int)(tmp.size()); i++) {
if (tmp[i].second == 0 && flag == 0) return 0;
if (tmp[i].second < 0) {
flag = 1;
cnt = 0;
} else if (tmp[i].second > 0)
flag = 0;
else {
if (cnt) return 0;
ret += -tmp[i - 1].second;
cnt++;
}
}
}
return ret;
}
int main(int argc, char *argv[]) {
scanf("%d%d%d", &hl, &hr, &n);
for (int i = 0; i < (int)(n); i++) {
int s, lt, rt;
char st[11];
scanf("%d%s%d%d", &s, st, <, &rt);
B[st[0] == 'T'].push_back(make_pair(lt - 0.00001, -s));
B[st[0] == 'T'].push_back(make_pair(rt + 0.00001, s));
}
int best = 0;
for (int k = 0; 2 * k + 2 < n; k++) {
double t, chu = 0;
chu = (100.0 - hl + hr) / 100.0 + 2 * k + 1;
t = 100000 / chu;
best = max(best, getscore(1, (100.0 - hl) / 100.0 * t, t));
chu = (100.0 - hr + hl) / 100.0 + 2 * k + 1;
t = 100000 / chu;
best = max(best, getscore(0, hl / 100.0 * t, t));
chu = (200.0 - hr - hl) / 100.0 + 2 * k;
t = 100000 / chu;
best = max(best, getscore(1, (100.0 - hl) / 100.0 * t, t));
chu = (hr + hl) / 100.0 + 2 * k;
t = 100000 / chu;
best = max(best, getscore(0, hl / 100.0 * t, t));
debug = 0;
}
cout << best << endl;
return EXIT_SUCCESS;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<long long> perm;
bool used[20];
string hf = "4";
int ans;
bool ish(long long q) {
while (q > 0) {
if (q % 10 != 4 && q % 10 != 7) return false;
q /= 10;
}
return true;
}
long long ltoa() {
long long ten = 1;
long long ta = 0;
for (int i = hf.length() - 1; i >= 0; i--) {
ta += ten * (hf[i] - '0');
ten *= 10;
}
return ta;
}
void np() {
bool ch = false;
for (int i = hf.length() - 1; i >= 0; i--) {
if (hf[i] == '4') {
hf[i] = '7';
ch = true;
break;
} else {
hf[i] = '4';
}
}
if (!ch) hf.insert(0, 1, '4');
}
int main() {
long long real = 1, qup = 1;
cin >> n >> k;
k--;
for (; qup <= k; real++) qup *= real;
real--;
if (real > n) {
cout << -1;
return 0;
}
if (k > 0) qup /= real;
int mod = n - real;
while (ltoa() <= mod) {
ans++;
np();
}
for (long long i = real - 1; i >= 1; i--) {
int u = k / qup;
for (int i = 0; i < 20; i++) {
if (!used[i]) {
u--;
if (u < 0) {
used[i] = true;
perm.push_back(i + mod);
break;
}
}
}
k %= qup;
qup /= i;
}
for (int i = 0; i < 20; i++)
if (!used[i]) {
perm.push_back(i + mod);
break;
}
for (int i = 0; i < perm.size(); i++) {
if (ish(i + mod + 1) && ish(perm[i] + 1)) ans++;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gi() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
const int N = 1005;
int n, a[N], b[N], c[N], d[N], pa[N], pb[N], pc[N], pd[N];
vector<pair<pair<int, int>, pair<int, int> > > ans;
int main() {
n = gi();
for (int i = 1; i <= n; ++i) pb[b[i] = gi()] = i;
for (int i = 1; i <= n; ++i) pa[a[i] = gi()] = i;
for (int i = 1; i <= n; ++i) c[i] = d[i] = pc[i] = pd[i] = i;
for (int i = 1; i <= n; ++i) {
if (pa[i] == c[i] && pb[i] == d[i]) continue;
ans.push_back(make_pair(make_pair(i, pc[pa[i]]), make_pair(pd[pb[i]], i)));
int x = c[i], y = d[i];
swap(c[i], c[pc[pa[i]]]);
swap(pc[pa[i]], pc[x]);
swap(d[i], d[pd[pb[i]]]);
swap(pd[pb[i]], pd[y]);
}
printf("%d\n", ans.size());
for (auto x : ans)
printf("%d %d %d %d\n", x.first.first, x.first.second, x.second.first,
x.second.second);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s;
int puede[1001][2001];
char letra[1001][2001];
char sol[1001];
void genera(int j) {
for (int i = n; i >= 1; i--) {
sol[i] = letra[i][j];
if (sol[i] == 'W')
j--;
else if (sol[i] == 'L')
j++;
}
for (int i = 1; i <= n; i++) cout << sol[i];
cout << endl;
}
int main() {
cin >> n >> k >> s;
puede[0][1000] = 1;
for (int i = 1; i <= n; i++) {
char c = s[i - 1];
if (i == n) {
if (c == 'W' or c == '?') {
puede[i][1000 + k] = puede[i - 1][1000 + (k - 1)];
letra[i][1000 + k] = 'W';
}
if (c == 'L' or c == '?') {
puede[i][1000 - k] = puede[i - 1][1000 - (k - 1)];
letra[i][1000 - k] = 'L';
}
} else {
if (c == 'W' or c == '?') {
for (int j = 1000 - (k - 1); j <= 1000 + (k - 1) - 1; j++) {
if (puede[i - 1][j]) {
puede[i][j + 1] = 1;
letra[i][j + 1] = 'W';
}
}
}
if (c == 'L' or c == '?') {
for (int j = 1000 - (k - 1) + 1; j <= 1000 + (k - 1); j++) {
if (puede[i - 1][j]) {
puede[i][j - 1] = 1;
letra[i][j - 1] = 'L';
}
}
}
if (c == 'D' or c == '?') {
for (int j = 1000 - (k - 1); j <= 1000 + (k - 1); j++) {
if (puede[i - 1][j]) {
puede[i][j] = 1;
letra[i][j] = 'D';
}
}
}
}
}
if (puede[n][1000 + k]) {
genera(1000 + k);
} else if (puede[n][1000 - k]) {
genera(1000 - k);
} else
cout << "NO" << endl;
}
| 5 |
#include <bits/stdc++.h>
using ld = long double;
const ld EPS = 1e-12;
const ld PI = acos((ld)-1);
inline bool equ(const ld& a, const ld& b) { return std::abs(a - b) < EPS; }
struct vec {
public:
ld x, y;
bool operator==(const vec& o) const { return equ(x, o.x) && equ(y, o.y); }
vec& operator+=(const vec& o) { return x += o.x, y += o.y, *this; }
vec& operator-=(const vec& o) { return x -= o.x, y -= o.y, *this; }
ld ang() { return atan2(y, x); }
friend vec operator+(vec a, const vec& b) { return a += b; }
friend vec operator-(vec a, const vec& b) { return a -= b; }
ld operator*(const vec& o) const { return x * o.x + y * o.y; }
ld mag() const { return hypot(x, y); }
};
const int MN = 1e5 + 10;
int N, S, P, G, s, p, g, ctr, op;
char t;
vec m, a[MN];
std::multiset<ld> set, val;
std::map<ld, int> map;
int main() {
scanf("%d%d%d%d", &S, &P, &G, &N);
m = vec{(ld)P / (S + P + G), (ld)G / (S + P + G)};
for (int i = 0, x = 0, y; i < N; ++i) {
scanf(" %c", &t);
if (t == 'A') {
scanf("%d%d%d", &s, &p, &g);
++x;
a[x] = {(ld)p / (s + p + g), (ld)g / (s + p + g)};
a[x] -= m;
if (a[x].mag() < EPS)
++ctr;
else {
{
ld v = a[x].ang();
auto it = map.lower_bound(v - EPS);
if (it == map.end() || !equ(it->first, v))
it = map.insert({v, 0}).first;
if (!it->second++) {
v += PI;
if (v > PI) v -= 2 * PI;
it = map.lower_bound(v - EPS);
if (it != map.end() && equ(it->first, v) && it->second) ++op;
}
}
{
ld v = a[x].ang();
auto it = set.insert(v);
auto nx = std::next(it);
if (it != set.begin()) {
auto pr = std::prev(it);
val.insert(*it - *pr);
if (nx != set.end()) val.erase(val.lower_bound(*nx - *pr - EPS));
}
if (nx != set.end()) val.insert(*nx - *it);
}
}
} else {
scanf("%d", &y);
if (a[y].mag() < EPS)
--ctr;
else {
{
ld v = a[y].ang();
auto it = map.lower_bound(v - EPS);
assert(it != map.end() && equ(it->first, v));
if (!--it->second) {
v += PI;
if (v > PI) v -= 2 * PI;
it = map.lower_bound(v - EPS);
if (it != map.end() && equ(it->first, v) && it->second) --op;
}
}
{
ld v = a[y].ang();
auto it = set.lower_bound(v - EPS);
auto nx = std::next(it);
if (it != set.begin()) {
auto pr = std::prev(it);
val.erase(val.lower_bound(*it - *pr - EPS));
if (nx != set.end()) val.insert(*nx - *pr);
}
if (nx != set.end()) val.erase(val.lower_bound(*nx - *it - EPS));
set.erase(it);
}
}
}
if (ctr)
printf("1\n");
else if (op)
printf("2\n");
else if (set.size() >= 3 && *val.rbegin() < PI &&
(2 * PI + *set.begin() - *set.rbegin()) < PI)
printf("3\n");
else
printf("0\n");
}
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int a,b,c,d,e,f;
int g,h,i,j,k,l;
cin >> a >> b >> c >> d >> e >> f;
cin >> g >> h >> i >> j >> k >> l;
for(int i=0; !(a==g && b==h); i++){
if(d==h || c==h){
int tmp = a;
a = d;
d = f;
f = c;
c = tmp;
}
for(int i=0; b!=h; i++){
int tmp=a;
a = b;
b = f;
f = e;
e = tmp;
}
for(int i=0; a!=g; i++){
int tmp=a;
a = d;
d = f;
f = c;
c = tmp;
}
}
if(c==i && d==j && e==k){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
scanf("%d%d", &a, &b);
for (int i = 1;; i++) {
if (a < i) {
printf("Vladik");
return 0;
}
a -= i;
i++;
if (b < i) {
printf("Valera");
return 0;
}
b -= i;
}
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int main(){
//sanbeki
int sanbeki[16];
int i;
sanbeki[0]=1;
for(i=1; i<=15; i++){
sanbeki[i] = 3*sanbeki[i-1];
}
//input nm
int n,m;
cin >> n >> m;
while(n!=0){
//input start
int start=0;
int kosu, bangou;
cin >> kosu;
for(i=0; i<kosu; i++){
cin >> bangou;
start += 0*sanbeki[bangou-1];
}
cin >> kosu;
for(i=0; i<kosu; i++){
cin >> bangou;
start += 1*sanbeki[bangou-1];
}
cin >> kosu;
for(i=0; i<kosu; i++){
cin >> bangou;
start += 2*sanbeki[bangou-1];
}
//bfs
int val[sanbeki[n]];
for(i=0; i<sanbeki[n]; i++){
val[i]=-1;
}
queue<int> que;
que.push(start);
val[start]=0;
int height[3];
while(!que.empty()){
int p=que.front();
que.pop();
height[0]=0;
height[1]=0;
height[2]=0;
int p_sub=p;
for(i=0; i<n; i++){
height[p_sub%3]=i+1;
p_sub = p_sub/3;
}
if(height[0]>height[1]){
if(val[p+sanbeki[height[0]-1]]<0){
val[p+sanbeki[height[0]-1]]=val[p]+1;
que.push(p+sanbeki[height[0]-1]);
}
}else if(height[0]<height[1]){
if(val[p-sanbeki[height[1]-1]]<0){
val[p-sanbeki[height[1]-1]]=val[p]+1;
que.push(p-sanbeki[height[1]-1]);
}
}
if(height[1]>height[2]){
if(val[p+sanbeki[height[1]-1]]<0){
val[p+sanbeki[height[1]-1]]=val[p]+1;
que.push(p+sanbeki[height[1]-1]);
}
}else if(height[1]<height[2]){
if(val[p-sanbeki[height[2]-1]]<0){
val[p-sanbeki[height[2]-1]]=val[p]+1;
que.push(p-sanbeki[height[2]-1]);
}
}
}
//judge
int sanbeki_max=0;
for(i=0; i<n; i++){
sanbeki_max += 2*sanbeki[i];
}
if((val[0]>=0&&val[0]<=m)||(val[sanbeki_max]>=0&&val[sanbeki_max]<=m)){
if((val[0]>=0&&val[0]<=m)&&(val[sanbeki_max]>=0&&val[sanbeki_max]<=m)){
cout << min(val[0],val[sanbeki_max]) << endl;
}else if((val[0]>=0&&val[0]<=m)){
cout << val[0] << endl;
}else{
cout << val[sanbeki_max] << endl;
}
}else{
cout << -1 << endl;
}
//input nm
cin >> n >> m;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v) in >> x;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
for (auto &x : v) out << x << ' ';
return out;
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << p.first << ' ' << p.second;
return out;
}
const bool tests = 1;
void solve_case() {
long long n, m, k;
cin >> n >> m >> k;
if (m < n - 1 || k <= 1 || m > n * (n - 1) / 2) {
cout << "NO\n";
return;
}
if (k == 2) {
if (n == 1)
cout << "YES\n";
else
cout << "NO\n";
return;
}
if (k == 3) {
if (m == n * (n - 1) / 2)
cout << "YES\n";
else
cout << "NO\n";
return;
}
cout << "YES\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long testcase = 1;
if (tests) cin >> testcase;
cout << fixed << setprecision(10);
for (long long test = 1; test <= testcase; test++) {
solve_case();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int n, a[maxn], b[maxn], tot = 0, x, y;
struct node {
int a, b, c, d;
node(){};
node(int aa, int bb, int cc, int dd) {
a = aa;
b = bb;
c = cc;
d = dd;
}
} ans[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) {
if (a[i] == i && b[i] == i) continue;
for (int j = i; j <= n; j++)
if (a[j] == i) {
swap(a[i], a[j]);
x = j;
break;
}
for (int j = i; j <= n; j++)
if (b[j] == i) {
swap(b[i], b[j]);
y = j;
break;
}
ans[++tot] = node(x, i, i, y);
}
printf("%d\n", tot);
for (int i = 1; i <= tot; i++)
cout << ans[i].a << ' ' << ans[i].b << ' ' << ans[i].c << ' ' << ans[i].d
<< '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int w = 1; w <= t; w++) {
long long int n, sum = 0, max = 2, f = 0, c = 2;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 2; i < n; i++) {
if (v[i] == v[i - 1] + v[i - 2])
c++;
else
c = 2;
if (max < c) max = c;
}
if (n >= 2)
cout << max;
else
cout << "1";
}
return 0;
}
| 2 |
#include<iostream>
#include<fstream>
#include<sstream>
#include<cstdio>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<deque>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
#include<cstdlib>
#include<climits>
#include<utility>
#include<cctype>
using namespace std;
#define ull unsigned long long
#define stt(it,order) sort(it.begin(),it.end(),order)
#define st(it) sort(it.begin(),it.end())
#define ll long long
#define rep(i,j) for(int i=0;i<j;++i)
#define loop(i,a,j) for(int i=a;i<j;++i)
#define mpi(it,table,T,E) for(map<T,E>::iterator it = table.begin();it!=table.end();++it)
#define PI 3.141592654
#define pb(v,e) v.push_back(e)
string sint(int i){
stringstream buf;
buf<<i;
return buf.str();
}
/*
ifstream fin("input.txt");
ofstream fout("output.txt");
#define cin fin
#define cout fout
*/
int graph[15][15] = {
{0,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,1,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,1,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,1,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,1,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,1,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
};
int sol[15];
int alias[] = {0,1,2,3,4,5,6,7,8,9,5,4,3,2,1};
string print(int i,int e){
if( i == -1)return "";
if(e)return print(sol[i],0)+sint(alias[i])+"\n";
return print(sol[i],0)+sint(alias[i])+" ";
}
string do_bfs(int j,int k){
bool vis[15];
memset(vis,0,sizeof(vis));
memset(sol,-1,sizeof(sol));
vis[j] = true;
sol[j] = -1;
queue<int> nodes;
nodes.push(j);
int stop = j;
while(!nodes.empty()){
int nx = nodes.front();
nodes.pop();
if( alias[nx] == k){
stop = nx;
break;
}
rep(i,15){
if( graph[nx][i] == 1 && !vis[i]){
sol[i] = nx;
vis[i] = true;
nodes.push(i);
}
}
}
return print(stop,1);
}
int main(){
int u;
scanf("%d",&u);
rep(a,u){
string sol = "1 2 3 4 5 6 7 8 9 5 4 3 2 1 0 0 0";
int j,k;
scanf("%d %d",&j,&k);
rep(i,15){
if( alias[i] == j){
string aux = do_bfs(i,k);
if( sol.size() > aux.size()) sol = aux;
}
}
printf("%s",sol.c_str());
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long a, b, n, x, y, v;
double mn = INT_MAX, time;
cin >> a >> b >> n;
while (n--) {
cin >> x >> y >> v;
time = (double)(sqrt(pow(x - a, 2) + pow(y - b, 2))) / v;
mn = min(mn, time);
}
cout << fixed << setprecision(20) << mn << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long q, n, c[30], r, a[100001];
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == ')') {
c[1]--;
if (c[1] < 0) c[2] += 2;
} else
c[1]++;
}
if (c[1] != 0)
cout << -1;
else
cout << c[2];
}
| 1 |
#include <cstdio>
int main()
{
int year, month, day;
while (~scanf("%d %d %d", &year, &month, &day)) {
if (year < 1868 || (year == 1868 && (month < 9 || (month == 9 && day < 8))))
printf("pre-meiji\n");
else if (year < 1912 || (year == 1912 && (month < 7 || (month == 7 && day < 30))))
printf("meiji %d %d %d\n", year-1868+1, month, day);
else if (year < 1926 || (year == 1926 && (month < 12 || (month == 12 && day < 25))))
printf("taisho %d %d %d\n", year-1912+1, month, day);
else if (year < 1989 || (year == 1989 && (month < 1 || (month == 1 && day < 8))))
printf("showa %d %d %d\n", year-1926+1, month, day);
else
printf("heisei %d %d %d\n", year-1989+1, month, day);
}
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main()
{
int a,b,c;
while(cin >> a >> b >> c){
if(a + b < 16) cout << "YES" << endl;
else if(a + b > 16) cout << "NO" << endl;
else if(c <= 4) cout << "NO" << endl;
else cout << "YES" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 5e18;
const long double pi = acos(-1.0);
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long double rad(long double x) { return x * pi / 180.0; }
bool isleft(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
long long det = (b.first - a.first) * (c.second - a.second) -
(c.first - a.first) * (b.second - a.second);
if (det >= 0) return true;
if (det < 0) return false;
return false;
}
long long exp(long long a, long long b) {
long long result = 1;
while (b > 0) {
if (b & 1) result = mod(result * a, MOD);
b >>= 1;
a = mod(a * a, MOD);
}
return result;
}
long long transform(vector<long long>& vet) {
long long ans = 0;
long long aux = 1;
for (long long i = vet.size() - 1; i >= 0; i--) {
ans += vet[i] * aux;
aux *= 10;
}
return ans;
}
void propaga(vector<long long>& vet) {
for (long long i = vet.size() - 1; i > 0; i--) {
if (vet[i] == 10) {
vet[i - 1]++;
vet[i] = 0;
}
}
if (vet[0] == 10) {
vet.push_back(0);
vet[0] = 1;
}
}
void solve() {
long long a, b;
cin >> a >> b;
vector<long long> vet;
long long x = a;
while (a > 0) {
vet.push_back(a % 10);
a /= 10;
}
reverse(vet.begin(), vet.end());
while (true) {
long long sum = 0;
for (long long i = 0; i < vet.size(); i++) {
sum += vet[i];
if (sum > b) {
vet[i] = 10;
for (long long j = i + 1; j < vet.size(); j++) {
vet[j] = 0;
}
propaga(vet);
break;
}
}
if (sum <= b) break;
}
a = transform(vet);
cout << a - x << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long start, n, init;
void kezd(long long l, long long r, long long dex, bool up) {
if (l == r) {
return;
}
long long m = (l + r - 1) / 2;
start = max(start, dex + m * (up ? 1ll : -1ll));
kezd(m + 1, r, dex + m * (up ? 1l : -1ll), !up);
}
void lep(long long l, long long r, long long dex, bool up) {
if (l == r) {
cout << "= " << l << endl;
return;
}
long long m = (l + r - 1) / 2;
cout << "? " << dex + m * (up ? 1ll : -1ll) << endl;
bool ans;
cin >> ans;
if (ans)
lep(l, m, dex + m * (up ? 1ll : -1ll), !up);
else
lep(m + 1, r, dex + m * (up ? 1ll : -1ll), !up);
}
int main() {
int t;
cin >> t;
while (t--) {
start = init = 0;
bool up = 0;
cin >> n;
kezd(1, n, init, up);
init += n - start;
cout << "? " << init << endl;
cin >> up;
up = 0;
lep(1, n, init, up);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char input[5002];
char tmpstr[5002];
long long int calculate(char* str, int x, int y) {
long long int tmp, result;
result = tmp = 0;
for (int i = x; i <= y;) {
if (tmp == 0)
tmp = atol(str + i);
else
tmp *= atol(str + i);
while (str[i] != '*' && str[i] != '+' && i <= y) i++;
if (str[i] == '+' || i > y) {
result += tmp;
tmp = 0;
}
i++;
}
return result;
}
long long int tie(int x, int y) {
long long int bracket = calculate(input, x, y);
strncpy(tmpstr, input, x);
sprintf(tmpstr + x, "%I64d", bracket);
strcat(tmpstr, input + y + 1);
return calculate(tmpstr, 0, strlen(tmpstr) - 1);
}
int main() {
long long int maxv;
vector<int> mul;
scanf("%s", input);
mul.push_back(-1);
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] == '*') mul.push_back(i);
}
mul.push_back(strlen(input));
maxv = calculate(input, 0, strlen(input) - 1);
for (int i = 0; i < mul.size(); i++) {
for (int j = i + 1; j < mul.size(); j++)
maxv = max(maxv, tie(mul[i] + 1, mul[j] - 1));
}
printf("%I64d\n", maxv);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string borze_code;
cin >> borze_code;
for (auto i = 0; i < borze_code.size(); i++) {
if (borze_code[i] == '.' &&
(borze_code[i + 1] == '-' ||
(borze_code[i + 1] == '\0' || (borze_code[i + 1] == '.')))) {
cout << 0;
} else if (borze_code[i] == '-' && borze_code[i + 1] == '.') {
cout << 1;
i++;
} else if (borze_code[i] == '-' && borze_code[i + 1] == '-') {
cout << 2;
i++;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
using namespace std;
const int MAXN = 2e5 + 100;
const int MOD = 1e9 + 7;
const double eps = 1e-12;
const long long INF = 1e16;
inline string toStr(long long x) {
string tmp = "";
do tmp = char(x % 10 + '0') + tmp;
while (x /= 10);
return tmp;
}
inline long long toInt(string s) {
long long res = 0;
for (auto x : s) res = res * 10 + x - '0';
return res;
}
vector<string> a;
int main() {
int n;
scanf("%d", &n);
a.resize(n);
for (int i = 0, _a = (n); i < _a; ++i) cin >> a[i];
string pat = a[0];
int res = 2e9;
for (int i = 0, _a = (pat.size()); i < _a; ++i) {
int cnt = i;
bool good = true;
for (int j = (1), _b = (n - 1); j <= _b; j++) {
bool can = true;
string tmp = a[j];
int x = 0;
while (tmp != pat) {
++x;
tmp += tmp[0], tmp.erase(0, 1);
if (x == tmp.size()) {
can = false;
break;
}
}
good &= can;
cnt += x;
}
pat += pat[0], pat.erase(0, 1);
if (good) res = min(res, cnt);
}
if (res == 2e9)
puts("-1");
else
printf("%d", res);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long nm = 0;
bool fh = true;
char cw = getchar();
for (; !isdigit(cw); cw = getchar()) fh ^= (cw == '-');
for (; isdigit(cw); cw = getchar()) nm = nm * 10 + (cw - '0');
return fh ? nm : -nm;
}
multiset<int> S;
set<pair<int, int> > seg;
int n, t[1000020], p[1000020], m, ans[1000020], f[1000020], kd[1000020], res,
now;
inline int fd(int x) { return f[x] == x ? x : f[x] = fd(f[x]); }
vector<int> pos[1000020];
inline void del(set<pair<int, int> >::iterator it) {
set<pair<int, int> >::iterator l = it, r = it;
l--, r++;
S.erase(S.find((*it).first - (*l).second - 1));
S.erase(S.find((*r).first - (*it).second - 1));
S.insert((*r).first - (*l).second - 1);
seg.erase(it);
}
inline void ins(int first, int second) {
seg.insert(make_pair(first, second));
set<pair<int, int> >::iterator it = seg.find(make_pair(first, second)),
l = it, r = it;
l--, r++;
S.insert(first - (*l).second - 1), S.insert((*r).first - (*it).second - 1),
S.erase(S.find((*r).first - (*l).second - 1));
if (!kd[first]) return;
int dnl = first, dnr = second;
dnl = (kd[(*l).first] != 0) ? ((*l).second + 1)
: (((*l).second + first + 1) >> 1);
dnr = (kd[(*r).second] != 0) ? ((*r).first - 1)
: (((*r).first + second - 1) >> 1);
for (int i = fd(dnl); i <= dnr; i = fd(dnl)) ans[i] = now, f[i] = i + 1;
}
inline set<pair<int, int> >::iterator cov(int x) {
set<pair<int, int> >::iterator it = seg.lower_bound(make_pair(x + 1, -1));
--it;
return it;
}
inline void mdf(int x) {
kd[x] = 1;
if (kd[x - 1] == 0 || kd[x + 1] == 0) {
set<pair<int, int> >::iterator it = cov(x);
int l = (*it).first, r = (*it).second;
del(it);
if (l + 1 < x) ins(l, x - 1);
if (r - 1 > x) ins(x + 1, r);
}
if (kd[x - 1] == 1 || kd[x + 1] == 1) {
int l = x, r = x;
set<pair<int, int> >::iterator it;
if (kd[x - 1] == 1) {
if (x - 1 > 1 && kd[x - 2] == 1)
it = cov(x - 1), l = (*it).first, del(it);
else
l = x - 1;
}
if (kd[x + 1] == 1) {
if (x + 1 < n + 2 && kd[x + 2] == 1)
it = cov(x + 1), r = (*it).second, del(it);
else
r = x + 1;
}
ins(l, r);
} else {
set<pair<int, int> >::iterator r = seg.upper_bound(make_pair(x, x)), l;
l = r, l--;
int tl = (*l).second, tr = (*r).first;
if (kd[tl] == 0 && kd[tr] == 0) return;
if (kd[tl] == -1 && kd[tr] == -1) return;
int dnl = 2, dnr = 1;
if (kd[tl] == 1 && kd[tr] == 1) dnl = tl + 1, dnr = tr - 1;
if (kd[tl] == 0 && kd[tr] == 1) dnl = ((tl + tr + 1) >> 1), dnr = tr - 1;
if (kd[tl] == 1 && kd[tr] == 0) dnl = tl + 1, dnr = ((tl + tr - 1) >> 1);
for (int i = fd(dnl); i <= dnr; i = fd(dnl)) ans[i] = now, f[i] = i + 1;
}
}
inline void solve(int x) {
now = t[x];
for (int j = 0, TP = pos[x].size(); j < TP; j++) mdf(pos[x][j]);
res = max(res, ((*(--S.end()) + 1)) >> 1);
}
int main() {
n = read(), kd[0] = kd[n + 3] = -1;
for (int i = 2; i <= n + 1; i++) p[i] = t[i - 1] = read();
p[1] = p[2], p[n + 2] = p[n + 1], f[n + 3] = n + 3;
sort(t + 1, t + n + 1), m = unique(t + 1, t + n + 1) - t - 1;
for (int i = 1; i <= n + 2; i++)
pos[p[i] = lower_bound(t + 1, t + m + 1, p[i]) - t].push_back(i), f[i] = i;
seg.insert(make_pair(1, n + 2)), f[1] = 2;
seg.insert(make_pair(0, 0)), seg.insert(make_pair(n + 3, n + 3));
S.insert(0), S.insert(0), S.insert(0);
for (int i = 1; i <= m; i++) solve(i);
ans[2] = t[p[2]], ans[n + 1] = t[p[n + 1]];
printf("%d\n", res);
for (int i = 2; i <= n + 1; i++) printf("%d%c", ans[i], i <= n ? ' ' : '\n');
return 0;
}
| 5 |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
int score[4],a,b,total=0;
for(int i=0;i<4;i++){
cin>>score[i];
}
sort(score,score+4);
for(int i=0;i<3;i++){
total+=score[3-i];
}
cin>>a>>b;
total+=max(a,b);
cout<<total<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5, inf = 1e9 + 7;
long long n, k, i, j;
long long A[N];
long long in[N], f[N];
inline long long expo(long long n, long long k, long long p = inf) {
if (k < 0) {
n = expo(n, inf - 2);
k = -k;
}
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
inline long long inv(long long a, long long p = inf) {
return expo(a, p - 2, p);
}
inline long long cc(long long a, long long b) {
if (a < b || b < 0) return 0;
return f[a] * in[b] % inf * in[a - b] % inf;
}
void fac() {
long long i;
f[0] = 1;
for (i = 1; i < N; i++) f[i] = f[i - 1] * i % inf;
in[N - 1] = inv(f[N - 1]);
for (i = N - 1; i > 0; i--) in[i - 1] = i * in[i] % inf;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long i, j, a, b, ans = 0, m;
cin >> n >> m >> a >> b;
fac();
for (i = 1; i < min(m, n - 1) + 1; i++)
ans += cc(m - 1, i - 1) * f[i - 1] % inf * (i + 1) % inf *
expo(n, n - i - 2) % inf * expo(m, n - i - 1) % inf *
cc(n - 2, i - 1) % inf;
ans = (ans % inf + inf) % inf;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
if (n % 2 == 0)
cout << "NO" << endl;
else {
cout << "YES" << endl;
if (n == 1) {
cout << "1"
<< " "
<< "2" << endl;
} else if (n == 3) {
cout << "1"
<< " "
<< "4"
<< " "
<< "5"
<< " "
<< "2"
<< " "
<< "3"
<< " "
<< "6" << endl;
} else {
cout << "1"
<< " "
<< "4"
<< " ";
int ans = 4, flag = 1;
while (1) {
if (flag == 1) {
ans += 3;
flag = 0;
} else if (flag == 0) {
ans += 5;
flag = 1;
}
cout << ans << " ";
if (ans >= 2 * n - 4) {
if (flag == 1) {
ans += 1;
cout << ans << " ";
break;
} else {
ans += 3;
cout << ans << " ";
break;
}
}
}
while (1) {
if (flag == 1) {
ans -= 3;
cout << ans << " ";
flag = 0;
} else if (flag == 0) {
ans -= 5;
cout << ans << " ";
flag = 1;
}
if (ans == 5) {
break;
}
}
cout << "2"
<< " "
<< "3"
<< " ";
ans = 3, flag = 0;
while (1) {
if (flag == 1) {
ans += 3;
flag = 0;
} else if (flag == 0) {
ans += 5;
flag = 1;
}
cout << ans << " ";
if (ans >= 2 * n - 4) {
if (flag == 1) {
ans += 1;
cout << ans << " ";
break;
} else {
ans += 3;
cout << ans << " ";
break;
}
}
}
while (1) {
if (flag == 1) {
ans -= 3;
cout << ans << " ";
flag = 0;
} else if (flag == 0) {
ans -= 5;
cout << ans << " ";
flag = 1;
}
if (ans == 6) {
break;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long r, g;
cin >> r >> g;
long long dp[r + 1][2];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
long long temp = r + g;
double k = -1 + sqrt(1.0 + 8.0 * (double)(temp));
k = k / 2.0;
long long num = (long long)(k);
long long p = (num * (num + 1)) / 2;
for (long long i = 1; i <= num; i++) {
for (long long j = 0; j <= r; j++) {
dp[j][i % 2] = dp[j][1 - (i % 2)];
if (j >= i) dp[j][i % 2] += dp[j - i][1 - (i % 2)];
dp[j][i % 2] = dp[j][i % 2] % 1000000007;
}
}
long long res = 0;
for (long long i = max((long long)(0), p - g); i <= r; i++) {
res += dp[i][num % 2];
res = res % 1000000007;
}
cout << res << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 1e5 + 5;
long long pref_sum[N], suff_sum[N];
long long a[N];
long long p, n, d;
long long b;
int first_instructor(long long students) {
int ans = 0;
long long debt = 0LL;
for (int i = 0; i < (n + 1) / 2; ++i) {
if (a[i] < b + debt && min(students, pref_sum[min(n - 1, i + (i + 1) * d)] -
pref_sum[i]) < (b - a[i]) + debt) {
ans++;
debt -= a[i];
} else {
debt += b - a[i];
}
}
return ans;
}
int second_instructor(long long students) {
students = 1LL * n * b - students;
int ans = 0;
long long debt = 0LL;
for (int i = n - 1; i >= (n + 1) / 2; --i) {
if (a[i] < b + debt && min(students, suff_sum[max(0LL, i - (n - i) * d)] -
suff_sum[i]) < (b - a[i]) + debt) {
ans++;
debt -= a[i];
} else {
debt += b - a[i];
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> d >> b;
p = 2;
long long debt = 0LL;
for (int i = 0; i < n; ++i) {
cin >> pref_sum[i];
a[i] = pref_sum[i];
if (i > 0) pref_sum[i] += pref_sum[i - 1];
}
suff_sum[n - 1] = 0LL + a[n - 1];
for (int i = n - 2; i >= 0; --i) {
suff_sum[i] = a[i] + suff_sum[i + 1];
}
if (p == 2) {
long long l = 0;
long long r = b * n + 1;
for (int i = 0; i < 200; ++i) {
long long m = (l + r) / 2;
if (second_instructor(m) - first_instructor(m) < 0)
l = m;
else
r = m;
}
int ans = max(first_instructor(r), second_instructor(r));
ans = min(ans, max(first_instructor(r - 1), second_instructor(r - 1)));
cout << ans;
} else {
int ans = 0;
for (int i = 0; i < n; ++i) {
if (a[i] < b + debt &&
pref_sum[min(n - 1, i + (i + 1) * d)] - pref_sum[i] <
(b - a[i]) + debt) {
ans++;
debt -= a[i];
} else {
debt += b - a[i];
}
}
cout << ans;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bitset<2010> g[2010];
long long f[2010][2010];
map<long long, int> cnt;
long long calc(int n) {
long long ans = 0;
for (int i = 0; i <= n; i++) ans = (ans + f[n][i]) % 1000000007LL;
return ans;
}
long long solve(int n, int m) {
long long ans = 1LL;
int k = 1;
for (int i = 0; i <= m; i++) f[i][i] = 1;
for (int i = 1; i <= m; i++) {
for (int j = 1; j < i; j++)
f[i][j] =
(j * f[i - 1][j] % 1000000007LL + f[i - 1][j - 1]) % 1000000007LL;
}
for (int i = 1; i <= m; i++) {
int t = 0;
for (int j = k; j <= n; j++)
if (g[j][i]) {
t = j;
break;
}
if (!t) continue;
swap(g[t], g[k]);
for (int j = 1; j <= n; j++)
if (j != k && g[j][i]) g[j] ^= g[k];
k++;
}
for (int i = 1; i <= m; i++) {
long long now = 0;
for (int j = 1; j <= n; j++)
if (g[j][i]) now |= (1LL << (j - 1));
cnt[now]++;
}
for (map<long long, int>::iterator ii = cnt.begin(); ii != cnt.end(); ii++)
if ((*ii).first) ans = ans * calc((*ii).second) % 1000000007LL;
return ans;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
char ch;
while (!isdigit(ch = getchar()))
;
g[i][j] = ch - '0';
}
}
m++;
for (int j = 1; j <= n; j++) g[m][j] = 1;
for (int i = m + 1; i <= 2 * m; i++) {
for (int j = 1; j <= n; j++) g[i][j] = g[i - m][j] ^ 1;
}
cout << solve(2 * m, n) << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
#ifndef LOCAL
#define cerr if(false)cerr
#endif // LOCAL
using namespace std;
using ll = long long;
const int N = 1e6 + 66;
const int inf = 1e9 + 123;
int a[N], last[N];
vector<int>pos[N];
int dp[N][2], n;
int solve(int i, int t) {
if (i <= 0) return 0;
if (~dp[i][t]) return dp[i][t];
if (t == 1 && i == pos[a[i]].back()) {
for (int j = 0 ; j < (int)pos[a[i]].size() ; ++ j) {
int first = pos[a[i]][j];
int cnt = (int)pos[a[i]].size() - j;
dp[i][t] = max(dp[i][t], cnt + solve(first - 1, 0));
}
}
if (i == pos[a[i]].back()) {
dp[i][t] = max(dp[i][t], solve(pos[a[i]][0] - 1, 0) + (int)pos[a[i]].size());
}
if (t == 1) {
dp[i][t] = max(dp[i][t], solve(i - 1, 1));
}
dp[i][t] = max(dp[i][t], solve(i - 1, 0));
return dp[i][t];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1 ; i <= n ; ++ i) {
cin >> a[i]; last[a[i]] = i;
}
for (int i = 1 ; i <= n ; ++ i) {
a[i] = last[a[i]];
pos[a[i]].emplace_back(i);
}
memset(dp, -1, sizeof dp);
cout << n - solve(n, 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int G = N;
set<pair<int, int> > S;
set<int> a[N];
int ans[N];
bool was[N];
vector<int> C[G + G];
int n, m;
bool solve() {
while (!S.empty()) {
int idx = S.begin()->second;
if (a[idx].empty()) {
cerr << "fail " << idx << endl;
return 0;
}
int u = *a[idx].begin();
ans[abs(u)] = u / abs(u);
was[idx] = 1;
S.erase(S.begin());
for (int v : C[u + G])
if (!was[v]) {
was[v] = 1;
auto it = S.find(pair<int, int>(a[v].size(), v));
assert(it != S.end());
S.erase(it);
}
for (int v : C[-u + G])
if (!was[v]) {
auto it = S.find(pair<int, int>(a[v].size(), v));
assert(it != S.end());
a[v].erase(-u);
S.erase(it);
S.insert(pair<int, int>(a[v].size(), v));
}
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int s, u;
for (int i = 1; i <= n; ++i) {
cin >> s;
for (int j = 1; j <= s; ++j) {
cin >> u;
a[i].insert(u);
C[u + G].push_back(i);
}
S.insert(pair<int, int>(a[i].size(), i));
}
bool res = solve();
if (res) {
cout << "YES\n";
for (int i = 1; i <= m; ++i) cout << (ans[i] == 1);
} else {
cout << "NO\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool fun(int a, int b) {
long double s = (long double)a * b, x = 100000;
long double t = x * x * x;
while (abs(t - s) > 0.5) {
x -= (t - s) / (3 * x * x);
t = x * x * x;
}
long long c = (long long)x;
if (c * c * c != (long long)a * b) return 0;
if (a % c != 0 || b % c != 0) return 0;
return 1;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
if (fun(a, b))
puts("YES");
else
puts("NO");
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.