solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long md = 998244353;
struct modular_num {
long long d;
modular_num(long long x = 0) { d = normal(x); }
long long normal(long long x) {
x %= md;
while (x < 0) x += md;
return x;
}
modular_num inverse(modular_num t) { return t ^ (md - 2); }
friend istream& operator>>(istream& in, modular_num& t) {
in >> t();
return in;
}
friend ostream& operator<<(ostream& out, modular_num t) {
out << t();
return out;
}
long long& operator()() { return d; }
modular_num operator+(modular_num t) { return normal(d + t()); }
modular_num& operator+=(modular_num t) { return *this = *this + t; }
modular_num operator-(modular_num t) { return normal(d - t()); }
modular_num& operator-=(modular_num t) { return *this = *this - t; }
modular_num operator*(modular_num t) { return 1ll * d * t() % md; }
modular_num& operator*=(modular_num t) { return *this = *this * t; }
modular_num operator^(long long power) {
modular_num base = *this, res = 1;
while (power > 0) {
if (power & 1) res *= base;
base *= base;
power >>= 1;
}
return res;
}
modular_num& operator^=(long long power) { return *this = *this ^ power; }
modular_num operator/(modular_num t) { return 1ll * d * inverse(t)() % md; }
modular_num& operator/=(modular_num t) { return *this = *this / t; }
modular_num& operator=(modular_num t) {
d = t();
return *this;
}
bool operator==(modular_num t) { return d == t(); }
bool operator!=(modular_num t) { return d != t(); }
};
using mint = modular_num;
const long long N = 2e5 + 5;
mint fac[N], ifac[N];
void precalc() {
fac[0] = ifac[0] = 1;
for (long long i = 1; i < N; i++) {
fac[i] = fac[i - 1] * i;
ifac[i] = mint(1) / fac[i];
}
}
mint C(long long n, long long k) {
assert(k <= n);
return fac[n] * ifac[k] * ifac[n - k];
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
precalc();
long long n, k;
cin >> n >> k;
if (k == 0) {
cout << fac[n] << '\n';
return 0;
}
if (k >= n) {
cout << 0 << '\n';
return 0;
}
mint ans = 0;
long long r = n - k;
for (long long i = 0; i <= r; i++) {
mint val = C(r, i) * (mint(i) ^ n);
(r - i)& 1 ? ans -= val : ans += val;
}
ans *= C(n, k) * 2;
cout << ans << '\n';
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
for (int i = 1; i < n; i++) {
if (a[i - 1] == 1) {
if (a[i] == 3)
ans += 4;
else {
if (i - 2 >= 0 && a[i - 2] == 3)
ans += 2;
else
ans += 3;
}
} else if (a[i - 1] == 2) {
if (a[i] == 1)
ans += 3;
else {
ans = -1;
}
} else {
if (a[i] == 1)
ans += 4;
else {
ans = -1;
}
}
if (ans == -1) break;
}
if (ans == -1)
cout << "Infinite";
else {
cout << "Finite\n";
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, set<string>> p;
map<set<string>, set<string>> q;
void solve() {
int n;
cin >> n;
for (__typeof(n) i = 0; i != n; i += 1) {
string s;
cin >> s;
int k = -1;
for (__typeof((int)s.size()) j = 7; j != (int)s.size(); j += 1) {
if (s[j] == '/') {
k = j;
break;
}
}
if (k == -1) {
p[s].insert("");
} else {
p[s.substr(0, k)].insert(s.substr(k));
}
}
for (auto i : p) {
q[i.second].insert(i.first);
}
vector<set<string>> x;
for (auto i : q) {
if ((int)i.second.size() > 1) {
x.push_back(i.second);
}
}
cout << (int)x.size() << '\n';
for (auto i : x) {
for (auto j : i) {
cout << j << " ";
}
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
bool cmp(long long a, long long b) { return (a > b); }
int main() {
c_p_c();
cout << fixed << setprecision(10);
long long t;
cin >> t;
while (t--) {
long long n;
int s = 0;
cin >> n;
long long a[n + 1];
long long maxa = INT_MIN;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 1; i < n; i++) {
maxa = max(maxa, a[i] * a[i - 1]);
}
cout << maxa << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2>& p) {
out << p.first << " " << p.second;
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto& i : v) {
out << i << "\n";
}
return out;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
long long ans = k / n;
k %= n;
if (k) {
++ans;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[5];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> p[i].first >> p[i].second;
if (n == 1) return cout << -1, 0;
if (n == 2) {
if (p[0].first == p[1].first || p[0].second == p[1].second)
return cout << -1, 0;
cout << abs(p[0].first - p[1].first) * abs(p[0].second - p[1].second);
return 0;
}
if (n == 3) {
int ans = 0;
for (int i = 0; i < 3; i++)
ans = max(
ans,
max(max(abs(p[i].first - p[0].first) * abs(p[i].second - p[0].second),
abs(p[i].first - p[1].first) *
abs(p[i].second - p[1].second)),
abs(p[i].first - p[2].first) * abs(p[i].second - p[2].second)));
return cout << ans, 0;
}
cout << max(
max(abs(p[0].first - p[1].first) * abs(p[0].second - p[1].second),
abs(p[0].first - p[2].first) * abs(p[0].second - p[2].second)),
abs(p[0].first - p[3].first) * abs(p[0].second - p[3].second));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long MOD = 1000000007;
const int MAXN = 22;
struct matrix {
int n, m;
unsigned long long arr[MAXN][MAXN];
matrix() {}
matrix(int x, int y, int V = 0) {
n = x;
m = y;
for (int j = 0; j < n; j++)
for (int i = 0; i < m; i++) arr[j][i] = V;
}
matrix(int x, int y, unsigned long long A[MAXN][MAXN]) {
n = x;
m = y;
for (int j = 0; j < n; j++)
for (int i = 0; i < m; i++) arr[j][i] = A[j][i];
}
matrix operator*(matrix &mat) {
matrix res(n, mat.m, 0);
unsigned long long theta;
for (int j = 0; j < n; j++) {
for (int i = 0; i < mat.m; i++) {
theta = 0;
for (int k = 0; k < m; k++) {
theta += 1ll * arr[j][k] * mat.arr[k][i];
theta %= MOD;
}
res.arr[j][i] = theta;
}
}
return res;
}
matrix power(unsigned long long K) {
matrix res(n, m, 0), b(n, m, 0);
for (int j = 0; j < n; j++) res.arr[j][j] = 1ll;
b = (*this);
while (K > 0) {
if ((K & 1)) res = res * b;
K /= 2;
b = b * b;
}
return res;
}
};
void print(matrix &G) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) cout << G.arr[i][j] << ' ';
cout << endl;
}
}
int main() {
int n;
unsigned long long k;
cin >> n >> k;
matrix M(20, 20, 0);
for (int i = 0; i < 20; i++) M.arr[i][i] = 1ll;
for (int u = 0; u < n; u++) {
int c;
unsigned long long a, b;
cin >> a >> b >> c;
matrix G(20, 20, 0);
for (int i = 0; i < 20; i++)
for (int j = 0; j < 20; j++) {
if (abs(j - i) <= 1 && j <= c && i <= c) G.arr[i][j] = 1ll;
}
if (min(b, k) - a == 0) continue;
G = G.power(min(b, k) - a);
M = M * G;
}
unsigned long long sum = M.arr[0][0] % MOD;
cout << sum << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int sum = 0;
for (int i = 1; i < n; i++) {
sum += (n - i) * i;
}
sum += n;
cout << sum << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3;
const long long INF = 1e18;
struct Dinic {
struct edge {
int from, to;
long long cap, flow;
};
vector<edge> es;
vector<int> G[N];
bool vis[N];
int dist[N], iter[N];
void init(int n) {
for (int i = 0; i <= n + 10; i++) G[i].clear();
es.clear();
}
void addedge(int from, int to, long long cap) {
es.push_back((edge){from, to, cap, 0});
es.push_back((edge){to, from, 0, 0});
int x = es.size();
G[from].push_back(x - 2);
G[to].push_back(x - 1);
}
bool BFS(int s, int t) {
memset(vis, 0, sizeof(vis));
queue<int> q;
vis[s] = 1;
dist[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); i++) {
edge &e = es[G[u][i]];
if (!vis[e.to] && e.cap > e.flow) {
vis[e.to] = 1;
dist[e.to] = dist[u] + 1;
q.push(e.to);
}
}
}
return vis[t];
}
long long DFS(int u, int t, long long f) {
if (u == t || f == 0) return f;
long long nowflow = 0, d;
for (int &i = iter[u]; i < G[u].size(); i++) {
edge &e = es[G[u][i]];
if (dist[u] + 1 == dist[e.to] &&
(d = DFS(e.to, t, min(f, e.cap - e.flow))) > 0) {
e.flow += d;
es[G[u][i] ^ 1].flow -= d;
nowflow += d;
f -= d;
if (f == 0) break;
}
}
return nowflow;
}
long long Maxflow(int s, int t) {
long long flow = 0;
while (BFS(s, t)) {
memset(iter, 0, sizeof(iter));
long long d = 0;
while (d = DFS(s, t, INF)) flow += d;
}
return flow;
}
} dc;
int n, m;
int main() {
cin >> n >> m;
int S = 0, T = n + m + 1;
dc.init(n + m + 10);
for (int i = 1; i <= n; i++) {
int c;
cin >> c;
dc.addedge(i, T, c);
}
long long sum = 0;
for (int i = 1; i <= m; i++) {
int a, b, c;
cin >> a >> b >> c;
sum += c;
dc.addedge(S, i + n, c);
dc.addedge(i + n, a, INF);
dc.addedge(i + n, b, INF);
}
cout << (sum - dc.Maxflow(S, T)) << '\n';
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
void add_ele(pair<int, int> p1, pair<int, int> p2, pair<int, int> p3,
vector<vector<int> > &ans) {
vector<int> temp = {p1.first, p1.second, p2.first,
p2.second, p3.first, p3.second};
ans.push_back(temp);
}
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
string s;
int arr[n][m];
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == '1') {
arr[i][j] = 1;
} else
arr[i][j] = 0;
}
}
vector<vector<int> > ans;
for (int i = 0; i < n - 2; i++) {
for (int j = 0; j < m; j++) {
if (j < m - 1) {
if (arr[i][j]) {
vector<int> temp = {i, j, i + 1, j, i + 1, j + 1};
arr[i + 1][j + 1] = 1 - arr[i + 1][j + 1];
arr[i + 1][j] = 1 - arr[i + 1][j];
ans.push_back(temp);
}
} else {
if (arr[i][j]) {
vector<int> temp = {i, j, i + 1, j, i + 1, j - 1};
arr[i + 1][j - 1] = 1 - arr[i + 1][j - 1];
arr[i + 1][j] = 1 - arr[i + 1][j];
ans.push_back(temp);
}
}
}
}
for (int j = 0; j < m - 2; j++) {
if (arr[n - 1][j] && arr[n - 2][j]) {
vector<int> temp = {n - 1, j, n - 2, j, n - 1, j + 1};
arr[n - 1][j + 1] = 1 - arr[n - 1][j + 1];
ans.push_back(temp);
} else if (arr[n - 1][j] && !arr[n - 2][j]) {
vector<int> temp = {n - 1, j, n - 2, j + 1, n - 1, j + 1};
arr[n - 1][j + 1] = 1 - arr[n - 1][j + 1];
arr[n - 2][j + 1] = 1 - arr[n - 2][j + 1];
ans.push_back(temp);
} else if (!arr[n - 1][j] && arr[n - 2][j]) {
vector<int> temp = {n - 1, j + 1, n - 2, j, n - 2, j + 1};
arr[n - 1][j + 1] = 1 - arr[n - 1][j + 1];
arr[n - 2][j + 1] = 1 - arr[n - 2][j + 1];
ans.push_back(temp);
}
}
vector<pair<int, int> > ones;
vector<pair<int, int> > zeros;
if (arr[n - 2][m - 2]) {
ones.push_back({n - 2, m - 2});
} else {
zeros.push_back({n - 2, m - 2});
}
if (arr[n - 1][m - 2]) {
ones.push_back({n - 1, m - 2});
} else {
zeros.push_back({n - 1, m - 2});
}
if (arr[n - 2][m - 1]) {
ones.push_back({n - 2, m - 1});
} else {
zeros.push_back({n - 2, m - 1});
}
if (arr[n - 1][m - 1]) {
ones.push_back({n - 1, m - 1});
} else {
zeros.push_back({n - 1, m - 1});
}
if (ones.size() == 4) {
add_ele(ones[0], ones[1], ones[2], ans);
add_ele(ones[3], ones[1], ones[2], ans);
add_ele(ones[0], ones[1], ones[3], ans);
add_ele(ones[0], ones[3], ones[2], ans);
} else if (ones.size() == 3) {
add_ele(ones[0], ones[1], ones[2], ans);
} else if (ones.size() == 2) {
add_ele(ones[0], zeros[0], zeros[1], ans);
add_ele(ones[1], zeros[0], zeros[1], ans);
} else if (ones.size() == 1) {
add_ele(ones[0], zeros[0], zeros[1], ans);
add_ele(ones[0], zeros[0], zeros[2], ans);
add_ele(ones[0], zeros[2], zeros[1], ans);
}
cout << ans.size() << endl;
for (auto vec : ans) {
for (auto ind : vec) {
cout << ind + 1 << ' ';
}
cout << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<vector<int>> grid(1001, vector<int>(1001));
vector<ll> fact(2001), invfact(2001);
ll MOD = 1e9 + 7;
ll inv(ll b, ll p = MOD - 2) {
if (p == 0) return 1LL;
ll x = inv(b, p / 2);
x = x * x % MOD;
if (p % 2) x = x * b % MOD;
return x;
}
ll choose(int x, int y) {
if (y > x) return 0LL;
return fact[x] * invfact[y] % MOD * invfact[x - y] % MOD;
}
int get(int a, int b, int c, int d) {
a = min(a, 1000);
b = min(b, 1000);
c = max(c, 1);
d = max(d, 1);
return grid[a][b] - grid[c - 1][b] - grid[a][d - 1] + grid[c - 1][d - 1];
}
int get(int X, int Y, int R) {
int a = X + R, b = Y + R, c = X - R, d = Y - R;
return get(a, b, c, d);
}
int main() {
int N, M, R;
cin >> N >> M >> R;
vector<int> X(N), Y(N), B(N);
fact[0] = 1LL, invfact[0] = 1LL;
for (int i = 1; i <= 2000; i++)
fact[i] = i * 1LL * fact[i - 1] % MOD, invfact[i] = inv(fact[i]);
ll S = 0LL;
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i] >> B[i];
++grid[X[i]][Y[i]];
S += B[i] * 1LL * B[i];
}
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= 1000; j++) {
grid[i][j] += grid[i - 1][j] + grid[i][j - 1] - grid[i - 1][j - 1];
}
}
vector<vector<int>> num(N, vector<int>(N));
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (min(Y[i], Y[j]) + R >= max(Y[i], Y[j]) - R &&
min(X[i], X[j]) + R >= max(X[i], X[j]) - R) {
int a = min(X[i], X[j]) + R, c = max(X[i], X[j]) - R;
int b = min(Y[i], Y[j]) + R, d = max(Y[i], Y[j]) - R;
num[i][j] = get(a, b, c, d);
}
}
}
vector<vector<ll>> f(N, vector<ll>(N));
ll tot = choose(N, M);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
int numBoth = num[i][i] + num[j][j] - num[i][j];
f[i][j] = tot - choose(N - num[i][i], M) - choose(N - num[j][j], M) +
choose(N - numBoth, M);
f[i][j] %= MOD;
}
}
ll ans = 0LL;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
ans += B[i] * 1LL * B[j] % MOD * f[i][j] % MOD;
ans %= MOD;
}
}
if (ans < 0) ans += MOD;
cout << ans << "\n";
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, w;
scanf("%d%d", &h, &w);
pair<int, int> s = make_pair(h, w), e = make_pair(0, 0), p;
char g[h + 3][w + 3];
for (int i = 0; i < h; i++) scanf("%s", g[i]);
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
if (g[i][j] == '*') {
p = make_pair(i, j);
s.first = min(i, s.first);
s.second = min(j, s.second);
e.first = max(i, e.first);
e.second = max(j, e.second);
}
for (int i = s.first; i <= e.first; i++) {
for (int j = s.second; j <= e.second; j++) printf("%c", g[i][j]);
puts("");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, k = 0;
cin >> n >> k;
set<int> s;
deque<int> d;
for (int i = 0; i < n; i++) {
int x = 0;
cin >> x;
if (s.count(x) == 0) {
if (d.size() == k) {
int y = d.back();
d.pop_back();
s.insert(x);
d.push_front(x);
s.erase(y);
} else {
s.insert(x);
d.push_front(x);
}
}
}
cout << d.size() << endl;
for (auto i = d.begin(); i != d.end(); i++) cout << *i << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
int x, y, z, ind;
pt() : x(0), y(0), z(0), ind(0){};
pt(int a, int b, int c, int d) : x(a), y(b), z(c), ind(d){};
};
bool compare(const pt &a, const pt &b) {
if (a.x != b.x) return a.x < b.x;
if (a.y != b.y) return a.y < b.y;
if (a.z != b.z) return a.z < b.z;
return a.ind < b.ind;
}
int main() {
int n;
cin >> n;
vector<pt> point(n);
for (int i = 0; i < n; i++) {
point[i].ind = i + 1;
cin >> point[i].x >> point[i].y >> point[i].z;
}
sort(point.begin(), point.end(), compare);
vector<pt> sec, thi;
for (int i = 0; i < n; i++) {
if (i == n - 1) {
sec.push_back(point[i]);
break;
}
if (point[i].x == point[i + 1].x && point[i].y == point[i + 1].y) {
cout << point[i].ind << ' ' << point[i + 1].ind << '\n';
i++;
} else
sec.push_back(point[i]);
}
int size = sec.size();
for (int i = 0; i < size; i++) {
if (i == size - 1) {
thi.push_back(sec[i]);
break;
}
if (sec[i].x == sec[i + 1].x) {
cout << sec[i].ind << ' ' << sec[i + 1].ind << '\n';
i++;
} else
thi.push_back(sec[i]);
}
size = thi.size();
for (int i = 0; i < size; i += 2)
cout << thi[i].ind << ' ' << thi[i + 1].ind << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
int mod = 1000000007;
using namespace std;
bool isp(long long x) {
for (long long i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
void pog() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
}
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
int32_t main() {
pog();
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
double g = n;
long long z = ceil(g / 4);
for (long long i = 0; i < n - z; i++) {
cout << 9;
}
for (long long i = 0; i < z; i++) cout << 8;
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x, y, ans;
int a[8][8];
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
ans = 1000;
memset(a, 0, sizeof a);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
a[x][y] = a[y][x] = 1;
}
if (n <= 6)
printf("%d\n", m);
else {
for (int i = 1; i < 7; i++) {
for (int j = i + 1; j <= 7; j++) {
int cnt = 0;
for (int k = 1; k <= 7; k++) {
if (a[i][k] && a[j][k]) {
cnt++;
}
}
ans = min(cnt, ans);
}
}
printf("%d\n", m - ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int a[MAXN], crime[MAXN], ncrime[MAXN], no;
bool mark[MAXN];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > 0)
crime[a[i]]++;
else {
ncrime[-a[i]]++;
no++;
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (crime[i] + no - ncrime[i] == m) {
mark[i] = true;
cnt++;
}
for (int i = 1; i <= n; i++)
if ((a[i] > 0 && mark[a[i]] && cnt == 1) || (a[i] < 0 && !mark[-a[i]]))
cout << "Truth" << endl;
else if ((a[i] > 0 && !mark[a[i]]) || (a[i] < 0 && mark[-a[i]] && cnt == 1))
cout << "Lie" << endl;
else
cout << "Not defined" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[200000];
long long n, k, l;
long long mins[200000];
long long cnt[200000];
stack<long long> fuck;
stack<long long> suck;
int main() {
memset(mins, 31, sizeof(mins));
cin >> n >> k >> l;
for (long long i = 0; i < n * k; i++) {
cin >> a[i];
}
sort(a, a + (n * k));
long long go = a[0] + l;
for (long long i = 0; i < n * k; i++) {
if (go >= a[i]) {
fuck.push(a[i]);
} else {
break;
}
}
if (fuck.size() < n) {
puts("0");
return 0;
}
while (fuck.empty() == false) {
suck.push(fuck.top());
fuck.pop();
}
int buck = 0;
while (suck.empty() == false) {
int rem = (n - 1 - buck);
if (rem < suck.size()) {
mins[buck] = min(mins[buck], suck.top());
cnt[buck]++;
if (cnt[buck] == k) buck++;
suck.pop();
} else {
buck++;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) ans += mins[i];
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[10005] = {0};
int main() {
int n;
cin >> n;
int pre = 0, Max = -1, Maxpos = 0;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
if (i == 0) {
pre = num;
continue;
}
a[i] = num - pre;
if (Max < a[i]) {
Max = max(Max, a[i]);
Maxpos = i;
}
pre = num;
}
int Min = 0x3f3f3f3f;
for (int i = 1; i < n - 1; i++) {
Min = min(a[i + 1] + a[i], Min);
}
cout << max(Max, Min) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k;
cin >> n >> k;
if (k < n + 1 || n == 4) {
cout << -1 << endl;
return 0;
}
int a, b, c, d;
cin >> a >> b >> c >> d;
vector<int> p;
for (int i = 1; i <= n; i++) {
if (i == a || i == b || i == c || i == d) continue;
p.push_back(i);
}
cout << a << " " << c << " ";
for (int i = 0; i < n - 4; i++) cout << p[i] << " ";
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (int i = 0; i < n - 4; i++) cout << p[i] << " ";
cout << b << " " << d << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long mod = 1e9 + 7;
inline long long pwr(long long base, long long n) {
long long ans = 1;
while (n > 0) {
if (n % 2 == 1) ans = ans * base;
base = base * base;
n /= 2;
}
return ans;
}
struct range {
int l, h;
};
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int final[26] = {0};
int ues[26] = {0};
int shck = 0;
int exc = 0;
int ext = 0;
int t;
cin >> t;
while (t--) {
char c;
string s;
cin >> c >> s;
int es[26] = {0};
if (c == '!') {
for (int i = 0; i < s.length(); i++) {
es[s[i] - 97] = 1;
}
}
if (c == '.' && exc != 1) {
for (int i = 0; i < s.length(); i++) {
ues[s[i] - 97] = 1;
}
}
int ct = 0;
if (shck == 1 && exc != 1) {
for (int i = 0; i < 26; i++) {
if (c == '!') final[i] = final[i] && es[i];
if (ues[i] == 1) final[i] = 0;
if (final[i] == 1) {
ct++;
}
}
} else if (shck == 0) {
for (int i = 0; i < 26; i++) {
final[i] = es[i];
if (ues[i]) final[i] = 0;
if (final[i] == 1) ct++;
}
}
if (c == '!') shck = 1;
if (c == '?' && exc != 1) ues[s[0] - 97] = 1;
int uct = 0;
for (int i = 0; i < 26; i++) uct += ues[i];
if (exc == 1 && c != '.') ext++;
if (ct == 1 || uct == 25) exc = 1;
}
cout << max(0, ext - 1) << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const double pi = acos(-1.0), eps = 1e-6;
double dist(int x, int y) { return sqrt((long long)x * x + (long long)y * y); }
struct Range {
double l, r;
bool operator<(const Range &b) const {
return fabs(l - b.l) < eps ? r > b.r : l < b.l;
}
} R[maxn << 1];
int X[maxn], Y[maxn];
int n, m, N;
void DFS(int x, int *f, int *g, int *outrange) {
int res = 0, X = x;
while (!g[x] && x + f[x] <= N) {
res++;
x += f[x];
}
if (!g[x]) {
outrange[x] = x + f[x] - 1 - N;
g[x] = 1;
}
while (X != x) {
g[X] = g[x] + res--;
outrange[X] = outrange[x];
X += f[X];
}
}
int Solve(double radius) {
static int f[maxn], g[maxn], outrange[maxn];
for (int i = 1; i <= n; i++) {
double delta = acos(radius / dist(X[i], Y[i]));
double initangle = atan2(Y[i], X[i]);
R[i].l = initangle - delta;
R[i].r = initangle + delta;
if (R[i].l < 0) R[i].l += 2 * pi;
if (R[i].r < 0) R[i].r += 2 * pi;
if (R[i].r < R[i].l) R[i].r += 2 * pi;
}
sort(R + 1, R + 1 + n);
N = 0;
for (int i = 1; i <= n; i++) {
while (N && R[i].r < R[N].r) N--;
R[++N] = R[i];
}
while (R[N].r - 2 * pi >= R[1].r) N--;
for (int i = N + 1; i <= N + N; i++) R[i] = R[i - N], R[i].l += 2 * pi;
memset(g, 0, sizeof(int) * (N + 1));
memset(outrange, 0, sizeof(int) * (N + 1));
for (int i = 1, r = 1; i <= N; i++) {
while (r < N + i - 1 && R[r + 1].l <= R[i].r) r++;
f[i] = r - i + 1;
}
if (f[1] == N) return 1;
int res = N;
for (int i = 1; i <= f[1] + 1; i++) {
DFS(i, f, g, outrange);
res = min(res, g[i] + (outrange[i] < i - 1));
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d%d", &X[i], &Y[i]);
double l = 0, r = 1e10, mid;
for (int i = 1; i <= n; i++) r = min(r, dist(X[i], Y[i]));
while (r - l > eps) Solve(mid = (l + r) / 2.0) > m ? r = mid : l = mid;
printf("%.9f\n", l);
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int today;
int temp;
cin >> today;
cin >> temp;
for (int i = 1; i < n; i++) {
today++;
int nwdocfrday;
int nwdoceach;
cin >> nwdocfrday;
cin >> nwdoceach;
int dayfornewdoc = nwdocfrday;
while (today > dayfornewdoc) {
dayfornewdoc = dayfornewdoc + nwdoceach;
}
today = dayfornewdoc;
}
cout << today;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const double eps = 1e-9;
int n;
struct cmp {
bool operator()(int const& lhs, int const& rhs) const { return lhs > rhs; }
};
void solveAA() {
int t;
cin >> t;
for (int z = 0; z < t; z++) {
cin >> n;
set<int, cmp> p;
map<int, int> mp;
map<int, int> rev;
for (int i = 0; i < n; i++) {
int tem;
cin >> tem;
p.insert(tem);
mp[tem] = i + 1;
rev[i + 1] = tem;
}
map<int, vector<int> > gr;
map<int, set<int, cmp> > grr;
for (int i = 0; i < n; i++) {
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
int aa = rev[a];
int bb = rev[b];
grr[a].erase(aa);
grr[a].erase(bb);
grr[b].erase(aa);
grr[b].erase(bb);
gr[a].push_back(b);
gr[b].push_back(a);
}
vector<int> ans(n, 0);
for (int i = 0; i < n; i++) {
int temp = i + 1;
set<int, cmp> te_ve = grr[temp];
if (!te_ve.empty()) {
ans[temp - 1] = mp[*te_ve.begin()];
} else
ans[temp - 1] = 0;
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
void solveA() {
string ss;
cin >> ss;
int B = 0;
int u = 0;
int l = 0;
int b = 0;
int a = 0;
int s = 0;
int r = 0;
for (int i = 0; i < ss.size(); i++) {
if (ss[i] == 'B') {
B++;
}
if (ss[i] == 'u') {
u++;
}
if (ss[i] == 'l') {
l++;
}
if (ss[i] == 'b') {
b++;
}
if (ss[i] == 'a') {
a++;
}
if (ss[i] == 's') {
s++;
}
if (ss[i] == 'r') {
r++;
}
}
int m = min(B, u / 2);
m = min(m, l);
m = min(m, b);
m = min(m, a / 2);
m = min(m, s);
m = min(m, r);
cout << m << endl;
}
void solveB() {}
void solveC() {}
void solveCC() {
int e;
cin >> n >> e;
map<int, int> mp;
vector<vector<int> > v(e, vector<int>(2, 0));
for (int i = 0; i < e; i++) {
int a, b;
cin >> a >> b;
v[i][0] = a;
v[i][1] = b;
mp[a]--;
mp[b]++;
}
map<int, int> vis;
for (int i = 0; i < e; i++) {
int a = v[i][0];
int b = v[i][1];
if (mp[a] < 0 && mp[b] != 0) {
mp[a] += 2;
mp[b] -= 2;
swap(v[i][0], v[i][1]);
} else if (mp[b] > 0 && mp[a] != 0) {
mp[a] += 2;
mp[b] -= 2;
swap(v[i][0], v[i][1]);
}
}
vector<vector<int> > grp(n);
for (int i = 0; i < e; i++) {
int a = v[i][0];
int b = v[i][1];
grp[a - 1].push_back(b);
}
stack<int> st;
st.push(1);
while (!st.empty()) {
int t = st.top();
st.pop();
vis[t] = 1;
vector<int> ty = grp[t - 1];
for (int i = 0; i < ty.size(); i++) {
int r = ty[i];
if (vis[r] == 0) {
st.push(r);
}
}
}
for (int i = 0; i < n; i++) {
if (mp[i + 1] != 0 || vis[i + 1] == 0) {
cout << "NO";
return;
}
}
cout << "YES" << endl;
for (int i = 0; i < e; i++) {
cout << v[i][0] << " " << v[i][1] << endl;
}
}
void solveD() {}
void solveE() {}
void solveD2() {}
void solveE2() {}
int main() {
solveA();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string d_ver[7][3] = {{"...", "...", "..."}, {"...", ".O.", "..."},
{"..O", "...", "O.."}, {"..O", ".O.", "O.."},
{"O.O", "...", "O.O"}, {"O.O", ".O.", "O.O"},
{"O.O", "O.O", "O.O"}};
string d_hor[7][3] = {{"...", "...", "..."}, {"...", ".O.", "..."},
{"O..", "...", "..O"}, {"O..", ".O.", "..O"},
{"O.O", "...", "O.O"}, {"O.O", ".O.", "O.O"},
{"OOO", "...", "OOO"}};
int h[255][255];
int v[255][255];
int n, m;
int f[255];
int g[255];
const int mod = 1000000007;
vector<string> ss;
int main() {
cin >> n >> m;
for (int(i) = 0; (i) < (n); ++(i)) {
string s[3];
cin >> s[0];
ss.push_back(s[0]);
s[0] = s[1] = s[2] = "";
ss.push_back(s[0]);
for (int(k) = 0; (k) < (3); ++(k)) {
string tt = "";
for (int(j) = 0; (j) < (4 * m + 1); ++(j)) {
char ch;
cin >> ch;
tt += ch;
if (ch != '#') s[k] += ch;
}
ss.push_back(tt);
}
for (int(j) = 0; (j) < (m); ++(j)) {
string c[3];
for (int(k) = 0; (k) < (3); ++(k)) c[k] = s[k].substr(3 * j, 3);
for (int(l) = 0; (l) < (7); ++(l)) {
bool ok = 1;
for (int(k) = 0; (k) < (3); ++(k))
if (c[k] != d_hor[l][k]) ok = 0;
if (ok) {
h[i + 1][j + 1] = 1;
break;
}
}
for (int(l) = 0; (l) < (7); ++(l)) {
bool ok = 1;
for (int(k) = 0; (k) < (3); ++(k))
if (c[k] != d_ver[l][k]) ok = 0;
if (ok) {
v[i + 1][j + 1] = 1;
break;
}
}
}
}
f[0] = 1;
for (int j = 1; j <= m; ++j) {
f[j] = 0;
bool ok1 = 0;
bool ok2 = 0;
if (n % 2 == 0) {
ok1 = 1;
ok2 = 1;
for (int i = 1; i <= n; i++) {
if (!v[i][j]) ok1 = 0;
if (!v[i][j - 1]) ok2 = 0;
}
if (ok1) f[j] = f[j - 1];
}
memset((g), 0, sizeof((g)));
g[0] = 1;
for (int i = 1; i <= n; ++i) {
if (v[i][j] && v[i - 1][j] && v[i][j - 1] && v[i - 1][j - 1])
g[i] = (g[i] + g[i - 2]) % mod;
if (h[i][j] && h[i][j - 1]) g[i] = (g[i] + g[i - 1]) % mod;
}
if (ok1 && ok2) g[n] = (g[n] + mod - 1) % mod;
if (j > 1) f[j] = ((long long)f[j] + (long long)f[j - 2] * g[n]) % mod;
}
cout << f[m] << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
bool dfs(int i, int j, vector<vector<int>>& a, int& sum, int n, int m) {
if (i + 1 < n && a[i + 1][j] == 0) dfs(i + 1, j, a, sum, n, m);
if (j + 1 < m && a[i][j + 1] == 0) dfs(i, j + 1, a, sum, n, m);
a[i][j] = min(a[i + 1][j], a[i][j + 1]) - 1;
if (a[i][j] <= a[i - 1][j] || a[i][j] <= a[i][j - 1]) {
return false;
}
sum += a[i][j];
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, sum = 0;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
sum += a[i][j];
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (a[i][j] == 0) {
if (!dfs(i, j, a, sum, n, m)) {
cout << -1 << endl;
return 0;
}
}
if (a[i - 1][j] >= a[i][j] || a[i][j - 1] >= a[i][j]) {
cout << -1 << endl;
return 0;
}
}
}
cout << sum << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> NameSet;
int NameSetLen, A[1010], B[1010], n, m, K;
struct Block {
vector<int> Peo, Key, Room;
void Check() {
sort(Peo.begin(), Peo.end());
sort(Key.begin(), Key.end());
sort(Room.begin(), Room.end());
}
};
bool operator==(Block A, Block B) {
return A.Peo == B.Peo && A.Key == B.Key && A.Room == B.Room;
}
struct Day {
vector<Block> ForBlocks;
vector<int> Key[1010];
vector<int> Room[1010];
int _Key[1010], Father[1010], _Room[1010];
bool bl[1010];
string Name[1010];
Block Tmp;
int Find(int x) { return (Father[x] == x) ? x : Father[x] = Find(Father[x]); }
void Solve() {
int i, j, k, l;
for (i = 1; i <= n; i++) Father[i] = i;
for (;;) {
for (i = 1; i <= m; i++)
if (Find(A[i]) != Find(B[i]) && (Find(_Room[_Key[i]]) == Find(A[i]) ||
Find(_Room[_Key[i]]) == Find(B[i])))
break;
if (i == m + 1) break;
Father[Find(A[i])] = Father[Find(B[i])];
}
for (i = 1; i <= n; i++)
if (Find(i) == i) {
Tmp.Peo.clear();
Tmp.Key.clear();
Tmp.Room.clear();
for (j = 1; j <= n; j++)
if (Find(j) == i) {
Tmp.Room.push_back(j);
for (k = Room[j].size() - 1; k >= 0; k--) {
Tmp.Peo.push_back(Room[j][k]);
for (l = Key[Room[j][k]].size() - 1; l >= 0; l--)
Tmp.Key.push_back(Key[Room[j][k]][l]);
}
}
Tmp.Check();
ForBlocks.push_back(Tmp);
}
}
void Read() {
string Name;
int i, j, k, l, room;
for (i = 0; i < K; i++) {
cin >> Name >> room;
if (!NameSet.count(Name)) NameSet[Name] = ++NameSetLen;
j = NameSet[Name];
Room[room].push_back(j);
_Room[j] = room;
cin >> k;
for (; k--;) {
cin >> l;
Key[j].push_back(l);
_Key[l] = j;
}
}
Solve();
}
} Thursday, Friday;
int main() {
cin >> n >> m >> K;
for (int i = 1; i <= m; i++) cin >> A[i] >> B[i];
Thursday.Read();
Friday.Read();
if (Thursday.ForBlocks == Friday.ForBlocks)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<long long>;
using VLL = vector<long long>;
using PII = pair<long long, long long>;
using PLL = pair<long long, long long>;
using VPII = vector<PII>;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
template <typename T>
T abs(T a) {
return a < 0 ? -a : a;
}
void solve() {
long long n;
cin >> n;
string p;
cin >> p;
long long cnt1 = 0, cnt2 = 0;
for (auto i = 0; i < (n - 1); ++i) {
if (p[i] == p[i + 1] && p[i] == '1') {
cnt1++;
}
if (p[i] == p[i + 1] && p[i] == '0') {
cnt2++;
}
}
cout << max(cnt1, cnt2) << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
struct Diameter {
int from, to, d;
};
P farthest(int u, int p, vector<vector<int>> &g) {
P r(0, u);
for (auto e : g[u]) {
if (e == p) continue;
P c = farthest(e, u, g);
c.first++;
r = max(r, c);
}
return r;
}
Diameter tree_diameter(vector<vector<int>> &g) {
P p = farthest(0, -1, g);
P q = farthest(p.second, -1, g);
return Diameter{p.second, q.second, q.first};
}
struct Lowlink {
const vector<vector<int>> &g;
vector<int> ord, low;
vector<int> articulation;
vector<P> bridge;
int k;
Lowlink(const vector<vector<int>> &g) : g(g) {}
virtual void dfs(int idx, int par) {
ord[idx] = k++;
low[idx] = ord[idx];
bool is_articulation = false;
int cnt = 0;
for (auto to : g[idx]) {
if (ord[to] < 0) {
++cnt;
dfs(to, idx);
low[idx] = min(low[idx], low[to]);
if (par != -1 && low[to] >= ord[idx]) is_articulation = true;
if (ord[idx] < low[to]) bridge.push_back(P(min(idx, to), max(idx, to)));
} else if (to != par) {
low[idx] = min(low[idx], ord[to]);
}
}
if (par == -1 && cnt > 1) is_articulation = true;
if (is_articulation) articulation.push_back(idx);
}
virtual void build() {
ord.assign(g.size(), -1);
low.assign(g.size(), 0);
k = 0;
for (int i = 0; i < (int)g.size(); i++) {
if (ord[i] < 0) dfs(i, -1);
}
}
};
struct TwoEdgeConnectedComponents : Lowlink {
vector<int> comp;
TwoEdgeConnectedComponents(vector<vector<int>> &g) : Lowlink(g) {}
void dfs(int idx, int par, int &k) {
if (par != -1 && ord[par] >= low[idx])
comp[idx] = comp[par];
else
comp[idx] = k++;
for (auto &to : g[idx]) {
if (comp[to] == -1) dfs(to, idx, k);
}
}
void build(vector<vector<int>> &t) {
Lowlink::build();
comp.assign(g.size(), -1);
int k = 0;
for (int i = 0; i < (int)g.size(); i++) {
if (comp[i] == -1) dfs(i, -1, k);
}
t.resize(k);
for (auto &e : bridge) {
int x = comp[e.first], y = comp[e.second];
t[x].push_back(y);
t[y].push_back(x);
}
}
int operator[](const int &k) { return comp[k]; }
};
int main() {
int n, m, u, v;
cin >> n >> m;
vector<vector<int>> g(n);
for (int i = 0; i < (int)m; i++) {
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
TwoEdgeConnectedComponents tecc(g);
vector<vector<int>> t;
tecc.build(t);
cout << tree_diameter(t).d << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, m, u, v;
vector<int> g[N], g2[N];
int vis[N], vis2[N];
string ans;
void DFS(int node) {
if (vis[node] == 2) return;
vis[node] = 1;
for (int i = 0; i < (int)g[node].size(); i++) {
if (vis[g[node][i]] == 1) {
puts("-1");
exit(0);
} else if (vis[g[node][i]] == 0)
DFS(g[node][i]);
}
vis[node] = 2;
}
void DFS2(int node) {
if (vis2[node] == 2) return;
vis2[node] = 1;
for (int i = 0; i < (int)g2[node].size(); i++) {
if (vis2[g2[node][i]] == 1) {
puts("-1");
exit(0);
} else if (vis2[g2[node][i]] == 0)
DFS2(g2[node][i]);
}
vis2[node] = 2;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
g[v].push_back(u);
g2[u].push_back(v);
}
ans.resize(n, 'E');
int all = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0 && vis2[i] == 0) {
all++;
ans[i - 1] = 'A';
}
DFS(i);
DFS2(i);
}
printf("%d\n", all);
puts(ans.c_str());
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 1e18;
long long r, n;
long long t[100005], x[100005], y[100005];
long long ans[100005];
long long tt[1000005];
long long mx[1000005];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> r >> n;
t[0] = 0, x[0] = 1, y[0] = 1;
long long ii = 0;
tt[0] = 0;
for (long long i = 1; i < n + 1; i++) {
ans[i] = -mod;
cin >> t[i] >> x[i] >> y[i];
mx[ii] = max(ans[i - 1], mx[ii]);
while (ii < t[i]) {
tt[ii] = i - 1;
ii++;
mx[ii] = mx[ii - 1];
}
long long val = tt[max(0ll, t[i] - 1 - 2000)];
for (long long j = i - 1; j >= val; j--) {
if (abs(x[j] - x[i]) + abs(y[j] - y[i]) <= t[i] - t[j]) {
ans[i] = max(ans[i], ans[j] + 1);
}
}
}
long long answer = 0;
for (long long i = 0; i < n + 1; i++) {
answer = max(answer, ans[i]);
}
cout << answer << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void no() {
cout << "NO\n";
exit(0);
}
void yes() { cout << "YES\n"; }
int nxt() {
int x;
cin >> x;
return x;
}
void query(vector<int> &a, vector<int> &res) {
int n = ((long long)a.size());
cout << "? ";
for (int i = (int)0; i < (int)n; i++) cout << char(a[i] + 'a');
cout << endl;
string s;
cin >> s;
for (int i = (int)0; i < (int)n; i++) {
res[i] = res[i] * 26 + (s[i] - 'a');
}
}
void solve() {
string s;
cin >> s;
int n = ((long long)s.size());
map<int, int> mp;
int it = 0;
vector<int> a, b, c;
for (int i = (int)0; i < (int)26; i++)
for (int j = (int)0; j < (int)26; j++)
for (int k = (int)0; k < (int)26; k++) {
if (it >= n) continue;
a.push_back(i), b.push_back(j), c.push_back(k);
mp[26 * 26 * i + 26 * j + k] = it++;
}
42;
vector<int> res(n);
query(a, res);
query(b, res);
query(c, res);
string ans = s;
for (int i = (int)0; i < (int)n; i++) {
int x = mp[res[i]];
ans[x] = s[i];
}
cout << "! " << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int tc = 1; tc <= t; tc++) {
solve();
}
}
| 14 |
#include <bits/stdc++.h>
const int N = 100010;
using namespace std;
int n;
long long x[N], c, d[N], b[N];
bitset<N> a[71];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d", x + i);
for (int i = 0; i < n; i++) {
c ^= x[i];
for (int j = 0; j < 63; j++) a[62 - j][i] = ((x[i] & (1ll << j)) > 0);
}
int tt = 0;
for (int i = 0; i < 63; i++) {
long long mask = 1ll << (62 - i);
if ((c & mask) == 0) {
a[69] = a[i];
for (int j = i; j > tt; j--) a[j] = a[j - 1];
a[tt++] = a[69];
}
}
int t = 0;
for (int i = 0; i < 63; i++) {
if (i < tt) a[i][n] = 1;
for (int j = 0; j < t; j++)
if (a[i][d[j]]) a[i] ^= a[j];
int p = 0;
for (; p < n && !a[i][p]; p++)
;
if (p == n)
a[i][n] = 0;
else {
for (int j = 0; j < t; j++)
if (a[j][p]) a[j] ^= a[i];
d[t] = p;
swap(a[t++], a[i]);
}
}
while (t--) b[d[t]] = a[t][n];
for (int i = 0; i < n; i++)
if (b[i])
cout << 1 << " ";
else
cout << 2 << " ";
cout << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r, R;
cin >> n >> R >> r;
if (n == 1) {
if (R < r)
cout << "NO" << endl;
else
cout << "YES" << endl;
} else if (R < 2 * r)
cout << "NO" << endl;
else {
double a = asin((double)r / (double)(R - r));
double m = acos(-1.) / a;
if (m + 1e-9 > n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] += k;
}
for (int i = 0; i < n; i++) {
if (a[i] <= 5) {
v.push_back(a[i]);
}
}
int s = v.size();
cout << s / 3 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long n, ans1, ans2, ans3;
int main() {
cin >> n;
ans1 = 1;
ans2 = 1;
ans3 = n - 2;
if (ans3 % 3 == 0) {
ans3--;
ans1++;
}
cout << ans1 << " " << ans2 << " " << ans3 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s, ss;
cin >> s >> ss;
long long int one_first = 0, one_second = 0;
for (auto it : s)
if (it == '1') one_first++;
for (auto it : ss)
if (it == '1') one_second++;
one_first += (one_first % 2);
if (one_first >= one_second)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long mod = 1e18;
const unsigned long long N = 2e5 + 5;
unsigned long long power(unsigned long long a, unsigned long long b) {
unsigned long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
return b ? gcd(b, a % b) : a;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
unsigned long long n, sum = 0;
cin >> n;
sum += ((n) / 1 * (n - 1) / 2 * (n - 2) / 3 * (n - 3) / 4 * (n - 4) / 5);
sum += ((n) / 1 * (n - 1) / 2 * (n - 2) / 3 * (n - 3) / 4 * (n - 4) / 5 *
(n - 5) / 6);
sum += ((n) / 1 * (n - 1) / 2 * (n - 2) / 3 * (n - 3) / 4 * (n - 4) / 5 *
(n - 5) / 6 * (n - 6) / 7);
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
multiset<long long> s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
long long x, y;
for (int(i) = 0; (i) < (n); i++) {
cin >> x >> y;
if (s.size() < k) {
s.insert(x + y);
cout << x + y << '\n';
} else {
long long t = max(x, *s.begin());
s.erase(s.begin());
s.insert(t + y);
cout << t + y << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int aa;
int count = 1;
int dd = 0;
cin >> aa;
if (aa < 0) aa = -aa;
while (dd < aa) {
dd += count;
count++;
}
count--;
if (dd == aa)
cout << count << endl;
else {
int vv = dd - aa;
if (vv % 2 == 0)
cout << count << endl;
else if ((count + 1) % 2) {
cout << count + 1 << endl;
} else
cout << count + 2 << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int vis[1005][1005], sp[1005], cnt[1005];
char s[1005][1005];
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
struct node {
int x, y, steps;
};
int main() {
int n, m, p;
cin >> n >> m >> p;
for (int i = 1; i <= p; i++) scanf("%d", &sp[i]);
queue<node> q[10];
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++)
if (s[i][j] >= '1' && s[i][j] <= '9') {
vis[i][j] = i;
cnt[s[i][j] - '0']++;
q[s[i][j] - '0'].push(node{i, j, 0});
} else if (s[i][j] == '#')
vis[i][j] = 10;
}
while (1) {
int ok = 0;
for (int i = 1; i <= p; i++)
if (!q[i].empty()) {
ok = 1;
break;
}
if (!ok) break;
for (int i = 1; i <= p; i++) {
queue<node> q2;
while (!q[i].empty()) {
q2.push(q[i].front());
q[i].pop();
}
while (!q2.empty()) {
node tmp = q2.front();
q2.pop();
int xx = tmp.x, yy = tmp.y;
for (int j = 0; j < 4; j++) {
int newx = xx + dx[j], newy = yy + dy[j], st = tmp.steps + 1;
if (!vis[newx][newy] && newx >= 1 && newx <= n && newy >= 1 &&
newy <= m && st <= sp[i]) {
q[i].push(node{newx, newy, 0});
q2.push(node{newx, newy, st});
vis[newx][newy] = 1;
cnt[i]++;
}
}
}
}
}
for (int i = 1; i <= p; i++) printf("%d ", cnt[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string alpha = "abcdefghijklmnopqrstuvwxyz";
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 5;
const long long nax = 101010;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
string C;
string A;
cin >> n >> C >> A;
long long na, nb, nc, nd, a, b, c, d;
na = nb = nc = nd = 0;
for (long long i = (0); i < (n); i++) {
if (C[i] == '0' && A[i] == '0') ++na;
if (C[i] == '0' && A[i] == '1') ++nb;
if (C[i] == '1' && A[i] == '0') ++nc;
if (C[i] == '1' && A[i] == '1') ++nd;
}
bool done = false;
for (b = 0; b <= nb; ++b) {
for (c = 0; c <= nc; ++c) {
long long z = nb + nd - b - c;
if (z % 2 == 0) {
d = z / 2;
if (d <= nd && d >= 0) {
a = (n / 2) - b - c - d;
if (a <= na && a >= 0) {
done = true;
}
}
}
if (done) break;
}
if (done) break;
}
if (!done) {
cout << -1;
exit(0);
}
vector<long long> res;
long long i = 0;
while (a > 0 || b > 0 || c > 0 || d > 0) {
if (C[i] == '0' && A[i] == '0' && a > 0) {
--a;
res.push_back(i + 1);
}
if (C[i] == '0' && A[i] == '1' && b > 0) {
--b;
res.push_back(i + 1);
}
if (C[i] == '1' && A[i] == '0' && c > 0) {
--c;
res.push_back(i + 1);
}
if (C[i] == '1' && A[i] == '1' && d > 0) {
--d;
res.push_back(i + 1);
}
++i;
}
for (long long x : res) cout << x << " ";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int p[100100];
int main() {
int n, i;
scanf("%d", &n);
if (n % 4 != 0 && n % 4 != 1) {
printf("-1\n");
return 0;
}
for (i = 1; i <= n / 2; i += 2) {
p[i] = i + 1;
p[i + 1] = n + 1 - i;
p[n - i + 1] = n - i;
p[n - i] = i;
}
if (n % 4 == 1) p[n / 2 + 1] = n / 2 + 1;
for (i = 1; i <= n; i++) printf("%d ", p[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, INF = 1e18, mx = 1e6 + 5, mn = 100;
int testCase = 1, cas = 0;
int main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
while (testCase--) {
long long n, l;
cin >> n >> l;
vector<long long> vec(n);
long long cnt = 0, a;
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
long long ans = 0, siz = vec.size();
for (int i = l; i < 101; i++) {
long long cnt = 0;
for (int j = 0; j < siz; j++) {
cnt += (vec[j] / i);
}
ans = max(ans, i * cnt);
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> res;
int getsum(int a) {
int r = a;
while (a) {
r += a % 10;
a /= 10;
}
return r;
}
int main(void) {
int n;
cin >> n;
res.clear();
int min = n > 90 ? n - 90 : 0;
for (int i = min; i != n; i++) {
if (getsum(i) == n) res.push_back(i);
}
if (res.size()) {
cout << res.size() << "\n";
for (int i = 0; i != res.size(); i++) cout << res[i] << "\n";
} else
cout << "0\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int mod = 1000000007;
inline void inc(int &x, int y) { (x += y) >= mod && (x -= mod); }
inline int mul(int x, int y) { return 1LL * x * y - 1LL * x * y / mod * mod; }
int n, k, m, ans;
struct matrix {
int mat[225][225];
void clear() { memset(mat, 0, sizeof(mat)); }
matrix(int x = 0) {
clear();
for (int i = 0; i < 225; ++i) mat[i][i] = x;
}
int *operator[](const int &x) { return mat[x]; }
friend matrix operator*(matrix &a, matrix &b) {
matrix res;
for (int i = 0; i < 225; ++i)
for (int j = 0; j < 225; ++j)
for (int k = 0; k < 225; ++k) inc(res[i][j], mul(a[i][k], b[k][j]));
return res;
}
friend matrix operator^(matrix a, long long b) {
matrix res(1);
while (b) {
if (b & 1) res *= a;
b >>= 1, a *= a;
}
return res;
}
matrix &operator*=(matrix &x) { return *this = *this * x; }
matrix &operator^=(long long x) { return *this = *this ^ x; }
} dp, trans;
inline int getid(int j, int mask) { return j * 16 + mask; }
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int j = 0; j <= k; ++j)
for (int mask = 0; mask < (1 << m); ++mask) {
int times = __builtin_popcount(mask) + 1;
trans[getid(j, mask)][getid(j, (mask << 1) & (1 << m) - 1)] = 1;
trans[getid(j, mask)][getid(j + 1, (mask << 1 | 1) & (1 << m) - 1)] =
times;
}
trans = trans ^ n;
dp[0][0] = 1;
dp = dp * trans;
for (int mask = 0; mask < (1 << m); ++mask) inc(ans, dp[0][getid(k, mask)]);
printf("%d\n", ans);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
long a[100500], b[100500];
long P = 1000;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long n, t, r, last = 0;
cin >> n >> t >> r;
for (int i = 0; i < n; i++) {
long x;
cin >> x;
a[P + x] = 1;
last = max(last, P + x);
}
long need = t, ans = 0;
for (int i = last; i >= 0; i--) {
if (a[i] == 1) {
need = r;
for (int j = i - t + 1; j <= i; j++) {
if (b[j] == 2) {
need--;
}
}
for (int j = i - t + 1; j <= i; j++) {
if (b[j] != 2 && need > 0) {
ans++;
need--;
b[j] = 2;
}
}
}
}
for (int i = last; i >= 300; i--) {
if (a[i] == 1) {
long cur = 0;
for (int j = i; j > i - t; j--) {
if (b[j] == 2) cur++;
}
if (cur < r) {
cout << "-1";
return (0);
}
}
}
cout << ans;
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false),cin.tie(nullptr),cout.tie(nullptr);
void calc(int u,vector<int> &vis, const vector<vector<int>> &adj,const vector<int> &dist, vector<int> &dp){
vis[u] = 1;
dp[u] = dist[u];
for(auto v : adj[u]){
if(!vis[v] && dist[u] < dist[v]){
calc(v,vis,adj,dist,dp);
}
if(dist[u] >= dist[v]){
dp[u] = min(dp[u] , dist[v]);
}
else{
dp[u] = min(dp[u], dp[v]);
}
}
}
int32_t main(){
fast;
int t;
cin >> t;
while(t--){
int n,m;
cin >> n >> m;
vector<vector<int>> adj(n + 1);
vector<int> dp(n + 1);
vector<int> dist(n + 1, -1);
for(int i = 0; i < m; i++){
int u,v;
cin >> u >> v;
--u;--v;
adj[u].push_back(v);
}
queue<int> q;
q.push(0);
dist[0] = 0;
while(q.size()){
int u = q.front();
q.pop();
for(auto v : adj[u]){
if(dist[v] == -1){
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
dp[0] = 0;
vector<int> vis(n + 1, 0);
calc(0,vis,adj,dist,dp);
for(int i = 0; i < n; i++){
cout << dp[i] << " \n"[i == n - 1];
}
}
} | 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
int f[110000], a[110000];
long long s[110000];
struct sb {
int x, y, z;
};
sb b[110000];
int n, m;
long long ans;
bool cmp(sb a, sb b) { return a.z > b.z; }
int find(int x) {
if (f[x] == x) return x;
f[x] = find(f[x]);
return f[x];
}
int main() {
int i, x, y;
sb t;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", a + i);
for (i = 1; i <= n; i++) f[i] = i, s[i] = 1;
for (i = 1; i <= m; i++) {
scanf("%d%d", &t.x, &t.y);
t.z = min(a[t.x], a[t.y]);
b[i] = t;
}
sort(b + 1, b + m + 1, cmp);
for (i = 1; i <= m; i++) {
x = find(b[i].x);
y = find(b[i].y);
if (x != y) {
ans += s[x] * s[y] * b[i].z;
f[x] = y;
s[y] += s[x];
}
}
printf("%lf\n", 1.0 * ans / n / (n - 1) * 2);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int dp[4][102][10002];
int main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin>>n;
vector<int> a(n+1), b(n+1);
vector<double> sol(n+1, 0);
int sumc=0, suml=0;;
for(int i=1;i<=n;++i){
cin>>a[i]>>b[i];
sumc+=a[i];
suml+=b[i];
}
for(int k=0;k<=n+1;++k){
for(int c=0;c<=sumc+1;++c){
dp[0][k][c]=dp[1][k][c]=-(1<<30);
}
}
dp[0][0][0]=dp[1][0][0]=0;
for(int ir=1;ir<=n;++ir){
for(int k=ir;~k;--k){
for(int c=sumc;~c;--c){
int i=ir%2;
if(c>=a[ir]&&k>0) dp[i][k][c]=max(dp[1-i][k][c], dp[1-i][k-1][c-a[ir]]+b[ir]);
else dp[i][k][c]=dp[1-i][k][c];
}
}
}
for(int c=0;c<=sumc;++c){
for(int k=1;k<=n;++k){
sol[k]=max(sol[k], min(dp[n%2][k][c]/2.0+suml/2.0, double(c)));
}
}
for(int i=1;i<=n;++i) cout<<fixed<<setprecision(10)<<sol[i]<<" ";
cout<<"\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int BASE = 1e9 + 7;
const int INF = 0x3f3f3f3f;
struct SegmentTree {
int st[6 * maxn], lp[6 * maxn];
int L[6 * maxn], R[6 * maxn];
void Build(int k, int x, int y) {
L[k] = x;
R[k] = y;
st[k] = 0;
lp[k] = -1;
if (L[k] == R[k]) return;
Build(k << 1, L[k], ((L[k] + R[k]) >> 1));
Build(k << 1 | 1, ((L[k] + R[k]) >> 1) + 1, R[k]);
}
void Propagate(int k) {
if (lp[k] == -1) return;
int v = lp[k];
lp[k] = -1;
lp[k << 1] = lp[k << 1 | 1] = v;
st[k << 1] = (long long)(R[k << 1] - L[k << 1] + 1) * (long long)v % BASE;
st[k << 1 | 1] =
(long long)(R[k << 1 | 1] - L[k << 1 | 1] + 1) * (long long)v % BASE;
}
void Update(int k, int i, int j, int v) {
if (L[k] > j || R[k] < i) return;
if (i <= L[k] && R[k] <= j) {
st[k] = (long long)(R[k] - L[k] + 1) * (long long)v % BASE;
lp[k] = v;
return;
}
Propagate(k);
Update(k << 1, i, j, v);
Update(k << 1 | 1, i, j, v);
st[k] = (st[k << 1] + st[k << 1 | 1]) % BASE;
}
int Query(int k, int i, int j) {
int res = 0;
if (L[k] > j || R[k] < i) return 0;
if (i <= L[k] && R[k] <= j) return st[k];
Propagate(k);
res += Query(k << 1, i, j) + Query(k << 1 | 1, i, j);
res %= BASE;
st[k] = (st[k << 1] + st[k << 1 | 1]) % BASE;
return res;
}
} Tree;
vector<pair<int, int> > In[maxn], Out[maxn];
int n, m, k;
int a[maxn], b[maxn], N;
set<pair<int, int> > S;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
In[x1].push_back(pair<int, int>(y1, y2));
Out[x2 + 1].push_back(pair<int, int>(y1, y2));
}
Tree.Build(1, 1, m);
Tree.Update(1, 1, 1, 1);
for (int k = 0; k < In[1].size(); ++k) S.insert(In[1][k]);
for (int i = 2; i <= n; ++i) {
N = 0;
for (int k = 0; k < In[i].size(); ++k) {
pair<int, int> T = In[i][k];
if (T.second + 1 > m) continue;
set<pair<int, int> >::iterator it =
S.upper_bound(pair<int, int>(T.second + 1, INF));
int Low = 0, High = T.second + 1;
if (it != S.begin()) {
--it;
Low = it->second;
}
a[++N] = (Low + 1 > High) ? 0 : Tree.Query(1, Low + 1, High);
b[N] = High;
}
for (int k = 1; k <= N; ++k) Tree.Update(1, b[k], b[k], a[k]);
for (int k = 0; k < Out[i].size(); ++k) S.erase(Out[i][k]);
for (int k = 0; k < In[i].size(); ++k) {
Tree.Update(1, In[i][k].first, In[i][k].second, 0);
S.insert(In[i][k]);
}
}
int Low = (S.empty()) ? 0 : (--S.end())->second;
int ans = Tree.Query(1, Low + 1, m);
printf("%d", ans);
return 0;
}
| 23 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-8;
const int MOD = 1e9 + 7;
const int N = 1e6 + 10;
using namespace std;
int a[N], b[N];
int main() {
ios::sync_with_stdio(false);
int n, m, p;
cin >> n >> m >> p;
int u = -1, v = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (u == -1 && a[i] % p != 0) u = i;
}
for (int i = 0; i < m; i++) {
cin >> b[i];
if (v == -1 && b[i] % p != 0) v = i;
}
cout << u + v << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void init_ios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const long long N = 2 * (long long)1e5 + 10;
long long n, a, b, last;
bool zm[N];
pair<long long, long long> x[N], po[N];
vector<pair<long long, long long> > v;
signed main() {
init_ios();
cin >> n >> a >> b;
long long pam = b;
for (long long i = 1; i <= n; ++i) {
cin >> x[i].first >> x[i].second;
po[i] = x[i];
if (x[i].first > x[i].second) v.push_back({x[i].first - x[i].second, i});
}
sort(v.begin(), v.end());
while (v.size() && b) {
auto p = v.back();
v.pop_back();
--b;
last = p.first;
x[p.second].second = x[p.second].first;
zm[p.second] = 1;
}
long long res = 0, res2 = 0;
long long pot = 1;
for (long long i = 1; i <= a; ++i) pot *= 2;
for (long long i = 1; i <= n; ++i) res += x[i].second;
if (pam == 0) {
cout << res << "\n";
return 0;
}
res2 = res;
for (long long i = 1; i <= n; ++i) {
long long now = pot * po[i].first;
if (now <= po[i].second) continue;
if (zm[i]) {
res2 = max(res2, res - x[i].second + now);
continue;
}
if (b) last = 0;
res2 = max(res2, res - x[i].second + now - last);
}
cout << res2 << "\n";
}
| 13 |
// after seeing discussions nice DP 10/10
/* dont stick to an approach */
#include <iostream>
#include <iomanip>
#include <cmath>
#include <string>
#include <algorithm>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
#include <numeric>
#include <cstdlib>
using namespace std;
typedef long long ll;
typedef unsigned long long int ull;
typedef long double ldb;
#define PB push_back
#define For(i, n) for (ll i = 0; i < n; i++)
#define trav(a,x) for (auto& a : x)
#define PYES cout<<"YES\n"
#define PNO cout<<"NO\n"
#define PYes cout<<"Yes\n"
#define PNo cout<<"No\n"
#define endl '\n'
#define sq(x) (x*x)
#define vll vector<ll>
#define rev(v) reverse(v.begin(),v.end())
#define srt(v) sort(v.begin(),v.end())
#define grtsrt(v) sort(v.begin(),v.end(),greater<int>())
#define mnv(v) *min_element(v.begin(),v.end())
#define mxv(v) *max_element(v.begin(),v.end())
#define all(v) v.begin(),v.end()
#define Fas ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
//--------------------------------------------functions-------------------------------------------------//
ll power(ll a,ll b){ll result=1;while(b>0){if(b%2 == 1){result *= a;} a *= a;b /= 2;}return result;}
//ll gcd(ll x,ll y){ll r;while(y!=0&&(r=x%y)!=0){x=y;y=r;}return y==0?x:y;}
ll countSetBits(ll x){ll Count=0;while(x>0){if(x&1) Count++;x=x>>1;}return Count;}
bool isPerfectSquare(ll n){ll sr = sqrt(n);if (sr * sr == n)return true;else return false;}
ll mod(ll x,ll M){return ((x%M + M)%M);}
ll add(ll a, ll b,ll M){return mod(mod(a,M)+mod(b,M),M);}
ll mul(ll a, ll b,ll M){return mod(mod(a,M)*mod(b,M),M);}
ll powerM(ll a,ll b,ll M){
ll res=1;
while(b){
if(b%2==1){
res=mul(a,res,M);
}
a=mul(a,a,M);b/=2;
}
return res;
}
//------------------------------------sieve of erantothenes-----------------------------------------------//
//ll MAXN=1e7+100;
//vector<ll> fact(MAXN);
//void sieve_of_erantothenes()
//{
// fact[1] = 1;
// for (ll i = 2; i <= MAXN; i++)
// fact[i] = i;
// for (ll i = 4; i <= MAXN; i += 2)
// fact[i] = 2;
// for (ll i = 3; i * i <= MAXN; i++){
// if (fact[i] == i){
// for (ll j = i * i; j <= MAXN; j += i)
// if (fact[j] == j)
// fact[j] = i;
// }
// }
//}
//----------------------------------------nCr mod------------------------------------------------------//
ll modInverse(ll n,ll M){
return powerM(n,M-2,M);
}
ll nCrM(ll n,ll r,ll M){
if(n<r) return 0;
if(r==0) return 1;
vector<ll> fact(n+1);
fact[0]=1;
for(ll i=1;i<=n;i++){
fact[i]=mul(fact[i-1],i,M);
}
return mul(mul(fact[n],modInverse(fact[r],M),M),modInverse(fact[n-r],M),M);
}
//-----------------------------------------------solve-----------------------------------------------------//
ll maxxn=(3*(1e5))+7;
ll M=998244353;
vll sto(maxxn);
void precalc(){
sto[0]=0;
sto[1]=0;
sto[2]=1;
for(ll i=3;i<maxxn;i++){
sto[i]=add(add(sto[i-1],mul(2,sto[i-2],M),M),powerM(2,i-2,M),M);
}
}
void solve(){
ll n,m;cin>>n>>m;
vector<string> vv(n);
ll cnt=0;
for(ll i=0;i<n;i++){
cin>>vv[i];
for(ll j=0;j<m;j++){
if(vv[i][j]!='*'){
cnt++;
}
}
}
vll ans;
for(ll i=0;i<n;i++){
ll curr=0;
for(ll j=1;j<m;j++){
if(vv[i][j]!=vv[i][j-1] && vv[i][j]=='*'){
if(j-curr!=1){
ans.PB(j-curr);
curr=j;
}
}else if(vv[i][j]!=vv[i][j-1] ){
curr=j;
}
}
if(vv[i][m-1]=='o' && m-curr!=1){
ans.PB(m-curr);
}
}
for(ll i=0;i<m;i++){
ll curr=0;
for(ll j=1;j<n;j++){
if(vv[j-1][i]!=vv[j][i] && vv[j][i]=='*'){
if(j-curr!=1){
ans.PB(j-curr);
curr=j;
}
}else if(vv[j-1][i]!=vv[j][i] ){
curr=j;
}
}
if(vv[n-1][i]=='o' && n-curr!=1){
ans.PB(n-curr);
}
}
ll fans=0;
for(ll i=0;i<ans.size();i++){
fans=add(fans,mul(sto[ans[i]],powerM(2,cnt-ans[i],M),M),M);
}
cout<<fans<<endl;
}
int main(){
Fas;
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
// ll t=0;
// cin>>t;
// while(t--)
precalc();
solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int a[100009], b[100009], ans[100009], n, m, mod;
int main() {
cin >> n >> m >> mod;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= m; i++) ans[i] += b[i], ans[n - m + 1 + i] -= b[i];
for (int i = 1; i <= n; i++) ans[i] += ans[i - 1];
for (int i = 1; i <= n; i++) cout << (a[i] + ans[i]) % mod << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
const long long INF = 1e18;
long long power(long long x, long long y) {
long long t = 1;
while (y > 0) {
if (y % 2)
y -= 1, t = t * x % mod;
else
y /= 2, x = x * x % mod;
}
return t;
}
vector<int> G[N];
int nw[N], sz[N], val[N], u[N], bst[N];
int dfs(int v, int p) {
bool leaf = 1;
u[v] = 1;
sz[v] = 0;
bst[v] = 0;
int ans = 0;
for (int i = 0; i < G[v].size(); ++i)
if (!nw[G[v][i]]) sz[v] = -1;
int sum = 1;
for (int i = 0; i < G[v].size(); ++i)
if (nw[G[v][i]] && G[v][i] != p) {
leaf = 0;
int to = G[v][i];
ans = max(ans, dfs(to, v));
if (sz[to] == -1) sz[v] = -1;
if (sz[v] != -1) sz[v] += sz[to];
if (sz[to] != -1) sum += sz[to];
}
if (sz[v] != -1) sz[v] += 1;
bst[v] = sum;
for (int i = 0; i < G[v].size(); ++i)
if (nw[G[v][i]] && G[v][i] != p) {
int to = G[v][i];
int s = bst[to];
if (sz[to] != -1) s -= sz[to];
ans = max(ans, bst[v] + s);
bst[v] = max(bst[v], s + sum);
}
ans = max(ans, bst[v]);
return ans;
}
int dfs2(int v, int p, int d) {
int sum = 1, tot = 0;
for (int i = 0; i < G[v].size(); ++i)
if (nw[G[v][i]] && G[v][i] != p) {
if (sz[G[v][i]] == -1)
tot++;
else
sum += sz[G[v][i]];
} else if (!nw[G[v][i]])
tot++;
int ans = sum;
bst[v] = sum;
for (int i = 0; i < G[v].size(); ++i)
if (nw[G[v][i]] && G[v][i] != p) {
int to = G[v][i];
int bad = tot - (sz[to] == -1), s = sum;
if (sz[to] != -1) s -= sz[to];
if (bad == 0) ans = max(ans, dfs2(to, v, d + s));
s = bst[to];
if (sz[to] != -1) s -= sz[to];
ans = max(ans, bst[v] + s + d);
bst[v] = max(bst[v], s + sum);
}
return ans;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &val[i]);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
}
int l = 1, r = N * 10;
while (r - l > 1) {
int m = (l + r) / 2;
memset(nw, 0, sizeof(nw));
memset(u, 0, sizeof(u));
for (int i = 0; i < n; ++i)
if (val[i] >= m) nw[i] = 1;
int ans = 0;
for (int i = 0; i < n; ++i)
if (nw[i] && u[i] == 0) {
ans |= (dfs(i, i) >= k);
ans |= (dfs2(i, i, 0) >= k);
}
if (ans)
l = m;
else
r = m;
}
printf("%d\n", l);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long k[200005], d[200005], a[200005];
bool dbrs[200005];
int main(void) {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> a[i];
long long p = 0;
for (long long i = 1; i <= m; ++i) cin >> k[i], p += (k[i] > 0);
long long s = 0;
for (long long i = 1; i <= m; ++i) d[i] = -k[i], s += d[i];
long long ans = 200005;
long long j = 1, dbr = 0;
for (long long i = 1; i <= n; ++i) {
d[a[i]]++;
s++;
if (d[a[i]] >= 0 && !dbrs[a[i]] && k[a[i]] > 0) dbrs[a[i]] = true, ++dbr;
while (j <= i && d[a[j]] > 0) {
--s;
--d[a[j]];
++j;
}
if (dbr == p) ans = min(ans, s);
}
if (ans == 200005) ans = -1;
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> a;
for (int i = 0, v; i < n; i++) {
cin >> v;
if (v != -1) {
a.push_back(v);
} else {
for (auto &x : a) {
x = 0;
}
}
}
long long ans = a.back();
int ind = n - 3, pow = n >> 1;
multiset<int> s;
while (ind >= 0) {
int i;
for (i = ind; ind - i + 1 <= pow; i--) {
s.insert(a[i]);
}
ans += *s.begin();
s.erase(s.begin());
ind = i;
pow /= 2;
}
cout << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 50;
int n;
struct Btree {
long long num, tag;
int cmx, cmi;
long long mi;
int left, right;
} tree[MAXN * 4];
void _clean(int x) {
if (tree[x].left == tree[x].right) return;
if (tree[x].tag == 0) return;
long long tag = tree[x].tag;
tree[x].tag = 0;
tree[x * 2].tag += tag;
tree[x * 2 + 1].tag += tag;
tree[x * 2].num += tag;
tree[x * 2 + 1].num += tag;
}
void _merge(int x) {
if (tree[x].left == tree[x].right) return;
tree[x].cmx = tree[x * 2].cmx + tree[x * 2 + 1].cmx;
tree[x].cmi = max(tree[x * 2].cmi, tree[x * 2 + 1].cmi);
tree[x].mi = min(tree[x * 2].mi, tree[x * 2 + 1].mi);
}
long long query(int x, int p) {
_clean(x);
if (tree[x].left == tree[x].right) {
return tree[x].num;
} else {
int mid = (tree[x].left + tree[x].right) / 2;
if (p <= mid) return query(x * 2, p);
return query(x * 2 + 1, p);
}
}
void _build(int x, int left, int right) {
tree[x].left = left;
tree[x].right = right;
tree[x].tag = tree[x].num = 0;
if (left == right) {
scanf("%lld", &tree[x].num);
} else {
int mid = (left + right) / 2;
_build(x * 2, left, mid);
_build(x * 2 + 1, mid + 1, right);
}
}
void _modify(int x, int left, int right, long long v) {
_clean(x);
if (left <= tree[x].left && tree[x].right <= right) {
tree[x].tag += v;
tree[x].num += v;
} else {
int mid = (tree[x].left + tree[x].right) / 2;
if (left <= mid) _modify(x * 2, left, right, v);
if (mid + 1 <= right) _modify(x * 2 + 1, left, right, v);
}
}
void _update(int x, int p) {
_clean(x);
if (tree[x].left == tree[x].right) {
long long prev = query(1, p - 1), next = query(1, p + 1);
if (next < prev) swap(next, prev);
long long now = tree[x].num;
tree[x].mi = abs(next - now);
tree[x].cmx = (now >= prev) && (now >= next);
if ((now < prev) && (now < next))
tree[x].cmi = p;
else
tree[x].cmi = 0;
} else {
int mid = (tree[x].left + tree[x].right) / 2;
if (p <= mid)
_update(x * 2, p);
else
_update(x * 2 + 1, p);
_merge(x);
}
}
int queryMX(int x, int left, int right) {
_clean(x);
if (left <= tree[x].left && tree[x].right <= right) {
return tree[x].cmx;
} else {
int ret = 0;
int mid = (tree[x].left + tree[x].right) / 2;
if (left <= mid) ret += queryMX(x * 2, left, right);
if (mid + 1 <= right) ret += queryMX(x * 2 + 1, left, right);
return ret;
}
}
int queryMI(int x, int left, int right) {
_clean(x);
if (left <= tree[x].left && tree[x].right <= right) {
return tree[x].cmi;
} else {
int ret = 0;
int mid = (tree[x].left + tree[x].right) / 2;
if (left <= mid) ret = max(ret, queryMI(x * 2, left, right));
if (mid + 1 <= right) ret = max(ret, queryMI(x * 2 + 1, left, right));
return ret;
}
}
long long queryX(int x, int left, int right) {
_clean(x);
if (left <= tree[x].left && tree[x].right <= right) {
return tree[x].mi;
} else {
long long ret = 2100000000;
int mid = (tree[x].left + tree[x].right) / 2;
if (left <= mid) ret = min(ret, queryX(x * 2, left, right));
if (mid + 1 <= right) ret = min(ret, queryX(x * 2 + 1, left, right));
return ret;
}
}
long long build(int n) {
_build(1, 1, n);
long long ret = 0;
for (int i = 2; i <= n - 1; i++) _update(1, i);
for (int i = 2; i <= n; i++) ret += abs(query(1, i) - query(1, i - 1));
return ret;
}
long long modify(int l, int r, long long v) {
long long ret = 0;
if (l > 1) ret -= abs(query(1, l) - query(1, l - 1));
if (r < n) ret -= abs(query(1, r) - query(1, r + 1));
_modify(1, l, r, v);
if (l > 1) {
_update(1, l);
ret += abs(query(1, l) - query(1, l - 1));
}
if (r < n) {
_update(1, r);
ret += abs(query(1, r) - query(1, r + 1));
}
if (l - 1 > 1) _update(1, l - 1);
if (r + 1 < n) _update(1, r + 1);
return ret;
}
long long query(int l, int r, long long x) {
if (queryMX(1, l, r) != 0) return 2LL * x;
long long ret = 0;
if (l > 1) {
long long a = query(1, l), b = query(1, l - 1);
ret = ret - abs(a - b) + abs(a + x - b);
}
if (l < n) {
long long a = query(1, l), b = query(1, l + 1);
ret = ret - abs(a - b) + abs(a + x - b);
}
int ll = max(2, l), rr = min(n - 1, r);
if (ll <= rr) {
int mp = queryMI(1, ll, rr);
if (mp == 0)
ret = max(ret, 2LL * max(0LL, x - queryX(1, ll, rr)));
else {
if (ll <= mp - 1)
ret = max(ret, 2LL * max(0LL, x - queryX(1, ll, mp - 1)));
if (mp + 1 <= rr)
ret = max(ret, 2LL * max(0LL, x - queryX(1, mp + 1, rr)));
if (mp > 1 && mp < n) {
long long lmp = query(1, mp - 1), rmp = query(1, mp + 1),
nmp = query(1, mp);
if (rmp < lmp) swap(rmp, lmp);
ret =
max(ret, 2LL * max(0LL, x - (rmp - nmp)) - 2LL * min(lmp - nmp, x));
}
}
}
if (l == 1) {
long long a = query(1, 1), b = query(1, 2);
ret = max(ret, abs(a + x - b) - abs(a - b));
}
if (r == n) {
long long a = query(1, n), b = query(1, n - 1);
ret = max(ret, abs(a + x - b) - abs(a - b));
}
return ret;
}
int main() {
scanf("%d", &n);
long long ans = build(n);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int p, l, r, x;
scanf("%d %d %d %d", &p, &l, &r, &x);
if (p == 2) {
ans += modify(l, r, x);
} else {
printf("%lld\n", ans + query(l, r, x));
}
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, i;
cin >> n >> a >> b;
long long h[n];
for (i = 0; i < n; i++) cin >> h[i];
sort(h, h + n);
cout << h[b] - h[b - 1] << endl;
}
| 0 |
#include <bits/stdc++.h>
void answer(int x, int y) { std::cout << x << ' ' << y << '\n'; }
void solve(unsigned l, unsigned r) {
const unsigned y = 2 * l;
if (y > r)
answer(-1, -1);
else
answer(l, y);
}
void test_case() {
unsigned l, r;
std::cin >> l >> r;
solve(l, r);
}
int main() {
size_t t;
std::cin >> t;
while (t-- > 0) test_case();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> mp;
int main() {
long long n;
cin >> n;
long long m = 2 * n;
long long a[m];
long long t = 0, ans = 0;
for (int i = 0; i < m; i++) {
cin >> a[i];
mp[a[i]]++;
if (mp[a[i]] == 1) {
t++;
} else {
t--;
}
ans = max(t, ans);
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, flag = 0;
cin >> n;
long long m[n], a[n], i;
for (int i = 1; i <= n; i++) cin >> m[i];
if (m[1] + m[2] <= m[n])
cout << "1 2 " << n << endl;
else
cout << "-1" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, sum;
long long a[110], k;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sum = 2;
for (int i = 1; i < n; i++) {
if (a[i] - a[i - 1] > 2 * k)
sum += 2;
else if (a[i] - a[i - 1] == 2 * k)
sum++;
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
map<int, int> m;
int n, x;
int main() {
int i, j, k;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> x;
m[x]++;
}
int t = 0, last;
for (map<int, int>::iterator it = m.begin(); it != m.end(); ++it) {
int x = it->first;
if (m[x] > 1) {
m[x + 1] += m[x] / 2;
m[x] %= 2;
}
if (m[x]) ++t;
last = x;
}
cout << last - t + 1;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 301;
const int MOD = 1e9 + 7;
int n, k, have[MAXN];
multiset<int> arr;
long long dp[MAXN][MAXN], com[2 * MAXN][2 * MAXN], fac[MAXN];
void inp() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
arr.insert(x);
}
return;
}
bool check(long long s) {
long double sq = sqrt(s);
return int(sq) == sq;
}
void build() {
while (arr.size()) {
have[++k] = 1;
auto it = arr.begin();
int local = *it;
set<int> delet;
delet.insert(local);
while (++it != arr.end()) {
if (check((long long)(*it) * local)) {
delet.insert(*it);
have[k]++;
}
}
for (auto i : delet) {
arr.erase(i);
}
}
return;
}
void comb_fac() {
for (int i = 0; i < 2 * MAXN; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i) {
com[j][i] = 1;
} else {
com[j][i] = (com[j][i - 1] + com[j - 1][i - 1]) % MOD;
}
}
}
fac[0] = 1;
for (int i = 1; i < MAXN; i++) {
fac[i] = (fac[i - 1] * i) % MOD;
}
return;
}
void dp_upt() {
int sig = 0;
for (int ind = 1; ind < k; ind++) {
sig += have[ind];
for (int now = 0; now < sig; now++) {
for (int i = max(0, now - have[ind + 1]); i <= now + have[ind + 1]; i++) {
for (int j = 0; j <= min(now, have[ind + 1]); j++) {
int remain = now - j;
remain = i - remain;
int me = have[ind + 1] - j;
if (remain < 0) {
continue;
}
if (remain > me) {
continue;
}
me -= remain;
dp[ind + 1][i] += (((dp[ind][now] * com[me][sig + 1 - now] % MOD) *
com[j][now] % MOD) *
com[j + me - 1][remain + j + me - 1]) %
MOD;
dp[ind + 1][i] %= MOD;
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
inp();
build();
comb_fac();
dp[1][have[1] - 1] = 1;
dp_upt();
for (int i = 1; i <= k; i++) {
dp[k][0] *= fac[have[i]];
dp[k][0] %= MOD;
}
cout << dp[k][0] << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
string G[2];
int dp[200008][20][2][2], n;
void init() {
for (int i = 0; i < 19; i++) {
for (int j = 0; j < 200008; j++) {
for (int a = 0; a < 2; a++)
for (int b = 0; b < 2; b++) dp[j][i][a][b] = 1e9;
}
}
for (int i = 0; i < n - 1; i++) {
for (int a = 0; a < 2; a++) {
for (int b = 0; b < 2; b++) {
if (G[a][i] == 'X' || G[b][i + 1] == 'X') continue;
if (a == b)
dp[i][0][a][b] = 1;
else {
if (G[a][i + 1] == 'X' && G[b][i] == 'X') continue;
dp[i][0][a][b] = 2;
}
}
}
}
for (int pw = 1; pw < 18; pw++) {
for (int i = 0; i < n; i++) {
if (i + (1 << pw) >= n) break;
for (int a = 0; a < 2; a++)
for (int b = 0; b < 2; b++)
for (int c = 0; c < 2; c++) {
dp[i][pw][a][b] =
min(dp[i][pw][a][b], dp[i][pw - 1][a][c] +
dp[i + (1 << (pw - 1))][pw - 1][c][b]);
}
}
}
}
int solve(int a, int b) {
int ay = a / n, by = b / n;
int ax = a % n, bx = b % n;
if (ax > bx) swap(ax, bx), swap(ay, by);
if (a == b) {
return 0;
} else if (ax == bx) {
if (G[ay][ax] == 'X' || G[by][bx] == 'X') return -1;
return 1;
}
int dist = bx - ax;
int ans[2], pdp[2];
ans[0] = ans[1] = 1e9;
ans[ay] = 0;
for (int bit = 0; bit <= 18; bit++) {
if (dist & (1 << bit)) {
pdp[0] = ans[0], pdp[1] = ans[1];
ans[0] = ans[1] = 1e9;
for (int a = 0; a < 2; a++)
for (int b = 0; b < 2; b++) {
ans[b] = min(ans[b], pdp[a] + dp[ax][bit][a][b]);
}
ax += (1 << bit);
}
}
return (ans[by] == 1e9) ? -1 : ans[by];
}
int main() {
int m;
cin >> n >> m;
for (int i = 0; i < 2; i++) cin >> G[i];
init();
int a, b;
while (m--) {
scanf("%d %d", &a, &b);
printf("%d\n", solve(a - 1, b - 1));
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 5;
const int base = 303;
const int mod = 1e9 + 9;
string s;
int n, res, f[N];
long long hash_fw[N], hash_bw[N], pw[N];
long long gethash_fw(int x, int y) {
return ((hash_fw[y] - hash_fw[x - 1] * pw[y + 1 - x]) % mod + mod) % mod;
}
long long gethash_bw(int x, int y) {
return ((hash_bw[x] - hash_bw[y + 1] * pw[y + 1 - x]) % mod + mod) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s;
n = s.size();
s = " " + s;
pw[0] = 1;
for (int i = 1; i <= n; i++) {
pw[i] = (pw[i - 1] * base) % mod;
hash_fw[i] = (hash_fw[i - 1] * base + (int)(s[i])) % mod;
}
for (int i = n; i >= 1; i--) {
hash_bw[i] = (hash_bw[i + 1] * base + (int)(s[i])) % mod;
}
for (int i = 1; i <= n; i++) {
if (gethash_fw(1, i) == gethash_bw(1, i)) {
f[i] = f[i / 2] + 1;
res += f[i];
} else {
f[i] = 0;
}
}
cout << res << '\n';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int ti = 0; ti < t; ti++) {
int n;
cin >> n;
vector<long long> a(n);
vector<long long> b;
b.reserve(n * 2);
b.push_back(0);
long long mel = 0, indm = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= mel) {
mel = a[i];
indm = i;
}
}
long long ans = 0;
if (indm == n - 1) {
ans = 0;
} else {
for (int i = n - 1; i > indm; i--) {
if (a[i] > b[b.size() - 1]) {
b.push_back(a[i]);
}
}
ans = b.size() - 1;
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long g() {
char c;
while (!isdigit(c = getchar()))
;
long long x = c - '0';
while (isdigit(c = getchar())) x = x * 10 + c - '0';
return x;
}
int s[100005];
int main() {
int n = g(), a = g(), b = g();
long long sum = 0;
for (int i = 0; i <= n - 1; i++) s[i] = g(), sum += s[i];
const int m = n - 1;
sort(s + 1, s + 1 + m, greater<int>());
double flow = s[0] * double(a) / sum;
if (flow >= b) return !printf("0\n");
int ans = 0;
for (int i = 1; i <= m; i++) {
sum -= s[i];
flow = s[0] * double(a) / sum;
++ans;
if (flow >= b) break;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, q, m, bm, l, r;
bool x[19][200005];
char y[19][200005][2][32];
int ta;
long long tb;
void cal(int a, int b) {
if (((1 << (a - 1)) * (b * 2 + 1)) < n) {
bool xa = x[a - 1][b * 2];
bool xb = x[a - 1][b * 2 + 1];
for (int i = 0; i <= bm; i++) {
y[a][b][0][i] = y[a - 1][b * 2][xa][y[a - 1][b * 2 + 1][xb][i]];
y[a][b][1][i] = y[a - 1][b * 2][xa ^ 1][y[a - 1][b * 2 + 1][xb ^ 1][i]];
}
} else {
bool xx = x[a - 1][b * 2];
for (int i = 0; i <= bm; i++) {
y[a][b][0][i] = y[a - 1][b * 2][xx][i];
y[a][b][1][i] = y[a - 1][b * 2][1 ^ xx][i];
}
}
}
void f1(int a, int b, int c, int d) {
if (((1 << (c)) * (d)) == a && ((1 << (c)) * (d + 1)) == b) {
x[c][d] ^= 1;
return;
}
c--;
d = d * 2 + 1;
if (b <= ((1 << (c)) * (d)))
f1(a, b, c, d - 1);
else if (a >= ((1 << (c)) * (d)))
f1(a, b, c, d);
else {
f1(a, ((1 << (c)) * (d)), c, d - 1);
f1(((1 << (c)) * (d)), b, c, d);
}
cal(c + 1, d / 2);
}
char f2(int a, int b, int c, int d, bool e, char f) {
e ^= x[c][d];
if (((1 << (c)) * (d)) == a && ((1 << (c)) * (d + 1)) == b)
return y[c][d][e][f];
c--;
d = d * 2 + 1;
if (b <= ((1 << (c)) * (d))) return f2(a, b, c, d - 1, e, f);
if (a >= ((1 << (c)) * (d))) return f2(a, b, c, d, e, f);
char tmp = f2(((1 << (c)) * (d)), b, c, d, e, f);
return f2(a, ((1 << (c)) * (d)), c, d - 1, e, tmp);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
bm = (1 << m) - 1;
for (int i = 0; i < n; i++) {
scanf("%d", &ta);
x[0][i] = ta & 1;
for (int j = 0; j <= bm; j++) {
y[0][i][0][j] = (j >> 1) | (1 << (m - 1));
y[0][i][1][j] = (j >> 1) | (1 << (m - 1));
}
y[0][i][0][bm] = (bm >> 1) | (1 << (m - 1));
y[0][i][1][bm] = bm >> 1;
}
for (int i = 1; i < 19; i++)
for (int j = 0; ((1 << (i)) * (j)) < n; j++) cal(i, j);
while (q--) {
scanf("%d%d%d", &ta, &l, &r);
l--;
if (ta == 1) {
scanf("%lld", &tb);
if (tb & 1) f1(l, r, 18, 0);
} else
printf("%d\n", 2 - (f2(l, r, 18, 0, 0, bm) >> (m - 1)));
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
int z[maxn], a[maxn], b[maxn];
int main() {
int n, su = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", z + i);
if (z[i] == 2) ++su;
}
for (int i = 1; i <= n; ++i) {
if (z[i] == 1)
a[i] = a[i - 1] + 1;
else
a[i] = a[i - 1] - 1;
}
b[n + 1] = -23333333;
for (int i = n; i > 0; --i) b[i] = max(a[i], b[i + 1]);
int ans = -23333333;
int g = 0;
for (int i = 1; i <= n; ++i) {
int g = 0;
g = max(g, a[i - 1]);
ans = max(ans, g);
int f = a[i - 1];
int ma = a[i - 1];
int t;
for (int j = i; j <= n; ++j) {
if (z[j] == 1) {
t = f + 1;
ma = max(t, ma + 1);
} else {
t = f - 1;
ma = max(t, ma - 1);
}
ans = max(ans, max(ma, b[j + 1]));
}
}
printf("%d\n", ans + su);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long st[4005][4005], f[4005];
int C[4005][4005];
void Stirling() {
for (int i = 0; i < 4005; i++) st[i][0] = st[i][1] = 1;
for (int i = 2; i < 4005; i++)
for (int j = 2; j <= i; j++)
st[i][j] = (st[i - 1][j - 1] + j * st[i - 1][j]) % 1000000007;
for (int i = 0; i < 4005; i++)
for (int j = 1; j <= i; j++) f[i] = (f[i] + st[i][j]) % 1000000007;
}
void C0() {
for (int i = 0; i < 4005; i++) C[i][0] = C[i][i] = 1;
for (int i = 1; i < 4005; i++)
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
Stirling();
f[0] = 1;
C0();
long long ans = 0;
for (int i = 0; i <= n - 1; i++)
ans = (ans + (C[n][i] * (long long)f[i]) % 1000000007) % 1000000007;
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 20) + 5;
long long a[maxn], b[maxn], mod;
int d[maxn];
long long mul_mod(long long a, long long b) {
return (a * b - (long long)(a / (long double)mod * b + 1e-3) * mod + mod) %
mod;
}
long long pow_mod(long long a, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = mul_mod(ret, a);
a = mul_mod(a, a);
n >>= 1;
}
return ret;
}
void fwt(long long *a, int l, int r) {
if (r - l == 1) return;
int mid = (l + r) >> 1, len = mid - l;
fwt(a, l, mid);
fwt(a, mid, r);
for (int i = l; i < mid; ++i) {
long long u = a[i], v = a[i + len];
a[i] = (u + v) % mod;
a[i + len] = (u - v + mod) % mod;
}
}
void ifwt(long long *a, int l, int r) {
if (r - l == 1) return;
int mid = (l + r) >> 1, len = mid - l;
for (int i = l; i < mid; ++i) {
long long u = a[i], v = a[i + len];
a[i] = (u + v) % mod;
a[i + len] = (u - v + mod) % mod;
}
ifwt(a, l, mid);
ifwt(a, mid, r);
}
int cal(int x) {
int ret = 0;
while (x) {
++ret;
x -= x & -x;
}
return ret;
}
int main() {
int m;
long long t;
scanf("%d%I64d%I64d", &m, &t, &mod);
int len = 1 << m;
mod <<= m;
for (int i = 0; i < len; ++i) {
scanf("%I64d", a + i);
a[i] %= mod;
}
for (int i = 0; i <= m; ++i) {
scanf("%d", d + i);
d[i] %= mod;
}
for (int i = 0; i < len; ++i) b[i] = d[cal(i)];
fwt(a, 0, len);
fwt(b, 0, len);
for (int i = 0; i < len; ++i) a[i] = mul_mod(a[i], pow_mod(b[i], t));
ifwt(a, 0, len);
mod >>= m;
for (int i = 0; i < len; ++i) {
printf("%I64d\n", a[i] >> m);
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
char getc() {
char c = getchar();
while ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c > '9'))
c = getchar();
return c;
}
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
int n, m, a[600010], p[600010], dfn[600010], fa[600010][20], deep[600010],
f[600010 << 1], F[600010 << 1][2], pre[600010 << 1], suf[600010 << 1], t, T,
cnt, stk[600010], top;
vector<int> pos[600010];
struct data {
int to, nxt;
} edge[600010 << 1], tree[600010 << 2];
void addedge(int x, int y) {
t++;
edge[t].to = y, edge[t].nxt = p[x], p[x] = t;
}
void new_addedge(int x, int y) {
T++;
tree[T].to = y, tree[T].nxt = p[x], p[x] = T;
}
void dfs(int k) {
dfn[k] = ++cnt;
for (int i = p[k]; i; i = edge[i].nxt)
if (edge[i].to != fa[k][0]) {
fa[edge[i].to][0] = k;
deep[edge[i].to] = deep[k] + 1;
dfs(edge[i].to);
}
}
bool cmp(const int& a, const int& b) { return dfn[a] < dfn[b]; }
int lca(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int j = 19; ~j; j--)
if (deep[fa[x][j]] >= deep[y]) x = fa[x][j];
if (x == y) return x;
for (int j = 19; ~j; j--)
if (fa[x][j] != fa[y][j]) x = fa[x][j], y = fa[y][j];
return fa[x][0];
}
bool paint(int x, int y, int color) {
while (x != y) {
if (f[x] > n && f[x] != color) return 1;
f[x] = color;
x = fa[x][0];
}
return 0;
}
void dp(int k, int from) {
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) dp(tree[i].to, k);
if (k > n) {
F[k][0] = 0;
F[k][1] = 1;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from)
F[k][1] =
1ll * F[k][1] * (F[tree[i].to][0] + F[tree[i].to][1]) % 998244353;
} else {
F[k][0] = 1;
int cnt = 0;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) {
F[k][0] =
1ll * F[k][0] * (F[tree[i].to][0] + F[tree[i].to][1]) % 998244353;
pre[++cnt] = F[tree[i].to][0] + F[tree[i].to][1];
}
for (int i = 1; i <= cnt; i++) suf[i] = pre[i];
pre[0] = 1;
for (int i = 1; i <= cnt; i++)
pre[i] = 1ll * pre[i - 1] * pre[i] % 998244353;
suf[cnt + 1] = 1;
for (int i = cnt; i >= 1; i--)
suf[i] = 1ll * suf[i] * suf[i + 1] % 998244353;
int t = 0;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) {
t++;
F[k][1] = (F[k][1] + 1ll * pre[t - 1] * suf[t + 1] % 998244353 *
F[tree[i].to][1]) %
998244353;
}
}
}
signed main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read();
addedge(x, y), addedge(y, x);
}
fa[1][0] = 1;
dfs(1);
for (int j = 1; j < 20; j++)
for (int i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
for (int i = 1; i <= n; i++)
if (a[i])
f[i] = n + a[i], pos[a[i]].push_back(i);
else
f[i] = i;
for (int i = 1; i <= m; i++)
if (pos[i].size() > 1) {
sort(pos[i].begin(), pos[i].end(), cmp);
int root = (*pos[i].begin());
for (int j = 0; j < pos[i].size() - 1; j++)
if (deep[lca(pos[i][j], pos[i][j + 1])] < deep[root])
root = lca(pos[i][j], pos[i][j + 1]);
if (f[root] > n && f[root] != n + i) {
cout << 0;
return 0;
}
top = 0;
stk[++top] = root;
f[root] = n + i;
for (int j = ((*pos[i].begin()) == root); j < pos[i].size(); j++) {
int l = lca(stk[top], pos[i][j]);
if (l != stk[top]) {
while (top > 1 && deep[l] <= deep[stk[top - 1]]) {
if (paint(stk[top], stk[top - 1], n + i)) {
cout << 0;
return 0;
}
top--;
}
if (paint(stk[top], l, n + i)) {
cout << 0;
return 0;
}
stk[top] = l;
}
stk[++top] = pos[i][j];
}
while (top > 1) {
if (paint(stk[top], stk[top - 1], n + i)) {
cout << 0;
return 0;
}
top--;
}
}
memset(p, 0, sizeof(p));
for (int i = 1; i <= t; i += 2)
if (f[edge[i].to] != f[edge[i + 1].to])
new_addedge(f[edge[i].to], f[edge[i + 1].to]),
new_addedge(f[edge[i + 1].to], f[edge[i].to]);
dp(n + 1, n + 1);
cout << F[n + 1][1];
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100;
long long N, M, K, P;
long long a[1010][1010];
priority_queue<long long> q1, q2;
long long cnt1[MAXN + 1], cnt2[MAXN + 1];
void solve() {
cin >> N >> M >> K >> P;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= N; i++) {
int sum = 0;
for (int j = 1; j <= M; j++) {
sum += a[i][j];
}
q1.push(sum);
}
for (int j = 1; j <= M; j++) {
int sum = 0;
for (int i = 1; i <= N; i++) {
sum += a[i][j];
}
q2.push(sum);
}
for (int i = 1; i <= MAXN; i++) {
long long tmp = q1.top();
cnt1[i] = cnt1[i - 1] + tmp;
q1.pop();
tmp -= P * M;
q1.push(tmp);
}
for (int i = 1; i <= MAXN; i++) {
long long tmp = q2.top();
cnt2[i] = cnt2[i - 1] + tmp;
q2.pop();
tmp -= P * N;
q2.push(tmp);
}
long long ans = -1e18;
for (int i = 0; i <= K; i++) {
ans = max(ans, cnt1[i] + cnt2[K - i] - i * (K - i) * P);
}
cout << ans << endl;
}
void Times(int T) {
while (T--) {
solve();
}
}
int main() {
int T;
T = 1;
Times(T);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int d[400], n, b[400];
int main() {
scanf("%d", &n);
for (int i = 0; i < 400; i++) d[i] = 0;
int curr = 0;
for (int xxx = 0; xxx < n; xxx++) {
int b;
scanf("%d", &b);
for (int j = 0;; j++) {
if (d[j] == 9) {
curr -= d[j];
d[j] = 0;
continue;
}
int lim = 9 - d[j] + j * 9;
if (curr + lim >= b && curr < b) {
d[j]++;
curr++;
lim = b - curr;
for (int i = 0; i < j; i++) {
if (lim > 9) {
d[i] = 9;
lim -= 9;
} else {
d[i] = lim;
lim = 0;
break;
}
}
if (lim != 0) d[j] += lim;
break;
}
curr -= d[j];
d[j] = 0;
}
curr = b;
int flag = 0;
for (int i = 390; i >= 0; i--) {
if (d[i] != 0) flag = 1;
if (flag) printf("%d", d[i]);
}
printf("\n");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct Seg_tree {
int left, right;
int size;
long long hash1, hash2;
} L[200005 << 2];
int n, m;
int a[200005], b[200005], p[200005];
long long fact_2[200005] = {1}, fact_1[200005] = {1};
long long hash_a_1, hash_a_2;
long long sum_1, sum_2;
void bulid(int step, int l, int r) {
L[step].left = l;
L[step].right = r;
L[step].hash1 = L[step].hash2 = 0LL;
L[step].size = 0;
if (l == r) return;
int m = (l + r) >> 1;
bulid(step << 1, l, m);
bulid(step << 1 | 1, m + 1, r);
}
void push_up(int step) {
L[step].size = L[step << 1].size + L[step << 1 | 1].size;
L[step].hash1 = L[step << 1].hash1 * fact_1[L[step << 1 | 1].size] +
L[step << 1 | 1].hash1;
L[step].hash2 = L[step << 1].hash2 * fact_2[L[step << 1 | 1].size] +
L[step << 1 | 1].hash2;
}
void update(int step, int pos, int val, int k) {
if (L[step].left == pos && L[step].right == pos) {
L[step].size += k;
L[step].hash1 += k * val;
L[step].hash2 += k * val;
return;
}
int m = (L[step].left + L[step].right) >> 1;
if (pos <= m)
update(step << 1, pos, val, k);
else
update(step << 1 | 1, pos, val, k);
push_up(step);
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
hash_a_1 = hash_a_2 = 0;
sum_1 = sum_2 = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
hash_a_1 = hash_a_1 * 1000003LL + a[i];
hash_a_2 = hash_a_2 * 999997LL + a[i];
sum_1 += fact_1[i - 1];
sum_2 += fact_2[i - 1];
fact_1[i] = fact_1[i - 1] * 1000003LL;
fact_2[i] = fact_2[i - 1] * 999997LL;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
p[b[i]] = i;
}
int ans = 0;
bulid(1, 1, m);
for (int i = 1; i <= m; i++) {
update(1, p[i], i, 1);
if (i > n) update(1, p[i - n], i - n, -1);
int d = i - n;
if (d >= 0 && L[1].hash1 == d * sum_1 + hash_a_1 &&
L[1].hash2 == d * sum_2 + hash_a_2)
ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 100 + 2;
int numOf[maxn];
int lastAcc[maxn];
int main() {
ios_base::sync_with_stdio(false);
memset(numOf, 0, sizeof(numOf));
memset(lastAcc, -1, sizeof(lastAcc));
int n, k;
cin >> n >> k;
vector<int> nums;
int temp;
int cur = 0;
int l = -1, r = -1;
bool ff = false;
for (int i = 0; i < n; i++) {
if (cur >= k) {
cin >> temp;
continue;
}
cin >> temp;
if (numOf[temp] == 0) {
cur++;
nums.push_back(temp);
lastAcc[temp] = i;
} else if (numOf[temp] > 0) {
lastAcc[temp] = i;
}
if (!ff && cur == k) {
r = i;
ff = true;
}
numOf[temp]++;
}
if (cur < k) {
cout << "-1 -1" << endl;
return 0;
}
int minnn = 1000 * 100 + 3;
for (int i = 0; i < k; i++) {
if (lastAcc[nums[i]] < minnn) {
minnn = lastAcc[nums[i]];
}
}
l = minnn;
cout << l + 1 << " " << r + 1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool SR(int &x) { return scanf("%d", &x) == 1; }
bool SR(long long &x) { return scanf("%lld", &x) == 1; }
bool SR(double &x) { return scanf("%lf", &x) == 1; }
bool SR(char *s) { return scanf("%s", s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &x, T &...tail) {
return SR(x) && RI(tail...);
}
void SP(const int x) { printf("%d", x); }
void SP(const long long x) { printf("%lld", x); }
void SP(const double x) { printf("%.16lf", x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I x, const T... tail) {
SP(x);
if (sizeof...(tail)) putchar(' ');
PL(tail...);
}
const int maxn = 2e5 + 5;
const int MOD = 1e9;
int f[maxn], sf[maxn];
void predo() {
f[0] = 0;
f[1] = 1;
for (int i = (2); i <= int(maxn - 1); i++) f[i] = (f[i - 1] + f[i - 2]) % MOD;
for (int i = (1); i <= int(maxn - 1); i++) sf[i] = (sf[i - 1] + f[i]) % MOD;
}
struct Node {
int s1, s2, siz;
Node() {}
Node(int _1, int _2, int _s) : s1(_1), s2(_2), siz(_s) {}
Node operator+(const Node &o) const {
return Node((s1 + 1LL * o.s2 * f[siz] + 1LL * o.s1 * f[siz - 1]) % MOD,
(s2 + 1LL * o.s2 * f[siz + 1] + 1LL * o.s1 * f[siz]) % MOD,
siz + o.siz);
}
void eat(int k) {
s1 = (s1 + 1LL * k * sf[siz]) % MOD;
s2 = (s2 + 1LL * k * (sf[siz + 1] + MOD - sf[1])) % MOD;
}
};
struct Seg {
Node dat[4 * maxn];
int tag[4 * maxn];
void push(int x, int low, int high) {
if (tag[x]) {
for (int i = (x << 1); i <= int(x << 1 | 1); i++) {
dat[i].eat(tag[x]);
tag[i] = (tag[i] + tag[x]) % MOD;
}
tag[x] = 0;
}
}
void pull(int x, int low, int high) {
dat[x] = dat[x << 1] + dat[x << 1 | 1];
}
void init(int x, int low, int high, int *a) {
if (low == high) {
dat[x] = Node(a[low], a[low], 1);
return;
}
int mid = (low + high) / 2;
init(x << 1, low, mid, a);
init(x << 1 | 1, mid + 1, high, a);
pull(x, low, high);
}
void fix(int x, int low, int high, int pos, int val) {
if (low == high) {
dat[x] = Node(val, val, 1);
return;
}
int mid = (low + high) / 2;
push(x, low, high);
if (pos <= mid)
fix(x << 1, low, mid, pos, val);
else
fix(x << 1 | 1, mid + 1, high, pos, val);
pull(x, low, high);
}
void add(int x, int low, int high, int a, int b, int v) {
if (low == a && b == high) {
dat[x].eat(v);
tag[x] = (tag[x] + v) % MOD;
return;
}
int mid = (low + high) / 2;
push(x, low, high);
if (b <= mid)
add(x << 1, low, mid, a, b, v);
else if (mid + 1 <= a)
add(x << 1 | 1, mid + 1, high, a, b, v);
else
add(x << 1, low, mid, a, mid, v),
add(x << 1 | 1, mid + 1, high, mid + 1, b, v);
pull(x, low, high);
}
Node ask(int x, int low, int high, int a, int b) {
if (low == a && b == high) return dat[x];
int mid = (low + high) / 2;
push(x, low, high);
Node ret;
if (b <= mid)
ret = ask(x << 1, low, mid, a, b);
else if (mid + 1 <= a)
ret = ask(x << 1 | 1, mid + 1, high, a, b);
else
ret = ask(x << 1, low, mid, a, mid) +
ask(x << 1 | 1, mid + 1, high, mid + 1, b);
pull(x, low, high);
return ret;
}
} seg;
int n, m;
int a[maxn];
void read() {
RI(n, m);
for (int i = (1); i <= int(n); i++) RI(a[i]);
}
void build() { seg.init(1, 1, n, a); }
void sol() {
while (m--) {
int op;
RI(op);
if (op == 1) {
int p, v;
RI(p, v);
seg.fix(1, 1, n, p, v);
} else if (op == 2) {
int l, r;
RI(l, r);
PL(seg.ask(1, 1, n, l, r).s1);
} else {
int l, r, v;
RI(l, r, v);
seg.add(1, 1, n, l, r, v);
}
}
}
int main() {
predo();
read();
build();
sol();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, B = 350;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int n, m, a[N], p[N], pos[N], L[N], R[N], size;
long long f[N], ans;
inline bool cmp(int i, int j) { return a[i] < a[j]; }
struct block {
int l, r, q[B];
long long k, b;
inline long long calc(int i) { return f[i] + k * a[i] + b; }
inline long double slope(int i, int j) {
if (a[i] == a[j]) return f[i] > f[j] ? -inf : inf;
return 1.0L * (f[i] - f[j]) / (a[i] - a[j]);
}
inline void build(int x) {
for (int i = L[x]; i <= R[x]; i++) f[i] += k * a[i] + b;
k = b = r = 0;
l = 1;
for (int i = L[x]; i <= R[x]; i++) {
while (l < r && slope(q[r - 1], q[r]) < slope(q[r], p[i])) r--;
q[++r] = p[i];
}
}
inline pair<long long, int> query(void) {
while (l < r && calc(q[l]) <= calc(q[l + 1])) l++;
return make_pair(calc(q[l]), q[l]);
}
} t[B];
int main() {
ios::sync_with_stdio(false);
cin >> n;
m = sqrt(n);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) f[i] = a[i];
for (int i = 1; i <= n; i++) pos[i] = (i - 1) / m + 1;
for (int i = 1; i <= n; i++) p[i] = i;
size = pos[n];
for (int i = 1; i <= size; i++) {
L[i] = R[i - 1] + 1;
R[i] = min(n, i * m);
for (int j = L[i]; j <= R[i]; j++) pos[j] = i;
sort(p + L[i], p + R[i] + 1, cmp);
}
for (int i = 1; i <= size; i++) t[i].build(i);
while (true) {
pair<long long, int> res = make_pair(0ll, 0);
for (int i = 1; i <= size; i++) res = max(res, t[i].query());
if (!res.first) {
cout << ans << endl;
return 0;
}
ans += res.first;
f[res.second] = -inf;
for (int i = 1; i < pos[res.second]; i++) t[i].b += a[res.second];
for (int i = L[pos[res.second]]; i < res.second; i++) f[i] += a[res.second];
for (int i = res.second + 1; i <= R[pos[res.second]]; i++) f[i] += a[i];
for (int i = pos[res.second] + 1; i <= size; i++) t[i].k++;
t[pos[res.second]].build(pos[res.second]);
}
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
long long powermod(long long a, long long b, long long c) {
long long ans = 1, tempans = a % c;
while (b > 0) {
if (b & 1 == 1) {
ans = (ans * tempans) % c;
}
tempans = (tempans * tempans) % c;
b = b >> 1;
}
return ans;
}
long long modinverse(long long a, long long m) { return powermod(a, m - 2, m); }
void solve() {
long long a, b;
cin >> a >> b;
string s;
cin >> s;
long long n = s.length();
string temp(n, '0');
if (s == temp) {
cout << 0 << endl;
return;
}
long long ans = a;
long long firstone, lastone;
for (long long i = 0; i < n; i++) {
if (s[i] == '1') {
firstone = i;
break;
}
}
for (long long i = n - 1; i >= 0; i--) {
if (s[i] == '1') {
lastone = i;
break;
}
}
for (long long i = firstone; i <= lastone;) {
if (s[i] == '1') {
i++;
continue;
}
long long count = 0;
while (i <= lastone && s[i] == '0') {
count++;
i++;
}
ans += min(count * b, a);
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
cin >> t;
long long count = 0;
while (t--) {
count++;
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, cur, ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> x;
if (cur + x > m) {
cur = 0;
ans++;
cur = x;
} else
cur += x;
}
cout << ans + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 150;
const int sz = 1 << 21;
const long long INF = 2e18;
int n, m, b, k[maxn], p[maxn], mask[maxn], x[maxn];
long long dp[sz];
bool cmp(int X, int Y) { return k[X] < k[Y]; }
int main() {
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
p[i] = i;
int a;
cin >> x[i] >> k[i] >> a;
while (a--) {
int x;
cin >> x;
--x;
mask[i] |= (1 << x);
}
}
sort(p + 1, p + 1 + n, cmp);
memset(dp, 63, sizeof dp);
dp[0] = 0;
long long ans = INF;
for (int i = 1; i <= n; i++) {
for (int j = (1 << m) - 1; j >= 0; j--)
dp[j] = min(dp[j], dp[j & (~mask[p[i]])] + x[p[i]]) +
1LL * (k[p[i]] - k[p[i - 1]]) * b;
ans = min(ans, dp[(1 << m) - 1]);
}
cout << (ans == INF ? -1 : ans) << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int x[110], y[110];
int main() {
int n, a, b;
scanf("%d%d%d", &n, &a, &b);
for (int i = 0; i < n; i++) scanf("%d%d", &x[i], &y[i]);
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b)
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
if (x[i] + x[j] <= b && max(y[i], y[j]) <= a)
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
if (y[i] + y[j] <= a && max(x[i], x[j]) <= b)
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
if (y[i] + y[j] <= b && max(x[i], x[j]) <= a)
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
if (x[i] + y[j] <= a && max(x[j], y[i]) <= b)
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
if (x[i] + y[j] <= b && max(x[j], y[i]) <= a)
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
if (x[j] + y[i] <= a && max(x[i], y[j]) <= b)
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
if (x[j] + y[i] <= b && max(x[i], y[j]) <= a)
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 2003;
int a[nax] = {0}, n;
int main() {
int tc;
cin >> tc;
while (tc--) {
vector<int> v[27];
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
v[a[i]].push_back(i);
}
int max1 = 0;
for (int i = 1; i <= 26; ++i) {
if (v[i].empty()) continue;
max1 = max(max1, (int)v[i].size());
}
for (int i = 1; i <= 26; ++i) {
if (v[i].empty()) continue;
for (int j = 1; j <= 26; ++j) {
if (v[j].empty()) continue;
int k = v[i].size();
if (i == j) continue;
for (int z = 0; z < (k + 1) / 2; ++z) {
int j1 =
lower_bound(v[j].begin(), v[j].end(), v[i][z]) - v[j].begin();
int j2 = lower_bound(v[j].begin(), v[j].end(), v[i][k - 1 - z]) -
v[j].begin();
j2--;
if (j2 >= j1) max1 = max(max1, j2 - j1 + 1 + 2 * (z + 1));
}
}
}
cout << max1 << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[650];
bool vis[650];
int main() {
int m, t, r, i, j, k, ans = 0, x, z;
bool b;
scanf("%d %d %d", &m, &t, &r);
int w[m + 2];
for (i = 0; i < m; i++) scanf("%d", &w[i]);
if (r > t) {
cout << "-1" << endl;
return 0;
}
for (i = 0; i < 650; i++) a[i] = 0;
for (i = 0; i < 650; i++) vis[i] = false;
for (i = m - 1; i >= 0; i--) {
x = w[i] + 305;
k = r;
j = x - t;
z = 0;
b = false;
while (k > 0) {
if (a[x] >= r) {
b = true;
break;
}
if (vis[j] == true) {
j++;
continue;
}
if (j >= x && a[x] < r) {
b = false;
break;
}
vis[j] = true;
a[j] += z;
j++;
z++;
k--;
if (a[x] + z >= r) {
for (j; j <= x; j++) a[j] += z;
b = true;
break;
}
}
if (b == false) break;
}
if (b == false)
cout << "-1" << endl;
else {
for (i = 0; i < 650; i++) {
if (vis[i]) ans++;
}
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e9 + 1;
const double pi = 3.1415926535897932384626433832;
const long long M = 2e18 + 7;
long long bis(long long a[], long long l, long long r, long long x) {
while (l <= r) {
long long m = l + (r - l) / 2;
if (a[m] == x) return m;
if (a[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
long long gcd(long long x, long long y) {
if (x == 0)
return y;
else
return gcd(y % x, x);
}
long long lcm(long long x, long long y) { return (x * y) / gcd(x, y); }
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
bool pdrome(string s) {
long long n = s.length();
for (long long i = 0; i < n / 2; i++) {
if (s[i] != s[n - i - 1]) {
return false;
}
}
return true;
}
long long mindig(long long x) {
long long ans = 9;
long long t = x;
while (x) {
ans = min(ans, x % 10);
x /= 10;
}
x = t;
return ans;
}
long long maxdig(long long x) {
long long ans = 0;
long long t = x;
while (x) {
ans = max(ans, x % 10);
x /= 10;
}
x = t;
return ans;
}
long long modpow(long long x, long long n, long long M) {
if (n == 0) return 1 % M;
long long u = modpow(x, n / 2, M);
u = (u * u) % M;
if (n % 2 == 1) u = (u * x) % M;
return u;
}
long long sumdigits(long long a) {
long long result = 0;
while (a > 0) {
result += a % 10;
a /= 10;
}
return result;
}
long long digits(long long n) { return floor(log10(n) + 1); }
const long long Node = 1e5 + 7;
vector<long long> adj[Node];
bool vis[Node];
void addedge(long long u, long long v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void bfs(long long u) {
vis[u] = true;
list<long long> q;
q.push_back(u);
while (!q.empty()) {
q.pop_front();
for (auto x : adj[u]) {
if (!vis[x]) {
vis[x] = true;
q.push_back(x);
}
}
}
}
void dfs(long long u) {
vis[u] = true;
for (auto x : adj[u]) {
if (!vis[x]) {
dfs(x);
}
}
}
long long con1(string s) {
long long res = 0;
stringstream geek(s);
geek >> res;
return res;
}
string con2(long long num) {
string stri = to_string(num);
return stri;
}
const long long N = 1e9 + 7;
void solve() {
long long n, m, k;
cin >> n >> m >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
k = min(k, m - 1);
long long ans = 0;
for (long long i = 0; i < k + 1; i++) {
long long cnt = N;
for (long long j = 0; j < m - k; j++) {
cnt = min(cnt, max(a[i + j], a[i + j + n - m]));
}
ans = max(ans, cnt);
}
cout << ans << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long MAX = 300010;
const long long MOD = (long long)1e9 + 7;
const long long INF = 1e9;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-8;
struct Segtree {
vector<long long> seg, lazy;
long long n, LOG;
Segtree(long long n = 0) {
this->n = n;
LOG = ceil(log2(n));
seg.assign(2 * n, 0);
lazy.assign(2 * n, 0);
}
long long merge(long long a, long long b) { return a + b; }
void poe(long long p, long long x, long long tam, bool prop = 1) {
seg[p] += x * tam;
if (prop and p < n) lazy[p] += x;
}
void sobe(long long p) {
for (long long tam = 2; p /= 2; tam *= 2) {
seg[p] = merge(seg[2 * p], seg[2 * p + 1]);
poe(p, lazy[p], tam, 0);
}
}
void prop(long long p) {
long long tam = 1 << (LOG - 1);
for (long long s = LOG; s; s--, tam /= 2) {
long long i = p >> s;
if (lazy[i]) {
poe(2 * i, lazy[i], tam);
poe(2 * i + 1, lazy[i], tam);
lazy[i] = 0;
}
}
}
void build() {
for (long long i = n - 1; i; i--)
seg[i] = merge(seg[2 * i], seg[2 * i + 1]);
}
long long query(long long a, long long b) {
long long ret = 0;
for (prop(a += n), prop(b += n); a <= b; ++a /= 2, --b /= 2) {
if (a % 2 == 1) ret = merge(ret, seg[a]);
if (b % 2 == 0) ret = merge(ret, seg[b]);
}
return ret;
}
void update(long long a, long long b, long long x) {
long long a2 = a += n, b2 = b += n, tam = 1;
for (; a <= b; ++a /= 2, --b /= 2, tam *= 2) {
if (a % 2 == 1) poe(a, x, tam);
if (b % 2 == 0) poe(b, x, tam);
}
sobe(a2), sobe(b2);
}
};
int32_t main() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < (long long)n; i++) cin >> v[i];
Segtree st1 = Segtree(MAX);
Segtree st2 = Segtree(MAX);
Segtree st3 = Segtree(MAX);
Segtree st4 = Segtree(MAX);
long long res = 0;
for (long long k = 0; k < n; k++) {
res += v[k] * st1.query(v[k], MAX - 1);
res += v[k] * st1.query(1, v[k]) - st2.query(v[k], v[k]);
res += st3.query(1, v[k]);
res += st3.query(v[k], MAX - 1);
for (long long m = 1; m * v[k] < MAX; m++) {
res -= m * v[k] * st1.query(m * v[k], min((m + 1) * v[k] - 1, MAX - 1));
}
st1.update(v[k], v[k], 1);
for (long long m = 1; m * v[k] < MAX; m++) {
st2.update(m * v[k], min((m + 1) * v[k] - 1, MAX - 1), m * v[k]);
}
st3.update(v[k], v[k], v[k]);
cout << res << " ";
}
cout << '\n';
return 0;
}
| 15 |
#include <bits/stdc++.h>
#include <math.h>
#define lli long long int
#include <limits.h>
#include <fstream>
#define F first
#define S second
#define PI 3.141592653589793238
#define pb push_back
using namespace std;
//doesn't work for arrays
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
const lli mod=1000000007;
lli gcd(lli a,lli b)
{
if(a==0)
return b;
return gcd(b%a,a);
}
lli binpow(lli x,lli y,lli m)
{
if (y==0)
return 1;
lli p=binpow(x,y/2,m)%m;
p=(p*p)%m;
if(y%2)
return (x*p)%m;
else
return p;
}
lli modi(lli a,lli m)
{
return binpow(a,m-2,m);
}
lli query(lli tree[],lli l,lli r)
{
lli ans=0;
while(l<r)
{
if(l%2)
{
ans=gcd(ans,tree[l]);
l++;
}
if(r%2)
{
r--;
ans=gcd(ans,tree[r]);
}
l/=2;
r/=2;
}
return ans;
}
lli find_set(lli v,lli parent[]) {
if (v==parent[v])
return v;
return parent[v]=find_set(parent[v],parent);
}
void union_sets(lli a, lli b,lli parent[]) {
a=find_set(a,parent);
b=find_set(b,parent);
if(a!=b)
parent[b]=a;
}
lli lca(lli a,lli b,vector<vector<lli>> &par,lli depth[])
{
if(depth[a]<depth[b])
swap(a,b);
lli diff=depth[a]-depth[b],ct=0;
while(diff)
{
if(diff%2)
{
a=par[ct][a];
}
ct++;
diff/=2;
}
if(a==b)
return a;
for(lli i=19;i>=0;i--)
{
if(par[i][a]!=par[i][b])
{
a=par[i][a];
b=par[i][b];
}
}
return par[0][a];
}
//how to set precision for double
//cout<<fixed<<setprecision(10);
/*
//euler tour for subtrees
lli timer=0;
void dfs(lli v,lli par,vector<lli> g[],pair<lli,lli> range[],lli nw[],bool vis[])
{
range[v].first=timer;
nw[v]=timer;
for(lli i=0;i<g[v].size();i++)
{
if(!vis[g[v][i]])
{
timer++;
vis[g[v][i]]=1;
dfs(g[v][i],v,g,range,nw,vis);
}
}
range[v].second=timer;
}*/
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
lli i,j,tt=1,tc;
cin>>tt;
for(tc=1;tc<=tt;tc++)
{
//cout<<"Case #"<<tc<<": ";
lli n,ans=0,temp,temp1,temp2;
cin>>n;
pair<lli,lli> a[n],b[n];
for(i=0;i<n;i++)
{
cin>>a[i].first>>a[i].second>>b[i].first>>b[i].second;
}
map<pair<lli,lli>,lli> m;
for(i=0;i<n;i++)
{
temp=gcd(abs(a[i].first-b[i].first),abs(a[i].second-b[i].second));
temp1=(a[i].first-b[i].first)/temp;
temp2=((a[i].second-b[i].second))/temp;
m[{temp1,temp2}]++;
}
for(auto x:m)
{
ans+=(x.second*m[{-x.first.first,-x.first.second}]);
}
cout<<(ans)/2<<"\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
double p[10000009], dp[10000009], ans[30];
int main() {
int n, k;
memset(dp, 0, sizeof(dp));
memset(ans, 0, sizeof(ans));
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%lf", &p[i]);
dp[0] = 1;
for (int i = 0; i < (1 << n); i++) {
double t = 0, l = 0;
for (int j = 0; j < n; j++) {
if (((1 << j) & i) == 0) {
t += p[j];
l++;
}
}
if (n - l > k) continue;
for (int j = 0; j < n; j++) {
if (p[j] < 0.0000000001) continue;
if (((1 << j) & i) != 0) {
dp[i] += dp[i - (1 << j)] * p[j] / (p[j] + t);
ans[j] += dp[i - (1 << j)] * p[j] / (p[j] + t);
}
}
}
for (int i = 0; i < n; i++) printf("%.8lf ", ans[i]);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s, p;
char c;
void solve(int x) {
if (x == 1) {
s = "", p = "a", c = 'a';
return;
}
if (x == 2) {
s = "b", p = "ab", c = 'b';
return;
}
if (!(x & 1)) {
solve((x >> 1) - 1);
++c;
s = c + s + c + c;
p = p + c;
return;
}
if (x & 1) {
solve(x >> 1);
++c;
s = s + c + c;
p = p + c;
return;
}
}
int main() {
scanf("%d", &n);
solve(n);
cout << p << s << " " << p << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
m *= 2;
n *= 2;
char ar[250][250];
for (int i = 0; i < m; i += 2) {
for (int j = 0; j < n; j += 2) {
cin >> ar[i][j];
ar[i + 1][j] = ar[i][j];
ar[i + 1][j + 1] = ar[i][j];
ar[i][j + 1] = ar[i][j];
}
}
char arr[250][250];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ar[j][i];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f3f3f3f3LL;
const long long mod = (long long)1e9 + 7;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
const long long N = 2 * (long long)1e5 + 10;
long long n, a[N], T, p[N];
vector<pair<long long, long long> > v;
bool cp(long long L, long long R) { return v[L].first < v[R].first; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> T;
v.resize(n);
for (long long i = 0; i < n; ++i) {
cin >> v[i].second >> v[i].first;
p[i] = i;
}
sort(p, p + n, cp);
long long low = 0, high = n, ans = -1;
while (low <= high) {
long long score = (low + high) >> 1;
long long vals = T, problems = 0;
for (long long i = 0; i < n; ++i) {
if (problems < score and vals >= v[p[i]].first and
score <= v[p[i]].second) {
vals -= v[p[i]].first;
++problems;
}
if (problems == score) break;
}
if (problems == score) {
ans = score;
low = score + 1;
} else {
high = score - 1;
}
}
cout << ans << '\n';
cout << ans << '\n';
long long vals = T, problems = 0, score = ans;
for (long long i = 0; i < n; ++i) {
if (problems < ans and vals >= v[p[i]].first and score <= v[p[i]].second) {
cout << p[i] + 1 << ' ';
vals -= v[p[i]].first;
++problems;
}
if (problems == ans) break;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int e = 127;
vector<int> v[30][30];
bool d[N][N][N];
bool dp[N][N][N];
int p[N][N];
int main() {
string s, t;
cin >> s >> t;
int n, m, i, j, k;
cin >> n;
string w;
for (i = 1; i <= n; i++) {
cin >> w;
v[w[3] - 97][w[4] - 97].push_back(w[0] - 97);
}
for (i = 1; i <= s.size(); i++) {
for (j = 0; j < s.size(); j++) {
int f = j;
int l = f + i - 1;
if (i == 1) {
int x = s[f] - 97;
d[f][l][x] = 1;
} else {
for (k = f + 1; k <= l; k++) {
for (int c = 0; c <= 25; c++) {
if (d[f][k - 1][c]) {
for (int w = 0; w <= 25; w++) {
if (d[k][l][w]) {
for (int a = 0; a < v[c][w].size(); a++) {
d[f][l][v[c][w][a]] = 1;
}
}
}
}
}
}
}
}
}
for (i = 1; i <= t.size(); i++) {
for (j = 0; j < t.size(); j++) {
int f = j;
int l = f + i - 1;
if (i == 1) {
int x = t[f] - 97;
dp[f][l][x] = 1;
} else {
for (k = f + 1; k <= l; k++) {
for (int c = 0; c <= 25; c++) {
if (dp[f][k - 1][c]) {
for (int w = 0; w <= 25; w++) {
if (dp[k][l][w]) {
for (int a = 0; a < v[c][w].size(); a++) {
dp[f][l][v[c][w][a]] = 1;
}
}
}
}
}
}
}
}
}
for (i = 0; i < s.size(); i++) {
for (j = 0; j < t.size(); j++) {
p[i][j] = 1e8;
}
}
for (i = 0; i < s.size(); i++) {
for (j = 0; j < t.size(); j++) {
for (k = i - 1; k >= 0; k--) {
for (int c = j - 1; c >= 0; c--) {
bool ok = 0;
for (int e = 0; e <= 25; e++) {
if (d[k + 1][i][e] && dp[c + 1][j][e]) ok = 1;
}
if (ok) {
p[i][j] = min(p[k][c] + 1, p[i][j]);
}
}
}
bool ok = 0;
for (int e = 0; e <= 25; e++) {
if (d[0][i][e] && dp[0][j][e]) ok = 1;
}
if (ok) {
p[i][j] = 1;
}
}
}
if (p[s.size() - 1][t.size() - 1] == 1e8) p[s.size() - 1][t.size() - 1] = -1;
cout << p[s.size() - 1][t.size() - 1];
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
struct segment {
int L, R;
double p;
segment(int L = 0, int R = 0, double p = 0) : L(L), R(R), p(p) {}
bool operator<(const segment &s) const {
if (L == s.L) return R > s.R;
return L < s.L;
}
} seg[5050];
int a[100100];
int mx[100100][20];
void pre(int n) {
for (int i = 1; i <= n; i++) mx[i][0] = a[i];
for (int j = 1; j < 20; j++)
for (int i = 1; i <= n; i++) {
mx[i][j] = max(mx[i][j - 1], mx[min(n, i + (1 << j - 1))][j - 1]);
}
}
int calc(int L, int R) {
int l = 31 - (__builtin_clz(R - L + 1));
return max(mx[L][l], mx[R - (1 << l) + 1][l]);
}
vector<int> adj[5050];
int val[5050];
int cur, m;
void build(int u) {
val[u] = calc(seg[u].L, seg[u].R);
while (cur < m) {
if (seg[cur].L > seg[u].R) return;
int v = cur++;
adj[u].push_back(v);
build(v);
}
}
double dp[5050][5050];
void solve(int u) {
for (int j = 0; j < 5050; j++) dp[u][j] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
solve(v);
for (int j = 0; j < 5050; j++) {
int k = min(5050 - 1, val[u] + j - val[v]);
dp[u][j] *= dp[v][k];
}
}
for (int j = 5050; j--;) {
dp[u][j] = dp[u][j] * (1 - seg[u].p);
if (j) dp[u][j] += dp[u][j - 1] * seg[u].p;
}
}
int main() {
int n, m;
gn(n, m);
for (int i = 1; i <= n; i++) gn(a[i]);
pre(n);
for (int i = 0; i < m; i++) {
gn(seg[i].L, seg[i].R);
scanf("%lf", &seg[i].p);
}
seg[m++] = segment(1, n, 0);
sort(seg, seg + m);
cur = 1;
::m = m;
build(0);
solve(0);
double ans = 0;
for (int j = 5050; j--;) {
if (j) dp[0][j] -= dp[0][j - 1];
ans += dp[0][j] * (val[0] + j);
}
printf("%.9lf\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int cnt = 0, cnt2 = 0;
cin >> s;
if (s.size() == 1) {
if (isupper(s[0])) {
putchar(tolower(s[0]));
} else
putchar(toupper(s[0]));
return 0;
}
if (islower(s[0]) && s.size() > 1) {
for (int i = 1; i < s.size(); i++) {
if (isupper(s[i])) {
cnt++;
}
}
}
if (cnt == s.size() - 1 && s.size() > 1) {
putchar(toupper(s[0]));
for (int i = 1; i < s.size(); i++) {
putchar(tolower(s[i]));
}
return 0;
}
for (int i = 0; i < s.size(); i++) {
if (isupper(s[i])) {
cnt2++;
}
}
if (cnt2 == s.size()) {
for (int i = 0; i < s.size(); i++) {
putchar(tolower(s[i]));
}
return 0;
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
vector<long long> prefSum(n);
prefSum[0] = arr[0];
for (int i = 1; i < n; i++) {
prefSum[i] = prefSum[i - 1] + arr[i];
}
map<long long, int> cnt;
for (int i = 0; i < n; i++) {
cnt[prefSum[i]]++;
}
int maxFreq = 0;
for (map<long long, int>::iterator it = cnt.begin(); it != cnt.end(); it++) {
maxFreq = max(maxFreq, it->second);
}
cout << n - maxFreq << endl;
}
int main() {
solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 7;
const double eps = 0.000000001;
double mi[N], ma[N], a[N], b[N];
int n;
void read_input() {
for (int i = 1; i <= n; ++i) {
cin >> ma[i];
ma[i] += ma[i - 1];
}
for (int i = 1; i <= n; ++i) {
cin >> mi[i];
mi[i] += mi[i - 1];
}
}
void print_result() {
for (int i = 1; i <= n; ++i) {
cout << a[i] - a[i - 1] << " ";
}
cout << endl;
for (int i = 1; i <= n; ++i) {
cout << b[i] - b[i - 1] << " ";
}
cout << endl;
}
bool eq(double t1, double t2) { return (t1 - t2) <= eps && (t1 - t2) >= -eps; }
void solve() {
cin >> n;
read_input();
for (int i = 1; i <= n; ++i) {
double c = mi[i], d = ma[i];
double D = sqrt(max((d + c) * (d + c) - 4 * d, 0.0));
double b1 = ((d + c) - D) / 2;
double b2 = ((d + c) + D) / 2;
if (eps > b1 && b1 > -eps) {
b1 = eps;
}
if (eps > b2 && b2 > -eps) {
b2 = eps;
}
double a1 = d / b1;
double a2 = d / b2;
if (a1 > b1) {
swap(a1, b1);
}
if (a2 > b2) {
swap(a2, b2);
}
if (a1 + eps >= a[i - 1] && b1 + eps >= b[i - 1] && a1 <= 1 + eps &&
b1 <= 1 + eps && eq(d, a1 * b1) && eq(c, a1 + b1 - a1 * b1)) {
a[i] = a1;
b[i] = b1;
} else {
a[i] = a2;
b[i] = b2;
}
}
print_result();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(7) << std::fixed;
solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int nn, mm;
typedef struct {
int x, s, e;
} ele;
int cmp(ele a, ele b) { return a.x < b.x || (a.x == b.x && a.s < b.s); }
vector<ele> a[2];
template <class T>
int dcdc(T s, T e, int x) {
ele l = *s;
s++;
for (; s != e; s++) {
if (l.e >= s->s) {
l.e = max(l.e, s->e);
} else {
x -= l.e - l.s;
l = *s;
}
}
return x - (l.e - l.s);
}
template <class T>
void dcdc2(T s, T e, int x, int m, int t) {
ele l = (ele){s->x, 0, 0};
int ts = 0;
for (; s != e; s++) {
if (l.e >= s->s) {
l.e = max(l.e, s->e);
} else {
ts += s->s - l.e;
if (ts >= x) {
if (t == 0)
printf("%d %d %d %d\n", l.x, 0, l.x, s->s - (ts - x));
else
printf("%d %d %d %d\n", 0, l.x, s->s - (ts - x), l.x);
return;
}
l = *s;
}
}
ts += m - l.e;
if (t == 0)
printf("%d %d %d %d\n", l.x, 0, l.x, m - (ts - x));
else
printf("%d %d %d %d\n", 0, l.x, m - (ts - x), l.x);
}
int test(int t, int tox, int m) {
int tn = (int)a[t].size();
for (int i = 0; i < tn;) {
int j = i;
for (; i < tn && a[t][i].x == a[t][j].x; i++)
;
int tt = dcdc(a[t].begin() + j, a[t].begin() + i, m);
if (tt > (tox ^ tt)) {
dcdc2(a[t].begin() + j, a[t].begin() + i, tt - (tox ^ tt), m, t);
return 1;
}
}
return 0;
}
void sol() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int x, y, z, w;
scanf("%d %d %d %d", &x, &y, &z, &w);
if (x == z) {
if (y > w) swap(y, w);
a[0].push_back((ele){x, y, w});
} else {
if (x > z) swap(x, z);
a[1].push_back((ele){y, x, z});
}
}
nn = n - 1;
mm = m - 1;
int txo = ((nn & 1) * m) ^ ((mm & 1) * n);
for (int t = 0; t < 2; t++) {
sort(a[t].begin(), a[t].end(), cmp);
int tn = (int)a[t].size();
for (int i = 0; i < tn;) {
int j = i;
for (; i < tn && a[t][i].x == a[t][j].x; i++)
;
txo ^= m;
nn--;
txo ^= dcdc(a[t].begin() + j, a[t].begin() + i, m);
}
swap(n, m);
swap(nn, mm);
}
if (txo == 0) {
puts("SECOND");
} else {
puts("FIRST");
if (nn && m > (txo ^ m)) {
int tn = (int)a[0].size();
int ta = 1;
for (int i = 0; i < tn; i++) {
if (ta == a[0][i].x) ta++;
}
printf("%d %d %d %d\n", ta, 0, ta, m - (txo ^ m));
} else if (mm && n > (txo ^ n)) {
int tn = (int)a[1].size();
int ta = 1;
for (int i = 0; i < tn; i++) {
if (ta == a[1][i].x) ta++;
}
printf("%d %d %d %d\n", 0, ta, n - (txo ^ n), ta);
} else {
if (test(0, txo, m) == 0) test(1, txo, n);
}
}
a[0].clear();
a[1].clear();
}
int main() {
while (1) {
sol();
break;
}
return 0;
}
| 16 |
Subsets and Splits