solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include<bits/stdc++.h>
using namespace std;
int main(){
int t,n,m;
cin>>t;
while(t--){
cin>>n;
int r[n],max1=0,max2=0;
for(int i=0 ; i<n; i++){
cin>>r[i];
if(r[i]>0){
if(max2+r[i]>=max1){
max1=max2+r[i];
max2=max1 ;
}
else{
max2+=r[i];
}
}
else{
max2+=r[i];
}
}
cin>>m;
int b[m],max3=0,max4=0;
for(int i=0 ; i<m; i++){
cin>>b[i];
if(b[i]>0){
if(max4+b[i]>=max3){
max3=max4+b[i];
max4=max3;
}
else{
max4+=b[i];
}
}
else{
max4+=b[i];
}
}
//cout<<max1<<" "<<max3<<" ";
cout<<max1+max3<<endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 12345678910;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, -1, 1, 0}, dy[] = {1, 0, 0, -1};
int ddx[] = {0, 0, 1, 1, 1, -1, -1, -1}, ddy[] = {1, -1, 1, 0, -1, 1, 0, -1};
struct Edge {
int to, r, c, idx;
Edge *ori;
Edge *rev;
Edge(int T, int R, int C, int I) { to = T, r = R, c = C, idx = I; }
};
vector<Edge *> v[4002];
void addedge(int f, int t, int r, int c, int i) {
Edge *ori = new Edge(t, r, c, i);
Edge *rev = new Edge(f, 0, -c, i);
ori->rev = rev;
rev->rev = ori;
v[f].push_back(ori);
v[t].push_back(rev);
}
const int S = 4000, T = 4001;
int level[4002], work[4002];
bool bfs() {
memset(level, -1, sizeof(level));
;
level[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto &nn : v[x]) {
int next = nn->to;
if (level[next] == -1 && nn->r > 0) {
level[next] = level[x] + 1;
q.push(next);
}
}
}
return level[T] != -1;
}
int dfs(int N, int des, int flow) {
if (N == des) return flow;
for (int &i = work[N]; i < v[N].size(); i++) {
int next = v[N][i]->to;
if (level[next] == level[N] + 1 && v[N][i]->r > 0) {
int df = dfs(next, des, min(v[N][i]->r, flow));
if (df > 0) {
v[N][i]->r -= df;
v[N][i]->rev->r += df;
return df;
}
}
}
return 0;
}
pair<int, int> edge[2001];
int cnt[4000], c[4000];
bool chk[2001];
int main() {
int n1, n2, m;
scanf("%d%d%d", &n1, &n2, &m);
for (int(i) = (0); (i) <= (n1 - 1); (i) += (1)) addedge(S, i, 0, 0, -1);
for (int(i) = (n1); (i) <= (n1 + n2 - 1); (i) += (1)) addedge(i, T, 0, 0, -1);
for (int(i) = (1); (i) <= (m); (i) += (1)) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
edge[i] = make_pair(x, n1 + y);
addedge(x, n1 + y, 1, 0, i);
cnt[x]++;
cnt[n1 + y]++;
}
int K = *min_element(cnt, cnt + n1 + n2);
puts("0");
for (int(k) = (1); (k) <= (K); (k) += (1)) {
for (auto &E : v[S]) E->r++;
for (auto &E : v[T]) E->rev->r++;
memset(c, 0, sizeof(c));
;
memset(chk, 0, sizeof(chk));
;
while (bfs()) {
memset(work, 0, sizeof(work));
;
while (1) {
int f = dfs(S, T, 987654321);
if (f == 0) break;
}
}
vector<int> ans;
for (int(i) = (0); (i) <= (n1 - 1); (i) += (1)) {
for (auto &E : v[i]) {
if (E->to != S && E->r == 0) {
ans.push_back(E->idx);
chk[E->idx] = 1;
c[i]++, c[E->to]++;
}
}
}
for (int(i) = (0); (i) <= (n1 + n2 - 1); (i) += (1)) {
if (c[i] >= k) continue;
for (auto &E : v[i]) {
if (chk[E->idx]) continue;
if (E->to != S && E->to != T) {
ans.push_back(E->idx);
chk[E->idx] = 1;
c[i]++;
if (c[i] == k) break;
}
}
}
printf("%d ", ans.size());
for (int x : ans) printf("%d ", x);
puts("");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int inf = (int)1e7;
const int base = 10;
const int maxn = 700000;
const long double pi = acosl(-1.0);
const long double eps = 1e-9;
void error(void) { exit(1); }
int main() {
int n, val;
scanf("%d", &n);
vector<int> a(n + 1);
vector<int> pos(n + 1, -1);
vector<int> cur(n + 1, -1);
for (int i = 1; i < n + 1; i++) {
scanf("%d", &a[i]);
cur[a[i]] = i;
}
for (int i = 1; i < n + 1; i++) {
scanf("%d", &val);
pos[val] = i;
}
vector<pair<int, int> > ans;
bool ok = false;
while (!ok) {
ok = true;
int t = n;
for (int i = t; i >= 1; i--) {
if (i != pos[a[i]]) {
ok = false;
int cr = pos[a[i]];
bool f = true;
for (int j = i; j >= cr && f; j--) {
if (j != pos[a[j]] && pos[a[j]] >= i) {
f = false;
ans.push_back(make_pair(i, j));
swap(a[i], a[j]);
}
}
if (!f) break;
} else {
t--;
if (ok) n--;
}
}
}
long long res = 0;
for (int i = 0; i < (int)ans.size(); i++)
res += (1LL * abs(ans[i].first - ans[i].second));
printf("%I64d\n%d\n", res, (int)ans.size());
for (int i = 0; i < (int)ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c, max, count = 0;
cin >> r >> c;
char a[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> a[i][j];
if (a[i][j] == '.') count++;
}
if (count == c) {
for (int j = 0; j < c; j++) a[i][j] = 'X';
}
count = 0;
}
for (int i = 0; i < c; i++) {
for (int j = 0; j < r; j++) {
if (a[j][i] == '.' || a[j][i] == 'X') count++;
}
if (count == r) {
for (int j = 0; j < r; j++) a[j][i] = 'X';
}
count = 0;
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (a[i][j] == 'X') count++;
}
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace mine {
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3fll;
long long qread() {
long long ans = 0;
char c = getchar();
int f = 1;
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) {
num = -num;
putchar('-');
}
if (num > 9) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
puts("");
}
void chmax(int &x, const int y) { x = x > y ? x : y; }
void chmin(int &x, const int y) { x = x < y ? x : y; }
const int MAX_N = 1e6 + 10;
const long long MOD = 1e9 + 7;
void add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
if (x < 0) x += MOD;
}
long long qpower(long long x, long long e) {
long long ans = 1;
while (e) {
if (e & 1) ans = ans * x % MOD;
x = x * x % MOD;
e >>= 1;
}
return ans;
}
long long inv(long long x) { return qpower(x, MOD - 2); }
int m, n, st;
pair<int, int> mx;
int f[MAX_N][2], a[MAX_N];
void dp(int T, int op) {
for (int i = st + 1 + op; i <= st + n - 1; i++) {
if (f[i - 1][0] >= a[i] - T) chmax(f[i][0], a[i] + 1);
if (f[i - 1][1] >= a[i] - T)
chmax(f[i][0], max(a[i - 1] + T + 1, a[i] + 1));
int tmp = max(f[i - 1][0], f[i - 1][1]);
if (tmp >= a[i]) chmax(f[i][1], a[i] + T + 1);
chmax(f[i][0], tmp);
chmax(f[i][1], tmp);
}
}
bool check(int T) {
int st = mx.second;
{
memset(f, -0x3f, sizeof f);
f[st][0] = a[st] + 1;
dp(T, 0);
if (max(f[st + n - 1][0], f[st + n - 1][1]) >= a[st] + m - T) return 1;
}
if (a[st] + T + 1 >= a[st + 1]) {
memset(f, -0x3f, sizeof f);
f[st + 1][0] = max(a[st] + T + 1, a[st + 1] + 1);
dp(T, 1);
if (max(f[st + n - 1][0], f[st + n - 1][1]) >= a[st + 1] + m - T) return 1;
}
return 0;
}
void main() {
m = qread(), n = qread();
for (int i = 1; i <= n; i++) a[i] = qread();
mx = make_pair(a[1] - 1 + m - a[n] + 1, 1);
for (int i = 2; i <= n; i++) mx = max(mx, make_pair(a[i] - a[i - 1], i));
st = mx.second;
for (int i = 1; i <= n; i++) a[n + i] = a[i] + m;
int l = 0, r = mx.first - 1, ans = mx.first;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
write(ans);
}
}; // namespace mine
signed main() {
srand(time(0));
mine::main();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 1;
cin >> n;
for (int i = 2; i <= n; i++) ans = (ans * 3) % 1000003;
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int t;
cin >> t;
while (t--) {
string key;
cin >> key;
string s;
cin >> s;
int ans = 0;
for (int i = 1; i < s.length(); i++) {
int r = (int)(key.find(s[i]) - key.find(s[i - 1]));
ans += abs(r);
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
struct node {
double x, y, r;
};
double x0, yy0, v, t;
node a[100050];
struct qj {
double l, r;
};
qj b[100050];
int cnt;
void did(int i) {
double r1 = a[i].r;
double r2 = v * t;
double r3 =
sqrt((a[i].x - x0) * (a[i].x - x0) + (a[i].y - yy0) * (a[i].y - yy0));
double qw = sqrt(r3 * r3 - r1 * r1);
if (r2 > qw) r2 = qw;
if (r1 + r2 <= r3) return;
double cosc = (r2 * r2 + r3 * r3 - r1 * r1) / (2 * r2 * r3);
double jd = acos(cosc);
double xj = atan2(a[i].y - yy0, a[i].x - x0);
b[++cnt].l = xj - jd;
b[cnt].r = xj + jd;
}
void gz() {
int res = cnt;
for (int i = 1; i <= cnt; i++) {
if (b[i].l < (-pi)) {
double xl = b[i].l + pi;
xl += pi;
double xr = pi;
b[++res].l = xl;
b[res].r = xr;
b[i].l = (-pi);
} else if (b[i].r > pi) {
double xr = b[i].r - pi;
xr -= pi;
double xl = -pi;
b[++res].r = xr;
b[res].l = xl;
b[i].r = pi;
}
}
cnt = res;
}
double cmp(qj a, qj b) {
if (a.l == b.l) return a.r > b.r;
return a.l < b.l;
}
double hb() {
double res = 0;
double l, r;
for (int i = 1; i <= cnt; i++) {
if (i == 1) {
l = b[i].l;
r = b[i].r;
res += (r - l);
} else {
if (b[i].l >= r) {
l = b[i].l;
r = b[i].r;
res += (r - l);
} else if (b[i].l < r && b[i].r > r) {
res += (b[i].r - r);
r = b[i].r;
} else if (b[i].r <= r)
continue;
}
}
return res / (2 * pi);
}
int main() {
scanf("%lf%lf%lf%lf", &x0, &yy0, &v, &t);
int n;
scanf("%d", &n);
bool ok = false;
for (int i = 1; i <= n; i++) {
scanf("%lf%lf%lf", &a[i].x, &a[i].y, &a[i].r);
if ((a[i].x - x0) * (a[i].x - x0) + (a[i].y - yy0) * (a[i].y - yy0) <=
a[i].r * a[i].r) {
ok = true;
}
}
if (ok) {
printf("1.00000000000\n");
return 0;
}
cnt = 0;
for (int i = 1; i <= n; i++) {
did(i);
}
gz();
sort(b + 1, b + 1 + cnt, cmp);
double ans = hb();
printf("%.11f\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
double a[200010], l, r, ml, mr;
void nhap() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
}
double func(double x) {
double ma = 0, mi = 0, sum = 0;
for (int i = 1; i <= n; ++i) {
sum += a[i] - x;
ma = max(ma, sum);
mi = min(mi, sum);
}
return abs(ma - mi);
}
int main() {
nhap();
l = -20000, r = 20000;
for (int i = 1; i <= 100; ++i) {
ml = (l + l + r) / 3;
mr = (r + r + l) / 3;
if (func(ml) > func(mr))
l = ml;
else
r = mr;
}
printf("%.10f", func(l));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
struct nd {
int a, b, w, is;
bool operator<(const nd &r) const { return w < r.w; }
} g[10005];
int C[10005];
int spa(int M, int N) {
int S = 0, W = N - 1;
sort(g, g + M);
for (int i(0); i < M && W; i++)
if (!C[g[i].b]) S += g[i].w, C[g[i].b] = 1, --W;
return W ? -1 : S;
}
int N, M, A[10005], a, b, c;
int main(void) {
scanf("%d", &N), ga(N, A);
scanf("%d", &M);
for (int i(0); i < M; i++)
scanf("%d%d%d", &a, &b, &c), g[i] = {--a, --b, c, 0};
printf("%d\n", spa(M, N));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c, d;
while (1) {
n++;
a = n % 10;
b = (n / 10) % 10;
c = (n / 100) % 10;
d = (n / 1000) % 10;
if (a != b && a != c && a != d && b != c && b != d && c != d) break;
}
cout << n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int p[] = {0, 1, 2};
int main() {
int n;
cin >> n;
int input[n][6];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 6; j++) {
cin >> input[i][j];
}
}
int max = 0;
while (true) {
bool res = false;
sort(p, p + 3);
while (true) {
for (int i = 0; i < pow(6, n); i++) {
int digits[n];
string generated = "";
for (int j = 0; j < n; j++) {
digits[j] = (int)round(i / (int)pow(6, j)) % 6;
digits[j] = input[p[j]][digits[j]];
generated += to_string(digits[j]);
}
if (generated.find(to_string(max + 1)) != string::npos) {
res = true;
break;
}
}
if (!next_permutation(p, p + n)) break;
}
if (!res) {
break;
} else {
max++;
}
}
cout << max << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct line {
int k;
long long b;
line() : k(0), b(0) {}
line(int k, long long b) : k(k), b(b) {}
long long get(long long x) const { return k * x + b; }
};
pair<long long, int> get_intersection(const line &l1, const line &l2) {
return {l1.b - l2.b, l2.k - l1.k};
}
bool cmp(const pair<long long, int> &a, const pair<long long, int> &b) {
return 1LL * a.first * b.second < 1LL * b.first * a.second;
}
struct line_container {
vector<line> v;
void add(const line &l) {
while (!v.empty()) {
if (v.back().k == l.k) {
if (l.b >= v.back().b) {
return;
}
v.pop_back();
continue;
}
if (v.size() == 1) {
break;
}
if (cmp(get_intersection(v[v.size() - 2], l),
get_intersection(v[v.size() - 2], v.back()))) {
v.pop_back();
} else {
break;
}
}
v.push_back(l);
}
long long get_min(long long x) {
int l = 0, r = v.size();
while (r - l > 1) {
int mid = (l + r) / 2;
long long v1 = v[mid - 1].get(x);
long long v2 = v[mid].get(x);
if (v1 > v2) {
l = mid;
} else {
r = mid;
}
}
return v[l].get(x);
}
};
const int max_n = 100111;
const long long inf = 1000111222000111222LL;
int n, c, d;
int t[max_n], tp[max_n], p[max_n];
long long cnt[2][max_n], sum[2][max_n], dp[max_n], val[max_n], val2[max_n],
mn[2];
line_container l[2];
void get_all_p() {
const int mxt = d / c;
int pos = n;
for (int i = n; i >= 0; --i) {
while (pos > 0 && t[i] - t[pos - 1] <= mxt) {
--pos;
}
p[i] = pos;
}
}
void upd(int j) {
val[j] = dp[j] + 1LL * c * t[j] + 1LL * d * cnt[tp[j]][j - 1];
val[j] += 1LL * d * cnt[tp[j] ^ 1][p[j] - 1];
val[j] += 1LL * c *
(1LL * t[j] * (cnt[tp[j] ^ 1][j - 1] - cnt[tp[j] ^ 1][p[j] - 1]) -
(sum[tp[j] ^ 1][j - 1] - sum[tp[j] ^ 1][p[j] - 1]));
val2[j] = dp[j] + 1LL * c * t[j] + 1LL * d * cnt[tp[j]][j - 1];
val2[j] +=
1LL * c * (1LL * t[j] * cnt[tp[j] ^ 1][j - 1] - sum[tp[j] ^ 1][j - 1]);
l[tp[j]].add({t[j], val2[j]});
}
int main() {
scanf("%d%d%d", &n, &c, &d);
for (int i = 1; i <= n; ++i) {
char ctp;
scanf("%d %c", &t[i], &ctp);
tp[i] = (ctp == 'W');
}
t[0] = -1000111222;
++n;
scanf("%d", &t[n]);
++n;
t[n] = t[n - 1];
tp[n] = 1;
for (int i = 1; i <= n; ++i) {
cnt[tp[i]][i] = 1;
sum[tp[i]][i] = t[i];
sum[0][i] += sum[0][i - 1];
cnt[0][i] += cnt[0][i - 1];
sum[1][i] += sum[1][i - 1];
cnt[1][i] += cnt[1][i - 1];
}
get_all_p();
mn[0] = mn[1] = inf;
upd(n);
upd(n - 1);
int pos = n;
for (int i = n - 2; i >= 1; --i) {
long long y =
-1LL * c * t[i] - 1LL * d * cnt[tp[i] ^ 1][i] - 1LL * d * cnt[tp[i]][i];
long long y2 = y + 1LL * d * cnt[tp[i]][i] + 1LL * c * sum[tp[i]][i];
while (p[pos] >= i + 1) {
mn[tp[pos]] = min(mn[tp[pos]], val[pos]);
--pos;
}
dp[i] = mn[tp[i] ^ 1] + y;
long long x = l[tp[i] ^ 1].get_min(-1LL * c * cnt[tp[i]][i]);
dp[i] = min(dp[i], x + y2);
upd(i);
}
long long ans = inf;
for (int i = 1; i <= n; ++i) {
ans = min(ans, 1LL * (i - 1) * d + dp[i]);
}
printf("%I64d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
char s1[101];
char s2[101];
scanf("%s", &s1);
scanf("%s", &s2);
bool x = 0;
int i;
int j;
for (i = 0; s1[i] != '\0'; i++) {
}
int n1 = i;
for (j = 0; s2[j] != '\0'; j++) {
}
int n2 = j;
if (n1 == n2) {
for (i = 0; s1[i] != '\0'; i++) {
if (s1[i] != s2[n2 - i - 1]) {
x = 1;
}
}
} else if (n1 != n2) {
x = 1;
}
if (x == 1) {
printf("NO");
} else
printf("YES");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool am[3005][3005];
vector<int> adj[3005];
int main() {
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
am[u][v] = 1;
}
long long tot = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
long long cur = 0;
for (int nx : adj[i]) {
if (am[nx][j]) cur++;
}
tot += cur * (cur - 1) / 2;
}
}
cout << tot << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long current = 0;
long long answer = 0;
while (n >= current * 10 + 9) {
current = current * 10 + 9;
answer += 9;
}
n = n - current;
while (n) {
answer += n % 10;
n /= 10;
}
cout << answer << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
~debug() { cerr << endl; }
template <class c>
typename enable_if<sizeof dud<c>(0) != 1, debug&>::type operator<<(c i) {
cerr << boolalpha << i;
return *this;
}
template <class c>
typename enable_if<sizeof dud<c>(0) == 1, debug&>::type operator<<(c i) {
return *this << range(begin(i), end(i));
}
template <class c, class b>
debug& operator<<(pair<b, c> d) {
return *this << "(" << d.first << ", " << d.second << ")";
}
template <class c>
debug& operator<<(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it;
return *this << "]";
}
};
using ll = long long int;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using mii = map<int, int>;
using pii = pair<int, int>;
const int inf = 1e9;
const int N = 100005;
const ld eps = 1e-9;
const ll mod = (ll)1e9 + 7;
const ll mod2 = (ll)998244353;
struct fenwick {
int n;
vector<ll> BIT;
void init(int sz) {
n = sz + 1;
BIT.resize(n + 1, 0);
}
ll query(int pos) {
ll sum = 0;
for (; pos > 0; pos -= pos & -pos) sum += BIT[pos];
return sum;
}
void update(int pos, int val) {
for (; pos <= n; pos += pos & -pos) BIT[pos] += val * 1LL;
}
};
void test() {
int n, m;
cin >> n >> m;
vi b(n), g(m);
for (int i = 0; i < n; i++) cin >> b[i];
for (int j = 0; j < m; j++) cin >> g[j];
int64_t sumB = accumulate(begin(b), end(b), int64_t(0));
int64_t sumG = accumulate(begin(g), end(g), int64_t(0));
sort(begin(b), end(b));
sort(begin(g), end(g));
int64_t mxB = b[n - 1], mx2B = b[n - 2], mnG = g[0];
if (mxB > mnG) {
cout << -1 << '\n';
} else if (mxB == mnG) {
int64_t ans = sumB * m + sumG - mxB * m;
cout << ans << '\n';
} else {
int64_t ans = sumB * m + sumG - mxB * (m - 1) - mx2B;
cout << ans << '\n';
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int tt = 1;
while (tt--) {
test();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast,no-stack-protector")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
template <typename T>
vector<T> &operator<<(vector<T> &__container, T x) {
__container.push_back(x);
return __container;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &__container) {
for (T _ : __container) out << _ << ' ';
return out;
}
void sci() {}
template <typename... Args>
void sci(int &x, Args &...args) {
scanf("%d", &x);
sci(args...);
}
void scl() {}
template <typename... Args>
void scl(long long int &x, Args &...args) {
scanf("%lld", &x);
scl(args...);
}
const int MAXN = 2e5 + 7;
int n, m, deg[MAXN];
struct Graph {
int head[MAXN], to[MAXN << 2], nxt[MAXN << 2], tot;
Graph() {
memset(head, 255, sizeof(head));
tot = 0;
}
void addEdge(int u, int v) {
to[tot] = v;
nxt[tot] = head[u];
head[u] = tot++;
}
} G;
int tag[MAXN];
bool vis[MAXN << 2];
vector<pair<int, int> > edge;
void euler(int u) {
int curtime = ++tag[u];
for (int i = G.head[u]; ~i; i = G.nxt[i]) {
if (vis[i]) continue;
vis[i] = vis[i ^ 1] = true;
G.head[u] = G.nxt[i];
euler(G.to[i]);
edge.push_back(make_pair(u, G.to[i]));
if (tag[u] != curtime) break;
}
}
void solve() {
sci(n, m);
for (int i = 1; i <= m; i++) {
int u, v;
sci(u, v);
G.addEdge(u, v);
G.addEdge(v, u);
deg[u]++;
deg[v]++;
}
vector<int> oddnode;
for (int i = 1; i <= n; i++)
if (deg[i] & 1) oddnode.push_back(i);
for (int i = 0; i < (int)oddnode.size(); i += 2) {
G.addEdge(oddnode[i], oddnode[i + 1]),
G.addEdge(oddnode[i + 1], oddnode[i]);
deg[oddnode[i]]++;
deg[oddnode[i + 1]]++;
m++;
}
if (m & 1) G.addEdge(1, 1), G.addEdge(1, 1);
euler(1);
for (int i = 0; i < (int)edge.size(); i++)
if (i & 1) swap(edge[i].first, edge[i].second);
cout << edge.size() << "\n";
for (auto &e : edge) cout << e.first << ' ' << e.second << "\n";
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> town(n);
for (int i = 0; i < n; ++i) {
cin >> town[i];
}
int start_x = -1, start_y = -1;
int dest_x = -1, dest_y = -1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (town[i][j] == 'S') {
start_x = i;
start_y = j;
}
if (town[i][j] == 'T') {
dest_x = i;
dest_y = j;
}
}
}
vector<pair<int, int>> shifts = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
vector<vector<vector<int>>> dist(n);
for (int i = 0; i < n; ++i) {
dist[i] = vector<vector<int>>(m);
for (int j = 0; j < m; ++j) {
dist[i][j] = vector<int>(shifts.size(), 3);
}
}
set<tuple<int, int, int, int>> positions;
for (int i = 0; i < 4; ++i) {
positions.insert(make_tuple(0, i, start_x, start_y));
}
while (!positions.empty()) {
tuple<int, int, int, int> position = *positions.begin();
positions.erase(positions.begin());
int distance = get<0>(position);
int dir = get<1>(position);
int x = get<2>(position);
int y = get<3>(position);
if (dist[x][y][dir] <= distance) {
continue;
}
dist[x][y][dir] = distance;
for (int i = 0; i < shifts.size(); ++i) {
int new_x = x + shifts[i].first;
int new_y = y + shifts[i].second;
if (new_x < 0 || new_y < 0 || new_x >= n || new_y >= m) {
continue;
}
if (town[new_x][new_y] == '*') {
continue;
}
int new_dist = distance + (i != dir);
if (new_dist <= 2) {
positions.insert(make_tuple(new_dist, i, new_x, new_y));
}
}
}
int ans = 4;
for (int i = 0; i < shifts.size(); ++i) {
ans = min(ans, dist[dest_x][dest_y][i]);
}
cout << (ans <= 2 ? "YES" : "NO") << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long k, b, n, t;
cin >> k >> b >> n >> t;
int ans = -1;
long long cur = 1;
while (cur <= t) {
cur = cur * k + b;
++ans;
}
cout << max(0LL, n - ans) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<ll, ll>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int mod = 1e9 + 9;
int n;
map<int, pi> pos;
map<pi, int> id;
vector<set<int>> p, ch;
bool canrem(int i) {
int ok = 1;
for (auto j : p[i]) {
ok &= ch[j].size() > 1;
}
return ok;
}
void rem(int i) {
for (auto j : p[i]) {
ch[j].erase(i);
}
for (auto j : ch[i]) {
p[j].erase(i);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
p.resize(n);
ch.resize(n);
for (int x, y, i = 0; i < n; i++) {
cin >> y >> x;
pos[i] = {x, y};
id[{x, y}] = i;
}
for (int i = 0; i < n; i++) {
int x = pos[i].first, y = pos[i].second;
for (int z = -1; z < 2; z++) {
if (id.count({x + 1, y + z})) p[i].insert(id[{x + 1, y + z}]);
if (id.count({x - 1, y + z})) ch[i].insert(id[{x - 1, y + z}]);
}
}
set<int> can;
for (int i = 0; i < n; i++) {
int x = pos[i].first, y = pos[i].second;
if (canrem(i)) can.insert(i);
}
ll ans = 0;
for (int i = 0; i < n; i++) {
int j = ((i & 1) ? *can.begin() : *can.rbegin());
ans = (ans * 1ll * n + j) % mod;
int x = pos[j].first, y = pos[j].second;
rem(j);
can.erase(j);
id.erase(pos[j]);
for (int z = -2; z < 3; z++) {
if (id.count({x, y + z})) {
can.erase(id[{x, y + z}]);
}
if (id.count({x - 1, y + z})) {
can.erase(id[{x - 1, y + z}]);
}
}
for (int z = -2; z < 3; z++) {
if (id.count({x, y + z}) && canrem(id[{x, y + z}])) {
can.insert(id[{x, y + z}]);
}
x--;
if (id.count({x, y + z}) && canrem(id[{x, y + z}])) {
can.insert(id[{x, y + z}]);
}
x++;
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
map<int, int> vis;
int main() {
int n;
cin >> n;
while (n--) {
string str;
cin >> str;
vis.clear();
int len = str.size();
for (int i = 0; i < len; i++) {
vis[str[i] - 'a']++;
}
int i;
for (i = 0; i < 26; i++) {
if (vis[i]) break;
}
int j;
for (j = 25; j >= 0; j--) {
if (vis[j]) break;
}
int flag = 1;
for (int k = i; k <= j; k++) {
if (vis[k] >= 2 || vis[k] == 0) {
flag = 0;
break;
}
}
if (flag)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, f[2][100100], ans, ch[100100][26], fail[100100];
char s[100100], t[100100];
void build() {
int n = strlen(t + 1);
for (int i = 1; i <= n; i++) ch[i][t[i] - 'a'] = i + 1;
for (int i = 0; i <= 25; i++)
if (!ch[1][i]) ch[1][i] = 1;
fail[2] = 1;
for (int i = 2; i <= n + 1; i++)
for (int j = 0; j <= 25; j++)
if (!ch[i][j])
ch[i][j] = ch[fail[i]][j];
else
fail[i + 1] = ch[fail[i]][j];
}
int main() {
scanf("%s%s", s + 1, t + 1);
build();
n = strlen(s + 1);
m = strlen(t + 1);
memset(f[0], 200, sizeof f[0]);
f[0][1] = 0;
for (int i = 1; i <= n; i++) {
memset(f[i & 1], 200, sizeof f[i & 1]);
for (int j = 1; j <= m + 1; j++)
if (f[(i & 1) ^ 1][j] >= 0) {
int d = 0, u = 25;
if (s[i] != '?') d = u = s[i] - 'a';
for (int c = d; c <= u; c++) {
int nx = ch[j][c];
if (nx == m + 1)
f[i & 1][nx] = max(f[i & 1][nx], f[(i & 1) ^ 1][j] + 1);
else
f[i & 1][nx] = max(f[i & 1][nx], f[(i & 1) ^ 1][j]);
}
}
}
for (int i = 1; i <= m + 1; i++) ans = max(ans, f[n & 1][i]);
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename... As>
struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...>>
typename tuple_element<0, T>::type const& x() const {
return get<0>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<0, T>::type& x() {
return get<0>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<1, T>::type const& y() const {
return get<1>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<1, T>::type& y() {
return get<1>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<2, T>::type const& z() const {
return get<2>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<2, T>::type& z() {
return get<2>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<3, T>::type const& w() const {
return get<3>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<3, T>::type& w() {
return get<3>(*this);
}
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_queue = priority_queue<T>;
template <size_t... I>
struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J>
struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...>>
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <>
struct make_index_sequence<0> : my_index_sequence<> {};
template <>
struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T>
ostream& print_collection(ostream& s, T const& a);
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a);
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a);
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a);
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, multiset<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
using M = vector<vector<lli>>;
const lli infty = (1ll << 60);
M zero(int sz) {
M a(sz, vi(sz));
for (lli i = 0; i < (lli)(sz); ++i)
for (lli j = 0; j < (lli)(sz); ++j) a[i][j] = infty;
return a;
}
M iden(int sz) {
M a = zero(sz);
for (lli i = 0; i < (lli)(sz); ++i) a[i][i] = 0;
return a;
}
M mult(M a, M b) {
M c = zero(a.size());
for (lli i = 0; i < (lli)(a.size()); ++i)
for (lli k = 0; k < (lli)(a.size()); ++k)
if (a[i][k] < infty)
for (lli j = 0; j < (lli)(a.size()); ++j) {
c[i][j] = min(c[i][j], a[i][k] + b[k][j]);
}
return c;
}
vi multV(M a, vi b) {
vi c(b.size(), infty);
for (lli i = 0; i < (lli)(b.size()); ++i) {
for (lli j = 0; j < (lli)(b.size()); ++j) c[i] = min(c[i], b[j] + a[j][i]);
}
return c;
}
M fexp(M a, lli b) {
M r = iden(a.size());
while (b) {
if (b & 1) r = mult(r, a);
a = mult(a, a);
b /= 2;
}
return r;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
lli x, k, n, q;
cin >> x >> k >> n >> q;
vi C(k);
for (lli i = 0; i < (lli)(k); ++i) cin >> C[i];
vi states;
vi iSts(1 << k, -1);
for (lli i = 0; i < (lli)(1 << k); ++i)
if (__builtin_popcount(i) == x) {
iSts[i] = states.size();
states.push_back(i);
}
vi S(states.size(), infty);
S[iSts[(1 << x) - 1]] = 0;
int cur = 1;
map<lli, lli> Q;
for (lli q_ = 0; q_ < (lli)(q); ++q_) {
lli p, w;
cin >> p >> w;
Q[p] = w;
};
M mat(states.size(), vi(states.size(), infty));
for (lli m1_ = 0; m1_ < (lli)(states.size()); ++m1_) {
int m1 = states[m1_];
if (m1 & 1) {
for (lli i = 0; i < (lli)(k); ++i) {
int m2 = m1 / 2;
if (m2 & (1 << i)) continue;
m2 |= (1 << i);
mat[m1_][iSts[m2]] = min(mat[m1_][iSts[m2]], C[i]);
}
} else {
mat[m1_][iSts[m1 / 2]] = min(mat[m1_][iSts[m1 / 2]], 0ll);
}
}
auto adv = [&]() {
cur += 1;
auto T = S;
fill(begin(T), end(T), infty);
for (lli m1_ = 0; m1_ < (lli)(states.size()); ++m1_) {
int m1 = states[m1_];
lli co0 = S[m1_];
if (m1 & 1) {
for (lli i = 0; i < (lli)(k); ++i) {
int m2 = m1 / 2;
if (m2 & (1 << i)) continue;
m2 |= (1 << i);
lli co = co0 + C[i];
if (Q.count(cur + i)) co += Q[cur + i];
T[iSts[m2]] = min(T[iSts[m2]], co);
}
} else {
T[iSts[m1 / 2]] = min(T[iSts[m1 / 2]], co0);
}
}
S = T;
};
for (auto const& q : Q) {
lli p = q.first;
if (cur + k < p) {
S = multV(fexp(mat, p - (cur + k)), S);
cur = p - k;
}
while (cur < p && cur + x - 1 < n) adv();
}
if (cur + x - 1 < n) {
S = multV(fexp(mat, n - (cur + x - 1)), S);
cur = n - (x - 1);
}
cout << S[iSts[(1 << x) - 1]] << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
void solve() {
long long int n;
cin >> n;
string s[n + 1][3];
for (long long int i = 0; i < n; i++) cin >> s[i][0] >> s[i][1] >> s[i][2];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < s[i][0].size(); j++) {
if (s[i][0][j] >= 97) s[i][0][j] = 'A' + (s[i][0][j] - 97);
}
for (long long int j = 0; j < s[i][2].size(); j++) {
if (s[i][2][j] >= 97) s[i][2][j] = 'A' + (s[i][2][j] - 97);
}
}
map<string, long long int> m;
long long int max1 = 0;
m[s[0][2]] = 0;
for (long long int i = 0; i < n; i++) {
m[s[i][0]] = m[s[i][2]] + 1;
max1 = max(max1, m[s[i][0]]);
}
cout << max1 + 1;
}
int main() {
long long int t = 1;
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
for (long long int i = 1; i <= t; i++) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
int get(long long x, long long k) { return (x - 1) / k; }
int main() {
long long n, m, k;
R(n, m, k);
vector<long long> AA(m);
for (int i = 0; i < (m); ++i) R(AA[i]);
int it = 0, an = 0, cnt = 0;
while (it < m) {
an++;
int page = get(AA[it] - cnt, k);
int it2 = it + 1;
while (it2 < m && get(AA[it2] - cnt, k) == page) it2++;
cnt += it2 - it;
it = it2;
}
W(an);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
const int maxn = 100 + 5;
int dp[maxn][maxn];
int col_r[maxn][maxn], col_l[maxn][maxn];
void scan(int &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
int solve(int l, int r) {
if (r < l) return 0;
if (dp[l][r]) return dp[l][r];
int &ans = dp[l][r];
for (int k = l; k <= r; k++) {
int t = 0;
for (int i = 0; i < N; i++) {
if (l <= col_l[i][k] && col_r[i][k] <= r) ++t;
}
ans = max(ans, solve(l, k - 1) + t * t + solve(k + 1, r));
}
return ans;
}
int main() {
scan(N), scan(M);
for (int i = 0; i < N; i++) {
int num;
scan(num);
for (int j = 0; j < num; j++) {
int a, b;
scan(a);
scan(b);
--a;
--b;
for (int k = a; k <= b; k++) {
col_l[i][k] = a;
col_r[i][k] = b;
}
}
}
for (int k = 0; k < M; k++) {
for (int i = 0; i + k < M; i++) {
int j = i + k;
for (int q = i; q <= j; q++) {
int t = 0;
for (int x = 0; x < N; x++) {
if (i <= col_l[x][q] && col_r[x][q] <= j) t++;
}
int lt, rt;
lt = (q - 1 < 0) ? 0 : dp[i][q - 1];
rt = (q + 1 >= M) ? 0 : dp[q + 1][j];
dp[i][j] = max(dp[i][j], lt + t * t + rt);
}
}
}
printf("%d\n", dp[0][M - 1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using ll = long long;
using ld = long double;
using ull = uint64_t;
using namespace std;
struct Node {
bool w = false, b = false;
bool hw = false, hb = false;
Node* go[2];
Node() { go[0] = go[1] = nullptr; }
};
void add(Node* v, const string& s, bool bl) {
for (char c : s) {
int x = c - '0';
if (v->go[x] == nullptr) {
v->go[x] = new Node();
}
v = v->go[x];
}
if (bl) {
v->b = true;
v->hb = true;
} else {
v->w = true;
v->hw = true;
}
}
void dfs(Node* v) {
for (int i = 0; i < 2; i++) {
if (v->go[i]) {
dfs(v->go[i]);
v->hb |= v->go[i]->hb;
v->hw |= v->go[i]->hw;
}
}
}
string conv(int x) {
string res;
for (int i = 0; i < 8; i++) {
res += '0' + (x % 2);
x /= 2;
}
return string(res.rbegin(), res.rend());
}
string parse(string s) {
int pos = -1;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '/') {
pos = i;
}
}
int len = 32;
if (pos != -1) {
len = stoi(s.substr(pos + 1));
}
if (pos == -1) {
pos = s.size();
}
string res;
string cur;
for (int i = 0; i < pos; i++) {
if (s[i] == '.') {
res += conv(stoi(cur));
cur = "";
} else {
cur += s[i];
}
}
res += conv(stoi(cur));
return res.substr(0, len);
}
vector<string> ans;
void nein() {
cout << -1 << "\n";
exit(0);
}
string tob(string s) {
int x = 0;
for (char c : s) {
x = 2 * x;
if (c == '1') {
x++;
}
}
return to_string(x);
}
string make(string s) {
int smask = s.size();
while (s.size() < 32) {
s += '0';
}
string res;
string cur;
for (int i = 0; i < 32; i++) {
cur += s[i];
if (i % 8 == 7) {
if (!res.empty()) {
res += '.';
}
res += tob(cur);
cur = "";
}
}
res += "/";
res += to_string(smask);
return res;
}
void solve(Node* v, string cur) {
if (v->b && v->hw) {
nein();
}
if (v->w && v->hb) {
nein();
}
if (v->hb && !v->hw) {
ans.push_back(make(cur));
return;
}
for (int i = 0; i < 2; i++) {
if (v->go[i]) {
solve(v->go[i], cur + char('0' + i));
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(20);
int n;
cin >> n;
Node* root = new Node();
for (int i = 0; i < n; i++) {
string s;
cin >> s;
string mask = parse(s.substr(1));
bool bl = false;
if (s[0] == '-') {
bl = true;
}
add(root, mask, bl);
}
dfs(root);
solve(root, "");
cout << ans.size() << "\n";
for (const auto& s : ans) {
cout << s << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int maxn = 1e5 + 5;
int arr[maxn], tot;
int main() {
int t = read();
while (t--) {
tot = 0;
int n = read();
int sq = sqrt(n);
for (int i = 0; i < sq; i++) arr[tot++] = i;
for (int i = sq + 1; i >= 1; i--)
if (n / i > arr[tot - 1]) arr[tot++] = n / i;
cout << tot << endl;
for (int i = 0; i < tot; i++) cout << arr[i] << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
long long Bigmod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
long long ModInverse(long long number, long long MOD) {
return Bigmod(number, MOD - 2, MOD);
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
long long int a[100007];
long long int b[100007];
int n, m;
bool isok(long long int mid) {
int nw = 0;
for (int i = 0; i < n && nw < m; i++) {
long long int ps = a[i];
if (b[nw] >= ps) {
while (nw < m && b[nw] <= (ps + mid)) {
nw++;
}
} else {
if ((ps - b[nw]) > mid) return 0;
long long int pos = ps - b[nw];
pos = mid - pos;
pos = b[nw] + pos;
long long int pos1 = ps + (mid - (ps - b[nw])) / 2LL;
pos = max(pos, pos1);
while (nw < m && (b[nw] <= ps || b[nw] <= pos)) {
nw++;
}
}
}
if (nw != m) return 0;
return 1;
}
int main() {
n = in<int>(), m = in<int>();
for (int i = 0; i < n; i++) {
a[i] = in<long long int>();
}
for (int i = 0; i < m; i++) {
b[i] = in<long long int>();
}
a[n] = 20000000000LL;
b[m] = 20000000000LL;
long long int lo = 0LL, hi = 20000000000LL;
long long int ans;
while (lo <= hi) {
long long int mid = (lo + hi) / 2;
if (isok(mid)) {
ans = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int b;
queue<pair<int, int> > qu;
void OUT() {
if (ans.size() == 201) ans.pop_back();
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
}
int solve(int last, int i) {
if (last == 0) return 0;
qu.push(pair<int, int>(last, i));
return (last + b - 1) / b;
}
int main() {
int n, a, k, cnt = 0, last2 = 0;
string s;
scanf("%d %d %d %d", &n, &a, &b, &k);
cin >> s;
s += '1';
int last = 0;
string tmp = s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
for (last = max(last, i - b + 1); last <= i; last++) tmp[last] = '1';
}
}
s = tmp;
last = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1')
cnt += solve(last, i), last = 0;
else
last++;
}
while (cnt >= a) {
ans.push_back(qu.front().second);
cnt--;
if (qu.front().first > b)
qu.front().second -= b, qu.front().first -= b;
else
qu.pop();
}
OUT();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
int x = 0, f = 1, c = getchar();
for (; c < 48 || c > 57; f = c == '-' ? -1 : f, c = getchar())
;
for (; c > 47 && c < 58; x = x * 10 + c - 48, c = getchar())
;
return x * f;
}
const int N = 105;
int n, m, k;
char s[N][N][N];
bool a[N][N][N];
bool check(int x, int y, int z) {
return a[x][y][z] &&
((a[x - 1][y][z] &&
((a[x + 1][y][z]) || (a[x][y + 1][z] && !a[x - 1][y + 1][z]) ||
(a[x][y][z + 1] && !a[x - 1][y][z + 1]))) ||
(a[x][y - 1][z] &&
((a[x][y + 1][z]) || (a[x][y][z + 1] && !a[x][y - 1][z + 1]) ||
(a[x + 1][y][z] && !a[x + 1][y - 1][z]))) ||
(a[x][y][z - 1] &&
((a[x][y][z + 1]) || (a[x + 1][y][z] && !a[x + 1][y][z - 1]) ||
(a[x][y + 1][z] && !a[x][y + 1][z - 1]))));
}
int main() {
n = getint(), m = getint(), k = getint();
for (int x = 1; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
scanf("%s", s[x][y] + 1);
for (int z = 1; z <= k; ++z) {
a[x][y][z] = s[x][y][z] == '1';
}
}
}
int ans = 0;
for (int x = 1; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
for (int z = 1; z <= k; ++z) {
if (check(x, y, z)) {
++ans;
}
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[4][1005][1005];
int arr[1005][1005];
int main() {
int i, j, k;
int n, m;
long long int a, b;
memset(dp, 0, sizeof(dp));
memset(arr, 0, sizeof(arr));
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) scanf("%d", &arr[i][j]);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
dp[0][i][j] = max(dp[0][i][j - 1], dp[0][i - 1][j]) + arr[i][j];
}
for (i = n; i >= 1; i--) {
for (j = 1; j <= m; j++)
dp[1][i][j] = max(dp[1][i][j - 1], dp[1][i + 1][j]) + arr[i][j];
}
for (i = n; i >= 1; i--) {
for (j = m; j >= 1; j--)
dp[2][i][j] = arr[i][j] + max(dp[2][i + 1][j], dp[2][i][j + 1]);
}
for (i = 1; i <= n; i++) {
for (j = m; j >= 1; j--)
dp[3][i][j] = arr[i][j] + max(dp[3][i - 1][j], dp[3][i][j + 1]);
}
long long int mx = 0;
for (i = 2; i < n; i++) {
for (j = 2; j < m; j++) {
a = dp[0][i - 1][j] + dp[2][i + 1][j] + dp[1][i][j - 1] + dp[3][i][j + 1];
b = dp[0][i][j - 1] + dp[2][i][j + 1] + dp[1][i + 1][j] + dp[3][i - 1][j];
mx = max(mx, max(a, b));
}
}
printf("%I64d", mx);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int num[MAXN], leftBracket[MAXN];
int main() {
string str;
cin >> str;
int count = 0, max = 0, times = 1;
for (int i = 0; i < str.size(); ++i) {
if (str[i] == '(')
leftBracket[++count] = i;
else if (count) {
int pairLeft = leftBracket[count];
num[i] = i - pairLeft + 1 + num[pairLeft - 1];
--count;
if (num[i] == max) {
++times;
} else if (num[i] > max) {
max = num[i];
times = 1;
}
}
}
printf("%d %d\n", max, times);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} c[1010000];
int a[500], b[500];
int main() {
int n, i, j, k, ans = 0, t;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
if (b[j] == a[i]) break;
}
for (k = j; k > i; k--) {
ans++;
c[ans].x = k - 1;
c[ans].y = k;
t = b[k];
b[k] = b[k - 1];
b[k - 1] = t;
}
}
printf("%d\n", ans);
for (i = 1; i <= ans; i++) printf("%d %d\n", c[i].x, c[i].y);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
const int NN = 272727;
INT a[NN], ans;
int main() {
int n;
INT k;
scanf("%d%I64d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
int id = 0;
for (int i = 1; i <= n; i++)
if (a[i]) {
id = i;
break;
}
for (int i = id; i <= n; i++) a[i - id + 1] = a[i];
n = n - id + 1;
if (a[n] >= k) {
puts("0");
return 0;
}
if (n == 2) {
ans = k - a[2];
ans = (ans + a[1] - 1) / a[1];
ans = max(ans, 0LL);
cout << ans << endl;
return 0;
}
if (n == 3) {
INT st = 0, ed = 2e9;
while (st + 1 < ed) {
INT mid = st + ed >> 1;
INT A = mid * (mid + 1) / 2;
if (k / A < a[1]) {
ed = mid;
continue;
}
INT B = A * a[1] + mid * a[2] + a[3];
if (B >= k)
ed = mid;
else
st = mid;
}
cout << ed << endl;
return 0;
}
ans = 0;
while (1) {
ans++;
int fl = 0;
for (int i = 2; i <= n; i++) {
a[i] += a[i - 1];
if (a[i] >= k) {
fl = 1;
break;
}
}
if (fl) break;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a <= b) && (a <= c))
cout << "Yes";
else
cout << "No";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int collinear(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3) {
long long a = x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2);
return a == 0 ? 1 : 0;
}
int main() {
long long ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
long long ab = ax - bx;
ab *= ab;
ab += (ay - by) * (ay - by);
long long cb = cx - bx;
cb *= cb;
cb += (cy - by) * (cy - by);
if (ab == cb && !collinear(ax, ay, bx, by, cx, cy))
cout << "Yes";
else
cout << "No";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000005;
const long long mmod = 1e9 + 333 + 7;
long long n, m, dp[1000009], f[1000009], ddp[1000009], ff[1000009];
char a[1000009];
signed main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) cin >> a[(i - 1) * m + j];
dp[n * m] = 1, ddp[n * m] = 1;
for (long long i = n; i >= 1; i--)
for (long long j = m; j >= 1; j--) {
if (i == n && j == m) continue;
long long now = (i - 1) * m + j;
long long l = i * m + j, r = (i - 1) * m + j + 1;
if (a[now] == '#') continue;
if (j != m) dp[now] += dp[r], ddp[now] += ddp[r];
if (i != n) dp[now] += dp[l], ddp[now] += ddp[l];
dp[now] %= mod, ddp[now] %= mmod;
}
f[1] = 1;
ff[1] = 1;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (i == 1 && j == 1) continue;
long long now = (i - 1) * m + j;
long long l = (i - 2) * m + j, r = (i - 1) * m + j - 1;
if (a[now] == '#') continue;
if (j != 1) f[now] += f[r], ff[now] += ff[r];
if (i != 1) f[now] += f[l], ff[now] += ff[l];
f[now] %= mod, ff[now] %= mmod;
}
if (f[n * m] == 0 && ff[n * m] == 0) {
cout << 0;
return 0;
}
long long flag = 0;
for (long long i = 2; i <= n * m - 1; i++)
if ((dp[i] * f[i] % mod == dp[1]) && (ddp[i] * ff[i] % mmod == ddp[1]))
flag = 1;
if (flag)
cout << 1;
else
cout << 2;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
const long double E = 1e-9;
unsigned char ccc;
bool _minus = false;
template <typename T>
inline T sqr(T t) {
return (t * t);
}
inline void read(long long &n) {
n = 0;
_minus = false;
while (true) {
ccc = getchar();
if (ccc == ' ' || ccc == '\n') break;
if (ccc == '-') {
_minus = true;
continue;
}
n = n * 10 + ccc - '0';
}
if (_minus) n *= -1;
}
inline bool read(int &n) {
n = 0;
_minus = false;
while (true) {
ccc = getchar();
if (ccc == ' ' || ccc == '\n') {
if (ccc == '\n') return true;
break;
}
if (ccc == '-') {
_minus = true;
continue;
}
n = n * 10 + ccc - '0';
}
if (_minus) n *= -1;
return false;
}
char wwww[19];
int kkkk;
inline void write(long long y) {
long long x = y;
kkkk = 0;
if (x < 0) {
putchar('-');
x *= -1;
}
if (!x) {
++kkkk;
wwww[kkkk] = '0';
} else
while (x) {
++kkkk;
wwww[kkkk] = char(x % 10 + '0');
x /= 10;
}
for (int i = kkkk; i >= 1; --i) putchar(wwww[i]);
}
const int MAX = 53;
long long ar[MAX];
bool dp[MAX][MAX];
int n, k;
bool check(long long mask) {
memset(dp, 0, sizeof(dp));
dp[0][0] = true;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < k; j++) {
if (dp[i][j]) {
long long sum = 0;
for (int z = i + 1; z <= n; z++) {
sum += ar[z];
if ((sum & mask) == mask) {
dp[z][j + 1] = true;
}
}
}
}
}
return dp[n][k];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
srand((unsigned int)time(NULL));
cout.precision(10);
cout << fixed;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
long long ans = 0;
for (int i = 59; i >= 0; i--) {
if (check(ans | (1LL << i))) {
ans |= (1LL << i);
}
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, n, b;
cin >> n >> a >> b;
cout << min(b + 1, n - a) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long l[n], r[n];
for (long long i = 0; i < n; ++i) cin >> l[i] >> r[i];
long long ans = n;
sort(l, l + n);
sort(r, r + n);
for (long long i = 0; i < n; ++i) ans += max(l[i], r[i]);
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int d4x[] = {0, 0, 1, -1};
int d4y[] = {1, -1, 0, 0};
int d8x[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int d8y[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long a[205];
long long n;
long long dp[205][305];
long long f(int i, int k) {
if (i == n) return 0;
if (dp[i][k] != -1) return dp[i][k];
long long res = 696969;
for (int kk = k + 1; kk <= 301; kk++) {
res = min(res, abs(kk - a[i]) + f(i + 1, kk));
}
return dp[i][k] = res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T;
cin >> T;
while (T--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
memset(dp, -1, sizeof(dp));
;
cout << f(0, 0) << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int p[n];
int c[n];
for (int i = 0; i < n; i++) {
cin >> p[i] >> c[i];
}
if (p[0] < c[0]) {
cout << "NO\n";
return;
}
for (int i = 1; i < n; i++) {
if ((p[i] < p[i - 1]) || (c[i] < c[i - 1]) ||
(p[i] - p[i - 1] < c[i] - c[i - 1])) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%i", &n);
int min = 999999;
int* casher = new int[n];
for (int x = 0; x < n; x++) {
scanf("%i", &casher[x]);
}
for (int i = 0; i < n; i++) {
int total = 0;
for (int ii = 0; ii < casher[i]; ii++) {
int a;
scanf("%i", &a);
total += ((a * 5) + 15);
}
if (total < min) min = total;
}
printf("%i\n", min);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << n << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, t, m;
long long int ar[101][101];
long long int br[101][101];
cin >> t;
for (long long int i = 1; i <= t; i++) {
set<long long int> s;
cin >> n >> m;
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = 0; j < m; j++) {
cin >> ar[i][j];
br[i][j] = ar[i][j];
s.insert(ar[i][j]);
}
}
if (n == 1 && m == 1)
cout << ar[0][0] << endl;
else {
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = 0; j < m; j++) {
if (!(i & 1) && !(j & 1) && (ar[i][j] & 1)) {
ar[i][j]++;
}
if (!(i & 1) && (j & 1) && !(ar[i][j] & 1)) {
ar[i][j]++;
}
if ((i & 1) && (j & 1) && (ar[i][j] & 1)) {
ar[i][j]++;
}
if ((i & 1) && !(j & 1) && !(ar[i][j] & 1)) {
ar[i][j]++;
}
}
}
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = 0; j < m; j++) {
cout << ar[i][j] << " ";
}
cout << endl;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, int> dp, Prime;
unordered_map<int, int>::iterator it;
int Count;
void Insert(int n) {
for (int i = 2; i * i <= n; i++) {
Count = 0;
while (n % i == 0) {
n = n / i;
Count++;
}
Prime[i] |= (1 << Count);
}
if (n > 1) Prime[n] |= 1 << 1;
}
int Grundy(int mask) {
if (mask == 1) return 0;
if (dp.count(mask)) return dp[mask];
int SET = 31 - __builtin_clz(mask);
unordered_map<int, bool> Mark;
for (int k = SET; k >= 0; k--) {
int newMask = (mask >> k) | (mask & ((1 << k) - 1));
if (mask == newMask) continue;
Mark[Grundy(newMask)] = true;
}
int ans = 0;
while (Mark.count(ans)) ans++;
return dp[mask] = ans;
}
int main() {
int n, p;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p);
Insert(p);
}
int ans = 0;
for (it = Prime.begin(); it != Prime.end(); it++) ans ^= Grundy(it->second);
if (ans)
printf("Mojtaba");
else
printf("Arpa");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long a, b, c;
cin >> a >> b >> c;
double rr = sqrt(b * b - 4 * a * c);
if (a > 0)
cout << scientific << (rr - b) / (double(2 * a)) << '\n'
<< (-b - rr) / (double(2 * a)) << endl;
else
cout << scientific << (-b - rr) / (double(2 * a)) << '\n'
<< (-b + rr) / (double(2 * a)) << endl;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2, 3, "Ofast")
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void print(T x, char let) {
print(x), putchar(let);
}
const int N = 200005;
struct dot {
int x, y, id;
} a[N], b[N];
int sq[N];
double ans = 1e9;
int special, n, m, S, SS;
dot operator+(dot a, dot b) { return {a.x + b.x, a.y + b.y}; }
dot operator-(dot a, dot b) { return {a.x - b.x, a.y - b.y}; }
bool operator==(dot a, dot b) { return 1ll * a.x * b.y == 1ll * a.y * b.x; }
bool operator!=(dot a, dot b) { return 1ll * a.x * b.y != 1ll * a.y * b.x; }
inline double sqr(double x) { return x * x; }
inline double dist(int x, int y) {
return sqrt(sqr(a[x].x - a[y].x) + sqr(a[x].y - a[y].y));
}
int main() {
scanf("%d%d", &m, &SS);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &b[i].x, &b[i].y);
b[i].id = i;
}
sort(b + 1, b + m + 1, [&](dot a, dot b) {
return make_pair(a.x, a.y) <= make_pair(b.x, b.y);
});
for (int i = 1; i <= m; i++) {
if (i == 1 ||
make_pair(b[i - 1].x, b[i - 1].y) != make_pair(b[i].x, b[i].y))
a[++n] = b[i];
if (b[i].id == SS) S = n;
}
if (n == 1) {
puts("0.000000");
return 0;
}
if (n == 2) {
printf("%.10f\n", dist(1, 2));
return 0;
}
if (n == 3) {
double ans = 1e9;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (i != S && j != S && i != j) {
ckmin(ans, dist(S, i) + dist(i, j));
}
}
}
printf("%.10f\n", ans);
return 0;
}
dot a1 = a[2] - a[1], a2 = a[3] - a[1], a3 = a[3] - a[2], v;
if (a1 == a2)
v = a1;
else if (a1 == a2)
v = a2;
else
v = a3, special = 1;
if (!special) {
for (int i = 2; i <= n; i++)
if ((a[i] - a[1]) != v) special = i;
}
if (!special) special = 1;
for (int i = 1; i <= n; i++) {
if (i == S) {
int t = 0;
double sum = 0;
if (i == special) {
for (int j = 1; j <= n; j++) {
if (j != special) sq[++t] = j;
}
} else {
for (int j = i; j >= 1; j--)
if (j != special) sq[++t] = j;
for (int j = i + 1; j <= n; j++)
if (j != special) sq[++t] = j;
}
for (int j = 1; j < n - 1; j++) sum += dist(sq[j], sq[j + 1]);
if (i != special) {
ckmin(ans, sum + dist(special, sq[n - 1]));
for (int j = n - 2; j >= 1; j--)
ckmin(ans, sum - dist(sq[j], sq[j + 1]) + dist(sq[j], special) +
dist(sq[j + 1], special));
} else {
ckmin(ans, sum + dist(special, sq[1]));
}
t = 0;
if (i == special) {
for (int j = n; j >= 1; j--)
if (j != special) sq[++t] = j;
} else {
for (int j = i; j <= n; j++)
if (j != special) sq[++t] = j;
for (int j = i - 1; j >= 1; j--)
if (j != special) sq[++t] = j;
}
sum = 0;
for (int j = 1; j < n - 1; j++) sum += dist(sq[j], sq[j + 1]);
if (i != special) {
ckmin(ans, sum + dist(special, sq[n - 1]));
for (int j = n - 2; j >= 1; j--)
ckmin(ans, sum - dist(sq[j], sq[j + 1]) + dist(sq[j], special) +
dist(sq[j + 1], special));
} else {
ckmin(ans, sum + dist(special, sq[1]));
}
}
}
printf("%.10f\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n], ans = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (long long int i = n - 1; i >= 0; i--) {
if (a[i] <= i + 1) {
ans = i + 1;
break;
}
}
cout << ans + 1 << endl;
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<vector<int> > setvect;
vector<int> tmp;
int n, cnt = 0, a, b, c, d;
string s;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%1d%1d%1d%1d", &a, &b, &d, &c);
if (i < n - 1) cin >> s;
tmp.clear();
tmp.push_back(a);
tmp.push_back(b);
tmp.push_back(c);
tmp.push_back(d);
if (setvect.find(tmp) == setvect.end()) {
cnt++;
setvect.insert(tmp);
tmp.clear();
tmp.push_back(d);
tmp.push_back(a);
tmp.push_back(b);
tmp.push_back(c);
setvect.insert(tmp);
tmp.clear();
tmp.push_back(c);
tmp.push_back(d);
tmp.push_back(a);
tmp.push_back(b);
setvect.insert(tmp);
tmp.clear();
tmp.push_back(b);
tmp.push_back(c);
tmp.push_back(d);
tmp.push_back(a);
setvect.insert(tmp);
}
}
cout << cnt;
}
| 2 |
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=(1e5+7)*2;
int T,n,num[maxn];
int f1[maxn],f2[maxn];
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
long long sum=0;
for(int i=1;i<=n;i++)
scanf("%d",&num[i]),sum+=num[i],f1[i]=f2[i]=num[i];
f1[0]=f1[n+1]=f2[0]=f2[n+1]=0;
if(sum%2==1)
{
printf("NO\n");
continue;
}
int j=1;
for(int i=1;i<=n;i++)
{
if(f1[i-1]>=0)
f1[i]-=f1[i-1];
else f1[i]=-1;
if(f1[i]<0)j=0;
}
if(j&&f1[n]==0)
{
printf("YES\n");
continue;
}
for(int i=n;i>=1;i--)
{
if(f2[i+1]>=0)
f2[i]-=f2[i+1];
else f2[i]=-1;
}
j=1;
/*
for(int i=1;i<=n;i++)
printf("%d ",f1[i]);
printf("\n");
for(int i=1;i<=n;i++)
printf("%d ",f2[i]);
printf("\n");*/
for(int i=1;i<n;i++)
{
if(f1[i-1]<0||f2[i+2]<0)
continue;
if(num[i+1]>=f1[i-1]&&num[i]>=f2[i+2]&&num[i]-f2[i+2]==num[i+1]-f1[i-1])
{
printf("YES\n");j=0;
break;
}
}
if(j)
printf("NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool debug = true;
long long n, m, a, b;
int main(int argc, char* argv[]) {
cin >> n >> m >> a >> b;
long long r = n % m;
cout << min(r * b, (m - r) * a);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
int n;
char s[maxn], t[maxn];
vector<int> V;
void move(int p) {
V.push_back(n), V.push_back(p - 1), V.push_back(1);
char tmp = s[p];
for (int i = p; i > 1; i--) s[i] = s[i - 1];
s[1] = tmp, reverse(s + p + 1, s + n + 1);
}
int main() {
scanf("%d %s %s", &n, s + 1, t + 1);
for (int i = n; i; i--) {
bool flag = 0;
for (int j = n - i + 1; j <= n; j++) {
if (s[j] == t[i]) {
move(j), flag = 1;
break;
}
}
if (!flag) printf("-1\n"), exit(0);
}
printf("%d\n", V.size());
for (int x : V) {
printf("%d ", x);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
const int inf = 2000000000;
const long long linf = 5000000000000000000;
const long double LDINF = 2e18;
template <typename T>
void print(vector<T>& a) {
for (int i = 0; i < a.size(); i++) cout << a[i] << ' ';
cout << '\n';
}
template <typename T>
void print(deque<T>& a) {
for (int i = 0; i < a.size(); i++) cout << a[i] << ' ';
cout << '\n';
}
template <typename T>
void print(vector<vector<T>>& a) {
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << ' ';
cout << '\n';
}
}
template <typename T>
void input(vector<T>& a) {
for (int i = 0; i < a.size(); i++) cin >> a[i];
}
template <typename T>
void input(deque<T>& a) {
for (int i = 0; i < a.size(); i++) cin >> a[i];
}
template <typename T>
void input(vector<vector<T>>& a) {
for (int i = 0; i < a.size(); i++)
for (int j = 0; j < a[i].size(); j++) cin >> a[i][j];
}
long long mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
vector<int> t, tAdd;
void push(int v, int vl, int vr) {
if (tAdd[v] == 0) return;
t[v] += tAdd[v];
if (vl != vr) {
tAdd[2 * v + 1] += tAdd[v];
tAdd[2 * v + 2] += tAdd[v];
}
tAdd[v] = 0;
}
long long query(int v, int vl, int vr, int l, int r) {
push(v, vl, vr);
if (vl >= l && vr <= r)
return t[v];
else if (vl > r || l > vr)
return 0;
int vm = (vl + vr) / 2;
return query(2 * v + 1, vl, vm, l, r) + query(2 * v + 2, vm + 1, vr, l, r);
}
void modify(int v, int vl, int vr, int l, int r, int val) {
push(v, vl, vr);
if (vl >= l && vr <= r) {
tAdd[v] += val;
push(v, vl, vr);
return;
}
if (vl > r || l > vr) return;
int vm = (vl + vr) / 2;
modify(2 * v + 1, vl, vm, l, r, val);
modify(2 * v + 2, vm + 1, vr, l, r, val);
t[v] = t[2 * v + 1] + t[2 * v + 2];
}
int n, k, cnt = 0;
void check(string& str) {
vector<bool> used(k + 1, false);
for (int i = 0; i < str.length(); i++) used[str[i] - '0'] = true;
for (int i = 0; i < k + 1; i++) {
if (!used[i]) return;
}
cnt++;
}
void solve() {
long long n, d;
cin >> n >> d;
vector<long long> c(n);
input(c);
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += c[i];
}
vector<vector<bool>> dp(n + 1, vector<bool>(sum + 1, false));
dp[0][0] = true;
for (int i = 0; i < n; i++) {
for (int w = 0; w <= sum; w++) {
if (dp[i][w]) dp[i + 1][w + c[i]] = true;
if (dp[i][w]) dp[i + 1][w] = true;
}
}
vector<int> vals;
for (int w = 0; w <= sum; w++) {
for (int i = 0; i <= n; i++) {
if (dp[i][w]) {
vals.push_back(w);
break;
}
}
}
long long now = 0;
int cnt = 0;
while (true) {
auto it = upper_bound((vals).begin(), (vals).end(), now + d);
it--;
if (*it == now) break;
now = *it;
cnt++;
}
cout << now << ' ' << cnt;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tst = 1;
while (tst--) solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 10004205361450474;
long long dp[10010][6];
long long t[10010];
int main() {
for (int i = 1; i <= 10000; i++) dp[i][0] = 0;
for (int j = 1; j <= 4; j++)
for (int i = 1; i <= 10000; i++) {
long long now = i;
dp[i][j] = dp[i][j - 1];
now = min(i + dp[i][j - 1] + 1, (long long)10000);
for (int k = 1; k <= i; k++) {
if (now == 10000) {
dp[i][j] += (dp[now][j - 1] + 1) * (i - k + 1);
break;
}
dp[i][j] += dp[now][j - 1] + 1;
now = min(now + dp[now][j - 1] + 1, (long long)10000);
}
}
long long now = 1;
for (int i = 4; i >= 0; i--) {
long long num = now;
t[0] = now - 1;
int tot = 0;
for (int j = 1; j <= min(now, (long long)10000); j++) {
num += dp[min(num, (long long)10000)][i];
if (num > M) break;
t[++tot] = num;
num++;
}
printf("%d ", tot);
for (int j = 1; j <= tot; j++) printf("%I64d ", t[j]);
printf("\n");
fflush(stdout);
int pos;
scanf("%d", &pos);
if (pos < 0) return 0;
now = t[pos] + 1;
}
return ~~(0 - 0);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char s[1000005], a[1000005], b[1000005];
bool vis[26];
int match[26];
void out(int k) {
printf("YES\n");
for (int i = 0; i < k; ++i) {
putchar(char('a' + match[i]));
}
putchar('\n');
}
bool canDo(int n, int k, int bit) {
for (int i = 0; i < 26; ++i) {
vis[i] = false;
match[i] = -1;
}
bool isSameA = true;
bool isSameB = true;
for (int i = 0; i < n && (isSameA || isSameB); ++i) {
int ind = s[i] - 'a';
int x = a[i] - 'a', y = b[i] - 'a';
if (match[ind] != -1) {
char c = char(match[ind] + 'a');
if ((isSameA && a[i] > c) || (isSameB && c > b[i])) {
return false;
}
} else {
if (isSameA && isSameB) {
vector<int> tmp;
for (int j = x; j <= y; ++j) {
if (!vis[j]) {
tmp.push_back(j);
}
}
for (int u : tmp) {
if (u != x && u != y) {
vis[u] = true;
match[ind] = u;
break;
}
}
if (match[ind] != -1) {
break;
}
if (bit) {
reverse(tmp.begin(), tmp.end());
}
for (int u : tmp) {
vis[u] = true;
match[ind] = u;
break;
}
} else if (isSameA) {
for (int j = k - 1; j >= x; --j) {
if (!vis[j]) {
match[ind] = j;
vis[j] = true;
if (j != x) {
isSameA = false;
}
break;
}
}
} else {
for (int j = 0; j <= y; ++j) {
if (!vis[j]) {
match[ind] = j;
vis[j] = true;
if (j != y) {
isSameB = false;
}
break;
}
}
}
}
if (match[ind] == -1) {
return false;
}
if (match[ind] != x) {
isSameA = false;
}
if (match[ind] != y) {
isSameB = false;
}
}
for (int i = 0; i < k; ++i) {
if (match[i] == -1) {
for (int j = 0; j < k; ++j) {
if (!vis[j]) {
vis[j] = true;
match[i] = j;
break;
}
}
}
}
return true;
}
void solve2() {
int k;
scanf("%d ", &k);
scanf(" %s %s %s ", s, a, b);
int n = strlen(s);
for (int bit = 0; bit < 2; ++bit) {
if (canDo(n, k, bit)) {
out(k);
return;
}
}
printf("NO\n");
}
void solve() {
int t;
scanf("%d ", &t);
while (t--) {
solve2();
}
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int LINF = 0x3f3f3f3f3f3f3f3fll;
mt19937 rng((int)chrono::steady_clock::now().time_since_epoch().count());
const int MAX = (int)1e5 + 10;
long long int pot(long long int x) {
if (x == 0) return 1;
return pot(x - 1) * 2;
}
int main() {
ios::sync_with_stdio(false);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<long long int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
long long int l = 0, r = 60;
while (l < r) {
long long int mx = v[0];
long long int x = (l + r) / 2;
bool ok = true;
for (int i = 1; i < n; i++) {
if (v[i] <= mx) {
if (mx - v[i] > pot(x) - 1) {
ok = false;
}
} else {
mx = v[i];
}
}
if (not ok) {
l = x + 1;
} else {
r = x;
}
}
cout << l << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
clock_t time_p = clock();
void aryanc403() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return !(a.first < b.first || a.first == b.first && a.second <= b.second);
}
};
void add(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt == m.end())
m.insert({x, cnt});
else
jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 1000000007L;
const long long int maxN = 100000L;
long long int po(long long int a, long long int n) {
if (n == 0) return 1;
if (n & 1) return (a * po(a, n - 1)) % mod;
return po(a * a % mod, n / 2);
}
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y;
long long int m;
string s;
vector<long long int> fac[maxN + 5];
long long int f[maxN + 5];
void pre(long long int n) {
for (long long int i = 1; i <= n; ++i) {
for (j = i; j <= n; j += i) fac[j].push_back(i);
}
}
long long int d(long long int n) {
long long int k = 1;
for (auto x : fac[n])
if (x != 1 && n % (x * x) == 0) return 0;
;
k = log2((long long int)fac[n].size() + .5);
if (k % 2) return -1;
return 1;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
pre(maxN);
cin >> n;
for (i = 0; i < (n); ++i) {
cin >> in;
for (auto x : fac[in]) f[x]++;
}
cnt = 0;
for (i = (1); i <= (maxN); ++i) {
if (!f[i]) continue;
cnt += d(i) * (po(2, f[i]) - 1);
cnt %= mod;
}
cnt = (cnt + mod) % mod;
cout << cnt << "\n";
aryanc403();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace lgr {
short factor[1000010];
long long P[1000010], S[1000010], ar[1000010], inv[1000010];
inline long long expo(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (long long)res * a % 1000000007;
a = (long long)a * a % 1000000007;
b >>= 1;
}
return res;
}
long long lagrange(long long n, long long k) {
if (!k) return (n % 1000000007);
long long i, j, x, res = 0;
if (!inv[0]) {
for (i = 2, x = 1; i < 1000010; i++) x = (long long)x * i % 1000000007;
inv[1000010 - 1] = expo(x, 1000000007 - 2);
for (i = 1000010 - 2; i >= 0; i--)
inv[i] = ((long long)inv[i + 1] * (i + 1)) % 1000000007;
}
k++;
for (i = 0; i <= k; i++) factor[i] = 0;
for (i = 4; i <= k; i += 2) factor[i] = 2;
for (i = 3; (i * i) <= k; i += 2) {
if (!factor[i]) {
for (j = (i * i), x = i << 1; j <= k; j += x) {
factor[j] = i;
}
}
}
for (ar[1] = 1, ar[0] = 0, i = 2; i <= k; i++) {
if (!factor[i])
ar[i] = expo(i, k - 1);
else
ar[i] = ((long long)ar[factor[i]] * ar[i / factor[i]]) % 1000000007;
}
for (i = 1; i <= k; i++) {
ar[i] += ar[i - 1];
if (ar[i] >= 1000000007) ar[i] -= 1000000007;
}
if (n <= k) return ar[n];
P[0] = 1, S[k] = 1;
for (i = 1; i <= k; i++)
P[i] = ((long long)P[i - 1] * ((n - i + 1) % 1000000007)) % 1000000007;
for (i = k - 1; i >= 0; i--)
S[i] = ((long long)S[i + 1] * ((n - i - 1) % 1000000007)) % 1000000007;
for (i = 0; i <= k; i++) {
x = (long long)ar[i] * P[i] % 1000000007 * S[i] % 1000000007 * inv[k - i] %
1000000007 * inv[i] % 1000000007;
if ((k - i) & 1) {
res -= x;
if (res < 0) res += 1000000007;
} else {
res += x;
if (res >= 1000000007) res -= 1000000007;
}
}
return (res % 1000000007);
}
} // namespace lgr
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
cout << lgr::lagrange(n, k) << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
long long a[300001];
long long n, m, k;
int b[300001];
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
a[x]++;
b[a[x]] += a[x];
k = (b[a[x]] >= i && b[a[x]] != n) ? b[a[x]] : k;
}
cout << k + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s[10];
int a, b;
void setup() { cin >> a; }
void init() {}
void work() { cout << 1ll * (a - 2) * (a - 2); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
setup();
work();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, A[100001], m, x, y;
long long int Vasya(0), Petya(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
A[x] = i;
}
cin >> m;
while (m--) {
cin >> y;
Vasya = Vasya + A[y];
Petya = Petya + (n + 1 - A[y]);
}
cout << Vasya << " " << Petya << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAX = 1000002;
int n, k;
int a[1002];
int dp[MAX];
void solve() {
for (int i = 0; i < MAX; ++i) dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < MAX; ++i) {
if (dp[i] == INF) continue;
for (int j = 1; j < 1000; ++j) {
if (!a[j]) continue;
if (dp[j + i] > dp[i] + 1) dp[j + i] = dp[i] + 1;
}
}
}
int main() {
scanf("%d %d", &n, &k);
set<int> s;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
s.insert(x);
}
int minval = *s.begin();
for (auto it : s) a[it - minval] = true;
solve();
for (int i = 0; i < MAX; ++i)
if (dp[i] <= k) printf("%d ", i + minval * k);
}
| 8 |
#include <bits/stdc++.h>
const long double EPS = 1e-10;
const long long int MOD = 1000000007ll;
const long long int mod1 = 1000000009ll;
const long long int mod2 = 1100000009ll;
int INF = 2147483645;
long long int INFINF = 9223372036854775807;
int debug = 0;
using namespace std;
void print(int a[], int s, int e) {
for (int i = s; i <= e; i++) cout << a[i] << " ";
cout << "\n";
}
void print(vector<int> &v, int s, int e) {
for (int i = s; i <= e; i++) cout << v[i] << " ";
cout << "\n";
}
void print(vector<int> &v) {
for (int x : v) cout << x << " ";
cout << "\n";
}
long long int bit_count(long long int _x) {
long long int _ret = 0;
while (_x) {
if (_x % 2 == 1) _ret++;
_x /= 2;
}
return _ret;
}
long long int bit(long long int _mask, long long int _i) {
return (_mask & (1 << _i)) == 0 ? 0 : 1;
}
long long int powermod(long long int _a, long long int _b, long long int _m) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a) % _m;
_b /= 2;
_a = (_a * _a) % _m;
}
return _r;
}
long long int add(long long int a, long long int b, long long int m = MOD) {
long long int x = a + b;
while (x >= m) x -= m;
return x;
}
long long int sub(long long int a, long long int b, long long int m = MOD) {
long long int x = a - b;
while (x < 0) x += m;
return x;
}
long long int mul(long long int a, long long int b, long long int m = MOD) {
long long int x = a * b;
x %= m;
return x;
}
long long int M;
long long int Cube[100010];
vector<int> v;
bool check() {
long long int sum = 0;
for (long long int x : v) {
sum += Cube[x];
if (sum >= Cube[x + 1]) return false;
}
return sum <= M;
}
int main() {
srand(time(NULL));
cin >> M;
for (long long int i = 1; i <= 100000; i++) Cube[i] = i * i * i;
long long int sum = 0;
long long int cur = 1;
long long int ans = 0;
while (sum <= M) {
while (sum + Cube[cur] >= Cube[cur + 1]) {
cur++;
if (sum + Cube[cur] > M) break;
}
if (sum + Cube[cur] > M) break;
v.push_back(cur);
sum += Cube[cur];
ans++;
}
for (int i = v.size() - 1; i >= 0; i--) {
while (check()) v[i]++;
v[i]--;
}
sum = 0;
for (int x : v) sum += Cube[x];
cout << ans << " " << sum;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 0, k = 0, a;
cin >> n;
int b[n];
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) s += b[i];
int q = 0, s2;
if (s % 2 == 0)
s2 = s / 2;
else
s2 = s / 2 + 1;
for (int i = 0; i < n; i++) {
k += b[i];
q++;
if (k >= s2) break;
}
cout << q;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
int n = s.size();
auto check = [s](const int &i) { return s[i - 1] == '0'; };
vector<vector<int> *> res[2];
for (int i = 1; i <= n; i++) {
auto &c = s[i - 1];
if (c == '1') {
if (res[0].empty()) return puts("-1"), 0;
auto ptr = res[0].back();
res[0].pop_back();
(*ptr).push_back(i);
res[1].push_back(ptr);
} else {
if (res[1].size()) {
auto ptr = res[1].back();
res[1].pop_back();
(*ptr).push_back(i);
res[0].push_back(ptr);
} else {
auto ptr = new vector<int>(1, i);
res[0].push_back(ptr);
}
}
}
if (res[1].size()) return puts("-1"), 0;
printf("%d\n", res[0].size());
for (auto &v : res[0]) {
printf("%d", v->size());
for (auto &x : *v) printf(" %d", x);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const unsigned long long mxx = 1333331;
int a[2100];
int sum1[2100];
int sum2[2100];
int dp[2100][2100][2];
int main() {
int n;
cin >> n;
int ans = -INF;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum1[i] += sum1[i - 1] + (a[i] == 1);
}
for (int i = n; i >= 1; i--) {
sum2[i] += sum2[i + 1] + (a[i] == 2);
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
dp[i][j][0] = dp[i][j - 1][0] + (a[j] == 2);
dp[i][j][1] = max(dp[i][j - 1][0], dp[i][j - 1][1]) + (a[j] == 1);
ans = max(ans, dp[i][j][0] + sum1[i - 1] + sum2[j + 1]);
ans = max(ans, dp[i][j][1] + sum1[i - 1] + sum2[j + 1]);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cout << ']' << '\n'; }
template <typename T, typename... R>
void debug_out(const T &ff, const R &...rr) {
cout << ff;
if (sizeof...(R)) {
cout << ", ";
}
debug_out(rr...);
}
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
int mpow(int base, int exp);
template <class T>
T npow(T base, T exp);
const int mod = 1e9 + 7;
const int N = 3e5, M = N;
void Solve_main() {
int n, m, k;
int i, j;
cin >> n >> k;
vector<pair<int, int> > v(n);
for (i = (0); i < (n); ++i) {
cin >> m;
v[i] = {m, i};
}
sort((v).begin(), (v).end());
vector<int> res(n);
vector<bool> flag(n, true);
for (i = (0); i < (n); ++i) {
if (!flag[i]) {
continue;
}
res[v[i].second] = 1;
flag[i] = false;
m = k - v[i].first;
pair<int, int> p = {m, -1};
auto it = lower_bound(v.begin() + i + 1, v.end(), p);
if (it != v.end()) {
j = it - v.begin();
if (v[i].first == m) {
if (v[j].first == m) {
flag[j] = false;
res[v[j].second] = 0;
}
continue;
}
while (j < n && flag[j] && v[j].first == m) {
flag[j] = false;
res[v[j].second] = 0;
j++;
}
}
}
for (i = 0; i < ((int)(res).size()); i++) {
cout << res[i] << " ";
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int tc = 1;
cin >> tc;
while (tc--) {
Solve_main();
}
cerr << "[time:" << 1.0 * clock() / CLOCKS_PER_SEC << "s] ";
return 0;
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % mod;
base = ((long long)base * base) % mod;
exp >>= 1;
}
return result;
}
template <class T>
T npow(T base, T exp) {
T result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base);
base = (base * base);
exp >>= 1;
}
return result;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long powm(long long base, long long exp, long long mod = 1000000007) {
long long ans = 1;
while (exp) {
if (exp & 1) ans = (ans * base) % mod;
exp >>= 1, base = (base * base) % mod;
}
return ans;
}
long long ctl(char x, char an = 'a') { return (long long)(x - an); }
char ltc(long long x, char an = 'a') { return (char)(x + an); }
bool a[4195305], vis1[4195305], vis2[4195305];
int badawala, k;
void dfs2(int x);
void dfs1(int x) {
if (vis1[x]) return;
vis1[x] = 1;
dfs2(badawala - 1 - x);
}
void dfs2(int x) {
if (vis2[x]) return;
vis2[x] = 1;
for (int i = 0; i < k; i++)
if ((x >> i) & 1) dfs2(x ^ (1 << i));
if (a[x]) dfs1(x);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int x, n, m;
cin >> k >> n;
for (int i = 1; i < n + 1; i++) {
cin >> x;
a[x] = 1;
}
int ans = 0;
badawala = (1 << k);
for (int i = 0; i < badawala; i++)
if (a[i] and !vis1[i]) dfs1(i), ans++;
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int h[N];
int main() {
int n, e, ans, i, t;
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n + 2; i++) h[i] = 0;
for (i = 1; i <= n; ++i) scanf("%d", &h[i]);
ans = 0;
for (i = e = 0; i < n; ++i) {
if (h[i] + e < h[i + 1]) {
t = (h[i + 1] - e - h[i]);
h[i] += t;
ans += t;
}
e += (h[i] - h[i + 1]);
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long rd() {
long long data = 0, w = 1;
char ch = 0;
while (ch != '-' && (ch > '9' || ch < '0')) ch = getchar();
(ch == '-') && (w = -1, ch = getchar());
while (ch >= '0' && ch <= '9') {
data = data * 10 + ch - '0';
ch = getchar();
}
return data * w;
}
void P(long long v) {
if (v < 0) {
putchar('-');
v = -v;
}
if (v > 9) P(v / 10);
putchar(v % 10 + '0');
}
struct E {
long long v, n;
E(long long a = 0, long long b = 0) : v(a), n(b) {}
} e[400010];
long long n, h[400010], c, dt, q, u, v, K, fl;
long long dfn[400010], dep[400010], F[400010], sz[400010], x[400010];
void ad(long long u, long long v) {
e[++c] = E(v, h[u]);
h[u] = c;
}
void df(long long u, long long f) {
F[u] = f;
dep[u] = dep[f] + 1;
dfn[u] = ++dt;
sz[u] = 1;
for (long long i = h[u]; i; i = e[i].n) {
long long v = e[i].v;
if (v == f) continue;
df(v, u);
sz[u] += sz[v];
}
}
signed main() {
n = rd();
q = rd();
for (long long i = (2); i <= (n); i++) {
u = rd();
v = rd();
ad(u, v);
ad(v, u);
}
df(1, 0);
F[1] = 1;
for (long long i = (1); i <= (q); i++) {
K = rd();
for (long long k = (1); k <= (K); k++) x[k] = F[rd()];
std::sort(x + 1, x + K + 1,
[](long long a, long long b) -> bool { return dep[a] < dep[b]; });
fl = 0;
for (long long k = (1); k <= (K - 1); k++) {
if (x[k] == x[k + 1]) continue;
if (dfn[x[k]] < dfn[x[k + 1]] && dfn[x[k + 1]] < dfn[x[k]] + sz[x[k]] - 1)
;
else {
fl = 1;
break;
}
}
puts(!fl ? "YES" : "NO");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& in, vector<T>& v) {
for (int i = (0); i < int(v.size()); ++i) in >> v[i];
return in;
}
template <typename A, typename B>
istream& operator>>(istream& in, pair<A, B>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& v) {
if (v.size()) out << v[0];
for (int i = (1); i < int(v.size()); ++i) out << ' ' << v[i];
return out;
}
template <typename A, typename B>
ostream& operator<<(ostream& out, pair<A, B>& p) {
out << p.first << ' ' << p.second;
return out;
}
void solve() {
map<char, int> v;
v['>'] = 8;
v['<'] = 8 + 1;
v['+'] = 8 + 2;
v['-'] = 8 + 2 + 1;
v['.'] = 8 + 4;
v[','] = 8 + 4 + 1;
v['['] = 8 + 4 + 2;
v[']'] = 8 + 4 + 2 + 1;
int x = 0;
string s;
cin >> s;
for (int i = (0); i < int(s.size()); ++i) {
x = 16 * x + v[s[i]];
x %= 1000003;
}
cout << x << endl;
}
int main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(false);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void print(vector<long long> ar) {
for (long long i = 0; i < ar.size(); i++) cout << ar[i] << " ";
cout << "\n";
}
void rprint(vector<long long> ar) {
for (long long i = ar.size() - 1; i >= 0; i--) cout << ar[i] << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
long long x, y;
cin >> x >> y;
if (x == 1) {
if (y == 1)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
} else if (x == 2 || x == 3) {
if (y == 1 || y == 2 || y == 3)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
} else {
cout << "YES"
<< "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10;
const int inf = 1e8;
int a[N], b[N];
int main() {
int n, m;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (int i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (abs(a[i] - b[j]) <= 1) {
ans++;
b[j] = inf;
break;
}
}
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[5010];
int main() {
int n, mx = 0, c = 0, t = 0, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
arr[i] = arr[i - 1] + x;
for (int j = 0; j < i - mx; j++)
if (arr[i] - arr[j] > (i - j) * 100) {
mx = i - j;
break;
}
}
cout << mx;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p1, p2;
int r1, r2, R1, R2, ans;
int main() {
cin >> p1.first >> p1.second >> r1 >> R1;
cin >> p2.first >> p2.second >> r2 >> R2;
double dis = sqrt((p1.first - p2.first) * (p1.first - p2.first) +
(p1.second - p2.second) * (p1.second - p2.second));
if (r1 + R2 <= dis || r2 - r1 >= dis || r1 - R2 >= dis) ans++;
if (R1 + R2 <= dis || r2 - R1 >= dis || R1 - R2 >= dis) ans++;
if (R1 + r2 <= dis || r1 - r2 >= dis || r2 - R1 >= dis) ans++;
if (R1 + R2 <= dis || r1 - R2 >= dis || R2 - R1 >= dis) ans++;
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2050, MOD = 1073741824;
int mu[Maxn], prime[Maxn], tot, g[Maxn][Maxn];
bool vis[Maxn];
void Getmu() {
mu[1] = 1;
for (int i = 2; i < Maxn; ++i) {
if (!vis[i]) {
prime[++tot] = i;
mu[i] = -1;
}
for (int j = 1; i * prime[j] < Maxn && j <= tot; ++j) {
vis[i * prime[j]] = 1;
if (i % prime[j] == 0) {
mu[i * prime[j]] = 0;
break;
}
mu[i * prime[j]] = -mu[i];
}
}
}
int gcd(int x, int y) { return x == 0 ? y : gcd(y % x, x); }
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
Getmu();
for (int i = 1; i < Maxn; ++i)
for (int j = 1; j <= i; ++j) g[i][j] = g[j][i] = gcd(i, j);
long long ans = 0;
for (int i = 1; i <= a; ++i) {
for (int d = 1; d <= min(b, c); ++d)
if (g[i][d] == 1) {
long long res1 = 0, res2 = 0;
for (int j = d; j <= b; j += d)
if (g[i][j] == 1) {
res1 += b / j;
}
for (int k = d; k <= c; k += d)
if (g[i][k] == 1) {
res2 += c / k;
}
ans = (ans + 1ll * mu[d] * (a / i) * res1 * res2 % MOD) % MOD;
}
}
printf("%lld\n", (ans + MOD) % MOD);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
vector<int> vec(x);
for (int &i : vec) cin >> i;
map<int, int> mp;
int sum = 0, cnt = 0, l = 0, r = 0, ll = 0, rr = 0;
for (int i = 0; i < x; i++) {
mp[vec[i]]++;
if (mp.size() <= y)
l++;
else {
if (l - r > ll - rr) {
rr = r;
ll = l;
}
for (; mp[vec[r]] > 1; r++) {
mp[vec[r]]--;
}
mp.erase(vec[r]);
if (r > l)
r--;
else if (l > r)
r++;
l++;
}
}
if (l - r > ll - rr) {
rr = r;
ll = l;
}
cout << rr + 1 << " " << ll << endl;
cout << endl;
}
| 4 |
#include <iostream>
using namespace std;
int a[51];
int main()
{
int t,n,i,j,minim,maxim,aux,cnt;
cin>>t;
for(i=1;i<=t;++i)
{
cin>>n;
cnt=0;
for(j=1;j<=n;++j)
{
cin>>a[j];
}
for(j=1;j<=n-1;j++)
{
minim=a[j];
maxim=a[j+1];
if(minim>maxim)
{
swap(maxim,minim);
}
while(maxim>2*minim)
{
minim*=2;
cnt++;
}
}
cout<<cnt<<'\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int S = 8;
long long pow_mod(long long a, long long n, long long mod) {
long long ret = 1;
long long temp = a % mod;
while (n) {
if (n & 1) ret = ret * temp % mod;
temp = temp * temp % mod;
n >>= 1;
}
return ret;
}
bool check(long long a, long long n, long long x, long long t) {
long long ret = pow_mod(a, x, n);
long long last = ret;
for (int i = 1; i <= t; i++) {
ret = ret * ret % n;
if (ret == 1 && last != 1 && last != n - 1) return true;
last = ret;
}
if (ret != 1)
return true;
else
return false;
}
bool Miller_Rabin(long long n) {
if (n < 2) return false;
if (n == 2) return true;
if ((n & 1) == 0) return false;
long long x = n - 1;
long long t = 0;
while ((x & 1) == 0) {
x >>= 1;
t++;
}
for (int i = 0; i < S; i++) {
long long a = rand() % (n - 1) + 1;
if (check(a, n, x, t)) return false;
}
return true;
}
long long getPrePrime(long long n) {
while (n) {
if (Miller_Rabin(n)) return n;
n--;
}
return 0;
}
int main() {
srand(time(NULL));
long long n;
cin >> n;
if (Miller_Rabin(n))
printf("1");
else if ((n & 1) == 0)
printf("2");
else if (Miller_Rabin(n - 2))
printf("2");
else
printf("3");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const long long inf = 1e9 + 7;
long long mod = 998244353;
char s[maxn], t[maxn];
int main(void) {
scanf("%s%s", s, t);
int n1 = strlen(s), n2 = strlen(t);
int ans = n1 + n2, i, j;
for (i = n1 - 1, j = n2 - 1; i >= 0 && j >= 0; i--, j--) {
if (s[i] == t[j])
ans -= 2;
else
break;
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, nxt, c;
} e[1500005];
int p[53005], eid, pp[53005];
void init() {
memset(p, -1, sizeof p);
eid = 0;
}
void insert(int u, int v, int c) {
e[eid].v = v;
e[eid].c = c;
e[eid].nxt = p[u];
p[u] = eid++;
}
void add(int u, int v, int c) {
insert(u, v, c);
insert(v, u, 0);
}
int d[53005], S, T, n, m, b, k, a[53005], g;
queue<int> q;
int bfs() {
for (int i = 1; i <= T + 5; i++) pp[i] = p[i], d[i] = -1;
d[S] = 0;
q.push(S);
while (q.size()) {
int u = q.front();
q.pop();
for (int i = p[u]; i + 1; i = e[i].nxt) {
int v = e[i].v, c = e[i].c;
if (d[v] == -1 && c) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
return d[T] != -1;
}
int dfs(int u, int flow) {
if (u == T) return flow;
int ret = 0;
for (int &i = pp[u]; i + 1; i = e[i].nxt) {
int v = e[i].v, c = e[i].c;
if (c && d[v] == d[u] + 1) {
int tmp = dfs(v, min(flow, c));
e[i].c -= tmp, e[i ^ 1].c += tmp;
flow -= tmp, ret += tmp;
if (!flow) break;
}
}
if (!ret) d[u] = -1;
return ret;
}
int Dinic() {
int ret = 0;
for (; bfs();) ret += dfs(S, 23333333);
return ret;
}
int main() {
init();
scanf("%d%d%d", &n, &m, &g);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
S = n + m + 1, T = S + 1;
for (int i = 1; i <= n; i++) {
int x = 0;
scanf("%d", &x);
if (a[i])
add(i, T, x);
else
add(S, i, x);
}
int ans = 0;
for (int id = n + 1; id <= n + m; id++) {
int opt, w, gs;
scanf("%d%d%d", &opt, &w, &gs);
if (opt) {
for (int i = 1; i <= gs; i++) {
int x = 0;
scanf("%d", &x);
add(x, id, 23333333);
}
scanf("%d", &opt);
add(id, T, w + opt * g);
} else {
for (int i = 1; i <= gs; i++) {
int x = 0;
scanf("%d", &x);
add(id, x, 23333333);
}
scanf("%d", &opt);
add(S, id, w + opt * g);
}
ans += w;
}
printf("%d", ans - Dinic());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int s[t];
int sres[100];
int mayor = 100;
for (int i = 0; i < t; ++i) {
int sd;
cin >> sd;
s[i] = sd;
}
for (int i = 0; i < t; ++i) {
int d = s[i];
int cont = 0;
while (d > 7) {
cont += (d / 3);
d = d / 3;
}
cont++;
cout << cont << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 15005;
vector<int> g[N];
int deg[N];
bool cycle[N];
int par[N], sub[N];
vector<int> cycle_nodes;
long long dp[N];
int sz[N];
int n;
void find_cycle(int u, int p, int st) {
cycle_nodes.push_back(u);
for (int v : g[u]) {
if (v != p && cycle[v] && st != v) {
find_cycle(v, u, st);
break;
}
}
}
void dfs(int u, int p, vector<int> &nodes) {
par[u] = p;
sub[u] = 1;
nodes.push_back(u);
for (int v : g[u]) {
if (cycle[v] == 0 && v != p) {
dfs(v, u, nodes);
sub[u] += sub[v];
dp[u] += dp[v];
}
}
dp[u] += sub[u];
}
long long DP[N][2];
int SUM(int x, int y) {
if (x <= y) return sz[y] - (x > 0 ? sz[x - 1] : 0);
return sz[y] + n - sz[x - 1];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
x++, y++;
g[x].push_back(y);
g[y].push_back(x);
deg[x]++;
deg[y]++;
}
vector<int> leafs;
for (int i = 1; i <= n; i++) {
if (deg[i] == 1) leafs.push_back(i);
}
for (int i = 1; i <= n; i++) cycle[i] = 1;
while (leafs.size() > 0) {
int u = leafs.back();
cycle[u] = 0;
leafs.pop_back();
for (int v : g[u]) {
deg[v]--;
if (deg[v] == 1) leafs.push_back(v);
}
}
for (int i = 1; i <= n; i++) {
if (cycle[i]) {
find_cycle(i, -1, i);
break;
}
}
for (int i = 0; i < cycle_nodes.size(); i++) {
int u = cycle_nodes[i];
vector<int> nodes;
dfs(u, -1, nodes);
sz[i] = (int)nodes.size();
if (i > 0) sz[i] += sz[i - 1];
for (int cen : nodes) {
long long cur_pot = n;
int v = cen;
while (par[v] != -1) {
int p = par[v];
cur_pot += dp[p] - dp[v] - sub[v] + (n - sub[p]);
v = p;
}
DP[i][0] = max(DP[i][0], cur_pot);
}
}
int C = cycle_nodes.size();
long long ans = 0;
for (int d = 1; d < C; d++) {
int f = d & 1;
for (int i = 0; i < C; i++) {
int j = (i + d);
if (j >= C) j -= C;
int u = cycle_nodes[i], v = cycle_nodes[j];
int sum = SUM(i, j);
long long ans1 = DP[i == C - 1 ? 0 : i + 1][f ^ 1] + dp[u] + n - sum;
long long ans2 = DP[i][f ^ 1] + dp[v] + n - sum;
DP[i][f] = max(ans1, ans2);
ans = max(ans, DP[i][f]);
}
}
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
struct p {
long long pos;
bool j;
long long l;
long long r;
int num;
};
p r[200000];
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n + m; i++) cin >> r[i].pos;
for (int i = 0; i < n + m; i++) cin >> r[i].j;
int we = -1;
for (int i = 0; i < n + m; i++) {
if (r[i].j)
we = i;
else
r[i].l = we;
}
we = -1;
for (int i = n + m - 1; i >= 0; i--) {
if (r[i].j)
we = i;
else
r[i].r = we;
}
for (int i = n + m - 1; i >= 0; i--) {
long long ld, rd;
if (!r[i].j) {
ld = abs(r[r[i].l].pos - r[i].pos), rd = abs(r[i].pos - r[r[i].r].pos);
if (r[i].l == -1)
r[r[i].r].num++;
else if (r[i].r == -1)
r[r[i].l].num++;
else {
if (ld <= rd)
r[r[i].l].num++;
else
r[r[i].r].num++;
}
}
}
for (int i = 0; i < n + m; i++) {
if (r[i].j) cout << r[i].num << ' ';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void fact(int v, vector<int> &primes) {
for (int p = 2; p * p <= v; ++p)
if (v % p == 0) {
primes.push_back(p);
while (v % p == 0) v /= p;
}
if (v != 1) primes.push_back(v);
}
int main() {
int n, a, b;
scanf("%d %d %d", &n, &a, &b);
vector<int> val(n);
for (int i = 0; i < n; ++i) scanf("%d", &val[i]);
vector<int> cand;
for (int d = -1; d <= 1; ++d) {
fact(val[0] + d, cand);
fact(val[n - 1] + d, cand);
}
sort(cand.begin(), cand.end());
cand.resize(unique(cand.begin(), cand.end()) - cand.begin());
const long long BIG = 1000000000000000000LL;
vector<long long> cost(n), rightcostsum(n);
vector<long long> dp(n + 1);
long long result = BIG;
for (int p : cand) {
for (int i = 0; i < n; ++i)
if (val[i] % p == 0)
cost[i] = 0;
else if ((val[i] - 1) % p == 0)
cost[i] = b;
else if ((val[i] + 1) % p == 0)
cost[i] = b;
else
cost[i] = BIG;
rightcostsum[n - 1] = cost[n - 1];
for (int i = n - 2; i >= 0; --i)
rightcostsum[i] = min(BIG, rightcostsum[i + 1] + cost[i]);
dp[n] = 0;
for (int i = n - 1; i >= 0; --i) {
dp[i] = min(a + dp[i + 1], rightcostsum[i]);
}
result = min(result, dp[0]);
long long leftcostsum = 0;
for (int i = 0; i < n; ++i) {
leftcostsum = min(BIG, leftcostsum + cost[i]);
result = min(result, leftcostsum + dp[i + 1]);
}
}
cout << result << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2002;
bool isPal(string s) {
long long n = s.size();
for (long long i = 0; i < n / 2; ++i)
if (s[i] != s[n - i - 1]) return false;
return true;
}
string lcs(string s) {
long long n = s.size();
long long dp[n + 1][n + 1];
memset(dp, 0, sizeof dp);
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
if (s[i - 1] == s[n - j]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
string ans = "";
long long i = n, j = n;
while (i && j) {
if (s[i - 1] == s[n - j])
ans.push_back(s[i - 1]), --i, --j;
else if (dp[i - 1][j] > dp[i][j - 1])
--i;
else
--j;
}
if (ans.size() > 100) {
long long n = ans.size();
if (n & 1) ans.erase(ans.begin() + n / 2);
while (ans.size() > 100) {
ans.erase(ans.begin());
ans.pop_back();
}
}
return ans;
}
void solve() {
string s;
cin >> s;
string val = "";
string ans = "";
if (s.size() < 2600) ans = lcs(s);
vector<long long> fre(26);
for (char c : s) fre[c - 'a']++;
for (long long i = 0; i < 26; ++i)
if (fre[i] >= 100) val = string(100, i + 'a');
if (val.size() == 100) ans = val;
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int Tree[200005 * 4], Z[200005];
int X[200005], Y[200005], A[200005], B[200005];
void build(int node, int l, int r) {
if (l == r)
Tree[node] = 1;
else {
int MID = (l + r) >> 1;
build(node * 2, l, MID);
build(node * 2 + 1, MID + 1, r);
Tree[node] = Tree[node * 2] + Tree[node * 2 + 1];
}
}
int update(int node, int l, int r, int k) {
if (l == r) {
Tree[node] = 0;
return l;
}
int x, MID = (l + r) >> 1;
if (Tree[node * 2] > k)
x = update(node * 2, l, MID, k);
else
x = update(node * 2 + 1, MID + 1, r, k - Tree[node * 2]);
Tree[node] = Tree[node * 2] + Tree[node * 2 + 1];
return x;
}
int query(int node, int l, int r, int a, int b) {
if (l > r || a > r || b < l || a > b) return 0;
if (a <= l && b >= r) return Tree[node];
int MID = (l + r) >> 1;
int x = query(node * 2, l, MID, a, b) + query(node * 2 + 1, MID + 1, r, a, b);
Tree[node] = Tree[node * 2] + Tree[node * 2 + 1];
return x;
}
void f(int node, int l, int r, int x) {
if (x < l || x > r) return;
if (l == r && l == x) {
Tree[node] = 0;
return;
}
int MID = (l + r) >> 1;
if (x <= MID)
f(node * 2, l, MID, x);
else
f(node * 2 + 1, MID + 1, r, x);
Tree[node] = Tree[node * 2] + Tree[node * 2 + 1];
}
void H(int n) {
build(1, 0, n - 1);
for (int i = 0; i < n; i++) {
X[i] = query(1, 0, n - 1, 0, A[i]) - 1;
f(1, 0, n - 1, A[i]);
}
memset(Tree, 0, sizeof Tree);
build(1, 0, n - 1);
for (int i = 0; i < n; i++) {
Y[i] = query(1, 0, n - 1, 0, B[i]) - 1;
f(1, 0, n - 1, B[i]);
}
memset(Tree, 0, sizeof Tree);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < n; i++) cin >> B[i];
H(n);
int carry = 0;
for (int i = n - 1; i >= 0; i--) {
Z[i] = (X[i] + Y[i] + carry) % (n - i);
carry = (X[i] + Y[i] + carry) / (n - i);
}
build(1, 0, n - 1);
for (int i = 0; i < n; i++) {
int x = update(1, 0, n - 1, Z[i]);
cout << x << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 5;
const int INF = 0x3f3f3f3f;
struct SNode {
int r, id;
SNode() {}
SNode(int r, int id) : r(r), id(id) {}
bool operator<(const SNode& e) const { return r > e.r; }
};
int N;
vector<string> Ans;
multiset<SNode> S;
int main() {
ios::sync_with_stdio(false);
S.clear();
Ans.clear();
cin >> N;
for (int i = 0, r; i < N; i++) {
cin >> r;
S.insert(SNode(r, i));
}
while (S.begin()->r != S.rbegin()->r) {
int sz = S.size(), num = 2;
if (S.count(*S.begin()) == 3) num++;
string buf(N, '0');
vector<SNode> ar(num);
for (int i = 0; i < num; i++) {
SNode p = *S.begin();
S.erase(S.begin());
buf[p.id] = '1';
p.r = max(p.r - 1, 0);
ar[i] = p;
}
S.insert(ar.begin(), ar.end());
Ans.push_back(buf);
}
cout << S.begin()->r << "\n" << Ans.size() << "\n";
copy(Ans.begin(), Ans.end(), ostream_iterator<string>(cout, "\n"));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 123, inf = 1e9, mod = 1e9 + 7;
const double eps = 1e-9;
struct pt {
int x, y;
};
bool cmp(pt a, pt b) { return a.x < b.x || a.x == b.x && a.y < b.y; }
bool cw(pt a, pt b, pt c) {
return 1ll * a.x * (b.y - c.y) + 1ll * b.x * (c.y - a.y) +
1ll * c.x * (a.y - b.y) <
0;
}
bool ccw(pt a, pt b, pt c) {
return 1ll * a.x * (b.y - c.y) + 1ll * b.x * (c.y - a.y) +
1ll * c.x * (a.y - b.y) >
0;
}
void convex_hull(vector<pt>& a) {
if (a.size() == 1) return;
sort(a.begin(), a.end(), &cmp);
pt p1 = a[0], p2 = a.back();
vector<pt> up, down;
up.push_back(p1);
down.push_back(p1);
for (size_t i = 1; i < a.size(); ++i) {
if (i == a.size() - 1 || cw(p1, a[i], p2)) {
while (up.size() >= 2 && !cw(up[up.size() - 2], up[up.size() - 1], a[i]))
up.pop_back();
up.push_back(a[i]);
}
if (i == a.size() - 1 || ccw(p1, a[i], p2)) {
while (down.size() >= 2 &&
!ccw(down[down.size() - 2], down[down.size() - 1], a[i]))
down.pop_back();
down.push_back(a[i]);
}
}
a.clear();
for (size_t i = 0; i < up.size(); ++i) a.push_back(up[i]);
for (size_t i = down.size() - 2; i > 0; --i) a.push_back(down[i]);
}
long long dis(pt a, pt b) {
return 1ll * (a.x - b.x) * (a.x - b.x) + 1ll * (a.y - b.y) * (a.y - b.y);
}
pair<double, double> get(pt q, pt w, pt e) {
long long a, b, c;
a = dis(q, w);
b = dis(q, e);
c = dis(w, e);
return {1.0 * (a + b - c) / (2 * sqrtl(a) * sqrtl(b)), sqrtl(a)};
}
vector<int> z_function(vector<pair<double, double> > second) {
int n = (int)second.size();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n &&
fabs(second[z[i]].first - second[i + z[i]].first) < eps &&
fabs(second[z[i]].second - second[i + z[i]].second) < eps)
++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<pt> a, b;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a.push_back({x, y});
}
convex_hull(a);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
b.push_back({x, y});
}
convex_hull(b);
if (a.size() != b.size()) {
puts("NO");
return 0;
}
vector<pair<double, double> > second, t;
for (int i = 0; i < a.size(); i++)
second.push_back(
get(a[i], a[(i - 1 + a.size()) % a.size()], a[(i + 1) % a.size()]));
for (int i = 0; i < b.size(); i++)
t.push_back(
get(b[i], b[(i - 1 + b.size()) % b.size()], b[(i + 1) % b.size()]));
t.push_back({-1e9, -1e9});
for (int i = 0; i < a.size(); i++) t.push_back(second[i]);
for (int i = 0; i < a.size(); i++) t.push_back(second[i]);
vector<int> z = z_function(t);
int good = 0;
for (int i = 0; i < z.size(); i++)
if (z[i] >= b.size()) good++;
if (good <= 0)
puts("NO");
else
puts("YES");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 520;
const int M = 998244353;
int n, k, dp[N * N], dpp[N * N], ans;
inline int f(int n, int maxw) {
int dp[N];
dp[0] = 1;
int cur = 1, sum = 1;
for (int i = 1; i <= n; i++) {
dp[i] = sum;
sum += dp[i];
if (sum >= M) sum -= M;
if (cur == maxw) {
sum -= dp[i - maxw];
if (sum < 0) sum += M;
} else
cur++;
}
return dp[n];
}
int32_t main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) dp[i] = f(n, i);
for (int i = k; i >= 1; i--) {
dpp[i] = dp[i] - dp[i - 1];
if (dpp[i] < 0) dpp[i] += M;
}
for (int i = 1; i < k; i++) {
int ub = k / i;
if (ub * i == k) ub--;
ans = (ans + (1ll * dpp[i] * 1ll * dp[ub]) % M) % M;
}
printf("%d\n", (ans + ans) % M);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void swap(char *a, char *b) {
char t = *a;
*a = *b;
*b = t;
}
signed main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
int n, t;
cin >> n >> t;
string s;
cin >> s;
for (int j = 0; j < t; j++) {
for (int i = 0; i < n; i++) {
if (s[i] == 'B' && s[i + 1] == 'G') {
swap(&s[i], &s[i + 1]);
i++;
}
}
}
cout << s << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int solve() {
int n;
long long w;
cin >> n >> w;
long long m = (w + 1) / 2;
vector<int> a(n), p;
vector<pair<int, int>> v;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] <= w) {
v.emplace_back(a[i], i);
}
}
long long ans = 0;
sort(v.begin(), v.end());
while (!v.empty() && ans < m) {
ans += v.back().first;
p.push_back(v.back().second);
v.pop_back();
}
if (ans < m) return cout << "-1\n", 0;
cout << p.size() << "\n";
for (int i : p) cout << i + 1 << " ";
cout << "\n";
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string a;
char o = 'a';
int p = 0;
for (int i = 0; i < n; i++) {
a += o + p;
if (p < k - 1)
p++;
else
p = 0;
}
cout << a;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool prime[1000000 + 1];
void seive() {
long long int N = 1e6 + 1;
memset(prime, true, sizeof(prime));
prime[0] = false;
prime[1] = false;
for (long long int i = 2; i * i <= N; i++) {
if (prime[i]) {
for (long long int j = i * i; j <= N; j += i) {
prime[j] = false;
}
}
}
}
bool isPowerOfTwo(int x) { return (x && !(x & (x - 1))); }
bool is_prime(int n) {
if (n == 1) return false;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
void hemant() {
long long int n, m;
cin >> n;
long long int lx = 1000000000000000003, ly = 1000000000000000003;
long long int rx = -1000000000000000003, ry = -1000000000000000003;
while (n--) {
long long int x, y;
cin >> x >> y;
lx = ((x > lx) ? lx : x);
ly = ((y > ly) ? ly : y);
rx = (x < rx ? rx : x);
ry = (y < ry ? ry : y);
}
long long int s = (abs(lx - rx) < abs(ry - ly) ? abs(ry - ly) : abs(lx - rx));
cout << s * s << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
hemant();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v;
int n, p[10001], res;
bool used[10001];
void dfs(int x) {
used[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
if (!used[v[x][i]]) dfs(v[x][i]);
}
}
int main() {
cin >> n;
v.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> p[i];
v[i].push_back(p[i]);
v[p[i]].push_back(i);
}
for (int i = 1; i <= n; i++)
if (!used[i]) {
res++;
dfs(i);
}
cout << res << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
const int MOD = 1000000007;
struct Mint {
int val;
Mint(long long v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = v;
}
static int mod_inv(int a, int m = MOD) {
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
Mint &operator+=(const Mint &other) {
val += other.val;
if (val >= MOD) val -= MOD;
return *this;
}
Mint &operator-=(const Mint &other) {
val -= other.val;
if (val < 0) val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
return x % m;
unsigned x_high = x >> 32, x_low = (unsigned)x;
unsigned quot, rem;
asm("divl %4\n" : "=a"(quot), "=d"(rem) : "d"(x_high), "a"(x_low), "r"(m));
return rem;
}
Mint &operator*=(const Mint &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
Mint &operator/=(const Mint &other) { return *this *= other.inv(); }
friend Mint operator+(const Mint &a, const Mint &b) { return Mint(a) += b; }
friend Mint operator-(const Mint &a, const Mint &b) { return Mint(a) -= b; }
friend Mint operator*(const Mint &a, const Mint &b) { return Mint(a) *= b; }
friend Mint operator/(const Mint &a, const Mint &b) { return Mint(a) /= b; }
Mint &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
Mint &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
Mint operator++(int32_t) {
Mint before = *this;
++*this;
return before;
}
Mint operator--(int32_t) {
Mint before = *this;
--*this;
return before;
}
Mint operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const Mint &other) const { return val == other.val; }
bool operator!=(const Mint &other) const { return val != other.val; }
Mint inv() const { return mod_inv(val); }
Mint power(long long p) const {
assert(p >= 0);
Mint a = *this, result = 1;
while (p > 0) {
if (p & 1) result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &stream, const Mint &m) {
return stream << m.val;
}
friend istream &operator>>(istream &stream, Mint &m) {
return stream >> m.val;
}
};
int _runtimeTerror_() {
int n, m;
cin >> n >> m;
Mint ans = 0;
for (int i = 1; i <= n; ++i) {
ans += m * Mint(2 * m - 1).power(i - 1) * Mint(m).power(n - i);
}
ans += Mint(m).power(n);
cout << ans << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline void splay(int &v) {
v = 0;
char c = 0;
int p = 1;
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
v = (v << 3) + (v << 1) + c - '0';
c = getchar();
}
v *= p;
}
const int N = 100010;
int n, a[N], b[N], dp[5], v[N], ans;
int main() {
splay(n);
for (int i = 1; i <= n; i++) {
splay(v[i]);
}
for (int i = 1; i <= n; i++) {
a[i] = a[i - 1] + (v[i] == 1);
}
for (int i = n; i >= 1; i--) {
b[i] = b[i + 1] + (v[i] == 2);
}
for (int l = 1; l <= n; l++) {
int now = 0;
dp[1] = dp[2] = 0;
for (int r = l; r <= n; r++) {
if (v[r] == 1) {
dp[1] = max(dp[1], dp[2]) + 1;
} else {
dp[2] = dp[2] + 1;
}
ans = max(ans, a[l - 1] + b[r + 1] + max(dp[1], dp[2]));
if (l == 2) {
int tr = 1;
}
}
}
cout << ans << endl;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.