solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<iostream>
#include<map>
using namespace std;
int n,a[200010];
long long ans;
map<int,int> myd;
int main() {
scanf("%d",&n);
for(int i=1;i<=n;i++) {
scanf("%d",&a[i]);
ans+=myd[i-a[i]];
myd[i+a[i]]++;
}
printf("%lld",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string friends[5] = {"Danil", "Olya", "Slava", "Ann", "Nikita"};
int cnt = 0;
string inp;
cin >> inp;
for (int i = int(0); i < int(5); i++) {
for (int j = int(0); j < int(inp.size() - friends[i].size() + 1); j++) {
if (inp.substr(j, friends[i].size()) == friends[i]) {
cnt++;
}
}
}
if (cnt == 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l, c, d, p, nl, np, drink, slice, salt, ans;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
drink = (k * l) / nl;
slice = (c * d);
salt = p / np;
ans = min(slice, salt);
ans = min(ans, drink) / n;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c, d;
cin >> a >> b >> c >> d;
printf("%.10lf", (a * d) / (b * d - (b - a) * (d - c)));
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[60], l, r, cnt;
long long m;
int main() {
scanf("%d%I64d", &n, &m);
m = (m - 1) * 2, l = 0, r = n;
for (long long i = 1ll << n - 1; i; i >>= 1) a[m & i ? --r : l++] = ++cnt;
for (int i = 0; i < n; i++) printf("%d%c", a[i], " \n"[i == n - 1]);
}
| 2 |
#include<bits/stdc++.h>
char s0[200007];
int t[417];
int main(){
scanf("%s",s0+1);
int n=strlen(s0+1);
long long ans=1ll*n*(n+1)/2+1;
for(int i=1;i<=n;++i)++t[s0[i]-'a'];
for(int i=0;i<26;++i)ans-=1ll*t[i]*(t[i]+1)/2;
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
std::ifstream fin("input.txt");
std::ofstream fout("output.txt");
using namespace std;
const string alphabetLower = "abcdefghijklmnopqrstuvwxyz";
const string alphabetHigher = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string digits = "0123456789";
void run() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int ans = n;
int p = n - 1;
for (int i = n / 2 - 1; i >= 0; i--) {
if (a[i] * 2 <= a[p]) {
ans--;
p--;
}
}
printf("%d", ans);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
run();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-' && t != EOF; t = getchar())
;
if (t == '-') neg = true, t = getchar();
if (t == EOF) return false;
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
return true;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int maxn = 100111;
const int maxm = 300111;
int head[maxn], nxt[maxm << 1], to[maxm << 1], etot = 1;
void addedge(int u, int v) {
nxt[++etot] = head[u];
head[u] = etot;
to[etot] = v;
nxt[++etot] = head[v];
head[v] = etot;
to[etot] = u;
}
int n, m, dgr[maxn];
int iter[maxn];
bool use[maxm];
vector<int> vs;
void dfs(int x) {
for (int &i = iter[x]; i; i = nxt[i])
if (!use[i >> 1]) {
use[i >> 1] = 1;
dfs(to[i]);
}
vs.push_back(x);
}
int main() {
(get_int(n) && get_int(m));
for (int i = 1, u, v; i <= m; i++) {
(get_int(u) && get_int(v));
addedge(u, v);
dgr[u]++;
dgr[v]++;
}
int tmp = 0;
for (int i = 1; i <= n; i++)
if (dgr[i] % 2 == 1) {
if (tmp) {
addedge(i, tmp);
tmp = 0;
} else
tmp = i;
}
if (etot % 4 == 3) addedge(1, 1);
memcpy(iter, head, sizeof(head));
dfs(1);
printf("%d\n", etot / 2);
for (int i = 1; i < (int)vs.size(); i += 2) {
printf("%d %d\n", vs[i], vs[i - 1]);
printf("%d %d\n", vs[i], vs[i + 1]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
istream &in = cin;
int n;
vector<string> s;
int dp[30][30];
int main() {
in >> n;
s.resize(n + 1);
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; ++i) in >> s[i];
for (int k = 1; k <= n; ++k) {
int h = s[k][0] - 'a', t = s[k][(int)s[k].size() - 1] - 'a';
for (int i = 'a' - 'a'; i <= 'z' - 'a'; ++i)
if (dp[i][h] > 0) dp[i][t] = max(dp[i][t], dp[i][h] + (int)s[k].size());
dp[h][t] = max(dp[h][t], (int)s[k].size());
}
int ret = 0;
for (int i = 0; i < 30; ++i) ret = max(ret, dp[i][i]);
cout << ret << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "-O3"
const int N = (3e2 + 5);
const int64_t MOD = (1e9 + 9);
int n, k;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> k;
while (s.length() <= k) s += to_string(++n);
cout << s[k - 1] << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-12;
const int N = 300000 + 10, maxn = 400000 + 10;
struct point {
long long x, y;
point(long long x = 0, long long y = 0) : x(x), y(y) {}
bool operator<(const point &rhs) const {
return x < rhs.x || (x == rhs.x && y < rhs.y);
}
point operator+(const point &rhs) const {
return point(x + rhs.x, y + rhs.y);
}
point operator-(const point &rhs) const {
return point(x - rhs.x, y - rhs.y);
}
long long operator*(const point &rhs) const { return x * rhs.y - y * rhs.x; }
} p[N];
int en[N];
long long ask[N], ans;
vector<point> pointset[N << 2];
void update(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
pointset[rt].push_back(p[L]);
return;
}
int m = (l + r) >> 1;
if (L <= m) update(L, R, l, m, rt << 1);
if (m < R) update(L, R, m + 1, r, rt << 1 | 1);
}
void dfs(int l, int r, int rt) {
vector<point> &v = pointset[rt];
if (!v.empty()) sort(v.begin(), v.end());
if (v.size() > 2) {
int i, j;
for (i = 2, j = 1; i < v.size(); i++) {
while (j > 0 && (v[j] - v[j - 1]) * (v[i] - v[j]) >= 0) j--;
j++;
v[j] = v[i];
}
while (v.size() > j + 1) v.pop_back();
}
if (l == r) return;
int m = (l + r) >> 1;
dfs(l, m, rt << 1);
dfs(m + 1, r, rt << 1 | 1);
}
long long fun(point p, long long v) { return p.x * v + p.y; }
long long solve(vector<point> &v, long long c) {
long long ans = -9223372036854775807ll;
int l = 0, r = v.size() - 1;
while (r - l > 6) {
int m1 = (l * 2 + r) / 3;
int m2 = (l + r * 2) / 3;
if (fun(v[m1], c) < fun(v[m2], c))
l = m1;
else
r = m2;
}
for (int i = l; i <= r; i++) ans = max(ans, fun(v[i], c));
return ans;
}
void query(int pos, long long c, int l, int r, int rt) {
ans = max(ans, solve(pointset[rt], c));
if (l == r) return;
int m = (l + r) >> 1;
if (pos <= m)
query(pos, c, l, m, rt << 1);
else
query(pos, c, m + 1, r, rt << 1 | 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
en[i] = -1;
ask[i] = -9223372036854775807ll;
int t;
scanf("%d", &t);
if (t == 1) {
scanf("%lld%lld", &p[i].x, &p[i].y);
en[i] = n;
} else if (t == 2) {
int x;
scanf("%d", &x);
en[x] = i - 1;
} else {
scanf("%lld", &ask[i]);
}
}
for (int i = 1; i <= n; i++)
if (en[i] != -1) update(i, en[i], 1, n, 1);
dfs(1, n, 1);
for (int i = 1; i <= n; i++) {
if (ask[i] != -9223372036854775807ll) {
ans = -9223372036854775807ll;
query(i, ask[i], 1, n, 1);
if (ans == -9223372036854775807ll)
puts("EMPTY SET");
else
printf("%lld\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
const int maxn = 300010;
int n, W;
int w[maxn], v[maxn];
vector<int> A, B, C;
int nA, nB, nC;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> W;
for (int i = (0); i < (n); i++) {
cin >> w[i] >> v[i];
if (w[i] == 1) A.push_back(v[i]);
if (w[i] == 2) B.push_back(v[i]);
if (w[i] == 3) C.push_back(v[i]);
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
sort(B.begin(), B.end());
reverse(B.begin(), B.end());
sort(C.begin(), C.end());
reverse(C.begin(), C.end());
nA = A.size();
nB = B.size();
nC = C.size();
long long dp[maxn], suma[maxn];
pair<int, int> r[maxn];
memset(dp, 0LL, sizeof dp);
dp[0] = 0;
r[0] = pair<int, int>(0, 0);
for (int i = (1); i < (W + 1); i++) {
pair<int, int> x = r[i - 1];
pair<int, int> y;
if (i >= 2) y = r[i - 2];
if (x.first < nA) {
if (dp[i - 1] + A[x.first] > dp[i]) {
dp[i] = dp[i - 1] + A[x.first];
r[i] = pair<int, int>(x.first + 1, x.second);
}
}
if (i >= 2 and y.second < nB) {
if (dp[i - 2] + B[y.second] > dp[i]) {
dp[i] = dp[i - 2] + (int)B[y.second];
r[i] = pair<int, int>(y.first, y.second + 1);
}
}
if (dp[i - 1] > dp[i]) {
dp[i] = dp[i - 1];
r[i] = r[i - 1];
}
if (i >= 2 and dp[i - 2] > dp[i]) {
dp[i] = dp[i - 2];
r[i] = r[i - 2];
}
}
for (int i = (0); i < (nC); i++) {
suma[i] = C[i];
if (i > 0) suma[i] += suma[i - 1];
}
long long maxi = 0;
for (int i = (0); i < (W); i++) {
if (W - (i + 1) * 3 < 0) break;
maxi = max(maxi, suma[i] + dp[W - (i + 1) * 3]);
}
maxi = max(maxi, dp[W]);
cout << maxi << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
template <typename T>
inline int max(T &a, T &b) {
return (a > b) ? (a) : (b);
}
template <typename T>
inline int max(T &a, T &b, T &c) {
if (a >= b && a >= c) return a;
if (b >= c) return b;
return c;
}
int n = 0, m = 0;
int main() {
int n, k;
int a[1000 * 10 + 1];
int b[1000 * 10 + 1];
cin >> n >> k;
for (int i = 1; i < n; ++i) {
a[i] = 1;
b[i] = 1;
}
a[n] = 0;
b[n] = 0;
if (n == 1) {
for (int i = 0; i < k; ++i) cout << 1 << endl;
return 0;
}
if (n <= k + 2) {
for (int i = 0; i < n - 1 && i < k; ++i) {
for (int j = 0; j < n - i - 2; ++j) cout << n - 1 << ' ';
for (int j = n - i - 2; j < n; ++j) cout << n << ' ';
cout << endl;
}
for (int i = n - 1; i < k; ++i) {
for (int j = 0; j < n; ++j) cout << n << ' ';
cout << endl;
}
return 0;
}
for (int i = 0; i < k; ++i) {
for (int j = 1; j <= n; ++j) {
if (a[j] == n - j)
cout << n << ' ';
else if (a[j] + a[j] < n - j) {
b[j] = a[j] + a[j];
cout << j << ' ';
} else {
int l = 2;
for (l = 2; a[j] + a[l] > n - j; ++l)
;
b[j] = a[j] + a[l];
cout << l << ' ';
}
}
for (int j = 1; j <= n; ++j) a[j] = b[j];
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int lim, n, mark[5005];
pair<int, int> data[5005];
bool dfs(int x, int c) {
mark[x] = c;
for (int i = 0; i < n; i++)
if (abs(data[i].first - data[x].first) +
abs(data[i].second - data[x].second) >
lim) {
if (mark[i] == 0 && !dfs(i, 3 - c)) return false;
if (mark[i] == mark[x]) return false;
}
return true;
}
int compute(int mid) {
int ret = 1;
lim = mid;
memset(mark, 0, sizeof(mark));
for (int i = 0; i < n; i++)
if (mark[i] == 0) {
ret = ret * 2 % 1000000007;
if (!dfs(i, 1)) return -1;
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &data[i].first, &data[i].second);
int g = 0, h = 10000, ans1, ans2;
while (g <= h) {
int mid = (g + h) / 2;
int ret = compute(mid);
if (ret == -1)
g = mid + 1;
else
h = mid - 1, ans1 = mid, ans2 = ret;
}
printf("%d\n%d\n", ans1, ans2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int SetBit(int val, int pos) { return val | (1 << pos); }
int ReSet(int val, int pos) { return val & ~(1 << pos); }
int CheckBit(int val, int pos) { return val & (1 << pos); }
int ReverseBit(int val, int pos) { return val ^ (1 << pos); }
int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int main() {
ios::sync_with_stdio(0);
int t;
int n;
cin >> n;
double ans = 0.00;
for (int i = 1; i <= n; i++) {
ans += (1.0 / i);
}
printf("%.12lf\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define M 20000
int main(void){
int tx,ty;
string s;
cin>>s>>tx>>ty;
assert(abs(tx)<=8000 && abs(ty)<=8000);
s += "T";
int init = s.find("T",0);
tx -= init;
s = string(s.begin()+init, s.end());
bitset<M*2> dp[2];
dp[0][M] = dp[1][M] = 1;
int cnt = 0, mode = 0;
for(char c : s){
if(c=='F') cnt++;
else{
dp[mode] = (dp[mode]<<cnt) | (dp[mode]>>cnt);
cnt = 0;
mode = !mode;
}
}
cout<<((dp[0][M+tx] && dp[1][M+ty]) ? "Yes" : "No")<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
char s[1005];
int len;
bool vis[10][10];
memset(vis, 0, sizeof(vis));
scanf("%s", s);
len = strlen(s);
for (i = 0; i < len; i++) {
if (s[i] == '0') {
if (!vis[3][3]) {
vis[3][3] = 1;
printf("3 3\n");
} else {
vis[3][3] = 0;
printf("1 3\n");
}
} else {
if (!vis[1][1]) {
vis[1][1] = 1;
printf("1 1\n");
} else {
vis[1][1] = 0;
printf("1 3\n");
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 2;
int a[maxn], b[maxn * maxn], c[maxn * maxn], dem = 0, ans = 0;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
b[dem] = a[i] + a[j];
c[b[dem]]++;
ans = max(ans, c[b[dem]]);
dem++;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int sqr(int x) { return x * x; }
inline int cube(int x) { return x * x * x; }
inline long long sqrLL(long long x) { return x * x; }
inline long long cubeLL(long long x) { return x * x * x; }
const long long LLINF = 9223372036854775807LL;
const long long LLINF17 = 100000000000000000LL;
const int INF = 1000000000;
const int INF9 = 1000000000;
long long MOD = 1000000009;
const double eps = 1e-7;
const double PI = acos(-1.0);
template <typename T>
void check(T &a, const T &b) {
if (a >= b) {
a %= b;
}
}
template <typename T>
void read(T &x) {
register T c = getchar();
x = 0;
int t = 0;
if (c == '-') t = 1, c = getchar();
for (; (c < 48 || c > 57); c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (t) x = -x;
}
template <typename T>
T gcd(T u, T v) {
if (u == v) return u;
if (u == 0) return v;
if (v == 0) return u;
if (~u & 1) {
if (v & 1)
return gcd(u >> 1, v);
else
return gcd(u >> 1, v >> 1) << 1;
}
if (~v & 1) return gcd(u, v >> 1);
if (u > v) return gcd((u - v) >> 1, v);
return gcd((v - u) >> 1, u);
}
long long mulmod(long long a, long long b, long long m) {
long long q = (long long)(((long double)a * (long double)b) / (long double)m);
long long r = a * b - q * m;
if (r > m) r %= m;
if (r < 0) r += m;
return r;
}
template <typename T, typename S>
T expo(T e, S n) {
T x = 1, p = e;
while (n) {
if (n & 1) x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T>
T powerL(T e, T n, T &m) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mulmod(x, p, m);
p = mulmod(p, p, m);
n >>= 1;
}
return x;
}
template <typename T>
T InverseEuler(T a, T &m) {
return (a == 1 ? 1 : power(a, m - 2, m));
}
int v, a[10], ans, idx, var = 9;
vector<int> _ans;
int _check(int paint, int &index, int size) {
for (int i = index; i >= 1; i--) {
if (paint >= 0 && paint / a[i] == size) return i;
}
return 0;
}
int main() {
read(v);
for (int(i) = (1); (i) <= (9); (i)++) read(a[i]);
for (int(i) = (1); (i) <= (9); (i)++) {
if (ans < v / a[i])
ans = v / a[i], idx = i;
else if (ans == v / a[i])
idx = i;
}
if (!ans) cout << -1 << "\n", exit(0);
if (idx == 9) {
for (int(i) = (0); (i) < (ans); (i)++) cout << 9;
exit(0);
}
for (int(i) = (0); (i) < (ans); (i)++) {
for (int j = var; j >= 1; j--) {
if (_check(v - a[j], j, ans - i - 1)) {
v -= a[j];
_ans.push_back(j);
var = j;
break;
}
}
}
for (auto &i : _ans) printf("%d", i);
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct majik {
int lef[13], rig[13], res = 0;
void comb(int x, int y) {
res--;
for (int i = 1; i <= 10; i++) {
if (lef[i] == x) {
lef[i] = y;
}
if (rig[i] == x) {
rig[i] = y;
}
}
}
};
int n, m, q;
majik it[400007];
int x[13][100007];
majik connect(majik a, majik b, int l, int r) {
majik c;
for (int i = 1; i <= n; i++) {
c.lef[i] = a.lef[i];
c.rig[i] = b.rig[i];
}
c.res = a.res + b.res;
for (int i = 1; i <= n; i++) {
if (x[i][l] == x[i][r]) {
if (a.rig[i] != b.lef[i]) {
c.comb(a.rig[i], b.lef[i]);
a.comb(a.rig[i], b.lef[i]);
}
}
}
return c;
}
void init(int k, int l, int r) {
if (l == r) {
for (int i = 1; i <= n; i++) {
it[k].lef[i] = (l - 1) * n + i;
it[k].rig[i] = (l - 1) * n + i;
}
it[k].res = n;
for (int i = 2; i <= n; i++) {
if (x[i][l] == x[i - 1][l]) {
it[k].comb(it[k].lef[i], it[k].rig[i - 1]);
}
}
return;
}
int mid = (l + r) / 2;
init(k * 2, l, mid);
init(k * 2 + 1, mid + 1, r);
it[k] = connect(it[k * 2], it[k * 2 + 1], mid, mid + 1);
}
majik get(int k, int l, int r, int le, int ri) {
if (l >= le && r <= ri) return it[k];
int mid = (l + r) / 2;
majik rem;
if (mid >= ri) {
rem = get(k * 2, l, mid, le, ri);
} else if (mid < le) {
rem = get(k * 2 + 1, mid + 1, r, le, ri);
} else
rem = connect(get(k * 2, l, mid, le, ri),
get(k * 2 + 1, mid + 1, r, le, ri), mid, mid + 1);
return rem;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> x[i][j];
}
}
init(1, 1, m);
while (q--) {
int u, v;
cin >> u >> v;
cout << get(1, 1, m, u, v).res << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ldb = long double;
using pa = pair<ll, ll>;
using vec = vector<ll>;
const int MOD = 1e9 + 7, INF = INT_MAX, N = 1e5 + 10;
const double PI = acos(-1);
const ll LINF = LLONG_MAX;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll m;
cin >> m;
bool yes[6][6] = {false};
ll i, j, k, a, b;
for (i = 0; i < m; ++i) {
cin >> a >> b;
yes[a][b] = yes[b][a] = true;
}
for (i = 1; i <= 5; ++i)
for (j = i + 1; j <= 5; ++j)
for (k = j + 1; k <= 5; ++k)
if ((yes[i][j] && yes[i][k] && yes[j][k]) ||
(!yes[i][j] && !yes[i][k] && !yes[j][k])) {
cout << "WIN";
return 0;
}
cout << "FAIL";
cerr << "Time taken: " << int((clock() * 1000.) / CLOCKS_PER_SEC) << "ms\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long cal(long long r) {
if (r % 4 == 0) {
return r;
} else if (r % 4 == 1) {
return 1;
} else if (r % 4 == 2) {
return r + 1;
} else {
return 0;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
long long res = 0;
for (int i = 0; i < n; i++) {
long long m, x;
cin >> x >> m;
res ^= cal(x + m - 1);
res ^= cal(x - 1);
}
cout << (res ? "tolik" : "bolik");
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("02")
using namespace std;
using ll = long long;
const ll N = 1e4 + 5, X = 11111, mod = 1e9 + 7;
ll n, ans, sum, dp[N * 20], dp2[N * 20];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
ll a;
cin >> a;
ans = (ans + dp[a + X] + dp[-a + X]) % mod;
for (ll j = -sum; j <= sum; j++) dp2[j + X] = 0;
dp2[a + X]++;
dp2[-a + X]++;
for (ll j = -sum; j <= sum; j++) {
dp2[j + a + X] = (dp2[j + a + X] + dp[j + X]) % mod;
dp2[j - a + X] = (dp2[j - a + X] + dp[j + X]) % mod;
}
sum += a;
for (ll j = -sum; j <= sum; j++) dp[j + X] = dp2[j + X];
}
cout << ans % mod << endl;
}
| 4 |
/* template.cpp {{{ */
#include <bits/stdc++.h>
using namespace std;
#define get_macro(a, b, c, d, name, ...) name
#define rep(...) get_macro(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) get_macro(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define rep1(n) rep2(i_, n)
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, a, b) rep4(i, a, b, 1)
#define rep4(i, a, b, s) for (ll i = (a); i < (ll)(b); i += (ll)(s))
#define rrep1(n) rrep2(i_, n)
#define rrep2(i, n) rrep3(i, 0, n)
#define rrep3(i, a, b) rrep4(i, a, b, 1)
#define rrep4(i, a, b, s) for (ll i = (ll)(b) - 1; i >= (ll)(a); i -= (ll)(s))
#define each(x, c) for (auto &&x : c)
#define fs first
#define sc second
#define all(c) begin(c), end(c)
using ui = unsigned;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
const ll mod = 1e9 + 7;
const ll mod9 = 1e9 + 9;
const int dx[]{-1, 0, 1, 0, -1, 1, 1, -1};
const int dy[]{0, -1, 0, 1, -1, -1, 1, 1};
template<class T, class U> void chmin(T &x, const U &y){ x = min<T>(x, y); }
template<class T, class U> void chmax(T &x, const U &y){ x = max<T>(x, y); }
//struct prepare_ { prepare_(){ cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(12); } } prepare__;
/* }}} */
int n;
string s;
int main(){
cin >> n;
cin >> s;
deque<int> l, r;
rep(i, n) if (s[i] == '<') r.push_back(i);
int res = 0;
rep(i, n){
if (r.size() && r[0] == i) r.pop_front();
if (s[i] == '>'){
if (r.empty()) chmax(res, n - i);
else if (l.size() >= r.size()) chmax(res, n - l[r.size() - 1]);
else chmax(res, r[l.size()] + 1);
}
else {
if (l.empty()) chmax(res, i + 1);
else if (l.size() <= r.size()) chmax(res, r[l.size() - 1] + 1);
else chmax(res, n - l[r.size()]);
}
if (s[i] == '>') l.push_front(i);
}
cout << res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 5;
map<long long int, long long int> m;
long long int n, ans;
void init() {
m[-1] = -1;
m[2e9] = 2e9;
m[1] = n;
ans = n;
}
void add(long long int l, long long int r) {
m[l] = r;
ans += r - l + 1;
}
void remove(long long int l, long long int r) {
long long int rem = 0;
auto it = m.lower_bound(l);
it--;
if (it->second >= l) {
m[l] = it->second;
it->second = l - 1;
}
it++;
while (it->first <= r) {
if (it->second > r) {
rem += r + 1 - it->first;
m[r + 1] = it->second;
} else
rem += it->second - it->first + 1;
auto it2 = it;
it++;
m.erase(it2);
}
ans -= rem;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int q;
cin >> n >> q;
init();
while (q--) {
long long int l, r, k;
cin >> l >> r >> k;
remove(l, r);
if (k == 2) add(l, r);
cout << ans << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> adj;
vector<bool> visited;
int main() {
long long n;
cin >> n;
adj.resize(n + 1);
visited.resize(n + 1);
long long x, y;
for (int i = 1; i < n; i++) {
cin >> x;
adj[x].push_back(i + 1);
}
for (int i = 0; i <= n; i++) visited[i] = false;
vector<long long> colour(n + 1);
for (int i = 1; i <= n; i++) {
cin >> colour[i];
}
long long ans = 1;
vector<long long> cc(n + 1, colour[1]);
for (int i = 2; i <= n; i++) {
if (colour[i] != cc[i]) {
ans++;
queue<long long> q;
q.push(i);
while (!q.empty()) {
long long x = q.front();
q.pop();
cc[x] = colour[i];
long long len = adj[x].size();
for (int i = 0; i < len; i++) {
q.push(adj[x][i]);
}
}
}
}
cout << ans << endl;
}
| 2 |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
string s;
cin >> s;
int p = count(s.begin(), s.end(), 'p');
int g = count(s.begin(), s.end(), 'g');
cout << (p + g) / 2 - p << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long int n;
cin>>n;
long long int sum=0;
long long int minn=0x3f3f3f3f;
for(long long int i=0; i<n; i++)
{
long long int a,b;
cin>>a>>b;
sum+=a;
if(a>b)
minn=min(minn,b);
}
minn!=0x3f3f3f3f?cout<<sum-minn<<endl:cout<<0<<endl;
return 0;
}
| 0 |
#include <cstdio>
int main(void)
{
double g, h;
while (scanf("%lf %lf", &g, &h) != EOF){
if ((g < 35.5) && (h < (60 * 1) + 11)){
printf("AAA\n");
}
else if ((g < 37.5) && (h < (60 * 1) + 17)){
printf("AA\n");
}
else if ((g < 40) && (h < (60 * 1) + 23)){
printf("A\n");
}
else if ((g < 43) && (h < (60 * 1) + 29)){
printf("B\n");
}
else if ((g < 50) && (h < (60 * 1) + 45)){
printf("C\n");
}
else if ((g < 55) && (h < (60 * 1) + 56)){
printf("D\n");
}
else if ((g < 70) && (h < (60 * 2) + 28)){
printf("E\n");
}
else {
printf("NA\n");
}
}
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
const int K = 230;
int D[N];
int A[N];
long long PS[N];
int st[N];
bool was[N];
vector<int> E[N];
int n, k;
struct block {
int len = 0;
long long X[K] = {0};
long long dA[K] = {0};
long long glob = 0;
long long max_req = -(long long)1e18;
long long max_X = -(long long)1e18;
void add_global(long long d) { glob += d; }
inline long long get_max_req() const { return max_req; }
inline long long get_max_X() const { return max_X + glob; }
void recalc() {
assert(glob == 0);
max_req = -(long long)1e18;
for (int i = 0; i < len; i++) {
long long got = i ? dA[i - 1] : 0;
if (got > k) break;
max_req = max(max_req, X[i] + k - got);
}
max_X = *max_element(X, X + len);
}
void flush() {
for (int i = 0; i < len; i++) {
X[i] += glob;
dA[i] += glob;
}
max_X += glob;
glob = 0;
}
void add_suff(int x, long long d) {
flush();
for (int i = x; i < len; i++) {
X[i] += d;
dA[i] += d;
}
recalc();
}
pair<int, long long> get(int l, long long prev_mx = -1e18) const {
long long mx = prev_mx;
if (l != -1) mx = X[l] + glob;
int ans = 0;
for (int i = l + 1; i < len; i++) {
long long got_prev = (i ? dA[i - 1] : -(long long)1e18) + glob;
long long got = dA[i] + glob;
if (got_prev > k) break;
if (X[i] + glob + k - got >= mx) {
ans = max(ans, i - l);
}
mx = max(mx, X[i] + glob);
}
return make_pair(ans, mx);
}
} B[N / K + 2];
int blocks;
void add_suff(int l, long long d) {
int id = l / K;
B[id].add_suff(l - id * K, d);
while (++id < blocks) {
B[id].add_global(d);
}
}
int ans = 1;
void process(int l) {
int ans;
long long mx;
int id = l / K;
tie(ans, mx) = B[id].get(l - id * K);
++ans;
int good_id = -1;
long long good_mx = -42;
int prev_good_id = -1;
long long prev_good_mx = -42;
while (++id < blocks) {
if (B[id - 1].dA[K - 1] + B[id - 1].glob > k) break;
if (B[id].get_max_req() >= mx) {
prev_good_id = good_id;
prev_good_mx = good_mx;
good_id = id;
good_mx = mx;
}
mx = max(mx, B[id].get_max_X());
}
if (good_id != -1) {
if ((good_id + 1) * K - l <= ::ans) return;
int ans2;
tie(ans2, ignore) = B[good_id].get(-1, good_mx);
if (ans2 == 0) {
if (prev_good_id != -1) {
if ((prev_good_id + 1) * K - l <= ::ans) return;
tie(ans2, ignore) = B[prev_good_id].get(-1, prev_good_mx);
assert(ans2 != -1);
ans = ans2 + prev_good_id * K - l;
}
} else {
ans = ans2 + good_id * K - l;
}
}
::ans = max(::ans, ans);
}
void DFS(int x, int p = -1) {
was[x] = true;
if (p != -1) add_suff(p - 1, PS[x] - PS[p]);
process(x);
for (int y : E[x]) {
DFS(y, x);
}
if (p != -1) add_suff(p - 1, PS[p] - PS[x]);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n - 1; i++) {
scanf("%d", &D[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
for (int i = 1; i < n; i++) {
PS[i] = PS[i - 1] + A[i - 1] - D[i - 1];
}
int pt = 0;
for (int i = n - 1; i >= 0; i--) {
while (pt > 0 && PS[st[pt - 1]] >= PS[i]) --pt;
if (pt) E[st[pt - 1]].push_back(i);
st[pt++] = i;
}
long long curX = 0;
for (int i = 1; i < n; i++) curX = B[i / K].X[i % K] = curX + A[i] - D[i - 1];
blocks = (n + K - 1) / K;
for (int id = 0; id < blocks; id++) {
B[id].len = min(K, n - id * K);
B[id].recalc();
}
for (int i = 0; i < n; i++) {
reverse(E[i].begin(), E[i].end());
}
for (int i = n - 1; i >= 0; i--) {
if (!was[i]) DFS(i);
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000 + 10;
long long f[MAXN][MAXN];
long long n, k;
const long long mod = 1e9 + 7;
inline long long fast_pow(long long x, long long a) {
register long long ans = 1;
for (; a; a >>= 1, x = 1ll * x * x % mod)
if (a & 1) ans = 1ll * ans * x % mod;
return ans;
}
inline long long dp(const long long &a, const long long &b) {
if (b > n) return 0;
if (f[a][b] >= 0) return f[a][b];
register long long c = n - b;
if (!a) {
f[a][b] = fast_pow(2, c);
return f[a][b];
}
f[a][b] = (1ll * b * dp(a - 1, b) + 1ll * c * dp(a - 1, b + 1)) % mod;
return f[a][b];
}
inline void _read(long long &x) {
x = 0;
char t = getchar();
while (!isdigit(t)) t = getchar();
while (isdigit(t)) {
x = x * 10 + t - '0';
t = getchar();
}
}
int main() {
_read(n), _read(k);
memset(f, -1, sizeof f);
printf("%d", dp(k, 0));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const double eps = (1e-10);
int isGreater(long double x, long double y) {
if (abs(x - y) < eps) return 0;
if (x > y) return 1;
return -1;
}
int get(int mn, int mx, const vector<int> &b, int st) {
int l = lower_bound(b.begin() + st + 1, b.end(), mn) - b.begin();
int r = upper_bound(b.begin() + st + 1, b.end(), mx) - b.begin() - 1;
return max(0, r - l + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
int ans = 0;
for (int k = 0; k <= 28; ++k) {
vector<int> b(n);
int p = (1 << k);
for (int i = 0; i < n; ++i) b[i] = a[i] & (2 * p - 1);
int cnt = 0;
sort(b.begin(), b.end());
for (int i = 0; i < n; ++i) {
cnt += get(p - b[i], 2 * p - 1 - b[i], b, i);
cnt += get(p + 2 * p - b[i], p * 2 * 2 - 2 - b[i], b, i);
cnt %= 2;
}
if (cnt & 1) ans |= p;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 1e3 + 2;
const long long int mod = 1e6 + 3;
long long int power(long long int j) {
long long int k = 1;
for (long long int n = 0; n < j; n++) {
k = ((k % mod) * (2 % mod)) % mod;
}
return k % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
map<char, string> m;
m['>'] = "1000";
m['<'] = "1001";
m['+'] = "1010";
m['-'] = "1011";
m['.'] = "1100";
m[','] = "1101";
m['['] = "1110";
m[']'] = "1111";
long long int mod = 1000003, i;
string str = "";
for (i = 0; i < s.length(); i++) {
str += m[s[i]];
}
long long int sum = 0;
reverse(str.begin(), str.end());
for (i = 0; i < str.length(); i++) {
if (str[i] == '0') continue;
sum += power(i);
}
sum = sum % mod;
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k = 0, l = 0;
char a[1000000], b[1000000];
cin >> a >> b;
for (int i = 0; a[i]; i++) {
if (a[i] != b[i]) {
if (a[i] == '4') k++;
if (a[i] == '7') l++;
}
}
cout << max(k, l);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long n_ = 1e5 + 1000;
const long double PI = acos(-1.0);
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
bool vowel(char ch) {
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
else
return false;
}
class UnionFind {
private:
vector<long long> p, rank, setSize;
long long numSets;
public:
UnionFind(long long N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
for (long long 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); }
void unionSet(long long i, long long j) {
if (!isSameSet(i, j)) {
numSets--;
long long x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
}
long long numDisjointSets() { return numSets; }
long long sizeOfSet(long long i) { return setSize[findSet(i)]; }
};
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, s, x;
cin >> n >> m;
vector<long long> vec[n];
long long cnt = 0;
for (long long i = 0; i < n; i++) {
cin >> s;
for (long long j = 0; j < s; j++) {
cin >> x;
vec[i].push_back(x);
}
}
for (long long i = 0; i < n; i++) cnt += vec[i].size();
if (cnt == 0) {
cout << n;
return 0;
}
UnionFind UF(n);
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (vec[i].size() == 0 || vec[j].size() == 0) continue;
for (long long a = 0; a < vec[i].size(); a++) {
for (long long b = 0; b < vec[j].size(); b++) {
if (vec[i][a] == vec[j][b]) UF.unionSet(i, j);
}
}
}
}
cout << UF.numDisjointSets() - 1;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int N=100;
const int NIL =-1;
struct node
{
int p,r,l;
};
node T[N];
int leve[N];
int high[N];
void setDepth(int u,int d)//求结点的深度
{
if(u==NIL)
return ;
leve[u]=d;
setDepth(T[u].l,d+1);
setDepth(T[u].r,d+1);
}
int setHeight(int u)//结点的高
{
int h1=0,h2=0;
if(T[u].l!=NIL)
h1=setHeight(T[u].l)+1;
if(T[u].r!=NIL)
h2=setHeight(T[u].r)+1;
return high[u]=h1>h2?h1:h2;
}
int getSibling(int u)//返回兄弟结点
{
if(T[u].p==NIL)
return NIL;
if(T[T[u].p].l!=u&&T[T[u].p].l!=NIL)
return T[T[u].p].l;
if(T[T[u].p].r!=u&&T[T[u].p].r!=NIL)
return T[T[u].p].r;
return NIL;
}
void print(int u)
{
cout<<"node "<<u<<": ";
cout<<"parent = "<<T[u].p<<", ";
cout<< "sibling = " <<getSibling(u)<<", ";
int deg=0;
if(T[u].l!=NIL)
deg++;
if(T[u].r!=NIL)
deg++;
cout<<"degree = "<<deg<<", ";
cout<<"depth = "<<leve[u]<<", ";
cout<<"height = "<<high[u]<<", ";
if(T[u].p==NIL)
cout<<"root"<<endl;
else if(T[u].l==NIL&&T[u].r==NIL)
cout<<"leaf"<<endl;
else
cout<<"internal node"<<endl;
}
int main()
{
int n;
cin>>n;
for(int i=0;i<n;i++) T[i].p=NIL;
for(int i=0;i<n;i++){
int v,l,r;
cin>>v>>l>>r;
T[v].l=l;
T[v].r=r;
if(l!=NIL) T[l].p=v;
if(r!=NIL) T[r].p=v;
}
int id=0;
for(int i=0;i<n;i++){
if(T[i].p==NIL) id=i;
}
setDepth(id,0);
setHeight(id);
for(int i=0;i<n;i++) print(i);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long LINF = 4611686018427387903;
const int dir4[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int dir8[8][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1},
{1, 1}, {-1, -1}, {1, -1}, {-1, 1}};
const int dir63[6][3] = {{0, 0, 1}, {0, 0, -1}, {0, 1, 0},
{0, -1, 0}, {1, 0, 0}, {-1, 0, 0}};
const int daym[2][13] = {{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
char s[211];
int main() {
int a, b, n;
scanf("%d %d %d", &a, &b, &n);
if (a < b) {
s[0] = '1';
b--;
} else {
s[0] = '0';
a--;
}
int p = 1;
while (n > 1) {
n--;
if (s[p - 1] == '1') {
s[p++] = '0';
a--;
} else {
s[p++] = '1';
b--;
}
}
if (s[p - 1] == '0') {
while (a--) s[p++] = '0';
while (b--) s[p++] = '1';
s[p] = '\0';
} else {
while (b--) s[p++] = '1';
while (a--) s[p++] = '0';
s[p] = '\0';
}
printf("%s\n", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool pr(int n) {
for (int i = 2; i <= int(sqrt(n * 1.0)); ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
int z(int n) {
int res = 0;
while (n) {
res *= 10;
res += n % 10;
n /= 10;
}
return res;
}
int main(void) {
int a, k = 0, i = 12, q;
cin >> a;
while (k < a) {
++i;
q = z(i);
if (q != i && pr(i) && pr(q)) {
++k;
}
}
cout << i;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
class Solution {
public:
void solve(std::istream& in, std::ostream& out) {
int a, b, c, d;
in >> a >> b >> c >> d;
if (a * d < b * c) {
int num = b * c - a * d;
int dom = b * c;
int g = gcd(num, dom);
num /= g;
dom /= g;
out << num << '/' << dom << '\n';
} else if (a * d > b * c) {
int num = a * d - c * b;
int dom = a * d;
int g = gcd(num, dom);
num /= g;
dom /= g;
out << num << '/' << dom << '\n';
} else
out << "0/1\n";
}
};
void solve(std::istream& in, std::ostream& out) {
out << fixed << std::setprecision(6);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a == b || c == d) {
cout << "NO"
<< "\n";
continue;
}
if (max(a, b) == max(c, d) && max(a, b) == min(a, b) + min(c, d)) {
cout << "YES"
<< "\n";
} else
cout << "NO"
<< "\n";
}
}
| 2 |
#include <iostream>
#include <cstdio>
#include <cassert>
#include <cstring>
#include <vector>
#include <valarray>
#include <array>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <complex>
#include <random>
using namespace std;
typedef long long ll;
/**
* F-F ??????????????¨?????????????????¨
*/
template<int V>
struct MaxFlow {
struct Edge {
int to, rev, cap;
};
vector<Edge> g[V];
/// ?????????
void init() {
for (int i = 0; i < V; i++) {
g[i].clear();
}
}
/// ??????????????????
void add(int from, int to, int cap) {
g[from].push_back(Edge{to, (int)g[to].size(), cap});
g[to].push_back(Edge{from, (int)g[from].size()-1, 0});
}
/// ??????????????????
/// ??????????????¨?????????, ??????1??????2????????????????????????????????????
void add_multi(int from, int to, int cap) {
g[from].push_back(Edge{to, (int)g[to].size(), cap});
g[to].push_back(Edge{from, (int)g[from].size()-1, cap});
}
int erase(int from, int to) {
for (int i = 0; i < (int)g[from].size(); i++) {
auto e = g[from][i];
if (e.to == to) {
int c = g[to][e.rev].cap - e.cap;
g[to].erase(g[to].begin()+e.rev);
g[from].erase(g[from].begin()+i);
return c;
}
}
assert(false);
}
bool used[V];
bool dfs(int s, int t) {
if (s == t) return true;
used[s] = true;
for (auto &e : g[s]) {
if (used[e.to]) continue;
if (!e.cap) continue;
if (dfs(e.to, t)) {
e.cap -= 1;
g[e.to][e.rev].cap += 1;
return true;
}
}
return false;
}
int exec(int s, int t, int F) {
int f = 0;
while (f < F) {
fill_n(used, V, false);
if (!dfs(s, t)) break;
f++;
}
return f;
}
void print() {
for (int i = 0; i < V; i++) {
for (auto &e: g[i]) {
printf("(%d %d %d)\n", i, e.to, e.cap);
}
}
}
};
typedef pair<int, int> P;
const int MN = 110;
const int ML = 1100;
MaxFlow<ML*2> mf;
int dist[MN][MN];
P qu[ML];
bool solve() {
mf.init();
int n, m, l;
cin >> n >> m >> l;
if (!n) return false;
for (int i = 0; i < MN; i++) {
for (int j = 0; j < MN; j++) {
if (i == j) dist[i][j] = 0;
else dist[i][j] = 1e8;
}
}
for (int i = 0; i < m; i++) {
int u, v, d;
cin >> u >> v >> d;
dist[u][v] = d;
dist[v][u] = d;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist[i][j] = min(dist[i][j],
dist[i][k]+dist[k][j]);
}
}
}
for (int i = 0; i < l; i++) {
int p, t;
cin >> p >> t;
qu[i] = P(t, p);
}
sort(qu, qu+l);
int vs = 2*ML-1;
int vt = 2*ML-2;
for (int i = 0; i < l; i++) {
for (int j = i+1; j < l; j++) {
int ap, at, bp, bt;
tie(at, ap) = qu[i];
tie(bt, bp) = qu[j];
if (dist[ap][bp] <= bt - at) {
mf.add(i, j+ML, 1);
}
}
}
for (int i = 0; i < l; i++) {
mf.add(vs, i, 1);
mf.add(i+ML, vt, 1);
}
cout << l - mf.exec(vs, vt, 100000) << endl;
return true;
}
int main() {
while (true) {
if (!solve()) break;
}
return 0;
}
| 0 |
#define _USE_MATH_DEFINES
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<list>
#include<stack>
#include<cstring>
#include<string>
#include<cmath>
using namespace std;
int main(){
while(true){
stack<double> s;
char In[81];
double num=0;
bool is_pos=true;
int r;
for(int i=0;r=scanf("%c",&In[i]);i++){
if(In[i]=='\n') break;
if(r==EOF) return 0;
}
for(int i=0;In[i]!='\n';i++){
if(In[i]==' ') continue;
if('0'<=In[i] && In[i]<='9'){
num = num*10+(In[i]-'0');
if(In[i+1]<'0' || '9'<In[i+1]){
if(is_pos==false) num *= -1;
s.push(num);
num = 0; is_pos = true;
}
}
else{
if(In[i]=='-' && '0'<=In[i+1] && In[i+1]<='9'){
is_pos = false;
}
else{
double a,b;
b = s.top(); s.pop();
a = s.top(); s.pop();
if(In[i]=='+') s.push(a+b);
else if(In[i]=='-') s.push(a-b);
else if(In[i]=='*') s.push(a*b);
else s.push(a/b);
}
}
}
printf("%lf\n",s.top());
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
long long sum[maxn], s[maxn];
bool cmp(long long x, long long y) { return x > y; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
long long t;
cin >> t;
s[i] = t / 100;
}
long long x, y, a, b;
cin >> x >> a;
cin >> y >> b;
long long k;
if (x < y) swap(x, y), swap(a, b);
cin >> k;
sort(s + 1, s + 1 + n, cmp);
int pos;
long long res = 0ll;
sum[0] = 0;
int t1 = 0, t2 = 0, t3 = 0;
for (pos = 1; pos <= n; pos++) {
sum[pos] = sum[pos - 1] + s[pos];
if (pos % a == 0) t1++;
if (pos % b == 0) t2++;
if (pos % a == 0 && pos % b == 0) t3++;
res = sum[t3] * (x + y) + (sum[t1] - sum[t3]) * x +
(sum[t1 + t2 - t3] - sum[t1]) * y;
if (res >= k) break;
}
if (pos != n + 1)
cout << pos << endl;
else
cout << "-1" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, mod = 1e9 + 7;
const long long inf = 1e18;
string s[maxn], ans[maxn];
int cnt[maxn], n, m;
vector<int> dp[maxn];
bool check(int mid) {
int k = 2 * mid + 1;
fill(cnt, cnt + m, 0);
if (k > n || k > m) return 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < m; j++) {
if (dp[i][j] >= k) cnt[j]++;
if (i + k < n && dp[i + k][j] >= k) cnt[j]--;
}
int sm = 0;
for (int j = m - 1; j >= 0; j--) {
sm += cnt[j];
if (j + k < m) sm -= cnt[j + k];
if (s[i][j] == 'X' && sm == 0) return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) ans[i] += '.';
dp[i].resize(m);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') {
dp[i][j] = 0;
} else {
dp[i][j] =
1 + min(i == 0 ? 0 : dp[i - 1][j], j == 0 ? 0 : dp[i][j - 1]);
if (s[i - dp[i][j] + 1][j - dp[i][j] + 1] == '.') dp[i][j]--;
}
}
}
int l = 0, r = maxn;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dp[i][j] >= (2 * l + 1)) ans[i - l][j - l] = 'X';
}
}
cout << l << "\n";
for (int i = 0; i < n; i++) cout << ans[i] << "\n";
return 0;
}
| 3 |
#include "bits/stdc++.h"
using namespace std;
//#define int long long
#define DBG 0
#define dump(o) if(DBG){cerr<<#o<<" "<<o<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) c.begin(),c.end()
static const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
static const int MOD = (int)(1e9 + 7);
signed main() {
int L, N; cin >> L >> N;
int m = 0;
rep(i, 0, N) {
int x, w; cin >> x >> w;
m += x*w;
}
bool minus = false;
if (m > 0)minus = true;
m = abs(m);
vector<int> X, W;
rrep(i, 1, L + 1) {
if (m == 0)break;
int x = i, w = m / i;
if (w) {
X.emplace_back(x);
W.emplace_back(w);
m -= (m / i)*i;
}
}
cout << X.size() << endl;
rep(i, 0, X.size()) {
if (minus)cout << "-";
cout << X[i] << " " << W[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[8][2];
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 2; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < 8; i = i + 2) {
for (int j = 0; j < 1; j++) {
if (a[i][j] + a[i + 1][0] <= n) {
cout << i / 2 + 1 << " " << a[i][j] << " " << n - a[i][j] << endl;
return 0;
}
if (a[i][j + 1] + a[i + 1][0] <= n) {
cout << i / 2 + 1 << " " << a[i][j + 1] << " " << n - a[i][j + 1]
<< endl;
return 0;
}
if (a[i][j] + a[i + 1][1] <= n) {
cout << i / 2 + 1 << " " << a[i][j] << " " << n - a[i][j] << endl;
return 0;
}
if (a[i][j + 1] + a[i + 1][1] <= n) {
cout << i / 2 + 1 << " " << a[i][j + 1] << " " << n - a[i][j + 1]
<< endl;
return 0;
}
}
}
cout << "-1" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a;
cin >> n >> k;
vector<int> v, brr(n), arr(n);
long long mx = 1, sum = 0;
for (int i = 0; i < n; i++) {
cin >> a;
arr[i] = a;
}
for (int i = 0; i < n; i++) {
if (arr[i] > n - k) v.push_back(i);
}
sort(arr.begin(), arr.end());
for (int i = n - 1; i > n - k - 1; i--) sum += arr[i];
for (int i = 0; i < v.size() - 1; i++) {
mx = (mx * (v[i + 1] - v[i])) % 998244353;
}
cout << sum << " " << mx;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a[1000], i, cnt = 0;
cin >> n;
cnt = n;
for (i = 0; i < n; i++) {
cin >> a[i];
cnt = cnt + (1 + i) * (a[i] - 1);
}
cout << cnt;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005;
const int MAXN = 1000000;
const int logn = 12;
const int inf = 2e9;
const int alpha = 26;
const int my_hash = 31;
const long long base = 1000000000;
const long long my_mod = 2674894331;
const long long l_inf = 4e18;
const long long mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-10;
int main() {
int a1, a2, a3, b1, b2, b3, n;
scanf("%d %d %d %d %d %d %d", &a1, &a2, &a3, &b1, &b2, &b3, &n);
printf((a1 + a2 + a3 + 4) / 5 + (b1 + b2 + b3 + 9) / 10 <= n ? "YES" : "NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int tele(string str, int l);
int main() {
int t;
cin >> t;
while (t--) {
int l;
cin >> l;
string str;
cin >> str;
int x = tele(str, l);
if (x == 1)
cout << "YES"
<< "\n";
if (x == -1)
cout << "NO"
<< "\n";
}
return 0;
}
int tele(string str, int l) {
int i;
for (i = 0; i < l; i++) {
if (str[i] == '8' && (l - i) >= 11) return 1;
}
return -1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[200005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%1d", &a[i]);
}
printf("%d\n", n);
bool ok = 1;
for (int i = k + 1; i <= n; ++i) {
if (a[i] < a[i - k]) {
break;
} else if (a[i] > a[i - k]) {
ok = 0;
break;
}
}
if (!ok) {
a[k]++;
for (int i = k; i >= 1; --i) {
if (a[i] >= 10) {
a[i] -= 10;
a[i - 1]++;
}
}
}
for (int i = 1; i <= n; ++i) {
if (i <= k) {
printf("%d", a[i]);
} else
printf("%d", a[i] = a[i - k]);
}
puts("");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 24) + 5;
int n, sta, a[N], f[N];
char s[5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
sta = 0;
for (int i = 0; i < 3; i++) sta |= (1 << (s[i] - 'a'));
for (int i = sta; i; i = (i - 1) & sta) {
if (__builtin_popcount(i) & 1)
a[i]++;
else
a[i]--;
}
}
for (int i = 0; i < (1 << 24); i++) f[i] = a[i];
for (int i = 0; i < 24; i++)
for (int j = 0; j < (1 << 24); j++)
if (j & (1 << i)) f[j] += f[j ^ (1 << i)];
long long ans = 0;
for (int i = 0; i < (1 << 24); i++) ans ^= 1LL * f[i] * f[i];
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void call(long long int num, string str) {
map<pair<long long int, long long int>, bool> visited;
map<pair<long long int, long long int>, long long int> pos;
visited[{0, 0}] = true;
pos[{0, 0}] = 0;
long long int ud = 0, lr = 0, leftPos = 0, rightPos = 0;
long long int difMIn = num + 5;
for (long long int i = 0; i < num; i++) {
if (str[i] == 'U') ud++;
if (str[i] == 'D') ud--;
if (str[i] == 'R') lr++;
if (str[i] == 'L') lr--;
if (visited[{ud, lr}]) {
long long int dis = (i + 1) - pos[{ud, lr}] + 1;
if (dis < difMIn) {
difMIn = dis;
leftPos = pos[{ud, lr}] + 1;
rightPos = i + 1;
}
}
pos[{ud, lr}] = i + 1;
visited[{ud, lr}] = true;
}
if (difMIn == num + 5)
cout << -1 << endl;
else
cout << leftPos << " " << rightPos << endl;
}
int main() {
long long int n, m, num, tc, t = 1;
cin >> tc;
while (tc--) {
cin >> num;
string str;
cin >> str;
call(num, str);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (x == 0) {
return y;
}
if (y == 0) {
return x;
}
if (x >= y) {
return gcd(x % y, y);
} else {
return gcd(y % x, x);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> a;
long long u;
for (long long i = 0; i < n; ++i) {
cin >> u;
a.push_back(u);
}
long long r;
long long l;
while (k != 1) {
r = k;
for (long long i = 0; i < a.size(); ++i) {
l = gcd(a[i], k);
if (l > 1) {
a.erase(a.begin() + i);
k /= l;
for (long long j = 0; j < a.size(); ++j) {
a[j] /= gcd(l, a[j]);
}
break;
}
}
if (r == k) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main() {
char ch;
int num, count[1200] = {0};
while (cin >> ch){
num = ch - 'a';
if('A' <= ch && ch <= 'Z') count[ch - 'A']++;
else count[num]++;
}
for(int i=0; i<26; i++)
cout << char('a'+i) << " : " << count[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define reps(i, f, n) for(int i = (int)(f); i < (int)(n); i++)
typedef pair<int, int> P;
signed main()
{
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
int n, m; cin >> n >> m;
vector<P> robot;
rep(i, m) {
int x, y; cin >> x >> y;
robot.emplace_back(x, y);
}
sort(all(robot));
vector<int> l(n), h(n);
rep(i, n) l[i] = h[i] = i;
for(auto &p : robot) {
int x, y; tie(x, y) = p;
l[y] = l[y-1];
h[y-1] = h[y];
}
rep(i, n) cout << h[i]-l[i]+1 << (i==n-1 ? '\n' : ' ');
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
scanf("%d %d", &n, &s);
s = 1000000 - s;
vector<pair<double, int> > cities;
for (int i = (0); i < (n); i++) {
int x, y, k;
scanf("%d %d %d", &x, &y, &k);
cities.push_back(make_pair(sqrt(x * x + y * y), k));
}
std::sort(cities.begin(), cities.end());
double x = 0.0;
for (int i = (0); i < (n); i++) {
if (s <= 0) {
break;
}
x = cities[i].first;
s -= cities[i].second;
}
if (s > 0) {
cout << "-1";
} else
printf("%.7f", x);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t, a, b, c;
cin >> n;
string s;
for (k = 0; k < n; k++) {
cin >> s;
a = b = c = 0;
for (t = 0; t < s.length(); t++) {
if (s[t] == 'A') a++;
if (s[t] == 'B') b++;
if (s[t] == 'C') c++;
}
if (b == a + c)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
char S[MAXN];
int N, fact[11];
int main() {
scanf("%s", S + 1);
N = strlen(S + 1);
int c = 0, i;
fact[0] = 1;
for (i = 1; i <= 10; i++) fact[i] = fact[i - 1] * i;
for (i = 1; i <= N; i++)
if ((S[i] >= 'A') && (S[i] <= 'Z')) c |= 1 << (S[i] - 'A');
c = __builtin_popcount(c);
if ((S[1] >= 'A') && (S[i] <= 'Z'))
printf("%d", fact[10] / fact[10 - c] - fact[9] / fact[10 - c]);
else
printf("%d", (fact[10] / fact[10 - c]) * ((S[1] == '?') ? 9 : 1));
for (i = 2; i <= N; i++)
if (S[i] == '?') putchar('0');
puts("");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int r[105];
double D[105][105 * 1005];
int main() {
scanf("%d %d", &n, &m);
int inits = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &r[i]);
inits += r[i];
}
if (m == 1) {
printf("%.11lf\n", 1.0);
return 0;
}
D[0][0] = 1;
for (int i = 1; i <= n; ++i) {
double s = 0;
for (int j = 0; j <= n * m; ++j) {
D[i][j] += s - (j >= r[i] ? D[i - 1][j - r[i]] : 0);
s += D[i - 1][j];
if (j >= m) {
s -= D[i - 1][j - m];
}
D[i][j] /= (m - 1);
}
}
double p = 0;
for (int j = 0; j < inits; ++j) {
p += D[n][j];
}
printf("%.11lf\n", p * (m - 1) + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool u[550][505] = {0}, ans[100100] = {0};
int n, m, x, y, q = 0;
cin >> n >> m >> x >> y;
string s;
cin >> s;
u[x][y] = 1;
ans[0] = 1;
for (int i = 0; i < s.size(); i++) {
int x1 = x, y1 = y;
if (s[i] == 'U' && x > 1)
x1--;
else if (s[i] == 'D' && x < n)
x1++;
else if (s[i] == 'L' && y > 1)
y1--;
else if (s[i] == 'R' && y < m)
y1++;
if (!u[x1][y1]) {
u[x1][y1] = 1;
ans[i + 1] = 1;
q = 1;
} else
q = 0;
x = x1;
y = y1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!u[i][j]) q++;
}
}
for (int i = 0; i < s.size(); i++) {
cout << ans[i] << " ";
}
cout << q << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const int inf = 1e9;
int n;
int a[maxn];
int dp[maxn][31];
inline void upd(int &x, int y) { x = min(x, y); }
int main() {
cin.tie();
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i], a[i] /= 100;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= 30; ++j) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= 30; ++j) {
if (dp[i][j] == inf) continue;
upd(dp[i + 1][j + a[i] / 10], dp[i][j] + a[i]);
int d = min(j, a[i]);
upd(dp[i + 1][j - d], dp[i][j] + a[i] - d);
}
int ans = inf;
for (int j = 0; j <= 30; ++j) ans = min(ans, dp[n][j]);
cout << ans * 100 << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int read_int() {
int value;
cin >> value;
return value;
}
template <class T>
void println(const T& value) {
cout << value << '\n';
}
template <class T>
void print_vector(const vector<T>& values) {
for (size_t(i) = 0, __size = (values.size()); (i) < __size; ++(i))
cout << values[i] << ' ';
cout << '\n';
;
}
void print_indexes(const vector<size_t>& indexes) {
for (size_t(i) = 0, __size = (indexes.size()); (i) < __size; ++(i))
cout << indexes[i] + 1 << ' ';
cout << '\n';
;
}
bool check_index(const size_t index, const size_t size) {
return (0 <= index && index < size);
}
bool check_indexes(const size_t x, const size_t x_size, const size_t y,
const size_t y_size) {
return check_index(x, x_size) && check_index(y, y_size);
}
int set_bit(int& mask, const size_t bit_index) {
return mask = (mask | (1 << bit_index));
}
const unsigned int MODULO = 1000 * 1000 * 1000 + 9;
inline unsigned int add(unsigned int a, unsigned int b) {
return (a + b) % MODULO;
}
inline unsigned int multiply(unsigned int a, unsigned int b) {
return static_cast<unsigned int>((a * 1LL * b) % MODULO);
}
class fib_matrix {
public:
unsigned int values[2][2];
fib_matrix() {
for (size_t(row) = 0, __size = (2); (row) < __size; ++(row))
for (size_t(column) = 0, __size = (2); (column) < __size; ++(column))
values[row][column] = 0;
}
fib_matrix(const fib_matrix& base) {
for (size_t(row) = 0, __size = (2); (row) < __size; ++(row))
for (size_t(column) = 0, __size = (2); (column) < __size; ++(column))
values[row][column] = base.values[row][column];
}
fib_matrix& operator=(const fib_matrix& other) {
if (this != &other) {
for (size_t(row) = 0, __size = (2); (row) < __size; ++(row))
for (size_t(column) = 0, __size = (2); (column) < __size; ++(column))
(*this).values[row][column] = other.values[row][column];
}
return (*this);
}
fib_matrix operator+(const fib_matrix& other) {
fib_matrix result;
for (size_t(row) = 0, __size = (2); (row) < __size; ++(row))
for (size_t(column) = 0, __size = (2); (column) < __size; ++(column))
result.values[row][column] =
add((*this).values[row][column], other.values[row][column]);
return result;
}
fib_matrix operator*(const fib_matrix& other) {
fib_matrix result;
for (size_t(row) = 0, __size = (2); (row) < __size; ++(row))
for (size_t(mid) = 0, __size = (2); (mid) < __size; ++(mid))
for (size_t(other_column) = 0, __size = (2); (other_column) < __size;
++(other_column))
result.values[row][other_column] =
add(result.values[row][other_column],
multiply((*this).values[row][mid],
other.values[mid][other_column]));
return result;
}
};
const unsigned long long SHIFT = 32;
const unsigned long long FIRST_MASK = (1LL << SHIFT) - 1;
long long multiply(const fib_matrix& coeff_matrix,
const long long& base_values) {
unsigned int base_first = ((base_values)&FIRST_MASK);
unsigned int base_second = ((base_values) >> SHIFT);
unsigned int first_value =
add(multiply(coeff_matrix.values[0][0], base_first),
multiply(coeff_matrix.values[0][1], base_second));
unsigned int second_value =
add(multiply(coeff_matrix.values[1][0], base_first),
multiply(coeff_matrix.values[1][1], base_second));
return ((first_value) |
(static_cast<unsigned long long>(second_value) << SHIFT));
}
unsigned int get_sum(const fib_matrix& sum_matrix,
const long long& base_values) {
unsigned int base_first = ((base_values)&FIRST_MASK);
unsigned int base_second = ((base_values) >> SHIFT);
unsigned int sum = add(multiply(sum_matrix.values[0][0], base_first),
multiply(sum_matrix.values[0][1], base_second));
return sum;
}
long long add_base(const long long& changed_base, const long long& added_base) {
unsigned int first_value =
add(((changed_base)&FIRST_MASK), ((added_base)&FIRST_MASK));
unsigned int second_value =
add(((changed_base) >> SHIFT), ((added_base) >> SHIFT));
return ((first_value) |
(static_cast<unsigned long long>(second_value) << SHIFT));
}
static const long long BASE =
((1LL) | (static_cast<unsigned long long>(0LL) << SHIFT));
static const long long EMPTY_BASE = 0;
inline size_t min(const size_t a, const size_t b) { return (a < b ? a : b); }
inline size_t max(const size_t a, const size_t b) { return (a > b ? a : b); }
class Segment_tree {
private:
static const size_t ROOT = 1;
const size_t array_size, tree_size;
vector<size_t> v_sizes;
vector<long long> bases;
vector<unsigned int> sums;
vector<fib_matrix> powers;
vector<long long> base_powers;
vector<fib_matrix> sum_matrixes;
unsigned int build_tree(const size_t v, const size_t left, const size_t right,
const vector<unsigned int>& array) {
if (left == right) {
v_sizes[v] = 1;
return (sums[v] = array[left]);
} else {
size_t mid = ((left + right) >> 1);
size_t v_left = (v << 1);
size_t v_right = (v_left + 1);
unsigned int left_sum = build_tree(v_left, left, mid, array);
unsigned int right_sum = build_tree(v_right, mid + 1, right, array);
v_sizes[v] = v_sizes[v_left] + v_sizes[v_right];
return (sums[v] = add(left_sum, right_sum));
}
}
void push(const size_t v, const size_t v_left, const size_t v_right) {
long long vertex_base = bases[v];
if (vertex_base != 0) {
long long left_base = bases[v_left];
long long right_base = bases[v_right];
size_t left_size = v_sizes[v_left];
bases[v_left] = add_base(left_base, vertex_base);
bases[v_right] =
add_base(right_base, multiply(powers[left_size], vertex_base));
bases[v] = EMPTY_BASE;
}
}
void update(const size_t v, const size_t v_left, const size_t v_right) {
long long left_base = bases[v_left];
size_t left_size = v_sizes[v_left];
long long right_base = bases[v_right];
size_t right_size = v_sizes[v_right];
unsigned int left_sum =
add(sums[v_left], get_sum(sum_matrixes[left_size], left_base));
unsigned int right_sum =
add(sums[v_right], get_sum(sum_matrixes[right_size], right_base));
sums[v] = add(left_sum, right_sum);
}
unsigned int add_segment(const size_t v, const size_t left,
const size_t right, const size_t left_index,
const size_t right_index, const size_t base_power) {
if (right_index < left || right < left_index) return 0;
if (left == left_index && right_index == right) {
long long base = base_powers[base_power];
bases[v] = add_base(bases[v], base);
} else {
size_t v_left = (v << 1);
size_t v_right = (v_left + 1);
size_t mid = ((left + right) >> 1);
push(v, v_left, v_right);
if (right_index <= mid)
add_segment(v_left, left, mid, left_index, right_index, base_power);
else if (left_index >= mid + 1)
add_segment(v_right, mid + 1, right, left_index, right_index,
base_power);
else {
size_t left_part_size = (mid - left_index + 1);
add_segment(v_left, left, mid, left_index, mid, base_power);
add_segment(v_right, mid + 1, right, mid + 1, right_index,
base_power + left_part_size);
}
update(v, v_left, v_right);
}
return sums[v];
}
unsigned int const get_segment(const size_t v, const size_t left,
const size_t right, const size_t left_index,
const size_t right_index) {
if (right_index < left || right < left_index) return 0;
unsigned int segment_sum = 0;
if (left == left_index && right_index == right) {
segment_sum = add(segment_sum, sums[v]);
size_t v_size = v_sizes[v];
segment_sum = add(segment_sum, get_sum(sum_matrixes[v_size], bases[v]));
} else {
size_t v_left = (v << 1);
size_t v_right = (v_left + 1);
size_t mid = ((left + right) >> 1);
push(v, v_left, v_right);
unsigned int left_sum =
get_segment(v_left, left, mid, left_index, min(mid, right_index));
unsigned int right_sum = get_segment(
v_right, mid + 1, right, max(left_index, mid + 1), right_index);
segment_sum = add(segment_sum, add(left_sum, right_sum));
update(v, v_left, v_right);
}
return segment_sum;
}
public:
Segment_tree(const vector<unsigned int>& array)
: array_size(array.size()),
tree_size(array_size << 2),
v_sizes(tree_size),
bases(tree_size),
sums(tree_size),
powers(array_size + 10),
base_powers(powers.size()),
sum_matrixes(powers.size()) {
powers[0].values[0][0] = 1;
powers[0].values[1][1] = 1;
powers[1].values[0][0] = 1;
powers[1].values[0][1] = 1;
powers[1].values[1][0] = 1;
for (size_t power = 2; power < powers.size(); ++power)
powers[power] = powers[power - 1] * powers[1];
for (size_t(power) = 0, __size = (powers.size()); (power) < __size;
++(power))
base_powers[power] = multiply(powers[power], BASE);
for (size_t power = 1; power < powers.size(); ++power)
sum_matrixes[power] = sum_matrixes[power - 1] + powers[power - 1];
build_tree(ROOT, 0, array_size - 1, array);
}
void add_segment(const size_t left, const size_t right) {
add_segment(ROOT, 0, array_size - 1, left, right, 0);
}
unsigned int const get_segment(const size_t left, const size_t right) {
unsigned int sum = get_segment(ROOT, 0, array_size - 1, left, right);
return sum;
}
};
const int ADD = 1, PRINT_SUM = 2;
int main() {
const size_t n = read_int();
size_t queries_count = read_int();
vector<unsigned int> array(n);
for (size_t(i) = 0, __size = (n); (i) < __size; ++(i)) array[i] = read_int();
Segment_tree tree(array);
while (queries_count-- > 0) {
int operation = read_int();
size_t left = read_int() - 1;
size_t right = read_int() - 1;
if (operation == ADD)
tree.add_segment(left, right);
else
println(tree.get_segment(left, right));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define lp(i,n) for(int i=0;i<n;i++)
int main(){
int n;
cin>>n;
lp(z,n){
int a,b=0,count=0;
cin>>a;
vector<int> lis;
while(1){
if(a/10==0) break;
int i=1;
while(1){
if(a/10==0) break;
b+=a%10*i;
a/=10;
lis.push_back(b*a);
i*=10;
}
b=0;
sort(lis.begin(),lis.end());
reverse(lis.begin(),lis.end());
a=lis[0];
lis.clear();
count++;
}
cout<<count<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = ' ';
int f = 1, x = 0;
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') f *= -1;
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return f * x;
}
long long ans3, num, n, ans1, ans2, f;
int main() {
cin >> num >> n;
ans1 = 1e19;
for (long long i = (1); i <= (n); i++) {
long long d;
cin >> d;
if (d <= 0) continue;
if (num % d < ans1) {
ans1 = num % d;
ans3 = num / d;
ans2 = i;
f = 1;
}
}
if (f)
cout << ans2 << ' ' << ans3;
else
cout << 1 << ' ' << 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 100;
int t[20 * N], ls[20 * N], rs[20 * N], a[N], root[N];
int cur_size = 1;
void upd(int &v, int u, int l, int r, int pos, int x) {
v = cur_size++;
t[v] = t[u] + x, ls[v] = ls[u], rs[v] = rs[u];
if (l + 1 == r) {
return;
}
int mid = (l + r) / 2;
if (pos < mid)
upd(ls[v], ls[u], l, mid, pos, x);
else
upd(rs[v], rs[u], mid, r, pos, x);
t[v] = t[ls[v]] + t[rs[v]];
}
int get(int v, int l, int r, int ql, int qr) {
if (qr <= l || r <= ql) return 0;
if (ql <= l && r <= qr) return t[v];
int mid = (l + r) / 2;
return get(ls[v], l, mid, ql, qr) + get(rs[v], mid, r, ql, qr);
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> pos[N];
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
int p =
lower_bound(pos[a[i]].begin(), pos[a[i]].end(), i) - pos[a[i]].begin();
upd(root[i], root[i - 1], 1, n + 1, i, 1);
if (p >= k) {
p -= k;
int tmp = 0;
upd(tmp, root[i], 1, n + 1, pos[a[i]][p], -1);
root[i] = tmp;
}
}
int q;
cin >> q;
int ans = 0;
while (q--) {
int l, r;
cin >> l >> r;
l = (l + ans) % n + 1;
r = (r + ans) % n + 1;
if (l > r) swap(l, r);
ans = get(root[r], 1, n + 1, l, r + 1);
cout << ans << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10005;
const int MAXO = 105;
const int INF = 0x3f3f3f3f;
vector<int> e[MAXN];
int val[MAXN], mx[MAXN][MAXO], mi[MAXN][MAXO];
void dfs(int u, int t) {
for (int j = 0; j < MAXO; j++) mx[u][j] = -INF, mi[u][j] = INF;
if (val[u] > 0) {
mx[u][0] = mi[u][0] = val[u];
return;
}
int l = e[u][0], r = e[u][1];
dfs(l, t), dfs(r, t);
for (int i = 0; i < MAXO; i++)
if (mx[l][i] > -INF)
for (int j = 0; i + j + 1 < MAXO; j++)
if (mx[r][j] > -INF) {
mx[u][i + j + t] = max(mx[u][i + j + t], mx[l][i] + mx[r][j]);
mx[u][i + j + 1 - t] = max(mx[u][i + j + 1 - t], mx[l][i] - mi[r][j]);
mi[u][i + j + t] = min(mi[u][i + j + t], mi[l][i] + mi[r][j]);
mi[u][i + j + 1 - t] = min(mi[u][i + j + 1 - t], mi[l][i] - mx[r][j]);
}
}
char str[MAXN];
int main() {
int P, M, n = 0;
scanf("%s%d%d", str, &P, &M);
stack<int> stk;
for (int i = 0; str[i]; i++) {
if (str[i] == '(')
stk.push(++n);
else if (str[i] == ')') {
int t = stk.top();
stk.pop();
if (!stk.empty()) e[stk.top()].push_back(t);
} else if (str[i] >= '1' && str[i] <= '9') {
if (stk.empty()) return 0 * printf("%d\n", str[i] - '0');
e[stk.top()].push_back(++n);
val[n] = str[i] - '0';
}
}
dfs(1, P < M);
return 0 * printf("%d\n", mx[1][min(P, M)]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[101][10001];
int pr[101][10001], ne[101][10001];
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
bool good = 0;
for (int j = 0; j < m; j++) {
char c;
cin >> c;
a[i][j] = c - '0';
good |= a[i][j];
}
if (!good) {
cout << "-1\n";
return 0;
}
}
for (int i = 0; i < n; i++) {
int pos = 0;
for (int j = 0; j < m; j++)
if (a[i][j] == 1) pos = j;
pr[i][0] = (a[i][0] == 0 ? m - pos : 0);
for (int j = 1; j < m; j++)
pr[i][j] = (a[i][j] == 0 ? pr[i][j - 1] + 1 : 0);
pos = m - 1;
for (int j = m - 1; j >= 0; j--)
if (a[i][j] == 1) pos = j;
ne[i][m - 1] = (a[i][m - 1] == 0 ? pos + 1 : 0);
for (int j = m - 2; j >= 0; j--)
ne[i][j] = (a[i][j] == 0 ? ne[i][j + 1] + 1 : 0);
}
int res = int(1e9);
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) sum += min(pr[i][j], ne[i][j]);
res = min(res, sum);
}
cout << res << '\n';
return 0;
}
| 1 |
#include<stdio.h>
#include<math.h>
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
int W, H, C;
int max, sum, kaz, hen;
kaz = 100001;
cin >> W >> H >> C;
sum = W*H;
if (W < H)
{
max = W;
}
else
{
max = H;
}
for (int i = 1; i <= max; i++)
{
hen = (i*i);
if (W%i==0 && H%i==0)
{
kaz = sum / hen;
}
}
cout << C*kaz << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const inline int __GET_INT() {
int ret;
scanf("%d", &ret);
return ret;
}
int main() {
long long A = __GET_INT(), B = __GET_INT(), n = __GET_INT();
for (int i = 0; i < n; ++i) {
long long l = __GET_INT(), t = __GET_INT(), m = __GET_INT();
long long first = B * (l - 1) + A;
if (first > t) {
puts("-1");
} else {
int r = -1;
long long low = 1, high = 1000000, mid;
while (low <= high) {
mid = (low + high) >> 1;
long long val = ((mid * (mid - 1)) / 2) * B + mid * first;
long long second = B * (l + mid - 2) + A;
if (second > t || val > (t * m)) {
high = mid - 1;
} else {
low = mid + 1;
r = l + mid - 1;
}
}
printf("%d\n", r);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
int n, a, r, m;
int h[N];
long long f(int H) {
long long rem = 0, all = 0;
for (int i = 1; i <= n; i++) {
if (h[i] > H) {
rem += h[i] - H;
}
all += h[i];
}
if (all == H * 1ll * n) return rem * 1ll * m;
if (all > H * 1ll * n) {
long long del = all - H * 1ll * n;
rem = max(0ll, rem - del);
return del * 1ll * r + rem * 1ll * m;
}
return rem * 1ll * m + (H * 1ll * n - all) * 1ll * a;
}
int main() {
cin >> n >> a >> r >> m;
m = min(m, a + r);
int mx = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &h[i]);
mx = max(mx, h[i]);
}
sort(h + 1, h + n + 1);
int ina = 0, inb = mx;
while (ina < inb) {
int mid = (ina + inb) / 2;
if (f(mid) <= f(mid + 1)) {
inb = mid;
} else {
ina = mid + 1;
}
}
cout << f(ina) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, s2 = 0, o, o2 = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
o = a[0];
s = a[0];
for (int i = 0; i < n; i++) {
if (a[i] > o) {
o = a[i];
o2 = i;
}
if (a[i] < s) {
s = a[i];
s2 = i;
}
}
if (((o2 == 0) && (s2 == n - 1)) || ((o2 == n - 1) && (s2 == 0))) {
cout << n - 1;
} else if (o2 > s2) {
if (n - 1 - s2 >= o2 - 0)
cout << n - 1 - s2;
else
cout << o2 - 0;
} else if (o2 < s2) {
if (n - 1 - o2 >= s2 - 0)
cout << n - 1 - o2;
else
cout << s2 - 0;
}
return 0;
}
| 1 |
#include<stdio.h>
struct TT{int nu;int sco;int jun;};
int main(){
struct TT TR[101]={};
int n,x;
int c=0;
while(1)
{
scanf("%d,%d",&n,&x);if(n==0&&x==0)break;
TR[c].nu=n;TR[c].sco=x;
c++;
}
for(int i=0;i<c;i++)
for(int j=c-1;j>i;j--)
if(TR[j].sco>TR[j-1].sco){struct TT QQ=TR[j];TR[j]=TR[j-1];TR[j-1]=QQ;}
int cn=1;TR[0].jun=1;
for(int i=1;i<c;i++){
if(TR[i].sco!=TR[i-1].sco)cn++;
TR[i].jun=cn;
}
while(scanf("%d",&x)!=EOF){
for(int i=0;i<c;i++)
if(x==TR[i].nu)printf("%d\n",TR[i].jun);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
int a1 = -1, b1 = -1, c1 = -1, a2 = -1, b2 = -1, c2 = -1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
for (int i = 0; i < (int)s.length(); i++) {
if (s[i] == 'a') {
a2 = i;
if (a1 == -1) {
a1 = i;
}
} else if (s[i] == 'b') {
b2 = i;
if (b1 == -1) {
b1 = i;
}
} else if (s[i] == 'c') {
c2 = i;
if (c1 == -1) {
c1 = i;
}
}
}
if (a1 == -1 || a2 == -1 || b1 == -1 || b2 == -1 || c1 == -1 || c2 == -1) {
cout << "NO" << endl;
return 0;
}
if (a1 != 0 || b1 - a2 != 1 || c1 - b2 != 1 || c2 != (int)s.length() - 1) {
cout << "NO" << endl;
return 0;
}
if (c2 - c1 + 1 != a2 - a1 + 1 && c2 - c1 + 1 != b2 - b1 + 1) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3FFFFFFF;
const int maxn = 2222;
struct node {
int st, en, flow, cost, next;
node() {}
node(int st, int en, int flow, int cost, int next)
: st(st), en(en), flow(flow), cost(cost), next(next) {}
} E[101000];
int num, p[maxn];
void init() {
memset(p, -1, sizeof(p));
num = 0;
}
void add(int st, int en, int flow, int cost) {
E[num] = node(st, en, flow, cost, p[st]);
p[st] = num++;
E[num] = node(en, st, 0, -cost, p[en]);
p[en] = num++;
}
int pre[maxn];
int dis[maxn];
bool fg[maxn];
bool spfa(int st, int en) {
for (int i = 0; i <= en; i++) {
fg[i] = 0, dis[i] = inf, pre[i] = -1;
}
queue<int> q;
q.push(st);
fg[st] = 1;
dis[st] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
fg[u] = 0;
for (int i = p[u]; ~i; i = E[i].next) {
int v = E[i].en;
if (E[i].flow && dis[v] > dis[u] + E[i].cost) {
dis[v] = dis[u] + E[i].cost;
pre[v] = i;
if (!fg[v]) {
fg[v] = 1;
q.push(v);
}
}
}
}
if (dis[en] < inf) return 1;
return 0;
}
int solve(int st, int en) {
int ans = 0;
while (spfa(st, en)) {
int d = inf;
for (int i = pre[en]; i + 1; i = pre[E[i].st]) d = min(d, E[i].flow);
for (int i = pre[en]; i + 1; i = pre[E[i].st]) {
E[i].flow -= d;
E[i ^ 1].flow += d;
ans += d * E[i].cost;
}
}
return ans;
}
int n, a[111];
int cnt[30];
int main() {
scanf("%d", &n);
string s;
cin >> s;
for (int i = 0; i < n; i++) cnt[s[i] - 'a']++;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
init();
int st = n + 48, en = st + 1;
for (int i = 0; i < 26; i++) {
add(st, i + n, cnt[i], 0);
for (int j = 0; j < n / 2; j++) {
if (s[j] == s[n - 1 - j]) {
int cost = 0;
if (s[j] == 'a' + i) cost = -max(a[j], a[n - 1 - j]);
add(i + n, j, 1, cost);
} else {
int cost = 0;
if (s[j] == 'a' + i) cost = -a[j];
if (s[n - 1 - j] == 'a' + i) cost = -a[n - 1 - j];
add(i + n, j, 1, cost);
}
}
}
for (int i = 0; i < n / 2; i++) add(i, en, 2, 0);
printf("%d\n", -solve(st, en));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const long long MAXN = 1e6 + 10;
const long long LOG = 22;
const long long INF = 8e18;
const long long MOD = 1e9 + 7;
long long solve() {
long long n, x;
cin >> n >> x;
long long xc = 0;
for (int i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
if (u == x || v == x) xc++;
}
if (xc < 2 || n % 2 == 0) return cout << "Ayush" << '\n', 0;
cout << "Ashish" << '\n';
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void printContainer(T& a) {
auto it = a.begin();
cout << "{";
for (; it != a.end(); ++it) cout << (*it) << ", ";
cout << "}\n";
}
class Fenwick {
vector<int> data;
public:
Fenwick(int n) : data(vector<int>(n)){};
void update(int at, int by) {
while (at < data.size()) {
data[at] += by;
at |= (at + 1);
}
}
int query(int at) {
if (at < 0) return 0;
int res = 0;
while (at >= 0) {
res += data[at];
at = (at & (at + 1)) - 1;
}
return res;
}
};
int main() {
int n;
cin >> n;
Fenwick lleft(n), lright(n);
vector<int> tab(n);
for (int i = 0; i < (int)(n); ++i) {
cin >> tab[i];
((tab[i] == 0) ? lleft : lright).update(i, 1);
}
long long res = 0;
int L = 0, R = n - 1;
while (L < R) {
if (tab[L] == 0) {
++L;
continue;
}
if (tab[R] == 1) {
--R;
continue;
}
int lookingatL = lleft.query(R) - lleft.query(L);
int lookingatR = lright.query(R - 1) - lright.query(L - 1);
if (lookingatL < lookingatR) {
res += lookingatL;
++L;
} else {
res += lookingatR;
--R;
}
}
cout << res << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void min_self(C &a, C b) {
a = min(a, b);
}
template <class C>
void max_self(C &a, C b) {
a = max(a, b);
}
const long long MOD = 1000000007;
long long mod(long long n, long long m = MOD) {
n %= m, n += m, n %= m;
return n;
}
const int MAXN = 1e5 + 5;
const int LOGN = 21;
const long long INF = 1e14;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
template <class T1, class T2>
void add(T1 &x, T2 y, long long m = MOD) {
x += y;
if (x >= m) x -= m;
}
template <class T1, class T2>
void sub(T1 &x, T2 y, long long m = MOD) {
x -= y;
if (x < 0) x += m;
}
int n, k;
string s[2];
bool vis[MAXN][2];
bool bfs(int wall, int node) {
queue<tuple<int, int, int>> q;
q.push({wall, node, 0});
while (!q.empty()) {
int w, h, step;
tie(w, h, step) = q.front();
q.pop();
if (vis[h][w]) continue;
vis[h][w] = 1;
if (step > h) continue;
if (h + k >= n || h + 1 >= n) {
return 1;
}
if (h + 1 < n && s[w][h + 1] != 'X') q.push({w, h + 1, step + 1});
if (h + k < n && s[1 ^ w][h + k] != 'X') q.push({1 ^ w, h + k, step + 1});
if (h - 1 >= 0 && s[w][h - 1] != 'X') q.push({w, h - 1, step + 1});
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s[0] >> s[1];
if (bfs(0, 0))
cout << "YES", cout << "\n";
else
cout << "NO", cout << "\n";
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
int a[maxn];
int b[maxn];
int c[maxn];
int dp[4][maxn];
int main() {
ios::sync_with_stdio(false);
int n;
int ans;
scanf("%d", &n);
for (int i = 1; i < n + 1; ++i) scanf("%d", &a[i]);
for (int i = 1; i < n + 1; ++i) scanf("%d", &b[i]);
for (int i = 1; i < n + 1; ++i) scanf("%d", &c[i]);
if (n == 1) {
ans = a[1];
printf("%d\n", ans);
return 0;
} else if (n == 2) {
ans = max(a[1] + b[2], b[1] + a[2]);
printf("%d\n", ans);
return 0;
}
int i, j, k;
for (i = 1; i <= n; ++i) {
if (i == 1) {
dp[1][i] = a[i];
dp[3][i] = b[i];
} else if (i == n) {
dp[2][i] = max(dp[2][i - 1], dp[3][i - 1]) + a[i];
dp[3][i] = max(dp[0][i - 1], dp[1][i - 1]) + b[i];
} else {
dp[0][i] = max(dp[2][i - 1], dp[3][i - 1]) + a[i];
dp[1][i] = max(dp[0][i - 1], dp[1][i - 1]) + b[i];
dp[2][i] = max(dp[2][i - 1], dp[3][i - 1]) + b[i];
dp[3][i] = max(dp[0][i - 1], dp[1][i - 1]) + c[i];
}
}
ans = max(dp[2][n], dp[3][n]);
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve(int cnum) {
string y;
cin >> y;
int sum = 0;
bool isev = false;
bool hasz = false;
for (auto a : y) {
sum += (a - '0');
if (a == '0' && !hasz) {
hasz = true;
continue;
}
if (a == '0' || a == '2' || a == '4' || a == '6' || a == '8') {
isev = true;
}
}
if (sum % 3 == 0 && hasz && isev)
cout << "red\n";
else
cout << "cyan\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
int count = 1;
for (cin >> t; t--; solve(count), count++)
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long long INFF = (long long)1e18;
const int MXN = (int)2e2 + 7;
const int mod = (int)1e9 + 9;
vector<int> st[101];
int dp[101][1001];
int main() {
int n, t;
scanf("%d %d", &n, &t);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d %d", &a, &b);
st[t - a].push_back(b);
}
for (int i = 0; i < t; i++) {
sort(begin(st[i]), end(st[i]), greater<int>());
for (int j = 1; j < ((int)(st[i]).size()); j++) st[i][j] += st[i][j - 1];
}
for (int i = 0; i < t; i++)
for (int j = 0; j <= 1000; j++) dp[i][j] = -INF;
dp[0][1] = 0;
if (!st[0].empty()) dp[0][0] = st[0][0];
for (int i = 1; i < t; i++) {
for (int j = 0; j <= 1000; j++) {
int jj = min(1000, j * 2);
dp[i][jj] = max(dp[i][jj], dp[i - 1][j]);
for (int k = 0; k < ((int)(st[i]).size()); k++) {
jj = min(1000, j * 2 - k - 1);
if (jj < 0) break;
dp[i][jj] = max(dp[i][jj], dp[i - 1][j] + st[i][k]);
}
}
}
int ans = 0;
for (int j = 0; j <= 1000; j++) ans = max(ans, dp[t - 1][j]);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int wenl, wenr, LL, RR;
char ch[400006];
int main() {
cin >> n;
scanf("%s", ch + 1);
for (int i = 1; i <= n / 2; ++i)
wenl += (ch[i] == '?'), LL += isdigit(ch[i]) ? ch[i] - '0' : 0;
for (int i = n / 2 + 1; i <= n; ++i)
wenr += (ch[i] == '?'), RR += isdigit(ch[i]) ? ch[i] - '0' : 0;
if (wenl < wenr) swap(wenl, wenr), swap(LL, RR);
int dir = wenl - wenr;
if (dir & 1) return puts("Monocarp"), 0;
if (dir / 2 * 9 + LL == RR)
puts("Bicarp");
else
puts("Monocarp");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void re(long long &x) {
x = 0;
char ch = getchar();
int b = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') b = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
if (b == 1) x *= -1;
}
long long n, m, vx, vy, x, y;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, x, y);
long long t = x;
x = y;
y = t - a / b * y;
}
int main() {
re(n), re(m), re(x), re(y), re(vx), re(vy);
if (vx * vy == 0) {
if (x > 0 && x < n && y > 0 && y < m)
printf("-1");
else {
bool flag = 0;
if (vx == -1) {
if (y == 0) printf("0 0"), flag = 1;
if (y == m) printf("%d %d", 0, m), flag = 1;
} else if (vx == 1) {
if (y == 0) printf("%d %d", n, 0), flag = 1;
if (y == m) printf("%d %d", n, m), flag = 1;
} else if (vy == -1) {
if (x == 0) printf("0 0"), flag = 1;
if (x == n) printf("%d %d", n, 0), flag = 1;
} else if (vy == 1) {
if (x == 0) printf("%d %d", 0, m), flag = 1;
if (x == n) printf("%d %d", n, m), flag = 1;
}
if (!flag) printf("%d", -1);
}
} else {
if (vx == -1) x = n - x;
if (vy == -1) y = m - y;
long long d = gcd(n, m);
if ((x - y) % d != 0)
printf("-1");
else {
long long a = n, b = m, c = x - y;
long long p, q;
exgcd(a, b, p, q);
long long t = c / d;
long long nowb = b / d;
long long x1 = (p + nowb) * t;
if (x1 <= 0)
x1 = x1 % nowb + nowb;
else
x1 = x1 % nowb;
long long y1 = (c - a * x1) / b;
long long ansx = 0, ansy = 0;
if (x1 % 2) ansx = n;
if (y1 % 2) ansy = m;
if (vx == -1) ansx = n - ansx;
if (vy == -1) ansy = m - ansy;
printf("%lld %lld", ansx, ansy);
}
}
return 0;
}
| 5 |
#include "bits/stdc++.h"
using namespace std;
int main() {
long long N, M;
while (cin >> N >> M) {
if (N == 0 && M == 0) return 0;
vector<long long> S(N), T(M);
long long SC = 0, TC = 0;
for (int i = 0; i < N; i++) cin >> S[i], SC += S[i];
for (int i = 0; i < M; i++) cin >> T[i], TC += T[i];
sort(S.begin(), S.end()), sort(T.begin(), T.end());
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (SC - S[i] + T[j] == TC - T[j] + S[i]) {
cout << S[i] << " " << T[j] << endl;
goto next;
}
}
}
cout << -1 << endl;
next:;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m[2], a[2][7005], d[2][7005], ans[2][7005];
int main() {
scanf("%d", &n);
for (int i = 0; i < 2; i++) {
scanf("%d", &m[i]);
for (int j = 0; j < m[i]; j++) scanf("%d", &a[i][j]);
}
queue<pair<int, int>> q;
q.push(make_pair(0, 1));
ans[0][1] = 2;
q.push(make_pair(1, 1));
ans[1][1] = 2;
while (!q.empty()) {
int i = q.front().first ^ 1, p = q.front().second;
q.pop();
for (int j = 0; j < m[i]; j++) {
int t = (p - a[i][j] + n - 1) % n + 1;
if ((++d[i][t] == m[i] || ans[i ^ 1][p] == 2) && !ans[i][t]) {
ans[i][t] = ans[i ^ 1][p] ^ 3;
q.push(make_pair(i, t));
}
}
}
for (int i = 0; i < 2; i++) {
for (int j = 2; j <= n; j++)
printf(ans[i][j] ? (ans[i][j] == 1 ? "Win " : "Lose ") : "Loop ");
puts("");
}
return 0;
}
| 1 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T> >;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {return a < b && (a = b, true);}
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {return a > b && (a = b, true);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vi a(n);
rep(i, n) cin >> a[i];
int m;
cin >> m;
vi b(m);
rep(i, m) cin >> b[i];
rep(i, m) {
a.emplace_back(b[i]);
}
sort(all(a));
a.erase(unique(all(a)), a.end());
rep(i, a.size()) {
cout << a[i] << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct trie {
bool fis;
trie *next[27];
trie() {
for (int i = 0; i <= 25; i++) next[i] = 0;
fis = 0;
}
} * Trie;
Trie root = new trie, T;
map<string, int> mp;
vector<int> sfarsit, inceput;
char N[2005], Sf[2005], Inc[2005], c, viz[2005];
int S1[2005], S2[2005], n, inc, sf, k, f1, f2, nr;
string s, q, aux;
int main() {
cin >> (N + 1);
n = strlen(N + 1);
for (int i = 1; i <= n; i++) s.push_back(N[i]);
cin >> (Inc + 1);
inc = strlen(Inc + 1);
cin >> (Sf + 1);
sf = strlen(Sf + 1);
S1[0] = -1;
S1[1] = 0;
S2[0] = -1;
S2[1] = 0;
for (int i = 2; i <= inc; i++) {
k = i - 1;
c = Inc[i];
while (S1[k] != -1 && Inc[S1[k] + 1] != c) k = S1[k];
S1[i] = S1[k] + 1;
}
for (int i = 2; i <= sf; i++) {
k = i - 1;
c = Sf[i];
while (S2[k] != -1 && Sf[S2[k] + 1] != c) k = S2[k];
S2[i] = S2[k] + 1;
}
f1 = 0;
f2 = 0;
for (int i = 1; i <= n; i++) {
while (f1 && Inc[f1 + 1] != N[i]) f1 = S1[f1];
while (f2 && Sf[f2 + 1] != N[i]) f2 = S2[f2];
if (Inc[f1 + 1] == N[i]) f1++;
if (Sf[f2 + 1] == N[i]) f2++;
if (f1 == inc) {
f1 = S1[f1];
inceput.push_back(i);
}
if (f2 == sf) {
f2 = S2[f2];
viz[i] = 1;
sfarsit.push_back(i);
}
}
for (int i = 0; i < inceput.size(); i++) {
aux.clear();
T = root;
int it = inceput[i] - inc + 1;
for (int j = 0; j < inc - 1; j++) {
aux += N[it + j];
if (!T->next[N[it + j] - 'a']) T->next[N[it + j] - 'a'] = new trie;
T = T->next[N[it + j] - 'a'];
}
for (int j = it + inc - 1; j <= n; j++) {
aux += N[j];
if (!T->next[N[j] - 'a']) T->next[N[j] - 'a'] = new trie;
T = T->next[N[j] - 'a'];
if (!viz[j] || aux.size() < sf) continue;
if (!T->fis) ++nr, T->fis = 1;
}
}
cout << nr;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int V, E, P;
std::vector<std::pair<int, int>> door;
std::vector<int> edge[1005];
std::bitset<1005> visited[2];
int ind[1005][1005];
int parent[2][1005];
int rank[2][1005];
std::vector<int> locked[2][1005];
std::vector<int> vkeys[2][1005];
std::bitset<1005> keys[2][1005];
int findRoot(int crt, int node) {
if (parent[crt][node] == node) return node;
return (parent[crt][node] = findRoot(crt, parent[crt][node]));
}
void unionSets(int crt, int node1, int node2, std::queue<int>& q) {
node1 = findRoot(crt, node1);
node2 = findRoot(crt, node2);
for (int i : locked[crt][node2]) {
if (keys[crt][node1][i] == true) {
int n1 = door[i].first;
int n2 = door[i].second;
if (findRoot(crt, n2) == node2) std::swap(n1, n2);
q.push(n1);
}
}
for (int i : locked[crt][node1]) {
if (keys[crt][node2][i] == true) {
int n1 = door[i].first;
int n2 = door[i].second;
if (findRoot(crt, n2) == node1) std::swap(n1, n2);
q.push(n1);
}
}
if (rank[crt][node1] < rank[crt][node2]) std::swap(node1, node2);
if (rank[crt][node1] == rank[crt][node2]) rank[crt][node1]++;
for (int i : locked[crt][node2]) locked[crt][node1].push_back(i);
for (int i : vkeys[crt][node2]) {
vkeys[crt][node1].push_back(i);
keys[crt][node1][i] = true;
}
parent[crt][node2] = node1;
}
void traverse(int crt, int node) {
int root = node, key, newNode = true;
std::queue<int> q;
std::queue<int> check;
q.push(node);
while (q.empty() == false) {
node = q.front();
root = findRoot(crt, node);
q.pop();
visited[crt][node] = true;
for (int next : edge[node]) {
key = ind[node][next];
root = findRoot(crt, node);
if (keys[crt][root][key] == true) {
if (visited[crt][next] == false) {
visited[crt][next] = true;
q.push(next);
unionSets(crt, node, next, q);
} else if (findRoot(crt, node) != findRoot(crt, next)) {
unionSets(crt, node, next, q);
}
} else
locked[crt][findRoot(crt, node)].push_back(key);
}
}
}
void solve(int crt) {
for (int node = 1; node <= V; node++) {
rank[crt][node] = 1;
parent[crt][node] = node;
}
for (int node = 1; node <= V; node++) {
if (visited[crt][node] == false) {
traverse(crt, node);
}
}
}
std::unordered_map<std::string, int> person;
std::unordered_map<int, int> keyLocation;
void print() {
std::string s;
bool valid = true;
int crt = 1;
for (int i = 0, node, k, key; i < P; i++) {
std::cin >> s >> node >> k;
if (findRoot(0, node) != findRoot(0, person[s])) valid = false;
for (int j = 0; j < k; j++) {
std::cin >> key;
if (findRoot(0, node) != findRoot(0, keyLocation[key])) valid = false;
vkeys[crt][node].push_back(key);
keys[crt][node][key] = true;
}
}
solve(crt);
for (int i = 1; i <= V; i++) {
if (findRoot(1, findRoot(0, i)) != findRoot(1, i) or
findRoot(0, findRoot(1, i)) != findRoot(0, i))
valid = false;
}
if (valid == true)
std::cout << "YES";
else
std::cout << "NO";
}
int32_t main() {
std::cin >> V >> E >> P;
door.resize(E + 1);
for (int i = 0, src, dest; i < E; i++) {
std::cin >> src >> dest;
door[i + 1] = {src, dest};
edge[src].push_back(dest);
edge[dest].push_back(src);
ind[src][dest] = i + 1;
ind[dest][src] = i + 1;
}
std::string s;
int crt = 0;
for (int i = 0, node, k, key; i < P; i++) {
std::cin >> s >> node >> k;
person[s] = node;
for (int j = 0; j < k; j++) {
std::cin >> key;
keyLocation[key] = node;
vkeys[crt][node].push_back(key);
keys[crt][node][key] = true;
}
}
solve(crt);
print();
return 0;
}
| 6 |
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <vector>
#define X first
#define Y second
#define P first
#define S second
#define mp(x, y) make_pair(x, y)
using namespace std;
typedef ostringstream OSS;
typedef pair<int, int> PII;
typedef pair<PII, string> PIIS;
struct die_t {
int top, front, right, left, back, bottom;
die_t ( int t, int f, int r, int l, int bk, int b )
: top(t), front(f), right(r), left(l), back(bk), bottom(b) { }
die_t ( string dice ) {
top = dice[0] - '0'; front = dice[1] - '0'; right = dice[2] - '0';
left = dice[3] - '0'; back = dice[4] - '0'; bottom = dice[5] - '0';
}
void rotate_swap ( int &a, int &b, int &c, int &d ) {
swap(a, b); swap(b, c); swap(c, d);
}
void rotate_right ( void ) { rotate_swap(top,left,bottom,right); }
void rotate_left ( void ) { rotate_swap(top,right,bottom,left); }
void rotate_front ( void ) { rotate_swap(top,back,bottom,front); }
void rotate_back ( void ) { rotate_swap(top,front,bottom,back); }
void rotate_cw ( void ) { rotate_swap(back,left,front,right); }
void rotate_cc ( void ) { rotate_swap(back,right,front,left); }
bool rotate_set ( int n, int t, int f, int r, int l, int bk, int b ) {
for (int i = 0; i < 6; ++i) {
for (int j = 0; j < 4; ++j) {
if (n == equal_num(t, f, r, l, bk, b)) { return true; }
rotate_cw();
}
(i&1 ? rotate_front() : rotate_right());
}
return false;
}
int equal_num ( int t, int f, int r, int l, int bk, int b ) {
return (top==t) + (front==f) + (right==r) + (left==l) + (back==bk) + (bottom==b);
}
string toString ( void ) {
OSS os; os << top << front << right << left << back << bottom;
return os.str();
}
};
const int INF = 1 << 29;
const int MAX_WH = 10;
int main ( void )
{
vector<string> vs;
die_t dd("123456");
for (int i = 0; i < 6; ++i) {
for (int j = 0; j < 4; ++j) {
vs.push_back(dd.toString());
dd.rotate_cw();
}
if (i&1) { dd.rotate_front(); }
else { dd.rotate_right(); }
}
int h, w, mat[MAX_WH][MAX_WH];
while (cin >> h >> w, h | w) {
map<string, int> M[MAX_WH][MAX_WH];
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) {
cin >> mat[y][x];
for (int i = 0, I = vs.size(); i < I; ++i) {
M[y][x].insert(mp(vs[i], INF));
}
}
}
PII s, g;
cin >> s.Y >> s.X;
cin >> g.Y >> g.X;
die_t dice("123456");
queue<PIIS> Q;
M[s.Y][s.X]["123456"] = 0;
Q.push(mp(mp(s.X, s.Y), dice.toString()));
while (!Q.empty()) {
PIIS piis = Q.front(); Q.pop();
PII p = piis.P;
string s = piis.S, s1, s2, s3, s4;
die_t d1(s), d2(s), d3(s), d4(s);
d1.rotate_right(); s1 = d1.toString();
d2.rotate_left(); s2 = d2.toString();
d3.rotate_front(); s3 = d3.toString();
d4.rotate_back(); s4 = d4.toString();
int now = M[p.Y][p.X][s];
if (p.X + 1 < w
&& M[p.Y][p.X+1][s1] > now + mat[p.Y][p.X+1] * d1.bottom) {
M[p.Y][p.X+1][s1] = now + mat[p.Y][p.X+1] * d1.bottom;
Q.push(mp(mp(p.X+1, p.Y), s1));
}
if (p.X - 1 >=0
&& M[p.Y][p.X-1][s2] > now + mat[p.Y][p.X-1] * d2.bottom) {
M[p.Y][p.X-1][s2] = now + mat[p.Y][p.X-1] * d2.bottom;
Q.push(mp(mp(p.X-1, p.Y), s2));
}
if (p.Y + 1 < h
&& M[p.Y+1][p.X][s3] > now + mat[p.Y+1][p.X] * d3.bottom) {
M[p.Y+1][p.X][s3] = now + mat[p.Y+1][p.X] * d3.bottom;
Q.push(mp(mp(p.X, p.Y+1), s3));
}
if (p.Y - 1 >=0
&& M[p.Y-1][p.X][s4] > now + mat[p.Y-1][p.X] * d4.bottom) {
M[p.Y-1][p.X][s4] = now + mat[p.Y-1][p.X] * d4.bottom;
Q.push(mp(mp(p.X, p.Y-1), s4));
}
}
int ans = INF;
for (int i = 0, I = vs.size(); i < I; ++i) {
ans = min(ans, M[g.Y][g.X][vs[i]]);
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e5 + 10;
const int Inf = 0x7f7f7f7f;
const long long Inf_ll = 1ll * Inf * Inf;
const int Mod = 1e9 + 7;
const double eps = 1e-7;
long long ans = 0;
int n, k, a[Maxn];
priority_queue<pair<long long, pair<int, int>>> q;
pair<pair<int, int>, pair<int, int>> Div(int x, int m) {
if (m >= x) return make_pair(make_pair(1, x), make_pair(0, 0));
pair<int, int> a, b;
a.first = x / m;
b.first = x / m + 1;
b.second = x - m * a.first;
a.second = (x - b.first * b.second) / a.first;
return make_pair(a, b);
}
long long calc(pair<pair<int, int>, pair<int, int>> pp) {
pair<int, int> p1 = pp.first, p2 = pp.second;
return 1ll * p1.first * p1.first * p1.second +
1ll * p2.first * p2.first * p2.second;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ans += 1ll * a[i] * a[i];
pair<pair<int, int>, pair<int, int>> pp = Div(a[i], 2);
long long tmp = calc(pp);
q.push(make_pair(1ll * a[i] * a[i] - tmp, make_pair(a[i], 1)));
}
for (int i = n + 1; i <= k; i++) {
if (q.empty()) break;
pair<long long, pair<int, int>> plp = q.top();
q.pop();
ans -= plp.first;
pair<int, int> p = plp.second;
long long Now = calc(Div(p.first, p.second + 1)),
New = calc(Div(p.first, p.second + 2));
q.push(make_pair(Now - New, make_pair(p.first, p.second + 1)));
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int MAXN = 100005;
string a, b, c;
int cntA[128], cntB[128], cntC[128];
void count(string &s, int cnt[128]) {
for (int i = 0; i < 128; i++) {
cnt[i] = 0;
}
for (size_t i = 0; i < s.size(); i++) {
cnt[(int)s[i]]++;
}
}
void solve() {
count(a, cntA);
count(b, cntB);
count(c, cntC);
int memB = 0, memC = 0;
bool good = true;
for (int numB = 0; numB <= (int)(a.size() / b.size()) && good; numB++) {
int numC = MAXN;
for (int x = 'a'; x <= 'z'; x++) {
int numX = cntB[x] * numB;
if (numX > cntA[x]) {
good = false;
break;
}
if (cntC[x]) {
numC = min(numC, (cntA[x] - numX) / cntC[x]);
}
}
if (good && numB + numC > memB + memC) {
memB = numB;
memC = numC;
}
}
for (int x = 'a'; x <= 'z'; x++) {
cntA[x] -= memB * cntB[x] + memC * cntC[x];
}
for (int i = 0; i < memB; i++) {
cout << b;
}
for (int i = 0; i < memC; i++) {
cout << c;
}
for (int x = 'a'; x <= 'z'; x++) {
for (int i = 0; i < cntA[x]; i++) {
cout << char(x);
}
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
while (cin >> a >> b >> c) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int maxn = 1010;
int n;
LL x[maxn],y[maxn],u[maxn],v[maxn],bs[35];
void work(){
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
int sum = (x[0] ^ y[0]) & 1;
for (int i = 0; i < n; i++) if ( ((x[i] ^ y[i]) & 1 ) ^ sum) {cout<<"-1"<<endl;return;}
if (sum == 0) {
cout << 32 << endl;
for (int i = 30; i > -1; i--) cout<<bs[i]<<" ";
cout << 1 << endl;
for (int i = 0; i < n; i++) x[i]++;
}else {
cout << 31 << endl;
for (int i = 30; i > -1; i--) cout<<bs[i]<<" ";
cout << endl;
}
for (int i = 0; i < n; i++) u[i] = x[i] + y[i], v[i] = x[i] - y[i];
for (int i = 0; i < n; i++) {
for (int j = 30; j > -1; j--) {
if (u[i] > 0 && v[i] > 0) {cout << 'R'; u[i] -= bs[j]; v[i] -= bs[j];}//x[i] > y[i] & x[i] > 0
else if (u[i] > 0 && v[i] < 0) {cout << 'U'; u[i] -= bs[j]; v[i] += bs[j];}//y[i] > x[i] & y[i] > 0
else if (u[i] < 0 && v[i] > 0) {cout << 'D'; u[i] += bs[j]; v[i] -= bs[j];}//x[i] > y[i] && y[i] < 0
else {cout << 'L'; u[i] += bs[j]; v[i] += bs[j];}//x[i] < y[i] & x[i] < 0;
}
if (sum == 0) cout << 'L';
cout << endl;
}
}
int main(){
bs[0] = 1;
for (int i=1;i<32;i++) bs[i] = bs[i-1] << 1;
work();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[26][26];
char s[200005];
char t[200005];
int main() {
int n;
scanf("%d", &n);
;
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++) arr[i][j] = -1;
scanf("%s", s);
;
scanf("%s", t);
;
int mans = 0;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
mans++;
if (arr[t[i] - 'a'][s[i] - 'a'] == -1) {
arr[t[i] - 'a'][s[i] - 'a'] = i;
}
}
}
int indexi = -1;
int indexj = -1;
long long ans = mans;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
if (arr[s[i] - 'a'][t[i] - 'a'] != -1) {
ans = mans - 2;
indexi = i;
indexj = arr[s[i] - 'a'][t[i] - 'a'];
} else {
for (int j = 0; j < 26; j++) {
if (arr[s[i] - 'a'][j] != -1) {
if (mans - 1 < ans) {
ans = mans - 1;
indexi = i;
indexj = arr[s[i] - 'a'][j];
}
}
}
}
}
}
printf("%d\n", ans);
;
if (indexi != -1 && indexj != -1)
printf("%d %d\n", indexi + 1, indexj + 1);
else {
printf("%d %d\n", indexi, indexj);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k, a[N];
void read_input() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
}
void solve() {
a[0] = 1;
sort(a, a + n + 1);
a[n + 1] = a[n];
if (a[k] == a[k + 1] && k < n || k == 0 && a[1] == 1)
cout << -1;
else
cout << a[k];
}
void write_output() {}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
read_input(), solve(), write_output();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> shoes;
bool marca[5];
int s1, s2, s3, s4;
int cont = 0;
scanf("%d %d %d %d", &s1, &s2, &s3, &s4);
memset(marca, false, sizeof(marca));
shoes.push_back(s1);
shoes.push_back(s2);
shoes.push_back(s3);
shoes.push_back(s4);
for (int i = 0; i < 3; i++) {
if (marca[i]) continue;
marca[i] = true;
for (int j = i + 1; j < 4; j++) {
if (shoes[i] == shoes[j] && !marca[j]) {
marca[j] = true;
cont++;
}
}
}
printf("%d\n", cont);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string str;
cin >> n >> str;
unordered_map<char, int> mp;
for (auto& a : str) mp[::tolower(a)]++;
if (mp.size() == 26)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
int main() {
char a[107], b[107];
scanf("%s %s", a, b);
if (!strcmp(a, b))
printf("%s\n", a);
else
printf("1\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> dp[100002];
void Formd() {
int i, j, k, l;
for (i = 1; i <= 100000; i++) {
k = trunc(sqrt(i));
dp[i].push_back(0);
for (j = 1; j <= k; j++)
if (i % j == 0) dp[i].push_back(j);
l = dp[i].size() - 1;
for (j = l; j >= 1; j--)
if (i / dp[i][j] != dp[i][j]) dp[i].push_back(i / dp[i][j]);
}
}
void Show(int k) {
cout << k << ":: ";
for (int i = 1; i < dp[k].size(); i++) cout << dp[k][i] << " ";
cout << endl;
}
int main() {
int A, B, C;
int t;
Formd();
cin >> t;
for (; t; t--) {
cin >> A >> B >> C;
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
int i, j;
int ai = 1, bi = 1, ci = 1;
int k;
while (true) {
if (ai > dp[A].size() - 1) break;
if (bi > dp[B].size() - 1) break;
if (ci > dp[C].size() - 1) break;
k = min(dp[A][ai], min(dp[B][bi], dp[C][ci]));
if ((dp[A][ai] == dp[B][bi]) && (dp[A][ai] == dp[C][ci]) &&
(dp[A][ai] == k)) {
g++;
ai++;
bi++;
ci++;
} else if ((dp[A][ai] == dp[B][bi]) && (dp[A][ai] == k)) {
e++;
ai++;
bi++;
} else if ((dp[A][ai] == dp[C][ci]) && (dp[A][ai] == k)) {
d++;
ai++;
ci++;
} else if ((dp[C][ci] == dp[B][bi]) && (dp[C][ci] == k)) {
f++;
ci++;
bi++;
} else {
if (k == dp[A][ai]) {
a++;
ai++;
} else if (k == dp[B][bi]) {
b++;
bi++;
} else if (k == dp[C][ci]) {
c++;
ci++;
}
}
}
while (true) {
if (ai > dp[A].size() - 1) break;
if (bi > dp[B].size() - 1) break;
if (dp[A][ai] == dp[B][bi]) {
e++;
ai++;
bi++;
} else {
k = min(dp[A][ai], dp[B][bi]);
if (k == dp[A][ai]) {
a++;
ai++;
} else if (k == dp[B][bi]) {
b++;
bi++;
}
}
}
while (true) {
if (ai > dp[A].size() - 1) break;
if (ci > dp[C].size() - 1) break;
if (dp[A][ai] == dp[C][ci]) {
d++;
ai++;
ci++;
} else {
k = min(dp[A][ai], dp[C][ci]);
if (k == dp[A][ai]) {
a++;
ai++;
} else if (k == dp[C][ci]) {
c++;
ci++;
}
}
}
while (true) {
if (ci > dp[C].size() - 1) break;
if (bi > dp[B].size() - 1) break;
if (dp[C][ci] == dp[B][bi]) {
f++;
ci++;
bi++;
} else {
k = min(dp[C][ci], dp[B][bi]);
if (k == dp[C][ci]) {
c++;
ci++;
} else if (k == dp[B][bi]) {
b++;
bi++;
}
}
}
while (true) {
if (ai > dp[A].size() - 1) break;
a++;
ai++;
}
while (true) {
if (bi > dp[B].size() - 1) break;
b++;
bi++;
}
while (true) {
if (ci > dp[C].size() - 1) break;
c++;
ci++;
}
int res = 0;
res += a * b * c;
res += a * b * d;
res += a * b * f;
res += a * b * g;
res += a * c * e;
res += a * c * f;
res += a * c * g;
res += a * d * e;
res += a * d * f;
res += a * d * g;
res += a * e * f;
res += a * e * g;
res += a * f * g;
res += b * c * d;
res += b * c * e;
res += b * c * g;
res += b * d * e;
res += b * d * f;
res += b * d * g;
res += b * e * f;
res += b * e * g;
res += b * f * g;
res += c * d * e;
res += c * d * f;
res += c * d * g;
res += c * e * f;
res += c * e * g;
res += c * f * g;
res += d * e * f;
res += d * e * g;
res += d * f * g;
res += e * f * g;
res += (e * (e - 1) / 2 + e) * (d + g + f + c) +
(d * (d - 1) / 2 + d) * (b + e + g + f) +
(f * (f - 1) / 2 + f) * (a + e + d + g);
res += (g * (g - 1) / 2 + g) * (a + b + c + d + e + f);
res += g * (g + 1) * (g + 2) / 6;
cout << res << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, l[110], r[110], p1, p2, p3, t1, t2, ans = 0, td = 0, f = 0;
cin >> n >> p1 >> p2 >> p3 >> t1 >> t2;
for (long long int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
ans += (r[i] - l[i]) * p1;
if (i > 0) {
td = l[i] - r[i - 1];
ans += min(td, t1) * p1;
f = 0;
if (td > t1) {
f = 1;
td -= t1;
ans += min(td, t2) * p2;
}
if (td > t2 && f == 1) {
td -= t2;
ans += td * p3;
}
}
cout << endl;
}
cout << ans << endl;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.