solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int t, n, q, p[300005], l, r, sta, ans;
unordered_map<int, vector<int>> mp[2];
char s[300005];
int find_id(int num, int f) {
int pos = lower_bound(mp[f][num].begin(), mp[f][num].end(), l - 1) -
mp[f][num].begin();
if (pos != mp[f][num].size() && mp[f][num][pos] < r)
return mp[f][num][pos] + 1;
return 0;
}
void solve() {
int sum = p[r] - p[l - 1];
ans = find_id((sum - 1) / 2 + p[l - 1], 1);
if (ans)
printf("%d\n", ans);
else
printf("%d\n", find_id((sum + 1) / 2 + p[l - 1], 0));
}
int main() {
scanf("%d", &t);
while (t--) {
mp[0].clear(), mp[1].clear();
scanf("%d%d%s", &n, &q, s + 1);
for (int i = 1; i <= n; ++i) {
if (i & 1)
p[i] = p[i - 1] + (s[i] == '+' ? 1 : -1);
else
p[i] = p[i - 1] + (s[i] == '+' ? -1 : 1);
if (p[i] - p[i - 1] == 1)
mp[1][p[i - 1]].push_back(i - 1);
else
mp[0][p[i - 1]].push_back(i - 1);
}
while (q--) {
scanf("%d%d", &l, &r);
if (r - l + 1 & 1)
puts("1"), solve();
else if (p[r] == p[l - 1])
puts("0");
else
printf("2\n%d ", r--), solve();
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
int res = 0;
for (int i = 0; i < s[0].size() - 1; i++) {
int same = 0;
for (int j = 0; j < n - 1; j++) {
if (s[j][i] == s[j + 1][i]) same++;
}
if (same == n - 1)
res++;
else
break;
}
cout << res << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
cin >> n;
cout << n << " ";
for (i = 1; i < n; i++) cout << i << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long fix(long long cur, long long m) { return ((cur % m) + m) % m; }
long long fast_power(long long x, long long y, long long m) {
if (y == 0) return 1;
long long temp = fast_power(x, y / 2, m);
temp = (temp * temp) % m;
if (y % 2 != 0) temp = (temp * x) % m;
return temp;
}
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
cout.tie(0);
int arr[5];
cin >> arr[1] >> arr[2] >> arr[3] >> arr[4];
string str;
cin >> str;
int cnt = 0;
for (int i = 0; i < str.size(); i++) cnt += arr[str[i] - '0'];
cout << cnt << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int d = k / n;
int m = k % n;
if (d > 2) {
cout << 0;
return 0;
} else {
cout << n - m;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pci = pair<char, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
const ll infll = 1e18 + 3;
const int maxn = 1e6 + 77;
const int nmax = 1e6 + 77;
const ll basell = 1e18 + 3;
const int mod = 1e9 + 7;
const ld eps = 1e-7;
const int inf = 1009000999;
const int nv = 100505;
const int baseint = 1000200013;
const ld PI = acos(-1.0);
inline bool EQ(ld a, ld b) { return fabs(a - b) < 1e-9; }
int a[nv][6];
int t[4 * 100000][6];
void build(int v, int vl, int vr, int x) {
if (vl == vr) {
t[v][x] = a[vl][x];
return;
}
int vm = vl + (vr - vl) / 2;
build(2 * v + 1, vl, vm, x);
build(2 * v + 2, vm + 1, vr, x);
t[v][x] = max(t[2 * v + 1][x], t[2 * v + 2][x]);
}
int query(int v, int vl, int vr, int l, int r, int x) {
if (r < vl || vr < l) return 0;
if (l <= vl && vr <= r) return t[v][x];
int vm = vl + (vr - vl) / 2;
int ql = query(2 * v + 1, vl, vm, l, r, x);
int qr = query(2 * v + 2, vm + 1, vr, l, r, x);
return max(ql, qr);
}
int inline solve() {
ios::sync_with_stdio(NULL), cin.tie(NULL), cout.tie(NULL);
;
int n, m, k;
cin >> n >> m >> k;
for (int r = 0; r < n; ++r) {
for (int i = 0; i < m; ++i) {
cin >> a[r][i];
}
}
for (int i = 0; i < m; ++i) {
build(0, 0, n - 1, i);
}
int l = 0;
int len = 0, x = -1, y = -1;
for (int r = 0; r < n; ++r) {
int sum = 0;
for (int i = 0; i < m; ++i) {
sum += query(0, 0, n - 1, l, r, i);
}
while (sum > k) {
l++;
if (l > r) break;
sum = 0;
for (int i = 0; i < m; ++i) {
sum += query(0, 0, n - 1, l, r, i);
}
}
if (r - l + 1 > len) len = r - l + 1, x = l, y = r;
}
for (int i = 0; i < m; ++i) {
if (x == -1)
cout << "0 ";
else
cout << query(0, 0, n - 1, x, y, i) << " ";
}
return 0;
}
int32_t main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void minimiza(long long int &a, long long int b) { a = min(a, b); }
const long long int infinito = 1000000000000000000LL;
const int limite = 5005;
int n, m;
int nhole = 0;
int poshole[limite];
queue<int> vq[limite];
int caben[limite];
int cuantos[limite];
int posini[limite];
long long int coste[limite];
int eleccion[limite];
int ihole[limite];
long long int absolut(long long int x) {
if (x < 0) return -x;
return x;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> posini[i];
sort(posini, posini + n);
map<int, int> mapa;
for (int i = 0; i < m; i++) {
int p, c;
cin >> p >> c;
mapa[p] += c;
}
m = 0;
int totalcaben = 0;
for (map<int, int>::iterator it = mapa.begin(); it != mapa.end(); it++, m++) {
poshole[m] = it->first;
caben[m] = it->second;
totalcaben += caben[m];
}
if (totalcaben < n) {
cout << -1 << endl;
exit(0);
}
{
int ind = 0;
for (int i = 0; i < n; i++) {
if (caben[ind] <= cuantos[ind]) ind++;
ihole[i] = ind;
cuantos[ind]++;
}
}
for (int i = n - 1; i >= 0; i--) vq[ihole[i]].push(posini[i]);
{
int i = m - 1;
for (;;) {
bool trobat = false;
while (i >= 0) {
if (int(vq[i].size()) == 0) {
coste[i] = 0;
eleccion[i] = 0;
i--;
continue;
}
coste[i] = infinito;
if (int(vq[i].size()) < caben[i]) {
coste[i] = 0;
eleccion[i] = 0;
}
if (i < m - 1) {
int pos = vq[i].front();
long long int nextcoste = absolut(poshole[i + 1] - pos) -
absolut(poshole[i] - pos) + coste[i + 1];
if (nextcoste < coste[i]) {
coste[i] = nextcoste;
eleccion[i] = 1;
}
}
if (coste[i] < 0) {
while (eleccion[i]) {
int pos = vq[i].front();
vq[i].pop();
i++;
vq[i].push(pos);
}
trobat = true;
break;
}
i--;
}
if (not trobat) break;
}
}
long long int sol = 0;
for (int i = 0; i < m; i++) {
queue<int> &q = vq[i];
while (not q.empty()) {
int pos = q.front();
q.pop();
sol += absolut(poshole[i] - pos);
}
}
cout << sol << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, t, a, b, c, i, j;
cin >> t;
while (t--) {
cin >> n;
vector<long long int> v, v1;
for (i = 0; i < n; i++) {
cin >> m;
v.push_back(m);
}
sort(v.rbegin(), v.rend());
for (i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
int n, m, ans = 0;
scanf("%d %d", &n, &m);
ans = n;
while (n) {
ans += (n / m);
if (n / m == 0) {
break;
}
n = (n / m) + (n % m);
}
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<vector<int>> f(n, vector<int>(n, 0));
vector<vector<int>> g(n, vector<int>(n, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j > 0) {
f[i][j] = f[i][j - 1];
g[i][j] = g[i][j - 1];
}
if (a[j] < a[i]) f[i][j]++;
if (a[j] > a[i]) g[i][j]++;
}
}
int num = 0;
for (int i = 0; i < n; i++) {
num += g[i][i];
}
int ans = 1e9, res = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int x = num;
x -= g[i][i];
x += g[i][j];
x -= g[j][j];
x += g[j][i];
x -= a[i] - f[i][i];
x += a[i] - f[i][j];
x -= a[j] - f[j][j];
x += a[j] - f[j][i];
if (x == ans) {
res++;
} else if (x < ans) {
ans = x;
res = 1;
}
}
}
cout << ans << ' ' << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> px, py;
vector<pair<long long, long long> > pts;
for (int i = 0; i < 4 * n + 1; i++) {
int a, b;
cin >> a >> b;
px.push_back(a);
py.push_back(b);
pts.push_back({a, b});
}
sort(px.begin(), px.end());
sort(py.begin(), py.end());
int largma = min(px[px.size() - 1], px[px.size() - 2]);
int largmi = max(px[0], px[1]);
int altma = min(py[py.size() - 1], py[py.size() - 2]);
int altmi = max(py[0], py[1]);
for (int i = 0; i < pts.size(); i++) {
bool cond = false;
if (pts[i].first == largma || pts[i].first == largmi) {
if (pts[i].second >= altmi && pts[i].second <= altma) cond = true;
}
if (pts[i].second == altma || pts[i].second == altmi) {
if (pts[i].first >= largmi && pts[i].first <= largma) cond = true;
}
if (!cond) {
cout << pts[i].first << " " << pts[i].second << endl;
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 400010, mod = 1000000007;
int moves(int n) {
int sq = sqrt(n);
int minn = 1000000011;
for (int i = max(0, sq - 3); i <= sq + 3; i++) {
minn = min(minn, abs(i * i - n));
}
return minn;
}
vector<int> a, b;
int main() {
ios_base::sync_with_stdio(false);
int n, i, j, k;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
if (moves(k) == 0) {
if (k == 0)
a.push_back(2);
else
a.push_back(1);
} else {
b.push_back(moves(k));
}
}
long long ans = 0;
if (a.size() == b.size()) {
ans = 0;
assert(a.size() == n / 2);
} else if (a.size() > n / 2) {
sort((a).begin(), (a).end());
for (i = 0; i < a.size() - n / 2; i++) ans += a[i];
} else {
sort((b).begin(), (b).end());
for (i = 0; i < b.size() - n / 2; i++) ans += b[i];
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n << endl;
for (int i = 0; i < n; i++) {
cout << "1"
<< " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 3;
vector<long long> prim;
vector<pair<long long, long long> > a[N];
long long n, m, x[N * 100];
void civ() {
prim.push_back(0);
prim.push_back(2);
for (int i = 3; i <= 1e7; i += 2) {
if (!x[i]) {
prim.push_back(i);
for (int j = i + i; j <= 1e7; j += i) x[j]++;
}
}
}
int main() {
civ();
cin >> n >> m;
for (int i = n, j = 1; i >= 2; i--, j++)
a[1].push_back(make_pair(i, prim[j] - prim[j - 1]));
long long i = 2, j = 3;
m -= n - 1;
while (m--) {
if (j == n + 1) {
i++;
j = i + 1;
}
a[i].push_back(make_pair(j, 1e9));
j++;
}
cout << 2 << " " << prim[n - 1] << endl;
for (int i = 1; i <= n; i++)
for (int j = 0; j < a[i].size(); j++)
cout << i << " " << a[i][j].first << " " << a[i][j].second << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int ans[51];
int f, l, n, i;
long long p, m;
cin >> n >> m;
if (n == 1) {
cout << 1 << endl;
return 0;
}
p = 1ll << (n - 2);
f = 0;
l = n - 1;
i = 1;
while (p) {
if (m <= p) {
ans[f++] = i;
} else {
ans[l--] = i;
m -= p;
}
p >>= 1;
i++;
}
ans[f] = i;
printf("%d", ans[0]);
for (i = 1; i < n; i++) {
printf(" %d", ans[i]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long gcdExtended(long long a, long long b, long long* x, long long* y)
{
if (a == 0)
{
*x = 0, *y = 1;
return b;
}
// To store results of recursive call
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
// Update x and y using results of recursive
// call
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long modInverse(long long a)
{
long long m = MOD;
long long x, y;
long long g = gcdExtended(a, m, &x, &y);
long long res = (x % m + m) % m;
return res;
}
long long fact[100006];
long long invFact[100006];
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
fact[0] = 1;
invFact[0] = 1;
for(int i = 1; i<100005; i++){
fact[i] = fact[i-1]*i;
fact[i] %= MOD;
invFact[i] = invFact[i-1]*modInverse(i);
invFact[i] %= MOD;
}
int t; cin >> t;
while(t--){
int n; cin >> n;
string s; cin >> s;
int run = 0;
int pairs = 0;
int singles = 0;
for(int i = 0; i<n; i++){
if(s[i] == '1') run++;
else {
if(run%2==0){
pairs += run/2;
}
else{
pairs+=run/2;
singles++;
}
run = 0;
}
}
if(run!=0){
if(run%2==0){
pairs += run/2;
}
else{
pairs+=run/2;
singles++;
}
}
if(pairs != 0){
long long ans = fact[n-pairs-singles];
ans = ans * invFact[pairs];
ans %= MOD;
ans = ans*invFact[n-singles-2*pairs];
ans %= MOD;
cout << ans << endl;
}
else cout << 1 << endl;
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
bool vis[maxn];
int n, par[maxn], depth[maxn], rev[maxn], left_leaf[maxn], right_leaf[maxn];
vector<int> adj[maxn], children[maxn], leaf_depths;
struct st {
int left, right;
st *lst, *rst;
pair<int, int> mx;
int add;
st(int _left, int _right, vector<int> &data) {
left = _left;
right = _right;
if (left == right) {
mx = {data[left], left};
add = 0;
lst = rst = NULL;
} else {
lst = new st(left, (left + right) / 2, data);
rst = new st((left + right) / 2 + 1, right, data);
mx = max(lst->mx, rst->mx);
add = 0;
}
}
void prop() {
if (add != 0) {
if (left < right) {
lst->add += add;
rst->add += add;
}
mx.first += add;
add = 0;
}
}
pair<int, int> query_mx(int b, int e) {
prop();
if (e < left || right < b) {
return {-1e9, -1};
} else if (b <= left && right <= e) {
return mx;
}
return max(lst->query_mx(b, e), rst->query_mx(b, e));
}
void update(int b, int e, int d) {
prop();
if (e < left || right < b) {
return;
} else if (b <= left && right <= e) {
add += d;
prop();
} else {
lst->update(b, e, d);
rst->update(b, e, d);
mx = max(lst->mx, rst->mx);
}
}
} * st_root;
pair<int, int> get_farthest(int u, int prv, int dist) {
pair<int, int> best = {dist, u};
for (int v : adj[u]) {
if (v != prv) {
best = max(get_farthest(v, u, dist + 1), best);
}
}
return best;
}
int get_root() {
int tmp = get_farthest(0, -1, 0).second;
return get_farthest(tmp, -1, 0).second;
}
void root_tree(int u, int prv) {
par[u] = prv;
for (int v : adj[u]) {
if (v != prv) {
children[u].push_back(v);
root_tree(v, u);
}
}
}
void compute_leaves(int u, int d) {
depth[u] = d;
if (children[u].empty()) {
left_leaf[u] = right_leaf[u] = leaf_depths.size();
rev[leaf_depths.size()] = u;
leaf_depths.push_back(d);
} else {
left_leaf[u] = leaf_depths.size();
for (int v : children[u]) {
compute_leaves(v, d + 1);
}
right_leaf[u] = leaf_depths.size() - 1;
}
}
void go(int u, int cnt, int rem) {
if (vis[u]) {
return;
}
vis[u] = true;
for (int v : children[u]) {
if (!vis[v]) {
st_root->update(left_leaf[v], right_leaf[v], -(rem - cnt));
}
}
go(par[u], cnt + 1, rem);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
--u;
--v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int root = get_root();
root_tree(root, -1);
compute_leaves(root, 0);
st_root = new st(0, leaf_depths.size() - 1, leaf_depths);
cout << '1';
int sum = 1;
vis[root] = true;
for (size_t i = 0; i < leaf_depths.size(); i++) {
auto resp = st_root->query_mx(0, leaf_depths.size() - 1);
sum += resp.first;
cout << ' ' << sum;
go(rev[resp.second], 0, resp.first);
st_root->update(resp.second, resp.second, -1e9);
}
for (int i = leaf_depths.size() + 1; i < n; i++) {
cout << ' ' << n;
}
cout << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int egcd(int a, int b, int &x, int &y) {
if (a == 0) {
x = 0, y = 1;
return b;
} else {
int x0, x1;
int g = egcd(b % a, a, x0, x1);
x = x1 - x0 * (b / a), y = x0;
return g;
}
}
int main() {
int T, n;
scanf("%d %d", &T, &n);
vector<int> dist(n);
for (int i = 0; i < n; ++i) scanf("%d", &dist[i]);
long long shift = 0;
for (int i = 0; i < n; ++i) shift += dist[i];
shift %= T;
const int nblock = gcd(shift, T), blocksize = T / nblock;
struct guy_t {
int block;
int pos_in_block;
int id;
};
vector<guy_t> guys;
set<int> taken;
long long pos = 0;
for (int i = 0; i < n; ++i) {
if (taken.find(pos) == taken.end()) {
taken.insert(pos);
int block = pos % nblock;
int x, _unused;
int g = egcd(shift, T, x, _unused);
assert((pos - pos % nblock) % g == 0);
int pos_in_block = (long long)x * ((pos - pos % nblock) / g) % blocksize;
guys.push_back((guy_t){block, pos_in_block, i});
}
pos = (pos + dist[(i + 1) % n]) % T;
}
vector<int> result(n, 0);
sort(guys.begin(), guys.end(), [](const guy_t &a, const guy_t &b) {
if (a.block != b.block) return a.block < b.block;
return a.pos_in_block < b.pos_in_block;
});
for (int j = 0, i = j; i < (int)guys.size(); i = j) {
while (j < (int)guys.size() && guys[j].block == guys[i].block) ++j;
for (int k = i; k < j; ++k) {
int res;
if (k + 1 < j)
res = guys[k + 1].pos_in_block - guys[k].pos_in_block;
else
res = blocksize - (guys[k].pos_in_block - guys[i].pos_in_block);
result[guys[k].id] = res;
}
}
for (int i = 0; i < n; ++i) {
if (i > 0) printf(" ");
printf("%d", result[i]);
}
printf("\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
typedef void (*callback_function)(void);
const long long INF64 = 1e18;
const long long INF32 = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
if (false) {
freopen("A.in", "r", stdin);
cerr << "Remember to switch INPUT_FILE off before submitting!" << endl
<< endl;
freopen("A.out", "w", stdout);
}
auto beginProgram = chrono::steady_clock::now();
{
long long x;
cin >> x;
if (x != 1) {
cout << x << ' ' << x << endl;
} else {
cout << -1 << endl;
}
}
if (false) {
auto endProgram = chrono::steady_clock::now();
cerr << "Elapsed time (ms): "
<< chrono::duration_cast<chrono::milliseconds>(endProgram -
beginProgram)
.count()
<< endl;
system("gnome-open A.in");
system("gnome-open A.correct");
system("gnome-open A.out");
fstream myAns("A.out");
fstream correctAns("A.correct");
string myLine, correctLine;
long long lineIndex = 1;
bool moreMyAns, moreCorrectAns;
moreMyAns = (bool)getline(myAns, myLine);
moreCorrectAns = (bool)getline(correctAns, correctLine);
while (moreMyAns && moreCorrectAns) {
cerr << lineIndex++ << "\t" << (myLine == correctLine ? "ok" : "WRONG")
<< endl;
moreMyAns = (bool)getline(myAns, myLine);
moreCorrectAns = (bool)getline(correctAns, correctLine);
}
if (moreMyAns) {
cerr << "ERROR: My answer is too long! Excessive lines:" << endl;
do {
cerr << lineIndex++ << "\t" << myLine << endl;
} while (getline(myAns, myLine));
} else if (moreCorrectAns) {
cerr << "ERROR: My answer is too short! Missing lines:" << endl;
do {
cerr << lineIndex++ << "\t" << correctLine << endl;
} while (getline(correctAns, correctLine));
}
myAns.flush();
myAns.close();
correctAns.flush();
correctAns.close();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int num = 6000000;
bool a[num];
int main() {
int n;
memset(a, false, sizeof(a));
scanf("%d", &n);
int x;
for (int i = 0; i <= 500; i++) x = i * (i + 1) / 2, a[x] = true;
a[n] ? printf("YES") : printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, p, k;
cin >> n >> p >> k;
vector<int> a(n);
for (auto& x : a) {
cin >> x;
auto y = ll(x) * x % p;
y = y * y % p;
x = y - k * ll(x) % p;
x += p * (x < 0);
}
sort(a.begin(), a.end());
ll ans = 0;
for (int i = 0, j = 0; i < n; i = j) {
while (j < n && a[i] == a[j]) ++j;
ans += ll(j - i) * (j - i - 1) / 2;
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
char s1[MAXN], s2[MAXN];
int l, r;
signed main() {
scanf("%s %s", s1, s2);
register int i;
l = strlen(s2);
while (s1[r] == s2[r]) ++r;
while (s1[l + 1] == s2[l] && l >= 0) --l;
printf("%d\n", r > l ? r - l : 0);
for (i = l + 1; i <= r; i++) printf("%d ", i + 1);
return puts(""), 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(15);
int T;
cin >> T;
while (T-- > 0) {
int a = 6, b = 10, c = 14, d = 15;
int n;
cin >> n;
int x = n - a - b - c;
int y = n - a - b - d;
if (n > a + b + c && x != a && x != b && x != c) {
cout << "YES\n";
cout << a << ' ' << b << ' ' << c << ' ' << x << '\n';
} else if (n > a + b + d && y != a && y != b && y != d) {
cout << "YES\n";
cout << a << ' ' << b << ' ' << d << ' ' << y << '\n';
} else {
cout << "NO\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[100005];
long long int cnt[100005];
string st;
long long int n;
int main() {
string str;
cin >> str;
st = "";
for (int i = 0; i < str.length(); i++)
if (str[i] == 'a' || str[i] == 'b') st = st + str[i];
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < st.length(); i++) {
if (i == 0 && st[i] == 'a')
cnt[i] = 1;
else if (i > 0) {
if (st[i] == 'a')
cnt[i] = cnt[i - 1] + 1;
else
cnt[i] = cnt[i - 1];
}
}
memset(dp, 0, sizeof(dp));
int flag = 0, pos = 0;
for (int i = 0; i < st.length(); i++) {
if (st[i] == 'a') {
dp[i] = (1 % 1000000007);
if (i > 0)
dp[i] = (dp[i] % 1000000007 + dp[i - 1] % 1000000007) % 1000000007;
if (i >= 2 && flag)
dp[i] = (dp[pos] % 1000000007 + dp[i] % 1000000007) % 1000000007;
} else {
flag = 1;
pos = i;
if (i > 0) dp[i] = dp[i - 1] % 1000000007;
}
}
cout << dp[st.length() - 1] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, l, r;
int main() {
cin >> n;
string s;
cin >> s;
cout << n + 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
char putnb[20];
using namespace std;
const int inf = 1e8;
const long long infl = 1e18;
const int N = 1000000;
int main() {
int n;
cin >> n;
if (n % 2)
cout << "black";
else
cout << "white\n1 2";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000001;
int n;
int sub[MAXN];
long long int pot[MAXN];
int num[MAXN];
int cont[MAXN];
long long int dp[2][(1 << 19) + 1];
int p[MAXN] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 53, 59, 61, 67};
int id(int a) {
for (int i = 0; i < 19; i++)
if (p[i] == a) return i;
}
void go(int a) {
if (a <= 1) return;
int nueva = 0, o = a;
for (int i = 2; i * i <= a; i++) {
while (a % i == 0) {
nueva ^= (1 << id(i)), a /= i;
}
}
if (a > 1) nueva ^= (1 << id(a));
sub[o] = nueva;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pot[0] = 1;
for (int i = 0; i < MAXN; i++)
if (i) pot[i] = (pot[i - 1] * 2ll) % 1000000007;
for (int i = 0; i < MAXN; i++) pot[i] = (pot[i] * 500000004) % 1000000007;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
cont[num[i]]++;
}
for (int i = 0; i < 71; i++) go(i);
for (int id = 71; id >= 1; id--) {
for (int mask = (1 << 19) - 1; mask >= 0; mask--) {
if (id == 71) {
dp[id & 1][mask] = (mask == 0);
continue;
}
if (!cont[id]) {
dp[id & 1][mask] = dp[(id + 1) & 1][mask];
continue;
}
long long int ans = (dp[(id + 1) & 1][mask] * pot[cont[id]]) % 1000000007;
ans += (dp[(id + 1) & 1][mask ^ sub[id]] * pot[cont[id]]) % 1000000007;
dp[id & 1][mask] = ans % 1000000007;
}
}
cout << (dp[1][0] - 1 + 1000000007) % 1000000007 << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int N = n;
n++;
vector<int> p(n + 1);
for (; n > 1;) {
int b = log2(n - 1);
int m = (1 << b) - 1;
for (int i = 1; i < n - m; i++) p[m + i] = m - i + 1, p[m - i + 1] = m + i;
n = 2 * m + 2 - n;
}
cout << ((long long)N) * ((long long)(N) + 1ll) << "\n";
for (int i = 0; i <= N; i++) cout << p[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
struct node {
int data;
long long cost;
bool operator<(const node &b) const {
if (cost == b.cost)
return data < b.data;
else
return cost > b.cost;
}
} a[3000000];
map<int, int> fa;
int find(int a) {
if (fa[a] == 0)
return a;
else
return fa[a] = find(fa[a]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x != y) fa[x] = y;
}
int main() {
cin >> n;
fa.clear();
for (int i = 0; i < n; ++i) scanf("%d", &a[i].data);
for (int i = 0; i < n; ++i) scanf("%lld", &a[i].cost);
sort(a, a + n);
long long ans = 0;
for (int i = 0; i < n; i++) {
int x = find(a[i].data);
ans += a[i].cost * (x - a[i].data);
unite(x, x + 1);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
const int MAX = 1e6 + 7;
using namespace std;
bool t[50][50];
int main() {
int n;
cin >> n;
char a[50][50];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (a[i][j] == '#')
continue;
else if (a[i][j] == '.' && !t[i][j]) {
if (a[i + 1][j] == '.' && a[i + 1][j + 1] == '.' &&
a[i + 2][j] == '.' && a[i + 1][j - 1] == '.' &&
t[i + 1][j + 1] != 1 && t[i + 1][j - 1] != 1) {
t[i + 1][j] = 1;
t[i + 1][j + 1] = 1;
t[i + 2][j] = 1;
t[i + 1][j - 1] = 1;
t[i][j] = 1;
} else {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, m;
int cnt;
long long sum[5];
};
const int maxn = 100100;
node T[maxn << 2];
char cmd[maxn][5];
int dat[maxn];
int bin[maxn];
int tmp[maxn];
int q;
void pushup(int rt) {
for (int i = 0; i < 5; i++)
T[rt].sum[i] = T[rt << 1].sum[i] +
T[rt << 1 | 1].sum[((i - T[rt << 1].cnt) % 5 + 5) % 5];
}
void build(int begin, int end, int rt) {
T[rt].l = begin;
T[rt].r = end;
T[rt].m = (T[rt].l + T[rt].r) >> 1;
T[rt].cnt = 0;
for (int i = 0; i < 5; i++) T[rt].sum[i] = 0;
if (begin == end) return;
build(T[rt].l, T[rt].m, rt << 1);
build(T[rt].m + 1, T[rt].r, rt << 1 | 1);
}
void update(int id, int add, int rt, int op) {
T[rt].cnt += op;
if (T[rt].l == T[rt].r) {
T[rt].sum[0] += add;
return;
}
if (id <= T[rt].m)
update(id, add, rt << 1, op);
else
update(id, add, rt << 1 | 1, op);
pushup(rt);
}
int main() {
while (~scanf("%d", &q)) {
int top = 0;
for (int i = 0; i < q; i++) {
scanf("%s", cmd[i]);
if (cmd[i][0] != 's') {
scanf("%d", &dat[top]);
tmp[top] = dat[top];
top++;
}
}
if (q == 1 && cmd[0][0] == 's') {
puts("0");
continue;
}
sort(tmp, tmp + top);
int num = unique(tmp, tmp + top) - tmp;
build(1, num, 1);
for (int i = 0; i < top; i++) {
bin[i] = lower_bound(tmp, tmp + num, dat[i]) - tmp + 1;
}
for (int i = 0, j = 0; i < q; i++) {
if (cmd[i][0] == 'a')
update(bin[j], dat[j], 1, 1), j++;
else if (cmd[i][0] == 'd')
update(bin[j], -dat[j], 1, -1), j++;
else
printf("%I64d\n", T[1].sum[2]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long fast_exp(long long base, long long exp) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % 1000000007;
base = (base * base) % 1000000007;
exp /= 2;
}
return res % 1000000007;
}
long long fib(long long n) {
if (n < 2) return n;
long long a = 0, b = 1, ans;
int i = 1;
while (i < n) {
ans = (a + b) % 1000000007;
a = b;
b = ans;
i++;
}
return ans;
}
long long fac(long long n) {
if (n % 2 == 0) return 2;
for (long long i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
if (n == 1) {
cout << 0 << "\n";
} else if (n == 2) {
cout << m << "\n";
} else {
cout << 2 * m << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t = 0;
cin >> t;
while (t--) {
string a;
string b;
cin >> a >> b;
bool r = true;
int i = 0;
int j = 0;
int k = 0;
int l = 0;
int alpha1[26] = {0};
int alpha2[26] = {0};
if (a.length() > b.length()) {
r = false;
}
while (i < a.length()) {
j = i;
l = k;
while (i < a.length() && a[i] == a[j]) {
alpha1[a[i++] - 0x61]++;
}
while (k < b.length() && b[k] == a[j]) {
alpha2[b[k++] - 0x61]++;
}
if (((k - l) < (i - j)) || (a[i] != b[k]) || (k < i)) {
r = false;
break;
}
}
if (r == true) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int uom_cnt;
pair<int, unsigned char> uom[100100];
inline void divisor(int x, int f) {
int i;
for (i = 1; i * i <= x; ++i) {
if (x % i == 0) {
uom[uom_cnt++] = make_pair(i, f);
if (i * i != x) {
uom[uom_cnt++] = make_pair(x / i, f);
}
}
}
}
long long int arr[8];
bitset<2048> bits;
int main() {
int t;
long long int s;
scanf("%d", &t);
while (t--) {
uom_cnt = 0;
memset(arr, 0, 8 * sizeof(long long int));
s = 0;
int a, b, c, i;
scanf("%d%d%d", &a, &b, &c);
divisor(a, 1);
divisor(b, 2);
divisor(c, 4);
sort(uom, uom + uom_cnt);
uom[uom_cnt++] = make_pair(-1, -1);
int last = 0, lastval = -1;
for (i = 0; i < uom_cnt; ++i) {
if (lastval != uom[i].first) {
lastval = uom[i].first;
++arr[last];
last = uom[i].second;
} else {
last |= uom[i].second;
}
}
bits.reset();
for (int i : {1, 3, 5, 7}) {
for (int j : {2, 3, 6, 7}) {
for (int k : {4, 5, 6, 7}) {
int temp[3] = {i, j, k};
sort(temp, temp + 3);
int v = (temp[0] << 6) | (temp[1] << 3) | temp[2];
if (!bits[v]) {
if (i == j && j == k) {
s += (arr[i] + 2) * (arr[i] + 1) * arr[i] / 6;
} else if (i == j) {
s += (arr[i] + 1) * arr[i] / 2 * arr[k];
} else if (j == k) {
s += (arr[j] + 1) * arr[j] / 2 * arr[i];
} else if (k == i) {
s += (arr[k] + 1) * arr[k] / 2 * arr[j];
} else {
s += arr[i] * arr[j] * arr[k];
}
bits[v] = true;
}
}
}
}
printf("%lld\n", s);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int num, pos;
scanf("%d%d", &num, &pos);
int a[num + 1];
int cnt = 0;
for (int i = 1; i <= num; i++) scanf("%d", &a[i]);
if (a[pos] == 1) cnt = 1;
for (int i = 1; pos + i <= num || pos - i >= 1; i++) {
int p = 0, n = 0;
if (pos + i <= num) {
if (a[pos + i] == 1) p = 1;
} else {
p = 1;
}
if (pos - i >= 1) {
if (a[pos - i] == 1) n = 1;
} else {
n = 1;
}
if (p == 1 && n == 1 && pos + i <= num && pos - i >= 1)
cnt += 2;
else if (p == 1 && n == 1)
cnt++;
}
printf("%d\n", cnt);
return 0;
}
| 1 |
#include <bits/stdc++.h>
namespace FastRead {
char __buff[5000];
long long __lg = 0, __p = 0;
char nc() {
if (__lg == __p) {
__lg = fread(__buff, 1, 5000, stdin);
__p = 0;
if (!__lg) return EOF;
}
return __buff[__p++];
}
template <class T>
void read(T& __x) {
T __sgn = 1;
char __c;
while (!isdigit(__c = nc()))
if (__c == '-') __sgn = -1;
__x = __c - '0';
while (isdigit(__c = nc())) __x = __x * 10 + __c - '0';
__x *= __sgn;
}
} // namespace FastRead
using namespace FastRead;
using namespace std;
const long long N = 2e5 + 10;
const long long M = 1e6 + 10;
const long double PI = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long n;
long long d[N], fish[N];
struct dish {
long long fish, meat, m;
} a[N];
struct segm {
long long l, r, ind;
};
struct cmps {
bool operator()(segm a, segm b) { return a.l < b.l; }
};
bool inline cmp(segm a, segm b) { return a.r < b.r; }
vector<segm> G[2 * M];
bool mark[N], vis[2 * M];
multiset<segm, cmps> s;
void init() {
for (long long i = 1; i <= n; i++)
G[d[i]].clear(), mark[i] = 0, vis[d[i]] = 0;
}
void Test() {
long long i, j;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i].fish >> a[i].meat >> a[i].m;
d[i] = a[i].fish + a[i].meat - a[i].m;
long long L = d[i] - min(d[i], a[i].meat);
long long R = min(d[i], a[i].fish);
G[d[i]].push_back({L, R, i});
}
long long diversity = 0;
for (long long t = 1; t <= n; t++) {
i = d[t];
if (vis[i]) continue;
vis[i] = 1;
sort(G[i].begin(), G[i].end(), cmp);
s.clear();
for (auto j : G[i]) s.insert(j);
for (j = 0; j < G[i].size(); j++) {
long long ind = G[i][j].ind;
long long l = G[i][j].l;
long long r = G[i][j].r;
if (mark[ind]) continue;
mark[ind] = 1;
++diversity;
while (!s.empty() && s.begin()->l <= r) {
mark[s.begin()->ind] = 1;
fish[s.begin()->ind] = r;
s.erase(s.begin());
}
}
}
cout << diversity << '\n';
for (i = 1; i <= n; i++)
cout << a[i].fish - fish[i] << ' ' << a[i].m - (a[i].fish - fish[i])
<< '\n';
cout << '\n';
init();
}
signed main() {
long long q;
cin >> q;
while (q--) Test();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool smin(T &a, const T &b) {
return a > b ? a = b : a;
}
template <typename T>
inline bool smax(T &a, const T &b) {
return a < b ? a = b : a;
}
const int N = (int)30005, mod = (int)0;
vector<int> adj[N];
int sz[N], mark[N], cyc[N];
long long dp[N], dw_alone[N];
vector<int> c;
int dfs_find_cyc(int v, int p = -1) {
if (mark[v]++) return v + 1;
for (int u : adj[v])
if (u != p) {
int marked_node = dfs_find_cyc(u, v);
if (marked_node == -1) return -1;
if (marked_node) {
cyc[v] = 1;
c.push_back(v);
if (v + 1 == marked_node) return -1;
return marked_node;
}
}
return 0;
}
int n, par[N];
void dfs_down(int v, int p = -1) {
sz[v] = 1;
par[v] = p;
for (int u : adj[v])
if (u != p && !cyc[u]) {
dfs_down(u, v);
sz[v] += sz[u];
dw_alone[v] += dw_alone[u] + sz[u];
}
}
int rev[N], sum[N];
int main() {
cin >> n;
for (int j = 0; j < n; ++j) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs_find_cyc(0);
for (int cur : c) {
dfs_down(cur);
}
for (int j = 0; j < (int)c.size(); ++j) rev[c[j]] = j;
int m = (int)c.size();
for (int j = 0; j < m; ++j) c.push_back(c[j]);
for (int j = 0; j < 2 * m; ++j) sum[j + 1] = sum[j] + sz[c[j]];
for (int sz = 1; sz <= m - 1; ++sz) {
if (sz == 1) {
for (int j = 0; j < 2 * m; ++j) {
int cur = c[j];
dp[j] = ::sz[cur] + dw_alone[cur];
}
} else {
for (int j = 0; j + sz - 1 < 2 * m; ++j) {
int sum_all = sum[j + sz] - sum[j];
int nx = c[j + sz - 1];
dp[j] = max(dp[j] + sum_all + dw_alone[nx],
dp[j + 1] + sum_all + dw_alone[c[j]]);
}
}
}
long long res = 0;
for (int stv = 0; stv < n; ++stv) {
int v = stv;
long long cur_res = 0, to_add = 0;
while (par[v] != -1) {
cur_res += n - to_add;
cur_res -= sz[v];
to_add = sz[v];
v = par[v];
}
cur_res += dw_alone[v];
cur_res += n - to_add;
int pos = rev[v];
cur_res += dp[pos + 1];
res = max(res, cur_res);
}
cout << res << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long p;
long long ksm(long long a, long long b) {
if (!b) return 1;
long long ns = ksm(a, b >> 1);
ns = ns * ns % p;
if (b & 1) ns = ns * a % p;
return ns;
}
long long jc[405], bjc[405];
long long ans[405][405];
long long dp[405];
long long ns[405];
int main() {
int t;
scanf("%d%lld", &t, &p);
jc[0] = bjc[0] = 1;
for (int i = 1; i < 405; i++)
jc[i] = jc[i - 1] * i % p, bjc[i] = ksm(jc[i], p - 2);
for (int i = 0; i < 405; i++)
for (int j = 0; j < 405; j++) {
if (i == 0)
if (j == 0)
ans[i][j] = 1;
else
ans[i][j] = 0;
else {
for (int k = 1; k <= i; k++)
ans[i][j] = (ans[i][j] + jc[k] * ans[i - k][j - 1]) % p;
}
}
ns[1] = 1;
for (int i = 2; i < 405; i++) {
ns[i] = jc[i];
for (int j = 1; j < i; j++) ns[i] -= ns[j] * jc[i - j], ns[i] %= p;
}
dp[1] = 1;
for (int i = 2; i < 405; i++) {
dp[i] = jc[i];
for (int x = 2; x < i; x++) {
long long nans = -1;
if (x >= 3) {
nans *= ans[i][x], nans %= p;
nans *= dp[x], nans %= p;
} else
nans *= 2 * (jc[i] - ns[i]);
dp[i] += nans;
dp[i] %= p;
}
if (dp[i] < 0) dp[i] += p;
}
for (int i = 0; i < t; i++) {
int n;
scanf("%d", &n);
printf("%lld\n", dp[n]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
int n, num, ans, a[N];
map<int, int> cnt;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], cnt[a[i]]++;
for (int i = 0; i < n; i++)
ans = max(ans, cnt[a[i]] + cnt[a[i] + 1] + cnt[a[i] + 2] + cnt[a[i] + 3] +
cnt[a[i] + 4] + cnt[a[i] + 5]);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[105];
int main() {
scanf("%d%d", &n, &m);
for (int x, i = 0; i < n; ++i) scanf("%d", &x), ++a[x];
int cnt = 0, sum = 0;
for (int i = 1; i < 105; ++i) {
if (!a[i]) continue;
++cnt;
sum = max(sum, (a[i] - 1) / m + 1);
}
printf("%d\n", m * sum * cnt - n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
vector<pair<int, int> > v;
vector<pair<int, int> >::iterator it;
int a[MAXN], book[MAXN * 10];
int n, m, k;
bool check(int j) {
int i = 0, last = 0;
while (i < n || j < m) {
if ((i < n && a[i] < last) || (j < m && v[j].first < last)) return 0;
for (int x = 0; x < k; x++) {
if (i < n && (j >= m || a[i] < v[j].first))
i++;
else
j++;
}
last++;
}
return 1;
}
int main() {
int b, cnt = 0;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 1; i <= m; i++) {
scanf("%d", &b), v.push_back(make_pair(b, i));
}
sort(a, a + n);
if (!check(m)) {
printf("-1");
return 0;
}
sort(v.begin(), v.end());
int l = 0, r = m, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", m - l);
for (int i = l; i < m; i++) {
printf("%d ", v[i].second);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double ans, Ax, Ay, Az, vx, vy, vz, R;
void func(double x0, double y0, double z0, double r) {
double t, t1, t2, delta;
double a = vx * vx + vy * vy + vz * vz;
double b = -x0 * vx + Ax * vx - y0 * vy + Ay * vy - z0 * vz + Az * vz;
b *= 2;
double c = (Ax - x0) * (Ax - x0) + (Ay - y0) * (Ay - y0) +
(Az - z0) * (Az - z0) - (r + R) * (r + R);
if (b * b - 4 * a * c >= 0) {
delta = sqrt(b * b - 4 * a * c);
t1 = (-b - delta) / (2 * a);
t2 = (-b + delta) / (2 * a);
if (t1 >= 0)
t = t1;
else if (t2 >= 0)
t = t2;
else
return;
if (ans == -1 || t < ans) ans = t;
}
}
int main() {
cin >> Ax >> Ay >> Az >> vx >> vy >> vz >> R;
int i, m, n;
double px, py, pz, x0, y0, z0, r;
cin >> n;
ans = -1;
for (i = 1; i <= n; i++) {
cin >> x0 >> y0 >> z0 >> r >> m;
func(x0, y0, z0, r);
while (m--) {
cin >> px >> py >> pz;
func(x0 + px, y0 + py, z0 + pz, 0);
}
}
printf("%.10lf", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int BIT[1000006];
void update(int x, int val, int n) {
for (; x <= n; x += (x & -x)) {
BIT[x] += val;
}
return;
}
long long int getSum(int x) {
long long int sum = 0;
for (; x > 0; x -= x & -x) {
sum += BIT[x];
}
return sum;
}
long long int query(int x1, int x2) {
long long int ans = getSum(x2) - getSum(x1);
return ans;
}
int main() {
int n, k;
long long int xx = 0, yy, x, y, ans = 1, ans1, ans2;
scanf("%d", &n);
scanf("%d", &k);
k = min(k, n - k);
for (int i = 0; i < n; i++) {
yy = (xx + k) % n;
x = xx + 1, y = yy + 1;
if (y > x) {
ans1 = query(x, y - 1) + 1;
ans += ans1;
} else {
ans2 = query(x, n) + query(0, y - 1) + 1;
ans += ans2;
}
update(x, 1, n);
update(y, 1, n);
printf("%lld ", ans);
xx = yy;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
void sieve(long long n) {
int arr[n + 1];
memset(arr, -1, sizeof(arr));
for (int i = 2; i * i <= n; i++) {
if (arr[i] == -1) {
for (int j = i * i; j <= n; j += i) arr[j] = 1;
}
}
for (int i = 2; i < n + 1; i++) {
if (arr[i] == -1) v.push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
string s;
cin >> s;
unordered_map<char, int> mp;
char c;
int maxi = INT_MIN;
for (int i = 0; i < s.length(); i++) {
mp[s[i]]++;
if (mp[s[i]] > maxi) {
maxi = mp[s[i]];
c = s[i];
}
}
sieve(s.length());
v.push_back(-1);
string ans(s.length(), '0');
int j = 0;
int f = 1;
for (int i = 1; i < s.length() + 1; i++) {
if (i == 1) continue;
if (i == v[j]) {
j++;
if (s.length() / i == 1) continue;
}
if (mp[c] == 0) {
f = 0;
break;
}
ans[i - 1] = c;
mp[c]--;
}
if (f) {
stack<char> st;
for (auto j : mp) {
int temp = j.second;
while (temp--) st.push(j.first);
}
for (int i = 0; i < s.length(); i++) {
if (ans[i] == '0') {
ans[i] = st.top();
st.pop();
}
}
cout << "YES" << '\n';
cout << ans << '\n';
} else
cout << "NO" << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m;
class cmp {
public:
int operator()(const long long int& a, const long long int& b) {
return m[a] > m[b];
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
map<long long int, long long int> flag;
long long int n, a, i, j, k, f;
cin >> n >> a;
long long int color[n];
set<long long int> s;
std::set<long long int>::iterator it;
for (i = 0; i < n; i++) {
cin >> color[i];
}
for (i = 0; i < n; i++) {
m[color[i]] += 1;
if (color[i] == a) {
if (s.size() == 0) {
cout << -1;
return 0;
}
for (it = s.begin(); it != s.end();) {
if (m[*it] < m[a])
it = s.erase(it);
else
++it;
}
} else if (m[a] == 0)
s.insert(color[i]);
}
if (s.size() == 0)
cout << -1;
else {
cout << *s.begin();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
char ch;
cin >> n >> m;
int a[200] = {0}, b[200] = {0};
set<int> s1, s2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ch;
if (ch == '*') {
a[i]++;
b[j]++;
s1.insert(i), s2.insert(j);
}
}
}
int x, y;
for (auto c : s1) {
if (a[c] == 1) x = c;
}
for (auto c : s2) {
if (b[c] == 1) y = c;
}
cout << x << " " << y << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
scanf("%d %d %d", &a, &b, &n);
int flag = 1;
if (a % b != 0) {
flag = 0;
--n;
for (int i = 0; i <= 9; ++i) {
if ((a * 10 + i) % b == 0) {
a = a * 10 + i;
flag = 1;
break;
}
}
}
if (!flag)
puts("-1");
else {
printf("%d", a);
for (int i = 0; i < n; ++i) printf("0");
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int countZeroGroup(string a) {
int i = 0, count = 0;
while (i < a.size()) {
if (a[i] == '0') {
while (a[i] == '0') {
++i;
}
++count;
} else {
++i;
}
}
return count;
}
int main() {
int n, x, y, count;
string a;
cin >> n >> x >> y >> a;
count = countZeroGroup(a);
if (count == 0) {
cout << 0 << endl;
} else {
cout << 1LL * min(x, y) * (count - 1) + y << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int TestCase;
cin >> TestCase;
string str1;
for (int i = 1; i <= TestCase; i++) {
cin >> str1;
int FirstOne = 0, SecondOne = 0, count = 0;
for (int j = 0; j < str1.length(); j++) {
if (str1[j] == '1') {
FirstOne = j;
}
}
for (int k = str1.length(); k >= 0; k--) {
if (str1[k] == '1') {
SecondOne = k;
count++;
}
}
if (count == 0) {
cout << 0 << "\n";
} else {
cout << FirstOne - SecondOne - count + 1 << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char ch;
bool fh;
inline void read(int &a) {
for (fh = 0, ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') fh = 1;
for (a = 0; ch >= '0' && ch <= '9'; ch = getchar()) (a *= 10) += ch - '0';
if (fh) a = -a;
}
int n, m;
int uplen;
int A[17][10010];
bool Unadj[17][17];
int Arrmap[17];
struct rec {
int x, ne;
} Arre[17 * 17];
int Atop;
inline void ins(int f, int x) {
Arre[++Atop].x = x;
Arre[Atop].ne = Arrmap[f];
Arrmap[f] = Atop;
}
void Restruct() {
int vi, vj;
for (vi = 1; vi <= n; vi++)
for (vj = 1; vj <= n; vj++)
if (Unadj[vi][vj]) ins(vi, vj);
}
bool Untail[17][17];
bool F[17][17][1 << 16];
void init() {
int vi, vj, vk;
for (vi = 1; vi <= n; vi++)
for (vj = 1; vj <= n; vj++) Unadj[vi][vj] = 1;
for (vi = 1; vi <= n; vi++) Unadj[vi][vi] = 0;
for (vi = 1; vi <= n; vi++) Arrmap[vi] = 0;
Atop = 0;
for (vi = 1; vi <= n; vi++)
for (vj = 1; vj <= n; vj++)
for (vk = 1; vk <= uplen; vk++) F[vi][vj][vk] = 0;
}
bool work(int k) {
int vi, vj, vk;
bool fl = 0;
for (vj = 1; vj <= m; vj++) {
for (vi = 1; vi <= n; vi++)
for (vk = vi + 1; vk <= n; vk++)
if (abs(A[vi][vj] - A[vk][vj]) < k) Unadj[vi][vk] = Unadj[vk][vi] = 0;
}
Restruct();
for (vi = 1; vi <= n; vi++)
for (vj = 2; vj <= m; vj++)
for (vk = 1; vk <= n; vk++)
if (abs(A[vi][vj] - A[vk][vj - 1]) < k) Untail[vi][vk] = 1;
int v;
for (vi = 1; vi <= n; vi++) F[vi][vi][1 << (vi - 1)] = 1;
for (vk = 1; vk <= uplen; vk++)
for (vi = 1; vi <= n; vi++)
for (vj = 1; vj <= n; vj++)
if (F[vi][vj][vk]) {
for (v = Arrmap[vj]; v; v = Arre[v].ne)
if (!(vk & (1 << (Arre[v].x - 1))))
F[vi][Arre[v].x][vk | (1 << (Arre[v].x - 1))] = 1;
}
for (vi = 1; vi <= n; vi++) {
if (fl == 1) break;
for (vj = 1; vj <= n; vj++)
if ((!Untail[vi][vj]) && (F[vi][vj][uplen])) {
fl = 1;
break;
}
}
for (vi = 1; vi <= n; vi++)
for (vj = 1; vj <= n; vj++) Untail[vi][vj] = 0;
return fl;
}
bool check(int k) {
init();
return work(k);
}
int main() {
int vi, vj;
read(n);
read(m);
uplen = (1 << n) - 1;
int mid, l = 0, r = 1e9 + 1, minn, maxn, lminn = -(1e9 + 1),
lmaxn = -(1e9 + 1);
for (vi = 1; vi <= n; vi++)
for (vj = 1; vj <= m; vj++) read(A[vi][vj]);
for (vj = 1; vj <= m; vj++) {
minn = 1e9 + 1;
maxn = 0;
for (vi = 1; vi <= n; vi++)
minn = min(minn, A[vi][vj]), maxn = max(maxn, A[vi][vj]);
r = min(r, maxn - minn);
r = min(r, max(max(abs(maxn - lmaxn), abs(maxn - lminn)),
max(abs(minn - lminn), abs(minn - lmaxn))));
lminn = minn;
lmaxn = maxn;
}
if (n == 1) {
int ans = 1e9 + 1;
for (vi = 2; vi <= m; vi++) ans = min(ans, abs(A[1][vi] - A[1][vi - 1]));
printf("%d\n", ans);
return 0;
}
for (; l != r;) {
mid = ((l + r) >> 1) + 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
bool a[2010][2010];
int n;
int kp;
short x[4000010], y[4000010];
bool u[2010][2010];
void dfs(int cx, int cy) {
x[kp] = cx;
y[kp] = cy;
u[cx][cy] = true;
kp++;
for (int q = 0; q < (int)(4); q++) {
int nx = cx + dx[q];
int ny = cy + dy[q];
if (nx >= 0 && ny >= 0 && nx < n && ny < n)
if (a[nx][ny] && !u[nx][ny]) dfs(nx, ny);
}
}
int main() {
scanf("%d", &n);
int z;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) {
scanf("%d", &z);
a[i][j] = z;
}
int ci = 0, sq = 0;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
if (a[i][j] && !u[i][j]) {
kp = 0;
dfs(i, j);
int minX = 3000, maxX = -1, minY = 3000, maxY = -1;
for (int i = 0; i < (int)(kp); i++) {
if (x[i] < minX) minX = x[i];
if (y[i] < minY) minY = y[i];
if (x[i] > maxX) maxX = x[i];
if (y[i] > maxY) maxY = y[i];
}
if (a[minX][minY] + a[minX][maxY] + a[maxX][minY] + a[maxX][maxY] > 2)
sq++;
else
ci++;
}
printf("%d %d\n", ci, sq);
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
if (flag) x = -x;
}
using namespace std;
int n;
int tre[201000];
inline void add(int i, int x) {
while (i <= n) tre[i] += x, i += ((i) & (-(i)));
}
inline int query(int i) {
int res = 0;
while (i) res += tre[i], i -= ((i) & (-(i)));
return res;
}
pair<int, int> ans[201000];
int atot;
inline void Push(int l, int r) {
int L = query(l), R = query(r);
if (L >= R) {
printf("QAQ : Push(%d, %d), L = %d, R = %d\n", l, r, L, R);
exit(-1);
}
ans[++atot] = make_pair(L + 1, R);
add(r, -(R - L));
}
inline void Print() {
printf("%d\n", atot);
for (int i = 1; i <= atot; ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
}
char s[201000];
int pos[201000], ptot;
int pre[201000], nxt[201000];
int cnt[27];
priority_queue<pair<int, int> > q;
set<int> st[27];
inline int Col(int p) { return s[pos[p]] - 'a'; }
inline void Link(int p) {
int q = pre[p];
if (!p || !q) return;
if (Col(p) != Col(q)) {
st[Col(q)].insert(p);
st[Col(p)].insert(p);
}
}
inline void Cancl(int p) {
if (!p || !pre[p] || Col(p) == Col(pre[p])) return;
st[Col(p)].erase(p);
st[Col(pre[p])].erase(p);
}
inline void Cut(int p) {
int q = pre[p];
int pe = pre[q], nt = nxt[p];
--cnt[Col(p)];
if (cnt[Col(p)]) ::q.push(make_pair(cnt[Col(p)], Col(p)));
--cnt[Col(q)];
if (cnt[Col(q)]) ::q.push(make_pair(cnt[Col(q)], Col(q)));
Cancl(q);
Cancl(p);
Cancl(nt);
Push(pos[q], pos[p]);
pre[nt] = pe;
nxt[pe] = nt;
if (nt <= ptot) Link(nt);
}
inline void calc() {
for (int i = 2; i <= ptot; ++i) {
pre[i] = i - 1, nxt[i - 1] = i;
Link(i);
}
pre[1] = 0;
nxt[ptot] = ptot + 1;
nxt[0] = 1;
pre[ptot + 1] = ptot;
for (int i = 1; i <= ptot; ++i) ++cnt[s[pos[i]] - 'a'];
for (int c = 0; c < 26; ++c)
if (cnt[c]) q.push(make_pair(cnt[c], c));
while (q.size()) {
pair<int, int> pr = q.top();
q.pop();
int c = pr.second;
if (cnt[c] != pr.first) continue;
if (!st[c].size()) {
for (int p = nxt[0]; p <= ptot; p = nxt[p]) {
Push(0, pos[p]);
}
break;
}
int p = *st[c].begin();
Cut(p);
}
Push(0, n);
}
inline void work() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i < n; ++i)
if (s[i] == s[i + 1]) pos[++ptot] = i;
for (int i = 1; i <= n; ++i) add(i, 1);
calc();
Print();
}
inline void clear() {
atot = 0;
memset(tre, 0, (n + 3) << 2);
memset(pos, 0, (ptot + 3) << 2);
memset(pre, 0, (ptot + 3) << 2);
memset(nxt, 0, (ptot + 3) << 2);
memset(cnt, 0, sizeof(cnt));
while (q.size()) q.pop();
for (int c = 0; c < 26; ++c) st[c].clear();
ptot = 0;
}
int main() {
int _;
read(_);
while (_--) work(), clear();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void work() {
string s;
cin >> s;
if (s.size() % 2 == 1) {
cout << "NO"
<< "\n";
return;
} else {
int f = 0;
int len = s.size();
for (int i = 0; i < len / 2; i++) {
if (s[i] != s[i + len / 2]) {
f = 1;
}
}
if (f) {
cout << "NO"
<< "\n";
} else {
cout << "YES"
<< " \n";
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
work();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A[500000];
cin >> N;
vector<int> V = {-1, 4, 8, 15, 16, 23, 42};
map<int, int> mp;
for (int i = 0; i < V.size(); i++) mp[V[i]] = i;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
A[i] = mp[a];
}
int dp[7] = {0};
dp[0] = N;
for (int i = 0; i < N; i++) {
if (dp[A[i] - 1] > 0) {
dp[A[i]]++;
dp[A[i] - 1]--;
}
}
int use = 6 * dp[6];
cout << N - use << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int T;
long long a[10080];
long long flag[10080];
int ans = 0;
long long n;
int main() {
cin >> n;
ans = n;
memset(flag, 0, sizeof flag);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j || flag[i] == 1) {
continue;
}
if ((a[j] % a[i] == 0) && (flag[j] == 0)) {
flag[j] = 1;
ans -= 1;
}
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
int flag = 0, flag2 = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (a == b) {
flag++;
} else {
flag2++;
}
}
if (flag2 > 0) {
cout << "Happy Alex" << endl;
} else {
cout << "Poor Alex" << endl;
}
return 0;
}
| 1 |
#include<stdio.h>
int head[512],last[2048],to[2048],cnt=0;
int d[404][404];
void add(int u,int v)
{
cnt++;
last[cnt]=head[u];
head[u]=cnt;
to[cnt]=v;
d[u][v]=1;
}
int main()
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i==j)
{
d[i][j]=0;
}
else
{
d[i][j]=100000000;
}
}
}
while(m--)
{
int u,v;
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(d[i][k]+d[k][j]<d[i][j])
{
d[i][j]=d[i][k]+d[k][j];
}
}
}
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
int num=0;
for(int k=1;k<=n;k++)
{
if(d[i][k]+d[k][j]==d[i][j])
{
num++;
}
}
int ans=1;
if(num!=d[i][j]+1)
{
ans=0;
}
for(int k=1;k<=n;k++)
{
if(d[i][k]+d[k][j]==d[i][j])
{
continue;
}
num=0;
for(int t=head[k];t;t=last[t])
{
int v=to[t];
if(d[i][v]<d[i][k]&&d[j][v]<d[j][k])
{
num++;
}
}
ans=(long long)ans*num%998244353;
}
printf("%d",ans);
if(j==n)
{
putchar('\n');
}
else
{
putchar(' ');
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
int main() {
int t;
cin >> t;
while (t--) {
int n, m, x, y;
cin >> n >> m >> x >> y;
vector<int> v;
string s;
int tot = 0;
for (int i = 0; i < n; i++) {
cin >> s;
int cnt = 0;
for (auto j : s) {
if (j == '.')
cnt++, tot++;
else {
if (cnt) v.push_back(cnt);
cnt = 0;
}
}
if (cnt) v.push_back(cnt);
}
if (2 * x <= y)
cout << tot * x << endl;
else {
int ans = 0;
for (auto i : v) {
ans += (i / 2) * y;
ans += (i % 2) * x;
}
cout << ans << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int init[210000], a[210000], fact[210000];
long long int fastPow(long long int base, int pow) {
long long int ans = 1;
while (pow) {
if (pow & 1) ans = ans * base % 1000000007;
base = base * base % 1000000007;
pow >>= 1;
}
return ans;
}
long long int C(int a, int b) {
return fact[a] * fastPow(fact[b] * fact[a - b] % 1000000007, 1000000007 - 2) %
1000000007;
}
void solve(int n) {
long long int ans = 0, sum1 = 0, sum2 = 0;
int N = n / 2 - 1;
for (int i = 1, id = 0; i <= n; i += 2, id++)
sum1 = (sum1 + C(N, id) * a[i] % 1000000007) % 1000000007;
for (int i = 2, id = 0; i <= n; i += 2, id++)
sum2 = (sum2 + C(N, id) * a[i] % 1000000007) % 1000000007;
if (n % 4 == 2)
ans = ((sum1 + sum2) % 1000000007 + 1000000007) % 1000000007;
else
ans = ((sum1 - sum2) % 1000000007 + 1000000007) % 1000000007;
printf("%I64d\n", ans);
}
int main() {
int n;
fact[0] = 1;
for (int i = 1; i < 210000; i++)
fact[i] = fact[i - 1] * (long long int)i % 1000000007;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &init[i]);
if (n == 1) {
printf("%I64d\n", init[1]);
return 0;
} else if (n % 2 == 0) {
for (int i = 1; i <= n; i++) a[i] = init[i];
solve(n);
} else {
for (int i = 1; i < n; i++) {
if (i % 2 == 1)
a[i] = init[i] + init[i + 1];
else
a[i] = init[i] - init[i + 1];
}
solve(n - 1);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 1e5 + 5;
int n, res[MAXM][2], data[MAXM], num;
bool val[MAXM];
bool isPri(int t) {
if (t % 2 == 0) return false;
int tmp = sqrt(1.0 * t);
for (int i = 2; i <= tmp; i++) {
if (t % i == 0) return false;
}
return true;
}
void cal() {
for (int i = 2; i <= n / 2; i++) {
if (isPri(i)) {
val[i] = true;
data[0] = i;
int tmp = 1;
for (int j = 2 * i; j <= n; j += i) {
if (!val[j]) {
data[tmp++] = j;
}
}
if (tmp % 2 == 0) {
for (int j = 0; j < tmp / 2; j++) {
val[data[j]] = val[data[tmp - 1 - j]] = true;
res[num][0] = data[j];
res[num][1] = data[tmp - 1 - j];
num++;
}
} else {
int t = 0;
for (int j = 0; j < tmp; j++) {
if (j == 1) continue;
val[data[j]] = true;
t++;
if (t == 1) {
res[num][0] = data[j];
}
if (t == 2) {
res[num][1] = data[j];
num++;
t = 0;
}
}
}
}
}
int count = 0;
for (int i = 2; i <= n; i += 2) {
if (!val[i]) {
count++;
if (count == 1) {
res[num][0] = i;
}
if (count == 2) {
res[num][1] = i;
count = 0;
num++;
}
}
}
printf("%d\n", num);
for (int i = 0; i < num; i++) {
printf("%d %d\n", res[i][0], res[i][1]);
}
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) {
val[i] = false;
}
num = 0;
cal();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
char str[20][10] = {"zero", "one", "two", "three",
"four", "five", "six", "seven",
"eight", "nine", "ten", "eleven",
"twelve", "thirteen", "fourteen", "fifteen"};
char tenn[20][10] = {"", "", "twenty", "thirty", "forty",
"fifty", "sixty", "seventy", "eighty", "ninety"};
int main() {
cin >> n;
int x1 = -1, x2 = -1;
if (n <= 15) {
cout << str[n];
} else if (n <= 19) {
x1 = n % 10;
if (n == 18)
cout << "eighteen";
else
cout << str[x1] << "teen";
} else {
x1 = n / 10;
cout << tenn[x1];
if (n % 10) {
x2 = n % 10;
cout << "-" << str[x2];
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:400000000")
int k, b, n, t;
long long ba[1000010];
int main() {
cin >> k >> b >> n >> t;
ba[0] = 1;
for (int i = 0; i < n; i++) {
ba[i + 1] = ba[i] * k + b;
if (ba[i + 1] > t) {
cout << n - i << endl;
return 0;
}
}
cout << 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
long long d[505][10][10];
int main() {
int n;
cin >> n;
d[0][0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= 5; ++j) {
for (int k = 0; k <= 3; ++k) {
for (int nj = 0; nj <= j; ++nj) {
for (int nk = 0; nk <= k; ++nk) {
d[i][j][k] += d[i - 1][nj][nk];
}
}
}
}
}
cout << d[n][5][3];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
vector<int> a;
int main() {
cin >> n;
for (int i = max(0, n - 100); i <= n; i++) {
int y = i, s = 0;
while (y > 0) {
s += y % 10;
y /= 10;
}
if (s + i == n) a.push_back(i);
}
cout << (int)a.size() << '\n';
for (auto i : a) cout << i << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, min = 999999, i, j, a[200001], s, b[200001];
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> a[i];
}
sort(a + 1, a + m + 1);
for (i = 1; i < m; i++) {
b[i] = a[i + 1] - a[i];
}
for (i = 1; i <= m - n + 1; i++) {
s = 0;
for (j = 0; j < n - 1; j++) {
s += b[i + j];
}
if (s < min) min = s;
}
cout << min;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct pairs {
long long a, b;
};
int main() {
int n;
cin >> n;
pairs p[n];
int a[n], b[n];
int ans = -1;
for (int i = 0; i < n; i++) {
cin >> p[i].a >> p[i].b;
a[i] = p[i].a;
b[i] = p[i].b;
}
sort(a, a + n);
sort(b, b + n);
int min = a[0], max = b[n - 1];
int f = 1;
for (int i = 0; i < n; i++) {
if (p[i].a == min && p[i].b == max) ans = i + 1;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[400001], K;
int cnt[400001], N;
map<int, int> m;
int main() {
int num, v = 1;
cin >> N >> K;
for (int i = 0; i < N; ++i) cin >> num, arr[i] = num, m[num] = 1;
map<int, int>::iterator it;
for (it = m.begin(); it != m.end(); ++it) it->second = v, ++v;
for (int i = 0; i < N; ++i) arr[i] = m[arr[i]];
int i = 0, j = 0, mx;
long long sum = 0;
bool flag = false;
while (i < N) {
while (j < N && !flag) {
int num = arr[j];
++cnt[num];
if (cnt[num] == K) mx = num, flag = true;
++j;
}
if (flag) sum += N - j + 1;
cnt[arr[i]]--;
if (mx == arr[i]) flag = false;
++i;
}
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, n, r, sum, nr;
scanf("%d", &t);
for (t; t > 0; --t) {
scanf("%d%d", &n, &r);
sum = 0;
for (i = 1; i < n; ++i) {
scanf("%d", &nr);
sum += nr;
}
nr = (r - 1 + n * n - sum) % n;
printf("%d\n", (nr + n - 1) % n + 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7f7f7f7f;
int main() {
int n;
while (~scanf("%d", &n)) {
int k;
cin >> k;
int a[n];
int sum = 0;
int days = 0;
int donated = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
days++;
if (sum > 8) {
donated += 8;
sum -= 8;
} else {
donated += sum;
sum = 0;
}
if (donated >= k) {
cout << days << endl;
return 0;
}
}
if (donated < k) {
cout << -1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace task {
int n;
char a[10][10];
char b[10][10];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> b[i][j];
}
}
bool ok = true;
for (int i = 0, i1 = 0; i < n && ok; ++i, ++i1) {
for (int j = 0, j1 = 0; j < n && ok; ++j, ++j1) {
ok = a[i][j] == b[i1][j1];
}
}
if (ok) {
cout << "Yes\n";
return 0;
}
ok = true;
for (int i = 0, i1 = 0; i < n && ok; ++i, ++i1) {
for (int j = n - 1, j1 = 0; j >= 0 && ok; --j, ++j1) {
ok = a[i][j] == b[i1][j1];
}
}
if (ok) {
cout << "Yes\n";
return 0;
}
ok = true;
for (int i = n - 1, i1 = 0; i >= 0 && ok; --i, ++i1) {
for (int j = 0, j1 = 0; j < n && ok; ++j, ++j1) {
ok = a[i][j] == b[i1][j1];
}
}
if (ok) {
cout << "Yes\n";
return 0;
}
ok = true;
for (int i = n - 1, i1 = 0; i >= 0 && ok; --i, ++i1) {
for (int j = n - 1, j1 = 0; j >= 0 && ok; --j, ++j1) {
ok = a[i][j] == b[i1][j1];
}
}
if (ok) {
cout << "Yes\n";
return 0;
}
ok = true;
for (int i = 0, i1 = 0; i < n && ok; ++i, ++i1) {
for (int j = 0, j1 = 0; j < n && ok; ++j, ++j1) {
ok = a[j][i] == b[i1][j1];
}
}
if (ok) {
cout << "Yes\n";
return 0;
}
ok = true;
for (int i = 0, i1 = 0; i < n && ok; ++i, ++i1) {
for (int j = n - 1, j1 = 0; j >= 0 && ok; --j, ++j1) {
ok = a[j][i] == b[i1][j1];
}
}
if (ok) {
cout << "Yes\n";
return 0;
}
ok = true;
for (int i = n - 1, i1 = 0; i >= 0 && ok; --i, ++i1) {
for (int j = 0, j1 = 0; j < n && ok; ++j, ++j1) {
ok = a[j][i] == b[i1][j1];
}
}
if (ok) {
cout << "Yes\n";
return 0;
}
ok = true;
for (int i = n - 1, i1 = 0; i >= 0 && ok; --i, ++i1) {
for (int j = n - 1, j1 = 0; j >= 0 && ok; --j, ++j1) {
ok = a[j][i] == b[i1][j1];
}
}
if (ok) {
cout << "Yes\n";
return 0;
}
cout << "No\n";
return 0;
}
} // namespace task
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(11);
cout.setf(ios::fixed);
return task::main();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void sieve(int N) {
bool isPrime[N + 1];
for (int i = 0; i <= N; ++i) {
isPrime[i] = true;
}
isPrime[0] = false;
isPrime[1] = false;
for (int i = 2; i * i <= N; ++i) {
if (isPrime[i] == true) {
for (int j = i * i; j <= N; j += i) isPrime[j] = false;
}
}
}
void machayenge() {
long long int t;
cin >> t;
while (t--) {
long long int x, y;
cin >> x >> y;
long long int dif = x - y;
if (dif <= 1) {
cout << "NO\n";
} else
cout << "YES\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
machayenge();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long b[1510100], n, x;
long long Mod, C;
long long power(long long a, long long n, long long mod) {
if (n == 0) return 1;
long long y;
y = power(a, n / 2, mod);
if (n & 1) {
return (((y * y) % mod) * a) % mod;
} else {
return (y * y) % mod;
}
}
bool func(int mid) {
int i, j, k;
long long EX, sum;
EX = power(x, mid, Mod);
sum = 0;
for (i = 0; i < n; i++) {
if (b[i] >= mid)
break;
else {
sum += power(x, b[i], EX);
sum %= EX;
}
}
if (sum == 0)
return true;
else
return false;
}
int main() {
int i, j, k;
scanf("%d", &n);
scanf("%d", &x);
long long mx, quan;
mx = 0;
quan = 0;
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
mx = max(mx, (long long)a[i]);
quan += a[i];
}
quan = quan - mx;
for (i = 0; i < n; i++) {
b[i] = mx - a[i];
}
sort(b, b + n);
int hi, lo, mid;
hi = mx;
lo = 0;
Mod = 1000000007;
while (hi != lo) {
mid = (hi + lo + 1) / 2;
if (func(mid)) {
lo = mid;
} else {
hi = mid - 1;
}
}
quan += hi;
cout << power(x, quan, Mod);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
int array[101][101] = {0};
bool emptya = 1;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> array[i][j];
if (array[i][j]) emptya = 0;
}
}
if (emptya) {
cout << "YES" << endl;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) cout << 0 << " ";
cout << endl;
}
return 0;
}
bool full, notempty;
vector<int> fullr, fullc;
for (int i = 0; i < m; i++) {
full = 1;
notempty = 0;
for (int j = 0; j < n; j++) {
full = full && array[i][j];
notempty = notempty || array[i][j];
}
if (full) fullr.push_back(i);
if (!notempty) {
cout << "NO" << endl;
return 0;
}
}
for (int j = 0; j < n; j++) {
full = 1;
notempty = 0;
for (int i = 0; i < m; i++) {
full = full && array[i][j];
notempty = notempty || array[i][j];
}
if (full) fullc.push_back(j);
if (!notempty) {
cout << "NO" << endl;
return 0;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
if (array[i][j] && find(fullr.begin(), fullr.end(), i) == fullr.end() &&
find(fullc.begin(), fullc.end(), j) == fullc.end()) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
if (find(fullr.begin(), fullr.end(), i) != fullr.end() &&
find(fullc.begin(), fullc.end(), j) != fullc.end())
cout << 1 << " ";
else
cout << 0 << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[21];
int main() {
a[0] = 1;
a[1] = 0, a[2] = 0, a[3] = 0, a[4] = 1;
a[5] = 0, a[6] = 1, a[7] = 0, a[8] = 2;
a[9] = 1, a[10] = 1, a[11] = 2, a[12] = 0;
a[13] = 1, a[14] = 0, a[15] = 0;
int n, ans = 0;
scanf("%d", &n);
if (n == 0) return 0 * puts("1");
while (n) {
ans += a[n % 16];
n /= 16;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000 * 1000 * 1000 + 7;
long long n, k, a, b, q, type, d, x, p, arr[200005], arrb[200005], tree[200005],
treeb[200005], upd, updb;
void update(int x, long long val) {
while (x < 200005) {
tree[x] += val;
x += (x & -x);
}
}
void updateb(int x, long long val) {
while (x < 200005) {
treeb[x] += val;
x += (x & -x);
}
}
long long sum(int x) {
long long res = 0;
while (x > 0) {
res += tree[x];
x -= (x & -x);
}
return res;
}
long long sumb(int x) {
long long res = 0;
while (x > 0) {
res += treeb[x];
x -= (x & -x);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> type;
if (type == 1) {
cin >> d >> x;
if (arr[d] == a) continue;
if (!arr[d]) {
arr[d] = min(x, a);
arrb[d] = min(arr[d], b);
update(d, arr[d]);
updateb(d, arrb[d]);
continue;
}
if (arr[d] + x > a) {
upd = a - arr[d];
arr[d] = a;
} else {
arr[d] += x;
upd = x;
}
if (arr[d] > b) {
updb = b - arrb[d];
arrb[d] = b;
} else {
arrb[d] += x;
updb = x;
}
update(d, upd);
updateb(d, updb);
} else {
cin >> p;
cout << (sum(n) - sum(p + k - 1)) + sumb(p - 1) << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int count = 0;
string str;
cin >> str;
int A = 0;
int F = 0;
int I = 0;
for (int i = 0; i < n; i++) {
if (str[i] == 'A') {
A++;
} else if (str[i] == 'F') {
F++;
} else if (str[i] == 'I') {
I++;
}
}
if (I == 0) {
cout << A;
return 0;
}
if (I > 1) {
cout << 0;
return 0;
}
cout << I;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int cnt(int x, int p) {
int ret = 0;
for (int i = 1; i <= x; i++) {
if (i % 5 == p) ret++;
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
long long ret = 0;
for (int i = 0; i < 5; i++) {
ret += 1ll * cnt(n, i) * cnt(m, (5 - i) % 5);
}
cout << ret;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct segm {
long long data[100011 * 4 + 1];
segm() { memset(data, 0, sizeof(data)); }
void upd(int node, int l, int r, int pos, long long v) {
if (l == r) {
data[node] = v;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
upd((node << 1), l, mid, pos, v);
else
upd(((node << 1) | 1), mid + 1, r, pos, v);
data[node] = min(data[(node << 1)], data[((node << 1) | 1)]);
}
long long que(int node, int l, int r, int qL, int qR) {
if (qL <= l && r <= qR) return data[node];
int mid = (l + r) >> 1;
long long ans = 1LL << 60;
if (qL <= mid) ans = min(ans, que((node << 1), l, mid, qL, qR));
if (qR > mid) ans = min(ans, que(((node << 1) | 1), mid + 1, r, qL, qR));
return ans;
}
};
long long n, q, i, tp, l, r, x;
long long a[100011];
long long aib[100011], act;
long long dif_l[100011];
long long dif_r[100011];
segm work;
long long zrs(long long x) { return (x ^ (x - 1)) & x; }
void upd(long long x, long long v) {
while (x <= n) {
aib[x] += v;
x += zrs(x);
}
}
long long sum(long long x) {
long long ans = 0;
while (x > 0) {
ans += aib[x];
x -= zrs(x);
}
return ans;
}
long long abss(long long x) {
if (x < 0) return -x;
return x;
}
void refresh(int pos) {
int pre = sum(pos);
int nxt = sum(pos + 1);
dif_l[pos] = max(0LL, sum(pos) - sum(pos + 1));
dif_r[pos] = max(0LL, sum(pos + 1) - sum(pos));
for (int i = max(1, pos - 1); i <= min(n - 2, 1LL * pos); i++) {
work.upd(1, 1, n, i, dif_l[i] + dif_r[i + 1]);
}
}
void update() {
int pre, nxt;
if (l > 1) act -= abss(sum(l) - sum(l - 1));
if (r + 1 <= n) act -= abss(sum(r) - sum(r + 1));
upd(l, +x);
upd(r + 1, -x);
if (l > 1) act += abss(sum(l) - sum(l - 1));
if (r + 1 <= n) act += abss(sum(r) - sum(r + 1));
refresh(l - 1);
refresh(r);
}
long long check(long long pos) {
long long ans = act;
if (pos > 1) ans -= abss(sum(pos - 1) - sum(pos));
if (pos + 1 <= n) ans -= abss(sum(pos + 1) - sum(pos));
upd(pos, +x);
upd(pos + 1, -x);
if (pos > 1) ans += abss(sum(pos - 1) - sum(pos));
if (pos + 1 <= n) ans += abss(sum(pos + 1) - sum(pos));
upd(pos, -x);
upd(pos + 1, +x);
return ans;
}
long long query() {
long long ans = max(check(l), check(r));
if (r - l + 1 >= 3)
ans = max(ans, act + 2LL * x - 2LL * work.que(1, 1, n, l, r - 2));
return ans;
}
int main() {
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
upd(i, a[i] - a[i - 1]);
if (i > 1) act += abss(a[i] - a[i - 1]);
}
for (i = 1; i < n; i++) {
dif_l[i] = max(0LL, a[i] - a[i + 1]);
dif_r[i] = max(0LL, a[i + 1] - a[i]);
}
for (i = 1; i + 2 <= n; i++) work.upd(1, 1, n, i, dif_l[i] + dif_r[i + 1]);
scanf("%lld", &q);
for (i = 1; i <= q; i++) {
scanf("%lld%lld%lld%lld", &tp, &l, &r, &x);
if (tp == 1)
printf("%lld\n", query());
else
update();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string second) {
second += ',';
vector<string> res;
while (!second.empty()) {
res.push_back(second.substr(0, second.find(',')));
second = second.substr(second.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt = clock();
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
b--;
if (b != 0 and b != n - 1) {
a[b - 1] += c - 1;
a[b + 1] += a[b] - c;
a[b] = 0;
} else if (b == 0) {
a[b + 1] += a[b] - c;
a[b] = 0;
} else {
a[b - 1] += c - 1;
a[b] = 0;
}
}
for (auto k : a) cout << k << "\n";
cerr << "TIME = " << (double)1.0 * (clock() - tt) / CLOCKS_PER_SEC
<< " seconds" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
vector<int> G[N];
vector<int> rG[N];
int n, m;
int rdis[N];
bool rvis[N];
int cnt[N];
int k;
int p[N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
rG[v].push_back(u);
}
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> p[i];
}
queue<int> Q;
Q.push(p[k]);
rvis[p[k]] = 1;
while (!Q.empty()) {
int hd = Q.front();
Q.pop();
for (auto v : rG[hd]) {
if (!rvis[v]) {
rdis[v] = rdis[hd] + 1;
rvis[v] = 1;
cnt[v] = 1;
Q.push(v);
} else {
if (rdis[hd] + 1 == rdis[v]) {
cnt[v]++;
}
}
}
}
int mn = 0, mx = 0;
for (int i = 2; i <= k; i++) {
if (rdis[p[i]] < rdis[p[i - 1]]) {
if (cnt[p[i - 1]] > 1) {
mx++;
}
} else {
mn++;
mx++;
}
}
cout << mn << " " << mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, probar[27] = {0};
int res = 0;
char c;
char a[150][150];
cin >> n >> m >> c;
if (n == 1 && m == 1) {
cout << "0";
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == c)
probar[a[i - 1][j] - 'A'] = probar[a[i + 1][j] - 'A'] =
probar[a[i][j - 1] - 'A'] = probar[a[i][j + 1] - 'A'] = 1;
for (int i = 0; i <= 26; i++) res += probar[i];
cout << res - probar[c - 'A'] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
inline int nextInt() {
int x;
if (scanf("%d", &x) != 1) throw;
return x;
}
inline long long nextInt64() {
long long x;
if (scanf("%I64d", &x) != 1) throw;
return x;
}
inline double nextDouble() {
double x;
if (scanf("%lf", &x) != 1) throw;
return x;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int MAXN = 100100;
unsigned long long d[MAXN], ans;
vector<int> g[MAXN];
int n;
unsigned long long DFS(int v, int prev) {
if (prev != -1) g[v].erase(find((g[v]).begin(), (g[v]).end(), prev));
d[v] = 0;
long long sum2 = 0;
for (int i = 0; i < (int)(g[v].size()); i++) {
unsigned long long cur = DFS(g[v][i], v);
sum2 += 1LL * d[v] * cur;
d[v] += cur;
}
d[v]++;
ans -= sqr(sum2);
ans -= 2LL * sum2 * ((n - d[v] + 1) * d[v] - 1);
ans -= 2LL * (d[v] - 1) * ((n - d[v] + 1) * d[v] - 1) - sqr(d[v] - 1);
return d[v];
}
int main() {
n = nextInt();
for (int i = 0; i < (int)(n - 1); i++) {
int v = nextInt() - 1;
int u = nextInt() - 1;
g[v].push_back(u);
g[u].push_back(v);
}
ans = sqr(1LL * n * (n - 1) / 2);
DFS(0, -1);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char ch;
int T, n, x;
int c[100007];
int s[100007], p;
multiset<int, greater<int> > Q;
inline void read(int &x) {
x = 0;
do {
ch = getchar();
} while (ch < '0' || '9' < ch);
do {
x = x * 10 + ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
}
inline void clean() {
for (int i = (1); i <= (n); i++) c[i] = 0;
}
inline int check(const int x) {
int tmp;
if (x == 0) return 1;
p = 0;
for (int i = (0); i <= (x); i++) s[i] = 0;
Q.clear();
for (int i = (1); i <= (n); i++)
if (c[i]) Q.insert(c[i]);
for (int i = (1); i <= (n); i++) {
if (Q.size() == 0) return 0;
tmp = *Q.begin();
Q.erase(Q.begin());
if (s[p]) Q.insert(s[p]);
s[p] = tmp - 1;
p = (p + 1) % x;
}
return 1;
}
inline int slv() {
int l = 0, r = n - 2, mid;
while (r - l > 1) {
mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
if (check(l + 1))
return l + 1;
else
return l;
}
int main(void) {
read(T);
while (T--) {
read(n);
for (int i = (1); i <= (n); i++) {
read(x);
c[x]++;
}
sort(c + 1, c + n + 1);
cout << slv() << endl;
clean();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[10000001], i, j;
void divisor() {
for (i = 1; i <= 1000000; i++) {
for (j = i; j <= 1000000; j += i) a[j]++;
}
}
int main() {
divisor();
long aa, b, c;
while (cin >> aa >> b >> c) {
long long ans = 0, i, j, k, d;
for (i = 1; i <= aa; i++) {
for (j = 1; j <= b; j++) {
for (k = 1; k <= c; k++) {
d = i * j * k;
ans += a[d];
ans = ans % 1073741824;
}
}
}
cout << ans << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string s;
bool isPalin(int a, int b) {
while (a < b) {
if (s[a] != s[b]) return false;
a++;
b--;
}
return true;
}
int main() {
cin >> s;
int mx = 0;
for (int i = 0; i < s.size(); i++) {
for (int j = i; j < s.size(); j++) {
if (!isPalin(i, j)) mx = max(mx, j - i + 1);
}
}
cout << mx << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct data {
long long x, y, s, l;
} t[800001], ansx, ansy;
long long n, m, x, y, p, val = 998244353, mod = 1000000007;
char ch[200001];
long long ksm(long long a, long long b, long long c) {
while (c > 0ll) {
if (c % 2ll) a = (a * b) % mod;
b = (b * b) % mod;
c = c / 2ll;
}
return a;
}
void clean(data &a) {
a.l = 0ll;
a.s = 0ll;
a.x = 0ll;
a.y = 0ll;
}
data merge(data a, data b) {
data s;
clean(s);
if (a.l == 0ll) return b;
if (b.l == 0ll) return a;
if (a.l == 1ll) {
if (b.l == 1ll) {
if (a.s != 1ll || b.s != 1ll) {
s.l = 2ll;
s.s = (a.s * val + b.s) % mod;
s.x = a.x;
s.y = b.y;
}
} else {
if (a.y == 1ll && b.x == 1ll) {
s.l = b.l - 1ll;
s.s = (b.s - ksm(1ll, val, s.l) + mod) % mod;
s.x = 0ll;
s.y = b.y;
} else {
s.l = a.l + b.l;
s.s = (ksm(a.s, val, b.l) + b.s) % mod;
s.x = a.x;
s.y = b.y;
}
}
} else if (b.l == 1ll) {
if (a.y == 1ll && b.x == 1ll) {
s.l = a.l - 1ll;
s.s = (ksm((a.s - 1ll + mod) % mod, val, mod - 2ll) + mod) % mod;
s.x = a.x;
s.y = 0ll;
} else {
s.l = a.l + b.l;
s.s = (ksm(a.s, val, b.l) + b.s) % mod;
s.x = a.x;
s.y = b.y;
}
} else {
if (a.y == 1ll && b.x == 1ll) {
s.l = a.l + b.l - 2ll;
a.s = (ksm((a.s - 1ll + mod) % mod, val, mod - 2ll) + mod) % mod;
b.s = (b.s - ksm(1ll, val, b.l - 1ll) + mod) % mod;
s.s = (ksm(a.s, val, b.l - 1ll) + b.s) % mod;
s.x = a.x;
s.y = b.y;
} else {
s.l = a.l + b.l;
s.s = (a.s * ksm(1ll, val, b.l) + b.s) % mod;
s.x = a.x;
s.y = b.y;
}
}
return s;
}
void build(long long s, long long l, long long r) {
if (l == r) {
if (ch[l] == '0') {
t[s].x = 0ll;
t[s].y = 0ll;
t[s].s = 0ll;
t[s].l = 1ll;
} else {
t[s].x = 1ll;
t[s].y = 1ll;
t[s].s = 1ll;
t[s].l = 1ll;
}
return;
}
long long mid = (l + r) / 2ll;
build(s * 2ll, l, mid);
build(s * 2ll + 1ll, mid + 1ll, r);
t[s] = merge(t[s * 2ll], t[s * 2ll + 1ll]);
}
void find(long long s, long long l, long long r, long long ql, long long qr,
data &v) {
if (l > qr || r < ql) return;
if (ql <= l && r <= qr) {
v = merge(v, t[s]);
return;
}
long long mid = (l + r) / 2ll;
find(s * 2ll, l, mid, ql, qr, v);
find(s * 2ll + 1ll, mid + 1ll, r, ql, qr, v);
}
bool check() {
if (ansx.l == ansy.l && ansx.s == ansy.s) return 1ll;
return 0ll;
}
int main() {
scanf("%lld", &n);
scanf("%s", ch + 1);
build(1ll, 1ll, n);
scanf("%lld", &m);
for (long long i = 1ll; i <= m; i++) {
scanf("%lld%lld%lld", &x, &y, &p);
clean(ansx);
clean(ansy);
find(1ll, 1ll, n, x, x + p - 1ll, ansx);
find(1ll, 1ll, n, y, y + p - 1ll, ansy);
if (check())
printf("Yes\n");
else
printf("No\n");
}
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int mod = 1000000009;
int n, m;
string s[105];
struct vertex {
int next[4];
int go[4];
int c;
int link;
int parent;
int mx;
int len;
vertex() {
memset(next, 255, sizeof(next));
memset(go, 255, sizeof(go));
link = -1;
parent = 0;
len = 0;
mx = -1;
}
};
vertex t[105];
int kv = 1;
int add(int v, int c, int len) {
if (t[v].next[c] == -1) {
t[kv].parent = v;
t[kv].c = c;
t[v].next[c] = kv;
kv++;
}
v = t[v].next[c];
t[v].len = max(t[v].len, len);
return v;
}
int get_go(int v, int c);
int get_link(int v) {
if (t[v].link != -1) return t[v].link;
if (t[v].parent == 0) return t[v].link = 0;
return t[v].link = get_go(get_link(t[v].parent), t[v].c);
}
int get_go(int v, int c) {
if (t[v].go[c] != -1) return t[v].go[c];
if (t[v].next[c] != -1) return t[v].go[c] = t[v].next[c];
if (v == 0) return t[v].go[c] = 0;
return t[v].go[c] = get_go(get_link(v), c);
}
int get_max_len(int v) {
if (t[v].mx != -1) return t[v].mx;
if (v == 0) return 0;
return t[v].mx = max(t[v].len, get_max_len(get_link(v)));
}
int d[1005][105][12];
int get_num(char c) {
if (c == 'A') return 0;
if (c == 'G') return 1;
if (c == 'C') return 2;
if (c == 'T') return 3;
assert(false);
return -1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < int(m); i++) {
cin >> s[i];
int v = 0;
for (int j = 0; j < int(s[i].size()); j++) {
if (j < (int)s[i].size() - 1)
v = add(v, get_num(s[i][j]), 0);
else
v = add(v, get_num(s[i][j]), (int)s[i].size());
}
}
d[0][0][0] = 1;
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(kv); j++) {
for (int k = 0; k < int(12); k++) {
if (d[i][j][k] == 0) continue;
for (int c = 0; c < int(4); c++) {
int nj = get_go(j, c);
int nk = k + 1;
if (get_max_len(nj) >= nk) nk = 0;
if (nk >= 12) continue;
d[i + 1][nj][nk] = (d[i + 1][nj][nk] + d[i][j][k]) % mod;
}
}
}
}
int ans = 0;
for (int i = 0; i < int(kv); i++) {
ans = (ans + d[n][i][0]) % mod;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 305;
const int mod = 1e9 + 7;
using namespace std;
map<int, int> mp;
int n, dp[N], fact[N], C[N][N], g[N];
void add(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
cin >> n;
for (int i = 0; i < N; i++)
for (int j = 0; j <= i; j++)
C[i][j] = ((j == 0) ? 1 : (C[i - 1][j] + C[i - 1][j - 1]) % mod);
for (int i = 0; i < N; i++)
fact[i] = ((i == 0) ? 1 : 1LL * fact[i - 1] * i % mod);
for (int i = 1; i <= n; i++) {
int x, y = 1;
cin >> x;
for (int j = 2; 1LL * j * j <= x; j++) {
int cnt = 0;
while (x % j == 0) cnt ^= 1, x /= j;
if (cnt) y *= j;
}
y *= x;
mp[y]++;
}
n = 0;
dp[0] = 1;
for (auto& pr : mp) {
int x = pr.second;
for (int i = 0; i < N; i++) g[i] = 0;
for (int i = 0; i <= n; i++) {
for (int k = 1; k <= min(n + 1, x); k++) {
for (int s = 0; s <= min(k, i); s++) {
add(g[i - s + x - k], 1LL * C[i][s] * C[n + 1 - i][k - s] % mod *
fact[x] % mod * C[x - 1][k - 1] % mod *
dp[i] % mod);
}
}
}
for (int i = 0; i < N; i++) dp[i] = g[i];
n += x;
}
cout << dp[0];
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int s, gr[20][20], n;
long long dp[1 << 19][20];
long long f(int bt, int a, int k) {
if (dp[bt][a] != -1) return dp[bt][a];
long long ans = 0;
for (int i = s; i < n; i++)
if (gr[i][a] && !(bt & (1 << i)))
ans += f(bt | (1 << i), i, k + 1);
else if (gr[i][a] && i == s && k > 1)
ans++;
return dp[bt][a] = ans;
}
int main() {
int m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
gr[a - 1][b - 1] = gr[b - 1][a - 1] = 1;
}
long long slv = 0;
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++) {
s = i;
slv += f(1 << i, i, 0) / 2;
}
cout << slv << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 10;
vector<int> adj[MAXN];
int match[MAXN], l[MAXN];
bool visited[MAXN], found;
int n, m, p;
void DFS(int u) {
for (int i = 0; i <= (int)(adj[u].size()) - 1; ++i) {
int v = adj[u][i];
if (!visited[v]) {
visited[v] = true;
if (match[v] != 0)
DFS(match[v]);
else
found = true;
if (found) {
match[v] = u;
return;
}
}
}
}
int matching() {
for (int i = 1; i <= m; ++i) match[i] = 0;
for (int i = 1; i <= n; ++i) l[i] = i;
int nlist = n, old = 0;
do {
old = nlist;
for (int i = 1; i <= m; ++i) visited[i] = false;
for (int i = nlist; i >= 1; --i) {
found = false;
DFS(l[i]);
if (found) {
l[i] = l[nlist];
nlist--;
}
}
} while (old != nlist);
return (n - nlist);
}
bool choose[MAXN], elim[MAXN];
vector<int> g[2 * MAXN];
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 1; i <= n; i++) {
int k, v;
scanf("%d", &k);
for (int j = 1; j <= k; j++) {
scanf("%d", &v);
if (v > 0)
g[v].push_back(i);
else
g[m - v].push_back(i);
}
}
for (int i = 1; i <= m; i++) {
if (g[i].size() == 2) {
choose[i] = true;
elim[g[i][0]] = elim[g[i][1]] = true;
}
if (g[i + m].size() == 2) {
elim[g[i + m][0]] = elim[g[i + m][1]] = true;
}
}
int nelim = 0;
for (int i = 1; i <= n; i++) nelim += elim[i];
for (int i = 1; i <= m; i++) {
for (int j : g[i]) {
if (!elim[j]) adj[i].push_back(j);
}
for (int j : g[i + m]) {
if (!elim[j]) adj[i].push_back(j);
}
}
int _n = n, _m = m;
n = _m;
m = _n;
int l = matching();
if (l != m - nelim) {
cout << "NO\n";
return 0;
}
for (int i = 1; i <= m; i++) {
if (match[i] != 0) {
int u = match[i];
if ((g[u].size() > 0) && (g[u][0] == i)) choose[u] = true;
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) printf("%d", ((choose[i]) ? 1 : 0));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
getchar();
string str;
getline(cin, str);
int numxi = 0, numjiu = 0;
char a, b;
for (int i = 0; i < str.length(); i++) {
a = str[i];
b = str[i + 1];
if (b == '\0') break;
if (a == 'S' && a != b)
numxi++;
else if (a == 'F' && a != b)
numjiu++;
}
if (numxi > numjiu)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const int N = 1010;
int n, m, x, y;
double a[N][N], b[N], c[N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> x >> y;
for (int r = n - 1; r >= x; r--) {
if (m == 1) {
a[1][1] = -1.0 / 2.0;
b[1] = -c[r + 1][1] / 2.0 - 1;
} else {
a[1][1] = -1.0 / 2.0;
a[1][1] = a[m][m] = -2.0 / 3.0;
a[1][2] = a[m][m - 1] = 1.0 / 3.0;
b[1] = -c[r + 1][1] / 3.0 - 1;
b[m] = -c[r + 1][m] / 3.0 - 1;
for (int i = 2; i <= m - 1; i++) {
a[i][i - 1] = a[i][i + 1] = 1.0 / 4.0;
a[i][i] = -3.0 / 4.0;
b[i] = -c[r + 1][i] / 4.0 - 1;
}
}
for (int i = 1; i <= m - 1; i++) {
double k = a[i + 1][i] / a[i][i];
a[i + 1][i] -= k * a[i][i];
a[i + 1][i + 1] -= k * a[i][i + 1];
b[i + 1] -= k * b[i];
}
c[r][m] = b[m] / a[m][m];
for (int i = m - 1; i >= 1; i--)
c[r][i] = (b[i] - c[r][i + 1] * a[i][i + 1]) / a[i][i];
}
cout << fixed << setprecision(4) << c[x][y];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n];
for (int i = 0; i < n; i++) cin >> x[i];
int m = x[n - 1] - x[0];
cout << (x[1] - x[0]) << ' ' << m << endl;
for (int i = 1; i < n - 1; i++) {
cout << min(x[i] - x[i - 1], x[i + 1] - x[i]) << ' '
<< max(x[i] - x[0], x[n - 1] - x[i]) << endl;
}
cout << (x[n - 1] - x[n - 2]) << ' ' << m << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string multiply(string num1, string num2) {
int len1 = num1.size();
int len2 = num2.size();
if (len1 == 0 || len2 == 0) return "0";
vector<int> result(len1 + len2, 0);
int i_n1 = 0;
int i_n2 = 0;
for (int i = len1 - 1; i >= 0; i--) {
int carry = 0;
int n1 = num1[i] - '0';
i_n2 = 0;
for (int j = len2 - 1; j >= 0; j--) {
int n2 = num2[j] - '0';
int sum = n1 * n2 + result[i_n1 + i_n2] + carry;
carry = sum / 10;
result[i_n1 + i_n2] = sum % 10;
i_n2++;
}
if (carry > 0) result[i_n1 + i_n2] += carry;
i_n1++;
}
int i = result.size() - 1;
while (i >= 0 && result[i] == 0) i--;
if (i == -1) return "0";
string s = "";
while (i >= 0) s += std::to_string(result[i--]);
return s;
}
string divide(string number, int divisor) {
string ans;
int idx = 0;
int temp = number[idx] - '0';
while (temp < divisor) temp = temp * 10 + (number[++idx] - '0');
while (number.size() > idx) {
ans += (temp / divisor) + '0';
temp = (temp % divisor) * 10 + number[++idx] - '0';
}
if (ans.length() == 0) return "0";
return ans;
}
int main() {
int spf[100000];
for (int i = 0; i < 100000; ++i) {
spf[i] = i;
}
for (int i = 4; i < 100000; i += 2) {
spf[i] = 2;
}
for (int i = 3; i * i < 100000; ++i) {
if (spf[i] == i) {
for (int j = i * i; j < 100000; j += i) {
if (spf[j] == j) {
spf[j] = i;
}
}
}
}
vector<int> primes;
for (int i = 2; i < 100000; ++i) {
if (spf[i] == i) {
primes.push_back(i);
}
}
int n;
cin >> n;
if (n == 2) {
cout << "-1" << endl;
return 0;
}
string ans = "1";
for (int i = 0; i < n; ++i) {
ans = multiply(ans, to_string(primes[i]));
}
for (int i = 0; i < n; ++i) {
cout << divide(ans, primes[i]) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500050;
int n, a, b, t;
char s[maxn];
int val[maxn << 1];
int sum[maxn << 1];
int main() {
scanf("%d%d%d%d", &n, &a, &b, &t);
scanf("%s", s + 1);
for (register int i = 1; i <= n; i++) {
val[i] = val[i + n] = (s[i] == 'w' ? b + 1 : 1);
}
for (register int i = n; i > 1; i--) {
sum[i] = sum[i + 1] + val[i];
}
for (register int i = n + 2; i <= 2 * n; i++) {
sum[i] = sum[i - 1] + val[i];
}
int ans = 0;
for (register int i = 2, j = n + 1; i <= n + 1 && j <= n * 2; i++) {
int res = val[n + 1] + sum[i] + sum[j] +
min((n + 1) - i, j - (n + 1)) * 2 * a +
max((n + 1) - i, j - (n + 1)) * a;
if (res > t) continue;
while (res <= t) {
int nex = val[n + 1] + sum[i] + sum[j + 1] +
min((n + 1) - i, (j + 1) - (n + 1)) * 2 * a +
max((n + 1) - i, (j + 1) - (n + 1)) * a;
if (nex <= t) {
j++;
res = nex;
} else
break;
}
if (j > n * 2) {
j = n * 2;
ans = max(ans, min(n, j - i + 1));
break;
}
ans = max(ans, min(n, j - i + 1));
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1234;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int x, y;
cin >> x >> y;
int k;
cin >> k;
long long ans = 0;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
int d1 = 2e9, d2 = 2e9;
if (a > 0) {
d1 = (n - x) / a;
}
if (a < 0) {
d1 = (x - 1) / (-1 * a);
}
if (b > 0) {
d2 = (m - y) / b;
}
if (b < 0) {
d2 = (y - 1) / (-1 * b);
}
int d = min(d1, d2);
ans += d;
x += a * d;
y += b * d;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[35010], pre[35010], lst[35010];
int vis[35010];
struct SegmentTree {
int tr[35010 << 2], lab[35010 << 2];
void update(int x) { tr[x] = max(tr[(x << 1)], tr[(x << 1 | 1)]); }
void push_down(int x) {
if (lab[x]) {
tr[(x << 1)] += lab[x];
lab[(x << 1)] += lab[x];
tr[(x << 1 | 1)] += lab[x];
lab[(x << 1 | 1)] += lab[x];
lab[x] = 0;
}
}
void modify(int x, int l, int r, int a, int b, int ad) {
if (a <= l && r <= b) {
lab[x] += ad;
tr[x] += ad;
return;
}
push_down(x);
int mid = l + r >> 1;
if (a <= mid) modify((x << 1), l, mid, a, b, ad);
if (b > mid) modify((x << 1 | 1), mid + 1, r, a, b, ad);
update(x);
}
int query(int x, int l, int r, int a, int b) {
if (a <= l && r <= b) return tr[x];
int mid = l + r >> 1;
push_down(x);
int res = 0;
if (a <= mid) res = max(res, query((x << 1), l, mid, a, b));
if (b > mid) res = max(res, query((x << 1 | 1), mid + 1, r, a, b));
update(x);
return res;
}
} tree[55];
int f[35010][55];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
f[i][1] = f[i - 1][1] + (!vis[a[i]]);
pre[i] = vis[a[i]];
vis[a[i]] = i;
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
tree[1].modify(1, 1, n, i, i, f[i][1]);
for (int j = 2; j <= min(i, m); ++j) {
tree[j - 1].modify(1, 1, n, pre[i], i - 1, 1);
f[i][j] = tree[j - 1].query(1, 1, n, 1, i - 1);
tree[j].modify(1, 1, n, i, i, f[i][j]);
}
}
printf("%d\n", f[n][m]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 22;
int n, ct = 1;
vector<pair<int, int> > vec;
int ver[N];
struct node {
int l, r, pr, sf, sz, res;
node() {
l = r = -1;
pr = sf = sz = res = 0;
}
} zx[50 * N];
void build(int v, int s, int e) {
zx[v].sz = e - s;
if (s == e - 1) return;
zx[v].l = ct++;
zx[v].r = ct++;
build(zx[v].l, s, (s + e) / 2);
build(zx[v].r, (s + e) / 2, e);
}
node merge(node x, node y) {
node z;
z.sz = x.sz + y.sz;
z.res = max(max(x.res, y.res), x.sf + y.pr);
z.pr = x.pr + (x.pr == x.sz) * y.pr;
z.sf = y.sf + (y.sf == y.sz) * x.sf;
return z;
}
int upd(int pv, int s, int e, int p) {
int id = ct++;
zx[id].sz = zx[pv].sz;
if (s == e - 1) {
zx[id].res = zx[id].pr = zx[id].sf = 1;
return id;
}
zx[id].l = zx[pv].l, zx[id].r = zx[pv].r;
if (p < (s + e) / 2)
zx[id].l = upd(zx[pv].l, s, (s + e) / 2, p);
else
zx[id].r = upd(zx[pv].r, (s + e) / 2, e, p);
int L = zx[id].l, R = zx[id].r;
zx[id] = merge(zx[L], zx[R]);
zx[id].l = L, zx[id].r = R;
return id;
}
node get(int id, int s, int e, int l, int r) {
if (l <= s && e <= r) return zx[id];
if (l >= e || s >= r) return node();
return merge(get(zx[id].l, s, (s + e) / 2, l, r),
get(zx[id].r, (s + e) / 2, e, l, r));
}
int main() {
ios::sync_with_stdio(false);
int x, y, q;
cin >> n;
for (int i = 0; i < (n); i++) cin >> x, vec.push_back({x, i});
build(0, 0, n);
sort(vec.rbegin(), vec.rend());
for (int i = 0; i < (vec.size()); i++)
ver[i + 1] = upd(ver[i], 0, n, vec[i].second);
cin >> q;
while (q--) {
int l, r, w, low = 0, high = n - 1;
cin >> l >> r >> w, l--;
while (low <= high) {
int mid = (low + high) / 2;
if (get(ver[mid + 1], 0, n, l, r).res < w)
low = mid + 1;
else
high = mid - 1;
}
cout << vec[low].first << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int MAXN = 2e6 + 7;
int n, m, q;
int home[MAXN], next[MAXN], to[MAXN];
int ans[MAXN];
int dp[MAXN], ccnt, tmp, cnt;
inline void ct(const int& x, const int& y) {
ccnt++;
next[ccnt] = home[x];
home[x] = ccnt;
to[ccnt] = y;
return;
}
inline void dfs(int u, int fa, int len) {
dp[u] = 0;
int maxx1 = 0;
int maxx2 = 0;
for (int i = home[u]; i; i = next[i]) {
int v = to[i];
if (v == fa) {
continue;
}
dfs(v, u, len);
if (dp[v] > maxx1) {
maxx2 = maxx1;
maxx1 = dp[v];
} else if (dp[v] > maxx2) {
maxx2 = dp[v];
}
}
if (maxx1 + maxx2 + 1 >= len) {
cnt++;
dp[u] = 0;
} else {
dp[u] = maxx1 + 1;
}
return;
}
inline void Dic(int l, int r, int L, int R) {
if (l > r || L > R) return;
if (L == R) {
for (int i = l; i <= r; i++) {
ans[i] = L;
}
return;
}
int mid = (l + r) >> 1;
cnt = 0;
dfs(1, 0, mid);
ans[mid] = cnt;
Dic(l, mid - 1, cnt, R);
Dic(mid + 1, r, L, cnt);
return;
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
ct(x, y);
ct(y, x);
}
Dic(1, n, 0, n);
for (int i = 1; i <= n; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int DIM = 2222;
int dp[DIM], fth[DIM], dst[DIM], aux[DIM];
int cap[DIM][DIM], cst[DIM][DIM];
bitset<DIM> mrk;
vector<int> edg[DIM];
deque<int> que;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
prq;
inline bool bf(int s, int d) {
fill(dst, dst + DIM, numeric_limits<int>::max());
dst[s] = 0;
mrk.reset();
mrk[s] = 1;
for (que.push_back(s); que.empty() == false; que.pop_front()) {
int x = que.front();
mrk[x] = false;
for (int y : edg[x]) {
if (cap[x][y] != 0 && dst[y] > dst[x] + cst[x][y]) {
dst[y] = dst[x] + cst[x][y];
fth[y] = x;
if (y != d && mrk[y] == false) {
mrk[y] = true;
que.push_back(y);
}
}
}
}
return (dst[d] != numeric_limits<int>::max());
}
inline bool dj(int s, int d) {
fill(dp, dp + DIM, numeric_limits<int>::max());
fill(aux, aux + DIM, numeric_limits<int>::max());
dp[s] = aux[s] = 0;
for (prq.push(make_pair(0, s)); prq.empty() == false;) {
pair<int, int> x = prq.top();
prq.pop();
if (dp[x.second] != x.first) continue;
for (int y : edg[x.second]) {
if (cap[x.second][y] != 0 &&
dp[y] > dp[x.second] + dst[x.second] - dst[y] + cst[x.second][y]) {
dp[y] = dp[x.second] + dst[x.second] - dst[y] + cst[x.second][y];
aux[y] = aux[x.second] + cst[x.second][y];
fth[y] = x.second;
if (y != d) prq.push(make_pair(dp[y], y));
}
}
}
memcpy(dst, aux, sizeof(aux));
return (dp[d] != numeric_limits<int>::max());
}
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cap[0][i] = 1;
cst[0][i] = x;
cap[i][0] = 0;
cst[i][0] = -x;
edg[0].push_back(i);
edg[i].push_back(0);
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cap[i][n + 1] = 1;
cst[i][n + 1] = x;
cap[n + 1][i] = 0;
cst[n + 1][i] = -x;
edg[i].push_back(n + 1);
edg[n + 1].push_back(i);
}
for (int i = 1; i < n; ++i) {
cap[i][i + 1] = k;
edg[i].push_back(i + 1);
edg[i + 1].push_back(i);
}
cap[n + 2][0] = k;
edg[n + 2].push_back(0);
edg[0].push_back(n + 2);
int s = n + 2, d = n + 1;
bf(s, d);
long long cmn = 0;
while (dj(s, d)) {
int mnm = numeric_limits<int>::max();
for (int i = d; i != s; i = fth[i]) mnm = min(mnm, cap[fth[i]][i]);
cmn += dst[d] * mnm;
for (int i = d; i != s; i = fth[i]) {
cap[fth[i]][i] -= mnm;
cap[i][fth[i]] += mnm;
}
}
printf("%I64d\n", cmn);
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.