solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
priority_queue<int> q[4];
int n, m;
long long f[4][300003];
void FoehnDestruct() {
int k = q[1].size();
for (int i = 1; i <= k && i <= m; i++) {
f[1][i] = f[1][i - 1] + q[1].top();
q[1].pop();
}
for (int i = k + 1; i <= m; i++) f[1][i] = f[1][i - 1];
}
void LightningStorm() {
int k = q[2].size();
long long c, l = 1, sum = 0, t = 0;
for (int i = 1; i <= k && i <= m; i++) {
c = q[2].top();
q[2].pop();
for (int j = l; j <= m; j++) {
l = j;
if (j >= 2 * (t + 1) &&
f[1][j - t * 2] + sum < f[1][j - t * 2 - 2] + sum + c) {
f[2][j] = sum + c + f[1][j - t * 2 - 2];
t++;
sum += c;
break;
} else {
f[2][j] = sum + f[1][j - t * 2];
}
}
}
for (int j = l; j <= m; j++) {
f[2][j] = sum + f[1][j - t * 2];
}
}
void DominatorControll() {
long long sum = 0, t = 0;
f[3][m] = f[2][m];
while (q[3].size()) {
t += 3;
sum += q[3].top();
q[3].pop();
if (t <= m) {
f[3][m] = max(f[3][m], f[2][m - t] + sum);
}
}
}
void MODEV() {
long long x = ~f[3][m] != -1 ? f[3][m] : 0;
cout << x;
return;
}
void Mental_Omega(int O) {
if (~O == -1) MODEV();
}
void NuclearMark() {
for (int i = 10; ~i; i--) Mental_Omega(i);
return;
}
int main() {
cin >> n >> m;
int mm, c;
for (int i = 0; i < n; i++) {
scanf("%d%d", &mm, &c);
if (mm == 1)
q[1].push(c);
else if (mm == 2)
q[2].push(c);
else
q[3].push(c);
}
FoehnDestruct();
LightningStorm();
DominatorControll();
NuclearMark();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, M = 998244353, OO = 0x3f3f3f3f, HS = 31, HS2 = 47,
M2 = 1e9 + 9;
const double PI = acos(-1);
long long tc, x, y;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
tc = 1;
cin >> tc;
while (tc--) {
cin >> x >> y;
long long ans = 0;
if (x > y)
ans = (y * x) + y;
else if (y % x == 0)
ans = y;
else {
long long md = y % x;
md /= 2;
ans = y - md;
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename... T>
void read(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void write(T&&... args) {
((cout << args << " "), ...);
}
using namespace std;
long long int __gcd(long long int a, long long int b) {
if (b == 0) return a;
return __gcd(b, a % b);
}
void solve() {
long long int n, k;
read(n, k);
pair<long long int, long long int> arr[n];
map<long long int, long long int> mp1;
for (long long int i = 0; i < n; i++) {
cin >> arr[i].first;
mp1[arr[i].first]++;
arr[i].second = i + 1;
}
sort(arr, arr + n);
if (mp1[0] == 0 || mp1[0] > 1) {
cout << -1 << endl;
return;
}
vector<pair<long long int, long long int> > ans;
vector<long long int> arr1;
arr1.push_back(arr[0].second);
long long int cnt = 1, start = 1, latest = 0, p = 0, flag = 0;
long long int start1 = 0, start2 = 1, sum = 0;
while (start1 <= start2) {
if (sum == k) {
start1++;
if (arr[start1].first == arr[start2].first) break;
sum = 0;
}
ans.push_back(make_pair(arr[start1].second, arr[start2].second));
start2++;
if (start2 == n) break;
if (arr[start2].first - arr[start2 - 1].first > 1) break;
sum++;
if (arr[start2].first - arr[start2 - 1].first == 1) {
sum = 0;
while (arr[start1].first != arr[start2].first - 1) start1++;
}
if (arr[start2].first != 1 && flag == 0) k--, flag = 1;
}
if (start2 == n) {
cout << ans.size() << endl;
for (long long int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
} else {
cout << -1 << endl;
}
}
int main() {
int t;
t = 1;
;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
using pii = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
void solve();
int main() {
high_resolution_clock::time_point t1 = high_resolution_clock::now();
{ solve(); }
high_resolution_clock::time_point t2 = high_resolution_clock::now();
const auto duration = duration_cast<milliseconds>(t2 - t1).count();
cout.flush();
cerr << "--------------" << endl;
cerr << "Elapsed Time: " << duration << "ms" << endl;
cerr << "--------------" << endl;
;
}
ll n, d, m, l;
void solve() {
cin >> n >> d >> m >> l;
long long plat = 1;
long long pos = 0;
long long gap = m - l;
while (plat <= n) {
const long long end_plat = plat * m;
if (pos < end_plat) {
if (pos > end_plat - gap) {
cout << pos << endl;
return;
}
const long long dist = end_plat - gap - pos;
const long long dd = dist / d;
pos += dd * d + d;
} else {
long long dist = pos - end_plat;
long long kk = dist / m;
plat += kk + 1;
}
}
cout << pos << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int l, r, sol;
unsigned int sieve[300000010 / 20] = {0};
bool isprime(int p) {
return (((sieve[(p - 1) >> 1 >> 5] >> ((p - 1) >> 1 & 31)) & 1) == 0);
}
inline void gen() {
int i, j, k, p;
int bd = sqrt(r / 2 + 1) + 2;
for (i = 1; i <= bd; i++)
if (((sieve[i >> 5] >> (i & 31)) & 1) == 0) {
for (j = 2 * i * (i + 1), k = 2 * i + 1; j < r / 2 + 1; j += k)
sieve[j >> 5] |= 1 << (j & 31);
p = (i * 2 + 1);
if (l <= p && p <= r && (p & 3) == 1) sol++;
}
i = i * 2 + 1;
i = (i + 2) / 4 * 4 + 1;
for (; i <= r; i += 4) {
if (l <= i && isprime(i)) {
sol++;
}
}
}
inline int solve() {
int i;
if (l <= 2 && r >= 2) sol++;
gen();
return sol;
}
int main(void) {
scanf("%d %d", &l, &r);
printf("%d\n", solve());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long n, m, tests, ar[1200][1200], l[1200][1200], r[1200][1200], u[1200][1200],
d[1200][1200];
long tp, x, y;
long ans;
stack<pair<long, long> > v, emp;
long uu;
long lp;
long op;
void update(long x, long y) {
ar[x][y] = 1 - ar[x][y];
for (int i = x; i <= x; i++)
for (int j = 1; j <= m; j++) {
l[i][j] = l[i][j - 1] + 1;
if (ar[i][j] == 0) l[i][j] = 0;
}
for (int i = x; i <= x; i++)
for (int j = m; j; --j) {
r[i][j] = r[i][j + 1] + 1;
if (ar[i][j] == 0) r[i][j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = y; j <= y; j++) {
u[i][j] = u[i - 1][j] + 1;
if (ar[i][j] == 0) u[i][j] = 0;
}
for (int i = n; i; --i)
for (int j = y; j <= y; j++) {
d[i][j] = d[i + 1][j] + 1;
if (ar[i][j] == 0) d[i][j] = 0;
}
}
long solve(long x, long y) {
ans = 0;
v = emp;
for (int i = 1; i <= n + 1; i++) {
lp = i;
while (v.size() > 0 && l[i][y] < v.top().first) {
uu = v.top().first;
op = v.top().second;
if (i > x && op <= x) ans = max(ans, (i - v.top().second) * uu);
lp = v.top().second;
v.pop();
}
if (v.size() == 0)
uu = 0;
else
uu = v.top().first;
if (l[i][y] > uu) v.push(make_pair(l[i][y], lp));
if (i == x && v.size() == 0) break;
}
v = emp;
for (int i = 1; i <= n + 1; i++) {
lp = i;
while (v.size() > 0 && r[i][y] < v.top().first) {
uu = v.top().first;
op = v.top().second;
if (i > x && op <= x) ans = max(ans, (i - v.top().second) * uu);
lp = v.top().second;
v.pop();
}
if (v.size() == 0)
uu = 0;
else
uu = v.top().first;
if (r[i][y] > uu) v.push(make_pair(r[i][y], lp));
if (i == x && v.size() == 0) break;
}
v = emp;
for (int i = 1; i <= m + 1; i++) {
lp = i;
while (v.size() > 0 && u[x][i] < v.top().first) {
uu = v.top().first;
op = v.top().second;
if (i > y && op <= y) ans = max(ans, (i - v.top().second) * uu);
lp = v.top().second;
v.pop();
}
if (v.size() == 0)
uu = 0;
else
uu = v.top().first;
if (u[x][i] > uu) v.push(make_pair(u[x][i], lp));
if (i == y && v.size() == 0) break;
}
v = emp;
for (int i = 1; i <= m + 1; i++) {
lp = i;
while (v.size() > 0 && d[x][i] < v.top().first) {
uu = v.top().first;
op = v.top().second;
if (i > y && op <= y) ans = max(ans, (i - v.top().second) * uu);
lp = v.top().second;
v.pop();
}
if (v.size() == 0)
uu = 0;
else
uu = v.top().first;
if (d[x][i] > uu) v.push(make_pair(d[x][i], lp));
if (i == y && v.size() == 0) break;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> tests;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cin >> ar[i][j];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
l[i][j] = l[i][j - 1] + 1;
if (ar[i][j] == 0) l[i][j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = m; j; --j) {
r[i][j] = r[i][j + 1] + 1;
if (ar[i][j] == 0) r[i][j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
u[i][j] = u[i - 1][j] + 1;
if (ar[i][j] == 0) u[i][j] = 0;
}
for (int i = n; i; --i)
for (int j = 1; j <= m; j++) {
d[i][j] = d[i + 1][j] + 1;
if (ar[i][j] == 0) d[i][j] = 0;
}
for (; tests; --tests) {
cin >> tp >> x >> y;
if (tp == 1) {
update(x, y);
continue;
}
if (tp == 2) {
cout << solve(x, y) << endl;
continue;
}
}
cin.get();
cin.get();
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long s, x, t, g, Res;
int main() {
int i;
std::cin >> s >> x;
if ((s - x) % 2 != 0 || s < x) {
std::cout << 0;
return 0;
}
t = (s - x) / 2;
if (t & x) {
std::cout << 0;
return 0;
}
Res = 1;
while (x) {
if (x % 2) Res *= 2;
x /= 2;
}
if (!t) Res -= 2;
std::cout << Res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const long long mod = (1e9) + 7;
int n, m, ans, tmp, tot;
void update(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
bool in(int t, int i) {
if (t & (1 << (i - 1))) return 1;
return 0;
}
int f(int x, int i) {
if (x % 2 != i) x--;
return x / 2 + 1;
}
int gcd(int x, int y) {
if (!x || !y) return x + y;
return gcd(y, x % y);
}
int main() {
read(n);
read(m);
int a, b, c, d;
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++) {
for (int t = 0; t < (1 << 4); t++) {
a = in(t, 1);
b = in(t, 2);
c = in(t, 3);
d = in(t, 4);
if (abs((a - x) * (d - y) - (c - x) * (b - y)) % 2 == 0)
update(ans, (long long)f(n, a) * f(m, b) % mod * f(n, c) % mod *
f(m, d) % mod * f(n, x) % mod * f(m, y) % mod);
}
}
tot = (n + 1) * (m + 1);
update(ans, mod - tot);
update(ans, mod - (long long)tot * (tot - 1) * 3 % mod);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) {
if (!i && !j) continue;
tmp = (n - i + 1) * (m - j + 1) % mod;
if (i && j) tmp = tmp * 2 % mod;
tmp = (long long)tmp * (gcd(i, j) - 1) * 6 % mod;
update(ans, mod - tmp);
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
if (n1 > n2)
puts("First");
else
puts("Second");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, a1;
cin >> n;
vector<long long int> a;
long long int ans = 0;
for (i = 0; i < n; i++) {
cin >> a1;
a.push_back(a1);
}
vector<long long int> sum(n + 1, 0);
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i - 1];
}
vector<long long int> sumsort(n + 1, 0);
sort(a.begin(), a.end());
for (i = 1; i <= n; i++) {
sumsort[i] = sumsort[i - 1] + a[i - 1];
}
long long int q;
cin >> q;
while (q--) {
long long int qtype, l, r;
ans = 0;
cin >> qtype >> l >> r;
if (qtype == 1) {
for (i = l; i <= r; i++) {
ans = sum[r] - sum[l - 1];
}
} else {
for (i = l; i <= r; i++) {
ans = sumsort[r] - sumsort[l - 1];
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c;
double p, q;
while (cin >> a >> b >> c) {
if (a == 0 && b == 0 && c == 0)
cout << -1 << endl;
else if (a == 0 && b == 0 && c != 0)
cout << 0 << endl;
else if (a == 0) {
if (b != 0 && c == 0) {
cout << 1 << endl;
p = 0 * 1.0;
printf("%lf\n", p);
} else {
cout << 1 << endl;
p = 1.0 * (-c / b);
printf("%lf", p);
}
} else {
if (b * b - 4 * a * c == 0) {
cout << 1 << endl;
p = -b / (2 * a) * 1.0;
if (!p) p = 0;
printf("%lf\n", p);
} else if (b * b - 4 * a * c > 0) {
cout << 2 << endl;
p = (-b - sqrt(b * b - 4 * a * c)) / (2 * a) * 1.0;
q = (-b + sqrt(b * b - 4 * a * c)) / (2 * a) * 1.0;
if (p > q) swap(p, q);
printf("%lf\n%lf\n", p, q);
} else
cout << 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
bool isprime(long long k) {
bool is = 1;
for (long long i = 2; i * i <= k; i++)
if (k % i == 0) is = 0;
return k > 1 ? is : 0;
}
const double PI = acos(-1);
long long n, x, y;
inline void sol() {
cin >> n >> x >> y;
x -= (n - 1);
y -= (n - 1);
for (long long i = 1; i <= 10000000; i++) {
if (i * i >= x && i <= y) {
for (long long j = 1; j < n; j++) cout << 1 << "\n";
cout << i << "\n";
return;
}
}
cout << -1;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long _ = 1;
while (_--) sol();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, kk, q;
pair<int, pair<int, int> > p[250000];
int a[510][510];
bool check(int mid) {
memset(a, 0, sizeof(a));
int k = 0;
while (k < q && p[k].first <= mid) {
a[p[k].second.first][p[k].second.second] = 1;
k++;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] += a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
}
}
for (int i = 1; i + kk - 1 <= n; i++) {
for (int j = 1; j + kk - 1 <= m; j++) {
int xx = i + kk - 1;
int yy = j + kk - 1;
if (a[xx][yy] - a[i - 1][yy] - a[xx][j - 1] + a[i - 1][j - 1] == kk * kk)
return 1;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> kk >> q;
for (int i = 0; i < q; i++) {
cin >> p[i].second.first >> p[i].second.second >> p[i].first;
}
sort(p, p + q);
int l = 0, r = 1e9, mid, ans = -1;
while (l <= r) {
mid = l + (r - l) / 2;
if (check(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> g(1000);
long long tre[1000];
long long aa[1000];
bool mark[1000];
long long par[1000];
queue<long long> q;
long long a, b, c, d, m, n, i;
void bldtr(long long l, long long r, long long k) {
if (l == r)
tre[k] = aa[l];
else {
bldtr(l, (l + r) / 2, k * 2);
bldtr((l + r) / 2 + 1, r, k * 2 + 1);
tre[k] = tre[2 * k] + tre[2 * k + 1];
}
}
long long sumtr(long long tl, long long tr, long long l, long long r,
long long v) {
if (l > r) return 0;
if (tl == l && tr == r) return tre[v];
return sumtr(tl, (tl + tr) / 2, l, min(r, (tl + tr) / 2), 2 * v) +
sumtr((tl + tr) / 2 + 1, tr, max(l, (tl + tr) / 2 + 1), r, 2 * v + 1);
}
void updatetr(long long v, long long tl, long long tr, long long pos,
long long val) {
if (tl == tr)
tre[v] = val;
else {
if (pos <= (tl + tr) / 2)
updatetr(2 * v, tl, (tl + tr) / 2, pos, val);
else
updatetr(2 * v + 1, (tl + tr) / 2 + 1, tr, pos, val);
tre[v] = tre[2 * v] + tre[2 * v + 1];
}
}
long long ddeg(long long a, long long n) {
if (n == 1) return a;
if (n == 0) return 1;
return ddeg(a, n / 2) * ddeg(a, (n / 2 + n % 2));
}
void dfs(long long a) {
mark[a] = true;
for (long long i = 0; i < g[a].size(); i++) {
if (mark[g[a][i]] != true) dfs(g[a][i]);
}
}
long long bfs(long long a, long long b) {
if (a == b) return b;
mark[a] = true;
q.push(a);
long long k = 0;
while (!q.empty()) {
long long s = q.size();
k++;
for (long long j = 0; j < s; j++) {
a = q.front();
q.pop();
for (i = 0; i < g[a].size(); i++) {
if (g[a][i] == b) return k;
if (mark[g[a][i]] != true) q.push(g[a][i]);
}
}
}
}
void makeset(long long a) { par[a] = a; }
long long fndpar(long a) {
if (par[a] == a) return a;
return par[a] = fndpar(par[a]);
}
void combset(long long a, long long b) {
a = fndpar(a);
b = fndpar(b);
if (a != b) {
par[a] = b;
}
}
int main() {
cin >> m >> d;
if (m == 1 || m == 3 || m == 5 || m == 7 || m == 8 || m == 10 || m == 12)
m = 31;
else if (m == 2)
m = 28;
else
m = 30;
m -= (7 - d + 1);
a++;
a += (m / 7);
if (m % 7 != 0) a++;
cout << a;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int X, d;
cin >> X >> d;
vector<unsigned long long> ans;
int ind = 0;
int cnt = 0;
unsigned long long num = 1LL;
while (X) {
int dig = X % 2;
if (dig) {
for (int i = 0; i < ind; i++) {
ans.push_back(num);
}
num += d;
cnt++;
}
++ind;
X /= 2;
}
for (int i = 0; i < cnt; i++) {
ans.push_back(num);
num += d;
}
cout << ans.size() << endl;
for (auto it : ans) {
cout << it << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[500005], L[500005], R[500005];
struct Node {
int id, vlu;
Node() { id = 0, vlu = INT_MAX; }
Node(int _i, int _v) : id(_i), vlu(_v) {}
};
Node _merge(Node p, Node q) { return p.vlu < q.vlu ? p : q; }
Node tree[500005 * 4];
void build(int node, int lo, int hi) {
if (lo == hi) {
tree[node] = Node(lo, a[lo]);
return;
}
int mid = lo + (hi - lo) / 2, lft = node << 1, rgt = lft | 1;
build(lft, lo, mid);
build(rgt, mid + 1, hi);
tree[node] = _merge(tree[lft], tree[rgt]);
}
void update(int node, int lo, int hi, int pos) {
if (lo == hi) {
tree[node].vlu = INT_MAX;
return;
}
int mid = lo + (hi - lo) / 2, lft = node << 1, rgt = lft | 1;
if (pos <= mid)
update(lft, lo, mid, pos);
else
update(rgt, mid + 1, hi, pos);
tree[node] = _merge(tree[lft], tree[rgt]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i), L[i] = i - 1, R[i] = i + 1;
build(1, 1, n);
long long res = 0;
int lft = 1, rgt = n;
for (int i = 1; i <= n - 2; i++) {
int id = tree[1].id;
if (id == rgt) {
res += tree[1].vlu, rgt = L[rgt];
} else if (id == lft) {
res += tree[1].vlu, lft = R[lft];
} else {
res += min(a[L[id]], a[R[id]]);
R[L[id]] = R[id];
L[R[id]] = L[id];
}
update(1, 1, n, id);
}
printf("%lld\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int i, n, A, b, c, d;
scanf("%d\n", &n);
b = -1;
c = d = 1;
for (i = 0; i < n; i++) {
static char line[64];
int h, m;
fgets(line, 64, stdin);
h = (line[1] - '0') * 10 + (line[2] - '0');
m = (line[4] - '0') * 10 + (line[5] - '0');
h %= 12;
if (line[7] == 'p') h += 12;
A = h * 60 + m;
if (b < A)
c = 1;
else if (b == A && c < 10)
c++;
else {
d++;
c = 1;
}
b = A;
}
printf("%d\n", d);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
const int N = 3e5;
vector<int> g[N], cg[N];
vector<long long> stree[N], contri[N], wt[N];
vector<int> cur;
int part;
int gvis[N], c_par[N];
const int LG = 20;
int a[N], lvl[N], P[N][LG], sz[N];
long long D[N];
void predfs(int u, int par) {
if (!par) lvl[u] = D[u] = 0;
P[u][0] = par;
int pos = -1;
for (int v : g[u]) {
int w = wt[u][++pos];
if (v == par) continue;
lvl[v] = 1 + lvl[u];
D[v] = w + D[u];
predfs(v, u);
}
}
void prelca(int n) {
int i, j;
for (i = 0; i < LG; i++)
for (j = 0; j < n + 1; j++) P[j][i] = -1;
lvl[0] = -1;
predfs(1, 0);
for (i = 1; i < LG; i++) {
for (j = 1; j < n + 1; j++)
if (P[j][i - 1] != -1) P[j][i] = P[P[j][i - 1]][i - 1];
}
}
int lca(int u, int v) {
int i, lg;
if (lvl[u] < lvl[v]) swap(u, v);
for (lg = 0; (1 << lg) <= lvl[u]; lg++)
;
lg--;
for (i = lg; i >= 0; i--) {
if (lvl[u] - (1 << i) >= lvl[v]) u = P[u][i];
}
if (u == v) return u;
for (i = lg; i >= 0; i--) {
if (P[u][i] != -1 and P[u][i] != P[v][i]) u = P[u][i], v = P[v][i];
}
return P[u][0];
}
long long dis(int u, int v) {
if (u == v) return 0;
if (lvl[u] < lvl[v]) swap(u, v);
int w = lca(u, v);
return D[u] + D[v] - 2 * D[w];
}
int tot = 0;
void dfs2(int u, int par) {
if (par == 0) tot = 0;
sz[u] = 1;
tot++;
for (int v : g[u]) {
if (gvis[v] or v == par) continue;
dfs2(v, u);
sz[u] += sz[v];
}
}
int centroid(int u, int par) {
for (int v : g[u]) {
if (v == par or gvis[v]) continue;
if (2 * sz[v] > tot) return centroid(v, u);
}
return u;
}
void decompose(int u, int par) {
dfs2(u, 0);
int cen = centroid(u, 0);
gvis[cen] = 1;
if (par) c_par[cen] = par;
for (int v : g[cen])
if (!gvis[v]) decompose(v, cen);
}
void build_centroid_tree(int n) {
int i;
for (i = 1; i < n + 1; i++)
if (c_par[i]) cg[c_par[i]].push_back(i);
}
void calc_root(int u, int root) {
stree[root].push_back(dis(u, root));
for (int v : cg[u]) calc_root(v, root);
}
void calc_contri(int u, int root) {
int par = c_par[root];
contri[root].push_back(dis(u, par));
for (int v : cg[u]) calc_contri(v, root);
}
void traverse_centroid_tree(int u, int par) {
for (int v : cg[u]) {
if (v == par) continue;
traverse_centroid_tree(v, u);
}
calc_root(u, u);
if (!par) return;
calc_contri(u, u);
}
bool f(long long val, long long x) { return val >= x; }
int bin(vector<long long> &a, long long val, int lo, int hi) {
if (a.empty()) return 0;
if (val < 0) return 0;
if (a[0] > val) return 0;
if (lo == hi) return lo + 1;
if (lo + 1 == hi) {
if (f(val, a[hi])) return hi + 1;
return lo + 1;
}
int mid = (lo + hi) / 2;
if (f(val, a[mid]))
return bin(a, val, mid, hi);
else
return bin(a, val, lo, mid - 1);
}
int query(int v, long long l) {
int ans = bin(stree[v], l, 0, (int)stree[v].size() - 1);
int u = v;
int orig = v;
v = c_par[v];
while (v) {
long long y = dis(orig, v);
ans += bin(stree[v], l - y, 0, (int)stree[v].size() - 1);
ans -= bin(contri[u], l - y, 0, (int)contri[u].size() - 1);
u = v;
v = c_par[v];
}
return ans;
}
long long ans[N];
void update(int u) {
int cur = u;
while (cur) {
ans[cur] = min(ans[cur], dis(cur, u));
cur = c_par[cur];
}
}
int query(int u) {
long long res = mod;
int cur = u;
while (cur) {
res = min(res, dis(cur, u) + ans[cur]);
cur = c_par[cur];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, n, k, j, u, v, w, q;
int t;
cin >> n >> q;
for (i = 0; i < n + 1; i++) ans[i] = mod;
for (i = 0; i < n - 1; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
wt[v].push_back(1);
wt[u].push_back(1);
}
prelca(n);
decompose(1, 0);
build_centroid_tree(n);
update(1);
while (q--) {
cin >> v >> w;
if (v == 1) {
update(w);
} else {
cout << query(w) << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 110;
const int inf = 0x3f3f3f3f;
const long long mod = 1000000007ll;
using namespace std;
int n, a[110];
long long c[N][110];
void init() {
c[0][0] = 1;
for (int i = 1; i <= 100; i++) {
c[i][0] = 1;
for (int j = 1; j <= 100; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
long long dp[11][N];
long long solve(int n, int a[]) {
init();
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i < 10; i++) {
for (int j = 0; j <= n; j++) {
if (dp[i][j] == 0) continue;
for (int k = a[i + 1]; k + j <= n; k++)
dp[i + 1][j + k] = (dp[i][j] * c[j + k][k] + dp[i + 1][j + k]) % mod;
}
}
return dp[10][n];
}
int main() {
int sum = 0;
scanf("%d", &n);
for (int i = 1; i <= 10; i++) scanf("%d", &a[i]), sum += a[i];
if (sum > n) {
printf("0\n");
return 0;
}
long long ret = 0;
for (int k = max(1, sum); k <= n; k++) {
if (k == 1) {
if (sum == 1)
ret++;
else
ret += 9;
continue;
}
for (int i = 2; i <= 10; i++) {
int f = 1;
if (a[i] == 0) f = 0;
a[i] -= f;
ret += solve(k - 1, a);
ret %= mod;
a[i] += f;
}
}
cout << (ret % mod) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long comb[19][19];
long long dp[262150][18];
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<long long> all(n);
for (int i = 0; i < n; i++) cin >> all[i];
for (int i = 0; i < k; i++) {
int x, y, c;
cin >> x >> y >> c;
x--;
y--;
comb[x][y] = c;
}
for (int mask = 1; mask < (1 << n); mask++) {
for (int y = 0; y < n; y++) {
if (mask & (1 << y)) {
int h = mask - (1 << y);
dp[mask][y] = all[y];
for (int j = 0; j < n; j++) {
if (h & (1 << j))
dp[mask][y] = max(dp[mask][y], dp[h][j] + all[y] + comb[j][y]);
}
}
}
}
long long ans = 0;
for (int mask = 1; mask < (1 << n); mask++) {
int cnt = 0;
for (int y = 0; y < n; y++) {
if (mask & (1 << y)) {
cnt++;
}
}
if (cnt == m) {
for (auto c : dp[mask]) ans = max(c, ans);
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int t;
t = 1;
while (t > 0) {
solve();
t--;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, M = 2e6;
int n, a[N];
void enter() {
cin >> n;
for (int i = (1), _b = (n); i <= _b; ++i) cin >> a[i];
}
pair<int, int> dp[M + 12];
inline void add(int a, int b) {
if (dp[a].first == b || dp[a].second == b) return;
if (dp[a].second < b)
dp[a] = {dp[a].second, b};
else if (dp[a].first < b)
dp[a] = {b, dp[a].second};
}
bool can(int i, int x) { return dp[x].second && dp[x].first > i; }
void process() {
for (int i = (1), _b = (n); i <= _b; ++i) add(a[i], i);
for (int i = 0; i < 21; ++i) {
for (int mask = (M), _b = (0); mask >= _b; --mask) {
if ((1 << (i)) & mask) {
add(mask ^ (1 << (i)), dp[mask].first);
add(mask ^ (1 << (i)), dp[mask].second);
}
}
}
int ans = 0;
for (int i = (1), _b = (n - 2); i <= _b; ++i) {
int mask = 0;
for (int j = (20), _b = (0); j >= _b; --j)
if (!((1 << (j)) & a[i])) {
if (can(i, (1 << (j)) | mask)) {
mask |= (1 << (j));
}
}
ans = max(ans, a[i] | mask);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
enter();
process();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) {
return false;
}
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
void Solved() {
long long n;
cin >> n;
long long ans = 0;
if (isPrime(n) == true) {
cout << 1 << endl;
return;
}
if (n % 2 == 1) {
ans++;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
n -= i;
break;
}
}
ans += (n / 2);
} else {
ans = (n / 2);
}
cout << ans << endl;
}
int main() {
Solved();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, la, lb;
int a[2002];
void sort(int i, int j) {
if (i >= j) return;
int m, n, t, k;
m = i, n = j;
k = a[i + j >> 1];
while (m <= n) {
while (a[m] < k) ++m;
while (a[n] > k) --n;
if (m <= n) {
t = a[m];
a[m] = a[n];
a[n] = t;
++m;
--n;
}
}
sort(i, n);
sort(m, j);
return;
}
void init() {
cin >> n >> la >> lb;
for (int i = 1; i <= n; ++i) cin >> a[i];
return;
}
int main() {
init();
sort(1, n);
cout << a[lb + 1] - a[lb] << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
const long long MAX_N = 2005;
long long P[MAX_N];
long long C[MAX_N][MAX_N];
long long F[MAX_N];
bool used[MAX_N];
long long n;
signed main() {
cin >> n;
F[0] = 1;
for (long long i = 1; i <= n; i++) F[i] = F[i - 1] * i % Mod;
for (long long i = 0; i <= n; i++) {
C[i][0] = 1;
for (long long j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % Mod;
}
}
for (long long i = 1; i <= n; i++) cin >> P[i];
for (long long i = 1; i <= n; i++) {
if (P[i] != -1) used[P[i]] = true;
}
long long fix = 0;
long long plc = 0;
for (long long i = 1; i <= n; i++) {
if (!used[i] && P[i] == -1) fix++;
if (P[i] == -1) plc++;
}
long long ans = 0;
for (long long i = 0; i <= fix; i++) {
if (i % 2)
ans -= C[fix][i] * F[plc - i] % Mod;
else
ans += C[fix][i] * F[plc - i] % Mod;
ans = (ans + Mod) % Mod;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:67108864")
using namespace std;
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
const int INF = 1000 * 1000 * 1000;
const int NMAX = 1000 * 1000;
int main() {
ifstream ifile("input.txt");
if (ifile) freopen("input.txt", "rt", stdin);
if (ifile) {
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
}
long double n, m, w;
while (cin >> n >> w >> m) {
long double d = (n * w) / m;
vector<vector<pair<int, long double> > > a(n);
int j = 0;
long double vs = d;
for (int i = 0; i < int(n); ++i) {
long double v = w;
while ((v - vs) > EPS) {
v -= vs;
a[i].push_back(make_pair(j, vs));
j++;
vs = d;
}
if (v > EPS) {
a[i].push_back(make_pair(j, v));
vs -= v;
if (vs < EPS) {
j++;
vs = d;
}
v = 0;
}
}
bool good = true;
for (int i = 0; i < int(n); ++i)
if (a[i].size() > 2) good = false;
vector<vector<pair<int, long double> > > ans(m);
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(a[i].size()); ++j) {
ans[a[i][j].first].push_back(make_pair(i, a[i][j].second));
}
}
if (good) {
cout << "YES" << endl;
for (int i = 0; i < int(m); ++i) {
for (int j = 0; j < int(ans[i].size()); ++j) {
printf("%d ", ans[i][j].first + 1);
printf("%.7lf ", ans[i][j].second);
}
printf("\n");
}
} else
cout << "NO" << endl;
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60, mod = 1e9 + 7;
int n, k, f[N][N][2], C[N][N];
int g(int x, int y) {
long long dat = 1ll * C[x][y] * (y + 1);
if (x - y > 1) dat *= (x - y);
return dat % mod;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i <= n; i++) C[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
if (k > n / 2) puts("0"), exit(0);
f[0][0][1] = f[1][0][0] = 1;
for (int i = 2; i <= n; i++)
for (int j = 0; j <= i / 2; j++)
for (int k = 0; k <= i - 2; k++)
for (int l = 0; l <= j; l++) {
f[i][j][0] =
(f[i][j][0] + 1ll * f[k + 1][l][1] * f[i - 2 - k][j - l][1] %
mod * g(i - 2, k)) %
mod,
l < j && (f[i][j][1] = (f[i][j][1] + 1ll * f[k + 1][l][0] *
f[i - 2 - k][j - 1 - l][1] %
mod * g(i - 2, k)) %
mod),
l < j && (f[i][j][1] =
(f[i][j][1] + 1ll * (f[k + 1][l][0] + f[k + 1][l][1]) *
f[i - 2 - k][j - 1 - l][0] % mod *
g(i - 2, k)) %
mod);
}
printf("%d\n", (f[n][k][0] + f[n][k][1]) % mod);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = n - 1; i >= 0; i--) {
if (k % arr[i] == 0) {
cout << k / arr[i] << endl;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int t, n, k;
char s[N];
string ar[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> k >> s + 1;
sort(s + 1, s + n + 1);
if (s[1] != s[k]) {
cout << s[k] << '\n';
continue;
}
cout << s[1];
if (s[k + 1] != s[n]) {
for (int i = k + 1; i <= n; i++) {
cout << s[i];
}
} else {
for (int i = 1; i <= (n - 1) / k; i++) {
cout << s[n];
}
}
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 5e3 + 10;
int n, k, v, a[N], dp[N][N], pre[N][N];
struct _ {
int cnt, first, second;
};
vector<_> g;
void add(int u, int v, int w) {
if (!u || v == w) return;
g.push_back({u, v, w});
int t = min((long long)u * k, (long long)a[v]);
a[v] -= t, a[w] += t;
}
int main() {
scanf("%d%d%d", &n, &k, &v);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
if (v % k == 0) {
for (int i = 1; i <= n; ++i) add(1e9, i, 1);
if (a[1] < v) return puts("NO"), 0;
puts("YES");
add(v / k, 1, 2);
for (auto [first, second, z] : g) printf("%d %d %d\n", first, second, z);
return 0;
}
memset(pre, -1, sizeof pre);
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k - 1; ++j)
if (dp[i - 1][j]) {
dp[i][(j + a[i]) % k] = dp[i][j] = 1;
pre[i][(j + a[i]) % k] = j;
}
}
if (!dp[n][v % k]) return puts("NO"), 0;
int now = v % k, f = 0, u = 0;
for (int i = n; i >= 1; --i) {
if (pre[i][now] >= 0) {
if (!f)
f = i;
else
add(1e9, i, f);
now = pre[i][now];
} else
u = i;
}
if (now || !f || a[f] % k != v % k) throw;
if (a[f] < v) {
if (!u) return puts("NO"), 0;
for (int i = 1; i <= n; ++i)
if (i != f) add(1e9, i, u);
add(a[u] / k, u, f);
}
if (a[f] < v) return puts("NO"), 0;
for (int i = 1; i <= n; ++i)
if (i != f) add((a[f] - v) / k, f, i);
if (a[f] != v) throw;
puts("YES");
for (auto [first, second, z] : g) printf("%d %d %d\n", first, second, z);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void debug(vector<T> v) {
cout << "\ndebug(vector)\n";
long long i;
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n\n";
}
void solve() {
int n, k, d;
cin >> n >> k >> d;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
map<int, int> mp;
int ans = INT_MAX;
for (int i = 0; i < d; i++) {
mp[v[i]]++;
}
if (mp.size() <= ans) ans = mp.size();
for (int i = d; i < n; i++) {
mp[v[i - d]]--;
if (mp[v[i - d]] == 0) {
mp.erase(v[i - d]);
}
mp[v[i]]++;
if (mp.size() <= ans) ans = mp.size();
}
cout << ans << endl;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
void dbg(const char* fmt, ...) {}
using namespace std;
const int N = 100100;
vector<int> ed[N];
vector<int> back[N];
vector<int> child[N];
int par[N], d[N];
void dfs(int s, int p) {
dbg("p = %d, s = %d\n", p, s);
par[s] = p;
d[s] = (p == -1) ? 0 : d[p] + 1;
for (int i = 0; i < int(ed[s].size()); ++i) {
int v = ed[s][i];
if (v == p) continue;
if (d[v] == -1) {
child[s].push_back(v);
dfs(v, s);
} else if (d[v] < d[s]) {
back[s].push_back(v);
dbg("back %d -> %d\n", s, v);
}
}
}
void printPath(int a, int b, int c) {
printf("%d %d %d\n", a + 1, b + 1, c + 1);
}
bool solve(int s, int p) {
vector<int> lostChild;
for (int i = 0; i < int(child[s].size()); ++i) {
if (!solve(child[s][i], s)) lostChild.push_back(child[s][i]);
}
while (lostChild.size() >= 2) {
int u = lostChild.back();
lostChild.pop_back();
int v = lostChild.back();
lostChild.pop_back();
printPath(u, s, v);
}
if (!lostChild.empty()) {
if (back[s].empty()) {
printPath(p, s, lostChild[0]);
return true;
} else {
int u = back[s].back();
back[s].pop_back();
printPath(u, s, lostChild[0]);
}
}
while (back[s].size() >= 2) {
int u = back[s].back();
back[s].pop_back();
int v = back[s].back();
back[s].pop_back();
printPath(u, s, v);
}
if (back[s].empty()) {
if (p == -1 || back[p].empty())
return false;
else {
int u = back[p].back();
back[p].pop_back();
printPath(u, p, s);
return true;
}
} else {
int u = back[s].back();
back[s].pop_back();
printPath(u, s, p);
return true;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
ed[u].push_back(v);
ed[v].push_back(u);
}
if (m % 2 == 1) {
printf("No solution\n");
return 0;
}
memset(d, 0xFF, sizeof(d));
dfs(0, -1);
solve(0, -1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long ans = 0;
vector <pair <int, int>> event;
for(int i = 0; i < n; i++) {
int a, c;
cin >> a >> c;
ans += c;
event.emplace_back(a, -1);
event.emplace_back(a + c, 1);
}
sort(event.begin(), event.end());
int last = event[0].first;
int cnt = 0;
for(auto i : event) {
if(cnt == 0) {
ans += i.first - last;
}
cnt += i.second;
if(cnt == 0) {
last = i.first;
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct candy {
candy() {
count = 0;
last = -1;
index = -1;
}
int count, last, index;
};
bool comp(candy& a, candy& b) { return a.count < b.count; }
int main() {
int n, k, m, a;
cin >> n >> k >> m >> a;
vector<candy> candidates(n);
for (int i = 0; i < a; ++i) {
int candidat_tmp;
cin >> candidat_tmp;
candidates[candidat_tmp - 1].index = candidat_tmp - 1;
candidates[candidat_tmp - 1].last = i;
candidates[candidat_tmp - 1].count++;
}
int numbers = k, stop = n;
sort(candidates.begin(), candidates.end(), comp);
reverse(candidates.begin(), candidates.end());
int count = 0;
vector<int> positions(n, -1);
for (int i = 0; i < n; ++i) {
if (candidates[i].index == -1) {
break;
}
if (count == k) {
break;
}
int chance_to_up = 0, count_from = m - a;
for (int j = 0; j < n; ++j) {
if (j != i) {
int coeff = 1;
if (candidates[i].count < candidates[j].count)
coeff = 0;
else {
if (candidates[i].count == candidates[j].count) {
coeff = candidates[i].last < candidates[j].last ? 1 : 0;
}
}
if (count_from -
(max(candidates[i].count - candidates[j].count, 0) + coeff) >=
0) {
count_from -=
(max(candidates[i].count - candidates[j].count, 0) + coeff);
chance_to_up++;
}
}
}
if (chance_to_up < k) {
positions[candidates[i].index] = 1;
count++;
} else {
int coeff = candidates[k - 1].last > candidates[i].last ? 1 : 0;
if (candidates[k - 1].count - candidates[i].count - coeff + m - a > 0) {
positions[candidates[i].index] = 2;
} else
positions[candidates[i].index] = 3;
}
}
for (int i = 0; i < n; ++i) {
if (positions[i] == -1) {
if (m - a - candidates[k - 1].count < 1)
positions[i] = 3;
else
positions[i] = 2;
}
}
for (int it : positions) cout << it << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(n), s(n);
for (int i = 0; i < n; ++i) cin >> p[i];
for (int i = 0; i < n; ++i) cin >> s[i];
map<int, int> m;
for (int i = 0; i < n; ++i) m[s[i]] = i;
vector<int> t(n);
for (int i = 0; i < n; ++i) {
t[i] = m[p[i]];
}
int r = 0;
vector<pair<int, int>> sw;
for (int i = n - 1; i > 0; --i) {
for (int j = 0; j < n; ++j)
if (t[j] == i) {
while (j < i) {
int p1 = j;
int p2 = j + 1;
while (!(t[p2] <= p1)) ++p2;
r += p2 - p1;
sw.push_back({p1, p2});
swap(t[p1], t[p2]);
j = p2;
}
break;
}
}
printf("%d\n", r);
printf("%d\n", sw.size());
for (auto x : sw) printf("%d %d\n", x.first + 1, x.second + 1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int A = -1, B = -1;
for (int i = 0; i < s.size(); i++) {
if (s[i] != 'a') {
A = i;
break;
}
}
if (A == -1) {
for (int i = 0; i < s.size() - 1; i++) printf("%c", s[i]);
if (s.back() == 'a')
printf("z");
else
printf("%c", s.back() - 1);
return 0;
}
for (int i = A; i < s.size(); i++) {
if (s[i] == 'a') {
B = i;
break;
}
}
if (B == -1) {
for (int i = 0; i < A; i++) printf("%c", s[i]);
for (int i = A; i < s.size(); i++) printf("%c", s[i] - 1);
} else {
for (int i = 0; i < A; i++) printf("%c", s[i]);
for (int i = A; i < B; i++) printf("%c", s[i] - 1);
for (int i = B; i < s.size(); i++) printf("%c", s[i]);
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
inline int read(){
int res=0;
char c;
bool zf=0;
while(((c=getchar())<'0'||c>'9')&&c!='-');
if(c=='-')zf=1;
else res=c-'0';
while((c=getchar())>='0'&&c<='9')res=(res<<3)+(res<<1)+c-'0';
if(zf)return -res;
return res;
}
const int maxn=1e5+5;
int l[maxn],r[maxn],p[maxn],x[maxn],y[maxn];
int a[maxn],b[maxn],c[maxn],d[maxn];
signed main(){
int n=read();
for(register int i=1;i<=n;++i){
p[i]=read();
}
for(register int i=1;i<=n;++i){
if(i==1||p[i-1]>p[i]){
l[i]=0;
}
else{
l[i]=l[i-1]+1;
}
}
for(register int i=n;i>=1;--i){
if(i==n||p[i+1]>p[i]){
r[i]=0;
}
else{
r[i]=r[i+1]+1;
}
}
for(register int i=1;i<=n;++i){
if(i==1||p[i-1]<p[i]){
x[i]=0;
}
else{
x[i]=x[i-1]+1;
}
}
for(register int i=n;i>=1;--i){
if(i==n||p[i+1]<p[i]){
y[i]=0;
}
else{
y[i]=y[i+1]+1;
}
}
int pre=0;
for(register int i=1;i<=n;++i){
if((l[i]||i==1)&&(r[i]||i==n)){
a[i]=pre,b[i]=max(max(b[pre],l[i]),r[i]),pre=i;
}
}
pre=n+1;
for(register int i=n;i>=1;--i){
if((l[i]||i==1)&&(r[i]||i==n)){
c[i]=pre,d[i]=max(max(d[pre],l[i]),r[i]),pre=i;
}
}
int ans=0;
for(register int i=1;i<=n;++i){
if(!l[i]||!r[i]){
continue;
}
if(max(b[a[i]],d[c[i]])>=max(l[i],r[i])){
continue;
}
if(l[i]&1){
if(max(x[i-l[i]],l[i])>=r[i]){
continue;
}
}
else{
if(l[i]>r[i]){
continue;
}
}
if(r[i]&1){
if(max(y[i+r[i]],r[i])>=l[i]){
continue;
}
}
else{
if(r[i]>l[i]){
continue;
}
}
++ans;
}
printf("%d\n",ans);
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
void owa_nb() {
set<int> zxczxc;
int zxc[] = {1, 2, 3};
for (int i = 0; i < 5432; i++) zxczxc.insert(i);
int _tmp = 0;
if (_tmp) exit(0);
}
bool check(int x) {
while (x) {
if (x % 10 == 7) return true;
x /= 10;
}
return false;
}
int main() {
owa_nb();
int x, h, m;
cin >> x;
cin >> h >> m;
int y = 0;
while (1) {
if (check(h) || check(m)) {
cout << y << endl;
break;
}
if (m - x >= 0) {
m -= x;
} else {
if (h - 1 >= 0) {
h -= 1;
m += 60;
} else {
h = 23;
m += 60;
}
m -= x;
}
y++;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, mod;
scanf("%lld%lld%lld", &a, &b, &mod);
if (b >= mod || a == 0) {
printf("2\n");
return 0;
}
long long num = 0, nump = 1000000000 % mod;
for (int i = 1; i <= a && i <= mod; i++) {
num += nump;
if (num >= mod) num -= mod;
if (num != 0 && num + b < mod) {
printf("1 %09d\n", i);
return 0;
}
}
printf("2\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 205;
int arr[MAX];
double p[MAX];
double dp[MAX][MAX][MAX];
int n, l, k;
double solve(int idx, int cnt, int w) {
if (idx == n) {
if (cnt >= l && w >= 0)
return 1.00;
else
return 0.00;
}
double &ret = dp[idx][cnt][w];
if (fabs(ret + 1) > 1e-9) return ret;
ret = p[idx] * solve(idx + 1, cnt + 1, min(200, w + arr[idx]));
ret += (1.00 - p[idx]) * solve(idx + 1, cnt, w);
return ret;
}
int main() {
memset(dp, -1.00, sizeof(dp));
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> l >> k;
for (int i = 0; i < n; ++i) {
cin >> p[i];
p[i] /= 100.00;
}
for (int i = 0; i < n; ++i) cin >> arr[i];
cout << fixed << setprecision(12) << solve(0, 0, k) << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, f[300005][19], d[300005];
long long a[300005][2], b[300005], dp[300005][19][2][2];
vector<int> v[300005];
vector<long long> e1[300005], e2[300005];
void dfs(int x, int y) {
d[x] = d[y] + 1, f[x][0] = y;
for (int i = 0; i < 18; ++i) f[x][i + 1] = f[f[x][i]][i];
for (int i = 0; i < v[x].size(); ++i) {
if (v[x][i] == y)
a[x][0] = e1[x][i], a[x][1] = e2[x][i];
else
dfs(v[x][i], x);
}
}
void upd(int x, int y) {
for (int i = 0; i < v[x].size(); ++i) {
if (v[x][i] == y) continue;
upd(v[x][i], x);
b[x] = min(b[x], e1[x][i] + b[v[x][i]] + e2[x][i]);
}
}
void upd2(int x, int y) {
for (int i = 0; i < v[x].size(); ++i) {
if (v[x][i] == y) continue;
b[v[x][i]] = min(b[v[x][i]], e1[x][i] + b[x] + e2[x][i]);
upd2(v[x][i], x);
}
}
void ope(int x, int y) {
dp[x][0][0][0] = min(a[x][0], b[x] + a[x][1] + b[y]);
dp[x][0][0][1] = min(a[x][0] + b[y], b[x] + a[x][1]);
dp[x][0][1][0] = min(a[x][1] + b[y], b[x] + a[x][0]);
dp[x][0][1][1] = min(a[x][1], b[x] + a[x][0] + b[y]);
for (int i = 0; i < 18; ++i) {
int _ = f[x][i];
dp[x][i + 1][0][0] =
min(dp[x][i][0][0] + dp[_][i][0][0], dp[x][i][0][1] + dp[_][i][1][0]);
dp[x][i + 1][0][1] =
min(dp[x][i][0][0] + dp[_][i][0][1], dp[x][i][0][1] + dp[_][i][1][1]);
dp[x][i + 1][1][0] =
min(dp[x][i][1][0] + dp[_][i][0][0], dp[x][i][1][1] + dp[_][i][1][0]);
dp[x][i + 1][1][1] =
min(dp[x][i][1][0] + dp[_][i][0][1], dp[x][i][1][1] + dp[_][i][1][1]);
}
for (int i = 0; i < v[x].size(); ++i)
if (v[x][i] != y) ope(v[x][i], x);
}
int lca(int x, int y) {
if (d[x] < d[y]) swap(x, y);
for (int i = 18; i >= 0; --i)
if (d[f[x][i]] >= d[y]) x = f[x][i];
if (x == y) return x;
for (int i = 18; i >= 0; --i)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
pair<long long, long long> up(int x, int y, int z) {
long long res[2] = {0, 0};
res[z ^ 1] = b[x];
for (int i = 18; i >= 0; --i) {
if (d[f[x][i]] < d[y]) continue;
long long X, Y;
X = min(res[0] + dp[x][i][0][0], res[1] + dp[x][i][1][0]);
Y = min(res[0] + dp[x][i][0][1], res[1] + dp[x][i][1][1]);
res[0] = X, res[1] = Y, x = f[x][i];
}
return make_pair(res[0], res[1]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%I64d", b + i);
for (int i = 1; i < n; ++i) {
int x, y;
long long p, q;
scanf("%d%d%I64d%I64d", &x, &y, &p, &q);
v[x].push_back(y), v[y].push_back(x), e1[x].push_back(p),
e1[y].push_back(p), e2[x].push_back(q), e2[y].push_back(q);
}
dfs(1, 0);
upd(1, 0);
upd2(1, 0);
ope(1, 0);
int T;
scanf("%d", &T);
while (T--) {
int x, y, z, X, Y;
scanf("%d%d", &x, &y);
if (x & 1)
X = 0;
else
X = 1;
if (y & 1)
Y = 0;
else
Y = 1;
x = (x + 1) >> 1, y = (y + 1) >> 1;
z = lca(x, y);
pair<long long, long long> xx = up(x, z, X), yy = up(y, z, Y);
long long ans;
ans = min(xx.first + yy.first, xx.second + yy.second);
printf("%I64d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char a[101];
int b = -1, c, d, e;
int main() {
cin >> a;
if (strlen(a) < 5) {
cout << "Too weak";
return 0;
}
while (++b < strlen(a)) {
if (47 < a[b] && a[b] < 58) {
c = 1;
}
if (96 < a[b] && a[b] < 123) {
d = 1;
}
if (64 < a[b] && a[b] < 91) {
e = 1;
}
}
if (c & d & e) {
cout << "Correct";
} else {
cout << "Too weak";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100003;
int a[maxn];
vector<pair<int, int> > dp[maxn], t;
int gcd(int x, int y) {
while (x != 0 && y != 0) {
if (x > y)
x %= y;
else
y %= x;
}
return x + y;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
t.push_back(make_pair(a[i], i));
}
sort(t.begin(), t.end());
dp[1].push_back(make_pair(a[1], 1));
for (int i = 2; i <= n; i++) {
int curnod = a[i];
for (int j = 0; j < dp[i - 1].size(); j++) {
if (dp[i - 1][j].first % curnod != 0) {
int nnod = gcd(curnod, dp[i - 1][j].first);
if (nnod != curnod) {
if (j)
dp[i].push_back(make_pair(curnod, dp[i - 1][j - 1].second + 1));
else
dp[i].push_back(make_pair(curnod, 1));
}
curnod = nnod;
}
}
dp[i].push_back(make_pair(curnod, i));
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
int len = r - l + 1;
int nod = dp[r][0].first;
for (int j = 0; j < dp[r].size(); j++) {
nod = dp[r][j].first;
if (dp[r][j].second >= len) break;
}
cout << len - (lower_bound(t.begin(), t.end(), make_pair(nod, r + 1)) -
lower_bound(t.begin(), t.end(), make_pair(nod, l)))
<< "\n";
}
cin >> n;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
int n, x, y;
cin >> n >> x >> y;
set<double> m;
while (n--) {
int x1, y1;
cin >> x1 >> y1;
if (x == x1) {
m.insert(double(1e9));
continue;
}
double mTemp = (y - y1) * 1.0 / (x - x1);
m.insert(mTemp);
}
cout << m.size() << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long be(long long a, long long b, long long mod) {
if (b == 0) return 1;
if (b % 2 == 1)
return (a * be(a, b - 1, mod)) % mod;
else
return (be(a, b / 2, mod) * be(a, b / 2, mod)) % mod;
}
const long long mod = 1e9 + 7;
const long long siz = (1e3 + 1);
const long long logi = 21;
const double epsilon = 1e-6;
bool prime[siz];
vector<long long> vt;
bool cmp(const long long &a, const long long &b) { return (abs(a - b) > 1); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
long long b[n];
set<long long> p, ng;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
p.insert(i);
}
if (a[i] == -1) {
ng.insert(i);
}
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
}
long long flag = 0;
for (long long i = n - 1; i >= 0; i--) {
if (a[i] == 1) {
p.erase(i);
}
if (a[i] == -1) {
ng.erase(i);
}
if (b[i] > a[i]) {
if (p.size() == 0) {
flag = 1;
break;
}
}
if (b[i] < a[i]) {
if (ng.size() == 0) {
flag = 1;
break;
}
}
}
if (flag == 1) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, q;
int s, a, b;
vector<pair<double, double>> segs;
double f[N];
double query(int x, int y) {
double l0 = a + (double)(x - a) * (-s) / (y - s);
double r0 = b + (double)(x - b) * (-s) / (y - s);
int p;
p = upper_bound(segs.begin(), segs.end(), make_pair(l0, (double)0)) -
segs.begin() - 1;
double sumL = 0;
if (p >= 0) {
sumL += min(segs[p].second, l0) - segs[p].first;
if (p) sumL += f[p - 1];
}
p = upper_bound(segs.begin(), segs.end(), make_pair(r0, (double)0)) -
segs.begin() - 1;
double sumR = 0;
if (p >= 0) {
sumR += min(segs[p].second, r0) - segs[p].first;
if (p) sumR += f[p - 1];
}
double ret = (sumR - sumL) / (r0 - l0) * (b - a);
ret = abs(ret);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(7);
cin >> s >> a >> b;
cin >> n;
segs.resize(n);
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
segs[i] = {l, r};
}
for (int i = 0; i < n; ++i) {
f[i] = segs[i].second - segs[i].first;
if (i) f[i] += f[i - 1];
}
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
cout << query(x, y) << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, s = 0, c = 0, i, k;
cin >> n;
for (i = 0; i < n; i++) {
cin >> k;
if (k == 0) c++, k++;
s = s + k;
}
if (s == 0) c++;
cout << c << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, p;
cin >> n >> p;
for (int i = 1; i <= 1000; i++) {
int k = n - i * p;
int k1 = k;
int t = 0;
if (k <= 0) {
cout << "-1" << '\n';
break;
}
while (k != 0) {
if (k % 2) t++;
k /= 2;
}
if ((k1 >= i) && t <= i) {
cout << i << '\n';
break;
}
if (i == 1000) {
cout << "-1" << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long c, wr, wb, hr, hb, ans = 0;
long long get(int i) { return i * hr + hb * int((c - i * wr) / wb); }
int main() {
cin >> c >> hr >> hb >> wr >> wb;
if (hb * wr > hr * wb) {
swap(hr, hb);
swap(wr, wb);
}
if (wr > 1e4) {
for (int i = 0; i * wr <= c; ++i) ans = max(ans, get(i));
} else if (wb > 1e4) {
for (int i = 0; i * wb <= c; ++i)
ans = max(ans, i * hb + hr * int((c - i * wb) / wr));
} else {
for (int i = 0; i < 1e7 && i * wb <= c; i++) {
ans = max(ans, i * hb + hr * int((c - i * wb) / wr));
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
a %= 1000000007;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
long long int modInverse(long long int a) { return power(a, 1000000007 - 2); }
const int N = 500023;
bool vis[N];
vector<int> adj[N];
void solve() {
int n;
cin >> n;
int next = 0;
vector<int> b(n);
for (long long int i = 0; i < n; i++) cin >> b[i];
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (next > b[i]) {
ans += (next - b[i]);
next = b[i];
} else {
ans += (b[i] - next);
next = b[i];
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
int t = 0;
while (t++ < T) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
int solve(int n, int k, vector<pair<int, int>>& edges, vector<int>& S, int c,
int d, int tar = 0) {
int T = k + edges.size();
int N = T * n;
init(N + 100);
int s = 0, t = 1;
auto nodeId = [&](int l, int i) { return t + 1 + l * n + i; };
vector<int> cnts(n, 0);
for (auto c : S) {
++cnts[c];
}
for (int i = 0; i < n; ++i) {
addEdge(s, nodeId(0, i), cnts[i], 0);
}
for (int i = 0; i < T; ++i) {
addEdge(nodeId(i, tar), t, k, c * i);
}
for (int i = 0; i + 1 < T; ++i) {
for (int u = 0; u < n; ++u) {
if (u != tar) {
addEdge(nodeId(i, u), nodeId(i + 1, u), k, 0);
}
}
}
for (auto& e : edges) {
vector<int> ends{e.first, e.second};
for (int _ = 0; _ < 2; ++_) {
int u = ends[0], v = ends[1];
if (u != tar) {
for (int i = 0; i + 1 < T; ++i) {
int from = nodeId(i, u), to = nodeId(i + 1, v);
for (int j = 1; j <= k; ++j) {
int w = d * (2 * j - 1);
addEdge(from, to, 1, w);
}
}
}
reverse(ends.begin(), ends.end());
}
}
return minCostMaxFlow(s, t).second;
}
private:
struct Edge {
Edge(int u = 0, int v = 0, int c = 0, int f = 0, int ct = 0)
: from(u), to(v), cap(c), flow(f), cost(ct) {}
int rem() { return cap - flow; }
int from;
int to;
int cap;
int flow;
int cost;
};
vector<Edge> E;
vector<vector<int>> G;
vector<int> pre;
vector<int> in;
const int INF = INT_MAX;
vector<int> dis;
void init(int n) {
G.clear();
G.resize(n);
pre.clear();
pre.resize(n, -1);
in.clear();
in.resize(n, false);
dis.clear();
dis.resize(n, INF);
}
void addEdge(int u, int v, int cap, int cost = 0) {
G[u].push_back(E.size());
E.emplace_back(u, v, cap, 0, cost);
G[v].push_back(E.size());
E.emplace_back(v, u, 0, 0, -cost);
}
pair<int, int> minCostMaxFlow(int s, int t) {
int flow = 0;
int cost = 0;
while (SPFA(s, t)) {
int fl = 1 << 20;
int e = pre[t];
while (e != -1) {
fl = min(fl, E[e].rem());
e = pre[E[e].from];
}
assert(fl > 0);
flow += fl;
cost += fl * dis[t];
e = pre[t];
while (e != -1) {
E[e].flow += fl;
E[e ^ 1].flow -= fl;
e = pre[E[e].from];
}
}
return {flow, cost};
}
bool SPFA(int s, int t) {
fill(dis.begin(), dis.end(), INF);
dis[s] = 0;
fill(pre.begin(), pre.end(), -1);
queue<int> que;
que.push(s);
in[s] = true;
while (!que.empty()) {
int u = que.front();
que.pop();
in[u] = false;
for (auto e : G[u]) {
int v = E[e].to;
int w = E[e].cost;
if (E[e].rem() > 0) {
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
pre[v] = e;
if (!in[v]) {
in[v] = true;
que.push(v);
}
}
}
}
}
return pre[t] != -1;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n, m, k, c, d;
cin >> n >> m >> k >> c >> d;
vector<int> S(k);
for (int i = 0; i < k; ++i) {
cin >> S[i];
--S[i];
}
vector<pair<int, int>> edges;
edges.reserve(m);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
edges.emplace_back(u, v);
}
cout << sol.solve(n, k, edges, S, c, d) << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
double a, b;
double minn = N * 1.0;
for (int i = 1; i <= n; i++) {
scanf("%lf%lf", &a, &b);
if (minn > a / b) minn = a / b;
}
printf("%.8lf\n", m * minn);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int maxlog = 22;
const long long inf = 1e18;
const int mod = 1e9 + 7;
const int sz = 350;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long x;
cin >> x;
long long a, b, c, d, e;
vector<pair<long long, long long> > v;
vector<pair<long long, long long> > g;
for (long long i = 1; i <= 6000006; i++) {
a = i * (i - 1) / 2;
b = i * (i - 1) * (2 * i - 1) / 6;
c = x;
c += (a * i);
c -= (b);
d = (i * i) - (a);
e = c / d;
if (i > e) break;
if (c % d == 0) v.push_back({i, e});
if (i != e && c % d == 0) g.push_back({e, i});
}
cout << v.size() + g.size() << endl;
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << endl;
for (int i = g.size() - 1; i >= 0; i--)
cout << g[i].first << " " << g[i].second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, S1, S2, F;
int T[10004], value[101], L[101], R[101];
long long D[10004];
vector<int> conr[10004], cons[10004];
priority_queue<pair<long long, int> > que;
int main() {
int i, j, k, d, q, t, x;
scanf("%d%d%d%d%d%d", &N, &M, &K, &S1, &S2, &F);
for (i = 1; i <= M; i++) {
scanf("%d%d%d", &j, &k, &d);
conr[j].push_back(k), conr[j].push_back(d);
}
for (i = 1; i <= K; i++) {
scanf("%d%d%d%d", &j, &k, L + i, R + i);
cons[j].push_back(k);
cons[j].push_back(i);
}
if (S1 == S2) {
puts("DRAW");
for (i = 1; i <= K; i++) printf("%d ", L[i]);
puts("");
return 0;
}
for (i = 1; i <= N; i++) D[i] = 1e17;
for (i = 1; i <= K; i++) value[i] = L[i];
D[S1] = D[S2] = 0;
T[S1] = 1, T[S2] = 2;
que.push(make_pair(0, S1));
que.push(make_pair(0, S2));
while (!que.empty()) {
long long d = que.top().first;
q = que.top().second;
que.pop();
if (-d != D[q]) continue;
t = T[q];
for (i = 0; i < ((int)(conr[q]).size()); i += 2) {
k = conr[q][i];
d = conr[q][i + 1];
if (D[k] > D[q] + d)
D[k] = D[q] + d, T[k] = T[q], que.push(make_pair(-D[k], k));
else if (D[k] == D[q] + d)
T[k] |= T[q];
}
for (i = 0; i < ((int)(cons[q]).size()); i += 2) {
k = cons[q][i], x = cons[q][i + 1];
d = L[x];
if (t & 2) d = R[x];
value[x] = (int)d;
if (D[k] > D[q] + d)
D[k] = D[q] + d, T[k] = T[q], que.push(make_pair(-D[k], k));
else if (D[k] == D[q] + d)
T[k] |= T[q];
}
}
if (T[F] == 1)
puts("WIN");
else if (T[F] == 3)
puts("DRAW");
else
puts("LOSE");
if (T[F] & 1) {
for (i = 1; i <= K; i++) printf("%d ", value[i]);
puts("");
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long double eps = 1e-13;
int data[200010];
long double dp[200010][2];
int n;
long double calc(long double x) {
dp[0][0] = dp[0][1] = 0;
long double ans0 = 0, ans1 = 0;
for (int i = 1; i <= n; ++i) {
dp[i][0] = max(dp[i - 1][0] + data[i] - x, data[i] - x);
dp[i][1] = min(dp[i - 1][1] + data[i] - x, data[i] - x);
ans0 = max(ans0, dp[i][0]);
ans1 = min(ans1, dp[i][1]);
}
return max(fabsl(ans0), fabsl(ans1));
}
int main() {
scanf("%d", &n);
long double l = 11000, r = -11000;
for (int i = 1; i <= n; ++i) {
scanf("%d", data + i);
l = min(l, (long double)data[i]);
r = max(r, (long double)data[i]);
}
while (r - l > eps) {
long double mid2 = r * 2 / 3 + l / 3, mid1 = l * 2 / 3 + r / 3;
if (calc(mid1) > calc(mid2))
l = mid1;
else
r = mid2;
}
printf("%f\n", (double)calc((l + r) / 2));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using DP = pair<int, LL>;
const int N = 3005, INF = 1e8;
const LL INFLL = 1e18;
vector<vector<int>> adj;
LL w[N];
vector<DP> best[N];
int dfs(int u, int p) {
best[u] = vector<DP>(2, {-INF, 0});
best[u][1] = {0, w[u]};
int sz = 1;
for (int v : adj[u]) {
if (v == p) continue;
int csz = dfs(v, u);
vector<DP> upd(sz + csz + 1, {-INF, 0});
for (int x = sz; x >= 1; x--) {
for (int y = csz; y >= 1; y--) {
DP no_merge(
best[u][x].first + best[v][y].first + (best[v][y].second > 0),
best[u][x].second);
upd[x + y] = max(upd[x + y], no_merge);
DP merge(best[u][x].first + best[v][y].first,
best[u][x].second + best[v][y].second);
upd[x + y - 1] = max(upd[x + y - 1], merge);
}
}
sz += csz;
swap(best[u], upd);
}
return sz;
}
int solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> w[i];
}
for (int i = 1; i <= n; i++) {
LL x;
cin >> x;
w[i] = x - w[i];
}
adj.assign(n + 1, vector<int>());
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
return best[1][m].first + (best[1][m].second > 0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
cout << solve() << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long t, ans, a[200005], k, n;
int main() {
cin >> t;
while (t--) {
cin >> n;
for (k = 1; k <= n; k++) {
cin >> a[k];
}
ans = 0;
for (k = n; k >= 1; k--) {
ans += max(0ll, a[k - 1] - a[k]);
}
cout << ans << endl;
}
}
| 2 |
/*─────────▄▄▄▄▄▄▄▄▄▄▄▄▄
────────▄▀▀─────────────▀▀▄
───────█───────────────────█
──────█─────────────────────█
─────█───▄▄▄▄▄▄▄───▄▄▄▄▄▄▄───█
────█───█████████─█████████───█
────█──██▀────▀█████▀────▀██──█
───██████───█▀█─███───█▀█─██████
───██████───▀▀▀─███───▀▀▀─██████
────█──▀█▄────▄██─██▄────▄█▀──█
────█────▀█████▀───▀█████▀────█
────█───────────────▄▄▄───────█
────█───────▄▄▄▄██▀▀█▀▀█▄─────█
────█─────▄██▄█▄▄█▄▄█▄▄██▄────█
────█─────▀▀█████████████▀────█
───▐▓▓▌─────────────────────▐▓▓▌
───▐▐▓▓▌▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▐▓▓▌▌
───█══▐▓▄▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▄▓▌══█
──█══▌═▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▌═▐══█
──█══█═▐▓▓▓▓▓▓▄▄▄▄▄▄▄▓▓▓▓▓▓▌═█══█
──█══█═▐▓▓▓▓▓▓▐██▀██▌▓▓▓▓▓▓▌═█══█
──█══█═▐▓▓▓▓▓▓▓▀▀▀▀▀▓▓▓▓▓▓▓▌═█══█
──█───█─█──█─█▀▀█─▀▀█▀▀─▀█─█─▀█──
──█▄█▄█─█▀▀█─█▄▄█───█───█▀─▀─█▀──
───▀─▀──▀──▀─▀──▀───▀───▄──▄─▄───
TAKE LOVE AND PRAY FOR ME :) :) :)
*/
#include<bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define ll long long
#define deciset(x) cout <<setprecision(x) <<fixed;
#define pb push_back
#define mp make_pair
#define PI 2*acos(0.0)
#define boost ios::sync_with_stdio(false);cin.tie(0)
int main()
{
boost;
ll t;
cin>>t;
while(t--)
{
ll a,b;
cin>>a>>b;
char arr[a][b];
ll brr[a][b];
for(int i=0;i<a;i++)
for(int j=0;j<b;j++) { cin>>arr[i][j]; brr[i][j]=0; }
int x=1;
for(int i=0;i<a;i++)
for(int j=0;j<b;j++)
{
if(arr[i][j]=='*') brr[i][j]=x;
else if(arr[i][j]=='.' && arr[i][j-1]=='*' && j>0) x++;
}
ll ans=0;
for(int i=0;i<a;i++)
for(int j=0;j<b;j++)
{
if(arr[i][j]=='*'){
ll kk=1,h=1;
for(ll k=i+1;k<a;k++){
if(arr[k][j]=='*' && brr[k][j+kk]!=0 && brr[k][j-kk]==brr[k][j+kk] && j-kk>=0 && j+kk<b )
{
h++;
kk++;
}
else break;
}
ans+=h;
}
}
cout<<ans<<endl;
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
using namespace std;
long long one = 1;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
const long long N = 2e5;
vector<vector<long long> > c, gr;
vector<long long> res;
vector<long long> child;
long long dfs1(long long v, long long p) {
for (long long u : gr[v]) {
if (u != p) {
child[v] = u;
dfs1(u, v);
}
}
}
signed main() {
long long n;
cin >> n;
c.resize(3);
for (long long i = 0; i < 3; i++) {
c[i].resize(n);
for (long long j = 0; j < n; j++) cin >> c[i][j];
}
gr.resize(n);
for (long long i = 0; i < n - 1; i++) {
long long v, u;
cin >> v >> u;
v--;
u--;
gr[v].push_back(u);
gr[u].push_back(v);
}
long long st = -1;
bool flag = 1;
for (long long i = 0; i < n; i++) {
if (gr[i].size() > 2) flag = 0;
if (gr[i].size() == 1) st = i;
}
if (flag == 0) {
cout << -1 << endl;
return 0;
}
child.resize(n, -1);
dfs1(st, -1);
res.resize(n);
long long anss = INF, ansj = -1, ansk = -1;
for (long long j = 0; j < 3; j++) {
for (long long k = 0; k < 3; k++) {
if (j == k) continue;
long long now = st;
long long j1 = j, k1 = k;
long long ans = 0;
while (now != -1) {
res[now] = j1;
ans += c[j1][now];
long long k11 = k1;
k1 = 3 - j1 - k1;
j1 = k11;
now = child[now];
}
if (ans < anss) {
anss = ans;
ansk = k;
ansj = j;
}
}
}
long long now = st;
long long j1 = ansj, k1 = ansk;
long long ans = 0;
while (now != -1) {
res[now] = j1;
ans += c[j1][now];
long long k11 = k1;
k1 = 3 - j1 - k1;
j1 = k11;
now = child[now];
}
cout << ans << endl;
for (long long i : res) cout << i + 1 << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxl = 9;
const int Maxn = 505;
int n, m;
char B[Maxn][Maxn];
int id[Maxl][Maxn][Maxn];
int res;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf(" %c", &B[i][j]);
for (int i = 0; i + (1 << 1) <= n; i++)
for (int j = 0; j + (1 << 1) <= m; j++)
id[1][i][j] = (B[i][j] == '.') << 3 | (B[i][j + 1] == '.') << 2 |
(B[i + 1][j] == '.') << 1 | (B[i + 1][j + 1] == '.');
for (int l = 2; l < Maxl; l++)
for (int i = 0; i + (1 << l) <= n; i++)
for (int j = 0; j + (1 << l) <= m; j++) {
id[l][i][j] = -1;
int ni = i + (1 << l - 1), nj = j + (1 << l - 1);
for (int k = 0; k < 1 << 4; k++) {
if (k & 1 << 3 && id[l - 1][i][j] != k ||
!(k & 1 << 3) && id[l - 1][i][j] != 0)
continue;
if (k & 1 << 2 && id[l - 1][i][nj] != k ||
!(k & 1 << 2) && id[l - 1][i][nj] != 0)
continue;
if (k & 1 << 1 && id[l - 1][ni][j] != k ||
!(k & 1 << 1) && id[l - 1][ni][j] != 0)
continue;
if (k & 1 << 0 && id[l - 1][ni][nj] != k ||
!(k & 1 << 0) && id[l - 1][ni][nj] != 0)
continue;
id[l][i][j] = k;
res++;
break;
}
}
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20003;
int a[N], b[N];
void solve() {
int n;
cin >> n;
set<int> coords;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
coords.insert(a[i]);
coords.insert(b[i]);
if (a[i] > b[i]) swap(a[i], b[i]);
}
vector<int> c;
for (int x : coords) c.push_back(x);
vector<int> dp(c.size() + 1, 0);
vector<int> pr(c.size() + 1, -1);
for (int i = 0; i < (int)c.size(); i++) {
int mn = -N;
for (int j = 0; j < n; j++)
if (b[j] < c[i]) mn = max(mn, a[j]);
if (mn == -N) {
dp[i + 1] = 1;
continue;
}
dp[i + 1] = N;
for (int j = i - 1; j >= 0 && c[j] >= mn; j--) {
if (dp[j + 1] + 1 < dp[i + 1]) {
dp[i + 1] = dp[j + 1] + 1;
pr[i + 1] = j + 1;
}
}
}
int mnVal = *max_element(a, a + n);
int ansInd = -1, ans = N;
for (int i = (int)c.size() - 1; i >= 0 && c[i] >= mnVal; i--) {
if (dp[i + 1] < ans) {
ans = dp[i + 1];
ansInd = i + 1;
}
}
vector<int> path;
while (ansInd > 0) {
path.push_back(c[ansInd - 1]);
ansInd = pr[ansInd];
}
reverse(path.begin(), path.end());
cout << path.size() << endl;
for (int x : path) cout << x << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long i, n, A[100005], j, hasil, final, x, jumlah, a, b;
int main() {
cin >> n;
hasil = 0;
final = -1;
x = 0;
long long cek = 0;
for (i = 1; i <= n; i++) {
cin >> a;
if (i == 1) {
x = 1;
hasil = x;
cek = 1;
} else if (cek == 1 && a >= b) {
x++;
hasil = x;
} else {
x = 1;
hasil = x;
}
b = a;
if (hasil >= final) {
final = x;
jumlah = x;
}
}
cout << jumlah << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXLEN = 2010;
int n, p;
char str[MAXLEN];
int output() {
for (int i = 1; i <= n; i++) {
if (str[i] != '.')
printf("%c", str[i]);
else
printf("0");
}
printf("\n");
return 0;
}
int main() {
scanf("%d%d", &n, &p);
scanf("%s", str + 1);
for (int i = 1; i <= n - p; i++) {
if (str[i] == '.' || str[i + p] == '.') {
if (str[i] == str[i + p]) {
str[i] = '0';
str[i + p] = '1';
output();
exit(0);
}
if (str[i] == '.') {
if (str[i + p] == '1')
str[i] = '0';
else
str[i] = '1';
} else {
if (str[i] == '1')
str[i + p] = '0';
else
str[i + p] = '1';
}
output();
exit(0);
} else {
if (str[i] != str[i + p]) {
output();
exit(0);
}
}
}
printf("No\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(time(0));
uniform_int_distribution<int> uid(-1e9, 1e9);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> v(n + 1, 0);
map<int, vector<vector<int>>> mp;
for (int i = 1; i <= n; ++i) cin >> v[i], v[i] += v[i - 1];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= i; ++j) mp[v[i] - v[j - 1]].push_back({j, i});
vector<vector<int>> res;
for (auto& i : mp) {
sort((i.second).begin(), (i.second).end(),
[](vector<int>& x, vector<int>& y) { return x[1] < y[1]; });
int p = -1e9, k = 0;
for (auto& j : i.second)
if (j[0] > p) ++k, p = j[1];
if (res.size() < k) {
res.clear();
p = -1e9;
for (auto& j : i.second)
if (j[0] > p) res.push_back(j), p = j[1];
}
}
cout << res.size() << '\n';
for (auto& i : res) cout << i[0] << ' ' << i[1] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> par, r;
map<int, int>::iterator it;
int find(int u) {
it = par.find(u);
if (it == par.end()) {
r[u] = 0;
return u;
}
int v = par[u];
int tmp = find(v);
r[u] ^= r[v];
return par[u] = tmp;
}
void join(int a, int b, int x) {
int c = find(a), d = find(b);
if (c == d) return;
par[d] = c;
r[d] = r[a] ^ r[b] ^ x;
}
int main() {
int q, a, b, last = 0, op, x;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &op, &a, &b);
a ^= last, b ^= last;
if (a > b) swap(a, b);
b++;
if (op == 1) {
scanf("%d", &x);
join(a, b, x ^ last);
} else {
if (find(a) != find(b))
last = -1;
else
last = r[a] ^ r[b];
printf("%d\n", last);
last = abs(last);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxn = 210000;
int fl[maxn], fr[maxn], a[maxn];
int fsum(int *f, int i) {
int s = 0;
for (; i >= 0; i &= i + 1, --i) s += f[i];
return s;
}
void fadd(int *f, int i, int x) {
for (; i < maxn; i |= i + 1) f[i] += x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n, k, A, B, q;
cin >> n >> k >> A >> B >> q;
for (int i = 0; i < (int)(q); ++i) {
int t;
cin >> t;
if (t == 1) {
int d, t;
cin >> d >> t;
fadd(fl, d, -min(a[d], B));
fadd(fr, d, -min(a[d], A));
a[d] += t;
fadd(fl, d, min(a[d], B));
fadd(fr, d, min(a[d], A));
} else {
int p;
cin >> p;
cout << fsum(fl, p - 1) + fsum(fr, n) - fsum(fr, p + k - 1) << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("test.in");
ofstream fout("test.out");
bool is_suffix(string it, string aa) {
for (int a = it.size() - 1, b = aa.size() - 1; b >= 0; a--, b--) {
if (it[a] != aa[b]) return 0;
}
return 1;
}
int main() {
map<string, vector<string> > mp;
vector<string> names;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string name;
cin >> name;
int m;
cin >> m;
string number;
if (mp[name].size() == 0) {
m--;
cin >> number;
mp[name].push_back(number);
names.push_back(name);
}
for (int j = 0; j < m; j++) {
cin >> number;
bool var = 0;
for (int k = 0; k < mp[name].size(); k++) {
if (mp[name][k].size() >= number.size() &&
is_suffix(mp[name][k], number)) {
var = 1;
break;
}
if (mp[name][k].size() <= number.size() &&
is_suffix(number, mp[name][k])) {
mp[name].erase(mp[name].begin() + k);
}
}
if (var == 0) mp[name].push_back(number);
}
}
cout << names.size() << '\n';
for (int i = 0; i < names.size(); i++) {
cout << names[i] << ' ' << mp[names[i]].size() << ' ';
for (int j = 0; j < mp[names[i]].size(); j++)
cout << mp[names[i]][j] << ' ';
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj;
bool vis[100100];
int mx = 0;
int far = -1;
void dfs(int cur, int len) {
if (vis[cur]++) return;
if (len > mx) {
mx = len;
far = cur;
}
for (int x : adj[cur]) dfs(x, len + 1);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
adj = vector<vector<int> >(n);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
adj[x - 1].push_back(y - 1);
adj[y - 1].push_back(x - 1);
}
bool ok = (m == n - 1);
dfs(0, 0);
memset(vis, 0, sizeof(vis));
dfs(far, 0);
printf("%d", mx);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long long linf = (1ll << 62) - 1;
const int N = 1101;
int n, k;
char s[N];
bool dp[N][28][28][2];
vector<char> ans;
bool write_answer(int i, int j, int z, int l) {
if (!dp[i][j][z][l]) return false;
if (i == n && l) return true;
for (int x = l ? 0 : s[i]; x < k; x++) {
if (j == x || z == x) continue;
int ni = i + 1, nj = z, nz = x, nl = l || x > s[i];
ans.push_back(x + 'a');
if (write_answer(ni, nj, nz, nl)) return true;
ans.pop_back();
}
return false;
}
int main() {
cin >> n >> k >> s;
for (int i = 0; i < n; i++) s[i] -= 'a';
if (n == 1) {
if (s[0] == k - 1)
puts("NO");
else {
s[0] += 'a' + 1;
printf("%s\n", s);
}
return 0;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j < k; j++)
for (int z = 0; z < k; z++)
for (int l = 0; l < 2; l++) dp[i][j][z][l] = 0;
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) dp[n][i][j][1] = 1;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < k; j++)
for (int z = 0; z < k; z++)
for (int l = 0; l < 2; l++) {
for (int x = 0; x < k; x++) {
if (x < s[i] && !l) continue;
if (j == x || z == x) continue;
int ni = i + 1, nj = z, nk = x, nl = x > s[i] || l;
dp[i][j][z][l] = dp[i][j][z][l] || dp[ni][nj][nk][nl];
}
}
for (int i = s[0]; i < k; i++)
for (int j = i > s[0] ? 0 : s[1]; j < k; j++)
if (i != j && write_answer(2, i, j, i != s[0] || j != s[1])) {
printf("%c%c", (char)(i + 'a'), (char)(j + 'a'));
for (int z = 0; z < ((int)(ans).size()); z++) printf("%c", ans[z]);
puts("");
return 0;
}
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
if (n <= 3) {
for (int i = 0; i < n - 1; i++) cout << 1 << " ";
cout << n << "\n";
return 0;
}
vector<int> logs(int(log2(1e6)) + 2, 0);
for (int i = 1; i < n + 1; i++) {
for (int k = log2(1e6) + 1; k >= 0; k--) {
if (i % (1 << k) == 0) {
logs[k]++;
break;
}
}
}
int k = 0;
for (int i = 0; i < log2(1e6) + 2; i++) {
for (int j = 0; j < logs[i]; j++) {
k++;
if (k == n && (1 << i) + (1 << (i - 1)) <= n) {
cout << (1 << i) + (1 << (i - 1)) << " ";
} else
cout << (1 << i) << " ";
}
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
int n, h[N], f[N], s[N];
vector<pair<int, int> > E[N];
void dfs(int i, int ff, int hh) {
f[i] = ff;
h[i] = hh;
s[i] = 1;
for (int j = 0; (j) < (int)(E[i].size()); (j)++)
if (ff != E[i][j].first) {
dfs(E[i][j].first, i, hh + 1);
s[i] += s[E[i][j].first];
}
}
int t[N][3];
double cc(int ss, int dd) {
double ans = 0;
ans += ss * 1.0 * (n - ss) * (n - ss - 1) * dd * 2 * 3;
ans += ss * 1.0 * (ss - 1) * (n - ss) * dd * 2 * 3;
ans /= n * 1.0 * (n - 1) * (n - 2);
return ans;
}
int main(void) {
cin >> n;
for (int i = 0; (i) < (int)(n - 1); (i)++) {
int x, y, d;
cin >> x >> y >> d;
E[x].push_back(make_pair(y, d));
E[y].push_back(make_pair(x, d));
t[i][0] = x;
t[i][1] = y;
t[i][2] = d;
}
dfs(1, -1, 0);
double ans = 0;
for (int i = 0; (i) < (int)(n - 1); (i)++) {
if (h[t[i][0]] > h[t[i][1]]) swap(t[i][0], t[i][1]);
int ss = s[t[i][1]];
ans += cc(ss, t[i][2]);
}
int m;
cin >> m;
for (int i = 0; (i) < (int)(m); (i)++) {
int j, k;
cin >> j >> k;
j--;
int ss = s[t[j][1]];
ans -= cc(ss, t[j][2]);
t[j][2] = k;
ans += cc(ss, t[j][2]);
printf("%.10f\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a[1010];
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ans = 1001, flag;
for (int i = 1; i <= 1000; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++) {
if (((j - 1) * k + i) != a[j]) tmp++;
}
if (tmp < ans) {
ans = tmp;
flag = i;
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
int shod = flag + (i - 1) * k;
if (a[i] < shod) {
cout << "+ " << i << " " << shod - a[i] << endl;
}
if (a[i] > shod) {
cout << "- " << i << " " << a[i] - shod << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long sum(long long x) {
long long res = 0;
while (x) res += x % 10, x /= 10;
return res;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, ans = 9e18;
cin >> n;
for (long long s = 1; s <= 9 * 18; ++s) {
long double sq = sqrt(s * s + 4 * n);
long long a = (long long)sq, b = a + 1, c = 0;
if (a * a == s * s + 4 * n)
c = a;
else if (b * b == s * s + 4 * n)
c = b;
else
continue;
if ((c - s) % 2) continue;
long long x = (c - s) / 2;
if (sum(x) == s) ans = min(ans, x);
}
if (ans == 9e18) ans = -1;
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
#define deb(x) cout << #x << " = " << x << endl;
#define supafast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
const int MOD = 1e9 + 7;
void solution()
{
string a, b;
cin >> a >> b;
// deb(a) deb(b)
if (a == b)
{
cout << 0 << endl;
return;
}
int size = 0, max_size = 0, x = 0, y = 0, c = 0;
for (int i = 0; i < a.length(); i++)
{
for (int j = 0; j < b.length(); j++)
{
if (a[i] == b[j])
{
x = i;
y = j;
while(true)
{
if(x >= a.length() || y >= b.length())
break;
if (a[x] == b[y])
{
size++;
}
else
{
break;
}
x++;
y++;
c++;
if (c >= 100) break;
}
}
max_size = max(size, max_size);
size = 0;
}
}
int res = a.length() + b.length() - 2 * max_size;
// deb(max_size)
cout << res << endl;
}
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
supafast
int testCases = 1;
cin >> testCases;
while (testCases-- > 0)
{
solution();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 100;
const int M = 4400000;
const int INF = 0x3f3f3f3f;
int s, t, n, m;
int h[N], e[M], ne[M], w[M], idx;
int cur[N], gap[N], d[N];
void add(int a, int b, int c) {
e[idx] = b;
w[idx] = c;
ne[idx] = h[a];
h[a] = idx++;
e[idx] = a;
w[idx] = 0;
ne[idx] = h[b];
h[b] = idx++;
}
int _;
void init(int s, int t) {
queue<int> q;
memset(d, 0, sizeof(d));
memset(gap, 0, sizeof(gap));
d[t] = 1, gap[1]++;
q.push(t);
for (int i = 0; i <= n + n + 1; i++) cur[i] = h[i];
while (!q.empty()) {
int t = q.front();
q.pop();
for (int i = h[t]; ~i; i = ne[i]) {
int j = e[i];
if (!d[j]) {
d[j] = d[t] + 1;
gap[d[j]]++;
q.push(j);
}
}
}
}
int dfs(int u, int t, int flow) {
if (u == t) return flow;
int flowed = 0;
for (int &i = cur[u]; ~i; i = ne[i]) {
int j = e[i];
if (d[j] + 1 == d[u]) {
int tmp = dfs(j, t, min(flow, w[i]));
flowed += tmp;
flow -= tmp;
w[i] -= tmp;
w[i ^ 1] += tmp;
if (!flow) return flowed;
}
}
gap[d[u]]--;
if (!gap[d[u]]) d[s] = n + n + 3;
d[u]++;
gap[d[u]]++;
cur[u] = h[u];
return flowed;
}
int ISAP(int s, int t) {
init(s, t);
int ret = 0;
while (d[s] <= n + n + 2) {
ret += dfs(s, t, INF);
}
return ret;
}
int u[N], v[N], ma[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u[i], &v[i]);
ma[u[i]][v[i]] = 1;
}
int ans = INF;
for (int i = 1; i <= n; i++) {
memset(h, -1, sizeof(h));
idx = 0;
s = 0, t = n + n + 1;
int tp = 0;
for (int j = 1; j <= n; j++) add(s, j, 1), add(j + n, t, 1);
for (int j = 1; j <= m; j++) {
if (u[j] == i || v[j] == i) continue;
add(u[j], v[j] + n, 1);
tp++;
}
for (int j = 1; j <= n; j++) {
if (!ma[i][j]) tp++;
if (!ma[j][i]) tp++;
}
if (!ma[i][i]) tp--;
int res = ISAP(s, t);
ans = min(ans, tp - res + n - 1 - res);
}
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long T;
int main() {
ios_base::sync_with_stdio(0);
;
long long T;
cin >> T;
while (T--) {
long long x;
cin >> x;
long long cnt = 0;
long long sum = 0;
for (long long i = 1; i <= 30; i++) {
long long cis = (1LL << (i - 1)) * ((1LL << i) - 1);
sum += cis;
if (sum > x) break;
cnt++;
}
cout << cnt << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int x[n];
for (int i = 0; i < n; i++) {
cin >> x[i];
}
long long int lans, gans = INT_MAX;
for (int i = 0; i < n; i++) {
lans = 0;
for (int j = 0; j < n; j++) {
if ((x[i] - x[j]) % 2 != 0) lans++;
}
if (lans < gans) gans = lans;
}
cout << gans << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX / 2;
const int Maxn = 300;
int n;
double R, r;
const double pi = acos(-1);
const double EPS = 1e-10;
int solve() {
int k;
if (r > R) return 0;
if (2 * r > R) return 1;
double a = asin(r / (R - r)) * 2;
k = 2 * pi / a + EPS;
return k;
}
int main() {
cin >> n >> R >> r;
int ans = solve();
if (ans >= n)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define io_speed_up ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
template<typename T>void rd(T&x){int f=0,c;while(!isdigit(c=getchar()))f^=!(c^45);x=(c&15);while(isdigit(c=getchar()))x=x*10+(c&15);if(f)x=-x;} //读整型
template<typename T>void pt(T x,int c=10){if(x<0)putchar('-'),x=-x;if(x>9)pt(x/10,-1);putchar(x%10+48);if(c!=-1)putchar(c);}
template<typename T>void umax(T&x,const T&y){if(x<y)x=y;}
template<typename T>void umin(T&x,const T&y){if(x>y)x=y;}
#define for_seq(i,s) for(int i=0;i<(int)s.size();i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define per(i,a,b) for(int i=a;i>=b;i--)
#define for1(i,n) for(int i=1;i<=n;i++)
#define for0(i,n) for(int i=0;i<n;i++)
#define ms(a,b) memset(a,b,sizeof a)
#define all(n) (n).begin(), (n).end()
#define sz(x) (int)x.size()
#define fi first
#define se second
using ll = long long;
using ld = long double;
using pii = pair<int,int>;
using pll = pair<long,long>;
const int inf = 0x3f3f3f3f;
const int maxn = 5000+5;
const int mod = 998244353;
int n,k;
vector<int> g[maxn];
int dp[maxn][maxn], f[maxn][maxn];
int DP(int a,int b) {
if(b<0) return 0;
return dp[a][b];
}
void dfs(int u,int pre) {
for(int i=0;i<=k;i++) dp[u][i] = 1;
f[u][0] = 1;
for(auto v:g[u]) {
if(v==pre) continue;
dfs(v,u);
for(int i=k;i>=1;i--) {
f[u][i] = (1LL*f[u][i] * (DP(v,min(k-i-1, i-1)) + dp[v][k])+ 1LL*DP(u, min(i-1,k-i))*f[v][i-1]) % mod;
}
dp[u][0] = f[u][0] = 1LL * f[u][0]*dp[v][k] % mod;
rep(i,1,k) dp[u][i] = (dp[u][i-1] + f[u][i]) % mod;
}
}
int main()
{
io_speed_up;
cin>>n>>k;
rep(i,1,n-1) {
int u,v;
cin>>u>>v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1,0);
cout<<dp[1][k]<<"\n";
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
bool check(int x) {
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int main() {
int ans = 0;
int n;
scanf("%d", &n);
if (n == 2 || n == 3) {
printf("1\n");
} else if (n % 2 == 0) {
printf("2\n");
} else {
if (check(n)) {
printf("1\n");
} else {
int z = n - 2;
if (check(z))
printf("2\n");
else {
printf("3\n");
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
pair<int, int> v[N];
bool dpb[N], dpa[N];
int n, a, b;
bool check(int in, int d) {
int x = v[in].first, need = d / (n - in);
if (d % (n - in)) need++;
return x >= need;
}
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i].first);
v[i].second = i + 1;
}
sort(v, v + n);
for (int i = n - 1; i >= 0; i--) {
dpb[i] = check(i, b) | dpb[i + 1];
}
for (int i = n - 1; i >= 0; i--) {
dpa[i] = check(i, a) | dpa[i + 1];
}
for (int i = 1; i <= n; i++) {
int x = a / i;
if (a % i) x++;
int l = lower_bound(v, v + n, make_pair(x, -1)) - v;
if (l + i - 1 <= n - 1 && dpb[l + i]) {
puts("Yes");
int at = n - 1;
while (!dpb[at]) at--;
printf("%d %d\n", i, n - at);
for (int j = l; j <= l + i - 1; j++) printf("%d ", v[j].second);
puts("");
for (int j = at; j < n; j++) printf("%d ", v[j].second);
return 0;
}
}
for (int i = 1; i <= n; i++) {
int x = b / i;
if (b % i) x++;
int l = lower_bound(v, v + n, make_pair(x, -1)) - v;
if (l + i - 1 <= n - 1 && dpa[l + i]) {
puts("Yes");
int at = n - 1;
while (!dpa[at]) at--;
printf("%d %d\n", n - at, i);
for (int j = at; j < n; j++) printf("%d ", v[j].second);
puts("");
for (int j = l; j <= l + i - 1; j++) printf("%d ", v[j].second);
return 0;
}
}
puts("No");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i) {
if (i != v.begin()) os << ", ";
os << *i;
}
os << "]";
return os;
}
struct Node {
Node* next[26];
bool winning, losing;
Node() {
for (int i = 0; i < (int)(26); ++i) next[i] = NULL;
}
};
char buf[100007];
Node root;
void add(char* s) {
Node* x = &root;
while (*s) {
int c = (*s) - 'a';
if (x->next[c] == NULL) x->next[c] = new Node();
x = x->next[c];
++s;
}
}
void compute(Node* x) {
x->winning = false;
x->losing = false;
bool leaf = true;
for (int i = 0; i < (int)(26); ++i)
if (x->next[i]) {
compute(x->next[i]);
leaf = false;
if (!x->next[i]->winning) x->winning = true;
if (!x->next[i]->losing) x->losing = true;
}
if (leaf) x->losing = true;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < (int)(n); ++i) {
scanf("%s", buf);
add(buf);
}
compute(&root);
bool res;
if (root.winning) {
if (root.losing) {
res = true;
} else {
res = (k % 2 == 1);
}
} else {
res = false;
}
printf("%s\n", res ? "First" : "Second");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005, INF = 0x3f3f3f3f, MAXB = 92;
int p[MAXN][3];
int acc[3], mogh[3];
int n;
int rje = MAXN;
int hackao[3];
vector<int> Bitni;
int ValZad(int bracc) {
int ret = 500;
for (; ret < 3000 && 2 * bracc <= n; bracc *= 2, ret += 500)
;
return ret;
}
int Eval(int valz, int t) {
if (!t) return 0;
return (valz * (250 - abs(t))) / 250;
}
int Prov() {
int dp[Bitni.size() + 1][hackao[0] + 2][hackao[1] + 2][hackao[2] + 2];
int valz[3];
int mojsc = 0;
int bolj = 0;
for (int i = 0; i < 3; i++) {
valz[i] = ValZad(acc[i] - hackao[i]);
mojsc += 100 * hackao[i] + Eval(valz[i], p[0][i]);
}
for (int i = 0; i < n; i++) {
int bitan = 0, sum = 0;
for (int j = 0; j < 3; j++) {
bitan |= (p[i][j] < 0);
sum += Eval(valz[j], p[i][j]);
}
if (!bitan) bolj += sum > mojsc;
}
memset(dp, INF, sizeof dp);
dp[0][0][0][0] = 0;
for (int i = 0; i < (int)Bitni.size(); i++)
for (int h0 = 0; h0 <= hackao[0]; h0++)
for (int h1 = 0; h1 <= hackao[1]; h1++)
for (int h2 = 0; h2 <= hackao[2]; h2++) {
int ind = Bitni[i];
for (int j = 0; j < 8; j++) {
int val = 0, ne = 0;
for (int k = 0; k < 3; k++) {
int st = (j >> k & 1);
if (p[ind][k] >= 0 && st) {
ne = 1;
break;
}
if (!st) val += Eval(valz[k], p[ind][k]);
}
if (!ne) {
dp[i + 1][h0 + (j >> 0 & 1)][h1 + (j >> 1 & 1)]
[h2 + (j >> 2 & 1)] =
min(dp[i + 1][h0 + (j >> 0 & 1)][h1 + (j >> 1 & 1)]
[h2 + (j >> 2 & 1)],
dp[i][h0][h1][h2] + (val > mojsc));
}
}
}
return dp[Bitni.size()][hackao[0]][hackao[1]][hackao[2]] + bolj;
}
void Rek(int ind) {
if (ind == 3) {
rje = min(rje, Prov());
return;
}
hackao[ind] = mogh[ind];
Rek(ind + 1);
for (int i = hackao[ind] - 1; i >= 0; i--)
if (ValZad(acc[ind] - i) != ValZad(acc[ind] - i - 1)) {
hackao[ind] = i;
Rek(ind + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
scanf("%d", &p[i][j]);
if (p[i][j]) acc[j]++;
if (p[i][j] < 0) mogh[j]++;
}
if (min(min(p[i][0], p[i][1]), p[i][2]) < 0) Bitni.push_back(i);
}
int ukhac = mogh[0] + mogh[1] + mogh[2];
if (ukhac >= 90) {
printf("1\n");
return 0;
}
Rek(0);
printf("%d\n", rje + 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<int> q[101];
bool ans;
bool been[101];
void dfs(int i, int where) {
if (i == where) {
ans = 1;
return;
}
been[i] = 1;
for (int j = 0; j < q[i].size(); j++)
if (!been[q[i][j]]) dfs(q[i][j], where);
}
int main() {
int n;
cin >> n;
int a[101], b[101], c[101];
for (int i = 0; i < n; i++) {
cin >> a[i];
c[a[i]] = i + 1;
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (i - b[i] >= 1) {
q[i].push_back(i - b[i]);
q[i - b[i]].push_back(i);
}
if (i + b[i] <= n) {
q[i].push_back(i + b[i]);
q[i + b[i]].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
ans = 0;
memset(been, 0, sizeof(been));
dfs(i, c[i]);
if (!ans) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const long long mod = (119 << 23) + 1;
const long long M = 1e9 + 7;
const long long N = 2e5 + 5;
vector<long long> dg[N], tg[N];
long long n, m;
long long color[N];
bool cdfs(long long z) {
color[z] = 1;
for (long long y : dg[z]) {
if (color[y] == 1) return true;
if (color[y] == 0) {
if (cdfs(y)) return true;
}
}
color[z] = 2;
return false;
}
bool cyc() {
for (long long i = 1; i <= n; ++i) {
if (color[i] == 0)
if (cdfs(i)) return true;
}
return false;
}
long long dpd[N], dpt[N];
bool vsd[N], vst[N];
void ddfs(long long z) {
if (vsd[z]) return;
vsd[z] = true;
for (long long y : dg[z]) {
ddfs(y);
if (dpd[z] == 0 || (dpd[y] && dpd[z] > dpd[y])) dpd[z] = dpd[y];
if (dpd[z] == 0 || dpd[z] > y) dpd[z] = y;
}
}
void tdfs(long long z) {
if (vst[z]) return;
vst[z] = true;
for (long long y : tg[z]) {
tdfs(y);
if (dpt[z] == 0 || (dpt[y] && dpt[z] > dpt[y])) dpt[z] = dpt[y];
if (dpt[z] == 0 || dpt[z] > y) dpt[z] = y;
}
}
void fdp() {
for (long long z = 1; z <= n; ++z) ddfs(z);
for (long long z = 1; z <= n; ++z) tdfs(z);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(15);
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long u, v;
cin >> u >> v;
dg[u].push_back(v);
tg[v].push_back(u);
}
if (cyc()) {
cout << -1 << '\n';
return 0;
}
fdp();
ostringstream oss;
long long ctr = 0;
for (long long i = 1; i <= n; ++i) {
if ((dpt[i] && dpt[i] < i) || (dpd[i] && dpd[i] < i)) {
oss << 'E';
} else {
oss << 'A';
ctr++;
}
}
cout << ctr << '\n';
cout << oss.str() << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool endline = false;
template <class T>
istream& operator>>(istream& inp, vector<T>& v) {
for (auto& it : v) inp >> it;
return inp;
}
template <class T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto& it : v) out << it << (endline ? "\n" : " ");
return out;
}
template <class T, class U>
istream& operator>>(istream& inp, pair<T, U>& v) {
inp >> v.first >> v.second;
return inp;
}
template <class T, class U>
ostream& operator<<(ostream& out, pair<T, U>& v) {
out << v.first << ' ' << v.second;
return out;
}
void debug() { cout << endl; }
template <typename H, typename... T>
void debug(H a, T... b) {
cout << a << ' ';
debug(b...);
}
void FAST_IO(string filein = "", string fileout = "", string fileerr = "") {
if (fopen(filein.c_str(), "r")) {
freopen(filein.c_str(), "r", stdin);
freopen(fileout.c_str(), "w", stdout);
}
cin.tie(0), cout.tie(0)->sync_with_stdio(0);
}
void Hollwo_Pelw();
signed main() {
FAST_IO(".inp", ".out");
int testcases = 1;
for (int test = 1; test <= testcases; test++) {
Hollwo_Pelw();
}
return 0;
}
const int allmod[3] = {(int)1e9 + 7, 998244353, (int)1e9 + 9};
const int mod = allmod[0];
const int MAXN = 1e5 + 5;
const int inf = 2e9;
const long long linf = 1e18;
const long double eps = 1e-9;
int n, m, vis[MAXN], evis[MAXN];
vector<pair<int, int>> adj[MAXN];
int dfs(int u) {
vis[u] = 1;
int last = -1;
for (auto vi : adj[u]) {
int v = vi.first, id = vi.second;
if (evis[id]) continue;
evis[id] = 1;
int w = (vis[v] == 1 ? -1 : dfs(v));
if (w == -1) {
if (last != -1) cout << v << " " << u << " " << last << "\n";
last = (last == -1 ? v : -1);
} else {
cout << u << ' ' << v << ' ' << w << "\n";
}
}
return last;
}
void Hollwo_Pelw() {
cin >> n >> m;
if (m & 1) {
cout << "No solution";
return;
}
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v, adj[u].emplace_back(v, i), adj[v].emplace_back(u, i);
}
dfs(1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char g[1000002];
int main() {
int i = 0;
scanf("%s", g);
for (; g[i] != '\0'; i++) g[i] == 'r' ? printf("%d ", i + 1) : 0;
for (i--; i >= 0; i--) g[i] == 'l' ? printf("%d ", i + 1) : 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[20], b[20];
void convert(long long p[], long long x) {
memset(p, 0, sizeof(p));
vector<long long> vec;
while (x) {
vec.push_back(x % 10);
x /= 10;
}
long long Size = vec.size();
long long cur = 18;
for (long long i = 0; i < Size; i++) p[cur--] = vec[i];
return;
}
long long mem[20][2][2][10][10];
long long dp(long long cur, bool s, bool e, long long st, long long pre) {
if (cur == 19) return st == pre && pre;
long long &ret = mem[cur][s][e][st][pre];
if (ret != -1) return ret;
ret = 0;
long long x = s ? a[cur] : 0;
long long y = e ? b[cur] : 9;
for (long long i = x; i <= y; i++)
ret += dp(cur + 1, s && a[cur] == i, e && b[cur] == i, st ? st : i, i);
return ret;
}
int main() {
long long x, y;
cin >> x >> y;
convert(a, x);
convert(b, y);
memset(mem, -1, sizeof(mem));
cout << dp(0, 1, 1, 0, 0) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
const long long SIZE = 1e6 + 5;
long long n, q;
long long sta[SIZE], a[SIZE], sum[SIZE], f[SIZE];
struct node {
long long x, y, idx;
bool operator<(const node &a) const { return y < a.y; }
} que[SIZE];
namespace GTR {
const long long bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline long long fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline long long read() {
long long a = 0, b = 1, c = fetch();
while (c < 48 || c > 57) b ^= c == '-', c = fetch();
while (c >= 48 && c <= 57) a = (a << 1) + (a << 3) + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace GTR
using GTR::read;
double slope(long long i, long long j) {
return double((sum[i] - (a[i] * i)) - (sum[j] - a[j] * j)) /
double(a[i] - a[j]);
}
long long find(long long x, long long top) {
long long l = 1, r = top, mid = 0;
while (l < r) {
mid = (l + r) >> 1;
if (sta[mid] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
signed main() {
n = read();
for (long long i = 1; i <= n; ++i) a[i] = read(), sum[i] = sum[i - 1] + a[i];
q = read();
for (long long i = 1; i <= q; ++i)
que[i].x = read(), que[i].y = read(), que[i].idx = i;
std::sort(que + 1, que + q + 1);
long long top = 0;
for (long long i = 1, j = 1; i <= n; ++i) {
while (top && a[sta[top]] >= a[i]) --top;
while (top > 1 && slope(sta[top], i) >= slope(sta[top - 1], i)) --top;
sta[++top] = i;
for (; que[j].y == i && j <= q;) {
long long l = find(que[j].y - que[j].x, top), r = top, mid = 0;
while (l < r) {
mid = (l + r) >> 1;
if (slope(sta[mid], sta[mid + 1]) < que[j].x - que[j].y)
r = mid;
else
l = mid + 1;
}
l = sta[l], r = que[j].y,
f[que[j].idx] = sum[r] - sum[l] + (que[j].x - (r - l)) * a[l], ++j;
}
}
for (long long i = 1; i <= q; ++i) printf("%lld\n", f[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int main() {
string s, s1 = "";
getline(cin, s);
vector<string> v;
int flag = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ')
continue;
else if (s[i] == '"') {
int j = i + 1;
for (; s[j] != '"'; j++) {
s1 += s[j];
}
v.push_back(s1);
s1 = "";
i = j;
} else {
int j = i;
for (j; j < s.size() && s[j] != ' '; j++) {
s1 += s[j];
}
v.push_back(s1);
s1 = "";
i = j;
}
}
for (int i = 0; i < v.size(); i++) {
cout << "<";
cout << v[i] << ">" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
int par[N], sz[N], n;
int dist[N][N], check[N], vis[N];
vector<pair<int, pair<int, int>>> edge;
vector<pair<int, int>> adj[N];
void dfs(int v) {
vis[v] = 1;
for (auto it : adj[v]) {
int u = it.second;
int wt = it.first;
if (!vis[u]) {
check[u] = check[v] + wt;
dfs(u);
}
}
}
void init_dsu() {
for (int i = 0; i < N; i++) {
par[i] = i;
sz[i] = 1;
}
}
int root(int v) {
if (par[v] != v) par[v] = root(par[v]);
return par[v];
}
void merge(int u, int v) {
if (sz[u] < sz[v]) swap(u, v);
par[v] = u;
sz[u] += sz[v];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init_dsu();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) scanf("%d", &dist[i][j]);
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
if (i != j) {
if (dist[i][j] != dist[j][i] || !dist[i][j]) {
printf("NO");
return 0;
} else
edge.push_back({dist[i][j], {i, j}});
} else {
if (dist[i][j]) {
printf("NO");
return 0;
}
}
}
}
sort(edge.begin(), edge.end());
int cnt = 0;
for (int it = 0; it < edge.size(); it++) {
int u = edge[it].second.first;
int v = edge[it].second.second;
int wt = edge[it].first;
int ru = root(u);
int rv = root(v);
if (rv != ru) {
cnt++;
merge(ru, rv);
adj[u].push_back({wt, v});
adj[v].push_back({wt, u});
}
}
if (cnt != n - 1) {
printf("NO");
return 0;
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
check[i] = 0;
dfs(i);
for (int j = 1; j <= n; j++) {
if (dist[i][j] != check[j]) {
printf("NO");
return 0;
}
}
}
printf("YES");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct bamboo {
long long x, h, a, deadline;
};
bool operator<(bamboo a, bamboo b) { return a.deadline > b.deadline; }
int get() {
char c;
while (c = getchar(), (c < '0' || c > '9') && (c != '-'))
;
bool flag = (c == '-');
if (flag) c = getchar();
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
return flag ? -x : x;
}
void output(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
int len = 0, data[10];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
putchar('\n');
}
const int maxn = 100000;
long long h[maxn], a[maxn];
long long calc(long long x, long long h, long long a, int m) {
if (x / a < m) return x / a;
if (x - a * m < h) return m;
return m + 1;
}
bool check(int n, int m, int k, long long p, long long ans) {
priority_queue<bamboo> all;
while (!all.empty()) all.pop();
for (int i = 0; i < n; i++)
all.push((bamboo){ans, h[i], a[i], calc(ans, h[i], a[i], m)});
for (int i = 0; i < m; i++)
for (int j = 0; j < k; j++) {
bamboo t = all.top();
all.pop();
if (t.deadline <= i) return false;
t.x += p;
t.deadline = calc(t.x, t.h, t.a, m);
all.push(t);
}
return (all.top().deadline > m);
}
int main() {
int n = get(), m = get(), k = get();
long long p = get();
for (int i = 0; i < n; i++) {
h[i] = get();
a[i] = get();
}
long long l = 0, r = 0;
for (int i = 0; i < n; i++) r = max(r, h[i] + m * a[i]);
while (l < r) {
long long mid = (l + r) / 2;
if (check(n, m, k, p, mid))
r = mid;
else
l = mid + 1;
}
cout << l << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int MaxN = 200010;
int n;
int cnt;
long long t;
int c[MaxN << 2];
long long a[MaxN], s[MaxN];
std::map<long long, int> m;
int query(int x) {
int ans = 0;
while (x) ans += c[x], x -= (x & (-x));
return ans;
}
void add(int x, int val) {
while (x <= cnt) c[x] += val, x += (x & (-x));
}
int main() {
scanf("%d%lld", &n, &t);
m[0] = 1;
for (int i = 1; i <= n; i++)
scanf("%lld", &a[i]), s[i] = s[i - 1] + a[i], m[s[i] - t] = m[s[i]] = 1;
for (std::map<long long, int>::iterator it = m.begin(); it != m.end(); it++)
it->second = ++cnt;
long long ans = 0;
add(m[0], 1);
for (int i = 1; i <= n; i++) {
ans += i - query(m[s[i] - t]);
add(m[s[i]], 1);
}
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, l;
cin >> n >> k >> l;
string s;
cin >> s;
vector<int> ret;
for (auto c : s) {
if ('a' <= c && c <= 'z')
ret.push_back(0);
else
ret.push_back(1);
}
const long long inf = (long long)(1e18) + 7;
long long ans = n;
for (int t = 0; t < 2; t++) {
auto f = [&](int m) {
vector<pair<long long, int> > dp(n, make_pair(inf, 0));
for (int i = 0; i < n; i++) {
{
auto go = (i >= l ? dp[i - l] : make_pair(0ll, 0));
go.first += m;
go.second++;
dp[i] = min(dp[i], go);
}
{
auto go = (i > 0 ? dp[i - 1] : make_pair(0ll, 0));
go.first += ret[i];
dp[i] = min(dp[i], go);
}
}
return dp[n - 1];
};
int l = -1, r = n + 228;
while (l < r - 1) {
int mid = (l + r) / 2;
if (f(mid).second <= k) {
r = mid;
} else {
l = mid;
}
}
auto go = f(r);
ans = min(ans, go.first - r * k);
for (int &x : ret) {
x ^= 1;
}
}
cout << ans << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, q, V[200005];
int T[200005];
inline int Calc(int x) { return (x < a) ? 0 : (1 + (x - a) / (a + 1)); }
inline int Count(int d) {
for (int i = 1; i <= d; i++) T[i] = V[i];
sort(T + 1, T + d + 1);
int Res = 0;
for (int i = 1, lst = 0; i <= d; i++) {
Res += Calc(T[i] - lst - 1);
lst = T[i];
}
Res += Calc(n - T[d]);
return Res;
}
int main() {
scanf("%d%d%d", &n, &k, &a);
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d", V + i);
if (Count(q) >= k)
printf("%d\n", -1);
else {
int l = 0, r = q, mid;
while (l < r - 1) {
int mid = (l + r) >> 1;
if (Count(mid) >= k)
l = mid;
else
r = mid;
}
printf("%d\n", r);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> get_parents(const vector<vector<int>>& adj, int root) {
int n = adj.size();
vector<int> parents(n, -1);
stack<pair<int, int>> st;
st.emplace(root, -1);
while (!st.empty()) {
int node = st.top().first;
parents[node] = st.top().second;
st.pop();
for (int i : adj[node]) {
if (i != parents[node]) {
st.emplace(i, node);
}
}
}
return parents;
}
vector<vector<int>> get_children(const vector<int>& parents) {
int n = parents.size();
vector<vector<int>> children(n);
for (int i = 0; i < n; ++i) {
if (parents[i] >= 0) {
children[parents[i]].push_back(i);
}
}
return children;
}
vector<int> get_depth(const vector<vector<int>>& children, int root) {
int n = children.size();
vector<int> depth(n);
vector<int> q(1, root);
int d = 0;
while (!q.empty()) {
vector<int> q2;
for (int i : q) {
depth[i] = d;
for (int j : children[i]) {
q2.push_back(j);
}
}
q2.swap(q);
d++;
}
return depth;
}
vector<int> get_order(const vector<vector<int>>& children, int root) {
int N = children.size();
vector<int> order(N);
int idx = 0;
stack<pair<bool, int>> st;
st.emplace(true, root);
while (!st.empty()) {
bool b = st.top().first;
int node = st.top().second;
st.pop();
if (b) {
st.emplace(false, node);
for (int ch : children[node]) {
st.emplace(true, ch);
}
} else {
order[idx++] = node;
}
}
assert(idx == N);
return order;
}
vector<int> calculate_small_dp(const vector<vector<int>>& children,
const vector<int>& order, int k) {
int n = children.size();
vector<int> dp(n, 0);
for (int i : order) {
for (int ch : children[i]) {
dp[i] += max(dp[ch] - k, 1);
}
}
return dp;
}
int& chmax(int& x, int y) {
if (y > x) x = y;
return x;
}
vector<int> solve(const vector<vector<int>>& adj, const vector<int>& v,
const vector<int>& k) {
const int THRESH1 = 1000;
const int THRESH2 = 200;
int n = adj.size();
vector<int> parents = get_parents(adj, 0);
vector<vector<int>> children = get_children(parents);
vector<int> order = get_order(children, 0);
int q = v.size();
vector<int> ans(q);
vector<vector<int>> by_k(THRESH1);
for (int qi = 0; qi < q; ++qi) {
if (k[qi] < THRESH1) {
by_k[k[qi]].push_back(qi);
}
}
for (int ki = 0; ki < THRESH1; ++ki) {
if (by_k[ki].empty()) continue;
vector<int> dp = calculate_small_dp(children, order, ki);
for (int qi : by_k[ki]) {
ans[qi] = dp[v[qi]];
}
}
vector<vector<int>> dp(n);
for (int i : order) {
dp[i].resize(1, 0);
for (int ch : children[i]) {
int m = min(int(dp[i].size()) + int(dp[ch].size()), THRESH2 + 1);
vector<int> u(m, 0);
for (int j = 0; j < int(dp[i].size()); ++j) {
u[j] = dp[i][j] + 1;
}
for (int j1 = 0; j1 < int(dp[i].size()); ++j1) {
for (int j2 = 0; (j2 < int(dp[ch].size())) && ((j1 + j2 + 1) < m);
++j2) {
chmax(u[j1 + 1 + j2], dp[i][j1] + dp[ch][j2]);
}
}
u.swap(dp[i]);
}
}
for (int qi = 0; qi < q; ++qi) {
if (k[qi] >= THRESH1) {
for (int i = 0; i < int(dp[v[qi]].size()); ++i) {
chmax(ans[qi], dp[v[qi]][i] - i * k[qi]);
}
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 0; i < (n - 1); ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
adj[x].push_back(y);
adj[y].push_back(x);
}
int q;
cin >> q;
vector<int> v(q), k(q);
for (int i = 0; i < q; ++i) {
cin >> v[i] >> k[i];
--v[i];
}
vector<int> ans = solve(adj, v, k);
for (int i = 0; i < q; ++i) {
cout << ans[i] << "\n";
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, sxd, a[55], b[55];
double p[55];
double f[55][12000];
bool ok(double x) {
for (long long i = n - 1; i >= 0; i--) {
for (long long j = sxd + 1; j <= 10000; j++) f[i + 1][j] = x;
for (long long j = 0; j <= sxd; j++)
f[i][j] =
min(x, (f[i + 1][j + a[i]] + a[i]) * p[i] / 100.0 +
(f[i + 1][j + b[i]] + b[i]) * (100.0 - p[i]) / 100.0);
}
return (f[0][0] < x);
}
signed main() {
cin >> n >> sxd;
for (long long i = 0; i < n; i++) cin >> a[i] >> b[i] >> p[i];
double l = 0, r = 1e18;
for (long long i = 1; i <= 150; i++) {
double mid = (l + r) / 2;
if (ok(mid))
r = mid;
else
l = mid;
}
printf("%.10f", l);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int Mat[105][105];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", n < m ? &Mat[j][i] : &Mat[i][j]);
}
}
if (n < m) n ^= m ^= n ^= m;
int res1 = 0;
int res2 = 0;
int res = 1 << 24;
for (int i = 1; i <= n; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++) {
res1 = 0;
res2 = 0;
for (int k = 1; k <= m; k++) {
if (Mat[i][k] == Mat[j][k])
res1++;
else
res2++;
}
tmp += min(res1, res2);
}
res = min(res, tmp);
}
for (int i = 1; i <= m; i++) {
int tmp = 0;
for (int j = 1; j <= m; j++) {
res1 = 0;
res2 = 0;
for (int k = 1; k <= n; k++) {
if (Mat[k][i] == Mat[k][j])
res1++;
else
res2++;
}
tmp += min(res1, res2);
}
res = min(res, tmp);
}
res1 = 0;
res2 = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (Mat[i][j] == 1)
res1++;
else
res2++;
}
}
res = min(res, min(res1, res2));
printf("%d", res > k ? -1 : res);
}
| 7 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
using namespace std;
const int Max = 10055;
int 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))); }
bool com(string x, string y) { return x + y < y + x; }
int main() {
int n, tot = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (a[i] == a[j] && i != j) {
sum++;
a[j] = a[j] + sum;
tot += sum;
}
}
}
cout << tot;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 500031;
string maps[1000];
vector<int> ordr;
int n, k;
string st[N];
vector<int> ans;
int done[2031][2031], memo[2031][2031];
pair<int, int> next_move[2031][2031];
int already_done[2031][15], memo_put[2031][15];
int count_ones(string& st) {
int cnt = 0;
for (int i = 0; i < st.size(); i++) {
if (st[i] == '1') cnt++;
}
return cnt;
}
bool can_put(int id, int dig) {
if (already_done[id][dig]) return memo_put[id][dig];
already_done[id][dig] = 1;
for (int i = 0; i < 7; i++) {
if (maps[dig][i] == '0' && st[id][ordr[i]] == '1') return false;
}
memo_put[id][dig] = 1;
return true;
}
bool solve(int ps, int rem) {
if (rem < 0) return false;
if (ps == n) {
return (rem == 0);
}
if (done[ps][rem]) return memo[ps][rem];
done[ps][rem] = 1;
for (int i = 9; i >= 0; --i) {
if (!can_put(ps + 1, i)) continue;
int new_rem = rem - count_ones(maps[i]) + count_ones(st[ps + 1]);
int here = solve(ps + 1, new_rem);
if (here == 1) {
memo[ps][rem] = 1;
next_move[ps][rem] = make_pair(i, new_rem);
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
maps[0] = "1111110";
maps[1] = "0110000";
maps[2] = "1101101";
maps[3] = "1111001";
maps[4] = "0110011";
maps[5] = "1011011";
maps[6] = "1011111";
maps[7] = "1110000";
maps[8] = "1111111";
maps[9] = "1111011";
ordr.push_back(0);
ordr.push_back(2);
ordr.push_back(5);
ordr.push_back(6);
ordr.push_back(4);
ordr.push_back(1);
ordr.push_back(3);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> st[i];
}
int ok = solve(0, k);
if (!ok) {
cout << -1 << endl;
return 0;
}
int cur_rem = k;
for (int iter = 0; iter < n; iter++) {
ans.push_back(next_move[iter][cur_rem].first);
cur_rem = next_move[iter][cur_rem].second;
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, char> ma;
long long l, r;
long long p;
unsigned int se[31250009];
bool isv(int k) { return se[k / 32] & (1 << (k % 32)); }
void sev(int k) { se[k / 32] = se[k / 32] | (1 << (k % 32)); }
int main() {
cin >> l >> r >> p;
ma[1] = 0;
long long nu;
char nk;
int res = 0;
for (long long k = 2; k < p; k++) {
while (!ma.empty() && (k * (long long)(--ma.end())->first) > r) {
ma.erase(--ma.end());
}
for (map<int, char>::iterator it = ma.begin(); it != ma.end(); it++) {
nu = it->first * k;
nk = it->second + 1;
if (nu >= l && nk + k <= p) {
if (!isv(nu)) {
res++;
}
sev(nu);
}
if (nu * k <= r) {
char c = 120;
if (ma.count(nu) > 0) {
ma[nu] = min(ma[nu], nk);
} else {
ma[nu] = nk;
}
}
}
}
cout << res << endl;
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.