solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 7;
char s[N];
const int MOD = 1e9 + 9;
int A, B, C;
struct Node {
int lc, rc, x, y;
bool operator==(const Node &other) const {
if (lc == -1 && other.lc == -1) return true;
return (lc == other.lc) && (rc == other.rc) && (x == other.x) &&
(y == other.y);
}
};
int add(int a, int b) { return ((long long)a + b) % MOD; }
int mul(int a, int b) { return (long long)a * b % MOD; }
Node t[N << 2];
Node combine(const Node &lhs, const Node &rhs) {
if (lhs.lc == -1 && rhs.lc == -1) {
return {-1, lhs.rc ^ rhs.rc, 0, 0};
} else if (lhs.lc == -1) {
return {lhs.rc ^ rhs.lc, rhs.rc, rhs.x, rhs.y};
} else if (rhs.lc == -1) {
return {lhs.lc, lhs.rc ^ rhs.rc, lhs.x, lhs.y};
} else {
return {
lhs.lc, rhs.rc,
add(lhs.x, mul(lhs.y, add((lhs.rc ^ rhs.lc) ? B : C, mul(A, rhs.x)))),
mul(lhs.y, mul(rhs.y, A))};
}
}
void build(int v, int l, int r) {
if (l == r) {
if (s[l] == '0') {
t[v] = {0, 0, 0, 1};
} else {
t[v] = {-1, 1, 0, 0};
}
return;
}
int mid = (l + r) >> 1;
build(v << 1, l, mid);
build(v << 1 | 1, mid + 1, r);
t[v] = combine(t[v << 1], t[v << 1 | 1]);
}
Node get(int v, int l, int r, int x, int y) {
if (l > y || r < x) return {-1, 0, 0, 0};
if (l >= x && r <= y) return t[v];
int mid = (l + r) >> 1;
return combine(get(v << 1, l, mid, x, y), get(v << 1 | 1, mid + 1, r, x, y));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
clock_t ttt = clock();
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
A = rng() % MOD;
B = rng() % MOD;
C = rng() % MOD;
int n;
cin >> n;
cin >> (s + 1);
int q;
cin >> q;
build(1, 1, n);
while (q--) {
int l1, l2, l;
cin >> l1 >> l2 >> l;
l--;
if (get(1, 1, n, l1, l1 + l) == get(1, 1, n, l2, l2 + l)) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
cerr << "Time taken " << (double)(clock() - ttt) / CLOCKS_PER_SEC
<< " seconds\n";
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int t;
cin >> t;
for (int tt = 0; tt < t; tt++) {
int n;
cin >> n;
vector<int> a(n);
vector<long long> f(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
f[i] = a[i];
if (i - 1 >= 0) {
f[i] += f[i - 1];
}
}
multiset<long long> q;
q.insert(0);
long long mx = (long long)-9e18;
for (int i = 0; i < n; i++) {
if (i == n - 1) {
q.erase(q.find(0));
}
mx = max(mx, f[i] - *q.begin());
q.insert(f[i]);
}
if (f[n - 1] > mx) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100004;
char s[N], t[N], str[N];
int main() {
int n, tr;
scanf("%d %d", &n, &tr);
scanf("%s", s + 1);
scanf("%s", t + 1);
int cnt = 0;
for (int i = 1; i <= n; i++)
if (s[i] != t[i]) cnt++;
if (tr < cnt) {
int val = cnt / 2 + cnt % 2;
if (tr < val)
printf("-1\n");
else {
val = cnt - tr;
val = val * 2;
cnt = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == t[i])
str[i] = s[i];
else {
if (cnt <= val) {
if (cnt % 2 == 1)
str[i] = t[i];
else
str[i] = s[i];
cnt++;
} else {
for (int j = 0; j < 26; j++) {
if (((s[i] - 'a') != j) && ((t[i] - 'a') != j)) {
str[i] = j + 'a';
break;
}
}
}
}
}
printf("%s\n", str + 1);
}
} else {
int val = tr - cnt;
for (int i = 1; i <= n; i++) {
if (s[i] == t[i]) {
if (val > 0) {
str[i] = ((s[i] - 'a') + 1) % 26 + 'a';
val--;
} else
str[i] = s[i];
} else {
for (int j = 0; j < 26; j++) {
if ((j != s[i] - 'a') && (j != t[i] - 'a')) {
str[i] = j + 'a';
break;
}
}
}
}
printf("%s\n", str + 1);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
if (p1 == p2) {
p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
if (p1 == p2) return EOF;
}
return *p1++;
}
inline void read(int &x) {
char c = nc(), b = 1;
for (; !(c >= '0' && c <= '9'); c = nc())
if (c == '-') b = -1;
for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= b;
}
const int N = 20005;
struct vv {
int x, y, idx, p;
} v[N];
int n, part[N];
vv IDX;
int rnk[N];
bool cmp(int a, int b) {
return (v[a].x - IDX.x) * (v[b].y - IDX.y) -
(v[b].x - IDX.x) * (v[a].y - IDX.y) <
0;
}
void match(int l, int r) {
if (l + 1 == r) {
part[v[rnk[l]].idx] = v[rnk[r]].idx;
part[v[rnk[r]].idx] = v[rnk[l]].idx;
return;
}
for (int i = l + 1; i <= r; i++)
if (v[rnk[i]].y < v[rnk[l]].y) swap(v[rnk[l]], v[rnk[i]]);
IDX = v[rnk[l]];
sort(rnk + l + 1, rnk + r + 1, cmp);
int t = 0, last = l + 1;
for (int i = l + 1; i < r; i++) {
t += v[rnk[i]].p;
if (t == 0) {
match(last, i);
last = i + 1;
}
}
part[v[rnk[l]].idx] = v[rnk[last]].idx;
part[v[rnk[last]].idx] = v[rnk[l]].idx;
if (last + 1 < r) match(last + 1, r);
}
int main() {
read(n);
for (int i = 1; i <= 2 * n; i++) rnk[i] = i;
for (int i = 1; i <= n; i++)
read(v[i].x), read(v[i].y), v[i].idx = i, v[i].p = 1;
for (int i = n + 1; i <= 2 * n; i++)
read(v[i].x), read(v[i].y), v[i].idx = i, v[i].p = -1;
match(1, 2 * n);
for (int i = 1; i <= n; i++) printf("%d\n", part[i] - n);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long faktori[30][65];
long long djelitelji[2][30];
int main() {
long long n, b;
cin >> n >> b;
int brd = 0;
for (long long i = 2; i * i <= b; i++) {
if (b % i == 0) {
djelitelji[0][brd] = i;
while (b % i == 0) {
djelitelji[1][brd]++;
b /= i;
}
brd++;
}
}
if (b > 1) {
djelitelji[0][brd] = b;
djelitelji[1][brd] = 1;
}
long long ind = 0;
while (djelitelji[0][ind] != 0) {
for (long long i = 1; i < 65; i++) {
faktori[ind][i] = n / pow(djelitelji[0][ind], i);
faktori[ind][0] += faktori[ind][i];
}
ind++;
}
long long mn = pow(2, 60);
for (int i = 0; i < 30; i++) {
if (djelitelji[0][i] == 0) {
break;
}
if (faktori[i][0] / djelitelji[1][i] < mn)
mn = faktori[i][0] / djelitelji[1][i];
}
cout << mn;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, i, mid, cnt = 0;
cin >> n >> a >> b;
int str[n];
for (i = 0; i < n; i++) {
cin >> str[i];
}
sort(str, str + n);
mid = n - a;
for (i = str[mid - 1]; i < str[mid]; i++) {
cnt++;
}
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,mmx,avx,avx2")
using namespace std;
const int MAXN = 1e6 + 5;
int a[MAXN];
int ct[MAXN];
int f[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
std::cout << std::fixed << std::setprecision(20);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= MAXN) {
continue;
}
ct[a[i]]++;
}
int x = 1;
for (int i = 1; i <= m; i++) {
for (int j = i; j <= m; j += i) {
f[j] += ct[i];
}
if (f[i] > f[x]) {
x = i;
}
}
cout << x << ' ' << f[x] << ' ' << '\n';
for (int i = 0; i < n; i++) {
if (x % a[i] == 0) {
cout << (i + 1) << ' ';
}
}
cout << '\n';
}
| 13 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline long long rd() {
long long x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * flag;
}
int n, q, a[1000010], c[1000010], pp;
inline void add(int x, int v) {
for (register int i = x; i <= n; i += (i & (-i))) c[i] += v;
}
inline int sum(int x) {
int ans = 0;
for (register int i = x; i > 0; i -= (i & (-i))) ans += c[i];
return ans;
}
int main() {
n = rd(), q = rd();
for (register int i = 1; i <= n; ++i) a[i] = rd(), add(a[i], 1);
int x;
while (q--) {
x = rd();
if (x < 0) {
x = -x;
int l = 1, r = n, mid, ret;
while (l <= r) {
mid = (l + r) >> 1;
if (sum(mid) < x)
l = mid + 1;
else
ret = mid, r = mid - 1;
}
add(ret, -1);
} else
add(x, 1);
}
for (register int i = 1; i <= n; ++i) {
if (c[i] > 0) {
cout << i;
return 0;
}
}
cout << 0;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int a, b, c, d, n, i, k, m, j;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s >> a >> b;
if (a >= 2400 && a < b) {
cout << "YES";
exit(0);
}
}
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int cnt[N];
int main() {
int T;
scanf("%d", &T);
for (; T--;) {
memset(cnt, 0, sizeof cnt);
int n;
scanf("%d", &n);
long long m = 1;
while (m * (m + 1) / 2 <= n) m++;
m--;
for (int i = m; i; i--) {
int res = i * (i + 1) / 2;
cnt[i] = n / res;
n %= res;
}
printf("13");
for (int i = 1; i <= m; i++) {
printf("3");
for (int j = 1; j <= cnt[i]; j++) printf("7");
}
puts("");
}
}
| 11 |
#include <bits/stdc++.h>
int main() {
int a, b, c, d, e, num;
scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
num = a;
if (b < num) num = b;
if (c / 2 < num) num = c / 2;
if (d / 7 < num) num = d / 7;
if (e / 4 < num) num = e / 4;
printf("%d\n", num);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int T;
double pi = acos(-1.0);
vector<long long> v;
long long factorial(long long x) {
long long total = 1;
for (int i = 2; i <= x; i++) total *= i;
return total;
}
bool isprime(long long x) {
vector<bool> prime(x + 1, 1);
prime[0] = prime[1] = 0;
for (long long i = 2; i * i <= x; i++)
if (prime[i])
for (long long j = i * i; j <= x; j += i) prime[j] = 0;
return prime[x];
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long temp = 1;
long long fastpow(long long base, long long exponent) {
if (exponent == 0) return 1;
if (exponent == 1) return (temp * base);
if (exponent % 2 == 0)
return fastpow(base * base, exponent / 2);
else {
temp *= base;
fastpow(base * base, exponent / 2);
}
}
void fill(long long f) {
v.clear();
long long x;
for (long long i = 0; i < f; i++) {
cin >> x;
v.push_back(x);
}
}
void printv() {
int size = v.size() - 1;
for (int i = 0; i <= size; i++) {
cout << v[i] << " ";
}
cout << endl;
}
double dis(double x1, double y1, double x2, double y2) {
return sqrt(pow(x1 - x2, 2.0) + pow(y1 - y2, 2.0));
}
void solve() {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
vector<pair<int, int>> v;
int maxx = max(x1, x2);
int minx = min(x1, x2);
int maxy = max(y1, y2);
int miny = min(y1, y2);
for (int i = miny; i <= maxy; i++) {
v.push_back(make_pair(minx, i));
}
for (int i = miny; i <= maxy; i++) {
v.push_back(make_pair(maxx, i));
}
minx++;
maxx--;
for (int i = minx; i <= maxx; i++) {
v.push_back(make_pair(i, miny));
}
for (int i = minx; i <= maxx; i++) {
v.push_back(make_pair(i, maxy));
}
int n;
cin >> n;
vector<pair<int, pair<int, int>>> cor;
while (n--) {
int x, y, r;
cin >> x >> y >> r;
cor.push_back(make_pair(r, make_pair(x, y)));
}
int ans = 0;
bool is = false;
for (auto itr = v.begin(); itr != v.end(); itr++) {
for (int i = 0; i < cor.size(); i++) {
if (dis((*itr).first, (*itr).second, cor[i].second.first,
cor[i].second.second) <= cor[i].first) {
is = true;
break;
}
}
if (!is) {
ans++;
}
is = false;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
{ solve(); }
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
short size = s.size();
int n = 0;
for (int i = 0; i < size; i++)
if (s[i] == 'a') n++;
while (n <= size / 2) size--;
cout << size << endl;
return 0;
}
| 0 |
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int N = 1001;
const int K = 1001;
int n, k;
const int mod = 1e9 + 7;
int dp[N][K][2];
int solve(int curr, int k, int dir) {
if (k == 1) {
return 1;
}
if (dp[curr][k][dir] != -1) {
return dp[curr][k][dir];
}
int ans = 2; // me and my copy
if (dir == 1) {
if (curr < n)
ans += solve(curr + 1, k, dir) - 1;
ans %= mod;
if (curr > 1)
ans += solve(curr - 1, k - 1, 1 - dir) - 1;
ans %= mod;
dp[curr][k][dir] = ans;
} else {
if (curr > 1)
ans += solve(curr - 1, k, dir) - 1;
ans %= mod;
if (curr < n)
ans += solve(curr + 1, k - 1, 1 - dir) -1;
ans %= mod;
dp[curr][k][dir] = ans;
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> n >> k;
memset(dp, -1, sizeof(dp));
cout << solve(1, k, 1) << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int const N = 10e5 + 5;
int const mod = 998244353;
long double min(long double x, long double y) {
if (x < y)
return x;
else
return y;
}
long double max(long double x, long double y) {
if (x > y)
return x;
else
return y;
}
long long gcd(long long x, long long y) {
if (x == 0)
return y;
else
return gcd(y % x, x);
}
long long pwr(long long x, long long e) {
long long res = 1;
while (e) {
if (e & 1) {
res = (res * x) % mod;
}
e /= 2;
x = (x * x) % mod;
}
return res;
}
long long cnt[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tt;
tt = 1;
while (tt--) {
long long n, m;
cin >> n;
vector<vector<long long> > v(n);
vector<long long> k(n);
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> k[i];
v[i].resize(k[i]);
for (auto &it : v[i]) {
cin >> it;
cnt[it]++;
}
}
for (int i = 0; i < n; i++) {
long long temp = 0;
for (auto j : v[i]) temp += cnt[j];
temp %= mod;
temp *= pwr(k[i], mod - 2);
temp %= mod;
temp *= pwr(n, mod - 2);
temp %= mod;
temp *= pwr(n, mod - 2);
temp %= mod;
ans += temp;
}
cout << ans % mod << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int fact(long long int n) {
if (n == 0 || n == 1)
return 1;
else
return n * fact(n - 1);
}
int gcd(int a, int b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
if (a == 1 || b == 1)
return 1;
else {
int r = a > b ? a % b : b % a;
if (r == 0)
return min(a, b);
else
return gcd(min(a, b), r);
}
}
int main() {
int n, a, b;
cin >> n >> a >> b;
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '.') {
if (s[i - 1] == 'p') {
if (b > 0) {
s[i] = 'a';
cnt++;
b--;
}
} else if (s[i - 1] == 'a') {
if (a > 0) {
s[i] = 'p';
cnt++;
a--;
}
} else {
if (a >= b && a > 0) {
s[i] = 'p';
a--;
cnt++;
} else if (a < b && b > 0) {
s[i] = 'a';
b--;
cnt++;
}
}
}
}
cout << cnt << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
signed main() {
long long n, a, b, c, d, ans = 0;
cin >> n >> a >> b >> c >> d;
for (int i = 1; i < n + 1; ++i) {
long long x = i + a - d;
long long y = i + b - c;
long long z = x + b - c;
if (x > 0 && x <= n && y <= n && z <= n && y > 0 && z > 0) ans++;
}
cout << ans * n;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 1e9;
int n, m, k, fort[200007], num[200007];
set<pair<long double, int>> s;
vector<int> G[200007];
vector<int> ans;
int idx;
long double mx, cur;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
fort[x] = 1;
}
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!fort[i]) {
for (int j = 0; j < G[i].size(); j++) {
if (!fort[G[i][j]]) {
num[i]++;
}
}
s.insert(make_pair((long double)num[i] / (long double)G[i].size(), i));
}
}
while (s.size() > 0) {
v = s.begin()->second;
cur = s.begin()->first;
if (cur >= mx) {
mx = cur;
idx = s.size();
}
s.erase(s.begin());
fort[v] = 1;
ans.push_back(v);
for (int i = 0; i < G[v].size(); i++) {
if (!fort[G[v][i]]) {
u = G[v][i];
s.erase(make_pair((long double)num[u] / (long double)G[u].size(), u));
num[u]--;
s.insert(make_pair((long double)num[u] / (long double)G[u].size(), u));
}
}
}
cout << idx << "\n";
for (int i = idx - 1; i >= 0; i--) {
cout << ans[ans.size() - i - 1] << " ";
}
cout << "\n";
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool was[(int)1e6 + 10];
vector<int> g[(int)1e6 + 10];
int up[(int)1e6 + 10][30];
void dfs(int v, int par = -1) {
for (int to : g[v]) {
if (to != par) {
up[to][0] = v;
dfs(to, v);
}
}
}
void solve() {
was[n] = true;
k = n - k - 1;
for (int i = n - 1; i >= 1; --i) {
if (!was[i]) {
int sum = 1, cur = i;
for (int j = 21; j >= 0; --j) {
if (up[cur][j] != -1) {
if (!was[up[cur][j]]) {
cur = up[cur][j];
sum += (1 << j);
}
}
}
if (k < sum) continue;
int x = i;
while (!was[x]) {
--k;
was[x] = true;
x = up[x][0];
}
}
}
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i <= 21; ++i)
for (int v = 1; v <= n; ++v) up[v][i] = -1;
dfs(n);
for (int i = 1; i <= 21; ++i) {
for (int v = 1; v <= n; ++v) {
if (up[v][i - 1] == -1) continue;
up[v][i] = up[up[v][i - 1]][i - 1];
}
}
solve();
for (int i = 1; i <= n; ++i)
if (!was[i]) cout << i << ' ';
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const long long oo = 1 << 30;
const long long loo = 1ll << 62;
const long long mods = 1e9 + 7;
const long long MAXN = 5000005;
const long long INF = 0x3f3f3f3f;
inline long long read() {
long long f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
long long num = 0, a[MAXN], cntl[10], cntr[10], cnt[10], L[20], R[20], ans = 0,
l, r;
long long check(long long x) {
cntl[0] = cntr[0] = 19;
for (long long i = 1; i < 10; i++)
cntl[i] = cntr[i] = cnt[i], cntl[0] -= cnt[i], cntr[0] -= cnt[i];
long long Flag = 1;
for (long long i = 0, flag = 0; i < 19; i++) {
for (long long j = (flag ? 0 : L[i] + 1); j <= R[i] - 1; j++)
if (cntr[j]) return 1;
if (L[i] != R[i]) flag = 1;
if ((--cntr[R[i]]) < 0) {
Flag = 0;
break;
}
}
if (Flag) return 1;
Flag = 1;
for (long long i = 0, flag = 0; i < 19; i++) {
for (long long j = L[i] + 1; j <= (flag ? 9 : R[i] - 1); j++)
if (cntl[j]) return 1;
if (L[i] != R[i]) flag = 1;
if ((--cntl[L[i]]) < 0) {
Flag = 0;
break;
}
}
return Flag;
return Flag > 0;
}
void dfs(long long x, long long y) {
if (x == 10) {
ans += check(y);
return;
}
for (;;) {
dfs(x + 1, y);
if (((long double)y) * 10 + x > 1e18) break;
y = y * 10 + x;
cnt[x]++;
}
cnt[x] = 0;
}
signed main() {
long long l = read(), r = read(), t;
t = l;
for (long long i = 1; i <= 19; i++) L[19 - i] = t % 10, t /= 10;
t = r;
for (long long i = 1; i <= 19; i++) R[19 - i] = t % 10, t /= 10;
dfs(1, 0);
printf("%lld\n", ans);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int v[1005];
int x[2005], y[2005];
int sum;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = 1; i <= m; i++) cin >> x[i] >> y[i];
sum = 0;
for (int i = 1; i <= m; i++) {
sum += min(v[x[i]], v[y[i]]);
}
cout << sum << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k;
cin >> k;
if (s.size() % k != 0) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < s.size(); i += s.size() / k) {
string ss = s.substr(i, s.size() / k);
for (int j = 0, l = ss.size() - 1; j < l; j++, l--) {
if (ss[j] != ss[l]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
template <typename T>
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
};
template <typename T>
using Edges = vector<edge<T>>;
template <typename T>
using WeightedGraph = vector<Edges<T>>;
template <typename T>
vector<T> dijkstra(WeightedGraph<T> &g, int s, int t) {
const auto INF = numeric_limits<T>::max();
vector<T> dist(g.size(), INF);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> que;
dist[s] = 0;
que.emplace(dist[s], s);
while (que.empty() != true) {
T cost;
int idx;
tie(cost, idx) = que.top();
que.pop();
if (dist[idx] < cost) continue;
for (auto &e : g[idx]) {
if ((idx == s && e.to == t) || (idx == t && e.to == s)) continue;
auto next_cost = cost + e.cost;
if (dist[e.to] <= next_cost) continue;
dist[e.to] = next_cost;
que.emplace(dist[e.to], e.to);
}
}
return dist;
}
int func(vector<ll> a) {
int N = a.size();
WeightedGraph<int> G(N);
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if (a[i] & a[j]) {
G[i].emplace_back(j, 1);
G[j].emplace_back(i, 1);
}
}
}
int res = inf;
for (int i = 0; i < N; i++) {
for (auto &v : G[i]) {
auto dist = dijkstra(G, i, v.to);
if (dist[v.to] < inf) res = min(res, dist[v.to] + 1);
}
}
return res;
}
int N;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> N;
vector<ll> a, bit(65);
for (int i = 0; i < N; i++) {
ll p;
cin >> p;
if (p != 0LL)
a.emplace_back(p);
else
continue;
for (ll b = 0; b < 60; b++) {
if ((1LL << b) & p) bit[b]++;
}
}
if (*max_element(bit.begin(), bit.end()) > 2) {
cout << 3 << endl;
return 0;
}
int ans = func(a);
if (ans == inf)
cout << -1 << endl;
else
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int s, i, e, ans;
void solve(void) {
cin >> s >> i >> e;
if ((s + e) <= i) {
cout << "0\n";
return;
}
double deli = ((s + e - i) / 2.00) - 1.00;
deli = ceil(deli);
int ans = deli;
cout << min(ans, e) + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, ty, val, idx;
int op[N] = {0};
int bl[N];
stack<pair<int, int> > seq;
stack<int> ans;
class node {
public:
int mbal, lz;
} seg[4 * N];
void upd(int id, int l, int r, int v) {
seg[id].mbal += v;
seg[id].lz += v;
}
void shift(int id, int l, int r) {
int mid = (l + r) / 2;
upd(2 * id, l, mid, seg[id].lz);
upd(2 * id + 1, mid, r, seg[id].lz);
seg[id].lz = 0;
}
void built(int id = 1, int l = 0, int r = n) {
if (r - l < 2) {
seg[id].mbal = bl[l];
seg[id].lz = 0;
return;
}
int mid = (l + r) / 2;
built(2 * id, l, mid);
built(2 * id + 1, mid, r);
seg[id].mbal = max(seg[2 * id].mbal, seg[2 * id + 1].mbal);
seg[id].lz = 0;
}
void update(int x, int v, int id = 1, int l = 0, int r = n) {
if (r - l < 2) {
seg[id].mbal += v;
return;
}
shift(id, l, r);
int mid = (l + r) / 2;
if (x < mid) {
update(x, v, 2 * id, l, mid);
} else {
update(x, v, 2 * id + 1, mid, r);
upd(2 * id, l, mid, v);
}
seg[id].mbal = max(seg[2 * id].mbal, seg[2 * id + 1].mbal);
}
int query(int x, int y, int id = 1, int l = 0, int r = n) {
if (y <= l || x >= r) return -100000007;
if (x <= l && r <= y) {
return seg[id].mbal;
}
shift(id, l, r);
int mid = (l + r) / 2;
return max(query(x, y, 2 * id, l, mid), query(x, y, 2 * id + 1, mid, r));
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> idx >> ty;
if (ty != 0) cin >> val;
op[idx - 1] = (ty == 0 ? 0 : val);
seq.push(pair<int, int>(idx - 1, ty));
}
bl[n] = 0;
for (int i = n - 1; i >= 0; i--) {
bl[i] = bl[i + 1] + (op[i] == 0 ? -1 : 1);
}
built();
int st, en, md;
while (!seq.empty()) {
st = 0;
en = n - 1;
while (st < en) {
md = (st + en) / 2;
if (query(md, n) > 0) {
st = md + 1;
} else
en = md - 1;
}
while (st >= 0 && query(st, n) <= 0) {
st--;
}
if (st == -1) {
ans.push(-1);
} else
ans.push(op[st]);
idx = seq.top().first;
ty = seq.top().second;
seq.pop();
update(idx, (ty == 0 ? 1 : -1));
}
while (!ans.empty()) {
cout << ans.top() << '\n';
ans.pop();
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
void solution(string wonderful) {
int size = wonderful.length();
int count[size];
for (int i = 0; i < size; i++) {
count[i] = 0;
}
for (int i = size - 1; i >= 1; i--) {
for (int j = i - 1; j >= 0; j--) {
if (wonderful[j] > wonderful[i]) {
count[j]++;
} else {
count[i]++;
}
}
}
char sortedWonderful[size];
for (int i = 0; i < size; i++) {
sortedWonderful[count[i]] = wonderful[i];
}
int i = 0, red = 0, single = 0;
while (i != size) {
int sublength = 1;
while (sortedWonderful[i] == sortedWonderful[i + 1] && i != size - 1) {
sublength++;
i++;
}
if (sublength >= 2) {
red++;
} else {
single++;
}
i++;
}
red += single / 2;
cout << red << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
string letters;
cin >> letters;
solution(letters);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long k, d, t;
long long T, T1, T2;
long long v;
double res;
int main() {
cin >> k >> d >> t;
if (k % d == 0) {
res = 1.0 * t;
printf("%f\n", res);
} else {
T = k + d - k % d;
T2 = d - k % d;
T1 = k;
t = t * 2;
v = 2 * k + T2;
res = t / v * T;
t %= v;
if (2 * T1 >= t) {
res += 0.5 * t;
} else {
res += 1.0 * T1 + 1.0 * t - 2.0 * T1;
}
printf("%f\n", res);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 14) + 10;
int a[2][maxn];
bool b[2][maxn] = {0};
int vis[maxn];
int g[maxn];
inline int find(int p, int x) {
return a[p][x] == x ? x : a[p][x] = find(p, a[p][x]);
}
inline void join(int p, int x, int y) {
x = find(p, x);
y = find(p, y);
if (x != y) {
a[p][x] = y;
}
}
void init(int p) {
for (int i = 0; i < maxn; i++) {
a[p][i] = i;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int u = m / 4;
string s;
int flag = 0;
int p = 0;
int ans = 0;
init(p);
for (int i = 0; i <= n; i++) {
memset(b[flag], 0, sizeof(bool) * maxn);
memset(g, -1, sizeof(g));
memset(vis, 0, sizeof(vis));
if (i < n) {
cin >> s;
for (int j = 0; j < u; j++) {
char c = s[j];
int num = c <= '9' ? c - '0' : c - 'A' + 10;
for (int k = 3; k >= 0; k--) {
b[flag][j * 4 + k] = num & 1;
num >>= 1;
}
}
}
int f = flag ^ 1;
for (int j = 0; j < m; j++) {
if (b[f][j] && b[flag][j]) vis[find(p, j)] = 1;
}
for (int j = 0; j < m; j++) {
if (b[f][j] && !vis[find(p, j)]) {
ans++;
vis[find(p, j)] = 1;
}
}
init(p ^ 1);
for (int j = 0; j < m; j++) {
if (b[flag][j] && b[f][j]) {
int x = find(p, j);
if (g[x] == -1)
g[x] = j;
else {
join(p ^ 1, g[x], j);
g[x] = j;
}
}
}
for (int j = 0; j < m - 1; j++) {
if (b[flag][j] && b[flag][j + 1]) join(p ^ 1, j, j + 1);
}
flag ^= 1;
p ^= 1;
}
cout << ans << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, t, len, a[10001], b[10001], f[10001];
int main() {
cin >> n >> t;
for (int i = 1; i <= n; i++) cin >> a[i];
int len = min(n, t) * n;
for (int i = 1; i <= n; i++) b[a[i]]++;
int mxa = 1;
for (int i = n + 1; i <= len; i++) a[i] = a[i - n];
for (int i = 1; i <= len; i++) {
f[i] = 1;
for (int j = i - 1; j >= max(i - n, 1); j--) {
if (a[i] >= a[j]) f[i] = max(f[i], f[j] + 1);
}
mxa = max(mxa, f[i]);
}
if (n >= t) {
cout << mxa;
return 0;
} else {
int maxx = 0;
for (int i = 0; i <= 305; i++) maxx = max(maxx, b[i]);
cout << mxa + maxx * (t - n);
return 0;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 105;
const long long oo = 1e18 + 7, mod = 1e9 + 7;
long long n, m, k;
long long arr[N][N];
long long tol_diff[N];
long long builtin[1LL << 20], msk[N];
void process() {
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> arr[i][j];
}
if (m <= 20) {
for (long long i = 0; i < (1ll << m); i++)
builtin[i] = __builtin_popcountll(i);
for (long long i = 1; i <= n; i++) {
for (long long j = m; j >= 1; j--) msk[i] = (msk[i] << 1) | arr[i][j];
}
long long ans = oo;
for (long long i = 0; i < (1LL << (m - 1)); i++) {
long long sum = 0;
for (long long j = 1; j <= n; j++) {
long long temp = builtin[msk[j] ^ i];
sum += min(temp, m - temp);
}
if (sum <= k) ans = min(ans, sum);
}
cout << (ans <= k ? ans : -1) << "\n";
} else {
for (long long i = 2; i <= n; i++) {
long long cnt = 0;
for (long long j = 1; j <= m; j++) {
cnt += (arr[1][j] != arr[i][j]);
}
if (cnt > 10) {
for (long long j = 1; j <= m; j++) arr[i][j] = 1 - arr[i][j];
}
}
long long sum = 0;
for (long long i = 1; i <= m; i++) {
long long cnt0 = 0, cnt1 = 0;
for (long long j = 1; j <= n; j++) {
if (!arr[j][i])
cnt0++;
else
cnt1++;
}
sum += min(cnt0, cnt1);
}
cout << (sum > k ? -1 : sum) << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
process();
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
struct timearray {
int gt = 1;
int val[MAXN];
int dhgdg[MAXN];
timearray() { memset(dhgdg, 0, sizeof(dhgdg)); }
void clear() { gt++; }
int get(int i) {
if (dhgdg[i] < gt) return -1;
return val[i];
}
void set(int i, int x) {
val[i] = x;
dhgdg[i] = gt;
}
};
unordered_map<int, int> qs[MAXN];
int ansq[MAXN];
int ta[MAXN];
pair<int, int> cq[MAXN];
map<pair<int, int>, int> la;
int cnt[MAXN];
set<int> big;
int n, m;
int cut;
vector<pair<int, int> > e[MAXN];
map<int, int> id;
int cid = 0;
int q;
int stk[MAXN];
int ptr = 0;
timearray p, rnk, used;
int find_set(int v) {
if (p.get(v) == -1) {
p.set(v, v);
return v;
}
if (p.get(v) == v)
return v;
else {
int x = find_set(p.get(v));
p.set(v, x);
return x;
}
}
void unite(int v, int u) {
v = find_set(v);
u = find_set(u);
if (v == u) return;
if (rnk.get(v) == -1) rnk.set(v, 0);
if (rnk.get(u) == -1) rnk.set(u, 0);
if (rnk.get(v) > rnk.get(u)) swap(v, u);
p.set(v, u);
if (rnk.get(v) == rnk.get(u)) rnk.set(u, rnk.get(u) + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(cnt, 0, sizeof(cnt));
memset(ta, 0, sizeof(ta));
memset(ansq, 0, sizeof(ansq));
scanf("%d%d", &n, &m);
for (auto i = 0; i != n; i++) qs[i].max_load_factor(0.25);
cut = (int)sqrt((long double)m) / 4;
cut = max(1, cut);
for (auto i = 0; i != m; i++) {
int v, u, c;
scanf("%d%d%d", &v, &u, &c);
v--;
u--;
if (!id.count(c)) id[c] = cid++;
int nc = id[c];
e[nc].push_back(make_pair(v, u));
cnt[nc]++;
}
scanf("%d", &q);
for (auto i = 0; i != q; i++) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
if (v > u) swap(v, u);
cq[i] = make_pair(v, u);
if (la.count(make_pair(v, u))) continue;
qs[v][u] = i;
la[make_pair(v, u)] = i;
}
for (auto cc : id) {
int c = cc.second;
if (cnt[c] < cut) {
ptr = 0;
p.clear();
rnk.clear();
used.clear();
for (auto ce : e[c]) {
int v = ce.first, u = ce.second;
unite(v, u);
if (used.get(v) == -1) {
used.set(v, 0);
stk[ptr++] = v;
}
if (used.get(u) == -1) {
used.set(u, 0);
stk[ptr++] = u;
}
}
for (auto i = 0; i != ptr; i++) {
for (auto j = i + 1; j != ptr; j++) {
int v = stk[i], u = stk[j];
if (v > u) swap(v, u);
if (find_set(v) != find_set(u)) continue;
if (qs[v].count(u)) ansq[qs[v][u]]++;
}
}
} else {
p.clear();
rnk.clear();
used.clear();
for (auto ce : e[c]) {
int v = ce.first, u = ce.second;
unite(v, u);
}
for (auto i = 0; i != q; i++) {
if (find_set(cq[i].first) == find_set(cq[i].second)) ta[i]++;
}
}
}
for (auto i = 0; i != q; i++) {
ta[i] += ansq[la[cq[i]]];
printf("%d\n", ta[i]);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
scanf("%d %d", &a, &b);
string s, crap;
getline(cin, crap);
getline(cin, s);
if (a == 0 && b == 0) {
printf("Yes");
return 0;
}
s += s;
s += s;
s += s;
s += s;
s += s;
s += s;
long long i, len, x = 0, y = 0;
len = s.length();
int xneg = 0, xpos = 0, ypos = 0, yneg = 0;
vector<pair<int, int> > pt;
pt.push_back(make_pair(0, 0));
for (i = 0; i < len; ++i) {
if (x > 0) xpos = 1;
if (y > 0) ypos = 1;
if (x < 0) xneg = 1;
if (y < 0) yneg = 1;
if (s[i] == 'R')
++x;
else if (s[i] == 'U')
++y;
else if (s[i] == 'L')
--x;
else if (s[i] == 'D')
--y;
pt.push_back(make_pair(x, y));
}
long long p = INT_MAX, t = INT_MAX;
if ((a < 0 && xneg == 0) && (yneg == 0 && b < 0)) {
printf("No");
return 0;
}
if ((a > 0 && xpos == 0) && (ypos == 0 && b > 0)) {
printf("No");
return 0;
}
if (x != 0) p = a / x;
if (y != 0) t = b / y;
p = min(p, t);
if (x != 0) a -= p * x;
if (y != 0) b -= p * y;
vector<pair<int, int> >::iterator it;
it = find(pt.begin(), pt.end(), pair<int, int>(a, b));
if (it == pt.end())
cout << "No";
else
cout << "Yes";
return 0;
}
| 9 |
#include <bits/stdc++.h>
struct Edge2 {
int first, sec, weight;
bool operator<(Edge2 other) const { return weight < other.weight; }
};
struct DisjointSet {
std::vector<int> par;
struct Change {
int index, old;
};
std::vector<Change> history;
DisjointSet(int number) : par(number, -1), history() {}
void undo() {
auto [index, old] = history.back();
history.pop_back();
par[index] = old;
}
private:
int set(int index, int value) {
if (par[index] == value) return value;
history.push_back({index, par[index]});
return par[index] = value;
}
public:
int root(int node) const {
assert(node != -1);
return par[node] >= 0 ? root(par[node]) : node;
}
bool join(int first, int sec) {
first = root(first);
sec = root(sec);
if (first == sec) return false;
if (par[first] > par[sec]) std::swap(first, sec);
if (par[first] == par[sec]) --par[first];
set(sec, first);
return true;
}
};
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int numNode, numEdge;
std::cin >> numNode >> numEdge;
struct Group {
struct QueryPart {
int index;
std::vector<std::pair<int, int>> edges;
};
std::vector<QueryPart> queryParts;
std::vector<std::pair<int, int>> edges;
};
std::map<int, Group> groups;
std::vector<Edge2> edges(numEdge);
for (auto& [first, sec, weight] : edges) {
std::cin >> first >> sec >> weight;
--first;
--sec;
groups[weight].edges.push_back({first, sec});
}
DisjointSet set(numNode);
int numQuery;
std::cin >> numQuery;
for (int queryIndex = 0; queryIndex < numQuery; ++queryIndex) {
int number;
std::cin >> number;
for (int _ = 0; _ < number; ++_) {
int edgeIndex;
std::cin >> edgeIndex;
--edgeIndex;
auto const [first, sec, weight] = edges[edgeIndex];
auto& it = groups[weight].queryParts;
if (it.empty() or it.back().index != queryIndex) {
it.emplace_back();
it.back().index = queryIndex;
}
it.back().edges.push_back({first, sec});
}
}
std::vector<char> result(numQuery, true);
for (auto const& [_weight, group] : groups) {
auto historyPos = set.history.size();
for (auto const& queryPart : group.queryParts) {
if (not result[queryPart.index]) continue;
for (auto [first, sec] : queryPart.edges) {
if (not set.join(first, sec)) result[queryPart.index] = false;
}
while (set.history.size() != historyPos) set.undo();
}
for (auto [first, sec] : group.edges) {
set.join(first, sec);
}
}
for (auto okay : result) std::cout << (okay ? "YES\n" : "NO\n");
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int OO = (int)2e9;
const double eps = 1e-9;
int main() {
int n, k, s, e, mid, sum, tmp;
cin >> n >> k;
s = 1, e = n;
while (s < e) {
mid = (s + (e - s) / 2);
sum = 0, tmp = mid;
while (tmp) sum += tmp, tmp /= k;
if (sum >= n)
e = mid;
else
s = mid + 1;
}
cout << s << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[1010];
int t, n, c0, c1, h;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d%d%d", &n, &c0, &c1, &h);
scanf("%s", s + 1);
int sum = 0;
if (h + c0 < c1) {
for (int i = 1; i <= n; i++) {
if (s[i] == '0')
sum += c0;
else
sum += h + c0;
}
printf("%d\n", sum);
continue;
}
if (h + c1 < c0) {
for (int i = 1; i <= n; i++) {
if (s[i] == '1')
sum += c1;
else
sum += h + c1;
}
printf("%d\n", sum);
continue;
}
for (int i = 1; i <= n; i++) {
if (s[i] == '0')
sum += c0;
else
sum += c1;
}
printf("%d\n", sum);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 10010;
const int K = 510;
const int LIT = 2500;
const long long INF = 1LL << 60;
int n, m, q;
vector<int> r[N], nr[N];
vector<pair<int, int> > qr[N];
int output[N], col[N];
bool vis[N];
set<pair<int, int> > brige;
int cut[N];
int deep[N], ans[N];
void dfs(int idx, int fa, int d) {
deep[idx] = ans[idx] = d;
vis[idx] = 1;
int s = r[idx].size();
for (int i = 0; i < s; i++) {
int v = r[idx][i];
if (v == fa) continue;
if (vis[v]) {
ans[idx] = min(ans[idx], deep[v]);
continue;
}
dfs(v, idx, d + 1);
ans[idx] = min(ans[idx], ans[v]);
if (ans[v] > d) {
int a = min(idx, v), b = max(idx, v);
brige.insert(make_pair(a, b));
}
if (ans[v] >= d) cut[idx]++;
}
if (fa != -1) cut[idx]++;
}
int cc;
void dfs2(int u, int c) {
vis[u] = 1;
col[u] = c;
int s = r[u].size();
for (int i = 0; i < s; i++) {
int v = r[u][i];
if (vis[v]) continue;
int a = min(u, v), b = max(u, v);
if (brige.count(make_pair(a, b))) {
cc++;
nr[c].push_back(cc);
nr[cc].push_back(c);
dfs2(v, cc);
} else
dfs2(v, c);
}
}
void dfs3(int u, int d) {
vis[u] = 1;
deep[u] = d;
int s = nr[u].size();
for (int i = 0; i < s; i++) {
int v = nr[u][i];
if (vis[v]) continue;
dfs3(v, d + 1);
}
}
int check[N], fa[N];
int sea(int a) {
int mid = N - 1;
while (1) {
if (!fa[a]) return a;
fa[mid] = fa[a];
mid = a;
a = fa[a];
}
}
void uni(int a, int b) {
a = sea(a);
b = sea(b);
if (a == b) return;
fa[b] = a;
}
void LCA(int u, int fa) {
int s = nr[u].size();
for (int i = 0; i < s; i++) {
int v = nr[u][i];
if (v == fa) continue;
LCA(v, u);
uni(u, v);
}
check[u] = 1;
s = qr[u].size();
for (int i = 0; i < s; i++) {
int v = qr[u][i].first, p = qr[u][i].second;
if (!check[v]) continue;
int lca = sea(v);
int res = deep[u] + deep[v] - deep[lca] * 2;
output[p] = res;
}
}
void init() {
memset(col, 0, sizeof(col));
memset(vis, 0, sizeof(vis));
memset(cut, 0, sizeof(cut));
memset(ans, 0, sizeof(ans));
memset(deep, 0, sizeof(deep));
brige.clear();
for (int i = 0; i <= n; i++) {
r[i].clear(), qr[i].clear();
nr[i].clear();
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
r[a].push_back(b);
r[b].push_back(a);
}
dfs(1, -1, 0);
cc = 1;
memset(vis, 0, sizeof(vis));
dfs2(1, cc);
memset(vis, 0, sizeof(vis));
memset(deep, 0, sizeof(deep));
dfs3(1, 1);
cin >> q;
for (int i = 1; i <= q; i++) {
int a, b;
scanf("%d %d", &a, &b);
a = col[a], b = col[b];
qr[a].push_back(make_pair(b, i));
qr[b].push_back(make_pair(a, i));
}
memset(fa, 0, sizeof(fa));
memset(check, 0, sizeof(check));
LCA(1, -1);
}
void solve() {
for (int i = 1; i <= q; i++) {
printf("%d\n", output[i]);
}
}
int main() {
while (cin >> n >> m) {
init();
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int, int>;
int main(int argc, const char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> arr(n), brr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
brr[i] = arr[i];
}
sort(brr.begin(), brr.end());
int cnt = 0;
vector<pii> res;
for (int i = 0; i < n; i++) {
if (arr[i] == brr[i]) continue;
cnt++;
int d;
for (int j = 0; j < n; j++) {
if (arr[j] == brr[i]) d = j;
}
res.push_back(pii(i + 1, d + 1));
for (int j = d; j > i; j--) swap(arr[j], arr[j - 1]);
}
cout << cnt << "\n";
for (auto t : res)
cout << t.first << " " << t.second << " " << t.second - t.first << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100], cnt1[100], cnt2[100], c[100];
vector<int> ans1, ans2;
int ansv;
int c1[100], c2[100];
int main() {
string str;
int s, bst, ans;
cin >> str;
for (int i = 0; i < str.size(); i++) {
cnt[str[i] - 48]++;
}
ansv = -1;
ans = cnt[0];
bst = ans;
for (int zeros = 0; zeros <= cnt[0]; zeros++) {
for (int pp = 0; pp <= 9; pp++) {
for (int i = 0; i <= 9; i++) c1[i] = c2[i] = cnt[i];
c1[0] -= zeros;
s = zeros;
if (c1[pp] == 0 || c2[10 - pp] == 0) continue;
c1[pp]--;
c2[10 - pp]--;
for (int i = 0; i <= 9; i++) s += min(c1[i], c2[9 - i]);
s++;
if (s > bst) {
bst = s;
ans = zeros;
ansv = pp;
}
}
}
for (int i = 0; i <= 9; i++) cnt1[i] = cnt2[i] = cnt[i];
for (int i = 0; i < ans; i++) {
ans1.push_back(0);
ans2.push_back(0);
--cnt1[0];
--cnt2[0];
}
if (ansv != -1) {
ans1.push_back(ansv);
--cnt1[ansv];
ans2.push_back(10 - ansv);
--cnt2[10 - ansv];
}
for (int i = 0; i <= 9; i++) {
for (int j = 0; j < min(cnt1[i], cnt2[9 - i]); j++) {
ans1.push_back(i);
ans2.push_back(9 - i);
}
int q = min(cnt1[i], cnt2[9 - i]);
for (int j = 0; j < q; j++) {
--cnt1[i];
--cnt2[9 - i];
}
}
for (int i = 0; i <= 9; i++)
for (int j = 0; j < cnt1[i]; j++) ans1.push_back(i);
for (int i = 0; i <= 9; i++)
for (int j = 0; j < cnt2[i]; j++) ans2.push_back(i);
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
for (int i = 0; i < ans1.size(); i++) cout << ans1[i];
cout << endl;
for (int i = 0; i < ans2.size(); i++) cout << ans2[i];
cout << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10;
int n, m, dp[N][N], L[N][N], R[N][N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
while (k--) {
int l, r;
cin >> l >> r;
for (int j = l; j <= r; j++) {
L[i][j] = l;
R[i][j] = r;
}
}
}
for (int l = m; l >= 1; l--) {
for (int r = l; r <= m; r++) {
for (int k = l; k <= r; k++) {
int temp = 0;
for (int i = 1; i <= n; i++) {
if (L[i][k] >= l && R[i][k] <= r) {
temp++;
}
}
dp[l][r] = max(dp[l][r], dp[l][k - 1] + dp[k + 1][r] + temp * temp);
}
}
}
cout << dp[1][m] << endl;
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
string s;
cin >> n >> s;
s += "A";
int kek = 0;
for (int i = 0; i < n; ++i) {
if (s[i] > s[i + 1] && !kek) {
kek = 1;
continue;
}
cout << s[i];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
long long ans[N + N], add[N + N], sum[N + N];
int a[N], b[N], chk[N];
int main() {
ios::sync_with_stdio(0);
int q;
cin >> q;
int n = 1000001;
const long long inf = 1e15;
auto push_up = [&](int u) { ans[u] = max(ans[u + u], ans[u + u + 1]); };
auto change = [&](int u, long long d) {
add[u] += d;
ans[u] += d;
};
auto push_down = [&](int u) {
if (!add[u]) return;
change(u + u, add[u]);
change(u + u + 1, add[u]);
add[u] = 0;
};
function<void(int, int, int, int)> update = [&](int u, int l, int r, int p) {
if (l == r) {
ans[u] = p;
return;
}
int mid = l + r >> 1;
push_down(u);
if (p <= mid)
update(u + u, l, mid, p);
else
update(u + u + 1, mid + 1, r, p);
push_up(u);
};
function<void(int, int, int, int, int, long long)> modify =
[&](int u, int l, int r, int ll, int rr, long long d) {
if (ll <= l && r <= rr) {
change(u, d);
return;
}
int mid = l + r >> 1;
push_down(u);
if (ll <= mid) modify(u + u, l, mid, ll, rr, d);
if (mid < rr) modify(u + u + 1, mid + 1, r, ll, rr, d);
push_up(u);
};
function<long long(int, int, int, int, int)> query = [&](int u, int l, int r,
int ll, int rr) {
if (ll <= l && r <= rr) return ans[u];
int mid = l + r >> 1;
long long ret = -inf;
push_down(u);
if (ll <= mid) ret = max(ret, query(u + u, l, mid, ll, rr));
if (mid < rr) ret = max(ret, query(u + u + 1, mid + 1, r, ll, rr));
return ret;
};
auto add = [&](int t, int d) {
for (; t <= n; t += t & -t) sum[t] += d;
};
auto get = [&](int t) {
long long ret = 0;
for (; t; t -= t & -t) ret += sum[t];
return ret;
};
for (int i = 1; i <= q; i++) {
string op;
cin >> op;
if (op[0] == '+') {
int t, d;
cin >> t >> d;
if (!chk[t]) modify(1, 0, n, t, t, t);
chk[t]++;
modify(1, 0, n, t + 1, n, -d);
a[i] = t, b[i] = d;
add(t, d);
} else if (op[0] == '-') {
int id;
cin >> id;
int t = a[id], d = b[id];
modify(1, 0, n, t + 1, n, d);
chk[t]--;
if (!chk[t]) modify(1, 0, n, t, t, -t);
add(t, -d);
} else {
long long t;
cin >> t;
printf("%lld\n", max(t, query(1, 0, n, 0, t) + get(t)) - t);
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2 * 1e5 + 10;
ll res;
ll a[N];
void solve() {
ll n, m, d, x, ans = 0;
cin >> n >> m >> d;
std::vector<ll> v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> x;
v.push_back(x);
}
}
sort(v.begin(), v.end());
ll k = v[v.size() / 2];
for (auto i : v) {
ll t = abs(i - k);
if (t % d == 0) {
ans += t / d;
} else {
cout << -1;
return;
}
}
cout << ans;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[150001];
vector<pair<int, long long> > queries;
int N;
int tin[150001], tout[150001];
int filhos[150001];
vector<pair<int, int> > toutfilhos[150001];
int t;
long long val[150001];
int dfsinout(int u, int pai = 0) {
filhos[u] = 1;
tin[u] = t++;
for (auto v : G[u]) {
if (pai != v) {
filhos[u] += dfsinout(v, u);
toutfilhos[u].push_back({tout[v], v});
}
}
tout[u] = t++;
return filhos[u];
}
long long modInverse(long long a, long long b) {
return a > 1LL ? b - ((modInverse(b % a, a) * b) / a) : 1LL;
}
long long inv(long long a) {
long long z = modInverse(a, 998244353);
if (z < 0) return z + 998244353;
return z;
}
long long subtrair[150001];
long long comecar[150001];
void dfs(int u, long long acum, int pai = 0) {
if (acum >= 996491788296388609LL) acum -= 996491788296388609LL;
acum -= subtrair[u];
if (acum < 0) acum += 996491788296388609LL;
val[u] += acum;
if (val[u] >= 996491788296388609LL) val[u] -= 996491788296388609LL;
for (auto v : G[u]) {
if (pai != v) {
dfs(v, acum + comecar[u] * (N - filhos[v]), u);
}
}
subtrair[u] = 0;
comecar[u] = 0;
}
int main() {
int Q, N1, u, v, op;
scanf("%d %d", &N, &Q);
N1 = inv(N);
for (int i = 1; i < N; i++) {
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfsinout(1);
while (Q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d %d", &u, &v);
queries.push_back({u, v});
} else {
scanf("%d", &u);
if (queries.size() >= 1000) {
long long inicio = 0;
for (auto q : queries) {
val[q.first] += q.second * N;
if (val[q.first] >= 996491788296388609LL)
val[q.first] -= 996491788296388609LL;
inicio += q.second * filhos[q.first];
if (inicio >= 996491788296388609LL) inicio -= 996491788296388609LL;
subtrair[q.first] += q.second * filhos[q.first];
if (subtrair[q.first] >= 996491788296388609LL)
subtrair[q.first] -= 996491788296388609LL;
comecar[q.first] += q.second;
if (comecar[q.first] >= 998244353) comecar[q.first] -= 998244353;
}
dfs(1, inicio);
queries.clear();
}
long long ans = val[u];
for (auto p : queries) {
if (u == p.first) {
ans += p.second * N;
if (ans >= 996491788296388609LL) ans -= 996491788296388609LL;
} else if (tin[p.first] <= tin[u] && tout[p.first] >= tin[u]) {
int x = lower_bound(toutfilhos[p.first].begin(),
toutfilhos[p.first].end(), make_pair(tin[u], 0))
->second;
ans += p.second * (N - filhos[x]);
if (ans >= 996491788296388609LL) ans -= 996491788296388609LL;
} else {
ans += p.second * filhos[p.first];
if (ans >= 996491788296388609LL) ans -= 996491788296388609LL;
}
}
printf("%lld\n", ((ans % 998244353) * N1) % 998244353);
}
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, m;
vector<int> v[101];
bool is_square(int x) {
int s = sqrt(x);
while (s * s < x) s++;
while (s * s > x) s--;
return s * s == x;
}
void add(int x, int y, int t) {
while (t--) v[x].push_back(y);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
v[1] = {1};
v[2] = {9, 16};
for (int i = 3; i <= 100; i++) {
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= i - j; k++) {
int l = i - j - k;
int x = 1 * j + 4 * k + 9 * l;
if (is_square(x)) {
add(i, 1, j), add(i, 4, k), add(i, 9, l);
break;
}
}
}
}
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
cout << (int)round(sqrt(v[n][i - 1] * v[m][j - 1])) << ' ';
cout << '\n';
}
}
| 16 |
#include <bits/stdc++.h>
const int MaxN = 1010;
int mod_v, pw[MaxN], cnt[MaxN], val[MaxN];
int main() {
int n, m, t, flag = 0;
std::scanf("%d %d %d", &n, &m, &t);
if (n < m) std::swap(n, m), flag = 1;
for (int i = 0; i != t; ++i) {
int x, y, v;
std::scanf("%d %d %d", &x, &y, &v);
if (flag) std::swap(x, y);
++cnt[x];
if (!val[x])
val[x] = v;
else
val[x] *= v;
}
std::scanf("%d", &mod_v);
for (int i = 1; i <= n; ++i) {
if (!cnt[i]) {
std::swap(cnt[i], cnt[n]);
std::swap(val[i], val[n]);
break;
}
}
pw[0] = 1;
for (int i = 1; i <= m; ++i) pw[i] = (pw[i - 1] << 1) % mod_v;
int ans = 1;
for (int i = 1; i != n; ++i) {
if (cnt[i] == m && val[i] == 1)
ans = 0;
else if (m != cnt[i])
ans = (long long)ans * pw[m - cnt[i] - 1] % mod_v;
}
if ((n ^ m) & 1)
std::puts("0");
else
std::printf("%d\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int dp[20][300300];
int dmin[20][300300];
int v[300300];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", v + i);
for (int i = 0; i < n; i++) dp[0][i] = dmin[0][i] = v[i];
for (int i = 1; i < 19; i++)
for (int j = 0; j < n; j++)
dp[i][j] = gcd(dp[i - 1][j], dp[i - 1][min(n - 1, j + (1 << (i - 1)))]),
dmin[i][j] =
min(dmin[i - 1][j], dmin[i - 1][min(n - 1, j + (1 << (i - 1)))]);
int a = 1, b = n;
int lg;
while (a != b) {
int m = (a + b + 1) / 2;
int ok = 0;
lg = -1;
for (int i = 1; i < m; i *= 2) lg++;
;
for (int i = 0; i <= n - m; i++)
if (gcd(dp[lg][i], dp[lg][min(n - 1, i + m - (1 << (lg)))]) ==
min(dmin[lg][i], dmin[lg][min(n - 1, i + m - (1 << (lg)))]))
ok = 1;
;
if (ok)
a = m;
else
b = m - 1;
}
int qnt = 0;
lg = -1;
for (int i = 1; i < a; i *= 2) lg++;
if (a == 1) {
printf("%d 0\n", n);
for (int i = 0; i < n; i++) printf("%d ", i + 1);
return 0;
}
for (int i = 0; i < n - a + 1; i++)
if (gcd(dp[lg][i], dp[lg][i + a - (1 << (lg))]) ==
min(dmin[lg][i], dmin[lg][i + a - (1 << (lg))]))
qnt++;
printf("%d %d\n", qnt, a - 1);
for (int i = 0; i < n - a + 1; i++)
if (gcd(dp[lg][i], dp[lg][i + a - (1 << (lg))]) ==
min(dmin[lg][i], dmin[lg][i + a - (1 << (lg))]))
printf("%d ", i + 1);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[20][105];
int dp[20][3];
int num[20];
int main(int argc, const char* argv[]) {
while (cin >> n >> m) {
memset(num, 0, sizeof(num));
for (int i = n; i >= 1; i--) {
scanf("%s", s[i]);
for (int j = 1; j <= m; j++) {
if (s[i][j] == '1') num[i]++;
}
}
for (int i = n - 1; i >= 1; i--) num[i] += num[i + 1];
int k;
for (k = m; k > 0; k--)
if (s[1][k] == '1') break;
dp[1][0] = 2 * k;
dp[1][1] = m + 1;
dp[1][2] = k;
for (int i = 2; i <= n; i++) {
int j;
for (j = m; j > 0; j--) {
if (s[i][j] == '1') break;
}
dp[i][0] = min(dp[i - 1][0] + 1 + 2 * j, dp[i - 1][1] + 1 + m + 1);
dp[i][2] = dp[i - 1][0] + 1 + j;
for (j = 1; j <= m; j++) {
if (s[i][j] == '1') break;
}
dp[i][1] = min(dp[i - 1][0] + m + 2, dp[i - 1][1] + 1 + 2 * (m + 1 - j));
dp[i][2] = min(dp[i - 1][1] + 1 + (m + 1 - j), dp[i][2]);
}
for (int i = 1; i <= n; i++) {
if (num[i + 1] == 0) {
cout << dp[i][2] << endl;
break;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int N = 100100;
int n, a[N];
inline int can(int x) {
std::unordered_map<int, int> map;
for (int i = 1; i <= x; ++i) ++map[a[i]];
for (int i = 1; i <= n; ++i) {
int rev = n + 1 - i;
if (rev > x) {
if (i > x) {
if (a[i] != a[rev]) return 0;
} else {
--map[a[rev]];
}
}
}
int c = 0;
for (auto x : map) {
if (x.second < 0) return 0;
c += x.second % 2;
}
return c <= 1;
}
inline int calc() {
int l = -1, r = n;
for (; l + 1 != r;) {
int mid = l + r >> 1;
if (can(mid)) {
r = mid;
} else {
l = mid;
}
}
return r;
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] == a[n + 1 - i]) {
++cnt;
} else {
break;
}
}
if (cnt == n) {
cout << (unsigned long long)n * (n + 1) / 2 << '\n';
} else {
if (!can(n)) {
cout << 0 << '\n';
} else {
unsigned long long x = n + 1 - calc();
std::reverse(a + 1, a + n + 1);
x += n + 1 - calc();
cout << x * (cnt + 1) - (cnt + 1) * (cnt + 1) << '\n';
}
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long quick1(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = ans * a;
b--;
}
b /= 2;
a = a * a;
}
return ans;
}
int main() {
long long n;
char c[100];
cin >> n;
cin >> c;
long long len = strlen(c);
long long now = 0;
long long i;
long long ans = 0;
long long f1;
for (i = len - 1; i >= 0; i--) {
long long now1 = c[i] - '0';
long long g = 1;
f1 = i;
while (i - 1 >= 0 && now1 + (c[i - 1] - '0') * quick1(10, g) < n &&
now1 + 1 * quick1(10, g) < n) {
now1 = now1 + (c[i - 1] - '0') * quick1(10, g);
g++;
i--;
if (c[i] != '0') f1 = i;
}
i = f1;
ans += now1 * quick1(n, now);
now++;
}
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
string A;
cin >> A;
if (k > 0 && n == 1) {
cout << 0;
return 0;
}
if (k > 0 && A[0] != '1') {
A[0] = '1';
--k;
}
long long i;
for (i = 1; i < A.length() && k > 0; ++i) {
if (A[i] != '0') {
--k;
A[i] = '0';
}
}
cout << A;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int main() {
int n, m;
cin >> n >> m;
string s, t;
int x;
pair<int, int> a[m];
for (int i = (0), _b = (m); i < (_b); ++i) {
cin >> s >> s >> s >> t >> x;
if (s == "left") {
a[i].first = 0;
a[i].second = x;
if (x == 1) {
cout << -1 << endl;
return 0;
}
} else {
a[i].first = 1;
a[i].second = x;
if (x == n) {
cout << -1 << endl;
return 0;
}
}
}
sort(a, a + m);
int k = -1;
for (int i = (0), _b = (m); i < (_b); ++i) {
if (a[i].first != 0) break;
k = i;
}
bool b[n + 1];
for (int i = (1), _b = (n + 1); i < (_b); ++i) b[i] = true;
for (int i = (k), _b = (-1); i > (_b); --i) {
int x = a[i].second;
for (int j = (x), _b = (n + 1); j < (_b); ++j) b[j] = false;
}
for (int i = (k + 1), _b = (m); i < (_b); ++i) {
int x = a[i].second;
for (int j = (x), _b = (-1); j > (_b); --j) b[j] = false;
}
int ret = 0;
for (int i = (1), _b = (n + 1); i < (_b); ++i)
if (b[i]) ++ret;
if (ret == 0) ret = -1;
cout << ret << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace fastIO {
bool IOerror = 0;
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline long long read() {
bool sign = 0;
char ch = getchar();
long long x = 0;
for (; blank(ch); ch = getchar())
;
if (IOerror) return 0;
if (ch == '-') sign = 1, ch = getchar();
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
if (sign) x = -x;
return x;
}
}; // namespace fastIO
using namespace fastIO;
struct node {
long double x;
long long v, f;
} e[1000010];
long long x[1000010], y[1000010], n, m, now = 0;
bool cmp(node e1, node e2) { return e1.x < e2.x; }
bool check(long long id, long double r) {
now = 0;
if (id <= n)
e[++now] = {0, 1, 1}, e[++now] = {2 * acos(-1.0), -1, 1};
else {
for (long long i = 1; i <= n; i++) {
if (sqrt((y[i] - y[id]) * (y[i] - y[id]) +
(x[i] - x[id]) * (x[i] - x[id])) > 2 * r - 1e-8)
continue;
long double pos = atan2(y[i] - y[id], x[i] - x[id]),
len = acos(sqrt((y[i] - y[id]) * (y[i] - y[id]) +
(x[i] - x[id]) * (x[i] - x[id])) /
r / 2);
long double l = pos - len, r = pos + len;
while (l < 0) l += 2 * acos(-1.0);
while (l > 2 * acos(-1.0)) l -= 2 * acos(-1.0);
while (r < 0) r += 2 * acos(-1.0);
while (r > 2 * acos(-1.0)) r -= 2 * acos(-1.0);
if (l < r)
e[++now] = {l, 1, 1}, e[++now] = {r, -1, 1};
else
e[++now] = {l, 1, 1}, e[++now] = {2 * acos(-1.0), -1, 1},
e[++now] = {0, 1, 1}, e[++now] = {r, -1, 1};
}
}
for (long long i = n + 1; i <= n + m; i++) {
if (i != id) {
if (sqrt((y[i] - y[id]) * (y[i] - y[id]) +
(x[i] - x[id]) * (x[i] - x[id])) > 2 * r - 1e-8)
continue;
long double pos = atan2(y[i] - y[id], x[i] - x[id]),
len = acos(sqrt((y[i] - y[id]) * (y[i] - y[id]) +
(x[i] - x[id]) * (x[i] - x[id])) /
r / 2);
long double l = pos - len, r = pos + len;
while (l < 0) l += 2 * acos(-1.0);
while (l > 2 * acos(-1.0)) l -= 2 * acos(-1.0);
while (r < 0) r += 2 * acos(-1.0);
while (r > 2 * acos(-1.0)) r -= 2 * acos(-1.0);
if (l < r)
e[++now] = {l, 1, 2}, e[++now] = {r, -1, 2};
else
e[++now] = {l, 1, 2}, e[++now] = {2 * acos(-1.0), -1, 2},
e[++now] = {0, 1, 2}, e[++now] = {r, -1, 2};
}
}
sort(e + 1, e + 1 + now, cmp);
long long cnt1 = 0, cnt2 = 0;
for (long long i = 1; i <= now; i++) {
if (e[i].f == 1)
cnt1 += e[i].v;
else
cnt2 += e[i].v;
if (cnt2 == 0 && cnt1 > 0 && (i == now || e[i + 1].x - e[i].x > 1e-12))
return 1;
}
return 0;
}
signed main() {
n = read(), m = read();
for (long long i = 1; i <= n; i++) x[i] = read(), y[i] = read();
for (long long i = 1; i <= m; i++) x[i + n] = read(), y[i + n] = read();
long double ans = 0;
long double l = 0, r = 1e9, mid;
for (long long i = 1; i <= n + m; i++) {
if (!check(i, l)) continue;
r = 1e9;
while (r - l > 1e-6) {
mid = (l + r) / 2;
if (check(i, mid))
l = mid;
else
r = mid;
}
}
if (l > 2e8)
puts("-1");
else
printf("%.10Lf", l);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
bool pri[1000010];
bool prime[1000010];
int main() {
pri[0] = 1;
pri[1] = 1;
for (int i = 2; i <= sqrt(1000000); i++) {
if (pri[i] == 0) {
for (int j = i + i; j <= 1000000; j += i) {
pri[j] = 1;
}
}
}
long long n, ans = 0;
cin >> n;
for (int i = 1; i <= 1000; i++) {
ans = ((n * i) + 1);
if (pri[ans] == 1) {
cout << i << endl;
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int a[27][5005][27];
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
int k = s[i] - 'a';
int idx = 0;
while (idx < s.size()) {
int kk = s[(i + idx) % s.size()] - 'a';
a[k][idx][kk]++;
idx++;
}
}
int res = 0;
for (int i = 0; i <= 25; i++) {
int max1 = 0;
for (int j = 0; j < s.size(); j++) {
int sum = 0;
for (int k = 0; k <= 25; k++) {
if (a[i][j][k] == 1) sum++;
}
max1 = max(max1, sum);
}
res += max1;
}
printf("%.7lf", res * 1.0 / s.size());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
long long lzy[N << 2], a[N];
pair<long long, long long> t[N << 2];
void push(long long v, long long l, long long r) {
if (lzy[v]) {
t[v].first += lzy[v];
if (l != r) {
lzy[v * 2] += lzy[v];
lzy[v * 2 + 1] += lzy[v];
}
lzy[v] = 0;
}
}
void build(long long v, long long l, long long r) {
if (l == r) {
t[v] = make_pair(0, l);
return;
}
long long mid = (l + r) / 2;
build(v * 2, l, mid);
build(v * 2 + 1, mid + 1, r);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
void modify(long long v, long long l, long long r, long long b, long long e,
long long x) {
push(v, l, r);
if (l > e || r < b) {
return;
}
if (l >= b && r <= e) {
lzy[v] += x;
push(v, l, r);
return;
}
long long mid = (l + r) >> 1;
modify(v * 2, l, mid, b, e, x);
modify(v * 2 + 1, mid + 1, r, b, e, x);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
pair<long long, long long> query(long long v, long long l, long long r,
long long L, long long R) {
push(v, l, r);
if (l > R || r < L) return make_pair(1e16, 1);
if (l >= L && r <= R) return t[v];
long long mid = (l + r) / 2;
return min(query(v * 2, l, mid, L, R), query(v * 2 + 1, mid + 1, r, L, R));
}
void Q(long long v, long long l, long long r, vector<long long> &idx) {
push(v, l, r);
if (l == r) {
if (t[v].first < 0) idx.push_back(l);
return;
}
long long mid = (l + r) / 2;
push(v * 2, l, mid);
push(v * 2 + 1, mid + 1, r);
if (t[v * 2].first < 0) Q(v * 2, l, mid, idx);
if (t[v * 2 + 1].first < 0) Q(v * 2 + 1, mid + 1, r, idx);
}
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, q;
cin >> n >> q;
build(1, 1, n);
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (a[i]) modify(1, 1, n, i, n, -a[i]);
if (i + 1 <= n && 2 * a[i]) {
modify(1, 1, n, i + 1, n, 2 * a[i]);
}
}
for (long long i = 1; i <= q; i++) {
long long p, x;
cin >> p >> x;
if (a[p] - x) modify(1, 1, n, p, n, +a[p] - x);
if (p + 1 <= n && -2 * a[p] + 2 * x) {
modify(1, 1, n, p + 1, n, -2 * a[p] + 2 * x);
}
a[p] = x;
vector<long long> idx(1, 0);
Q(1, 1, n, idx);
idx.push_back(n + 1);
assert(idx.size() < 40);
long long found = -1;
for (long long i = 0; i < idx.size() - 1; i++)
if (idx[i] + 1 != idx[i + 1]) {
pair<long long, long long> x =
query(1, 1, n, idx[i] + 1, idx[i + 1] - 1);
if (!x.first) {
found = x.second;
break;
}
}
cout << found << "\n";
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int a[N];
map<int, int> cnt[N];
int n;
int main() {
cin >> n;
map<int, int> num;
for (int i = 0; i < n; ++i) {
cin >> a[i];
num[a[i]]++;
}
if (num.size() == 2) {
cout << n;
return 0;
}
cnt[0][0] = 1;
int maxidx = 0;
int prev = 0;
for (auto nit = num.begin(); nit != num.end(); nit++) {
int na = nit->second;
int ai = nit->first;
maxidx += na;
for (int idx = maxidx; idx >= 1; --idx) {
for (int i = max(1, idx - prev); i <= na; i++) {
if (idx - i < 0) break;
for (auto it = cnt[idx - i].begin(); it != cnt[idx - i].end(); it++) {
cnt[idx][it->first + i * ai] =
min(2, cnt[idx][it->first + i * ai] + it->second);
}
}
}
prev = maxidx;
}
int maxk = 1;
for (auto it = num.begin(); it != num.end(); it++) {
int numa = it->second;
int ai = it->first;
for (int k = numa; k >= 1; k--) {
if (cnt[k][k * ai] == 1) {
maxk = max(maxk, k);
break;
}
}
}
cout << maxk;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, m, a[1005][1005], b[1005][1005], mare;
cin >> n >> m;
if (n >= m)
mare = n;
else
mare = m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> a[i + j][i];
for (i = 1; i <= 2 * mare; i++) sort(a[i] + 1, a[i] + n + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> b[i + j][i];
for (i = 1; i <= 2 * mare; i++) sort(b[i] + 1, b[i] + n + 1);
i = 2;
j = 1;
int ok = 1;
while (i <= 2 * mare and ok == 1) {
while (j <= mare and ok == 1) {
if (a[i][j] != b[i][j]) ok = 0;
j++;
}
j = 1;
i++;
}
if (ok == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
string to_str(int n) {
string res, tmp;
while (n) {
tmp += n % 10 + '0';
n /= 10;
}
for (int i = 0; i < tmp.size(); ++i) res += tmp[tmp.size() - i - 1];
return res;
}
int main() {
int n, m, s, d;
cin >> n >> m >> s >> d;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.begin() + n);
int pos, jump;
pos = jump = 0;
vector<string> cmd;
string tmp;
for (int i = 0; i < n || jump; i++) {
if (jump) {
if (i >= n) {
tmp = "JUMP ";
tmp += to_str(d - jump + 2);
cmd.push_back(tmp);
pos += 2;
jump = min(0, jump - 2);
if (jump < 0) {
cout << "IMPOSSIBLE";
return 0;
}
continue;
}
if (a[i] - pos - 3 >= s) {
tmp = "JUMP ";
tmp += to_str(d - jump + 2);
cmd.push_back(tmp);
pos = a[--i] + 1;
jump = min(0, jump - 2);
if (jump < 0) {
cout << "IMPOSSIBLE";
return 0;
}
continue;
} else {
if (a[i] - pos - 1 < jump) {
jump -= a[i] - pos - 1;
pos = a[i] - 1;
} else {
cout << "IMPOSSIBLE";
return 0;
}
continue;
}
}
if (a[i] - pos - 1 >= s) {
tmp = "RUN ";
tmp += to_str(a[i] - pos - 1);
cmd.push_back(tmp);
pos = a[i] - 1;
jump = d;
continue;
} else {
cout << "IMPOSSIBLE";
return 0;
}
}
if (pos < m) {
tmp = "RUN ";
tmp += to_str(m - pos);
cmd.push_back(tmp);
}
for (int i = 0; i < cmd.size(); ++i) {
if (i) cout << endl;
cout << cmd[i];
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
int n, a[MAXN], s[10];
void Print() {
puts("-1");
exit(0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i] == 5 || a[i] == 7) Print();
s[a[i]]++;
}
if (s[1] != n / 3) Print();
s[2] -= s[4];
if (s[2] < 0) Print();
s[6] -= s[3];
if (s[3] < 0) Print();
if (s[2] != s[6]) Print();
memset(s, 0, sizeof(s));
for (int i = 1; i <= n; ++i) s[a[i]]++;
for (int i = 1; i <= s[4]; ++i) printf("1 2 4\n");
s[2] -= s[4];
for (int i = 1; i <= s[3]; ++i) printf("1 3 6\n");
for (int i = 1; i <= s[2]; ++i) printf("1 2 6\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s, p;
int t, n;
vector<int> v, c;
set<int> let;
int main() {
cin >> s >> p;
if (s == p) return cout << 0, 0;
for (int i = 0; i < s.size(); i++)
if (s[i] != p[t])
n++, v.push_back(i + 1), let.insert(s[i]);
else
t++;
if (v.size() > 1) return cout << 0, 0;
int f = v[0] - 1;
for (int i = f; s[i] == *let.begin(); i--) c.push_back(i);
cout << c.size() << endl;
sort(begin(c), end(c));
for (auto i : c) cout << i + 1 << " ";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 5;
int n, x, y;
int c1[2020], c2[2020];
void solve() {
int cnt = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
cnt += (c1[x - y + 1000]++) + c2[x + y]++;
}
printf("%d", cnt);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5;
const int MOD[2] = {(int)1e9 + 7, (int)1e9 + 9};
int n, offset[N], mark[N], e[N][40];
char s[N];
long long p[2][N];
string foo[50];
vector<int> h[50][2];
string read() {
scanf("%s", s);
return s;
}
vector<int> build(string &now, long long mul, long long mod) {
vector<int> ret(now.size() + 1);
ret[0] = 0;
for (int i = 0; i < now.size(); i++) {
ret[i + 1] = (int)((ret[i] * mul + now[i]) % mod);
}
return ret;
}
int find(vector<int> &x, vector<int> &y, vector<int> &u, vector<int> &v,
int offset) {
int left = 0;
int right = min(x.size() - offset, u.size()) - 1;
while (left <= right) {
int mid = (left + right) / 2;
long long ph1 = (x[offset + mid] - x[offset] * p[0][mid]) % MOD[0];
if (ph1 < 0) {
ph1 += MOD[0];
}
long long qh1 = u[mid];
if (ph1 == qh1) {
long long ph2 = (y[offset + mid] - y[offset] * p[1][mid]) % MOD[1];
if (ph2 < 0) {
ph2 += MOD[1];
}
long long qh2 = v[mid];
if (ph2 == qh2) {
left = mid + 1;
} else {
right = mid - 1;
}
} else {
right = mid - 1;
}
}
return right;
}
bool dfs(int a, int left, int right) {
if (mark[a] == 1) {
return true;
}
if (mark[a] == 2) {
return false;
}
mark[a] = 1;
for (int j = left; j <= right; j++) {
int v = e[a][j];
if (v >= 0 && dfs(v, left, right)) {
return true;
}
}
mark[a] = 2;
return false;
}
bool check(int left, int right) {
memset(mark, 0, sizeof mark);
for (int i = 0; i < n; i++) {
if (i < left || i > right) {
for (int pos = 1; pos < foo[i].size(); pos++) {
int a = offset[i] + pos - 1;
mark[a] = 2;
}
}
}
for (int i = left; i <= right; i++) {
for (int pos = 1; pos < foo[i].size(); pos++) {
int a = offset[i] + pos - 1;
if (mark[a] == 0 && dfs(a, left, right)) {
return false;
}
}
}
return true;
}
int main() {
p[0][0] = 1;
p[1][0] = 1;
for (int i = 1; i < N; i++) {
p[0][i] = p[0][i - 1] * 991 % MOD[0];
p[1][i] = p[1][i - 1] * 997 % MOD[1];
}
scanf("%d", &n);
for (int i = 0; i < n; i++) {
foo[i] = read();
}
for (int i = 0; i < n; i++) {
h[i][0] = build(foo[i], 991, MOD[0]);
h[i][1] = build(foo[i], 997, MOD[1]);
}
int m = 1;
for (int i = 0; i < n; i++) {
offset[i] = m;
m += foo[i].size() - 1;
}
memset(e, -1, sizeof e);
for (int i = 0; i < n; i++) {
for (int pos = 0; pos < foo[i].size(); pos++) {
int start = (pos == 0) ? 0 : offset[i] + pos - 1;
for (int j = 0; j < n; j++) {
int len = find(h[i][0], h[i][1], h[j][0], h[j][1], pos);
int dif = foo[i].size() - pos;
if (len == dif && len == foo[j].size()) {
if (pos > 0) {
e[start][j] = 0;
}
} else if (len == dif) {
if (pos > 0) {
e[start][j] = offset[j] + len - 1;
}
} else if (len == foo[j].size()) {
e[start][j] = offset[i] + (pos + len - 1);
}
}
}
}
int res = 0;
for (int i = 0, j = 0; i < n; i++) {
while (j < i) {
j++;
}
while (j < n && check(i, j)) {
j++;
}
res += j - i;
}
printf("%d\n", res);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
struct node *next;
};
struct node *new_node(struct node *head, int num);
void print_node(struct node *head);
int main() {
long long int i;
long long int j;
long long int n;
long long int m;
long long int idx;
long long int id1;
long long int id2;
long long int min;
long long int flag;
long long int total;
struct node *head;
head = NULL;
cin >> n >> m;
long long int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
total = 0;
for (i = 1; i < arr[0]; i++) {
if ((m - i) >= 0) {
m = m - i;
total++;
head = new_node(head, i);
} else {
break;
}
}
idx = i;
min = arr[0];
id1 = 0;
for (i = idx; i <= arr[n - 1]; i++) {
flag = 0;
min = arr[id1];
if ((m - i) < 0) {
break;
}
for (j = id1; j < n; j++) {
if (arr[j] == i) {
flag = 1;
break;
} else if (arr[j] > i) {
break;
} else {
id1++;
}
}
if ((m - i) >= 0) {
if (flag == 0) {
m = m - i;
total++;
head = new_node(head, i);
}
}
}
i = arr[n - 1] + 1;
while (m >= 0) {
if ((m - i) >= 0) {
m = m - i;
total++;
head = new_node(head, i);
} else if ((m - i) < 0) {
break;
}
i++;
}
cout << total << endl;
print_node(head);
return 0;
}
struct node *new_node(struct node *head, int num) {
struct node *temp;
temp = (struct node *)malloc(sizeof(struct node));
temp->data = num;
if (head == NULL) {
temp->next = NULL;
} else {
temp->next = head;
}
return temp;
};
void print_node(struct node *head) {
struct node *trav;
for (trav = head; trav != NULL; trav = trav->next) {
cout << trav->data << " ";
}
cout << endl;
};
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void _read(T& x) {
char ch = getchar();
bool sign = true;
while (!isdigit(ch)) {
if (ch == '-') sign = false;
ch = getchar();
}
for (x = 0; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
if (!sign) x = -x;
}
int n, ans, ori;
string s[305];
int len[305];
int main() {
int i, j, k, l;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s[i];
len[i] = s[i].length();
ans += len[i];
}
ans += n - 1;
ori = ans;
for (i = 1; i <= n; i++) {
int Len = 0;
for (j = i; j <= n; j++) {
Len += s[j].length();
int sum = 0;
for (k = j + 1; k <= n; k++) {
if (k + j - i > n) break;
for (l = k; l <= k + j - i; l++) {
if (s[l] != s[l - k + i]) break;
}
if (l == k + j - i + 1) {
sum++;
k = k + j - i;
}
}
if (sum > 0) {
ans =
min(ans, ori - (sum + 1) * (Len - j + i - 1) - (sum + 1) * (j - i));
}
}
}
cout << ans;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) cin >> str[i][j];
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (str[i][j] == '.') {
if (i == 0 && j == 0) {
if (str[i + 1][j] == 'x' && str[i + 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j + 1] == 'x' && str[i][j + 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j + 1] == 'x' && str[i + 2][j + 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 0 && j == 3) {
if (str[i + 1][j] == 'x' && str[i + 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j - 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j - 1] == 'x' && str[i + 2][j - 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 3 && j == 0) {
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j + 1] == 'x' && str[i][j + 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j + 1] == 'x' && str[i - 2][j + 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 3 && j == 3) {
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j - 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j - 1] == 'x' && str[i - 1][j - 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 0 && j == 1) {
if (str[i][j - 1] == 'x' && str[i][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j] == 'x' && str[i + 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j + 1] == 'x' && str[i][j + 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j + 1] == 'x' && str[i + 2][j + 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 0 && j == 2) {
if (str[i + 1][j] == 'x' && str[i + 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j - 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j - 1] == 'x' && str[i + 2][j - 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 1 && j == 0) {
if (str[i + 1][j] == 'x' && str[i + 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j] == 'x' && str[i - 1][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j + 1] == 'x' && str[i][j + 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j + 1] == 'x' && str[i + 2][j + 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 1 && j == 1) {
if (str[i + 1][j] == 'x' && str[i + 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j] == 'x' && str[i - 1][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j + 1] == 'x' && str[i][j - 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j + 1] == 'x' && str[i][j + 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j - 1] == 'x' && str[i + 1][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j - 1] == 'x' && str[i - 1][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j + 1] == 'x' && str[i + 2][j + 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 1 && j == 2) {
if (str[i + 1][j] == 'x' && str[i + 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j] == 'x' && str[i - 1][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j - 1] == 'x' && str[i + 1][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j - 1] == 'x' && str[i - 1][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j - 1] == 'x' && str[i + 2][j - 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 1 && j == 3) {
if (str[i + 1][j] == 'x' && str[i + 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j] == 'x' && str[i - 1][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j - 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j - 1] == 'x' && str[i + 1][j - 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 2 && j == 0) {
if (str[i + 1][j] == 'x' && str[i - 1][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j + 1] == 'x' && str[i][j + 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j + 1] == 'x' && str[i - 2][j + 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 2 && j == 3) {
if (str[i + 1][j] == 'x' && str[i - 1][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j - 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j - 1] == 'x' && str[i - 2][j - 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 2 && j == 2) {
if (str[i][j + 1] == 'x' && str[i][j - 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j] == 'x' && str[i - 1][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j - 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j - 1] == 'x' && str[i + 1][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j - 1] == 'x' && str[i - 1][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j - 1] == 'x' && str[i - 2][j - 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 2 && j == 1) {
if (str[i][j + 1] == 'x' && str[i][j + 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j] == 'x' && str[i - 1][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j - 1] == 'x' && str[i + 1][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i + 1][j - 1] == 'x' && str[i - 1][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j + 1] == 'x' && str[i - 2][j + 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 3 && j == 1) {
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j + 1] == 'x' && str[i][j + 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j + 1] == 'x' && str[i - 2][j + 2] == 'x') {
cout << "YES";
return 0;
}
}
if (i == 3 && j == 2) {
if (str[i][j - 1] == 'x' && str[i][j - 2] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j] == 'x' && str[i - 2][j] == 'x') {
cout << "YES";
return 0;
}
if (str[i][j - 1] == 'x' && str[i][j + 1] == 'x') {
cout << "YES";
return 0;
}
if (str[i - 1][j - 1] == 'x' && str[i - 2][j - 2] == 'x') {
cout << "YES";
return 0;
}
}
}
}
}
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
ifstream in;
ofstream out;
const long long kk = 1000;
const long long ml = kk * kk;
const long long mod = ml * kk + 7;
const long long inf = 5 * ml * ml * ml + 7;
long long n, i, j, x, y;
vector<pair<long long, long long> > m;
set<pair<long long, long long> > s;
multiset<long long> fr;
bool viv = false;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> x >> y;
for (i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
m.push_back({a, b + 1});
}
sort(m.begin(), m.end());
long long ans = 0;
for (auto p : m) {
long long p1 = x + (p.second - p.first - 1) * y;
long long p2 = inf;
auto x = fr.upper_bound(p.first);
if (x != fr.begin()) {
x--;
long long last = (*x);
fr.erase(x);
p2 = (p.second - last) * y;
}
ans += (min(p2, p1) % mod);
ans %= mod;
fr.insert(p.second);
}
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> L[200000 + 1];
pair<int, int> edge[200000 + 1];
long long value_temp[200000 + 1];
long long value[200000 + 1];
long long path[2][1000];
int rmq[18 + 1][2 * 200000 + 1];
int euler[2 * 200000 + 1];
int logK[2 * 200000 + 1];
int parent[200000 + 1];
int height[200000 + 1];
int posT[200000 + 1];
int dsu[200000 + 1];
int N, M, T;
int step;
void DFS(int node, int father, int curr_height) {
++T;
posT[node] = T;
euler[T] = node;
height[node] = curr_height;
for (auto neighbour : L[node])
if (neighbour != father) {
parent[neighbour] = node;
DFS(neighbour, node, curr_height + 1);
euler[++T] = node;
}
}
void Build() {
int i, j;
for (i = 2; i <= T; i++) logK[i] = 1 + logK[i / 2];
for (i = 1; i <= T; i++) rmq[0][i] = euler[i];
for (i = 1; (1 << i) <= T; i++)
for (j = 1; j <= T - (1 << i) + 1; j++) {
rmq[i][j] = rmq[i - 1][j];
if (height[rmq[i - 1][j]] > height[rmq[i - 1][j + (1 << i - 1)]])
rmq[i][j] = rmq[i - 1][j + (1 << i - 1)];
}
}
inline int findLCA(int X, int Y) {
int A, B, K;
A = posT[X];
B = posT[Y];
if (A > B) swap(A, B);
K = logK[B - A + 1];
if (height[rmq[K][A]] > height[rmq[K][B + 1 - (1 << K)]])
return rmq[K][B + 1 - (1 << K)];
return rmq[K][A];
}
int findRoot(int X) {
int Y, root = X;
while (dsu[root] != root) root = dsu[root];
while (X != root) {
Y = dsu[X];
dsu[X] = root;
X = Y;
}
return root;
}
void Union(int A, int B) {
int pA, pB;
pA = findRoot(A);
pB = findRoot(B);
if (height[pA] < height[pB]) {
dsu[pB] = pA;
} else {
dsu[pA] = pB;
}
}
void findPath(int X, int Y, int l) {
int nxt, nxt_up;
nxt = findRoot(X);
path[l][0] = 0;
while (height[nxt] > height[Y]) {
if (step > 70) return;
++step;
path[l][++path[l][0]] = value[nxt];
nxt = findRoot(parent[nxt]);
}
}
int main() {
int i, op, X, Y, idx, LCA;
long long C;
scanf("%d %d", &N, &M);
for (i = 1; i <= N; i++) dsu[i] = i;
for (i = 1; i < N; i++) {
scanf("%d %d %I64d", &X, &Y, &C);
value_temp[i] = C;
edge[i] = {X, Y};
L[X].push_back(Y);
L[Y].push_back(X);
}
DFS(1, 0, 0);
Build();
for (i = 1; i < N; i++) {
X = edge[i].first;
Y = edge[i].second;
if (height[X] > height[Y])
value[X] = value_temp[i];
else
value[Y] = value_temp[i];
if (value_temp[i] == 1) Union(X, Y);
}
while (M--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d %d %I64d", &X, &Y, &C);
step = 0;
LCA = findLCA(X, Y);
findPath(X, LCA, 0);
findPath(Y, LCA, 1);
if (step > 70)
C = 0;
else {
for (i = 1; i <= path[0][0] && C > 0; i++) C = C / path[0][i];
for (i = path[1][0]; i >= 1 && C > 0; i--) C = C / path[1][i];
}
printf("%I64d\n", C);
} else {
scanf("%d %I64d", &idx, &C);
X = edge[idx].first;
Y = edge[idx].second;
if (C == 1) Union(X, Y);
if (height[X] > height[Y])
value[X] = C;
else
value[Y] = C;
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
int n, m;
int f[6000];
int ans;
int a[6000];
int main() {
scanf("%d %d", &n, &m);
double x;
for (int i = (1); i <= (n); ++i) scanf("%d %lf", &a[i], &x);
f[1] = 1;
ans = 1;
for (int i = (2); i <= (n); ++i) {
f[i] = 1;
for (int j = (1); j <= (i - 1); ++j)
if (a[i] >= a[j]) f[i] = max(f[i], f[j] + 1);
ans = max(ans, f[i]);
}
cout << n - ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, K, nums[100005], pl = 1, pr, a[100005];
long long res;
inline void getin(int x) {
res += nums[x];
++nums[x];
}
inline void getout(int x) {
--nums[x];
res -= nums[x];
}
inline long long calc(int l, int r) {
while (pr < r) getin(a[++pr]);
while (pl > l) getin(a[--pl]);
while (pl < l) getout(a[pl++]);
while (pr > r) getout(a[pr--]);
return res;
}
void solve(int l1, int r1, int l2, int r2, long long *g, long long *f) {
int mid = (l2 + r2) >> 1;
long long now;
int pos = -1;
for (int i = l1; i <= min(r1, mid - 1); ++i) {
long long tmp = g[i] + calc(i + 1, mid);
if (tmp < now || pos == -1) now = tmp, pos = i;
}
f[mid] = now;
if (l2 < mid) solve(l1, pos, l2, mid - 1, g, f);
if (mid < r2) solve(pos, r1, mid + 1, r2, g, f);
}
long long f[100005], g[100005];
int main() {
cin >> n >> K;
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
memset(f, 0x3f, sizeof f), f[0] = 0;
for (int i = 1; i <= K; ++i) swap(g, f), solve(0, n, 1, n, g, f);
cout << f[n] << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5003;
int l[N], r[N];
int sum[N], ones[N], twos[N];
pair<int, int> getIntersection(int l1, int r1, int l2, int r2) {
if (l2 < l1) {
swap(l1, l2);
swap(r1, r2);
}
pair<int, int> intersection = {1, 0};
if (l2 <= r1) {
intersection.first = l2;
intersection.second = min(r1, r2);
}
return intersection;
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < q; ++i) {
scanf("%d %d", l + i, r + i);
++sum[l[i]];
--sum[r[i] + 1];
}
int nonzeros = 0;
for (int i = 1; i <= n; ++i) {
sum[i] += sum[i - 1];
ones[i] = ones[i - 1] + (sum[i] == 1 ? 1 : 0);
twos[i] = twos[i - 1] + (sum[i] == 2 ? 1 : 0);
nonzeros += sum[i] > 0;
}
int res = 0;
for (int i = 0; i < q; ++i) {
for (int j = i + 1; j < q; ++j) {
pair<int, int> intersection = getIntersection(l[i], r[i], l[j], r[j]);
int cur = ones[r[i]] - ones[l[i] - 1];
cur += ones[r[j]] - ones[l[j] - 1];
cur += twos[intersection.second] - twos[intersection.first - 1];
cur -= ones[intersection.second] - ones[intersection.first - 1];
res = max(res, nonzeros - cur);
}
}
printf("%d\n", res);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1000003];
int memo[10003][1003][2];
int calcMemo(int i, int x, bool ok) {
if (x == 0 && ok) {
return 1;
}
if (i == min(n + 1, 10000)) {
return 0;
}
int &ret = memo[i][x][ok];
if (ret != -1) return ret;
int res1 = calcMemo(i + 1, (x + a[i]) % m, 1);
int res2 = calcMemo(i + 1, x, ok);
return ret = res1 | res2;
}
int main() {
scanf("%d%d", &n, &m);
int temp;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(memo, -1, sizeof memo);
if (calcMemo(1, 0, 0))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long ara[2003], co[2003], fact[2003], val[2003];
long long bigmod(long long b, long long p) {
if (!p) return 1ll;
long long ret = bigmod(b, p / 2);
ret = (ret * ret) % 1000000007ll;
if (p & 1ll) ret = (ret * b) % 1000000007ll;
return ret;
}
int main() {
fact[0] = 1ll;
for (long long i = 1; i <= 2000; i++)
fact[i] = (fact[i - 1] * i) % 1000000007ll;
long long n, k;
scanf("%lld %lld", &n, &k);
for (int i = 0; i < n; i++) scanf("%lld", &ara[i]);
if (k) {
co[0] = 1;
for (long long i = 1; i < n; i++) {
long long p = i + k - 1;
long long q = i;
long long nume = 1ll;
for (long long j = p - q + 1; j <= p; j++)
nume = (nume * j) % 1000000007ll;
long long deno = fact[q];
deno = bigmod(deno, 1000000007ll - 2);
co[i] = (nume * deno) % 1000000007ll;
}
for (int i = 0; i < n; i++)
for (int j = 0, l = i; j <= i; j++, l--)
val[i] = (val[i] + co[j] * ara[l]) % 1000000007ll;
for (int i = 0; i < n; i++) printf("%lld ", val[i]);
puts("");
} else {
for (int i = 0; i < n; i++) printf("%lld ", ara[i]);
puts("");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
vector<bool> us;
queue<int> q;
vector<queue<int> > vq;
void dfs(int v) {
us[v] = true;
q.push(v);
if (!us[vec[v]]) {
dfs(vec[v]);
}
}
int main() {
int n;
cin >> n;
int a[n];
vec.resize(n);
us.resize(n, false);
map<int, int> m;
for (int j = 0; j < n; j++) {
cin >> a[j];
m[a[j]] = j;
}
sort(a, a + n);
for (int j = 0; j < n; j++) {
vec[j] = m[a[j]];
}
for (int j = 0; j < n; j++) {
if (!us[j]) {
dfs(j);
vq.push_back(q);
while (!q.empty()) {
q.pop();
}
}
}
cout << vq.size();
for (int j = 0; j < vq.size(); j++) {
cout << '\n' << vq[j].size() << ' ';
while (!vq[j].empty()) {
cout << vq[j].front() + 1 << " ";
vq[j].pop();
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = ((long long)1) << 60;
const double dinf = 1e50;
const int INF = 1000000000;
const int N = 100005;
struct node {
int L, R, mid, Max;
};
node a[N << 2];
int b[N], c[N];
vector<int> V[N];
int n, m, K;
long long h, pos[N], p[N], cnt, d[N];
void Add(long long t) {
p[cnt++] = t;
memset(d, -1, sizeof(d));
int h[N] = {0}, i, j, u, v;
long long x, y;
queue<int> Q;
Q.push(1);
d[1] = 0;
while (!Q.empty()) {
u = Q.front();
Q.pop();
h[u] = 0;
for (i = 0; i < cnt; i++) {
x = (u + p[i]) / K;
y = (u + p[i]) % K;
if (d[y] == -1 || d[y] > d[u] + x) {
d[y] = d[u] + x;
if (!h[y]) Q.push(y);
}
}
}
memset(b, 0, sizeof(b));
for (i = 0; i < K; i++)
if (d[i] != -1)
for (j = 0; j < V[i].size(); j++) {
u = V[i][j];
if (pos[u] >= d[i] * K + i) b[u] = 1;
}
}
void pushUp(int t) {
a[t].Max = ((a[t * 2].Max) > (a[t * 2 + 1].Max) ? (a[t * 2].Max)
: (a[t * 2 + 1].Max));
}
void build(int t, int L, int R) {
a[t].L = L;
a[t].R = R;
a[t].mid = (L + R) >> 1;
if (L == R) {
if (!b[L])
a[t].Max = -1;
else
a[t].Max = c[L];
return;
}
build(t * 2, L, a[t].mid);
build(t * 2 + 1, a[t].mid + 1, R);
pushUp(t);
}
void update(int t, int x, int y) {
if (a[t].L == a[t].R) {
a[t].Max -= y;
c[x] -= y;
return;
}
if (x <= a[t].mid)
update(t * 2, x, y);
else
update(t * 2 + 1, x, y);
pushUp(t);
}
void modify(int t, int x) {
if (a[t].L == a[t].R) {
a[t].Max = 0;
c[a[t].L] = 0;
return;
}
if (a[t * 2].Max == x)
modify(t * 2, x);
else
modify(t * 2 + 1, x);
pushUp(t);
}
int main() {
cin >> h >> n >> m >> K;
int i;
for (i = 1; i <= n; i++) {
cin >> pos[i] >> c[i];
V[pos[i] % K].push_back(i);
if (pos[i] % K == 1) b[i] = 1;
}
build(1, 1, n);
int op, x, y;
long long A;
while (m--) {
cin >> op;
if (op == 1) {
cin >> A;
Add(A);
build(1, 1, n);
} else if (op == 2) {
cin >> x >> y;
update(1, x, y);
} else {
if (a[1].Max <= 0)
puts("0");
else {
cout << a[1].Max << endl;
modify(1, a[1].Max);
}
}
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, n, m, x, t, y, s;
cin >> n >> s >> t;
int a[n + 1];
bool vis[n + 1];
memset(vis, false, sizeof(vis));
for (i = 1; i <= n; i++) {
cin >> a[i];
}
int c = 0;
vis[s] = true;
i = s;
while (i != t) {
i = a[i];
c++;
if (vis[i] == true) {
c = -1;
break;
}
vis[i] = true;
}
cout << c << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100000 + 10;
const int maxM = 200000 + 10;
struct edge {
edge *pre;
int other;
edge() { pre = NULL; }
} * last[maxN], edgeData[maxM], *totEdge;
int a[maxN];
int vis[maxN], leaf[maxN];
long long f[maxN];
int cnt[maxN];
int N;
long long sum, ans;
int flag;
long long GCD(long long x, long long y) { return y ? GCD(y, x % y) : x; }
void addEdge(int u, int v) {
totEdge->pre = last[u];
totEdge->other = v;
last[u] = totEdge++;
}
void DFS(int x) {
vis[x] = 1;
f[x] = 1;
for (edge *p = last[x]; p != NULL; p = p->pre)
if (!vis[p->other]) {
++cnt[x];
DFS(p->other);
if (flag) return;
f[x] = (f[x] * f[p->other]) / GCD(f[x], f[p->other]);
}
if (cnt[x])
f[x] *= cnt[x];
else
leaf[x] = 1;
if (f[x] > sum) flag = 1;
}
int check(int x, long long s) {
if (leaf[x]) return (a[x] >= s);
vis[x] = 1;
for (edge *p = last[x]; p != NULL; p = p->pre)
if (!vis[p->other])
if (!check(p->other, s / cnt[x])) return 0;
return 1;
}
int main() {
totEdge = edgeData;
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = 1; i < N; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
DFS(1);
if (flag) {
printf("%I64d\n", sum);
return 0;
}
long long L = 0, R = sum / f[1];
while (L <= R) {
long long mid = (L + R) / 2;
memset(vis, 0, sizeof vis);
if (check(1, f[1] * mid)) {
ans = mid;
L = mid + 1;
} else
R = mid - 1;
}
printf("%I64d\n", sum - f[1] * ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
int min(int x, int y) { return x < y ? x : y; }
int max(int x, int y) { return x > y ? x : y; }
bool Chkmin(int &x, int y) { return y < x ? x = y, true : false; }
bool Chkmax(int &x, int y) { return y > x ? x = y, true : false; }
const int MAXN = 4000, oo = 0x3f3f3f3f;
bool c[MAXN][MAXN];
int Up[MAXN][MAXN], Down[MAXN][MAXN], Ans[MAXN * 4];
int n, m, k, X;
struct Sta {
int x, pos;
Sta() {}
Sta(int x, int pos) : x(x), pos(pos) {}
bool operator<(const Sta &a) const {
if (x != a.x) return x < a.x;
return pos < a.pos;
}
};
struct SpecialQueue {
int head, tail;
Sta q[MAXN];
inline void Init() { head = tail = 0; }
inline void push(Sta a) {
while (head <= tail) {
if (a < q[tail])
tail--;
else
break;
}
q[++tail] = a;
}
inline Sta top() {
if (head > tail) puts("error!");
return q[head];
}
bool empty() { return head > tail; }
inline void pop() { head++; }
} UpQueue, DownQueue;
void Readin(int &x) {
x = 0;
char c = getchar();
while (!('0' <= c && c <= '9')) c = getchar();
while ('0' <= c && c <= '9') {
(x *= 10) += c - '0';
c = getchar();
}
}
void Update(int x, int y) {
if (c[x][y]) return;
for (int i = x; i > 0 && !c[i][y]; i--) Down[i][y] = x - i;
for (int i = x; i <= n && !c[i][y]; i++) Up[i][y] = i - x;
c[x][y] = true;
}
void Maintain(int o) {
Chkmax(Ans[o], Ans[o << 1]);
Chkmax(Ans[o], Ans[o << 1 | 1]);
}
void Work(int o, int l, int r) {
if (X && (X < l || X > r)) return;
int mid = (l + r) >> 1, L = 1, R = 1, UpTmp, DownTmp, ans = 0;
UpQueue.Init();
DownQueue.Init();
do {
UpQueue.push(Sta(Up[mid][R], R));
DownQueue.push(Sta(Down[mid][R], R));
UpTmp = min(UpQueue.top().x, mid - l + 1);
DownTmp = min(DownQueue.top().x, r - mid + 1);
while (UpTmp + DownTmp < R - L + 1) {
L = min(UpQueue.top().pos, DownQueue.top().pos) + 1;
if (UpQueue.top().pos < L) UpQueue.pop();
if (DownQueue.top().pos < L) DownQueue.pop();
if (UpQueue.empty() || DownQueue.empty()) break;
UpTmp = min(UpQueue.top().x, mid - l + 1);
DownTmp = min(DownQueue.top().x, r - mid + 1);
}
Chkmax(ans, min(UpTmp + DownTmp - 1, R - L + 1));
} while (++R <= m);
Ans[o] = ans;
if (l == r) return;
Work(o << 1, l, mid);
Work(o << 1 | 1, mid + 1, r);
Maintain(o);
}
char s[MAXN];
void Init() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, _ = n; i <= _; i++) {
scanf("%s", s + 1);
for (int j = 1, _ = m; j <= _; j++)
if (s[j] == 'X') c[i][j] = true;
}
for (int j = 1, _ = m; j <= _; j++) {
for (int i = 1, _ = n; i <= _; i++)
Up[i][j] = c[i][j] ? 0 : Up[i - 1][j] + 1;
for (int i = n, _ = 1; i >= _; i--)
Down[i][j] = c[i][j] ? 0 : Down[i + 1][j] + 1;
}
}
void Solve() {
int x, y;
X = 0;
Work(1, 1, n);
for (int i = 1, _ = k; i <= _; i++) {
Readin(x);
Readin(y);
X = x;
Update(x, y);
Work(1, 1, n);
printf("%d\n", Ans[1]);
}
}
int main() {
Init();
Solve();
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
long long N;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> N;
vector<long long> A(N);
for (int i = 0; i < (N); i++) cin >> A[i];
vector<long long> B = A;
sort(B.begin(), B.end());
long long a = B[0], b = B[1], c = B[2];
long long ac = 0, bc = 0, cc = 0;
for (int i = 0; i < N && (B[i] == a || B[i] == b || B[i] == c); i++) {
if (B[i] == a) ac++;
if (B[i] == b) bc++;
if (B[i] == c) cc++;
}
if (a == b && b == c) {
long long ans = (ac - 2);
ans = ans * (ac - 1);
ans = ans * ac;
ans = ans / 6;
cout << ans << endl;
} else if (a == b && b != c) {
long long ans = ac;
ans = ans * (ac - 1);
ans = ans / 2;
ans = ans * cc;
cout << ans << endl;
} else if (b == c && a != b) {
long long ans = bc;
ans = ans * (bc - 1);
ans = ans / 2;
ans = ans * ac;
cout << ans << endl;
} else {
assert(a != b && b != c);
long long ans = ac;
ans = ans * bc;
ans = ans * cc;
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int main() {
int n;
scanf("%d", &n);
string s;
cin >> s;
map<char, int> np;
int k = 0;
for (int i = 0; i < (int)s.size(); i++) {
if (!np[s[i]]) k++;
np[s[i]]++;
}
int left = 0, right = 0, cnt = 0;
map<char, int> mp;
int MIN = 0x3f3f3f3f;
for (right = 0; right < n; right++) {
if (!mp[s[right]]) cnt++;
mp[s[right]]++;
while (cnt == k && left <= right) {
if (MIN > right - left + 1) MIN = right - left + 1;
if (--mp[s[left]] == 0) cnt--;
left++;
}
}
printf("%d\n", MIN);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i = 1, x, c = 0, c1 = 1;
cin >> n;
while (n >= c1) {
n = n - c1;
i++;
c1 += i;
c++;
}
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-14;
const int maxn = 100500;
const int mod = 1e9 + 7;
int get(int L, int R, int md) {
int lo = (L % 5 == 0 ? L : L + 5 - L % 5), hi = (R % 5 == 0 ? R : R - R % 5);
int d = hi / 5 - max(0, (lo - 1)) / 5;
if (R - hi < md) d--;
if (lo - L >= 5 - md) d++;
return d;
}
struct flow_graph {
int MAX_V, E, s, t, head, tail;
int *to, *next, *cap, *last, *dist, *q, *now;
flow_graph() {}
flow_graph(int V, int MAX_E) {
MAX_V = V;
to = new int[2 * MAX_E], cap = new int[2 * MAX_E],
next = new int[2 * MAX_E];
dist = new int[MAX_V], last = new int[MAX_V], q = new int[MAX_V],
now = new int[MAX_V];
}
void clear() {
fill(last, last + MAX_V, -1);
E = 0;
}
void add_edge(int u, int v, int uv, int vu = 0) {
to[E] = v, next[E] = last[u], last[u] = E, cap[E] = uv, E++;
to[E] = u, next[E] = last[v], last[v] = E, cap[E] = vu, E++;
}
bool bfs() {
fill(dist, dist + MAX_V, -1);
head = tail = 0;
q[tail] = t;
dist[t] = 0;
tail++;
while (head < tail) {
int u = q[head++];
for (int e = last[u]; e != -1; e = next[e]) {
int v = to[e];
if (cap[e ^ 1] > 0 && dist[v] == -1)
q[tail++] = v, dist[v] = dist[u] + 1;
}
}
return dist[s] != -1;
}
int dfs(int u, int f) {
if (u == t) return f;
for (int &e = now[u]; e != -1; e = next[e]) {
int v = to[e];
if (cap[e] > 0 && dist[v] == dist[u] - 1) {
int df = dfs(v, min(f, cap[e]));
if (df > 0) {
cap[e] -= df;
cap[e ^ 1] += df;
return df;
}
}
}
return 0;
}
int dinic(int src, int snk) {
s = src, t = snk;
int f = 0, df;
while (bfs()) {
for (int i = 0; i < MAX_V; i++) now[i] = last[i];
while (true) {
df = dfs(s, 1 << 15);
if (df == 0) break;
f += df;
}
}
return f;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, b, q;
cin >> n >> b >> q;
vector<pair<int, int> > qs;
while (q--) {
int R, Q;
cin >> R >> Q;
qs.push_back({R, Q});
}
sort((qs).begin(), (qs).end());
qs.push_back({b, n});
flow_graph F((int)(qs).size() + 7, 7e4);
F.clear();
int prv = 1, vpr = 0;
for (int i = 0; i < (int)(qs).size(); ++i) {
if (i < (int)(qs).size() - 1 &&
((qs[i + 1].second - qs[i].second > qs[i + 1].first - qs[i].first) ||
qs[i].second > qs[i + 1].second))
return cout << "unfair\n", 0;
for (int j = 0; j < 5; ++j) {
int ad = get(prv, qs[i].first, j);
if (ad) F.add_edge((int)(qs).size() + j + 1, i + 1, ad);
}
F.add_edge(i + 1, (int)(qs).size() + 6, qs[i].second - vpr);
prv = qs[i].first + 1;
vpr = qs[i].second;
}
for (int i = (int)(qs).size() + 1; i <= (int)(qs).size() + 5; ++i)
F.add_edge(0, i, n / 5);
cout << (F.dinic(0, (int)(qs).size() + 6) == n ? "fair\n" : "unfair\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
double a, b;
double cal() {
if (fabs(b) < 1e-6) return 1.0;
if (fabs(a) < 1e-6) return 0.5;
if (4.0 * b >= a) return 0.5 + a / b / 16.0;
return 1.0 - b / a;
}
int main() {
int n;
while (~scanf("%d", &n)) {
while (n--) {
scanf("%lf%lf", &a, &b);
printf("%.9f\n", cal());
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mx = (int)1e5 + 100;
deque<int> q;
long long sum[mx];
int n, to[mx];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) scanf("%d", &to[i]);
long long as = 0;
q.push_back(n - 1), sum[n - 1] = as = 1;
for (int i = n - 2; i; --i) {
int x = upper_bound(q.begin(), q.end(), to[i]) - q.begin() - 1;
sum[i] = n - i + sum[q[x]] - (to[i] - q[x]);
as += sum[i];
while (!q.empty() && to[i] >= to[q.front()]) q.pop_front();
q.push_front(i);
}
cout << as << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
int n, k;
const int maxn = 200010;
int a[26] = {0};
char s[100010];
using namespace std;
int main() {
cin >> n >> k;
cin >> s + 1;
for (int i = 1; i <= n; i++) {
int t = s[i] - 'A';
a[t]++;
}
int mi = 1e5;
for (int i = 0; i < k; i++) {
mi = min(mi, a[i]);
}
cout << mi * k;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[2002], ans, s;
bool c[5555];
int x[5555], n;
string t[5555];
vector<pair<int, pair<int, int> > > a;
inline void pr(vector<int> a) {
for (int i = 0; i < a.size(); i++) cout << (a[i]) << " ";
cout << ("") << endl;
}
inline vector<int> add(vector<int> a, vector<int> b) {
int n = a.size(), m = b.size();
vector<int> c;
c.clear();
c.resize(max(n, m) + 1);
for (int i = 0; i < max(n, m); i++) {
if (i < n) c[i] += a[i];
if (i < m) c[i] += b[i];
c[i + 1] += c[i] / 10;
c[i] %= 10;
}
while (!c.back()) c.pop_back();
return c;
}
int main() {
v[0].push_back(1);
for (int i = 1; i <= 2000; i++) v[i] = add(v[i - 1], v[i - 1]);
scanf("%d", &n);
for (int i = 0; i < n; i++) cin >> t[i] >> x[i];
for (int i = 0; i < n; i++)
if (t[i] == "sell")
for (int j = i - 1; j >= 0; j--)
if (t[j] == "win" && x[j] == x[i]) {
a.push_back(make_pair(x[i], make_pair(j, i)));
break;
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
for (int i = 0; i < a.size(); i++) {
int l = a[i].second.first, r = a[i].second.second;
bool f = true;
for (int j = l; j <= r; j++)
if (c[j]) {
f = false;
break;
}
if (f) {
s.push_back(a[i].first);
for (int j = l; j <= r; j++) c[j] = 1;
}
}
ans.push_back(0);
for (int i = 0; i < s.size(); i++) ans = add(ans, v[s[i]]);
for (int i = ans.size() - 1; i >= 0; i--) printf("%d", ans[i]);
printf("\n");
return 0;
}
| 12 |
#include <bits/stdc++.h>
bool ok(int32_t x, int32_t n, const std::vector<int32_t>& a) {
int32_t count = 0;
for (int32_t t : a) {
count += t / x;
}
return count >= n;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int32_t n;
size_t m;
std::cin >> n >> m;
std::map<int32_t, int32_t> as;
for (size_t i = 0; i < m; ++i) {
int32_t a;
std::cin >> a;
as[a] += 1;
}
std::vector<int32_t> a;
for (const auto& [k, v] : as) {
a.push_back(v);
}
int32_t result = 0;
while (ok(result + 1, n, a)) {
result += 1;
}
std::cout << result << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int> q;
int n;
long long ans = 0;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
int x = read() - i;
q.push(x);
if (q.top() > x) {
ans += q.top() - x;
q.pop();
q.push(x);
}
}
printf("%lld", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int A[3005], B[3005], sz[3005];
pair<ll, ll> dp[3005][3005], t[3005];
vector<int> edge[3005];
void dfs(int x, int p) {
sz[x] = 1;
dp[x][1] = {0, A[x] - B[x]};
for (auto i : edge[x]) {
if (i == p) continue;
dfs(i, x);
for (int j = 1; j <= sz[x] + sz[i]; ++j) t[j] = {-1e18, 0};
for (int j = sz[x]; j; --j) {
for (int k = sz[i]; k; --k) {
t[j + k] = max(t[j + k], make_pair(dp[x][j].first + dp[i][k].first +
(dp[i][k].second > 0),
dp[x][j].second));
t[j + k - 1] =
max(t[j + k - 1], make_pair(dp[x][j].first + dp[i][k].first,
dp[x][j].second + dp[i][k].second));
}
}
sz[x] += sz[i];
for (int j = 1; j <= sz[x]; ++j) dp[x][j] = t[j];
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int T;
cin >> T;
while (T--) {
int N, M;
cin >> N >> M;
for (int i = 1; i <= N; ++i) edge[i].clear();
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) dp[i][j] = {-1e18, 0};
for (int i = 1; i <= N; ++i) cin >> B[i];
for (int i = 1; i <= N; ++i) cin >> A[i];
for (int i = 1; i < N; ++i) {
int x, y;
cin >> x >> y;
edge[x].push_back(y);
edge[y].push_back(x);
}
dfs(1, 1);
printf("%lld\n", dp[1][M].first + (dp[1][M].second > 0));
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int MOD = 1e9 + 7;
const ll INF = 1e18;
const char nl = '\n';
/*READ THE QUESTION CORRECTLY (ll vs int)*/
void solve() {
string c;
cin >> c;
int x = 0, y = 0;
for (auto r : c) {
if (r == 'L') x--;
else if (r == 'R') x++;
else if (r == 'U') y++;
else y--;
int xt = 0, yt = 0;
for (auto k : c) {
if (k == 'L') {
if (xt - 1 != x || yt != y) {
xt--;
}
}
else if (k == 'R') {
if (xt + 1 != x || yt != y) {
xt++;
}
}
else if (k == 'U') {
if (yt + 1 != y || xt != x) {
yt++;
}
}
else {
if (yt - 1 != y || xt != x) {
yt--;
}
}
}
if (yt == 0 && xt == 0) {
cout << x << " " << y << nl;
return ;
}
}
cout << "0 0" << nl;
}
int main() {
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
//freopen(".in", "r", stdin);
//freopen(".out", "w", stdout);
int t = 1;
/*TEST CASES*/
cin >> t;
for (int i = 0; i < t; i++) {
//cout << "Case #" << i + 1 << ": ";
solve();
}
return 0;
} | 8 |
#include <bits/stdc++.h>
const int N = 310;
const int inf = 0x3f3f3f3f;
using namespace std;
int n, m, k;
struct data {
int x, y, r;
data() {}
data(int _x, int _y, int _r) : x(_x), y(_y), r(_r) {}
bool operator<(const data &a) const {
if (a.r != r) return r < a.r;
if (a.x != x) return x < a.x;
return y < a.y;
}
} a[10000010];
int c[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
char s[N][N];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%s", &s[i][1]);
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (s[i][j] == '.') continue;
for (int r = 1; r <= min(n, m); r++) {
bool f = 0;
for (int k = 0; k < 4; k++) {
int x = i + c[k][0] * r, y = j + c[k][1] * r;
if (x <= 0 || x > n || y <= 0 || y > m) {
f = 1;
break;
}
if (s[x][y] != '*') f = 1;
}
if (f) continue;
a[cnt++] = data(i, j, r);
}
}
sort(a, a + cnt);
if (k > cnt) {
puts("-1");
return 0;
}
printf("%d %d\n", a[k - 1].x, a[k - 1].y);
for (int i = 0; i < 4; i++) {
int x = a[k - 1].x + a[k - 1].r * c[i][0];
int y = a[k - 1].y + a[k - 1].r * c[i][1];
printf("%d %d\n", x, y);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Mx = 100005;
int N;
vector<int> g[Mx];
int ar[Mx];
void solve() {
cin >> N;
for (int i = 1; i <= N; i++) {
int p, c;
cin >> p >> c;
if (p != -1) {
g[p].push_back(i);
}
ar[i] = c;
}
vector<int> v;
for (int i = 1; i <= N; i++) {
if (ar[i]) {
bool check = 1;
for (auto it : g[i]) {
if (ar[it] == 0) check = 0;
}
if (check) {
v.push_back(i);
}
}
}
if (v.size() == 0)
cout << -1 << endl;
else {
for (auto it : v) {
cout << it << ' ';
}
cout << endl;
}
}
int32_t main() {
int tt;
tt = 1;
int cas = 1;
while (tt--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long niz[300005][2];
long long gore, dole;
long long obican[300005];
long long sranje = 0, res;
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &niz[i][0]);
for (int i = 1; i <= n; i++) scanf("%I64d", &niz[i][1]);
for (int i = 1; i <= n; i++) gore += (i - 1ll) * niz[i][0];
for (int i = 1; i <= n; i++) gore += (n - 1 + i) * niz[n - i + 1][1];
for (int i = 1; i <= n; i++) dole += (i - 1ll) * niz[i][1];
for (int i = 1; i <= n; i++) dole += (n - 1 + i) * niz[n - i + 1][0];
for (int i = n; i >= 1; i--)
obican[i] = obican[i + 1] + niz[i][0] + niz[i][1];
res = gore;
for (long long i = 1; i <= n; i++) {
dole -= (2 * i - 2) * niz[i][1] + niz[i][0] * (2 * n - 1) - obican[i + 1];
gore -= (2 * i - 2) * niz[i][0] + niz[i][1] * (2 * n - 1) - obican[i + 1];
if (i % 2 == 1) {
sranje += (i - 1) * 2 * (niz[i][0] + niz[i][1]) + niz[i][1];
res = max(res, sranje + dole);
} else {
sranje += (i - 1) * 2 * (niz[i][1] + niz[i][0]) + niz[i][0];
res = max(res, sranje + gore);
}
}
printf("%I64d", res);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int fact[500005];
long long int fact_(long long int n) {
long long int ans = 1;
fact[0] = fact[1] = 1;
for (int i = 2; i <= n; i++) {
ans = (ans * i) % 1000000007;
fact[i] = ans % 1000000007;
}
return ans;
}
long long int mod_pow(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b % 2 == 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b = b >> 1;
}
return ans;
}
long long int ncr(long long int n, long long int r) {
if (n < 0 || r < 0) return 0;
if (n == 0 && r == 0) return 1;
if (n < r) return 0;
if (r == 0) return 1;
if (r == 1) return n;
if (n == r) return 1;
return ((((fact[n] % 1000000007) *
mod_pow(fact[r] % 1000000007, 1000000007 - 2)) %
1000000007) *
mod_pow(fact[n - r] % 1000000007, 1000000007 - 2)) %
1000000007;
}
void affirm() { cout << "YES" << endl; }
void deny() { cout << "NO" << endl; }
template <typename T>
void print(T x) {
cout << x << " ";
}
struct comp {
bool operator()(const pair<long long int, long long int> &x,
const pair<long long int, long long int> &y) const {
return x.second > y.second;
}
};
long long int nxt() {
long long int x;
cin >> x;
return x;
}
void solve() {
long long int L, v, l, r;
cin >> L >> v >> l >> r;
cout << L / v - (r / v - (l - 1) / v) << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = nxt();
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
map<char, long long> m;
long long a[30], k, maxi = -1, x, res = 0;
char z = 'a';
cin >> s;
cin >> k;
for (char i = 1; i <= 26; i++) {
cin >> a[i];
if (a[i] > maxi) maxi = a[i];
m[z] = a[i];
z++;
}
for (int j = 0; j < s.size(); j++) {
res += ((j + 1) * m[s[j]]);
}
x = s.size() + 1;
while (k != 0) {
res += (x * maxi);
x++;
k--;
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e7;
const long long N = 5e5 + 1;
const long long mod = 1e9 + 7;
const long double eps = 1E-7;
long long n, m, cnt, x, y, a[N];
string s;
int main() {
cin >> n >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'n') x++;
if (s[i] == 'z') y++;
}
for (int i = 0; i < x; i++) cout << 1 << ' ';
for (int i = 0; i < y; i++) cout << 0 << ' ';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<int> ans;
if (n == 2 && m == 2 && k == 1) {
ans.push_back(1);
ans.push_back(2);
ans.push_back(3);
ans.push_back(4);
} else if (n >= m + 2) {
for (int i = 0; i < k; ++i) ans.push_back(1);
for (int i = 0; i < k; ++i) ans.push_back(n);
} else if (n == m + 1) {
for (int i = 0; i < k; ++i) ans.push_back(1);
for (int i = 0; i < max(k - 1, 1); ++i) ans.push_back(n);
ans.push_back(n + 1);
} else if (n == m) {
for (int i = 0; i < k; ++i) ans.push_back(1);
for (int i = 0; i < k - 1; ++i) ans.push_back(n + 1);
ans.push_back(n);
ans.push_back(n + 2);
}
sort(ans.begin(), ans.end());
printf("%d\n", int((ans).size()));
for (int i = 0; i < int((ans).size()); ++i) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
int head[maxn], nxt[maxn << 1], ver[maxn << 1], tot;
inline void addedge(int a, int b) {
nxt[++tot] = head[a];
ver[tot] = b;
head[a] = tot;
nxt[++tot] = head[b];
ver[tot] = a;
head[b] = tot;
}
int fa[maxn][21], size[maxn], dep[maxn];
long long sum[maxn], upsum[maxn];
inline int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 0, delta = dep[x] - dep[y]; delta; i++, delta >>= 1)
if (delta & 1) x = fa[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
inline int Climb(int x, int to) {
for (int i = 0, delta = dep[x] - dep[to] - 1; delta; i++, delta >>= 1)
if (delta & 1) x = fa[x][i];
return x;
}
inline void dfs(int x, int fat) {
fa[x][0] = fat;
size[x] = 1;
dep[x] = dep[fat] + 1;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == fat) continue;
dfs(y, x);
size[x] += size[y];
sum[x] += sum[y] + size[y];
}
}
int n, m;
inline void getsum(int x, int fat, long long upv) {
upsum[x] = upv;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == fat) continue;
getsum(y, x, upv + sum[x] - sum[y] + n - size[y] - size[y]);
}
}
inline double query(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
int l = lca(x, y);
long long res = 0, cnt = 0;
if (l == x) {
int z = Climb(y, x);
res += sum[y] * (n - size[z]) +
(upsum[x] + sum[x] - size[z] - sum[z]) * size[y];
res += 1ll * size[y] * (n - size[z]) * (dep[y] - dep[x]);
cnt += 1ll * size[y] * (n - size[z]);
} else {
res += 1ll * sum[x] * size[y] + 1ll * sum[y] * size[x];
res += 1ll * size[x] * size[y] * (dep[x] + dep[y] - (dep[l] << 1));
cnt += 1ll * size[x] * size[y];
}
return 1.0 * res / cnt + 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, a, b; i < n; i++) scanf("%d%d", &a, &b), addedge(a, b);
dfs(1, 0);
getsum(1, 0, 0);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%.8f\n", query(x, y));
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj(100001);
int t;
int mx = -1;
vector<bool> vis(100001, false);
int dfs(int x, int m) {
vis[x] = true;
int m1 = 0, m2 = 0;
for (int i = 0; i < adj[x].size(); i++)
if (!vis[adj[x][i]]) {
int n = dfs(adj[x][i], m + 1);
if (n > m1)
m2 = m1, m1 = n;
else if (n > m2)
m2 = n;
}
if (m1 == 0 && m2 == 0) return m;
if (m1 + m2 - 2 * m > mx) mx = m1 + m2 - 2 * m;
vis[x] = false;
return m1;
}
int main() {
int m;
cin >> t >> m;
t--;
while (t--) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0);
cout << mx << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x;
double v, dp1[105][105], dp2[105][10005], sum[105][105], k;
vector<double> a[105];
double num(int _, int i, int j) {
int z = a[_].size();
return sum[_][z] - sum[_][z - j] + sum[_][i];
}
signed main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> x;
for (int j = 1; j <= x; j++)
cin >> v, a[i].push_back(v), sum[i][j] = sum[i][j - 1] + v;
}
k = 1;
if (k == 0) cout << "0", exit(0);
if (k > 0) {
for (int _ = 1; _ <= n; _++)
for (int l = 1; l <= a[_].size(); l++)
for (int i = 0; i <= l; i++) {
int j = l - i;
dp1[_][l] = max(dp1[_][l], num(_, i, j));
}
for (int _ = 1; _ <= n; _++)
for (int i = 0; i <= m; i++)
for (int j = 0; j <= a[_].size() && j <= i; j++)
dp2[_][i] = max(dp2[_][i], dp2[_ - 1][i - j] + dp1[_][j]);
} else if (k < 0) {
for (int _ = 1; _ <= n; _++)
for (int l = 1; l <= a[_].size(); l++) {
dp1[_][l] = 1e9;
for (int i = 0; i <= l; i++) {
int j = l - i;
dp1[_][l] = min(dp1[_][l], num(_, i, j));
}
}
for (int i = 1; i <= a[1].size(); i++) dp2[0][i] = 1e9;
for (int _ = 1; _ <= n; _++)
for (int i = 0; i <= m; i++) {
dp2[_][i] = 1e9;
for (int j = 1; j <= a[_].size() && j <= i; j++) {
dp2[_][i] = min(dp2[_][i], dp2[_ - 1][i - j] + dp1[_][j]);
}
}
}
cout << dp2[n][m] * k;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<vector<int>, int> m;
while (n--) {
int h, mi;
cin >> h >> mi;
vector<int> v;
v.push_back(h);
v.push_back(mi);
m[v]++;
}
vector<int> v1;
for (auto it = m.begin(); it != m.end(); it++) v1.push_back(it->second);
cout << *max_element(v1.begin(), v1.end());
return 0;
}
| 2 |
Subsets and Splits