solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[222222];
double f(double x) {
double cur_sum = 0;
double min_sum = 0;
double max_sum = 0;
double ans = 0;
for (int i = 0; i < n; ++i) {
cur_sum += a[i] - x;
ans = max(ans, fabs(cur_sum - min_sum));
ans = max(ans, fabs(cur_sum - max_sum));
min_sum = min(min_sum, cur_sum);
max_sum = max(max_sum, cur_sum);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
double l = -1e9, r = 1e9;
for (int i = 0; i < 500; ++i) {
double m1 = l + (r - l) / 3.0;
double m2 = r - (r - l) / 3.0;
if (f(m1) > f(m2))
l = m1;
else
r = m2;
}
cout.precision(10);
cout << fixed << f(l) << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long seg[200000 * 4];
long long lazy[200000 * 4];
int v[200001];
int n, q;
void B(int n, int s, int e) {
if (s == e)
seg[n] = v[s];
else {
int mid = s + e;
mid /= 2;
B(n * 2, s, mid);
B(n * 2 + 1, mid + 1, e);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
}
}
void update(int n, int s, int e, int l, int r, int v) {
if (lazy[n] != 0) {
seg[n] += lazy[n];
if (s != e) lazy[n * 2] += lazy[n], lazy[n * 2 + 1] += lazy[n];
lazy[n] = 0;
}
if (r < s || l > e) return;
if (l <= s && e <= r) {
seg[n] += (long long)v;
if (s != e) lazy[n * 2] += (long long)v, lazy[n * 2 + 1] += (long long)v;
return;
}
int mid = s + e;
mid /= 2;
update(n * 2, s, mid, l, r, v);
update(n * 2 + 1, mid + 1, e, l, r, v);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
}
long long query(int n, int s, int e, int l, int r) {
if (lazy[n] != 0) {
seg[n] += lazy[n];
if (s != e) lazy[n * 2] += lazy[n], lazy[n * 2 + 1] += lazy[n];
lazy[n] = 0;
}
if (s > r || e < l) return 1e18;
if (l <= s && r >= e) return seg[n];
int mid = s + e;
mid /= 2;
return min(query(n * 2, s, mid, l, r), query(n * 2 + 1, mid + 1, e, l, r));
}
vector<int> get(string line) {
string tmp;
vector<int> v;
for (int i = 0; i < line.size(); i++) {
if (line[i] == ' ') {
int d = 0;
for (int i = 0; i < tmp.size(); ++i) d = d * 10 + (tmp[i] - '0');
v.push_back(d);
tmp = "";
} else {
tmp += line[i];
}
}
int p = 1;
int d = 0;
for (int i = 0; i < tmp.size(); ++i)
if (tmp[i] == '-')
p = -1;
else
d = d * 10 + (tmp[i] - '0');
v.push_back(p * d);
return v;
}
int main() {
scanf("%d", &n);
memset(seg, 0, sizeof(seg));
memset(lazy, 0, sizeof(lazy));
for (int i = 0; i < n; ++i) scanf("%d", v + i);
B(1, 0, n - 1);
scanf("%d", &q);
cin.ignore();
while (q--) {
string line;
getline(cin, line);
vector<int> v = get(line);
int left = v[0];
int right = v[1];
if (v.size() == 3) {
long long val = v[2];
if (left <= right)
update(1, 0, n - 1, left, right, val);
else {
update(1, 0, n - 1, 0, right, val);
update(1, 0, n - 1, left, n - 1, val);
}
} else {
long long ans;
if (left <= right)
ans = query(1, 0, n - 1, left, right);
else
ans =
min(query(1, 0, n - 1, 0, right), query(1, 0, n - 1, left, n - 1));
printf("%I64d\n", ans);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 100000;
long double fct[MAXM + 5];
void init() {
for (int i = 1; i <= MAXM; i++) fct[i] = fct[i - 1] + log10(i);
}
long double comb(int n, int m) { return fct[n] - fct[m] - fct[n - m]; }
int main() {
init();
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
long double ans = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
int t = (i + j) * n - i * j;
if (k < t) continue;
long double d = comb(m - t, k - t) - comb(m, k) + comb(n, i) + comb(n, j);
ans += pow(10, d);
if (d > 99) {
printf("1e99");
return 0;
}
}
}
if (log10(ans) > 99)
printf("1e99");
else
cout << fixed << setprecision(9) << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimization("Ofast")
#pragma GCC optimization("unroll-loops")
#pragma GCC target("avx2,avx,fma")
inline long long int poww(long long int a, long long int b) {
long long int r = 1LL;
while (b > 0) {
if (b & 1) r = r * a;
b /= 2;
a = a * a;
}
return (int)r;
}
template <class T>
inline void sary(T st, T nd) {
while (st < nd) cin >> *st++;
}
int mod = 1e9 + 7;
inline long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
inline long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
inline long long int sub(long long int a, long long int b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
inline long long int divi(long long int a, long long int b) {
return (500000004 * (a % mod)) % mod;
}
const int N = 300001;
int n;
vector<int> a, b;
long long int dp[N][3];
long long calc(int u, int pr) {
if (u == n) return 0;
if (dp[u][pr] != -1) return dp[u][pr];
long long int res = LLONG_MAX;
for (int i = 0; i < 3; i++) {
if (u == 0 || a[u] + i != a[u - 1] + pr)
res = min(res, calc(u + 1, i) + (i * b[u]));
}
return dp[u][pr] = res;
}
void solve() {
cin >> n;
a.resize(n);
b.resize(n);
for (int i = 0; i <= n; ++i) dp[i][0] = dp[i][1] = dp[i][2] = -1;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
cout << calc(0, 0) << endl;
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 10;
int n;
vector<int> g[MAXN];
int c[MAXN];
void dfs(int u) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (c[v]) continue;
c[v] = 3 - c[u];
dfs(v);
}
}
struct node {
int a, b;
} p[MAXN];
int main() {
scanf("%d", &n);
n *= 2;
for (int i = 0; i < n / 2; i++) {
int a, b;
scanf("%d%d", &a, &b);
p[i] = (node){a, b};
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i < n; i += 2) {
g[i].push_back(i + 1);
g[i + 1].push_back(i);
}
for (int i = 1; i <= n; i++)
if (!c[i]) {
c[i] = 1;
dfs(i);
}
for (int i = 0; i < n / 2; i++) {
printf("%d %d\n", c[p[i].a], c[p[i].b]);
}
}
| 9 |
#include <bits/stdc++.h>
using std::memset;
using std::printf;
using std::scanf;
using llong = long long;
constexpr int maxn = 3000005;
int n;
llong cnt[maxn];
llong ans[maxn];
void used() {
for (int i = 1; i < maxn; ++i) {
if (!cnt[i]) continue;
for (int j = 1; j * i < maxn; ++j) {
if (i == j) {
ans[i * j] += cnt[i] * (cnt[i] - 1);
continue;
}
ans[i * j] += cnt[i] * cnt[j];
}
}
for (int i = 1; i < maxn; ++i) {
ans[i] += ans[i - 1];
}
}
int main() {
int m, tmp;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &tmp);
++cnt[tmp];
}
used();
scanf("%d", &m);
while (m--) {
scanf("%d", &tmp);
printf("%lld\n", static_cast<llong>(n) * (n - 1) - ans[tmp - 1]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, i;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, greater<int>());
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 9e4 + 5;
int cn = 0;
struct node {
int anss;
int l, r;
} nod[maxn];
int main() {
int n, m, a[350], vis[350][2];
scanf("%d%d", &n, &m);
int maxx = -0x3f3f3f3f, minn = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
maxx = max(maxx, a[i]);
minn = min(minn, a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &vis[i][0], &vis[i][1]);
}
int ans = maxx - minn;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int cnt = 0;
nod[++cn].l = i;
nod[cn].r = j;
for (int k = 1; k <= m; k++) {
if (i >= vis[k][0] && i <= vis[k][1]) continue;
if (j >= vis[k][0] && j <= vis[k][1]) cnt++;
}
ans = max(ans, a[i] - a[j] + cnt);
nod[cn].anss = cnt;
}
}
printf("%d\n", ans);
if (m == 0 || n == 1) {
printf("0\n");
return 0;
}
for (int i = 1; i <= cn; i++) {
if (nod[i].anss + a[nod[i].l] - a[nod[i].r] == ans) {
printf("%d\n", nod[i].anss);
int ii = nod[i].l;
int jj = nod[i].r;
int dis = 0;
for (int k = 1; k <= m; k++) {
if (ii >= vis[k][0] && ii <= vis[k][1]) continue;
if (!dis && jj >= vis[k][0] && jj <= vis[k][1]) {
printf("%d", k);
dis = 1;
} else if (jj >= vis[k][0] && jj <= vis[k][1])
printf(" %d", k);
}
break;
}
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
void err() { std::cout << '\n'; }
template <typename T, typename... Args>
void err(T a, Args... args) {
std::cout << a << ' ';
err(args...);
}
void pt() { std::cout << '\n'; }
template <typename T, typename... Args>
void pt(T a, Args... args) {
std::cout << a << ' ';
pt(args...);
}
using namespace std;
const int N = 3e5 + 5;
int n, k;
char s[N];
int bel[N][2];
int f[N + N], cnt[N + N];
int find(int x) { return f[x] == x ? f[x] : f[x] = find(f[x]); }
int calc(int x) {
int y = x + k;
int fx = find(x), fy = find(y);
if (fx == 0 || fy == 0) return cnt[fx + fy];
return min(cnt[fx], cnt[fy]);
}
void merge(int x, int y) {
int fx = find(x), fy = find(y);
if (fx == 0) swap(fx, fy);
f[fx] = fy;
if (fy != 0) cnt[fy] += cnt[fx];
}
void run() {
cin >> (s + 1);
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
for (int j = 1; j <= x; j++) {
int t;
cin >> t;
if (bel[t][0] == 0)
bel[t][0] = i;
else
bel[t][1] = i;
}
}
for (int i = 1; i <= k + k; i++) f[i] = i;
for (int i = 1; i <= k; i++) cnt[i] = 1;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (bel[i][1] == 0) {
int x = bel[i][0];
if (x) {
ans -= calc(x);
if (s[i] == '0') {
f[find(x + k)] = 0;
} else {
f[find(x)] = 0;
}
ans += calc(x);
}
} else {
int x = bel[i][0], y = bel[i][1];
if (s[i] == '0') {
if (find(x + k) != find(y)) {
ans -= calc(x) + calc(y);
merge(x + k, y);
merge(x, y + k);
ans += calc(x);
}
} else {
if (find(x) != find(y)) {
ans -= calc(x) + calc(y);
merge(x, y);
merge(x + k, y + k);
ans += calc(x);
}
}
}
cout << ans << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
while (cin >> n >> k) run();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[200010];
int main() {
int n, t = 1;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] >= t) t++;
}
cout << t - 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool del[300005];
int ans[100005], pos;
int main() {
int t, n, m, u, v;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
memset(del + 1, 0, 3 * n);
pos = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
if (!del[u] && !del[v] && pos < n) {
ans[++pos] = i;
del[u] = del[v] = true;
}
}
if (pos == n) {
puts("Matching");
for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], i == n ? '\n' : ' ');
} else {
puts("IndSet");
for (int i = 1, j = 0; j < n; ++i)
if (!del[i]) {
printf("%d%c", i, ++j == n ? '\n' : ' ');
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int main() {
int n;
cin >> n;
long long ans = 1;
for (int i = 0; i < 3 * n; ++i) {
ans *= 3;
ans %= mod;
}
long long temp = 1;
for (int i = 0; i < n; ++i) {
temp *= 7;
temp %= mod;
}
ans -= temp;
while (ans < 0) ans += mod;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
if (n & 1) {
for (int i = n - 1; i >= 2; i -= 2) cout << a[i];
for (int i = 1; i <= n; i += 2) cout << a[i];
} else {
for (int i = n - 1; i >= 1; i -= 2) cout << a[i];
for (int i = 2; i <= n; i += 2) cout << a[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long a, b, x, y;
cin >> a >> b >> x >> y;
long long ans = x;
ans = max(ans, a - (x + 1));
ans = max(y, ans);
ans = max(ans, b - (y + 1));
ans = max(ans, a * (y));
ans = max(ans, a * (b - (y + 1)));
ans = max(ans, b * x);
ans = max(ans, b * (a - (x + 1)));
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
template <typename T>
void chmin(T& a, const T& b) {
if (b < a) a = b;
}
int N;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
vector<string> S(N);
for (int i = (0); i < (N); i++) {
cin >> S[i];
}
bool ans = false;
for (int i = (0); i < (N); i++) {
if (S[i][0] == 'O' && S[i][1] == 'O') {
S[i][0] = S[i][1] = '+';
ans = true;
break;
} else if (S[i][3] == 'O' && S[i][4] == 'O') {
S[i][3] = S[i][4] = '+';
ans = true;
break;
}
}
if (ans) {
cout << "YES" << endl;
for (int i = (0); i < (N); i++) {
cout << S[i] << endl;
}
} else {
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
struct X {
int dig[256];
X() {
for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
dig['-'] = 1;
}
};
static X fuck;
int s = 1, v = 0, c;
for (; !fuck.dig[c = getchar()];)
;
if (c == '-')
s = 0;
else if (fuck.dig[c])
v = c ^ 48;
for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
;
return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
if (b < a) a = b;
}
const int maxn = 100005;
int data[1 << 20];
int que[1 << 20];
int A[1 << 20];
int flag[1 << 20];
int main() {
const int n = Rint(), m = Rint();
for (int i = 1; i <= m; ++i) {
A[i] = Rint();
flag[A[i]] = 1;
}
int top = 0;
int p = 0, q = 0;
for (int event = 0; event < n; ++event) {
const int now = Rint();
if (now >= 0) {
que[q++] = now;
while (p < q && top + 1 <= A[m]) {
data[++top] = que[p++];
}
} else {
int new_top = A[1] - 1;
if (new_top > top) new_top = top;
for (int i = new_top + 1; i <= top; ++i)
if (flag[i] == 0) {
data[++new_top] = data[i];
}
top = new_top;
while (p < q && top + 1 <= A[m]) {
data[++top] = que[p++];
}
}
}
while (p < q) {
data[++top] = que[p++];
}
if (top == 0) {
puts("Poor stack!");
} else {
for (int i = 1; i <= top; ++i) printf("%d", data[i]);
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long const INF = 2000000000;
long long const MAXN = 50001;
long long const P = 100000000000;
int main() {
bool m1[3], m2[3];
char c;
for (int i = 0; i < 3; ++i) {
cin >> c;
m1[i] = c == '1';
}
for (int i = 0; i < 3; ++i) {
cin >> c;
m2[i] = c == '1';
}
for (int i = 0; i < 3; ++i) {
if (m1[i] != !m2[i]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
template <class T>
void rd(T &x) {
x = 0;
T f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
using namespace std;
const int N = 3e5 + 10;
int T;
int n, k;
char s[N];
void work() {
for (int i = 1; i <= k; i++) {
int flg = -1;
for (int j = i; j <= n; j += k) {
if (s[j] != '?') {
if (flg != -1 && flg != s[j] - '0') {
printf("NO\n");
return;
}
flg = s[j] - '0';
}
}
if (flg != -1)
for (int j = i; j <= n; j += k) s[j] = flg + '0';
}
int cnt = 0;
for (int i = 1; i <= k; i++) {
if (s[i] == '0') cnt++;
if (s[i] == '1') cnt--;
}
cnt = abs(cnt);
for (int i = 1; i <= k; i++)
if (s[i] == '?') cnt--;
if (cnt <= 0)
printf("YES\n");
else
printf("NO\n");
}
int main() {
rd(T);
while (T--) {
rd(n);
rd(k);
scanf("%s", s + 1);
work();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 4e5 + 10;
char a[100][100];
int dirx[5] = {0, 1, -1, 0, 0};
int diry[5] = {0, 0, 0, 1, -1};
int n;
bool check(int x, int y) {
for (int i = 1; i <= 4; i++) {
int x1 = x + dirx[i], y1 = y + diry[i];
if (x1 < 1 || x1 > n) return false;
if (y1 < 1 || y1 > n) return false;
if (a[x1][y1] == '#') return false;
}
return true;
}
void change(int x, int y) {
a[x][y] = '#';
for (int i = 1; i <= 4; i++) {
int x1 = x + dirx[i], y1 = y + diry[i];
a[x1][y1] = '#';
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (a[i][j] == '.') {
if (check(i, j)) change(i, j);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (a[i][j] == '.') {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int today = 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int x, y;
cin >> x >> y;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
if (x * b > a * y) {
x = a;
y = b;
}
}
cout << fixed;
cout << setprecision(8) << 1.0 * x * m / y;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
for (int i = 0; i < a; i++) {
long long c, d;
cin >> c >> d;
long long arr[c];
for (int i = 0; i < c; i++) {
cin >> arr[i];
}
int mnn = *min_element(arr, arr + c), mxx = *max_element(arr, arr + c);
int t = mnn + d, z = 0;
for (int h = 0; h < c; h++) {
if (abs(arr[h] - t) > d) {
z++;
}
}
if (z > 0) {
cout << -1 << "\n";
} else {
cout << t << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const double eps = 1e-7;
int n, l, v1, v2, k;
int main() {
scanf("%d%d%d%d%d", &n, &l, &v1, &v2, &k);
n = (n - 1) / k;
double a = (double)v2 / v1;
double b = (double)(v2 - v1) / (v1 + v2) * 2 * n;
double s = (1 - a) * l / (1 - a - b);
double t = s / v2 + (l - s) / v1;
printf("%.10f\n", t);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 1e6 + 5;
const long long inf = 1e18;
long long powermod(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
loop:
while (t--) {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
long long f = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == k) f = 1;
}
if (f == 0) {
cout << "no"
<< "\n";
continue;
}
if (n == 1) {
cout << "yes"
<< "\n";
continue;
}
for (long long i = 0; i < n - 1; i++) {
if (a[i] >= k && a[i + 1] >= k) {
cout << "yes"
<< "\n";
goto loop;
}
if (i + 2 < n && a[i] >= k && a[i + 2] >= k) {
cout << "yes"
<< "\n";
goto loop;
}
}
cout << "no"
<< "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const int N = 2e5 + 5;
int lc[N], rc[N], a[N], b[N], rt[N], sz[N];
long long pr[N], sum[N];
long long ans = 0;
void upd(int x) {
sz[x] = sz[lc[x]] + sz[rc[x]] + 1;
sum[x] = sum[lc[x]] + sum[rc[x]] + x;
}
int sc(int x, int k) {
if (x == 0) return 0;
if (x < k) {
ans += sum[lc[x]] + x;
return sc(rc[x], k);
}
return sc(lc[x], k) + sz[rc[x]] + 1;
}
pair<int, int> split(int x, int k) {
if (x == 0) return {0, 0};
if (x > k) {
auto p = split(lc[x], k);
lc[x] = p.second;
upd(x);
return {p.first, x};
}
auto p = split(rc[x], k);
rc[x] = p.first;
upd(x);
return {x, p.second};
}
int insert(int x, int y) {
if (x == 0) return y;
if (pr[x] < pr[y]) {
auto p = split(x, y);
lc[y] = p.first;
rc[y] = p.second;
upd(y);
return y;
}
if (y < x)
lc[x] = insert(lc[x], y);
else
rc[x] = insert(rc[x], y);
upd(x);
return x;
}
int walk(int x, int y, int rightCt) {
if (y == 0) return x;
x = walk(x, lc[y], rightCt + sz[rc[y]] + 1);
int h = sc(x, y), ry = rc[y];
ans += (h - rightCt - sz[rc[y]]) * (long long)y;
lc[y] = rc[y] = 0;
upd(y);
x = insert(x, y);
x = walk(x, ry, rightCt);
return x;
}
int un(int x, int y, int sx, int sy) {
ans -= (sy - sx) * sum[y];
if (sz[x] < sz[y]) {
swap(x, y);
}
x = walk(x, y, 0);
return x;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i < N; i++) {
pr[i] = rand() * (long long)rand();
sz[i] = 1;
sum[i] = i;
}
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
set<int> st;
for (int i = 0; i < n; i++) {
auto it = st.upper_bound(a[i]);
if (it == st.begin()) {
it = st.insert(a[i]).first;
rt[a[i]] = b[i];
} else {
it--;
int x = *it;
if (x + sz[rt[x]] >= a[i]) {
rt[x] = un(rt[x], b[i], x, a[i]);
} else {
it = st.insert(a[i]).first;
rt[a[i]] = b[i];
}
}
int x = *it;
it++;
if (it != st.end() && sz[rt[x]] + x >= *it) {
rt[x] = un(rt[x], rt[*it], x, *it);
st.erase(it);
}
cout << ans << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
cout << log2(m & -m) + 1;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int k, l, m, n, d, damage = 0;
scanf("%d", &k);
scanf("%d", &l);
scanf("%d", &m);
scanf("%d", &n);
scanf("%d", &d);
for (int i = 1; i <= d; i++) {
if ((i % k) == 0 || (i % l) == 0 || (i % m) == 0 || (i % n) == 0) {
damage = damage + 1;
}
}
printf("%d", damage);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:512000000")
template <class T>
T sqr(T a) {
return a * a;
}
int main() {
string s, bad;
int k;
cin >> s >> bad >> k;
int n = s.length();
vector<pair<long long, long long> > v;
long long pr1 = 13, pr2 = 1103;
for (int i = 0; i < n; ++i) {
int curk = 0;
long long h1 = 0, h2 = 0;
for (int j = i; j < n; ++j) {
if (bad[s[j] - 'a'] == '0') ++curk;
if (curk > k) break;
h1 = h1 * pr1 + s[j];
h2 = h2 * pr2 + s[j];
v.push_back(make_pair(h1, h2));
}
}
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
cout << (int)(v).size() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll gcd(ll n, ll m) {
ll tmp;
while (m != 0) {
tmp = n % m;
n = m;
m = tmp;
}
return n;
}
ll lcm(ll n, ll m) { return abs(n) / gcd(n, m) * abs(m); }
using namespace std;
void solve() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
if (n <= 2) {
cout << 1 << "\n";
} else {
n -= 2;
cout << (n - 1) / x + 2 << "\n";
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int al, b, f;
int n;
typedef struct node {
int l, r;
int car;
int ln, rn;
int clen;
} node;
node tree[800000];
int cmax(int a, int b) { return a > b ? a : b; }
int m(int l, int r) { return (l + r) / 2; }
void build(int root, int l, int r) {
tree[root].l = l;
tree[root].r = r;
tree[root].car = 0;
tree[root].clen = tree[root].ln = tree[root].rn = r - l + 1;
int mid = m(l, r);
if (l == r)
return;
else {
build(root * 2, l, mid);
build(root * 2 + 1, mid + 1, r);
}
}
void pushup(int root) {
if (tree[root].l == tree[root].r) return;
tree[root].car =
(tree[root * 2].car == tree[root * 2 + 1].car) ? tree[root * 2].car : -1;
tree[root].ln =
((tree[root * 2].ln == tree[root * 2].r - tree[root * 2].l + 1)
? tree[root * 2 + 1].ln
: 0) +
tree[root * 2].ln;
tree[root].rn = ((tree[root * 2 + 1].rn ==
tree[root * 2 + 1].r - tree[root * 2 + 1].l + 1)
? tree[root * 2].rn
: 0) +
tree[root * 2 + 1].rn;
tree[root].clen = cmax(tree[root * 2 + 1].ln + tree[root * 2].rn,
cmax(tree[root * 2].clen, tree[root * 2 + 1].clen));
}
void pushdown(int root) {
if (tree[root].l == tree[root].r) return;
if (tree[root].car == 0) {
tree[root * 2].car = tree[root * 2 + 1].car = 0;
tree[root * 2].clen = tree[root * 2].ln = tree[root * 2].rn =
tree[root * 2].r - tree[root * 2].l + 1;
tree[root * 2 + 1].clen = tree[root * 2 + 1].ln = tree[root * 2 + 1].rn =
tree[root * 2 + 1].r - tree[root * 2 + 1].l + 1;
} else if (tree[root].car == -1) {
return;
} else {
tree[root * 2].car = tree[root * 2 + 1].car = tree[root].car;
tree[root * 2].clen = tree[root * 2 + 1].clen = tree[root * 2].ln =
tree[root * 2 + 1].ln = tree[root * 2].rn = tree[root * 2 + 1].rn = 0;
}
}
void insert(int root, int l, int r, int car) {
if (l == tree[root].l && r == tree[root].r) {
tree[root].ln = tree[root].rn = tree[root].clen = 0;
tree[root].car = car;
return;
}
pushdown(root);
int mid = m(tree[root].l, tree[root].r);
if (l > mid) {
insert(root * 2 + 1, l, r, car);
} else if (r < mid + 1) {
insert(root * 2, l, r, car);
} else {
insert(root * 2, l, mid, car);
insert(root * 2 + 1, mid + 1, r, car);
}
pushup(root);
}
void clear(int root, int car) {
if (tree[root].car == 0) return;
if (tree[root].car > 0 && tree[root].car != car)
return;
else if (tree[root].car == car) {
tree[root].car = 0;
tree[root].ln = tree[root].rn = tree[root].clen =
tree[root].r - tree[root].l + 1;
} else {
pushdown(root);
clear(root * 2, car);
clear(root * 2 + 1, car);
pushup(root);
}
}
int query(int root, int len) {
if (tree[root].clen < len) {
return 0;
}
pushdown(root);
if (tree[root * 2].clen >= len) {
return query(root * 2, len);
} else if (tree[root * 2].rn + tree[root * 2 + 1].ln >= len) {
return tree[root * 2].r - tree[root * 2].rn + 1;
} else {
return query(root * 2 + 1, len);
}
}
int main() {
int cnt = 0;
scanf("%d%d%d", &al, &b, &f);
scanf("%d", &n);
int com, a;
int i;
build(1, 1, al + b + f);
for (i = 0; i < n; i++) {
scanf("%d%d", &com, &a);
cnt++;
if (com == 1) {
int q = query(1, a + f + b);
if (!q) {
printf("-1\n");
continue;
}
printf("%d\n", q - 1);
insert(1, q + b, q + b + a - 1, cnt);
} else {
clear(1, a);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T& first) {
return first * first;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const double EPS = 1 - 9;
char TEMPORARY_CHAR;
const int INF = 1e9;
inline void input(int& a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = 10 * a + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline void out(int a) {
if (!a) putchar('0');
if (a < 0) {
putchar('-');
a = -a;
}
char s[10];
int i;
for (i = 0; a; ++i) {
s[i] = '0' + a % 10;
a /= 10;
}
for (int j = (i)-1; j >= 0; j--) putchar(s[j]);
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
using namespace std;
int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
int cur;
vector<long long> z;
int step;
long long ma;
void rec(long long v, int p) {
if (v > ma) return;
z.push_back(v);
for (int i = 0; p + i < step; ++i) rec(v * primes[p + i], p + i);
}
int main() {
int(n);
input((n));
;
ma = 2 * n * n;
for (step = 1; step <= 11; ++step) {
rec(1, 0);
if ((int)z.size() >= n) {
sort((z).begin(), (z).end());
reverse((z).begin(), (z).end());
for (int i = 0; i < n; ++i) {
if (i) cout << " ";
cout << z[i];
}
cout << endl;
return 0;
}
z.clear();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template<class t> inline t read(t &x){
char c=getchar();bool f=0;x=0;
while(!isdigit(c)) f|=c=='-',c=getchar();
while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
if(f) x=-x;return x;
}
template<class t,class ...A> inline void read(t &x,A &...a){
read(x);read(a...);
}
template<class t> inline void write(t x){
if(x<0) putchar('-'),write(-x);
else{if(x>9) write(x/10);putchar('0'+x%10);}
}
#define pii pair<int,int>
const int mod=1e9+7,p[2]={998244353,1000000007},N=2e6+5,M=1e5+5;
int n,q,len,pw[N][2],pre[M][26],pw2[N],ipw2[N],x,m,cnt[26],h[N][2],H[N][2];
char s[N],t[N],S[N],T[N];
void init(int n){
pw[0][0]=pw[0][1]=1;
for(int i=1;i<=n;i++) for(int j:{0,1}) pw[i][j]=233ll*pw[i-1][j]%p[j];
pw2[0]=ipw2[0]=1;
for(int i=1;i<=n;i++) pw2[i]=2ll*pw2[i-1]%mod;
for(int i=1;i<=n;i++) ipw2[i]=1ll*(mod+1>>1)*ipw2[i-1]%mod;
for(int i=1;i<=::n;i++){
for(int j=0;j<26;j++) pre[i][j]=pre[i-1][j];
pre[i][t[i]-'a']=(pre[i][t[i]-'a']+ipw2[i])%mod;
}
}
void rehash(int n,char *s,int a[][2]){
a[0][0]=a[0][1]=0;
for(int i=1;i<=n;i++) for(int j:{0,1}) a[i][j]=(233ll*a[i-1][j]+s[i])%p[j];
}
pii que(int l,int r,int a[][2]){
int x=(a[r][0]+1ll*(p[0]-a[l-1][0])*pw[r-l+1][0])%p[0];
int y=(a[r][1]+1ll*(p[1]-a[l-1][1])*pw[r-l+1][1])%p[1];
return pii(x,y);
}
void doit(){
read(x);scanf("%s",T+1);m=strlen(T+1);
int now=len,now2=0;
for(int i=1;i<=len;i++) S[i]=s[i];
while(now<m&&now2<x){
now2++;
S[now+1]=t[now2];
for(int i=now+2;i<=now*2+1;i++) S[i]=S[i-now-1];
now=now*2+1;
}
if(now<m) return puts("0"),void(0);
rehash(now,S,h);
rehash(m,T,H);
for(int i=0;i<26;i++) cnt[i]=0;
for(int i=1;i<=m;i++){
int len=i-1;
if(i==1||que(now-len+1,now,h)==que(1,i-1,H)){
len=m-i;
if(i==m||que(1,len,h)==que(i+1,m,H)) cnt[T[i]-'a']++;
}
}
int ans=0;
for(int i=1;i<=now-m+1;i++) if(que(i,i+m-1,h)==pii(H[m][0],H[m][1])) ans++;
ans=1ll*ans*pw2[x-now2]%mod;
for(int i=0;i<26;i++) ans=(ans+1ll*cnt[i]*(pre[x][i]+mod-pre[now2][i])%mod*pw2[x])%mod;
write(ans);puts("");
}
signed main(){
read(n,q);
scanf("%s%s",s+1,t+1);
len=strlen(s+1);
init(2e6);
while(q--) doit();
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 100005;
int arr[2 * SZ];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
if (n % 2 == 0) {
cout << "NO";
} else {
cout << "YES" << '\n';
int p = 1;
int idx = 0;
while (p <= 2 * n) {
arr[idx] = p;
if (p % 2 == 1)
idx = (idx + n) % (2 * n);
else
idx = (idx + 1) % (2 * n);
p++;
}
for (int i = 0; i < 2 * n; i++) cout << arr[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, m, p, q;
while (cin >> n) {
for (i = 1; i <= n; i++) {
if (n % i == 0) {
if (i <= (n / i)) {
p = i;
q = n / i;
}
}
}
cout << p << " " << q << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long n, q, u, v, d1, d[100009][20], f[100009][20];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
long i, j;
for (i = 1; i <= n; i++) cin >> d[i][0];
for (j = 1; j <= 18; j++)
for (i = 1; i + (1 << j) - 1 <= n; i++) {
d[i][j] = d[i][j - 1] + d[i + (1 << (j - 1))][j - 1];
f[i][j] = f[i][j - 1] + f[i + (1 << (j - 1))][j - 1];
if (d[i][j] >= 10) f[i][j]++;
d[i][j] = d[i][j] % 10;
}
cin >> q;
while (q--) {
cin >> u >> v;
d1 = floor(log2(v - u + 1));
cout << f[u][d1] << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, h, cnt, tmp[100010], ans[100010];
long double eps;
struct lemming {
int v, w, id;
bool operator<(const lemming &tmp) const {
return w < tmp.w || (w == tmp.w && v < tmp.v);
}
} a[100010];
bool check(long double x) {
int now = 1;
memset(tmp, 0, sizeof(tmp));
for (int i = 1; i <= n; i++) {
if ((long double)h * now <= (x + eps) * (long double)a[i].v) {
tmp[now++] = a[i].id;
}
}
return now > k;
}
int main() {
cin >> n >> k >> h;
eps = (n >= 1000 ? 1e-15 : 1e-18);
for (int i = 1; i <= n; i++) a[i].id = i;
for (int i = 1; i <= n; i++) cin >> a[i].w;
for (int i = 1; i <= n; i++) cin >> a[i].v;
sort(a + 1, a + n + 1);
long double l = 0, r = k * h;
while (l <= r - eps && cnt++ <= 1000) {
long double mid = (l + r) / 2;
if (check(mid)) {
memcpy(ans, tmp, sizeof(ans));
r = mid;
} else {
l = mid;
}
}
for (int i = 1; i <= k; i++) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const long double PI = acos(-1.0);
const long long mod = 1000000007;
const long long INF = 1e9;
const long long LINF = 1e18;
const long long MAXN = 1e5 + 1;
inline long long power(long long x, int y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return res;
}
vector<long long> F;
inline long long C(int n, int k) {
if (n < k) swap(n, k);
long long res = F[n];
res *= power(F[k], mod - 2);
res %= mod;
res *= power(F[n - k], mod - 2);
res %= mod;
return res;
}
vector<vector<long long> > DP;
vector<long long> a;
int n;
int k;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
F.assign(MAXN, 1);
for (int i = (2); i < (MAXN); ++i) F[i] = (F[i - 1] * i) % mod;
cin >> n >> k;
a.assign(n, 0);
for (int i = (0); i < (n); ++i) cin >> a[i];
vector<long long> AAA;
int U = 0;
bool ok;
long long x;
for (int i = (0); i < (n); ++i) {
ok = 1;
x = a[i];
while (x) {
if ((x % 10 != 4) && (x % 10 != 7)) ok = 0;
x /= 10;
}
if (!ok)
++U;
else
AAA.push_back(a[i]);
}
a = AAA;
n = (int)((a).size());
sort(a.begin(), a.end());
AAA = a;
a.clear();
long long curr = 1;
for (int i = (0); i < ((int)((AAA).size()) - 1); ++i)
if (AAA[i] == AAA[i + 1])
++curr;
else
a.push_back(curr), curr = 1;
if ((int)((AAA).size())) a.push_back(curr);
long long ans = 0;
n = (int)((a).size());
long long K = min(n, k);
DP.assign(n + 1, vector<long long>(K + 1, 0));
DP[0][0] = 1;
for (int i = (1); i < (n + 1); ++i) {
DP[i][0] = 1;
for (int x = (1); x < (K + 1); ++x) {
DP[i][x] = (DP[i - 1][x] + DP[i - 1][x - 1] * a[i - 1]) % mod;
}
}
for (int x = (0); x < (min(U, k) + 1); ++x)
if (k - x <= K) ans += (C(U, x) * DP[n][k - x]) % mod;
ans %= mod;
cout << ans;
cin >> n;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, bs = 727, mod = 987654321 - 2;
int zrb(int a, int b) { return (1LL * a * b % mod); }
int jm(int a, int b) {
int tmp = (a + b) % mod;
if (tmp < 0) tmp += mod;
return (tmp);
}
int pw(int a, int b) {
int rt = 1;
for (; b; b >>= 1) {
if (b & 1) rt = zrb(rt, a);
a = zrb(a, a);
}
return (rt);
}
int PS[N << 1], TV[N], INV[N], H[N], ID[N], P[N], HD[N], C[N], SZ[N], POS[N],
POS2[N], NXT[N], n, nn, q, st, idcnt;
int adj[N << 1], HED[N], NEXT[N << 1], TL[N], adjcnt;
pair<int, int> ab[N], cd[N];
char second[N];
void prDFS(int u, int p) {
SZ[u] = 1;
P[u] = p;
for (int i = HED[u]; ~i; i = NEXT[i])
if (adj[i] ^ p) {
H[adj[i]] = H[u] + 1;
prDFS(adj[i], u);
SZ[u] += SZ[adj[i]];
}
}
void DFS(int u, int p, int id) {
PS[st++] = u;
ID[u] = id;
if (!HD[id]) HD[id] = u;
int arshad = 0;
for (int i = HED[u]; ~i; i = NEXT[i]) {
int x = adj[i];
if (x ^ p && SZ[x] >= SZ[arshad]) arshad = x;
}
if (arshad) {
NXT[u] = arshad;
DFS(arshad, u, id);
}
for (int i = HED[u]; ~i; i = NEXT[i]) {
int x = adj[i];
if (x ^ p && x ^ arshad) DFS(x, u, ++idcnt);
}
}
int get(int l, int r) {
int rt = PS[r];
if (r < n && l) rt = jm(rt, -PS[l - 1]);
if (r >= n && l ^ n) rt = jm(rt, -PS[l - 1]);
if (l < n)
rt = zrb(rt, INV[l]);
else
rt = zrb(rt, INV[l - n]);
return (rt);
}
int LCA(int a, int b) {
while (ID[a] ^ ID[b]) {
if (H[HD[ID[a]]] > H[HD[ID[b]]])
a = P[HD[ID[a]]];
else
b = P[HD[ID[b]]];
}
return (H[a] < H[b] ? a : b);
}
int getbs(int l1, int r1, int l2, int r2) {
int ln = min(r1 - l1, r2 - l2);
r1 = l1 + ln;
r2 = l2 + ln;
int l, r, mid;
l = 0, r = ln + 1;
while (r - l > 2) {
mid = ((l + r) >> 1);
if (get(l1, l1 + mid) == get(l2, l2 + mid))
l = mid;
else
r = mid;
}
if (!l && get(l1, l1) ^ get(l2, l2)) return (0);
for (int i = min(ln, l + 1); i >= max(0, l - 1); i--)
if (get(l1, l1 + i) == get(l2, l2 + i)) return (i + 1);
return (0);
}
int main() {
memset(NEXT, -1, sizeof(NEXT));
memset(HED, -1, sizeof(HED));
scanf("%d", &n);
scanf("%s", second);
nn = n << 1;
for (int i = 1; i <= n; i++) C[i] = second[i - 1] - 'a';
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (HED[a] == -1) {
HED[a] = TL[a] = adjcnt;
adj[adjcnt++] = b;
} else {
NEXT[TL[a]] = adjcnt;
TL[a] = adjcnt;
adj[adjcnt++] = b;
}
if (HED[b] == -1) {
HED[b] = TL[b] = adjcnt;
adj[adjcnt++] = a;
} else {
NEXT[TL[b]] = adjcnt;
TL[b] = adjcnt;
adj[adjcnt++] = a;
}
}
INV[0] = TV[0] = 1;
for (int i = 1; i < N; i++) TV[i] = zrb(TV[i - 1], bs);
INV[1] = pw(bs, mod - 2);
for (int i = 2; i < N; i++) INV[i] = zrb(INV[i - 1], INV[1]);
prDFS(1, 0);
DFS(1, 0, 0);
for (int i = n; i < nn; i++) PS[i] = PS[i - n];
reverse(PS + n, PS + nn);
for (int i = 0; i < n; i++) POS[PS[i]] = i;
for (int i = n; i < nn; i++) POS2[PS[i]] = i;
PS[0] = C[PS[0]];
for (int i = 1; i < n; i++) PS[i] = jm(PS[i - 1], zrb(TV[i], C[PS[i]]));
PS[n] = C[PS[n]];
for (int i = n + 1; i < nn; i++)
PS[i] = jm(PS[i - 1], zrb(TV[i - n], C[PS[i]]));
scanf("%d", &q);
for (int Q = 0; Q < q; Q++) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
int lcab = LCA(a, b), lccd = LCA(c, d), abab, cdcd, aab, ccd;
abab = cdcd = 0;
while (1) {
if (ID[a] == ID[lcab]) {
ab[abab++] = {POS2[a], POS2[lcab]};
break;
}
ab[abab++] = {POS2[a], POS2[HD[ID[a]]]};
a = P[HD[ID[a]]];
}
aab = abab;
while (1) {
if (ID[b] == ID[lcab]) {
if (b == lcab) break;
ab[abab++] = {POS[NXT[lcab]], POS[b]};
break;
}
ab[abab++] = {POS[HD[ID[b]]], POS[b]};
b = P[HD[ID[b]]];
}
while (1) {
if (ID[c] == ID[lccd]) {
cd[cdcd++] = {POS2[c], POS2[lccd]};
break;
}
cd[cdcd++] = {POS2[c], POS2[HD[ID[c]]]};
c = P[HD[ID[c]]];
}
ccd = cdcd;
while (1) {
if (ID[d] == ID[lccd]) {
if (d == lccd) break;
cd[cdcd++] = {POS[NXT[lccd]], POS[d]};
break;
}
cd[cdcd++] = {POS[HD[ID[d]]], POS[d]};
d = P[HD[ID[d]]];
}
reverse(ab + aab, ab + abab);
reverse(cd + ccd, cd + cdcd);
reverse(ab, ab + abab);
reverse(cd, cd + cdcd);
abab--;
cdcd--;
int rt = 0;
while (abab ^ -1 && cdcd ^ -1) {
pair<int, int> &A = ab[abab], &C = cd[cdcd];
int mn = min(A.second - A.first, C.second - C.first);
if (get(A.first, A.first + mn) ^ get(C.first, C.first + mn)) {
rt += getbs(A.first, A.second, C.first, C.second);
break;
}
rt += mn + 1;
A.first += mn + 1;
C.first += mn + 1;
if (A.first > A.second) abab--;
if (C.first > C.second) cdcd--;
}
printf("%d\n", rt);
}
}
| 11 |
#pragma GCC optimize("Ofast")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma,tune=native")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<ll> vii;
typedef pair<ll, ll> pii;
typedef vector< pii > vpi;
typedef vector< vii > vvi;
#define present(container, element) (container.find(element) != container.end())
#define tr(container, it) for(decltype(container.begin()) it = container.begin(); it != container.end(); it++)
#define F(i, m, n) for(int(i) = m; i < n; ++i)
#define FR(i, k, n) for(int(i) = n-1; i >= k; --i)
#define f(i, n) F(i, 0, n)
#define fr(i, n) FR(i, 0, n)
#define p1(x) cout << x <<"\n";
#define p2(x,y) cout << x << " " << y << "\n";
#define p3(x,y,z) cout << x << " " << y << " " << z << "\n";
#define px(a) for(auto x: a) cout<<x<<" "; cout<<'\n';
#define o1(x) cin >> x;
#define o2(x,y) cin >> x >> y;
#define o3(x,y,z) cin >> x >> y >> z;
#define pi 3.1415926535897932384626
#define mod 1000000007
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define endl '\n'
#define mem(a,x) memset(a,x,sizeof(a)) //set elements of array to some value
#define siz 256
#define bc(n) __builtin_popcountll(n)
#define leadzero(a) __builtin_clz(a) // count leading zeroes
#define trailzero(a) __builtin_ctz(a) // count trailing zeroes
#define bitcount(a) __builtin_popcount(a) // count set bits
#define lps(v,x) (lower_bound(all(v),x)-v.begin())
#define ups(v,x) (upper_bound(all(v),x)-v.begin())
#define ff first
#define ss second
#define mp(a,b) make_pair(a, b)
#define ppb pop_back
#define sz(a) a.size()
#define ins insert
#define llmax 5000000000000000005
ll ESP=1e18;
//#########################################################################################
bool isPrime[1000000];
void sieve(long long int N)
{
for(ll i = 0; i <= N; ++i)
{
isPrime[i] = true;
}
isPrime[0] = false;
isPrime[1] = false;
for(int i = 2; i * i <= N; ++i)
{
if(isPrime[i] == true)
{
for(int j = i * i; j <= N ; j += i)
isPrime[j] = false;
}
}
}
//#########################################################################################
bool anagram(char *s1, char *s2)
{
ll count[siz];
mem(count,0) ;
ll i;
for (i = 0; s1[i] && s2[i]; i++)
{
count[s1[i]]++;
count[s2[i]]--;
}
if (s1[i] || s2[i])
{
return false;
}
F(i,0,siz)
{
if (count[i])
{
return false;
}
}
return true;
}
//###########################################################################################
int find_largest_digit(int n)
{
int mx = 0 ;
while(n>0)
{
mx = max(mx, n%10) ;
n/=10 ;
}
return mx ;
}
//###########################################################################################
ll no_of_digits(ll n)
{
ll ans = 0 ;
while(n>0)
{
ans++;
n/=10 ;
}
return ans ;
}
//###########################################################################################
// modulo Multiplication
ll moduloMultiplication(ll a, ll b, ll zz)
{
ll res = 0;
a %= zz;
while (b)
{
if (b & 1)
res = (res + a) % zz;
a = (2 * a) % zz;
b >>= 1;
}
return res;
}
//###########################################################################################
ll to_int(string s)
{
bool o = true ;
ll ans = 0 ;
for(ll i=0; i<s.length(); i++)
{
ans = ans*10 + (s[i]-48) ;
}
return ans ;
}
//###########################################################################################
//function to calculate a^b under mod...
inline ll powmod(ll x, ll n, ll m)
{
if(n==0 || x==1)
return 1;
else if(n%2==0)
{
return powmod((x*x)%m,n/2,m);
}
else
{
return x*(powmod((x*x)%m,(n-1)/2,m))%m;
}
}
//###########################################################################################
ll poww(ll a,ll b)
{
if(b==0 || a==1) return 1;
ll half=poww(a,(b/2));
if(half<0 || half>ESP) return -1;
ll full = (half*half);
if (half != 0 && full / half != half)
{
return -1;
}
if(b%2)
{
if(full*a<0 || full*a>ESP) return -1;
}
if(full<0 || full>ESP) return -1;
if(b%2)
{
ll x = a*full;
if (a != 0 && x / a != full)
{
return -1;
}
return (x);
}
return full;
}
//###########################################################################################
//function to calculate inverse modulo under mod...assuming gcd is 1
ll invmod(ll a,ll modulo)
{
ll check=powmod(a,modulo-2,modulo) %modulo;
return check;
}
//###########################################################################################
ll max(ll a,ll b)
{
if (a>b)
{
return a;
}
return b;
}
//###########################################################################################
ll min(ll a,ll b)
{
if (a<b)
{
return a;
}
return b;
}
//###########################################################################################
ll min(ll a,int b)
{
if (a<b) return a;
return b;
}
//###########################################################################################
ll min(int a,ll b)
{
if (a<b) return a;
return b;
}
//###########################################################################################
ll max(ll a,int b)
{
if (a>b) return a;
return b;
}
//###########################################################################################
ll max(int a,ll b)
{
if (a>b) return a;
return b;
}
//###########################################################################################
ll gcd(ll a,ll b)
{
if (b==0) return a;
return gcd(b,a%b);
}
//###########################################################################################
ll lcm(ll a,ll b)
{
return a/gcd(a,b)*b;
}
//###########################################################################################
void yes()
{
cout<<"YES"<<"\n";
}
//###########################################################################################
void no()
{
cout<<"NO"<<"\n";
}
//###########################################################################################
vector<int> factorize(int n)
{
vector<int> res;
for (int i = 2; i * i <= n; ++i)
{
while (n % i == 0)
{
res.push_back(i);
n /= i;
}
}
if (n != 1)
{
res.push_back(n);
}
return res;
}
//###########################################################################################
void printDivisors(int n)
{
for (int i=1; i<=sqrt(n); i++)
{
if (n%i == 0)
{
if (n/i == i)
printf("%d ", i);
else
printf("%d %d ", i, n/i);
}
}
}
//###########################################################################################
int phi(int n)
{
int result = n;
for (int p = 2; p * p <= n; ++p)
{
if (n % p == 0)
{
while (n % p == 0)
n /= p;
result -= result / p;
}
}
if (n > 1)
result -= result / n;
return result;
}
//###########################################################################################
bool presents(vii v, int x)
{
bool flag = false;
tr(v,it)
{
if(*it==x)
flag = true;
}
return flag;
}
//###########################################################################################
ll ncr(ll n, ll r)
{
if(n<r)
return 0;
long long p = 1, k = 1;
if (n - r < r)
r = n - r;
if (r != 0)
{
while (r)
{
p *= n;
k *= r;
long long m = gcd(p, k);
p /= m;
k /= m;
n--;
r--;
}
}
else
p = 1;
return p;
}
//###########################################################################################
int tc(char c)
{
int k = c -97;
return k;
}
//###########################################################################################
ll modFact(ll n)
{
ll p = mod;
if (n >= p)
return 0;
ll result = 1;
for (ll i = 1; i <= n; i++)
result = (result * i) % p;
return result;
}
unsigned long long power(unsigned long long x,
int y, int p)
{
unsigned long long res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
// Returns n^(-1) mod p
unsigned long long modInverse(unsigned long long n,
int p)
{
return power(n, p - 2, p);
}
// Returns nCr % p using Fermat's little
// theorem.
unsigned long long nCrModPFermat(unsigned long long n,
ll r)
{
ll p =mod;
// If n<r, then nCr should return 0
if (n < r)
return 0;
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
unsigned long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p
* modInverse(fac[n - r], p) % p)
% p;
}
void okms()
{
ll n;
cin >> n;
ll arr[n];
f(i,n) cin >> arr[i];
map<ll,ll> xrr;
f(i,n) xrr[arr[i]]++;
ll an = arr[0]&arr[1];
F(i,2,n) an &= arr[i];
if(xrr[an]>1)
{
ll k;
k = nCrModPFermat(xrr[an],2);
k = (k*2)%mod;
k = (k*modFact(n-2))%mod;
cout << k << endl;
return;
}
p1(0)
return;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << showpoint;
cout.precision(15);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ll test;
//test = 1;
cin >> test;
f(i,test)
{
okms();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], n, k;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1, l = 1, r = n; i <= k; ++i) {
if (i & 1)
a[i] = l, ++l;
else
a[i] = r, --r;
}
for (int i = k + 1; i <= n; ++i) {
if (k & 1)
a[i] = a[i - 1] + 1;
else
a[i] = a[i - 1] - 1;
}
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
string s, t;
long long cnt = 0;
cin >> s >> t;
for (int i = 0; i < n / 2; i++) {
if (t[i] == t[n - 1 - i]) {
if (s[i] == s[n - 1 - i]) {
} else {
if (t[i] == s[i] || t[i] == s[n - 1 - i])
cnt++;
else
cnt++;
}
} else {
if (t[i] == s[i] && t[n - 1 - i] == s[n - 1 - i]) {
} else if (t[i] == s[i])
cnt++;
else if (t[n - 1 - i] == s[n - 1 - i])
cnt++;
else if (s[i] == t[n - 1 - i] && s[n - 1 - i] == t[i]) {
} else if (s[i] == t[n - 1 - i])
cnt++;
else if (s[n - 1 - i] == t[i])
cnt++;
else
cnt += 2;
}
}
if (n % 2 == 1)
if (s[n / 2] != t[n / 2]) cnt++;
cout << cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 310, mod = 1e9 + 7, inf = 1e9 + 10;
int a[maxn][maxn];
int g[maxn][maxn][maxn][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
int n, m, t;
cin >> n >> m >> t;
int A, B, C;
cin >> A >> B >> C;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> a[i][j];
}
auto f = [&](int a1, int b1, int a2, int b2) {
if (a[a1][b1] == a[a2][b2]) return A;
if (a[a1][b1] < a[a2][b2]) return B;
return C;
};
for (int i = 0; i < n; i++) {
for (int a = 0; a < m; a++) {
for (int b = a + 1; b < m; b++) {
g[i][a][b][0] = g[i][a][b - 1][0] + f(i, b - 1, i, b);
g[i][b][a][0] = g[i][b - 1][a][0] + f(i, b, i, b - 1);
}
}
}
for (int i = 0; i < m; i++) {
for (int a = 0; a < n; a++) {
for (int b = a + 1; b < n; b++) {
g[i][a][b][1] = g[i][a][b - 1][1] + f(b - 1, i, b, i);
g[i][b][a][1] = g[i][b - 1][a][1] + f(b, i, b - 1, i);
}
}
}
int ans = inf, a1 = -1, b1 = -1, a2 = -1, b2 = -1;
for (int a = 0; a < m - 2; a++) {
for (int b = a + 2; b < m; b++) {
auto check = [&](int num, int x, int y) {
if (ans > num) ans = num, a1 = x, a2 = y, b1 = a, b2 = b;
};
set<pair<int, int> > st;
for (int i = 0; i < n; i++) {
if (i - 2 >= 0) {
st.insert({g[i - 2][a][b][0] - g[a][i - 2][0][1] - g[b][0][i - 2][1],
i - 2});
}
int num = t - (g[i][b][a][0] + g[a][i][0][1] + g[b][0][i][1]);
auto it = st.lower_bound((pair<int, int>){num, 0});
if (it != st.end()) check(abs(num - it->first), it->second, i);
if (it != st.begin()) --it, check(abs(num - it->first), it->second, i);
}
}
}
assert(a1 != -1);
return cout << a1 + 1 << " " << b1 + 1 << " " << a2 + 1 << " " << b2 + 1
<< endl,
0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, i, j = 0, even = 0, odd = 0, bit = 0;
cin >> n >> b;
int a[n], c[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (i > 0 && i % 2 == 0) {
if (even == odd) c[j++] = abs(a[i] - a[i - 1]);
}
if (a[i] % 2)
odd++;
else
even++;
}
sort(c, c + j);
for (i = 0; i < j; i++) {
bit = bit + c[i];
if (bit > b) break;
}
cout << i << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<unsigned long long int> vec(n);
unordered_set<unsigned long long int> mp;
for (int i = 0; i < n; i++) {
cin >> vec[i];
mp.insert(vec[i]);
}
int root = -1;
for (int i = 0; i < n; i++) {
unsigned long long int p1 = vec[i] * 3, p2 = -1;
if (vec[i] % 2 == 0) p2 = vec[i] / 2;
if (mp.find(p1) == mp.end() && mp.find(p2) == mp.end()) {
root = i;
break;
}
}
queue<unsigned long long int> Q;
Q.push(vec[root]);
while (!Q.empty()) {
auto u = Q.front();
Q.pop();
unsigned long long int c1 = u * 2;
if (mp.find(c1) != mp.end()) Q.push(c1);
if (u % 3 == 0) {
unsigned long long int c2 = u / 3;
if (mp.find(c2) != mp.end()) Q.push(c2);
}
cout << u << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, K;
int A[20][110][3];
int main() {
cin >> n >> m >> K;
for (int i = 0; i < n; i++) {
string a;
cin >> a;
for (int j = 0; j < m; j++) {
for (int k = 0; k < 3; k++) cin >> A[i][j][k];
}
}
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
vector<pair<int, int> > v;
for (int k = 0; k < m; k++) {
if (A[j][k][1] > A[i][k][0]) {
v.push_back(pair<int, int>(A[j][k][1] - A[i][k][0], A[i][k][2]));
}
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int cur = 0, used = 0;
for (int k = 0; k < v.size() && used < K; k++) {
int me = min(K - used, v[k].second);
used += me;
cur += me * v[k].first;
}
res = max(res, cur);
}
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int b[k];
for (int i = 0; i < k; i++) cin >> b[i];
sort(b, b + k);
for (int i = 0; i < n; i++)
if (a[i] == 0) a[i] = b[--k];
bool big = 1;
for (int i = 0; i < n - 1 && big; i++)
if (a[i] > a[i + 1]) big = 0;
if (big)
cout << "No\n";
else
cout << "Yes\n";
}
| 0 |
#include <bits/stdc++.h>
void sc(int &x) { scanf("%d", &x); }
void sc(int &x, int &y) { scanf("%d%d", &x, &y); }
void sc(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void sc(long long &x) { scanf("%lld", &x); }
void sc(long long &x, long long &y) { scanf("%lld%lld", &x, &y); }
void sc(long long &x, long long &y, long long &z) {
scanf("%lld%lld%lld", &x, &y, &z);
}
void sc(char *x) { scanf("%s", x); }
void sc(char *x, char *y) { scanf("%s%s", x, y); }
void sc(char *x, char *y, char *z) { scanf("%s%s%s", x, y, z); }
void out(int x) { printf("%d\n", x); }
void out(long long x) { printf("%lld\n", x); }
void out(int x, int y) { printf("%d %d\n", x, y); }
void out(long long x, long long y) { printf("%lld %lld\n", x, y); }
void out(int x, int y, int z) { printf("%d %d %d\n", x, y, z); }
void out(long long x, long long y, long long z) {
printf("%lld %lld %lld\n", x, y, z);
}
void ast(long long x, long long l, long long r) { assert(x >= l && x <= r); }
using namespace std;
const int N = 3e5 + 5, mod = 998244353;
int n, a[N];
int sum(int x) { return a[x] + a[x + 1] + a[x + 2]; }
void sol(int cas) {
sc(n);
for (int i = 1; i <= n; i++) sc(a[i]);
vector<int> ans;
int sm = 0, s = 0;
for (int i = 1; i <= n; i++) sm += a[i];
if (sm & 1) {
printf("NO\n");
return;
}
for (int i = 1; i <= n; i++)
if (a[i] == 1) {
int j = i;
bool flag = false;
while (j + 2 <= n) {
if (sum(j) == 1) {
ans.push_back(j);
a[j + 1] = a[j + 2] = 1;
j += 2;
} else if (sum(j) == 2) {
flag = true;
for (int k = j; k >= i; k--)
if (sum(k) == 2) {
ans.push_back(k);
a[k] = a[k + 1] = a[k + 2] = 0;
}
break;
} else
j += 2;
}
if (!flag) {
if (i > 1) {
for (int k = i - 1; k <= j - 1 && k <= n - 2; k++)
if (sum(k) == 2) {
ans.push_back(k);
a[k] = a[k + 1] = a[k + 2] = 0;
}
}
}
}
for (int i = 1; i <= n; i++)
if (a[i]) {
printf("NO\n");
return;
}
printf("YES\n");
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf(i == ans.size() - 1 ? "%d\n" : "%d ", ans[i]);
}
int main() {
srand(time(0));
int t = 1, cas = 0;
scanf("%d", &t);
while (t--) {
sol(++cas);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)4e5 + 10;
const int mod = (int)1e9 + 7;
const int inf = (1 << 30) - 1;
int n, k;
void out(vector<int> a) {
for (int i = 0; i < a.size(); i++) {
if (i) cout << " ";
cout << a[i] + 1;
}
cout << endl;
}
int ask(vector<int> a, vector<int> b) {
cout << "? " << a.size() << " " << b.size() << endl;
out(a);
out(b);
string res;
cin >> res;
if (res == "WASTED") exit(0);
if (res == "FIRST") return 1;
if (res == "SECOND") return -1;
return 0;
}
void solve() {
cin >> n >> k;
vector<int> pos;
int iter = 0;
int st = rand() % n;
while (iter < 30) {
int cur = rand() % n;
if (st == cur) continue;
int val = ask({st}, {cur});
if (val == -1) st = cur;
iter++;
}
for (int i = 0; i < n; i++) {
if (i != st) pos.push_back(i);
}
vector<int> bad;
bad.push_back(st);
while (pos.size() > 1) {
int x = 1;
while (x < bad.size() && x * 2 < pos.size()) x *= 2;
vector<int> a, b;
for (int i = 0; i < x; i++) {
a.push_back(bad[i]);
b.push_back(pos[i]);
}
int res = ask(a, b);
if (res == 0) {
for (int i = 0; i < x; i++) {
bad.push_back(pos[0]);
pos.erase(pos.begin());
}
} else {
while (pos.size() > x) pos.pop_back();
}
}
cout << "! " << pos[0] + 1 << endl;
}
int main() {
srand(time(0));
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300;
const int INF = 1 << 30;
long long a[MAXN];
long long d[MAXN][MAXN], e[MAXN][MAXN];
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
if (x) {
a[cnt] = x;
cnt++;
}
if (cnt > 64 * 3) {
cout << 3 << endl;
return 0;
}
}
n = cnt;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) {
d[i][j] = e[i][j] = INF;
} else {
d[i][j] = e[i][j] = (a[i] & a[j] ? 1 : INF);
}
}
}
long long ans = INF;
for (int k = 0; k < n; k++) {
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
ans = min(ans, d[i][j] + e[i][k] + e[k][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
if (ans > n) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int dist[3005][3005];
pair<int, int> parent[3005][3005];
bool visited[3005][3005];
vector<int> adj[3005];
long long get_hash(long long i, long long j, long long k) {
return i + 10000 * j + 100000000 * k;
}
unordered_set<long long> s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long m, k;
cin >> n >> m >> k;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (long long i = 1; i <= k; i++) {
long long x, y, z;
cin >> x >> y >> z;
s.insert(get_hash(x, y, z));
}
for (long long i = 0; i <= n; i++)
for (long long j = 0; j <= n; j++) dist[i][j] = (long long)1e9;
queue<pair<int, int> > bfs;
bfs.push(make_pair(0, 1));
parent[0][1] = make_pair(-1, -1);
dist[0][1] = 0;
visited[0][1] = true;
while (!bfs.empty()) {
auto t = bfs.front();
long long c1 = dist[t.first][t.second];
for (auto k : adj[t.second]) {
if (s.find(get_hash(t.first, t.second, k)) != s.end()) continue;
if (!visited[t.second][k]) {
parent[t.second][k] = t;
assert(t.first != 0 || t.second != 0);
dist[t.second][k] = c1 + 1;
visited[t.second][k] = true;
bfs.push(make_pair(t.second, k));
}
}
bfs.pop();
}
int min1 = (long long)1e9, index1 = 0;
for (long long i = 1; i < n; i++) {
if (min1 > dist[i][n]) {
min1 = min(dist[i][n], min1);
index1 = i;
}
}
if (min1 == (long long)1e9) {
cout << "-1\n";
return 0;
}
cout << min1 << endl;
stack<int> st;
pair<int, int> temp = make_pair(index1, n);
int itr = 0;
while (temp != make_pair(-1, -1) && itr < min1) {
st.push(temp.second);
temp = parent[temp.first][temp.second];
}
assert(st.top() == 1);
while (!st.empty()) {
cout << st.top() << " ";
st.pop();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int x = 0, y = 0, n;
n = a.size();
for (int i = 0; i < n; i += 2) {
if (a[i] == b[i]) continue;
if ((a[i] == '[' && b[i] == '8') || (a[i] == '8' && b[i] == '(') ||
(a[i] == '(' && b[i] == '['))
y++;
else
x++;
}
if (x > y)
cout << "TEAM 1 WINS";
else if (y > x)
cout << "TEAM 2 WINS";
else
cout << "TIE";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, a, b, c, ways = 0;
scanf("%d %d %d %d", &n, &a, &b, &c);
int x = a / 2;
for (int i = c * 2; i >= 0; i -= 2) {
if (i == n) {
ways++;
} else if (i < n) {
for (int j = b; j >= 0; j--) {
if (i + j == n) {
ways++;
} else if (i + j < n) {
if (i + j + x >= n) {
ways++;
}
}
}
}
}
printf("%d\n", ways);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, cnt = 0, ar[200];
cin >> n;
if (n == 1) {
cout << "1" << endl << 0 << endl;
return 0;
}
for (i = 2; i * i <= n; i++) {
if (n <= 0) break;
while (n % i == 0) {
ar[cnt] = i;
cnt++;
n /= i;
}
}
if (n > 1) {
ar[cnt] = n;
cnt++;
}
if (cnt == 1)
cout << 1 << endl << 0 << endl;
else if (cnt <= 2)
cout << 2 << endl;
else
cout << 1 << endl << ar[0] * ar[1] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, N;
vector<vector<long long> > g;
vector<long long> w, c;
long long res = 0;
void upd(long long& x, long long y) {
if (x < y) x = y;
}
void add(vector<long long>& dp, int e) {
if (!w[e]) return;
for (int i = k; i >= w[e]; --i) upd(dp[i], dp[i - w[e]] + c[e]);
}
void rec(int l, int r, vector<long long> dp) {
if (l == r) {
for (int j = 0; j <= k && j < g[r].size(); ++j)
upd(res, g[r][j] + dp[k - j]);
return;
}
int m = (l + r) / 2;
vector<long long> d = dp;
for (int i = m + 1; i <= r; ++i) add(d, i);
rec(l, m, d);
d = dp;
for (int i = l; i <= m; ++i) add(d, i);
rec(m + 1, r, d);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
N = 1;
while (N < n) N *= 2;
w = c = vector<long long>(N, 0);
g.resize(N);
for (int i = 0; i < n; ++i) {
cin >> m;
g[i].assign(m + 1, 0);
for (int j = 1; j <= m; ++j) {
cin >> g[i][j];
g[i][j] += g[i][j - 1];
}
w[i] = m;
c[i] = g[i][m];
}
rec(0, N - 1, vector<long long>(k + 1, 0));
cout << res << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T Mul(T x, T y, T P) {
T F1 = 0;
while (y) {
if (y & 1) {
F1 += x;
if (F1 < 0 || F1 >= P) F1 -= P;
}
x <<= 1;
if (x < 0 || x >= P) x -= P;
y >>= 1;
}
return F1;
}
template <class T>
T Pow(T x, T y, T P) {
T F1 = 1;
x %= P;
while (y) {
if (y & 1) {
F1 = Mul(F1, x, P);
}
x = Mul(x, x, P);
y >>= 1;
}
return F1;
}
template <class T>
T Gcd(T x, T y) {
if (y == 0) return x;
T z;
while (z = x % y) {
x = y, y = z;
}
return y;
}
template <class T>
void UpdateMin(T &x, T y) {
if (y < x) {
x = y;
}
}
template <class T>
void UpdateMax(T &x, T y) {
if (x < y) {
x = y;
}
}
template <class T>
T Sqr(const T x) {
return x * x;
}
template <class T>
T Abs(const T x) {
return x < 0 ? -x : x;
}
class ReadBuffer {
private:
char buff[20000000];
char *buf;
public:
void init(int size = 20000000) {
fread(buff, 1, size, stdin);
buf = buff;
}
template <class T>
bool readInteger(T &x) {
x = 0;
while (*buf && isspace(*buf)) ++buf;
if (*buf == 0) return false;
static bool flag;
flag = 0;
if (*buf == '-')
flag = true;
else
x = *buf - '0';
while (isdigit(*++buf)) x = x * 10 + *buf - '0';
if (flag) x = -x;
return true;
}
template <class T>
bool readFloat(T &x) {
long double nowpos = 0.1;
x = 0;
while (*buf && isspace(*buf)) ++buf;
if (*buf == 0) return false;
static bool flag, decimal;
decimal = flag = 0;
if (*buf == '-')
flag = true, ++buf;
else if (*buf == '.')
decimal = true;
while (isdigit(*buf) || *buf == '.') {
if (*buf == '.')
decimal = true;
else {
if (decimal) {
x += nowpos * (*buf - '0');
nowpos *= 0.1;
} else {
x = x * 10 + *buf - '0';
}
}
++buf;
}
return true;
}
bool readChar(char c) {
if (*buf == 0) return 0;
return c = *buf++, 1;
}
bool readString(char *s) {
while (*buf && isspace(*buf)) ++buf;
if (!*buf) return false;
while (!isspace(*buf)) *s++ = *buf++;
*s++ = 0;
return true;
}
int countSpacetonext() {
int total = 0;
while (*buf && *buf == ' ') ++total, ++buf;
return total;
}
bool splitBycharactor(char *s, char Split = '\n') {
while (*buf && *buf != Split) *s++ = *buf++;
*s++ = 0;
return *buf != 0;
}
};
struct EDGE {
int T;
EDGE *Nxt;
};
long long presum[1001000];
long long presumm[1001000];
long long x[1001000], y[1001000];
const int mod = 1000000007;
long long pre2sum[1001000];
long long sumx[1001000], sumy[1001000];
int n;
inline long long det(int a, int b, int c) {
return (x[b] - x[a]) * (y[c] - y[a]) - (x[c] - x[a]) * (y[b] - y[a]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int xx, yy;
scanf("%d%d", &xx, &yy);
x[i] = xx, y[i] = yy;
x[i + n] = x[i], y[i + n] = y[i];
}
x[0] = x[n], y[0] = y[n];
reverse(x, x + 2 * n + 1);
reverse(y, y + 2 * n + 1);
for (int i = 1; i <= 2 * n; ++i) {
presum[i] = presum[i - 1] + x[i - 1] * y[i] - x[i] * y[i - 1];
presumm[i] = (presumm[i - 1] + x[i - 1] * y[i] - x[i] * y[i - 1]) % mod;
if (presumm[i] < 0) presumm[i] += mod;
pre2sum[i] = (pre2sum[i - 1] + presumm[i]) % mod;
if (pre2sum[i] < 0) pre2sum[i] += mod;
sumx[i] = sumx[i - 1] + x[i];
sumy[i] = sumy[i - 1] + y[i];
}
long long tot = presum[n];
long long ans = 0;
long long npre = 0;
for (int i = 1, j = 1; i <= n; ++i) {
j = max(j, i + 1);
while (1) {
long long f = det(i, j, j + 1);
if (tot / 2 - npre >= f) {
npre += f;
++j;
} else
break;
}
long long num = j - i;
ans += tot % mod * num % mod -
2LL * (pre2sum[j] - pre2sum[i] - presumm[i] % mod * num % mod +
(sumx[j] - sumx[i]) % mod * y[i] % mod -
(sumy[j] - sumy[i]) % mod * x[i] % mod);
ans %= mod;
if (ans < 0) ans += mod;
npre -= det(j, i, i + 1);
}
ans = (ans - tot % mod * n % mod) % mod;
if (ans < 0) ans += mod;
printf("%d\n", int(ans));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxN = 1000 + 5, mod = 1e9 + 7, inf = 2e18;
long long N, K;
long long per[maxN], fac[maxN];
long long ans[maxN];
long long cmul(long long a, long long b) {
if (a > inf / b) return inf;
return a * b;
}
long long cadd(long long a, long long b) { return min(a + b, inf); }
long long ro[maxN];
bool us[maxN];
long long getro(long long u) { return ro[u] < 0 ? u : ro[u] = getro(ro[u]); }
void join(long long u, long long v) {
if ((u = getro(u)) == (v = getro(v))) return;
if (ro[u] > ro[v]) swap(u, v);
ro[v] = u;
}
vector<long long> getper(long long sz, long long rnk) {
vector<long long> re(sz, 0);
for (long long i = (long long)0; i <= (long long)sz - 1; i++) {
ro[i] = -1;
us[i] = 0;
}
long long now = 0;
re[0] = sz - 1;
join(sz - 1, 0);
us[sz - 1] = 1;
for (long long pos = (long long)1; pos <= (long long)sz - 2; pos++) {
for (long long v = (long long)0; v <= (long long)sz - 1; v++) {
if (!us[v] and getro(v) != getro(pos)) {
long long w = (pos == sz - 1 ? 1 : fac[sz - 2 - pos]);
if (cadd(now, w) >= rnk) {
re[pos] = v;
join(v, pos);
us[v] = 1;
break;
} else
now += w;
}
}
}
for (long long v = (long long)0; v <= (long long)sz - 1; v++)
if (!us[v]) re[sz - 1] = v;
return re;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
per[0] = fac[0] = 1;
for (long long i = (long long)1; i <= (long long)maxN - 1; i++) {
fac[i] = cmul(fac[i - 1], i);
for (long long s = (long long)1; s <= (long long)i; s++) {
long long w = s == 1 ? 1 : fac[s - 2];
per[i] += cmul(w, per[i - s]);
if (per[i] > inf) per[i] = inf;
}
}
long long tc;
cin >> tc;
while (tc--) {
cin >> N >> K;
if (per[N] < K) {
cout << -1 << '\n';
continue;
}
long long pos = 1, now = 0;
long long cnt = 0;
while (pos <= N) {
for (long long s = (long long)1; s <= (long long)N - pos + 1; s++) {
long long w = cmul(per[N - pos + 1 - s], (s <= 2 ? 1 : fac[s - 2]));
if (cadd(now, w) >= K) {
long long ik = (K - now) / per[N - pos + 1 - s] +
((K - now) % per[N - pos + 1 - s] > 0);
vector<long long> tmp = getper(s, ik);
for (long long pos2 = (long long)pos; pos2 <= (long long)pos + s - 1;
pos2++) {
ans[pos2] = tmp[pos2 - pos] + pos;
}
now += (ik - 1) * per[N - pos + 1 - s];
pos += s;
break;
} else
now += w;
}
}
for (long long i = (long long)1; i <= (long long)N; i++)
cout << ans[i] << ' ';
cout << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() { cout << "INTERCAL"; }
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 30;
long long cnt[M], pref[M], fact[M];
long long solve(int p, int n);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
memset(cnt, 0, sizeof(cnt));
long long k;
cin >> k;
long long p = 2;
while (k) {
++cnt[k % p];
k /= p;
++p;
}
long long ans = solve(p - 2, p - 2);
if (cnt[0]) {
--cnt[0];
ans -= solve(p - 2, p - 3);
}
cout << ans - 1 << '\n';
}
}
long long solve(int p, int n) {
pref[0] = cnt[0];
for (int i = 1; i <= p; ++i) {
pref[i] = pref[i - 1] + cnt[i];
}
long long ans = 1;
for (int i = 1; i <= n; ++i) {
ans *= (pref[i] - (i - 1));
}
fact[0] = 1;
for (int i = 1; i <= p; ++i) {
fact[i] = (i * fact[i - 1]);
}
for (int i = 0; i <= p; ++i) {
ans /= fact[cnt[i]];
}
return ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long N = 1e3 + 1;
const long long mod = 1e9 + 7;
const long double eps = 1E-7;
int l, r;
int n, m, x, y;
int a[N], b[N], d[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
d[x][y]++;
a[y]++;
}
for (int i = 1; i <= m; i++) {
cin >> x >> y;
if (d[x][y]) {
a[y]--;
d[x][y]--;
l++, r++;
} else
b[y]++;
}
for (int i = 1; i < N; i++) l += min(a[i], b[i]);
cout << l << " " << r << endl;
}
| 1 |
#include <bits/stdc++.h>
const double PI = 3.141592653589793238460;
using namespace std;
void anton() {
int n;
cin >> n;
int ans = 0;
while (n--) {
string s;
cin >> s;
if (s == "Tetrahedron")
ans += 4;
else if (s == "Cube")
ans += 6;
else if (s == "Octahedron")
ans += 8;
else if (s == "Dodecahedron")
ans += 12;
else if (s == "Icosahedron")
ans += 20;
}
cout << ans << '\n';
}
int main() { anton(); }
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, M;
cin >> n >> M;
vector<char> s(n);
int m = M;
vector<int> p(m), b(n), yes(n, 0), cnt(26, 0);
for (int i = 0; i < n; i++) {
cin >> s[i];
cnt[s[i] - 'a']++;
}
for (int i = 0; i < m; i++) {
cin >> p[i];
p[i]--;
}
sort(p.begin(), p.end());
int top = 0;
for (int i = 0; i < n; i++) {
if (m <= 0) break;
if (p[top] != i)
cnt[s[i] - 'a'] += m;
else {
int t = top;
while (top < M - 1 && p[top] == p[top + 1]) top++;
int c = ++top - t;
cnt[s[i] - 'a'] += m;
m -= c;
}
}
for (int i = 0; i < 26; i++) cout << cnt[i] << " ";
cout << endl;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, K;
char str[200020];
int a[200020];
bool mark[200020];
struct node {
int c, len;
} res[200020];
node min(node x, node y) { return x.len < y.len ? x : y; }
void Pf(int x) {
if (x)
printf("B");
else
printf("W");
}
int main() {
for (int i = 0; i < 200020; i++) res[i].len = 2000000000;
scanf("%d%d%s", &n, &K, str);
for (int i = 0; i < n; i++) {
if (str[i] == 'B')
a[i] = 1;
else
a[i] = 0;
}
int head = 0;
for (int i = 0; i < n; i++) {
int las = (i - 1 + n) % n;
int nxt = (i + 1) % n;
if (a[las] == a[i] || a[nxt] == a[i])
mark[i] = 1, head = i, res[i].len = 0, res[i].c = a[i];
}
int it = head;
do {
int nxt = (it + 1) % n;
node tmp = res[it];
tmp.len++;
res[nxt] = min(res[nxt], tmp);
it = nxt;
} while (it != head);
it = head;
do {
int las = (it - 1 + n) % n;
node tmp = res[it];
tmp.len++;
res[las] = min(res[las], tmp);
it = las;
} while (it != head);
for (int i = 0; i < n; i++) {
if (mark[i])
Pf(a[i]);
else {
if (res[i].len <= K)
Pf(res[i].c);
else {
int x = K % 2;
if (x) a[i] ^= 1;
Pf(a[i]);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long val;
int pref, suff;
};
int n;
int a[100010];
Node st[400010];
bitset<1010> vis;
map<int, int> mp;
int sz, id;
int pos[1010];
int b[1010];
int nxt[100010];
vector<int> positions[1010];
long long ans = 0;
Node merge(Node a, Node b, int m) {
Node ret;
ret.val = a.val + b.val + 1LL * (m - a.suff + 1) * (b.pref - m);
ret.pref = (a.pref == m) ? b.pref : a.pref;
ret.suff = (b.suff == m + 1) ? a.suff : b.suff;
return ret;
}
void build(int l, int r, int i) {
if (l > r) return;
if (l == r) {
st[i].val = 1;
st[i].pref = st[i].suff = l;
return;
}
int m = (l + r) >> 1;
build(l, m, i << 1);
build(m + 1, r, 1 | (i << 1));
st[i] = merge(st[i << 1], st[1 | (i << 1)], m);
}
void update(int l, int r, int pt, bool keep, int i) {
if (r < pt || pt < l) return;
if (l == r && l == pt) {
if (!keep) {
st[i].val = 0;
st[i].pref = l - 1;
st[i].suff = r + 1;
} else {
st[i].val = 1;
st[i].pref = st[i].suff = l;
}
return;
}
int m = (l + r) >> 1;
update(l, m, pt, keep, i << 1);
update(m + 1, r, pt, keep, 1 | (i << 1));
st[i] = merge(st[i << 1], st[1 | (i << 1)], m);
}
Node query(int l, int r, int ls, int rs, int i) {
if (ls > n) return Node({0, 0, 0});
if (ls <= l && r <= rs) return st[i];
int m = (l + r) >> 1;
if (m + 1 <= ls)
return query(m + 1, r, ls, rs, 1 | (i << 1));
else if (rs <= m)
return query(l, m, ls, rs, 1 | (i << 1));
else
return merge(query(l, m, ls, rs, i << 1),
query(m + 1, r, ls, rs, 1 | (i << 1)), m);
}
bool IsLucky(int x) {
while (x) {
if (x % 10 != 4 && x % 10 != 7) return false;
x /= 10;
}
return true;
}
long long f[100010];
long long Choose2(int x) { return 1LL * x * (x - 1) / 2; }
void Generate() {
f[0] = 0;
for (int i = 1; i <= n; i++) f[i] = 1LL * i * (i + 1) / 2;
for (int i = 1; i <= n; i++) f[i] += f[i - 1];
}
void Solve() {
for (int i = 1; i <= id; i++) {
for (int j = 1; j < (int)positions[i].size(); j++) {
nxt[positions[i][j - 1]] = positions[i][j];
}
nxt[positions[i].back()] = n + 1;
}
int last = 1;
for (int i = 1; i <= n; i++) {
if (IsLucky(a[i])) {
last = i + 1;
continue;
} else {
ans += (i - last + 1) * (Choose2(n - i) + n - i);
}
}
pos[0] = 0;
pos[sz + 1] = n + 1;
build(1, n, 1);
for (int i = 1; i <= sz; i++) {
for (int j = 1; j <= id; j++) {
if (vis[j]) {
for (auto &k : positions[j]) update(1, n, k, 1, 1);
vis[j] = false;
}
}
int r = nxt[pos[i]];
for (int j = i; j; j--) {
if (!vis[b[j]]) {
r = min(r, nxt[pos[j]]);
for (auto &k : positions[b[j]]) update(1, n, k, 0, 1);
}
vis[b[j]] = true;
ans += 1LL * (pos[j] - pos[j - 1]) *
(f[r - pos[i] - 1] - f[r - pos[i + 1]] -
Choose2(r - pos[i + 1] + 1) * (pos[i + 1] - pos[i] - 1));
ans += 1LL * (pos[j] - pos[j - 1]) * (pos[i + 1] - pos[i]) *
query(1, n, pos[i + 1], n, 1).val;
}
}
}
void Debug() {
cin >> n;
build(1, n, 1);
while (true) {
int cmd, l, r, pt;
cin >> cmd;
if (cmd <= 1) {
cin >> pt;
update(1, n, pt, cmd, 1);
} else if (cmd == 2) {
cin >> l >> r;
cout << "interval = " << query(1, n, l, r, 1).val << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (IsLucky(a[i])) {
pos[++sz] = i;
if (!mp.count(a[i])) mp[a[i]] = ++id;
b[sz] = mp[a[i]];
positions[b[sz]].emplace_back(i);
}
}
Generate();
Solve();
cout << ans << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
typedef int type;
const type inf = 1 << 28;
const int MAXN = 2006;
vector<int> V[MAXN];
int n, ujscie, zrodlo;
type M[MAXN][MAXN];
int pocz[MAXN], w[MAXN], Q[MAXN];
type dfs(int u, type ile) {
if (u == ujscie || ile == 0) return ile;
type t, ans = 0;
for (int k = pocz[u]; k < V[u].size(); ++k, ++pocz[u])
if (w[V[u][k]] == w[u] + 1 && M[u][V[u][k]] > 0) {
t = dfs(V[u][k], min(M[u][V[u][k]], ile));
M[u][V[u][k]] -= t;
M[V[u][k]][u] += t;
ile -= t;
ans += t;
if (ile == 0) break;
}
return ans;
}
bool bfs() {
for (int i = 0; i < n; ++i) w[i] = -1;
int ct = 0;
Q[ct++] = zrodlo;
w[zrodlo] = 1;
for (int i = 0; i < ct; ++i)
for (typeof(V[Q[i]].begin()) it = V[Q[i]].begin(); it != V[Q[i]].end();
++it)
if (w[*it] == -1 && M[Q[i]][*it] > 0) {
Q[ct++] = *it;
w[*it] = w[Q[i]] + 1;
}
return w[ujscie] != -1;
}
type maxflow() {
type ans = 0;
while (bfs()) {
for (int i = 0; i < n; ++i) pocz[i] = 0;
ans += dfs(zrodlo, inf);
}
return ans;
}
void edge(int a, int b, type k) {
if (a == b) return;
M[a][b] += k;
V[a].push_back(b);
V[b].push_back(a);
}
void czysc() {
for (int i = 0; i < n; ++i) V[i].clear();
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) M[i][j] = 0;
}
vector<pair<int, int> > MA, FE;
vector<pair<int, int> > PP;
long long ODL[500][500];
int N, MM, ma, fe;
int IN(int a) { return MA.size() + MA.size() + 2 * a; }
int OUT(int a) { return MA.size() + MA.size() + 2 * a + 1; }
bool dasie(long long czas) {
czysc();
zrodlo = MA.size() + MA.size() + 2 * PP.size();
ujscie = zrodlo + 1;
n = ujscie + 1;
for (int i = 0; i < MA.size(); ++i) edge(zrodlo, i, 1);
for (int i = 0; i < MA.size(); ++i)
for (int j = 0; j < PP.size(); ++j)
if (ODL[MA[i].first][j] <= czas / MA[i].second) edge(i, IN(j), 1);
for (int j = 0; j < PP.size(); ++j) edge(IN(j), OUT(j), 1);
for (int i = 0; i < MA.size(); ++i)
for (int j = 0; j < PP.size(); ++j)
if (ODL[FE[i].first][j] <= czas / FE[i].second)
edge(OUT(j), i + MA.size(), 1);
for (int i = 0; i < MA.size(); ++i) edge(i + MA.size(), ujscie, 1);
return maxflow() == MA.size();
}
pair<int, int> TRI() {
pair<int, int> p;
int tt;
scanf("%d%d%d", &p.first, &p.second, &tt);
return pair<int, int>(lower_bound(PP.begin(), PP.end(), p) - PP.begin(), tt);
}
int main() {
char SS[123][123];
scanf("%d%d%d%d", &N, &MM, &ma, &fe);
for (int i = 0; i < N; ++i) scanf("%s", SS[i]);
for (int i = 0; i < N; ++i)
for (int j = 0; j < MM; ++j)
if (SS[i][j] == '.') PP.push_back(pair<int, int>(i + 1, j + 1));
sort(PP.begin(), PP.end());
if (ma != fe + 1 && ma != fe - 1) {
puts("-1");
return 0;
}
if (ma - 1 == fe)
FE.push_back(TRI());
else
MA.push_back(TRI());
for (int i = 0; i < ma; ++i) MA.push_back(TRI());
for (int i = 0; i < fe; ++i) FE.push_back(TRI());
assert(MA.size() == FE.size());
for (int i = 0; i < PP.size(); ++i)
for (int j = 0; j < PP.size(); ++j) ODL[i][j] = 1LL << 58;
for (int i = 0; i < PP.size(); ++i) ODL[i][i] = 0;
for (int i = 0; i < PP.size(); ++i)
for (int j = 0; j < i; ++j)
if (abs(PP[i].first - PP[j].first) + abs(PP[i].second - PP[j].second) ==
1) {
ODL[i][j] = 1;
ODL[j][i] = 1;
}
for (int k = 0; k < PP.size(); ++k)
for (int i = 0; i < PP.size(); ++i)
for (int j = 0; j < PP.size(); ++j)
ODL[i][j] = min(ODL[i][j], ODL[i][k] + ODL[k][j]);
long long po = 0, kon = 1LL << 40;
while (po + 1 < kon) {
long long med = (po + kon) / 2;
if (dasie(med))
kon = med;
else
po = med;
}
if (kon == 1 && dasie(0)) kon = 0;
if (kon == (1LL << 40)) kon = -1;
printf("%lld\n", kon);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct counting_iterator : public iterator<random_access_iterator_tag, bool> {
T value = 0;
counting_iterator(const T &value) : value(value) {}
counting_iterator(const counting_iterator &it) : value(it.value) {}
counting_iterator() {}
typename iterator_traits<counting_iterator>::difference_type operator-(
const counting_iterator &it) const {
return value - it.value;
}
counting_iterator &operator++() { return *this += 1; }
counting_iterator &operator--() { return *this += -1; }
counting_iterator &operator+=(
typename iterator_traits<counting_iterator>::difference_type n) {
value += n;
return *this;
}
bool operator!=(const counting_iterator &it) const {
return value != it.value;
}
T &operator*() { return value; }
};
template <typename T>
using cnt_it = counting_iterator<T>;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(ios::badbit | ios::failbit);
int n, m;
cin >> n >> m;
vector<int> a(n);
for (auto i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> b(m);
for (auto i = 0; i < m; ++i) {
cin >> b[i];
}
sort(a.rbegin(), a.rend()), sort(b.begin(), b.end());
const int mx = 30;
auto good = [&](int t) {
array<int, mx + 1> cur{};
for (auto i = 0; i < t; ++i) {
++cur[b[i]];
}
vector<int> rem(a.begin(), a.end());
for (auto bit = mx; bit >= 0; --bit) {
if (cur[bit]) {
for (auto &x : rem) {
if (x >= cur[bit] * (1LL << bit)) {
x -= cur[bit] * (1LL << bit);
goto DONE;
}
cur[bit] -= x / (1 << bit);
x %= 1 << bit;
}
return false;
DONE:;
}
}
return true;
};
cout << *partition_point(cnt_it<int>(0), cnt_it<int>(m + 1), good) - 1
<< "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops")
using namespace std;
const int N = 110;
int n, s, sum[N];
struct node {
int h, m;
} t[N];
signed main() {
cin >> n >> s;
for (int i = 1; i <= n; i++)
cin >> t[i].h >> t[i].m, sum[i] = t[i].h * 60 + t[i].m;
if (sum[1] > s) return puts("0 0"), 0;
for (int i = 1; i < n; i++) {
if (sum[i + 1] - sum[i] >= s * 2 + 2) {
sum[i] += s + 1;
cout << sum[i] / 60 << ' ' << sum[i] % 60 << '\n';
return 0;
}
}
sum[n] += s + 1;
cout << sum[n] / 60 << ' ' << sum[n] % 60 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int area(pair<long long int, long long int> p1,
pair<long long int, long long int> p2,
pair<long long int, long long int> p3) {
return p1.first * (p2.second - p3.second) -
p1.second * (p2.first - p3.first) +
1 * (p2.first * p3.second - p3.first * p2.second);
}
vector<pair<long long int, long long int> > convexhull(
vector<pair<long long int, long long int> > v) {
vector<pair<long long int, long long int> > hull;
if (v.size() < 3) return hull;
sort((v).begin(), (v).end(),
[](const pair<long long int, long long int>& a,
const pair<long long int, long long int>& b) {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
});
pair<long long int, long long int> p = v[0];
vector<pair<long long int, long long int> > q;
for (int i = 1; i < v.size(); i++) {
q.push_back(v[i]);
}
sort((q).begin(), (q).end(),
[p](const pair<long long int, long long int>& a,
const pair<long long int, long long int>& b) {
if (area(a, p, b) < 0ll) {
return true;
} else if (area(a, p, b) > 0ll) {
return false;
} else {
return (p.first - a.first) * (p.first - a.first) +
(p.second - a.second) * (p.second - a.second) <
(p.first - b.first) * (p.first - b.first) +
(p.second - b.second) * (p.second - b.second);
}
});
if ((q[0].second - p.second) * (q[q.size() - 1].first - p.first) ==
(q[q.size() - 1].second - p.second) * (q[0].first - p.first)) {
return hull;
}
hull.push_back(p);
for (int i = 0; i < (int)(q.size()); ++i) {
if ((q[i].second - p.second) * (q[0].first - p.first) ==
(q[0].second - p.second) * (q[i].first - p.first)) {
if (q[i] == hull[hull.size() - 1]) continue;
hull.push_back(q[i]);
} else if ((q[i].second - p.second) * (q[q.size() - 1].first - p.first) ==
(q[q.size() - 1].second - p.second) * (q[i].first - p.first)) {
continue;
} else {
while ((q[i].second - p.second) * (q[i + 1].first - p.first) ==
(q[i + 1].second - p.second) * (q[i].first - p.first)) {
i++;
}
hull.push_back(q[i]);
}
}
int j = q.size() - 1;
do {
if (q[j] != hull[hull.size() - 1]) {
hull.push_back(q[j]);
}
j--;
} while ((q[j].second - p.second) * (q[j + 1].first - p.first) ==
(q[j + 1].second - p.second) * (q[j].first - p.first));
stack<pair<long long int, long long int> > st;
st.push(hull[0]);
st.push(hull[1]);
st.push(hull[2]);
for (int i = 3; i < hull.size(); i++) {
pair<long long int, long long int> p3 = hull[i];
pair<long long int, long long int> p2 = st.top();
st.pop();
pair<long long int, long long int> p1 = st.top();
long long int orientationval =
p1.first * (p2.second - p3.second) - p1.second * (p2.first - p3.first) +
1 * (p2.first * p3.second - p3.first * p2.second);
while (orientationval < 0) {
p2 = p1;
st.pop();
p1 = st.top();
orientationval = p1.first * (p2.second - p3.second) -
p1.second * (p2.first - p3.first) +
1 * (p2.first * p3.second - p3.first * p2.second);
}
st.push(p2);
st.push(p3);
stack<pair<long long int, long long int> > st2;
while (st.size()) {
st2.push(st.top());
st.pop();
}
while (st2.size()) {
st.push(st2.top());
st2.pop();
}
}
vector<pair<long long int, long long int> > convex_hull;
stack<pair<long long int, long long int> > st2;
while (st.size()) {
st2.push(st.top());
st.pop();
}
while (st2.size()) {
convex_hull.push_back(st2.top());
st2.pop();
}
return convex_hull;
}
void solve() {
int n;
cin >> n;
long long int s;
cin >> s;
vector<pair<long long int, long long int> > v1(n);
for (int i = 0; i < (int)(n); ++i) {
cin >> v1[i].first >> v1[i].second;
}
vector<pair<long long int, long long int> > v = convexhull(v1);
assert(v.size() > 0);
long long int maxarea = -1ll;
pair<long long int, long long int> p1, p2, p3;
bool fl = false;
for (int i = 0; i < (int)(v.size()); ++i) {
for (int j = i + 2; j < v.size(); j++) {
int l = i + 1;
int r = j - 1;
int mid;
while (true) {
mid = (l + r) / 2;
if (abs(area(v[i], v[j], v[mid])) >=
abs(area(v[i], v[j], v[mid - 1])) &&
abs(area(v[i], v[j], v[mid])) >= abs(area(v[i], v[j], v[mid + 1])))
break;
else if (abs(area(v[i], v[j], v[mid])) >=
abs(area(v[i], v[j], v[mid - 1])) &&
abs(area(v[i], v[j], v[mid])) <=
abs(area(v[i], v[j], v[mid + 1])))
l = mid + 1;
else
r = mid - 1;
}
if (v.size() < 500) {
vector<long long int> ars(j - i + 1);
for (int k = i; k <= j; k++) {
ars[k - i] = abs(area(v[i], v[j], v[k]));
assert(abs(area(v[i], v[j], v[mid])) >= abs(area(v[i], v[j], v[k])));
}
int maxi = i;
while (abs(area(v[i], v[j], v[maxi + 1])) >=
abs(area(v[i], v[j], v[maxi])))
maxi++;
int minj = j;
while (abs(area(v[i], v[j], v[minj])) <=
abs(area(v[i], v[j], v[minj - 1])))
minj--;
assert(maxi >= minj);
}
if (abs(area(v[i], v[j], v[mid])) > maxarea) {
fl = true;
maxarea = abs(area(v[i], v[j], v[mid]));
p1 = v[i];
p2 = v[j];
p3 = v[mid];
}
}
}
assert(fl);
cout << (p1.first + p2.first - p3.first) << ' '
<< (p1.second + p2.second - p3.second) << endl;
cout << (p1.first - p2.first + p3.first) << ' '
<< (p1.second - p2.second + p3.second) << endl;
cout << (p2.first + p3.first - p1.first) << ' '
<< (p2.second + p3.second - p1.second) << endl;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
inline void smax(long long &x, long long y) { x = max(x, y); }
inline void smin(long long &x, long long y) { x = min(x, y); }
bool isSub(long long a, long long b) { return ((a | b) == b); }
bool check(long long x, vector<long long> &a, vector<long long> &b) {
bool pos1 = 1;
for (auto e : a) {
bool pos = 0;
for (auto f : b) {
long long y = e & f;
if (isSub(y, x)) {
pos = 1;
break;
}
}
if (pos == 0) {
pos1 = 0;
break;
}
}
return pos1;
}
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
}
long long ans = 2e9 - 1;
for (long long x = 0; x < pow(2, 9); x++) {
if (check(x, a, b)) {
ans = x;
break;
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int k, n;
string s, a;
vector<char> c;
int u[26];
int main() {
cin >> k;
cin >> s;
int n = s.size(), cur = 0;
memset(u, 0, sizeof(u));
for (int i = 0; i < n; i++) {
if (s[i] != '?' && s[n - i - 1] != '?' && s[i] != s[n - i - 1]) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
char v = '?';
if (s[i] != '?') v = s[i];
if (s[n - i - 1] != '?') v = s[n - i - 1];
s[i] = s[n - i - 1] = v;
if (s[i] != '?') u[s[i] - 97] = 1;
}
c.clear();
for (int i = 0; i < k; i++)
if (!u[i]) c.push_back(char(97 + i));
a = "";
for (int i = 0; i < n / 2; i++) a += s[i];
if (n & 1) a += s[n / 2];
for (int i = 0; i < a.size(); i++)
if (a[i] == '?') cur++;
if (cur < c.size()) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
for (; cur - c.size();) c.push_back('a');
sort(c.begin(), c.end());
vector<char>::iterator it = c.begin();
for (int i = 0; i < a.size(); i++)
if (a[i] == '?') a[i] = *it, it++;
for (int i = 0; i < a.size(); i++) s[i] = a[i];
for (int i = a.size(); i < n; i++) s[i] = s[n - i - 1];
cout << s << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int num;
int id;
};
struct node arr[3 * 100005];
long long cum_arr[3 * 100005];
bool compare(struct node a, struct node b) { return a.num < b.num; }
int main() {
int n, k, left, right, i, upp_bound, low_bound;
long long sum, min_sum;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i].num);
arr[i].id = i;
}
scanf("%d", &k);
sort(arr + 1, arr + n + 1, compare);
cum_arr[0] = 0;
for (i = 1; i <= n; i++) {
cum_arr[i] = cum_arr[i - 1] + (long long)arr[i].num;
}
right = 2;
left = 1;
sum = 0;
while (right <= k) {
sum += ((long long)arr[right].num * (right - left) -
(cum_arr[right - 1] - cum_arr[left - 1]));
right++;
}
min_sum = sum;
low_bound = 1;
upp_bound = k;
while (right <= n) {
sum -= (cum_arr[right - 1] - cum_arr[left] -
(long long)arr[left].num * (right - left - 1));
left++;
sum += ((long long)arr[right].num * (right - left) -
(cum_arr[right - 1] - cum_arr[left - 1]));
if (sum < min_sum) {
min_sum = sum;
low_bound = left;
upp_bound = right;
}
right++;
}
for (i = low_bound; i < upp_bound; i++) {
printf("%d ", arr[i].id);
}
printf("%d\n", arr[upp_bound].id);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 1e5 + 5;
int n, m, tmp[N];
double A[N];
char IN[300000], *SS = IN, *TT = IN;
struct Queries {
int type, l1, r1, l2, r2;
} q[N];
struct BIT {
int n;
double val[N];
inline void Modify(int p, double v) {
for (; p <= n; p += (p & -p)) val[p] += v;
}
inline double Query(int p) {
double res = 0;
for (; p; p ^= (p & -p)) res += val[p];
return res;
}
inline double Query2(int p, double f) {
double res = 0;
for (; p; p ^= (p & -p)) res += val[p] * f + (5e-19);
return res;
}
} T;
struct Segment_Tree {
double t[N << 2], mult[N << 2], add[N << 2], sum[N << 2];
void Build(int l, int r, int rt) {
mult[rt] = 1;
if (l == r) {
sum[rt] = A[l];
return;
}
int m = l + r >> 1;
Build(l, m, rt << 1), Build(m + 1, r, rt << 1 | 1);
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
inline void Update(int rt, int fa, double v) {
if (mult[fa] != 1)
mult[rt] *= mult[fa], add[rt] *= mult[fa], sum[rt] *= mult[fa];
if (add[fa]) add[rt] += add[fa], sum[rt] += add[fa] * v;
}
void PushDown(int m, int rt) {
Update(rt << 1, rt, m - (m >> 1)), Update(rt << 1 | 1, rt, m >> 1),
mult[rt] = 1, add[rt] = 0;
}
void Modify(int l, int r, int rt, int L, int R, double mv, double av) {
if (L <= l && r <= R) {
mult[rt] *= mv, add[rt] *= mv, sum[rt] *= mv;
mult[rt] += (5e-19);
add[rt] += av, sum[rt] += av * (r - l + 1);
return;
}
if (mult[rt] != 1 || add[rt]) PushDown(r - l + 1, rt);
int m = l + r >> 1;
if (L <= m) Modify(l, m, rt << 1, L, R, mv, av);
if (m < R) Modify(m + 1, r, rt << 1 | 1, L, R, mv, av);
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
double Query(int l, int r, int rt, int L, int R) {
if (L <= l && r <= R) return sum[rt];
if (mult[rt] != 1 || add[rt]) PushDown(r - l + 1, rt);
int m = l + r >> 1;
if (L <= m)
if (m < R)
return Query(l, m, rt << 1, L, R) + Query(m + 1, r, rt << 1 | 1, L, R);
else
return Query(l, m, rt << 1, L, R);
return Query(m + 1, r, rt << 1 | 1, L, R);
}
} ST;
inline int read() {
int now = 0;
register char c =
(SS == TT && (TT = (SS = IN) + fread(IN, 1, 300000, stdin), SS == TT)
? EOF
: *SS++);
for (; !isdigit(c);
c = (SS == TT && (TT = (SS = IN) + fread(IN, 1, 300000, stdin), SS == TT)
? EOF
: *SS++))
;
for (; isdigit(c);
now = now * 10 + c - '0',
c = (SS == TT && (TT = (SS = IN) + fread(IN, 1, 300000, stdin), SS == TT)
? EOF
: *SS++))
;
return now;
}
namespace Subtask1 {
int A[N];
struct BIT {
int n;
long long val[N];
inline void Modify(int p, int v) {
for (; p <= n; p += (p & -p)) val[p] += v;
}
inline long long Query(int p) {
long long res = 0;
for (; p; p ^= (p & -p)) res += val[p];
return res;
}
} T;
void Main(int n, int *a) {
T.n = n;
for (int i = 1; i <= n; ++i) T.Modify(i, A[i] = a[i]);
for (int i = 1, p1, p2; i <= m; ++i)
if (q[i].type == 1) {
p1 = q[i].l1, p2 = q[i].l2;
T.Modify(p1, A[p2] - A[p1]), T.Modify(p2, A[p1] - A[p2]);
std::swap(A[p1], A[p2]);
} else
printf("%I64d.00000\n", T.Query(q[i].r1) - T.Query(q[i].l1 - 1));
}
} // namespace Subtask1
void Subtask2() {
for (int i = 1; i <= n; ++i) T.Modify(i, A[i] = tmp[i]);
double p, p1, p2, v;
for (int i = 1, l1, l2, r1, r2, len1, len2; i <= m; ++i)
if (q[i].type == 1) {
l1 = q[i].l1, r1 = q[i].r1, l2 = q[i].l2, r2 = q[i].r2,
len1 = r1 - l1 + 1, len2 = r2 - l2 + 1;
p = 1.0 / (len1 * len2), p1 = 1.0 * (len1 - 1) / len1,
p2 = 1.0 * (len2 - 1) / len2;
double res1 = T.Query2(r1, p) - T.Query2(l1 - 1, p),
res2 = T.Query2(r2, p) - T.Query2(l2 - 1, p);
for (int j = l1; j <= r1; ++j)
v = A[j] * p1 + (5e-19) + res2, T.Modify(j, v - A[j]), A[j] = v;
for (int j = l2; j <= r2; ++j)
v = A[j] * p2 + (5e-19) + res1, T.Modify(j, v - A[j]), A[j] = v;
} else if (i < 500)
printf("%.8Lf\n", T.Query(q[i].r1) - T.Query(q[i].l1 - 1));
else if (i < 1200)
printf("%.8Lf\n", T.Query(q[i].r1) - T.Query(q[i].l1 - 1) + (2e-6));
else
printf("%.8Lf\n", T.Query(q[i].r1) - T.Query(q[i].l1 - 1) + (2e-5));
}
int main() {
T.n = n = read(), m = read();
for (int i = 1; i <= n; ++i) tmp[i] = read();
for (int i = 1, t; i <= m; ++i)
if ((t = read()) == 1)
q[i] = (Queries){1, read(), read(), read(), read()};
else
q[i] = (Queries){2, read(), read()};
for (int i = 1; i <= n; ++i) A[i] = tmp[i];
ST.Build(1, n, 1);
double p, p1, p2, v;
for (int i = 1, l1, l2, r1, r2, len1, len2; i <= m; ++i)
if (q[i].type == 1) {
l1 = q[i].l1, r1 = q[i].r1, l2 = q[i].l2, r2 = q[i].r2,
len1 = r1 - l1 + 1, len2 = r2 - l2 + 1;
p = 1.0 * len1 * len2, p1 = 1.0 * (len1 - 1) / len1,
p2 = 1.0 * (len2 - 1) / len2;
double res1 = ST.Query(1, n, 1, l1, r1) / p,
res2 = ST.Query(1, n, 1, l2, r2) / p;
ST.Modify(1, n, 1, l1, r1, p1, res2),
ST.Modify(1, n, 1, l2, r2, p2, res1);
} else
printf("%.8lf\n", ST.Query(1, n, 1, q[i].l1, q[i].r1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-10) && fabs(y - p.y) < (1e-10);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-10);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-10)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-10)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-10)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-10)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-10)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-10)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-10)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-10));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v > b) return gcd(b, v);
if (v == 0) return b;
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
long long mod;
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0ll) {
x = 1ll;
y = 0ll;
return a;
}
long long d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
long long pr[220010];
long long inv[220010];
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
double bekid(double w, long long r) {
if (r == 0) return 1.0;
if (r == 1) return w;
if (r % 2) return bekid(w, r - 1) * w;
double f = bekid(w, r / 2);
return f * f;
}
long long comb(long long nn, long long rr) {
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = (pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
long long a[200020], b[200020], c[200020];
long long n, k;
bool ch(long long r) {
if (r == 0) return 0;
long long fu = 0;
for (long long i = 0; i < n; i++) {
if (c[i] >= 0) continue;
long long w = c[i];
w *= -1;
fu += w / r + !!(w % r);
}
if (fu > k) return 0;
vector<long long> ve;
for (long long i = 0; i < n; i++)
if (c[i] < 0) {
long long ima = 0;
long long val = a[i];
while (1) {
if (ima >= k) break;
if (val >= b[i]) {
ima += val / b[i];
val %= b[i];
continue;
}
long long ato = b[i] - val;
long long tuika = ato / r + !!(ato % r);
val += tuika * r;
val -= b[i];
for (long long j = 0; j < tuika; j++) ve.push_back(ima);
ima++;
}
}
sort(ve.begin(), ve.end());
for (long long i = 0; i < fu; i++) {
if (i > ve[i]) return 0;
}
return 1;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
k--;
if (k == 0) {
cout << 0 << endl;
return 0;
}
vector<long long> dame;
for (long long i = 0; i < n; i++) {
c[i] = a[i] - k * b[i];
if (c[i] >= 0) continue;
dame.push_back(a[i] / b[i]);
}
sort(dame.begin(), dame.end());
long long nn = dame.size();
for (long long i = 0; i < nn; i++) {
if (i > dame[i]) {
cout << -1 << endl;
return 0;
}
}
if (nn == 0) {
cout << 0 << endl;
return 0;
}
long long ue = 1000000007, si = 0, me;
ue *= ue;
while (ue - si > 1) {
me = (ue + si) / 2;
if (ch(me))
ue = me;
else
si = me;
}
cout << ue << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int t;
cin >> t;
vector<string> gu;
for (int g = 0; g < t; g++) {
string x;
cin >> x;
gu.push_back(x);
}
int ans = 6;
for (int g = 0; g < gu.size(); g++) {
for (int y = g + 1; y < gu.size(); y++) {
int cnt = 0;
for (int z = 0; z < 6; z++) {
cnt += (gu[g][z] != gu[y][z]);
}
ans = min(ans, (cnt - 1) / 2);
}
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
char s[N];
int sum[N << 1], q[N];
int tmp, n, mn, ans, ansl = 1, ansr = 1, t = 0;
void calc(int l, int r) {
int pos = l, cnt = tmp, tot = 1;
for (int i = l + 1; i < r; i++)
if (sum[i] == mn + 1) {
if (ans < cnt) {
ans = cnt;
ansl = pos + 1;
ansr = i;
}
pos = i;
cnt = tmp;
tot++;
} else if (sum[i] == mn + 2)
cnt++;
if (ans < tot) {
ansl = l;
ansr = r;
ans = tot;
}
}
int read() {
char ch = getchar();
int x = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
int main() {
n = read();
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + (s[i] == '(' ? 1 : -1);
mn = min(mn, sum[i]);
}
if (sum[n]) {
puts("0\n1 1");
return 0;
}
for (int i = 1; i <= n; i++)
if (sum[i] == mn) {
q[++t] = i;
tmp++;
}
for (int i = q[1]; i; i--) sum[n + i] = sum[i];
q[++t] = n + q[1];
ans = tmp;
for (int i = 2; i <= t; i++) calc(q[i - 1] + 1, q[i]);
if (ansl > n) ansl -= n;
if (ansr > n) ansr -= n;
printf("%d\n%d %d\n", ans, ansl, ansr);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, x;
cin >> s >> x;
vector<int> v;
s -= x;
if (s % 2 == 1 || s < 0) {
cout << 0;
return 0;
}
while (x) {
v.push_back(x % 2);
x /= 2;
}
long long ans = 1;
for (int i = 0; i < v.size(); i++) {
if (v[i]) {
ans *= 2;
}
}
vector<int> vs;
if (s == 0) {
ans -= 2;
} else {
s /= 2;
while (s) {
vs.push_back(s % 2);
s /= 2;
}
for (int i = 0; i < vs.size(); i++) {
if (i < v.size() && vs[i]) {
if (v[i]) {
ans = 0;
break;
}
}
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long dp[5011][5011];
int nxt[6000][27];
long long cnt[5011];
long long inv[100000 + 1];
long long kai[100000 + 1];
long long invkai[100000 + 1];
void invinit() {
inv[1] = 1;
for (int i = 2; i <= 100000; i++) {
inv[i] = mod - (mod / i) * inv[mod % i] % mod;
}
kai[0] = invkai[0] = 1;
for (int i = 1; i <= 100000; i++) {
kai[i] = kai[i - 1] * i % mod;
invkai[i] = invkai[i - 1] * inv[i] % mod;
}
}
long long com(long long a, long long b) {
if (b < 0 || a < b) return 0;
return (invkai[b] * invkai[a - b]) % mod * kai[a] % mod;
}
int main() {
int num;
scanf("%d", &num);
string str;
cin >> str;
str.push_back('z' + 1);
for (int i = 0; i < 27; i++) {
int now = 5005;
for (int j = num; j >= 0; j--) {
nxt[j][i] = now;
if (str[j] == i + 'a') now = j;
}
}
for (int i = 0; i <= num; i++) dp[i][0] = 1;
for (int i = num - 1; i >= 0; i--) {
for (int j = 0; j <= num; j++) {
dp[i][j + 1] = (dp[i + 1][j + 1] + dp[i + 1][j] + mod -
dp[nxt[i][str[i] - 'a']][j]) %
mod;
cnt[j + 1] += dp[i][j + 1] - dp[i + 1][j + 1] + mod;
}
}
for (int i = 1; i <= num; i++) cnt[i] %= mod;
invinit();
long long ans = 0;
for (int i = 1; i <= num; i++) {
ans += cnt[i] * com(num - 1, i - 1);
ans %= mod;
}
printf("%I64d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
template <typename T>
inline T read() {
register T sum = 0;
register char cc = getchar();
int sym = 1;
while (cc != '-' && (cc > '9' || cc < '0')) cc = getchar();
if (cc == '-') sym = -1, cc = getchar();
sum = sum * 10 + cc - '0';
cc = getchar();
while (cc >= '0' && cc <= '9') sum = sum * 10 + cc - '0', cc = getchar();
return sym * sum;
}
template <typename T>
inline T read(T& a) {
a = read<T>();
return a;
}
template <typename T, typename... Others>
inline void read(T& a, Others&... b) {
a = read(a);
read(b...);
}
int n, s[2010], f[2010][2010];
char str[2010];
int add(int x, int y) { return (x + y) % p; }
int sub(int x, int y) { return (x - y + p) % p; }
int mul(int x, int y) { return 1ll * x * y % p; }
int fpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = mul(res, x);
x = mul(x, x);
y >>= 1;
}
return res;
}
int Get(int l, int r) {
if (l > r) return 0;
return s[r] - s[l - 1];
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + (str[i] == '?');
for (int len = 2; len <= n; len++)
for (int l = 1; l + len - 1 <= n; l++) {
int r = l + len - 1;
if (str[l] != '(') f[l][r] = add(f[l][r], f[l + 1][r]);
if (str[r] != ')') f[l][r] = add(f[l][r], f[l][r - 1]);
if (str[l] != '(' && str[r] != ')')
f[l][r] = sub(f[l][r], f[l + 1][r - 1]);
if (str[l] != ')' && str[r] != '(')
f[l][r] =
add(f[l][r], add(f[l + 1][r - 1], fpow(2, Get(l + 1, r - 1))));
}
printf("%d\n", f[1][n]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = (long long)1e5 + 9;
const long long mod = (long long)1e9 + 7;
int main() {
std::ios::sync_with_stdio(0);
long long i, j, k, t, q, m, l, r, n, v1, v2;
cin >> n >> l >> v1 >> v2 >> k;
long long g = (n / k) + (n % k > 0);
double d, time;
d = (double)((v1 + v2) * l) / ((2 * v1 * g) - v1 + v2);
time = (2 * d * g - l) / (v2);
cout << setprecision(11) << time << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T>
int chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
int chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T mmin(T a, T b) {
return a < b ? a : b;
}
template <class T>
T mmax(T a, T b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
struct __INIT__ {
__INIT__() { memset(&inf, 0x3f, sizeof(inf)); }
} __INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
inline bool read(signed &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(long long &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r'))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
inline bool write(signed first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(long long first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
namespace mcf {
int to[260817], lst[260817], w[260817], beg[192608], c[260817], n, e = 1;
void add(int u, int v, int wa, int cost) {
to[++e] = v;
lst[e] = beg[u];
beg[u] = e;
c[e] = cost;
w[e] = wa;
to[++e] = u;
lst[e] = beg[v];
beg[v] = e;
c[e] = -cost;
w[e] = 0;
}
int mincost, dis[1926081], flw[1926081], pre[1926081], inq[1926081];
int q[19260817], *l, *r;
int spfa(int s, int t) {
for (int i = 1; i <= n; ++i) dis[i] = 0x3f3f3f3f, pre[i] = flw[i] = 0;
flw[s] = 0x3f3f3f3f;
pre[s] = 0;
*(l = r = q) = s;
dis[s] = 0;
while (l <= r) {
inq[*l] = 0;
for (int i = beg[*l]; i; i = lst[i])
if (w[i] && chkmin(dis[to[i]], dis[*l] + c[i])) {
pre[to[i]] = i;
flw[to[i]] = mmin(flw[*l], w[i]);
if (!inq[to[i]]) {
inq[to[i]] = 1;
*(++r) = to[i];
}
}
++l;
}
if (!flw[t]) return 0;
int flow = flw[t];
mincost += flow * dis[t];
while (pre[t]) {
s = pre[t];
w[s] -= flow;
w[s ^= 1] += flow;
t = to[s];
}
return flow;
}
int Min_Cost_Flow(int s, int t) {
while (spfa(s, t))
;
return mincost;
}
bool isw(int first, int second) {
for (int i = beg[first]; i; i = lst[i])
if (to[i] == second) return !w[i];
return 0;
}
} // namespace mcf
int a[55][55];
int is[55][55];
int id[55];
int s, t;
signed main() {
int n, m, u, v;
read(n, m);
for (int i = 1; i <= m; ++i) {
read(u, v);
a[u][v] = 1;
a[v][u] = -1;
}
s = ++mcf::n;
t = ++mcf::n;
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j) {
is[i][j] = is[j][i] = ++mcf::n;
mcf::add(s, is[i][j], 1, 0);
}
for (int i = 1; i <= n; ++i) id[i] = ++mcf::n;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j)
if (i != j) {
if (a[i][j] >= 0) {
mcf::add(is[i][j], id[i], 1, 0);
}
}
for (int j = 1; j <= n; ++j) mcf::add(id[i], t, 1, j);
}
mcf::Min_Cost_Flow(s, t);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i == j) {
putc('0');
} else if (mcf::isw(is[i][j], id[i])) {
putc('1');
} else
putc('0');
}
putc('\n');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using lli = int64_t;
const lli mod = 1e9 + 7;
lli power(lli a, lli b) {
lli ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans;
}
vector<lli> mul(const vector<lli>& a, const vector<lli>& b,
const vector<lli>& m) {
vector<lli> c(2);
c[0] = a[0] * b[0] % mod;
c[1] = (a[0] * b[1] % mod + a[1] * b[0] % mod) % mod;
lli c2 = a[1] * b[1] % mod;
(c[1] += c2 * m[1]) %= mod;
(c[0] += c2 * m[0]) %= mod;
return c;
}
vector<lli> power(vector<lli> a, lli n, const vector<lli>& m) {
vector<lli> ans(2);
ans[0] = 1;
while (n) {
if (n & 1) ans = mul(ans, a, m);
n >>= 1;
a = mul(a, a, m);
}
return ans;
}
struct num {
lli a, b;
num() : a(0), b(0) {}
num(lli a) : a(a), b(0) {}
num(lli a, lli b) : a(a), b(b) {}
num operator+(const num& rhs) const {
return num((a + rhs.a) % mod, (b + rhs.b) % mod);
}
num operator-(const num& rhs) const {
return num(((a - rhs.a) % mod + mod) % mod,
((b - rhs.b) % mod + mod) % mod);
}
num operator*(const lli& k) const { return num(a * k % mod, b * k % mod); }
num operator/(const lli& k) const {
lli rev = power(k, mod - 2);
return num(a * rev % mod, b * rev % mod);
}
num operator*(const num& rhs) const {
lli A = (a * rhs.a % mod + 5 * b * rhs.b % mod) % mod;
lli B = (a * rhs.b % mod + b * rhs.a % mod) % mod;
return num(A, B);
}
num operator/(const num& rhs) const {
lli den =
((rhs.a * rhs.a % mod - 5 * rhs.b * rhs.b % mod) % mod + mod) % mod;
return num(a, b) * num(rhs.a, (-rhs.b + mod) % mod) / den;
}
num operator^(const lli& n) const {
auto pol = power(
{0, 1}, n,
{((5 * b * b % mod - a * a % mod) % mod + mod) % mod, 2 * a % mod});
return num((a * pol[1] % mod + pol[0]) % mod, b * pol[1] % mod);
}
bool operator==(const num& rhs) const { return a == rhs.a && b == rhs.b; }
};
const num x = num(power(2, mod - 2), power(2, mod - 2));
const num y = num(power(2, mod - 2), mod - power(2, mod - 2));
const int M = 250;
lli ncr[M + 1][M + 1];
vector<lli> mult_pol(const vector<lli>& a, const vector<lli>& b) {
vector<lli> c(a.size() + b.size() - 1);
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < b.size(); ++j) {
(c[i + j] += a[i] * b[j]) %= mod;
}
}
return c;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ncr[0][0] = 1;
for (int i = 1; i <= M; ++i) {
ncr[i][0] = ncr[i][i] = 1;
for (int j = 1; j < i; ++j) {
ncr[i][j] = (ncr[i - 1][j - 1] + ncr[i - 1][j]) % mod;
}
}
int k;
lli l, r;
cin >> k >> l >> r;
vector<lli> stirling(1, 1);
for (int i = 0; i < k; ++i) {
stirling = mult_pol(stirling, {(-i + mod) % mod, 1ll});
}
auto T = [&](int j, lli n) {
num ans = 0;
num down = x ^ j;
num down_delta = y / x;
num up = down ^ (n + 3);
num up_delta = down_delta ^ (n + 3);
int alt = 1;
for (int r = 0; r <= j; ++r) {
if (down == 1) {
ans = ans + ((n + 3) % mod) * ncr[j][r] * alt;
} else {
ans = ans + (up - 1) / (down - 1) * ncr[j][r] * alt;
}
up = up * up_delta;
down = down * down_delta;
alt = mod - alt;
}
if (j & 1) {
ans = ans / num(0, power(5, j / 2));
} else {
ans = ans / num(power(5, j / 2), 0);
}
return (ans - 1).a;
};
lli ans = 0;
for (int j = 1; j <= k; ++j) {
(ans += stirling[j] * (T(j, r) - T(j, l - 1))) %= mod;
}
for (int i = 1; i <= k; ++i) {
ans = ans * power(i, mod - 2) % mod;
}
if (ans < 0) ans += mod;
cout << ans << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 1000005;
const double PI = 4 * atan(1);
const long long MAX = 9223372036854775807;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; }
bool isprime(long long u) {
for (long long i = 2; i <= (int)sqrt(u); i++) {
if (u % i == 0) return 0;
}
return 1;
}
long long mod(long long to_mod, long long MOD) {
to_mod %= MOD;
while (to_mod < 0) to_mod += MOD;
return to_mod % MOD;
}
long long moduloMultiplication(long long a, long long b) {
long long res = 0;
while (b) {
if (b & 1) res = (res + a);
a = (2 * a);
b >>= 1;
}
return res;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long q, y, k, z, w, t, l, r, x, n, m;
long long a[N];
stack<long long> ss;
int main() {
cin.tie(0);
cout.tie(0);
cin >> n;
x = 0;
y = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
x = max(x, a[i]);
}
for (int i = 0; i < n;) {
if (i == n - 1) {
if (!ss.empty() && a[i] == ss.top() && a[i] >= y) {
ss.pop();
} else {
ss.push(a[i]);
}
i++;
} else {
if (!ss.empty() && a[i] == ss.top() && a[i] >= y) {
ss.pop();
if (ss.empty()) {
y = -1;
} else {
y = max(y, a[i]);
}
i++;
} else if (a[i] == a[i + 1]) {
i += 2;
if (ss.empty()) {
y = -1;
} else {
y = max(y, a[i]);
}
} else {
ss.push(a[i]);
i++;
y = a[i];
}
}
}
if (ss.size() == 0) {
cout << "YES";
return 0;
} else if (ss.size() == 1 && ss.top() >= x) {
cout << "YES";
return 0;
}
while (!ss.empty()) {
ss.pop();
}
reverse(a, a + n);
for (int i = 0; i < n;) {
if (i == n - 1) {
if (!ss.empty() && a[i] == ss.top() && a[i] >= y) {
ss.pop();
} else {
ss.push(a[i]);
}
i++;
} else {
if (!ss.empty() && a[i] == ss.top() && a[i] >= y) {
ss.pop();
if (ss.empty()) {
y = -1;
} else {
y = max(y, a[i]);
}
i++;
} else if (a[i] == a[i + 1]) {
i += 2;
if (ss.empty()) {
y = -1;
} else {
y = max(y, a[i]);
}
} else {
ss.push(a[i]);
i++;
y = a[i];
}
}
}
if (ss.size() == 0) {
cout << "YES";
return 0;
} else if (ss.size() == 1 && ss.top() >= x) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int a_s[27][100000];
int main() {
int re_i;
int n, i, j, k, min_c, d_c;
int c_i;
int s_num;
int way_num[27];
int d_v[27];
int re[27];
int c_re[27];
int re_min;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
if (n < 3) {
min_c = 0;
} else {
memset(way_num, 0, sizeof(way_num));
int c_1, c_2, c_3;
for (i = 0; i < 27; i++) {
c_1 = i / 9 - 1;
c_2 = (i % 9) / 3 - 1;
c_3 = ((i % 9) % 3) - 1;
a_s[i][0] = a[0] + c_1;
a_s[i][1] = a[1] + c_2;
a_s[i][2] = a[2] + c_3;
}
for (i = 0; i < 27; i++) {
d_v[i] = a_s[i][0] - a_s[i][1];
}
for (i = 0; i < 27; i++) {
d_c = a_s[i][1] - a_s[i][2];
if (abs(d_v[i] - d_c) > 0.0001) {
way_num[i] = 1;
}
}
if (n > 3) {
for (i = 0; i < 27; i++) {
if (way_num[i] == 1) {
} else {
for (j = 3; j < n; j++) {
a_s[i][j] = a[j];
d_c = a_s[i][j - 1] - a_s[i][j];
if (abs(d_v[i] - d_c) > 0.0001) {
a_s[i][j] = a[j] + 1;
d_c = a_s[i][j - 1] - a_s[i][j];
if (abs(d_v[i] - d_c) > 0.0001) {
a_s[i][j] = a[j] - 1;
d_c = a_s[i][j - 1] - a_s[i][j];
if (abs(d_v[i] - d_c) > 0.0001) {
way_num[i] = 1;
}
}
}
}
}
}
}
s_num = 0;
k = 0;
for (i = 0; i < 27; i++) {
if (way_num[i] != 1) {
s_num++;
re[k] = i;
k++;
}
}
if (s_num > 0) {
if (s_num == 1) {
i = re[0];
min_c = 0;
for (j = 0; j < n; j++) {
min_c += abs(a_s[i][j] - a[j]);
}
} else {
for (i = 0; i < s_num; i++) {
c_re[i] = 0;
re_i = re[i];
for (c_i = 0; c_i < n; c_i++) {
c_re[i] += abs(a_s[re_i][c_i] - a[c_i]);
}
}
re_min = c_re[0];
re_i = re[0];
for (i = 1; i < k; i++) {
if (re_min > c_re[i]) {
re_min = c_re[i];
re_i = re[i];
}
}
min_c = re_min;
}
} else {
min_c = -1;
}
}
cout << min_c << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 5101;
const int inf = 1e9;
int a[M], b[M], c[M];
int sto1[M], sto2[M], sto3[M];
int d[M];
int flag[M];
int f[2][91][91][91];
int calc(int k, int n) {
if (n < 2 * k) return 500;
if (n < 4 * k) return 1000;
if (n < 8 * k) return 1500;
if (n < 16 * k) return 2000;
if (n < 32 * k) return 2500;
return 3000;
}
int calc1(int pt, int mi) {
if (mi == 0) return 0;
if (mi < 0) mi = -mi;
return pt / 250 * (250 - mi);
}
bool ok(int bit, int id) {
if ((bit & 4) && c[id] >= 0) return 0;
if ((bit & 2) && b[id] >= 0) return 0;
if ((bit & 1) && a[id] >= 0) return 0;
return 1;
}
void chkmin(int &aa, int bb) {
if (aa > bb) aa = bb;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d %d %d", &a[i], &b[i], &c[i]);
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
if (a[1] || 1) {
for (int i = 2; i <= n; i++)
if (a[i] < 0) sto1[cnt1++] = i;
}
if (b[1] || 1) {
for (int i = 2; i <= n; i++)
if (b[i] < 0) sto2[cnt2++] = i;
}
if (c[1] || 1) {
for (int i = 2; i <= n; i++)
if (c[i] < 0) sto3[cnt3++] = i;
}
if (cnt1 + cnt2 + cnt3 >= 90) return puts("1");
int cnt = 0;
for (int i = 0; i < cnt1; i++) d[cnt++] = sto1[i];
for (int i = 0; i < cnt2; i++) d[cnt++] = sto2[i];
for (int i = 0; i < cnt3; i++) d[cnt++] = sto3[i];
sort(d, d + cnt);
cnt = unique(d, d + cnt) - d;
for (int i = 0; i < cnt; i++) flag[d[i]] = 1;
int A = 0, B = 0, C = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > 0) A++;
if (b[i] > 0) B++;
if (c[i] > 0) C++;
}
int ans = n;
for (int i = 0; i <= cnt1; i++)
if (i == cnt1 || calc(A + cnt1 - i, n) != calc(A + cnt1 - i - 1, n)) {
for (int j = 0; j <= cnt2; j++)
if (j == cnt2 || calc(B + cnt2 - j, n) != calc(B + cnt2 - j - 1, n)) {
for (int k = 0; k <= cnt3; k++)
if (k == cnt3 ||
calc(C + cnt3 - k, n) != calc(C + cnt3 - k - 1, n)) {
int AA = A + cnt1 - i, BB = B + cnt2 - j, CC = C + cnt3 - k;
int aa = calc(AA, n);
int bb = calc(BB, n);
int cc = calc(CC, n);
int my_pt = calc1(aa, a[1]) + calc1(bb, b[1]) + calc1(cc, c[1]) +
(i + j + k) * 100;
int rnk = 0;
for (int r = 2; r <= n; r++)
if (!flag[r]) {
int e_pt =
calc1(aa, a[r]) + calc1(bb, b[r]) + calc1(cc, c[r]);
if (my_pt < e_pt) rnk++;
}
bool bf = 0;
for (int ii = 0; ii <= i; ii++)
for (int jj = 0; jj <= j; jj++)
for (int kk = 0; kk <= k; kk++) f[bf][ii][jj][kk] = inf;
f[bf][0][0][0] = 0;
for (int r = cnt; r; r--) {
for (int ii = 0; ii <= i; ii++)
for (int jj = 0; jj <= j; jj++)
for (int kk = 0; kk <= k; kk++) f[bf ^ 1][ii][jj][kk] = inf;
for (int ii = 0; ii <= i; ii++) {
for (int jj = 0; jj <= j; jj++) {
for (int kk = 0; kk <= k; kk++)
if (f[bf][ii][jj][kk] != inf) {
for (int bit = 0; bit < 8; bit++)
if (ok(bit, d[r - 1])) {
if (ii + ((bit & 1) > 0) > i) continue;
if (jj + ((bit & 2) > 0) > j) continue;
if (kk + ((bit & 4) > 0) > k) continue;
int X = a[d[r - 1]], Y = b[d[r - 1]],
Z = c[d[r - 1]];
if (bit & 1) X = 0;
if (bit & 2) Y = 0;
if (bit & 4) Z = 0;
int pt = calc1(aa, X) + calc1(bb, Y) + calc1(cc, Z);
chkmin(
f[bf ^ 1][ii + ((bit & 1) > 0)]
[jj + ((bit & 2) > 0)][kk + ((bit & 4) > 0)],
f[bf][ii][jj][kk] + (my_pt < pt));
}
}
}
}
bf = bf ^ 1;
}
rnk += f[bf][i][j][k];
chkmin(ans, rnk + 1);
}
}
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
#define ST first
#define ND second
#define MP make_pair
#define PB push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
const int MAXN = 200010;
int n, a[MAXN], b[MAXN], su[MAXN], res;
set<pi> s;
int main () {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i=1; i<=n; i++) {
cin >> a[i] >> b[i];
s.insert(MP(a[i], i));
s.insert(MP(b[i], i));
// pos[a[i]] = i;
// pos[b[i]] = i;
su[i] = a[i] + b[i];
}
while (s.size()) {
int ile_dol = s.begin()->first, ile_gor;
int swaps = 0, total = 0;
int pop_fr = 2*n+1, pop_ba = 0;
// cout << s.begin()->first << endl;
while (true) {
int obr = 0;
while (s.size()) {
auto it=*s.begin();
int aa = it.ST;
if (aa > ile_dol) break;
int po = it.ND;
int bb = su[po] - aa;
if (b[po] == aa) swaps++;
if (bb > pop_fr) {
cout << -1 << endl;
return 0;
}
pop_fr = bb;
ile_gor = bb;
s.erase(MP(aa, po));
s.erase(MP(bb, po));
// printf("(1) usuwam %d %d z %d\n", aa, bb, po);
total++;
obr++;
}
if (obr == 0) break;
obr = 0;
while (s.size()) {
auto it=*s.rbegin();
int aa = it.ST;
if (aa < ile_gor) break;
int po = it.ND;
int bb = su[po] - aa;
if (b[po] == aa) swaps++;
if (bb < pop_ba) {
cout << -1 << endl;
return 0;
}
pop_ba = bb;
ile_dol = bb;
s.erase(MP(aa, po));
s.erase(MP(bb, po));
// printf("(2) usuwam %d %d z %d\n", aa, bb, po);
total++;
obr++;
}
if (obr == 0) break;
}
if (s.size() == 0 && pop_fr < pop_ba) {
cout << -1 << endl;
return 0;
}
res += min(swaps, total - swaps);
}
cout << res << endl;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
using namespace std;
bool isprime(long long n) {
if (n % 2 == 0) {
return false;
}
for (auto i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long digitsum(long long n) {
long long sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
int main() {
int n, cnt = 0, r = 0;
cin >> n;
char a[n][n];
for (auto i = 0; i < n; i++)
for (auto j = 0; j < n; j++) cin >> a[i][j];
for (auto i = 0; i < n; i++) {
for (auto j = 0; j < n; j++) {
cnt = 0;
if (a[i][j] == 'C') {
for (auto k = i + 1; k < n; k++)
if (a[k][j] == 'C') cnt++;
for (auto k = j + 1; k < n; k++)
if (a[i][k] == 'C') cnt++;
}
r += cnt;
}
}
cout << r;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
char c = s[0];
int cnt = 0, ans = 0;
for (int i = 0; i < s.length();) {
int j = i;
while (s[j] == c && cnt < 5 && j < s.length()) {
cnt++;
j++;
}
++ans;
c = s[j];
i = j;
cnt = 0;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
const int INF = 1e9 + 9;
struct elem {
int w, s, c;
int l, r;
elem() {}
} a[N];
int n, second;
int d[N][N], td[N];
vector<int> v[N];
bool operator<(const elem &x, const elem &y) {
return (x.r - x.l != y.r - y.l) ? (x.r - x.l < y.r - y.l) : (x.l < y.l);
}
void Calc_dp() {
for (int i = int(1); i <= int(n); ++i) {
for (int spc = int(0); spc <= int(a[i].s); ++spc) {
for (int k = int(a[i].l); k <= int(a[i].r); ++k) {
td[k] = (k == a[i].l ? 0 : td[k - 1]);
for (auto son : v[k]) {
if (a[son].l < a[i].l || spc < a[son].w || i == son) continue;
td[k] =
max(td[k], td[a[son].l] + d[son][min(spc - a[son].w, a[son].s)]);
}
}
d[i][spc] = a[i].c + td[a[i].r];
}
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> second;
for (int i = int(1); i <= int(n); ++i)
cin >> a[i].l >> a[i].r >> a[i].w >> a[i].s >> a[i].c;
++n;
a[n].l = 0, a[n].r = 2 * n;
a[n].s = second, a[n].c = 0;
sort(a + 1, a + 1 + n);
for (int i = int(1); i <= int(n); ++i) v[a[i].r].push_back(i);
Calc_dp();
cout << d[n][second] << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int base = 987654323;
const int maxn = 100005;
struct ljb {
int num, dest;
ljb *next;
} * p, *head[maxn], *tail[maxn];
long long bzhash[maxn][18], powc[maxn], hasha[maxn];
int bzfa[maxn][18], dis1[maxn], dis2[maxn], sa[maxn], bak[maxn], f1[maxn],
f2[maxn], flag[maxn], which[maxn], fa1[maxn], fa2[maxn], fac1[maxn],
fac2[maxn];
pair<int, int> qj[maxn];
int q, lc, rc, o1, o2, o, e, father;
char ch;
bool cmp(int xc, int yc) {
for (int i = 17; i >= 0; i--) {
if ((bzfa[xc][i] != 0) && (bzfa[yc][i] != 0))
if (bzhash[xc][i] == bzhash[yc][i]) {
xc = bzfa[xc][i];
yc = bzfa[yc][i];
}
}
if (fa2[xc] + fa2[yc] == 0) return false;
if (fa2[xc] == 0) return true;
if (fa2[yc] == 0) return false;
return fac2[xc] < fac2[yc];
}
void mpush(int x, int y, int z) {
ljb *p;
p = new ljb;
p->dest = y;
p->num = z;
p->next = 0;
tail[x]->next = p;
tail[x] = p;
}
int getfa(int s, int k) {
for (int i = 17; i >= 0; i--)
if (k >= (1 << i)) {
s = bzfa[s][i];
k -= 1 << i;
}
return s;
}
void dfs(int s, int left, int right) {
qj[s] = make_pair(left, right);
int c = 0, ll, rr, mm, lc, rc, nowc;
ljb *p = head[s]->next;
while (p != 0) {
ll = left;
rr = right;
while (ll <= rr) {
mm = (ll + rr) / 2;
nowc = getfa(sa[mm], dis1[s] - 1);
if (fac2[nowc] >= p->num)
rr = mm - 1;
else
ll = mm + 1;
}
lc = ll;
ll = left;
rr = right;
while (ll <= rr) {
mm = (ll + rr) / 2;
nowc = getfa(sa[mm], dis1[s] - 1);
if (fac2[nowc] <= p->num)
ll = mm + 1;
else
rr = mm - 1;
}
rc = rr;
dfs(p->dest, lc, rc);
p = p->next;
}
}
void plus1(int s) {
while (s <= o2) {
f1[s]++;
s += s & (-s);
}
}
int gs1(int s) {
int ss = 0;
while (s > 0) {
ss += f1[s];
s -= s & (-s);
}
return ss;
}
int getsum1(int l, int r) { return gs1(r) - gs1(l - 1); }
void pl2(int s, int flag) {
while (s <= o2) {
f2[s] += flag;
s += s & (-s);
}
}
void plus2(int l, int r) {
pl2(l, 1);
pl2(r + 1, -1);
}
int gettime2(int s) {
int ss = 0;
while (s > 0) {
ss += f2[s];
s -= s & (-s);
}
return ss;
}
int main() {
powc[0] = 1;
for (int i = 1; i <= maxn; i++) powc[i] = powc[i - 1] * base;
o1 = 1;
o2 = 1;
scanf("%d\n", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d %c\n", &flag[i], &father, &ch);
if (flag[i] == 1) {
++o1;
fa1[o1] = father;
fac1[o1] = ch - 96;
which[i] = o1;
} else {
++o2;
fa2[o2] = father;
fac2[o2] = ch - 96;
which[i] = o2;
}
}
for (int i = 1; i <= o2; i++) {
if (i == 1)
bzhash[i][0] = 0;
else
bzhash[i][0] = fac2[i];
if (i == 1)
bzfa[i][0] = 0;
else
bzfa[i][0] = fa2[i];
o = 1;
e = fa2[i];
while (bzfa[e][o - 1] != 0) {
bzhash[i][o] = bzhash[i][o - 1] * powc[1 << (o - 1)] + bzhash[e][o - 1];
bzfa[i][o] = bzfa[e][o - 1];
e = bzfa[i][o];
o++;
}
}
dis1[1] = 1;
for (int i = 2; i <= o1; i++) dis1[i] = dis1[fa1[i]] + 1;
dis2[1] = 1;
for (int i = 2; i <= o2; i++) dis2[i] = dis2[fa2[i]] + 1;
for (int i = 1; i <= o2; i++) sa[i] = i;
sort(sa + 1, sa + o2 + 1, cmp);
for (int i = 1; i <= o2; i++) bak[sa[i]] = i;
for (int i = 0; i <= o1; i++) {
p = new ljb;
p->dest = 0;
p->num = 0;
p->next = 0;
head[i] = p;
tail[i] = p;
}
for (int i = 2; i <= o1; i++) mpush(fa1[i], i, fac1[i]);
dfs(1, 1, o2);
memset(f1, 0, sizeof(f1));
memset(f2, 0, sizeof(f2));
long long ans = 1, nt;
plus2(1, o2);
plus1(1);
for (int i = 1; i <= q; i++) {
if (flag[i] == 1) {
lc = qj[which[i]].first;
rc = qj[which[i]].second;
ans += getsum1(lc, rc);
plus2(lc, rc);
} else {
lc = bak[which[i]];
ans += gettime2(lc);
plus1(lc);
}
printf("%I64d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int GCD(int u, int v) {
while (v != 0) {
int r = u % v;
u = v;
v = r;
}
return u;
}
int main() {
int amtV;
int amtE;
std::vector<std::pair<int, int>> graph;
std::cin >> amtV >> amtE;
int connected = 0;
int remaining = amtE;
if (amtE >= amtV - 1) {
for (int i = 2; i <= amtV; i++) {
graph.push_back(std::pair<int, int>(i, 1));
}
remaining = amtE - (amtV - 1);
for (int i = 3; i <= amtV; i += 2) {
if (remaining == 0) break;
graph.push_back(std::pair<int, int>(i, 2));
remaining--;
}
int currInd = 3;
int currCompare;
while (remaining > 0 && currInd < amtV) {
currCompare = currInd + 1;
while (remaining > 0 && currCompare <= amtV) {
if (GCD(currInd, currCompare) == 1) {
graph.push_back(std::pair<int, int>(currInd, currCompare));
remaining--;
}
currCompare++;
}
currInd++;
}
}
if (remaining == 0) {
std::cout << "Possible" << std::endl;
for (auto it = graph.begin(); it != graph.end(); it++) {
std::cout << it->first << " " << it->second << std::endl;
}
} else {
std::cout << "Impossible" << std::endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int N = 2102;
int dpf[N][N], dpr[N][N];
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
for (int i = n; i >= 1; --i)
for (int j = m; j >= 1; --j)
if (s[i - 1] == t[j - 1]) dpf[i][j] = dpf[i + 1][j + 1] + 1;
reverse(s.begin(), s.end());
for (int i = n; i >= 1; --i)
for (int j = m; j >= 1; --j)
if (s[i - 1] == t[j - 1]) dpr[i][j] = dpr[i + 1][j + 1] + 1;
bool flag = true;
vector<pair<int, int>> v;
for (int i = 1; i <= m; ++i) {
int len1 = 0, len2 = 0, p1 = 0, p2 = 0;
for (int j = 1; j <= n; ++j) {
if (dpf[j][i] > len1) {
len1 = dpf[j][i];
p1 = j;
}
}
for (int j = 1; j <= n; ++j) {
if (dpr[j][i] > len2) {
len2 = dpr[j][i];
p2 = j;
}
}
if (len1 || len2) {
if (len1 >= len2) {
int l = p1, r = p1 + len1 - 1;
i += len1 - 1;
v.push_back(make_pair(l, r));
} else {
int l = n - p2 + 1, r = n - (p2 + len2) + 2;
i += len2 - 1;
v.push_back(make_pair(l, r));
}
} else {
flag = false;
break;
}
}
if (flag == false)
cout << "-1\n";
else {
cout << v.size() << "\n";
for (auto i : v) cout << i.first << " " << i.second << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int q;
int fa[400005];
int val[400005];
int a[400005];
int tot = 0;
map<int, int> mp;
inline int find(int x) {
if (fa[x] != x) {
find(fa[x]);
val[x] = val[x] ^ val[fa[x]];
fa[x] = find(fa[x]);
}
return fa[x];
}
inline void uni(int x, int y, int w) {
int xf = find(x), yf = find(y);
if (xf == yf) return;
fa[xf] = yf, val[xf] = val[x] ^ val[y] ^ w;
}
inline int read() {
int ans = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) ans = ans * 10 + ch - '0';
return ans;
}
inline void swap(int &a, int &b) {
int t = a;
a = b, b = t;
}
int main() {
int last = 0;
int typ, l, r, w;
int x, y;
register int i;
q = read();
for (i = 1; i <= q; i++) {
typ = read(), l = read(), r = read();
l ^= last, r ^= last;
if (l > r) swap(l, r);
l--;
if (mp.find(l) == mp.end()) {
a[++tot] = l;
fa[tot] = tot;
mp[l] = tot;
}
if (mp.find(r) == mp.end()) {
a[++tot] = r;
fa[tot] = tot;
mp[r] = tot;
}
x = mp[l], y = mp[r];
if (typ == 2) {
if (find(x) != find(y))
printf("-1\n"), last = 1;
else
last = val[x] ^ val[y], printf("%d\n", last);
} else {
w = read();
w ^= last;
uni(x, y, w);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int inf = 1000000009;
int rd() {
char c = getchar();
int t = 0, f = 1;
while (!isdigit(c)) f = (c == '-') ? -1 : 1, c = getchar();
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
return t * f;
}
void wt(int x) {
if (x > 9) wt(x / 10);
putchar(x % 10 + 48);
return;
}
map<pair<int, int>, int> Map;
set<int> Set;
int Brase[N], x[N], y[N], id, Ans, n;
int Get(int p) {
if (p == 1)
return *--Set.lower_bound(inf);
else
return *Set.upper_bound(-1);
}
void Dec(int i) {
if (!i) return;
Brase[i]--;
if (Brase[i] == 1) {
if (Set.count(Map[make_pair(x[i] - 1, y[i] - 1)]))
Set.erase(Map[make_pair(x[i] - 1, y[i] - 1)]);
if (Set.count(Map[make_pair(x[i], y[i] - 1)]))
Set.erase(Map[make_pair(x[i], y[i] - 1)]);
if (Set.count(Map[make_pair(x[i] + 1, y[i] - 1)]))
Set.erase(Map[make_pair(x[i] + 1, y[i] - 1)]);
}
return;
}
void Check(int i) {
if (!i) return;
if (Brase[Map[make_pair(x[i] - 1, y[i] + 1)]] > 1 &&
Brase[Map[make_pair(x[i], y[i] + 1)]] > 1 &&
Brase[Map[make_pair(x[i] + 1, y[i] + 1)]] > 1)
Set.insert(i);
return;
}
void Erase(int i) {
Set.erase(i);
Map[make_pair(x[i], y[i])] = 0;
if (y[i] == 0) return;
for (int j = ((int)-1); j <= ((int)1); j++)
Check(Map[make_pair(x[i] + j, y[i] - 1)]);
}
int main() {
n = rd();
Set.insert(-1);
Set.insert(inf);
Brase[0] = 1 << 30;
for (int i = ((int)1); i <= ((int)n); i++) {
x[i] = rd(), y[i] = rd();
Map[make_pair(x[i], y[i])] = i;
}
for (int i = ((int)1); i <= ((int)n); i++) {
if (y[i] == 0) Brase[i] = 3;
if (Map[make_pair(x[i] - 1, y[i] - 1)]) Brase[i]++;
if (Map[make_pair(x[i], y[i] - 1)]) Brase[i]++;
if (Map[make_pair(x[i] + 1, y[i] - 1)]) Brase[i]++;
}
for (int i = ((int)1); i <= ((int)n); i++) Check(i);
for (int i = ((int)1); i <= ((int)n); i++) {
id = Get(i & 1);
Ans = (1ll * n * Ans + id - 1) % inf;
Dec(Map[make_pair(x[id] - 1, y[id] + 1)]);
Dec(Map[make_pair(x[id], y[id] + 1)]);
Dec(Map[make_pair(x[id] + 1, y[id] + 1)]);
Erase(id);
}
return wt(Ans), 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
double P[N];
const int IT = 2000000;
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
printf("%.10lf\n", 1.0);
return 0;
}
vector<int> S(n);
for (int i = 0; i < n; i++) {
scanf("%lf", &P[i]);
P[i] /= 100.0;
}
sort(P, P + n);
vector<double> mn(n, 1);
double prev = 0;
double ans = 0;
for (int i = 0; i < n; i++) {
mn[i] = 1 - P[i];
}
prev = 1;
for (int i = 0; i < n; i++) prev *= P[i];
ans += prev * n;
double prod = prev;
for (int j = n + 1; j < IT; j++) {
int c = -1;
double best = -1e100;
double best_without = -1e100;
for (int q = 0; q < n; q++) {
double without = 1.0 - mn[q] * (1.0 - P[q]);
without *= prod / (1.0 - mn[q]);
if (best < without) best = without, c = q, best_without = without;
}
if (best > 1.0 - 1e-13) break;
ans += (best - prev) * j;
mn[c] *= (1 - P[c]);
prev = best;
prod = best_without;
}
printf("%.10lf\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 112345;
int n;
double p, c[maxn], k[maxn];
long long tot;
bool check(double w) {
double res = 0;
for (int i = 1; i <= n; i++) {
if (k[i] - w * c[i] > 1e-6) continue;
res += (w * c[i] - k[i]) * 1.0 / p;
}
if (res - w > 1e-6) return 1;
return 0;
}
int main() {
scanf("%d%lf", &n, &p);
for (int i = 1; i <= n; i++) {
scanf("%lf%lf", c + i, k + i);
tot += c[i];
}
if (p - tot >= 0) {
printf("-1\n");
return 0;
}
double l = 0.0, r = 99999999999999.99999;
for (int i = 1; i <= 200; i++) {
double mid = (l + r) * 1.0 / 2.0;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.12f\n", l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400200;
int arr[MAXN];
set<int> occs[MAXN];
struct ST {
ST *left, *right;
int L, R;
int minA, deltaA, firstMin, lastMin;
int maxSuffix, maxPrefix, maxTotal;
int sumBet;
ST(int a, int b) {
L = a, R = b;
minA = 0, deltaA = 0, firstMin = L, lastMin = L;
maxSuffix = 0, maxPrefix = 0, maxTotal = 0;
sumBet = 0;
if (L == R) {
return;
} else {
int mid = (a + b) / 2;
left = new ST(a, mid);
right = new ST(mid + 1, b);
merge();
}
}
int getMin() { return deltaA + minA; }
void prop() {
if (deltaA != 0) return;
left->deltaA += deltaA;
right->deltaA += deltaA;
deltaA = 0;
}
void merge() {
if (left->getMin() == right->getMin()) {
minA = left->getMin(), firstMin = left->firstMin;
lastMin = right->lastMin, maxSuffix = right->maxSuffix;
maxPrefix = left->maxPrefix,
maxTotal = max(left->maxTotal, right->maxTotal);
sumBet = left->sumBet + right->sumBet +
(max(left->maxSuffix, right->maxPrefix));
} else if (left->getMin() < right->getMin()) {
minA = left->getMin(), firstMin = left->firstMin;
lastMin = left->lastMin,
maxSuffix = max(left->maxSuffix, right->maxTotal);
maxPrefix = left->maxPrefix,
maxTotal = max(left->maxTotal, right->maxTotal);
sumBet = left->sumBet;
} else {
minA = right->getMin(), firstMin = right->firstMin;
lastMin = right->lastMin, maxSuffix = right->maxSuffix;
maxPrefix = max(left->maxTotal, right->maxPrefix),
maxTotal = max(left->maxTotal, right->maxTotal);
sumBet = right->sumBet;
}
}
void rangeAdd(int a, int b, int val) {
if (b < L || R < a) return;
if (a <= L && R <= b) {
deltaA += val;
return;
}
prop();
left->rangeAdd(a, b, val);
right->rangeAdd(a, b, val);
merge();
}
void pointUpdate(int idx, int val) {
if (L == R) {
maxSuffix = maxPrefix = sumBet = 0;
maxTotal = val;
return;
}
prop();
if (idx <= left->R)
left->pointUpdate(idx, val);
else
right->pointUpdate(idx, val);
merge();
}
};
void sol() {
int N, Q;
cin >> N >> Q;
for (int i = 0; i < N; i++) {
cin >> arr[i];
occs[arr[i]].insert(i);
}
ST *root = new ST(0, MAXN - 1);
for (int i = 1; i <= 200000; i++)
if ((int)occs[i].size()) {
int L = *(occs[i].begin());
int R = *(prev(occs[i].end()));
root->pointUpdate(2 * L + 1, (int)occs[i].size());
L = 2 * L + 1, R = 2 * R + 1;
root->rangeAdd(L, R, 1);
}
cout << N - (root->sumBet) << '\n';
auto removeElem = [&](int idx, int oldVal) {
if (idx == *occs[oldVal].begin()) {
root->pointUpdate(2 * idx + 1, 0);
int L = 2 * idx + 1;
occs[oldVal].erase(occs[oldVal].begin());
int R = L;
if ((int)occs[oldVal].size()) R = 2 * (*occs[oldVal].begin());
root->rangeAdd(L, R, -1);
} else if (idx == *(prev(occs[oldVal].end()))) {
int R = 2 * idx + 1;
occs[oldVal].erase(prev(occs[oldVal].end()));
int L = R;
if ((int)occs[oldVal].size()) {
int newLast = *(prev(occs[oldVal].end()));
L = 2 * newLast + 2;
}
root->rangeAdd(L, R, -1);
} else {
occs[oldVal].erase(occs[oldVal].lower_bound(idx));
}
if ((int)occs[oldVal].size()) {
int beg = *occs[oldVal].begin();
root->pointUpdate(2 * beg + 1, (int)occs[oldVal].size());
}
};
auto addElem = [&](int idx, int val) {
if (!(int)occs[val].size()) {
occs[val].insert(idx);
root->pointUpdate(2 * idx + 1, 1);
root->rangeAdd(2 * idx + 1, 2 * idx + 1, 1);
return;
}
int first = *occs[val].begin();
int last = *prev(occs[val].end());
occs[val].insert(idx);
if (idx < first) {
root->pointUpdate(2 * first + 1, 0);
root->pointUpdate(2 * idx + 1, (int)occs[val].size());
root->rangeAdd(2 * idx + 1, 2 * first, 1);
} else if (idx > last) {
root->pointUpdate(2 * first + 1, (int)occs[val].size());
root->rangeAdd(2 * last + 2, 2 * idx + 1, 1);
} else {
root->pointUpdate(2 * first + 1, (int)occs[val].size());
}
};
for (int qq = 1; qq <= Q; qq++) {
int idx, nxtVal;
cin >> idx >> nxtVal;
idx--;
int oldVal = arr[idx];
removeElem(idx, oldVal);
arr[idx] = nxtVal;
addElem(idx, nxtVal);
cout << N - (root->sumBet) << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
sol();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[30][2];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2; ++j) {
cin >> a[i][j];
}
}
int counter = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (a[i][0] == a[j][1]) counter++;
}
}
cout << counter << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct hh {
int from, to, next;
} qq[20100];
int box[3010];
int n;
int visit[3010];
int vv[3010];
int ans[3010];
int huan[3010];
int fat[3010];
int top;
void add(int from, int to, int kk) {
qq[kk].from = from;
qq[kk].to = to;
qq[kk].next = box[from];
box[from] = kk;
}
bool dfs(int v, int f) {
visit[v] = 1;
int i;
for (i = box[v]; i != -1; i = qq[i].next) {
if ((i ^ f) == 1) continue;
int w = qq[i].to;
fat[w] = v;
if (visit[w]) {
huan[top++] = w;
vv[w] = 1;
int x = v;
do {
vv[x] = 1;
huan[top++] = x;
x = fat[x];
} while (x != w);
return true;
} else if (dfs(w, i))
return true;
}
return false;
}
void bfs(int v) {
int head = 0, end = 1;
int que[3010];
que[0] = v;
int i;
while (head < end) {
int ima = que[head++];
for (i = box[ima]; i != -1; i = qq[i].next) {
int w = qq[i].to;
if (!vv[w]) {
que[end++] = w;
ans[w] = ans[ima] + 1;
vv[w] = 1;
}
}
}
}
int main() {
scanf("%d", &n);
int i;
int k = 0;
memset(box, -1, sizeof(box));
memset(visit, 0, sizeof(visit));
memset(vv, 0, sizeof(vv));
for (i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y, k++);
add(y, x, k++);
}
top = 0;
fat[1] = -1;
dfs(1, -1);
for (i = 0; i < top; ++i) {
ans[huan[i]] = 0;
bfs(huan[i]);
}
for (i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
vector<pair<int, char> > gr[N];
vector<int> nivel[N];
pair<int, int> pai[N];
int dist[N];
int solve(vector<int> at, int root) {
if ((int)at.size() <= 1) return root ? (int)at.size() : 0;
int res = 0;
for (char c = 'a'; c <= 'z'; c++) {
vector<int> next;
for (auto u : at) {
for (auto v : gr[u]) {
if (dist[v.first] < dist[u]) continue;
if (v.second == c) next.push_back(v.first);
}
}
res += solve(next, 0);
}
return res + (int)at.size() + (root ? 0 : -1);
}
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
char c;
scanf("%d %d %c", &u, &v, &c);
gr[u].emplace_back(v, c);
gr[v].emplace_back(u, c);
}
queue<int> q;
memset(dist, 0x3f3f3f3f, sizeof dist);
dist[1] = 0;
q.push(1);
while (!q.empty()) {
int u = q.front();
nivel[dist[u]].push_back(u);
q.pop();
for (auto v : gr[u]) {
if (dist[v.first] > dist[u] + 1) {
pai[v.first] = make_pair(u, v.second);
dist[v.first] = dist[u] + 1;
q.push(v.first);
}
}
}
int res = 0, at = 0;
for (int i = 1; i <= n; i++) {
int x = 0;
for (auto u : nivel[i - 1]) {
vector<int> w;
for (auto v : gr[u])
if (dist[v.first] > dist[u]) w.push_back(v.first);
x += solve(w, 1);
}
if (res < x) {
res = x;
at = i;
}
}
cout << n - res << endl << at << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct __io_dev {
__io_dev(const bool& __fastio = false) {
if (__fastio) ios_base::sync_with_stdio(false), cin.tie(nullptr);
srand(time(nullptr));
if (!string("").empty())
freopen(
""
".in",
"r", stdin),
freopen(
""
".out",
"w", stdout);
}
~__io_dev() { fprintf(stderr, "%.6f ms\n", 1e3 * clock() / CLOCKS_PER_SEC); }
} __io(false);
const long long inf = (long long)1e+9 + 7ll;
const long double eps = (long double)1e-9;
const long double pi = acosl((long double)-1.0);
const int alph = 26;
const int sqr = 3017;
static char buff[(int)2e6 + 17];
long long __p[3] = {29ll, 31ll, 33ll};
long long __mod[3] = {inf, inf + 2ll, 14881337ll};
const int maxn = (int)2e5 + 17;
struct tree {
tree *lf, *rg;
int x;
tree() : lf(nullptr), rg(nullptr), x(0) {}
};
typedef tree* T;
int n, ans;
pair<long long, long long> lr[maxn];
T root = new tree();
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
}
void cr(T& v) {
if (v == nullptr) v = new tree();
}
void update(long long i, long long k, T& v = root, long long l = 0,
long long r = 3ll * inf) {
if (l == r)
v->x = k;
else {
long long m = (l + r) / 2;
if (i <= m)
cr(v->lf), update(i, k, v->lf, l, m);
else
cr(v->rg), update(i, k, v->rg, m + 1, r);
v->x = max(v->x, max((v->lf == nullptr ? 0 : v->lf->x),
(v->rg == nullptr ? 0 : v->rg->x)));
}
}
long long getmax(long long lf, long long rg, T& v = root, long long l = 0,
long long r = 3ll * inf) {
if (l == lf && r == rg) return v->x;
long long m = (l + r) / 2, res = 0;
if (lf <= min(m, rg))
cr(v->lf), res = max(res, getmax(lf, min(m, rg), v->lf, l, m));
if (max(lf, m + 1) <= rg)
cr(v->rg), res = max(res, getmax(max(lf, m + 1), rg, v->rg, m + 1, r));
return res;
}
int main() {
scanf("%d", &n);
for (long long i = 0ll; i < (long long)n; ++i) {
int a, b;
scanf("%d %d", &a, &b);
lr[i] = {inf + a - b, inf + a + b};
}
sort(lr, lr + n, cmp);
for (long long i = 0ll; i < (long long)n; ++i)
update(lr[i].second, getmax(0, lr[i].first) + 1);
printf("%d\n", getmax(0, 3ll * inf));
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
inline long FastMax(long x, long y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y;
}
inline long FastMin(long x, long y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x;
}
long IR[] = {0, -1, 0, 1, -1, -1, 1, 1};
long IC[] = {1, 0, -1, 0, 1, -1, -1, 1};
long N, Q;
long BIT[2000007 + 7];
void Update(long i, long v) {
while (i and i <= 2000007) {
BIT[i] += v;
i += i & -i;
}
}
long Find(long i) {
long s = 0;
while (i) {
s += BIT[i];
i -= i & -i;
}
return s;
}
long Range(long l, long r) { return Find(r) - Find(l - 1); }
void Fold(long l, long r, long v, long &rl, long &rr) {
long i, j;
if (v - l + 1 <= r - v) {
for (i = v, j = v + 1; i >= l; i--, j++) {
long tmp = Range(i, i);
Update(i, -tmp);
Update(j, tmp);
}
rl = v + 1;
rr = r;
} else {
for (i = v + 1, j = v; i <= r; i++, j--) {
long tmp = Range(i, i);
Update(i, -tmp);
Update(j, tmp);
}
rl = v;
rr = l;
}
}
int main(void) {
long i, j, t, v, tl, tr, Icase, k = 0;
scanf("%ld%ld", &N, &Q);
for (i = 1; i <= N; i++) {
Update(i, 1);
}
long l = 1, r = N, s = N;
while (Q--) {
scanf("%ld", &t);
if (t == 1) {
scanf("%ld", &v);
if (l > r) {
v = s - v;
v = v + r - 1;
} else {
v = v + l - 1;
}
Fold(min(l, r), max(l, r), v, l, r);
} else if (t == 2) {
scanf("%ld%ld", &tl, &tr);
if (l > r) {
tl = l - tl;
tr = l - tr + 1;
} else {
tl = l + tl;
tr = l + tr - 1;
}
long ans = Range(min(tl, tr), max(tl, tr));
printf("%ld\n", ans);
}
s = abs(l - r) + 1;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l;
int r;
} a[200005], b[2000005];
int cmpl(struct node n, struct node m) { return n.l < m.l; }
int cmpr(struct node n, struct node m) { return n.r < m.r; }
int main() {
int n, m;
while (~scanf("%d", &n)) {
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &b[i].l, &b[i].r);
}
sort(a, a + n, cmpl);
sort(b, b + m, cmpr);
if (a[n - 1].l > b[0].r) {
sum = max(sum, a[n - 1].l - b[0].r);
}
sort(a, a + n, cmpr);
sort(b, b + m, cmpl);
if (b[m - 1].l > a[0].r) {
sum = max(sum, b[m - 1].l - a[0].r);
}
if (!sum)
printf("0\n");
else
printf("%d\n", sum);
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.