solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O0")
#pragma GCC optimize("O1")
long long pw(long long a, long long b) {
long long ret = 1;
long long mul = a;
while (b > 0) {
if (b & 1) ret = (ret * mul) % (1000000007);
mul = (mul * mul) % (1000000007);
b /= 2;
}
return ret;
}
long long to_int(string s) {
long long ret = 0;
for (int(i) = (0); (i) < (s.size()); (i)++) {
ret += pw(10, s.size() - i - 1) * (long long)(s[i] - '0');
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int tt;
cin >> tt;
vector<vector<long long> > bin(1000100);
for (int(i) = (0); (i) < (1000100); (i)++) bin[i].resize(min(i + 1, 25));
for (int(i) = (0); (i) < (1000100); (i)++) {
if (i < 25) bin[i][i] = 1;
bin[i][0] = 1;
}
for (int(i) = (1); (i) < (1000100); (i)++) {
for (int(j) = (1); (j) < (min(i, 25)); (j)++) {
bin[i][j] = (bin[i - 1][j] + bin[i - 1][j - 1]) % (1000000007);
}
}
while (tt--) {
int x, n;
cin >> x >> n;
vector<int> pf;
int bs = x;
for (int i = 2; i * i <= bs; i++) {
long long a = 0;
while (x % i == 0) x /= i, a++;
if (a) pf.push_back(a);
if (x == 1) break;
}
if (x != 1) pf.push_back(1);
long long ans = 1;
for (int(i) = (0); (i) < (pf.size()); (i)++) {
int k = pf[i];
ans = (ans * (bin[n + k - 1][k])) % (1000000007);
}
ans = (ans * pw(2, n - 1)) % (1000000007);
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void Solve() {
long long a[3];
for (signed i = 0; i < (3); i++) cin >> a[i];
long long cnt = 0;
for (signed i = 0; i < (3); i++) {
long long q;
cin >> q;
a[i] -= q;
if (a[i] >= 0)
cnt += a[i] / 2;
else
cnt += a[i];
}
cout << (cnt >= 0 ? "Yes" : "No");
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> mam[200000];
int w1[200000];
int w2[200000];
vector<int> li;
int main() {
int a, b, n, i, j, k, br = 0;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> w1[i];
for (i = 0; i < n; i++) cin >> w2[i];
for (i = 0; i < n; i++) mam[w1[i]].push_back(w2[i]);
for (i = 1; i <= k; i++) {
if (mam[i].size() == 0) br++;
sort(mam[i].begin(), mam[i].end());
for (j = 0; j < (int)mam[i].size() - 1; j++) {
li.push_back(mam[i][j]);
}
}
long long ans = 0;
sort(li.begin(), li.end());
for (i = 0; i < br; i++) {
ans += (long long)li[i];
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int z = 1000000000;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, x;
cin >> n;
vector<long long int> a(n + 1);
long long int ans = -1;
for (int i = 1; i <= (n + 1) / 2; i++) {
cin >> a[i];
}
cin >> x;
for (int i = (n + 1) / 2 + 1; i <= n; i++) {
a[i] = x;
}
vector<long long int> prefix(n + 1);
a[0] = 0;
prefix[0] = 0;
vector<long long int> prefix2(n + 1);
prefix2[0] = INT_MIN;
for (int i = 1; i <= n; i++) {
prefix[i] = prefix[i - 1] + a[i];
long long int curr_max = prefix[i] - i * x;
prefix2[i] = max(prefix2[i - 1], curr_max);
}
for (long long int i = (n + 1) / 2; i <= n; i++) {
if (prefix[i] > 0 && prefix2[n - i] < prefix[i]) {
ans = i;
break;
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 100000000000ll;
int n, K, a[200001], sum[200001], vis[200001];
long long f[25][200001], val;
void work(const int &K, int l, int r, int ll, int rr) {
if (l > r) return;
int mid = (l + r) >> 1, aim = 0;
for (int i = l; i <= mid; ++i) {
assert(!vis[i]);
val += sum[a[i]];
++sum[a[i]];
vis[i] = 1;
}
for (int i = ll; i <= min(rr, mid - 1); ++i) {
if (val + f[K - 1][i] < f[K][mid]) {
f[K][mid] = val + f[K - 1][i];
aim = i;
}
assert(vis[i + 1]);
--sum[a[i + 1]];
val -= sum[a[i + 1]];
vis[i + 1] = 0;
}
for (int i = ll; i <= min(rr, mid - 1); ++i) {
assert(!vis[i + 1]);
val += sum[a[i + 1]];
++sum[a[i + 1]];
vis[i + 1] = 1;
}
for (int i = l; i <= mid; ++i) {
assert(vis[i]);
--sum[a[i]];
val -= sum[a[i]];
vis[i] = 0;
}
work(K, l, mid - 1, ll, aim);
for (int i = l; i < mid + 1; ++i) {
assert(!vis[i]);
val += sum[a[i]];
++sum[a[i]];
vis[i] = 1;
}
for (int i = ll + 1; i <= aim; ++i) {
assert(vis[i]);
--sum[a[i]];
val -= sum[a[i]];
vis[i] = 0;
}
work(K, mid + 1, r, aim, rr);
for (int i = ll + 1; i <= aim; ++i) {
assert(!vis[i]);
val += sum[a[i]];
++sum[a[i]];
vis[i] = 1;
}
for (int i = l; i < mid + 1; ++i) {
--sum[a[i]];
val -= sum[a[i]];
assert(vis[i]);
vis[i] = 0;
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 0; i <= K; ++i)
for (int j = 0; j <= n; ++j) f[i][j] = INF;
f[0][0] = 0;
for (int i = 1; i <= K; ++i) work(i, i, n, i - 1, n);
printf("%I64d\n", f[K][n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, i, temp;
long long t;
cin >> n >> k;
vector<long long> v;
for (i = 1; i <= n; i++) {
cin >> t;
v.push_back(t);
}
if (k > n) {
cout << "-1";
return 0;
} else if (k == n) {
cout << "0 0";
return 0;
}
sort(v.begin(), v.end());
temp = n - k;
cout << v[temp - 1] + 1 << " " << v[temp - 1] + 1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
long long int n, m;
cin >> n >> m;
vector<long long int> arr(n);
for (long long int i = 0; i < n; ++i) cin >> arr[i];
vector<pair<long long int, long long int>> q;
for (long long int i = 0; i < m; ++i) {
long long int a, b;
cin >> a >> b;
q.push_back(make_pair(a, b));
}
long long int count[n + 1];
for (long long int i = 0; i < n + 1; ++i) count[i] = 0;
for (long long int i = 0; i < n; ++i) {
if (arr[i] <= n) count[arr[i]]++;
}
long long int ans[m];
for (long long int i = 0; i < m; ++i) ans[i] = 0;
for (long long int i = 1; i <= n; i++) {
if (count[i] >= i) {
long long int cumsum[n + 1];
cumsum[0] = 0;
for (long long int j = 0; j < n; ++j) {
if (j == 0)
cumsum[j + 1] = (arr[j] == i) ? 1 : 0;
else {
cumsum[j + 1] = cumsum[j] + ((arr[j] == i) ? 1 : 0);
}
}
for (long long int j = 0; j < m; ++j) {
if (cumsum[q[j].second] - cumsum[q[j].first - 1] == i) ans[j]++;
}
}
}
for (long long int i = 0; i < m; ++i) cout << ans[i] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 1501000;
struct node {
node *s[2], *f, *minv;
int val, d, id;
bool rev;
bool isr() { return !f || (f->s[0] != this && f->s[1] != this); }
bool dir() { return f->s[1] == this; }
void setc(node *c, int d) {
s[d] = c;
if (c) c->f = this;
}
void push() {
if (rev) {
swap(s[0], s[1]);
for (int i = 0; i < 2; i++)
if (s[i]) s[i]->rev ^= 1;
}
rev = 0;
}
void upd() {
minv = this;
val = d;
for (int i = 0; i < 2; i++)
if (s[i] && s[i]->val > val) val = s[i]->val, minv = s[i]->minv;
}
} pool[N], *cur;
stack<node *> sta;
void rot(node *x) {
node *p = x->f;
bool d = x->dir();
if (!p->isr())
p->f->setc(x, p->dir());
else
x->f = p->f;
p->setc(x->s[!d], d);
x->setc(p, !d);
p->upd();
}
void splay(node *x) {
node *q = x;
while (1) {
sta.push(q);
if (q->isr()) break;
q = q->f;
}
while (!sta.empty()) sta.top()->push(), sta.pop();
while (!x->isr()) {
if (x->f->isr())
rot(x);
else if (x->isr() == x->f->isr())
rot(x->f), rot(x);
else
rot(x), rot(x);
}
x->upd();
}
node *expose(node *x) {
node *q = NULL;
for (; x; x = x->f) splay(x), x->s[1] = q, (q = x)->upd();
return q;
}
void evert(node *x) {
expose(x);
splay(x);
x->rev ^= 1;
x->push();
}
void expose(node *x, node *y) {
evert(x);
expose(y);
splay(x);
}
void link(node *x, node *y) {
evert(x);
evert(y);
x->setc(y, 1);
}
void cut(node *x, node *y) {
expose(x, y);
x->s[1] = y->f = NULL;
}
const int inf = 1 << 30;
int n, Q, x[N], y[N];
map<pair<int, int>, int> hs;
int main() {
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) pool[i].d = -1;
cur = pool + n + 1;
for (int i = 1; i < n; i++) {
scanf("%d%d", x + i + n, y + i + n);
if (x[i + n] > y[i + n]) swap(x[i + n], y[i + n]);
}
for (int i = 1; i < n; i++) {
scanf("%d%d", x + i, y + i);
if (x[i] > y[i]) swap(x[i], y[i]);
hs[make_pair(x[i], y[i])] = 0;
}
int ret = n - 1;
for (int i = 1; i < n; i++) {
node *w = cur++;
w->d = inf;
w->id = i + n;
if (hs.count(make_pair(x[i + n], y[i + n]))) {
hs[make_pair(x[i + n], y[i + n])] = 1;
w->d = 0;
--ret;
}
link(w, pool + x[i + n]);
link(w, pool + y[i + n]);
}
printf("%d\n", ret);
for (int i = 1; i < n; i++)
if (hs[make_pair(x[i], y[i])] == 0) {
node *u = pool + x[i], *v = pool + y[i];
expose(u, v);
node *w = u->minv;
expose(w, w);
printf("%d %d %d %d\n", x[w->id], y[w->id], x[i], y[i]);
cut(pool + x[w->id], w);
cut(pool + y[w->id], w);
w = cur++;
w->d = 0;
w->id = i;
link(w, pool + x[i]);
link(w, pool + y[i]);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const long long N = 1e5 + 5, M = 1e9 + 7, H = 31;
long long ans[105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, i, j, k, m, f, cnt = 1e18;
cin >> n >> f >> m;
vector<long long> frogs(f), mos(m), anss;
for (auto &p : frogs) cin >> p;
for (auto &p : mos) cin >> p;
i = 0;
for (auto p : frogs) {
long long tcnt = 0;
for (auto q : mos)
if ((q) % p == 0) tcnt++;
cnt = min(cnt, tcnt);
ans[i] = tcnt;
i++;
}
for (i = 0; i < f; i++) {
if (ans[i] == cnt) {
anss.push_back(i + 1);
}
}
cout << anss.size() << endl;
for (auto p : anss) cout << p << ' ';
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int deg[n], xor1[n];
vector<long long int> leaf;
vector<pair<long long int, long long int> > ans;
for (long long int i = 0; i < n; i++) {
cin >> deg[i] >> xor1[i];
if (deg[i] == 1) leaf.push_back(i);
}
while (leaf.size()) {
vector<long long int> temp;
for (long long int i = 0; i < leaf.size(); i++) {
if (deg[leaf[i]] != 1) continue;
ans.push_back({leaf[i], xor1[leaf[i]]});
xor1[xor1[leaf[i]]] ^= leaf[i];
deg[xor1[leaf[i]]]--;
if (deg[xor1[leaf[i]]] == 1) temp.push_back(xor1[leaf[i]]);
}
leaf.clear();
for (long long int i = 0; i < temp.size(); i++) {
if (deg[temp[i]] == 1) leaf.push_back(temp[i]);
}
}
cout << ans.size() << endl;
for (long long int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100000 + 10], b[100000 + 10];
int min(int m, int n) {
if (m < n) return m;
return n;
}
int main() {
int m, n, t, j;
scanf("%d%d%d", &m, &n, &t);
int i, k, cnt = t, flag;
for (i = 1; i <= m; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
sort(a + 1, a + 1 + m);
sort(b + 1, b + 1 + n);
if (a[m] + t < b[1])
printf("0 0\n");
else {
int l = 1, r = min(m, n) + 1;
while (l < r) {
k = (l + r) / 2, t = cnt;
for (i = 1, j = m - k + 1; i <= k; i++, j++) {
if (t < 0) break;
if (b[i] > a[j]) t = t - b[i] + a[j];
}
if (t >= 0)
l = k + 1;
else
r = k;
}
int ans = -cnt;
for (i = 1; i < l; i++) ans = ans + b[i];
if (ans > 0)
printf("%d %d\n", l - 1, ans);
else
printf("%d 0\n", l - 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1000 + 17;
int n, init[MAXN][MAXN], hope[MAXN][MAXN], c[MAXN][MAXN], r[MAXN],
cnt = 1, comp[MAXN << 2];
vector<int> out[MAXN << 2], in[MAXN << 2], order, trash;
vector<pair<string, int>> ans;
void add(int i, bool f1, int j, bool f2) {
int v = (i << 1) | f1, u = (j << 1) | f2;
out[v].push_back(u);
in[u].push_back(v);
out[u ^ 1].push_back(v ^ 1);
in[v ^ 1].push_back(u ^ 1);
}
void scc(int v, vector<int> g[], vector<int> &vec) {
comp[v] = cnt;
for (auto i : g[v])
if (!comp[i]) scc(i, g, vec);
vec.push_back(v);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
char C;
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> C, init[i][j] = int(C - '0');
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
cin >> C, hope[i][j] = int(C - '0'), c[i][j] = init[i][j] ^ hope[i][j];
for (int i = 1; i <= n; i++) cin >> C, r[i] = int(C - '0');
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (c[i][j] && r[i] && r[j])
add(i, true, n + j, false), add(i, false, n + j, true);
else if (c[i][j] && r[i] && !r[j])
add(i, true, n + j, true), add(i, false, n + j, true);
else if (c[i][j] && !r[i] && r[j])
add(n + j, true, i, true), add(n + j, false, i, true);
else if (c[i][j] && !r[i] && !r[j])
return cout << -1 << endl, 0;
else if (!c[i][j] && r[i] && r[j])
add(i, true, n + j, true), add(i, false, n + j, false);
else if (!c[i][j] && r[i] && !r[j])
add(i, true, n + j, false), add(i, false, n + j, false);
else if (!c[i][j] && !r[i] && r[j])
add(n + j, true, i, false), add(n + j, false, i, false);
else
;
for (int i = 1; i <= ((n << 2) | 1); i++)
if (!comp[i]) scc(i, out, order);
cnt = 0;
memset(comp, 0, sizeof(comp));
for (int i = (n << 1); ~i; i--) {
int v = order[i];
if (!comp[v]) cnt++, scc(v, in, trash);
}
for (int i = 1; i <= (n << 1); i++) {
if (comp[i << 1] == comp[i << 1 | 1]) return cout << -1 << endl, 0;
if (comp[i << 1 | 1] > comp[i << 1]) {
if (i > n)
ans.push_back({"col", i - n - 1});
else
ans.push_back({"row", i - 1});
}
}
cout << ans.size() << endl;
for (auto i : ans) cout << i.first << ' ' << i.second << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void file() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T>
void _print(set<T, greater<int>> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T, greater<int>> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
void solve() {
string s1, s2;
cin >> s1 >> s2;
int n1 = s1.size(), n2 = s2.size();
string temp = s1;
if (n2 > n1) {
cout << temp << endl;
return;
}
vector<int> v(n2, -1);
int j = 0;
for (int i = 1; i < n2; i++) {
if (s2[i] == s2[j]) {
v[i] = j;
j++;
} else {
j = 0;
if (s2[i] == s2[j]) {
v[i] = j;
j++;
}
}
};
int zero = 0, one = 0;
for (char ch : s1) {
ch == '1' ? one++ : zero++;
}
bool flag = 1;
for (int i = 0; i < n2; i++) {
if (s2[i] == '0' and zero) {
zero--;
s1[i] = '0';
} else if (s2[i] == '1' and one) {
one--;
s1[i] = '1';
} else {
flag = 0;
break;
}
}
if (flag == 0) {
cout << temp << endl;
return;
};
;
;
j = v[n2 - 1] + 1;
int ii = n2;
for (int i = n2; i < n1; i++) {
if (s2[j] == '0' and zero) {
s1[i] = '0';
zero--;
j++;
} else if (s2[j] == '1' and one) {
s1[i] = '1';
one--;
j++;
} else {
break;
}
if (j == n2) j = v[n2 - 1] + 1;
ii++;
};
while (ii < n1) {
if (one) {
s1[ii] = '1';
one--;
} else if (zero) {
s1[ii] = '0';
zero--;
} else {
break;
}
ii++;
};
;
cout << s1 << endl;
}
int32_t main() {
file();
int test = 1;
while (test--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
const int INF = 0x3f3f3f3f;
const long long inf = -2e18;
char s[N][N];
int id[N][N], sta[N * N], n, k, cnt, siz[N * N];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int main() {
auto ck = [&](int x, int y) {
return x >= 1 && x <= n && y >= 1 && y <= n && s[x][y] == '.';
};
function<void(int, int, int)> dfs = [&](int x, int y, int num) {
if (id[x][y]) return;
id[x][y] = num;
siz[num]++;
for (int i = 0; i < 4; i++)
if (ck(x + dx[i], y + dy[i])) dfs(x + dx[i], y + dy[i], num);
};
auto add = [&](int x, int y, int &res, int now) {
if (ck(x, y) && sta[id[x][y]] != now)
res += siz[id[x][y]], sta[id[x][y]] = now;
};
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf(" %s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (s[i][j] == '.' && !id[i][j]) dfs(i, j, ++cnt);
int ans = 0, now = 0;
for (int i = 1; i + k - 1 <= n; i++) {
for (int j = 1; j <= k; j++)
for (int l = 1; l <= k; l++) siz[id[i + l - 1][j]]--;
for (int j = 1; j + k - 1 <= n; j++) {
int res = k * k;
now++;
for (int l = 1; l <= k; l++)
add(i + l - 1, j - 1, res, now), add(i + l - 1, j + k, res, now);
for (int l = 1; l <= k; l++)
add(i - 1, j + l - 1, res, now), add(i + k, j + l - 1, res, now);
ans = max(ans, res);
if (j + k - 1 != n)
for (int l = 1; l <= k; l++)
siz[id[i + l - 1][j]]++, siz[id[i + l - 1][j + k]]--;
}
for (int j = n - k + 1; j <= n; j++)
for (int l = 1; l <= k; l++) siz[id[i + l - 1][j]]++;
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, p;
cin >> n >> b >> p;
int nb = b * 2 + 1;
int num_b = 0, num_p = 0;
num_p = p * n;
int x = n;
while (x != 1) {
num_b += nb * (x / 2);
if (x % 2 == 1) {
x = x / 2 + 1;
} else {
x = x / 2;
}
}
printf("%d %d\n", num_b, num_p);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, v[100500], s[100500], st[100500], ct, is2[100500];
long long su1[100500], su2[100500];
struct segt1 {
struct node {
int l, r;
long long mx, lz, mn, mx2;
} e[100500 * 4];
void pushdown(int x) {
if (!e[x].lz) return;
e[x << 1].lz += e[x].lz;
e[x << 1].mx += e[x].lz;
e[x << 1].mn += e[x].lz;
e[x << 1 | 1].mn += e[x].lz;
e[x << 1 | 1].lz += e[x].lz;
e[x << 1 | 1].mx += e[x].lz;
e[x].lz = 0;
}
long long query1(int x, long long v) {
if (e[x].mx <= v) return v - e[x].mx2;
if (e[x].l == e[x].r) return e[x].mx - e[x].mx2;
pushdown(x);
if (e[x << 1].mx <= v)
return min(query1(x << 1 | 1, v), v - e[x << 1].mx2);
else
return min(query1(x << 1, v), e[x].mn);
}
void pushup(int x) {
e[x].mn = query1(x << 1 | 1, e[x].mx);
e[x].mx = max(e[x << 1].mx, e[x << 1 | 1].mx);
}
void build(int x, int l, int r) {
e[x].l = l;
e[x].r = r;
if (l == r) {
e[x].mx = e[x].mx2 = su1[l];
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
e[x].mx2 = max(e[x << 1].mx2, e[x << 1 | 1].mx2);
pushup(x);
}
void modify(int x, int l, int r, long long v) {
if (r < l) return;
if (l < 1) l = 1;
if (e[x].l == l && e[x].r == r) {
e[x].lz += v;
e[x].mx += v;
e[x].mn += v;
return;
}
pushdown(x);
int mid = (e[x].l + e[x].r) >> 1;
if (mid >= r)
modify(x << 1, l, r, v);
else if (mid < l)
modify(x << 1 | 1, l, r, v);
else
modify(x << 1, l, mid, v), modify(x << 1 | 1, mid + 1, r, v);
pushup(x);
}
pair<long long, long long> query2(int x, int l, int r, long long v) {
if (e[x].l == l && e[x].r == r)
return make_pair(query1(x, v), max(e[x].mx, v));
pushdown(x);
int mid = (e[x].l + e[x].r) >> 1;
if (mid >= r)
return query2(x << 1, l, r, v);
else if (mid < l)
return query2(x << 1 | 1, l, r, v);
else {
pair<long long, long long> st = query2(x << 1, l, mid, v),
st2 =
query2(x << 1 | 1, mid + 1, r, st.second);
return make_pair(min(st.first, st2.first), st2.second);
}
}
} tr1;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &s[i]);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i <= n; i++)
su1[i] = su2[i - 1] + v[i], su2[i] = su1[i] - s[i];
tr1.build(1, 1, n);
int as = 1;
st[0] = n + 1;
for (int i = n; i >= 1; i--) {
while (ct && su2[st[ct]] >= su2[i - 1])
tr1.modify(1, st[ct], st[ct - 1] - 1, su2[st[ct]]), is2[st[ct]] = 0, ct--;
tr1.modify(1, i - 1, st[ct] - 1, -su2[i - 1]);
st[++ct] = i - 1;
is2[i - 1] = ct;
tr1.modify(1, i, n, su2[i - 1]);
int lb = i, rb = n, as1 = i;
while (lb <= rb) {
int mid = (lb + rb) >> 1, fg1 = is2[mid];
if (fg1) tr1.modify(1, st[fg1], st[fg1 - 1] - 1, su2[st[fg1]]);
if (tr1.query2(1, mid, n, tr1.query2(1, i, mid, -1e17).second).first <= k)
as1 = mid, lb = mid + 1;
else
rb = mid - 1;
if (fg1) tr1.modify(1, st[fg1], st[fg1 - 1] - 1, -su2[st[fg1]]);
}
if (as < as1 - i + 1) as = as1 - i + 1;
tr1.modify(1, i, n, -su2[i - 1]);
}
printf("%d\n", as);
}
| 12 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
using namespace std;
void MOD(long long &x) {
if (x >= 1000000007) x -= 1000000007;
if (x < 0) x += 1000000007;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void solve() {
long long n, m, k, l;
cin >> n >> m >> k >> l;
long long i = (l + k + m - 1) / m;
if (m * i > n)
cout << -1;
else
cout << i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};
using namespace std;
class pa3 {
public:
int x, y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
int x;
int y, z, w;
pa4(int x = 0, int y = 0, int z = 0, int w = 0) : x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
int x, y;
pa2(int x = 0, int y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator>(const pa2 &p) const { return x != p.x ? x > p.x : y > p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-7) && fabs(y - p.y) < (1e-7);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-7);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-7)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-7)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-7)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-7)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-7)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-7)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-7)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-7));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
int beki(int wa, int rr, int warukazu) {
if (rr == 0) return 1ll;
if (rr == 1) return wa % warukazu;
if (rr % 2 == 1) return (beki(wa, rr - 1, warukazu) * wa) % warukazu;
int zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
int y = 0;
struct segsum2D {
private:
public:
static const int corx = (1 << 12);
static const int cory = (1 << 12);
vector<vector<int>> vec;
void shoki1() { vec.resize(2 * corx + 3, vector<int>(2 * cory + 2, 0)); }
void shoki2() {
for (int i = 2 * corx - 1; i > 0; i--)
for (int j = 2 * cory - 1; j > 0; j--) {
if (i >= corx && j >= cory) continue;
if (i >= corx)
vec[i][j] = vec[i][2 * j] ^ vec[i][2 * j + 1];
else
vec[i][j] = vec[2 * i][j] ^ vec[2 * i + 1][j];
}
}
void updadd(int x, int y, int w) {
x += corx;
y += cory;
vec[x][y] ^= w;
for (int i = x; i > 0; i /= 2)
for (int j = y; j > 0; j /= 2) {
if (i == x && j == y) continue;
if (i >= corx)
vec[i][j] = vec[i][2 * j] ^ vec[i][2 * j + 1];
else
vec[i][j] = vec[2 * i][j] ^ vec[2 * i + 1][j];
}
}
void updchan(int x, int y, int w) {
x += corx;
y += cory;
vec[x][y] = w;
for (int i = x; i > 0; i /= 2)
for (int j = y; j > 0; j /= 2) {
if (i == x && j == y) continue;
if (i >= corx)
vec[i][j] = vec[i][2 * j] ^ vec[i][2 * j + 1];
else
vec[i][j] = vec[2 * i][j] ^ vec[2 * i + 1][j];
}
}
int ax;
int ay;
int bx;
int by;
int _kx;
int _sumy(int ky = 1, int ly = 0, int ry = cory) {
y++;
if (ay <= ly && ry <= by) {
return vec[_kx][ky];
}
if (ly >= by || ry <= ay) {
return 0;
}
int my = (ly + ry) / 2;
int v00 = _sumy(2 * ky, ly, my);
int v10 = _sumy(2 * ky + 1, my, ry);
return v00 ^ v10;
}
int _sumx(int kx = 1, int lx = 0, int rx = corx) {
y++;
if (ax <= lx && rx <= bx) {
_kx = kx;
return _sumy();
}
if (lx >= bx || rx <= ax) {
return 0;
}
int mx = (lx + rx) / 2;
int v00 = _sumx(2 * kx, lx, mx);
int v10 = _sumx(2 * kx + 1, mx, rx);
return v00 ^ v10;
}
int sum(int axx, int bxx, int ayy, int byy) {
ax = axx;
ay = ayy;
bx = bxx;
by = byy;
return _sumx();
}
};
segsum2D ss;
unsigned int randxor() {
static unsigned int x = 123456789, y = 362436069, z = 521288629, w = 88675123;
unsigned int tt;
tt = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (tt ^ (tt >> 8)));
}
map<pa4, int> ma;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
ss.shoki1();
ss.shoki2();
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
int t, x1, x2, y1, y2;
cin >> t >> x1 >> y1 >> x2 >> y2;
if (t == 1) {
int va = randxor();
ma[(pa4){x1, y1, x2, y2}] = va;
ss.updadd(x1, y1, va);
ss.updadd(x2 + 1, y1, va);
ss.updadd(x1, y2 + 1, va);
ss.updadd(x2 + 1, y2 + 1, va);
}
if (t == 2) {
int va = ma[(pa4){x1, y1, x2, y2}];
ss.updadd(x1, y1, va);
ss.updadd(x2 + 1, y1, +va);
ss.updadd(x1, y2 + 1, +va);
ss.updadd(x2 + 1, y2 + 1, va);
}
if (t == 3) {
if (ss.sum(0, x1 + 1, 0, y1 + 1) == ss.sum(0, x2 + 1, 0, y2 + 1))
cout << "Yes\n";
else
cout << "No\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n), a1, a2;
for (int i = 0; i < n; i++) cin >> v[i];
a1 = a2 = v;
sort(a1.begin(), a1.end());
sort(a2.rbegin(), a2.rend());
for (int i = 1; i < n; i++) {
if (v[i] != v[i - 1]) {
swap(v[i], v[i - 1]);
if (v == a1 || v == a2) {
swap(v[i], v[i - 1]);
continue;
}
cout << i << " " << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int go() {
long long val = 0;
size_t n;
cin >> n;
while (n--) {
char c, s;
cin >> c >> s >> c;
if (s == '+')
val++;
else
val--;
}
return val;
}
int main() {
cout << go() << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int limN = 1e5 + 5;
bool itWorks(int N, int* cst, int* hav, long long req, long long p) {
for (int i = 0; i < N; i++) {
long long w = max(0LL, req * cst[i] - hav[i]);
if (p < w) return false;
p -= w;
}
return true;
}
int main() {
int N, p;
int cst[limN], hav[limN];
long long ini = 0, fin = 2000000000;
scanf("%d%d", &N, &p);
for (int i = 0; i < N; i++) scanf("%d", &cst[i]);
for (int i = 0; i < N; i++) scanf("%d", &hav[i]);
while (ini < fin) {
long long piv = (ini + fin) / 2 + 1;
if (itWorks(N, cst, hav, piv, p))
ini = piv;
else
fin = piv - 1;
}
printf("%d\n", (int)ini);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, time = 30;
cin >> r >> g >> b;
while (r > 0 || g > 0 || b > 0) {
if (b > 0) {
r -= 2;
g -= 2;
b -= 2;
time += 3;
continue;
}
r -= 2;
g -= 2;
if (r > 0 || g > 0) {
time += 3;
continue;
}
if (g >= -1) {
time += 2;
} else {
time += 1;
}
}
cout << time - 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, p, w, d;
long long x, y, z;
long long k;
int main() {
cin >> n >> p >> w >> d;
y = 0;
while (y < w && (p - y * d) % w != 0) {
y++;
}
if (y < w) {
x = (p - y * d) / w;
z = n - x - y;
if (x >= 0 && z >= 0)
cout << x << " " << y << " " << z;
else
cout << -1;
} else
cout << -1;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > graph;
vector<vector<int> > newg;
vector<bool> visited;
stack<int> ss;
void transpose() {
newg.resize(n * m);
for (__typeof(n * m) i = (0) - ((0) > (n * m));
i != (n * m) - ((0) > (n * m)); i += 1 - 2 * ((0) > (n * m))) {
for (auto it = graph[i].begin(); it != graph[i].end(); it++)
newg[*it].push_back(i);
}
}
void dfs(int s) {
visited[s] = true;
for (auto it = graph[s].begin(); it != graph[s].end(); it++) {
if (!visited[*it]) {
dfs(*it);
}
}
ss.push(s);
}
void dfs_stack_popping(int s) {
visited[s] = true;
for (auto it = newg[s].begin(); it != newg[s].end(); it++) {
if (!visited[*it]) {
dfs_stack_popping(*it);
}
}
if (!ss.empty()) ss.pop();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
char c;
graph.resize(n * m);
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
int base = i * m;
cin >> c;
if (c == '<') {
int start = base + (m - 1);
for (__typeof(base + 1) j = (start + 1) - ((start + 1) > (base + 1));
j != (base + 1) - ((start + 1) > (base + 1));
j += 1 - 2 * ((start + 1) > (base + 1))) {
graph[j].push_back(j - 1);
}
} else {
int start = base;
for (__typeof(base + m - 1) j = (start) - ((start) > (base + m - 1));
j != (base + m - 1) - ((start) > (base + m - 1));
j += 1 - 2 * ((start) > (base + m - 1))) {
graph[j].push_back(j + 1);
}
}
}
for (__typeof(m) i = (0) - ((0) > (m)); i != (m) - ((0) > (m));
i += 1 - 2 * ((0) > (m))) {
int gap = m;
cin >> c;
int start = i;
if (c == '^') {
start += (gap) * (n - 1);
for (int j = start; j > i; j = j - gap) {
graph[j].push_back(j - gap);
}
} else {
start = i;
for (int j = start; j < gap * (n - 1); j = j + gap) {
graph[j].push_back(j + gap);
}
}
}
visited.resize(m * n, false);
for (__typeof(n * m) i = (0) - ((0) > (n * m));
i != (n * m) - ((0) > (n * m)); i += 1 - 2 * ((0) > (n * m))) {
if (!visited[i]) dfs(i);
}
transpose();
visited.clear();
visited.resize(m * n, false);
int component = 0;
while (!ss.empty()) {
int t = ss.top();
component++;
dfs_stack_popping(t);
}
if (component == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
a[i] %= 2;
if (a[i]) {
if (a[i + 1])
a[i + 1]--;
else {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
if (a + b + c == d + e + f || a + b + d == c + e + f ||
a + b + e == d + c + f || a + b + f == d + e + c ||
a + d + c == b + e + f || a + e + c == d + b + f ||
a + f + c == d + e + b || a + d + e == c + b + f ||
a + d + f == b + c + e || a + e + f == b + c + d)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b, c;
cin >> a >> b >> c;
int ans = 100000;
int A, B, C;
for (int i = 1; i < 2 * a; i++) {
for (int j = i; j < 2 * b; j += i) {
for (int k = 0; k < 2; k++) {
int l = (c / j) * j + k * j;
int x = abs(a - i) + abs(b - j) + abs(c - l);
if (x < ans) {
ans = x;
A = i;
B = j;
C = l;
}
}
}
}
cout << ans << endl;
cout << A << " " << B << " " << C << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
long long n, i, j, k, l, t, q, m, temp, f = 0;
cin >> n >> k;
long long a[n + 1], b[n + 1];
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= n; i++) {
cin >> b[i];
if (i >= k) {
if (a[i] == b[i] && a[i] == 1) {
f = 1;
}
}
}
if ((a[1] == 1 && a[k] == 1)) {
cout << "YES\n";
} else if (a[1] == 1 && f == 1 && b[k] == 1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, d, x;
int a[100005], b[100005], q[100005], to[100005];
int getNextX() {
x = ((long long)x * 37 + 10007) % 1000000007;
return x;
}
int main() {
while (scanf("%d%d%d", &n, &d, &x) == 3) {
for (int i = 0; i < n; i++) a[i] = i + 1;
for (int i = 0; i < n; i++) swap(a[i], a[getNextX() % (i + 1)]);
for (int i = 0; i < n; i++)
if (i < d)
b[i] = 1;
else
b[i] = 0;
for (int i = 0; i < n; i++) swap(b[i], b[getNextX() % (i + 1)]);
memset(q, 0, sizeof(q));
memset(to, 0, sizeof(to));
for (int i = 0; i < n; i++)
if (b[i]) q[++q[0]] = i;
for (int i = 0; i < n; i++) to[a[i]] = i;
int s = 30;
for (int i = 0; i < n; i++) {
int j;
for (j = n; j >= n - s; j--)
if (j > 0 && i >= to[j] && b[i - to[j]]) {
printf("%d\n", j);
break;
}
if (j < n - s) {
int Max = 0;
for (int j = 1; j <= q[0] && q[j] <= i; j++)
Max = max(Max, a[i - q[j]]);
printf("%d\n", Max);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 3e5 + 5, M = 998244353;
void madd(int& a, int b) {
a += b;
if (a >= M) a -= M;
}
int msub(int a, int b) {
madd(a, M - b);
return a;
}
int mult(int a, int b) { return (1LL * a * b) % M; }
int modexp(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = mult(res, a);
a = mult(a, a);
b >>= 1;
}
return res;
}
int inverse(int x) { return modexp(x, M - 2); }
int fac[maxn], ifac[maxn];
int choose(int n, int r) {
if (n < r) return 0;
int ans = fac[n];
ans = mult(ans, ifac[r]);
ans = mult(ans, ifac[n - r]);
return ans;
}
int n, m;
struct Person {
int bad, id, l, r;
bool operator<(const Person& rhs) const { return bad > rhs.bad; }
};
vector<Person> a;
vector<int> start[maxn], stop[maxn];
const int maxm = 41;
vector<int> edges[maxm];
int mapid[maxn];
bool active[maxn];
int bc = 0;
int badcount[maxm];
vector<pair<int, int>> edgelist;
ll edge_mask[maxm];
void recurse(int total_bad) {
vector<pair<int, int>> es;
for (int i = 0; i < edgelist.size(); i++) {
int u = edgelist[i].first;
int v = edgelist[i].second;
if (active[u] && active[v]) {
es.push_back({u, v});
}
}
int es_size = es.size();
for (int mask = 0; mask < (1 << es_size); mask++) {
vector<bool> seen(bc, false);
int sz = 0;
for (int i = 0; i < es_size; i++) {
if (!(mask & (1 << i))) continue;
int u = es[i].first;
int v = es[i].second;
if (!seen[u]) {
sz++;
seen[u] = true;
}
if (!seen[v]) {
sz++;
seen[v] = true;
}
}
if ((__builtin_popcount(mask)) & 1) {
for (int i = 0; i + sz <= total_bad; i++) {
badcount[i + sz] = msub(badcount[i + sz], choose(total_bad - sz, i));
}
} else {
for (int i = 0; i + sz <= total_bad; i++) {
madd(badcount[i + sz], choose(total_bad - sz, i));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fac[0] = ifac[0] = 1;
for (int i = 1; i < maxn; i++) {
fac[i] = mult(i, fac[i - 1]);
ifac[i] = inverse(fac[i]);
}
cin >> n >> m;
bool flag = false;
vector<pair<int, int>> ps;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (i == 0 && a == 1031397 && b == 239068) flag = true;
ps.push_back({a, b});
}
vector<pair<int, int>> ee;
vector<int> isbad(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
isbad[a] = true;
isbad[b] = true;
ee.push_back({a, b});
}
for (int i = 0; i < n; i++) {
a.push_back({isbad[i], i, ps[i].first, ps[i].second});
if (isbad[i]) bc++;
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
start[a[i].l].push_back(i);
stop[a[i].r].push_back(i);
mapid[a[i].id] = i;
}
for (auto p : ee) {
edges[mapid[p.first]].push_back(mapid[p.second]);
edges[mapid[p.second]].push_back(mapid[p.first]);
edgelist.push_back({mapid[p.first], mapid[p.second]});
}
int ans = 0;
int numgood = 0;
int numActive = 0;
int cnt = 0;
int calls = 0;
badcount[0] = 1;
for (int i = 1; i <= n; i++) {
for (int id : start[i]) {
numActive++;
active[id] = true;
if (id >= bc)
numgood++;
else
cnt++;
}
if (cnt) {
for (int i = 0; i <= bc; i++) badcount[i] = 0;
if (!flag) {
recurse(numActive - numgood);
}
cnt = 0;
calls++;
}
for (int j = 0; j <= bc && i - j >= 0; j++) {
int add = mult(choose(numgood, i - j), badcount[j]);
madd(ans, add);
}
for (int id : stop[i]) {
numActive--;
active[id] = false;
if (id >= bc)
numgood--;
else
cnt++;
}
}
if (flag) cout << "calls = " << calls << endl;
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
int N, K;
cin >> N >> K;
if (N % 2 == K % 2) {
if (N < K)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 0; i < K - 1; i++) cout << 1 << " ";
cout << N - K + 1 << endl;
}
} else if (N % 2 == 0 && K % 2 == 1) {
if (N < 2 * K)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 0; i < K - 1; i++) cout << 2 << " ";
cout << N - 2 * (K - 1) << endl;
}
} else
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
long long power(long long base, long long exp, int mod = 1000000007) {
base = base % mod;
long long res = 1;
while (exp > 0) {
if ((exp & 1)) res = (res * base) % mod;
base = (base * base) % mod;
exp = exp >> 1;
}
return res;
}
long long modinv(long long a, int m = 1000000007) { return power(a, m - 2); }
long long n, m, a, b;
long long pre[1000005] = {0LL}, fac[1000005] = {0LL};
void prepro() {
pre[0] = 1;
for (int i = 1; i <= m - 1; i++)
pre[i] = pre[i - 1] * (m - i) % 1000000007 * modinv(i) % 1000000007;
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % 1000000007;
}
long long caley(long long x, long long y) {
if (x == y)
return 1LL;
else
return y * power(x, x - y - 1) % 1000000007;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(17);
cin >> n >> m >> a >> b;
prepro();
long long ans = 0;
for (int x = 2; x <= n; x++) {
;
ans = (ans + fac[n - 2] * modinv(fac[n - x]) % 1000000007 * pre[x - 2] %
1000000007 * caley(n, x) % 1000000007 * power(m, n - x) %
1000000007) %
1000000007;
}
cout << ans << endl;
;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 200 + 10;
typedef long long Matrix[N][N];
int m, a[N];
long long n;
char s[N];
Matrix adj;
struct {
int next[26], fail, val;
} pool[N];
int tot = 1, root = 1;
void add(char s[], int v) {
int u = root;
for (char *it = s; *it != '\0'; ++it) {
int ch = *it - 'a';
if (!pool[u].next[ch]) pool[u].next[ch] = ++tot;
u = pool[u].next[ch];
}
pool[u].val += v;
}
void build() {
static std::queue<int> q;
q.push(root);
while (!q.empty()) {
int a = q.front();
q.pop();
pool[a].val += pool[pool[a].fail].val;
for (int i = 0; i < 26; ++i) {
int &b = pool[a].next[i];
(b ? (q.push(b), pool[b].fail) : b) =
(a == root) ? root : pool[pool[a].fail].next[i];
}
}
memset(adj, -0x3f, sizeof adj);
for (int a = 1; a <= tot; ++a) adj[a][a] = 0;
for (int a = 1; a <= tot; ++a) {
for (int i = 0; i < 26; ++i) {
int b = pool[a].next[i];
adj[a][b] = pool[b].val;
}
}
}
void mul(Matrix a, const Matrix b) {
static Matrix c;
memset(c, -0x3f, sizeof c);
for (register int i = 1; i <= tot; ++i)
for (register int k = 1; k <= tot; ++k)
for (register int j = 1; j <= tot; ++j)
c[i][j] = std::max(c[i][j], a[i][k] + b[k][j]);
memcpy(a, c, sizeof c);
}
void power(Matrix base, long long exp) {
static Matrix res;
memset(res, -0x3f, sizeof res);
res[1][1] = 0;
for (; exp; exp >>= 1) {
if (exp & 1) mul(res, base);
mul(base, base);
}
memcpy(base, res, sizeof res);
}
int main() {
scanf("%d%lld", &m, &n);
pool[root].fail = root;
for (int i = 1; i <= m; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= m; ++i) {
scanf(" %s", s);
add(s, a[i]);
}
build();
power(adj, n);
printf("%lld\n", *std::max_element(adj[1] + 1, adj[1] + tot + 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int Q;
scanf("%d", &Q);
while (Q--) {
int N, M;
scanf("%d%d", &N, &M);
std::vector<std::pair<int, int> > edges(M);
for (int i = 0; i < M; ++i) {
scanf("%d%d", &edges[i].first, &edges[i].second);
}
std::unordered_set<int> sIn;
std::vector<int> match, ind;
for (int i = 0; i < M; ++i) {
if (sIn.count(edges[i].first)) continue;
if (sIn.count(edges[i].second)) continue;
match.push_back(i + 1);
sIn.insert(edges[i].first);
sIn.insert(edges[i].second);
}
if (match.size() >= N) {
printf("Matching\n");
for (int i = 0; i < N; ++i) printf("%d ", match[i]);
printf("\n");
} else {
printf("IndSet\n");
int cnt = 0;
for (int i = 1; i <= 3 * N; ++i) {
if (sIn.count(i)) continue;
cnt++;
printf("%d ", i);
if (cnt == N) break;
}
printf("\n");
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long a, b, f, k;
int cnt() {
int c = 0;
int n = v.size();
long long now = 0;
for (int i = 0; i < n; i++) {
if (now + b < v[i]) return -1;
while (i < n && now + b >= v[i]) i++;
i--;
c++;
now = v[i];
}
return c - 1;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &a, &b, &f, &k);
v.push_back(f);
for (long long i = 1; i < k; i++) {
if (i & 1)
v.push_back(v[i - 1] + 2 * (a - f));
else
v.push_back(v[i - 1] + 2 * f);
}
v.push_back(a * k);
printf("%d", cnt());
}
| 3 |
#include<bits/stdc++.h>
#define int long long
#define ld long double
#define fi first
#define se second
#define vll vector<int>
#define pii pair<int,int>
#define pb push_back
#define sz(v) (int)(v).size()
#define inf (int)(1e18)
#define md (int)(1e9+7)
#define all(v) (v).begin(),(v).end()
#define rep(i,a,b) for(int i=a;i<b;++i)
using namespace std;
const int M = 2e5 + 10;
int32_t main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
int dx[]={0,1,0,1};
int dy[]={0,0,1,1};
int tc;
cin>>tc;
while(tc--) {
int n;
cin>>n;
char a[n][n];
rep(i,0,n)rep(j,0,n) cin>>a[i][j];
char b[n][n];
rep(i,0,n)rep(j,0,n) cin>>b[i][j];
bool ok=1;
rep(i,0,n-1)rep(j,0,n-1) {
int cnt=0;
rep(k,0,4) cnt+=a[i+dx[k]][j+dy[k]]==b[i+dx[k]][j+dy[k]];
if(cnt&1) ok=0;
}
cout<<(ok?"YES":"NO")<<"\n";
}
return 0;
} | 5 |
#include <bits/stdc++.h>
const long long MOD = 998244353;
using namespace std;
const long long N = 200010;
vector<long long> g[N];
long long dp[N] = {}, fact[N] = {};
void preproc() {
fact[0] = 1;
for (long long i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
}
long long dfs(long long n, long long p) {
if (p != -1 && g[n].size() == 1) {
dp[n] = 1;
return 1;
}
dp[n] = 1;
for (long long i : g[n]) {
if (i != p) {
long long k = dfs(i, n);
dp[n] = (dp[n] * k) % MOD;
}
}
long long kids = g[n].size();
dp[n] = (dp[n] * fact[kids]) % MOD;
return dp[n];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 1; i < n; i++) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
preproc();
dfs(1, -1);
cout << (dp[1] * n) % MOD << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)3e5 + 111;
const int inf = (int)1e9 + 111;
const long long llinf = (long long)1e18 + 5;
const long long base = (long long)1e9 + 7;
long long a[Z], st[Z];
int main() {
st[0] = 1;
for (int j = 1; j < Z; j++) st[j] = (2 * st[j - 1]) % base;
int n;
scanf("%d", &n);
for (int j = 0; j < n; j++) scanf("%d", &a[j]);
sort(a, a + n);
int ans = 0;
for (int j = 1; j < n; j++) {
int len = a[j] - a[j - 1];
int cntL = j;
int cntR = n - j;
int add = (1LL * (st[cntL] - 1 + base) * (st[cntR] - 1 + base)) % base;
ans = (1LL * ans + 1LL * len * add) % base;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long x1, y1, z1, x2, y2, z2, sum = 0;
cin >> x1 >> y1 >> z1;
cin >> x2 >> y2 >> z2;
if (z2 <= x1) {
x1 = x1 - z2;
z2 = 0;
if (z1 >= y2) {
sum = (y2 * 2);
} else {
sum = z1 * 2;
}
} else {
z2 = z2 - x1;
if (z2 <= z1) {
z1 = z1 - z2;
if (z1 >= y2) {
sum = (y2 * 2);
} else {
sum = z1 * 2;
}
} else {
z2 = z2 - z1;
if (z2 >= y1) {
sum = -(y1 * 2);
} else {
sum = -(z2 * 2);
}
}
}
cout << sum << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int classificacao(int p1, int p2, int p3) {
int s2, s3;
s2 = s3 = 0;
while (p1 != p2) {
s2++;
p1++;
if (p1 > 11) p1 = 0;
}
while (p2 != p3) {
s3++;
p2++;
if (p2 > 11) p2 = 0;
}
if (s2 == 4 && s3 == 3) return 1;
if (s2 == 3 && s3 == 4) return -1;
return 0;
}
int main() {
char vec[][3] = {"C", "C#", "D", "D#", "E", "F",
"F#", "G", "G#", "A", "B", "H"};
char a[3], b[3], c[3];
int p1, p2, p3;
p1 = p2 = p3 = 0;
scanf("%s %s %s", a, b, c);
while (strcmp(vec[p1], a) != 0) {
p1++;
if (p1 > 11) {
printf("strange\n");
return 0;
}
}
p2 = p1;
while (strcmp(vec[p2], b) != 0) {
p2++;
if (p2 > 11) {
p2 = 0;
} else if (p2 == p1) {
printf("strange\n");
return 0;
}
}
p3 = p2;
while (strcmp(vec[p3], c) != 0) {
p3++;
if (p3 > 11) {
p3 = 0;
} else if (p3 == p2) {
printf("strange\n");
return 0;
}
}
if (classificacao(p1, p2, p3) == 1) {
printf("major\n");
} else if (classificacao(p1, p2, p3) == -1) {
printf("minor\n");
} else if (classificacao(p2, p1, p3) == 1) {
printf("major\n");
} else if (classificacao(p2, p1, p3) == -1) {
printf("minor\n");
} else if (classificacao(p1, p3, p2) == 1) {
printf("major\n");
} else if (classificacao(p1, p3, p2) == -1) {
printf("minor\n");
} else if (classificacao(p2, p3, p1) == 1) {
printf("major\n");
} else if (classificacao(p2, p3, p1) == -1) {
printf("minor\n");
} else if (classificacao(p3, p2, p1) == 1) {
printf("major\n");
} else if (classificacao(p3, p2, p1) == -1) {
printf("minor\n");
} else if (classificacao(p3, p1, p2) == 1) {
printf("major\n");
} else if (classificacao(p3, p1, p2) == -1) {
printf("minor\n");
} else {
printf("strange\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T, N, A[100005];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", A + i);
sort(A + 1, A + N + 1);
printf("%d\n", min(A[N - 1] - 1, N - 2));
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt, w;
char a[100001];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
if (a[i] == 'R') {
if (a[i + 1] == '.' && a[i + 2] == 'L') a[i + 1] = '1';
if (a[i + 1] == '.' && a[i + 2] != 'L') {
a[i + 1] = 'R';
i++;
}
}
if (a[i] == 'L') {
if (a[i - 1] == '.') {
a[i - 1] = 'L';
}
}
}
}
for (int i = 0; i < n; i++)
if (a[i] == '.' || a[i] == '1') cnt++;
cout << cnt;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <class t>
inline void read(t &s) {
s = 0;
register int f = 1;
register char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) s = (s << 3) + (s << 1) + (c ^ 48), c = getchar();
s *= f;
return;
}
inline void write(long long x) {
if (x / 10) write(x / 10);
putchar((x % 10) ^ '0');
return;
}
long long dr[100][2];
long long sta[200050], top;
int n;
long long V, ans, A, B, C, sqrV, ta, sqrtV, limA;
long long mulV[100];
inline long long calc(long long x) {
return 4ll * (long long)(ceil(sqrt(V) * sqrt(x))) + V / x * 2ll;
}
inline void dfs(int dep, long long mul) {
if (mul > limA) return;
if (dep > n) {
sta[++top] = mul;
return;
}
dfs(dep + 1, mul);
for (int i = 1; i <= dr[dep][1]; ++i) mul *= dr[dep][0], dfs(dep + 1, mul);
return;
}
inline void dfs2(int dep, long long mul) {
if (mul * mulV[dep] < ta) return;
if (dep > n) {
register long long c = V / ta / mul;
register long long t = 2ll * (ta * mul + mul * c + ta * c);
if (t < ans) {
ans = t;
A = ta, B = mul, C = c;
}
return;
}
register int tt = dr[dep][1], Ta = ta;
while (!(Ta % dr[dep][0])) Ta /= dr[dep][0], --dr[dep][1];
register int Lim = dr[dep][1];
for (int i = 1; i <= dr[dep][1]; ++i)
if (mul * dr[dep][0] <= sqrV)
mul *= dr[dep][0];
else {
Lim = i - 1;
break;
}
while (Lim--) dfs2(dep + 1, mul), mul /= dr[dep][0];
dfs2(dep + 1, mul);
dr[dep][1] = tt;
return;
}
inline void work() {
top = 0;
read(n);
V = 1;
for (int i = 1; i <= n; ++i) {
read(dr[i][0]);
read(dr[i][1]);
for (int j = 1; j <= dr[i][1]; ++j) V *= dr[i][0];
}
mulV[n + 1] = 1;
for (int i = n; i; --i) {
mulV[i] = mulV[i + 1];
for (int j = 1; j <= dr[i][1]; ++j) mulV[i] *= dr[i][0];
}
ans = 2ll * (2ll * V + 1);
A = V, B = C = 1;
limA = (long long)ceil(pow(V, 1.0 / 3.0));
dfs(1, 1);
sort(sta + 1, sta + top + 1);
for (int i = top; i; --i)
if (calc(sta[i]) < ans) {
ta = sta[i];
sqrV = (long long)ceil(sqrt(V) * sqrt(ta));
dfs2(1, 1);
}
write(ans);
putchar(' ');
write(A);
putchar(' ');
write(B);
putchar(' ');
write(C);
puts("");
return;
}
signed main(void) {
int t;
cin >> t;
while (t--) work();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (x < y) return gcd(y, x);
if (x % y == 0) return y;
return gcd(y, x % y);
}
int main() {
long long x, y, q;
cin >> x >> y;
if (gcd(x, y) != 1) {
cout << "Impossible" << endl;
} else {
while (x > 1 && y > 1) {
if (x > y) {
q = x / y;
x = x % y;
cout << q << "A";
} else {
q = y / x;
y = y % x;
cout << q << "B";
}
}
if (x > 1) {
cout << (x - 1) << "A";
}
if (y > 1) {
cout << (y - 1) << "B";
}
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400;
const int INF = 0x3f3f3f3f;
int dp[maxn + 1][maxn + 1];
int nxt[maxn + 1][26];
string s, t;
int n, m;
bool check(int a, int b) {
memset(dp, INF, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < (a + 1); i++)
for (int j = 0; j < (b + 1); j++) {
if (i && dp[i - 1][j] != INF) {
dp[i][j] = min(dp[i][j], nxt[dp[i - 1][j]][t[i - 1] - 'a']);
}
if (j && dp[i][j - 1] != INF) {
dp[i][j] = min(dp[i][j], nxt[dp[i][j - 1]][t[j + a - 1] - 'a']);
}
}
return dp[a][b] != INF;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T;
cin >> T;
while (T--) {
cin >> s >> t;
n = ((int)s.size());
m = ((int)t.size());
memset(nxt, INF, sizeof(nxt));
for (int i = (n); i >= (1); i--) {
for (int j = 0; j < (26); j++) nxt[i - 1][j] = nxt[i][j];
nxt[i - 1][s[i - 1] - 'a'] = i;
}
int ans = 0;
for (int i = 0; i < (m); i++) {
if (check(i, m - i)) {
ans = 1;
break;
}
}
if (ans)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int cnt = 0;
int num;
for (int i = 0; i != n; ++i) {
scanf("%d", &num);
if (num % 2 == 1) ++cnt;
}
if (cnt >= 1)
printf("First\n");
else
printf("Second\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, N = 2e5 + 5;
long long powmod(long long b, long long p) {
long long r = 1;
for (; p; p >>= 1, b = b * b % mod)
if (p & 1) r = r * b % mod;
return r;
}
long long invmod(long long x) { return powmod(x, mod - 2); }
int l[N], r[N];
long long len[N], inv[N];
long long cnt[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", l + i);
for (int i = 0; i < n; ++i) scanf("%d", r + i);
long long square = 0, distinct = 0, all = 1;
for (int i = 0; i < n; ++i) {
len[i] = r[i] - l[i] + 1;
all = all * len[i] % mod;
inv[i] = invmod(len[i]);
}
long long single = 0;
for (int i = 0; i + 1 < n; ++i) {
int low = max(l[i], l[i + 1]);
int hig = min(r[i], r[i + 1]);
long long now = 1LL * len[i] * len[i + 1] % mod;
if (hig >= low) {
now = (now - (hig - low + 1)) % mod;
if (now < 0) now += mod;
}
now = now * inv[i] % mod;
now = now * inv[i + 1] % mod;
cnt[i] = now;
square = (square + now) % mod;
if (i >= 2) single = (single + cnt[i - 2]) % mod;
distinct = (distinct + now * single) % mod;
}
for (int i = 0; i + 2 < n; ++i) {
long long now = 1LL * len[i] * len[i + 1] % mod;
now = 1LL * now * len[i + 2] % mod;
{
int low = max(l[i], l[i + 1]);
int hig = min(r[i], r[i + 1]);
if (hig >= low) {
now = (now - 1LL * (hig - low + 1) * len[i + 2]) % mod;
if (now < 0) now += mod;
}
}
{
int low = max(l[i + 1], l[i + 2]);
int hig = min(r[i + 1], r[i + 2]);
if (hig >= low) {
now = (now - 1LL * (hig - low + 1) * len[i]) % mod;
if (now < 0) now += mod;
}
}
{
int low = max(l[i], max(l[i + 1], l[i + 2]));
int hig = min(r[i], min(r[i + 1], r[i + 2]));
if (hig >= low) {
now = (now + 1LL * (hig - low + 1)) % mod;
if (now < 0) now += mod;
}
}
now = now * inv[i] % mod;
now = now * inv[i + 1] % mod;
now = now * inv[i + 2] % mod;
distinct = (distinct + now) % mod;
}
single = 0;
for (int i = 0; i + 1 < n; ++i) single = (single + cnt[i]) % mod;
square = (square + 1) * all % mod;
distinct = (distinct + single) * all % mod;
long long ans = (square + 2LL * distinct) % mod;
ans = ans * invmod(all) % mod;
if (ans < 0) ans += mod;
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
int k2, k3, k5, k6;
cin >> k2 >> k3 >> k5 >> k6;
int n256 = 0;
int n32 = 0;
n256 = min(min(k2, k5), k6);
k2 -= n256;
n32 = min(k2, k3);
cout << 256 * n256 + 32 * n32 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
vector<int> v;
cin >> s;
bool is = true;
int t = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != '.') {
t++;
} else {
if ((v.size() == 0 && (t > 8 || t < 1)) ||
(v.size() != 0 && (t > 11 || t < 2))) {
is = false;
break;
}
v.push_back(t);
t = 0;
}
}
if (t > 3 || t < 1 || v.size() == 0)
is = false;
else
v.push_back(t);
if (is) {
cout << "YES" << endl;
int j = 0;
int y = -400000;
bool dot = false;
for (int i = 0; i < s.size(); i++) {
cout << s[i];
y++;
if (s[i] == '.') {
j++;
y = 0;
}
if (y == 3) {
y = -400000;
cout << endl;
} else if (v[j] == 3 && y == 2 && v.size() > j + 1) {
y = -400000;
cout << endl;
} else if (v[j] == 2 && y == 1 && v.size() > j + 1) {
y = -400000;
cout << endl;
}
}
} else {
cout << "NO" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
struct node {
int v;
node *next;
} edge[400000 * 2 + 10], *adj[200000 + 10], *ecnt = &edge[0];
struct Edge {
int u, v;
Edge() {}
Edge(int u, int v) : u(u), v(v) {}
} e[400000 + 10], ans[400000 + 10];
int n, m, s, t, ds, dt, col[200000 + 10], cntcol, cnta, fa[200000 + 10],
belong[200000 + 10];
int able[2][200000 + 10], link[2][200000 + 10];
template <class T>
void Read(T &x) {
char c;
while (c = getchar(), c != EOF)
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
void read() {
Read(n), Read(m);
for (int i = 1; i <= m; i++) Read(e[i].u), Read(e[i].v);
Read(s), Read(t), Read(ds), Read(dt);
}
void addedge(int u, int v) {
node *p = ++ecnt;
p->v = v;
p->next = adj[u];
adj[u] = p;
}
void dfs(int u) {
col[u] = cntcol;
for (node *p = adj[u]; p; p = p->next)
if (!col[p->v]) dfs(p->v);
}
int Find(int x) { return x == fa[x] ? x : fa[x] = Find(fa[x]); }
void solve() {
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
if (e[i].u == s || e[i].u == t || e[i].v == s || e[i].v == t) continue;
if (Find(e[i].u) != Find(e[i].v)) {
fa[Find(e[i].u)] = Find(e[i].v);
ans[++cnta] = e[i];
addedge(e[i].u, e[i].v), addedge(e[i].v, e[i].u);
}
}
for (int i = 1; i <= n; i++)
if (!col[i]) {
++cntcol;
dfs(i);
}
for (int i = 1; i <= m; i++)
if (e[i].u == s || e[i].u == t || e[i].v == s || e[i].v == t)
addedge(e[i].u, e[i].v), addedge(e[i].v, e[i].u);
int cnts = 0, cntt = 0;
belong[col[s]]++;
for (node *p = adj[s]; p; p = p->next)
if (!belong[col[p->v]]) belong[col[p->v]]++;
belong[col[t]]++;
for (node *p = adj[t]; p; p = p->next)
if (!belong[col[p->v]]) {
ans[++cnta] = Edge(t, p->v), cntt++;
belong[col[p->v]] = -1;
} else if (belong[col[p->v]] == 1) {
belong[col[p->v]]++;
able[1][col[p->v]] = p->v;
}
for (node *p = adj[s]; p; p = p->next)
if (belong[col[p->v]] == 1) {
ans[++cnta] = Edge(s, p->v), cnts++;
belong[col[p->v]] = -1;
} else if (belong[col[p->v]] == 2)
able[0][col[p->v]] = p->v;
if (cnts > ds || cntt > dt)
puts("No");
else {
ds -= cnts, dt -= cntt;
bool f = false;
for (node *p = adj[s]; p; p = p->next)
if (belong[col[p->v]] == 2 && ds && p->v != t) {
ds--;
ans[++cnta] = Edge(s, p->v);
link[0][col[p->v]] = p->v;
belong[col[p->v]] = 0;
}
if (ds && dt && belong[col[t]] == 2) {
f = true;
ans[++cnta] = Edge(s, t);
belong[col[s]] = 0;
dt--;
}
for (node *p = adj[t]; p; p = p->next)
if (belong[col[p->v]] == 2 && p->v != s) {
if (!dt) {
puts("No");
return;
}
dt--;
ans[++cnta] = Edge(t, p->v);
link[1][col[p->v]] = p->v;
belong[col[p->v]] = 0;
}
if (!f && dt && ds && belong[col[s]] == 2) {
f = true;
ans[++cnta] = Edge(s, t);
ds--;
}
if (!f && (ds || dt)) {
if (ds) {
for (int i = 1; i <= cntcol; i++)
if (able[0][i] && link[1][i]) {
f = true;
ans[++cnta] = Edge(s, able[0][i]);
break;
}
}
if (!f && dt) {
for (int i = 1; i <= cntcol; i++)
if (able[1][i] && link[0][i]) {
f = true;
ans[++cnta] = Edge(t, able[1][i]);
break;
}
}
}
if (f) {
puts("Yes");
for (int i = 1; i <= cnta; i++) printf("%d %d\n", ans[i].u, ans[i].v);
} else
puts("No");
}
}
int main() {
read();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 1;
register char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c & 15);
return x * f;
}
const int N = 1e6 + 10;
vector<int> G[N];
int n, m;
int dfn[N];
int low[N];
int co[N];
int idx = 0, num = 0;
int top = 0, st[N];
inline void Tarjan(int u) {
dfn[u] = low[u] = ++idx;
st[++top] = u;
for (int &x : G[u])
if (!dfn[x])
Tarjan(x), low[u] = min(low[u], low[x]);
else if (!co[x])
low[u] = min(low[u], dfn[x]);
if (low[u] == dfn[u]) {
co[u] = ++num;
while (st[top] ^ u) co[st[top--]] = num;
top--;
}
}
signed main() {
for (register int t = read(); t--;) {
n = read();
m = read();
for (register int i = 1; i <= n; i++) G[i].clear();
for (register int i = 1; i <= m; i++) {
int u = read(), v = read();
if (u == v) continue;
G[u].push_back(v);
}
idx = num = top = 0;
for (register int i = 1; i <= n; i++) dfn[i] = low[i] = co[i] = 0;
for (register int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i);
if (num == 1) {
puts("No");
} else {
puts("Yes");
int tot = 0;
for (register int i = 1; i <= n; i++)
if (co[i] ^ 1) tot++;
printf("%d %d\n", n - tot, tot);
for (register int i = 1; i <= n; i++)
if (co[i] == 1) printf("%d ", i);
puts("");
for (register int i = 1; i <= n; i++)
if (co[i] ^ 1) printf("%d ", i);
puts("");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct room {
room() { min_cost = 999999999; }
long h, l, w, min_cost;
};
struct roolon {
long w, h, cost;
};
long CHECK(room tocover, roolon R) {
long get_from_1 = R.h / tocover.h;
if (get_from_1 == 0) return -1;
long p = tocover.l * 2 + tocover.w * 2;
long need_to_p = p / R.w;
if (p % R.w != 0) ++need_to_p;
long total = need_to_p / get_from_1;
if (need_to_p % get_from_1 != 0) ++total;
return total * R.cost;
}
int main() {
long N, M;
cin >> N;
vector<room> rooms(N);
for (long Q = 0; Q < N; ++Q) cin >> rooms[Q].l >> rooms[Q].w >> rooms[Q].h;
cin >> M;
vector<roolon> r(M);
long a;
for (long Q = 0; Q < M; ++Q) {
cin >> r[Q].h >> r[Q].w >> r[Q].cost;
}
for (long Q = 0; Q < N; ++Q) {
for (long W = 0; W < M; ++W) {
a = CHECK(rooms[Q], r[W]);
if (a != -1) rooms[Q].min_cost = min(rooms[Q].min_cost, a);
}
}
long res = 0;
for (long Q = 0; Q < N; ++Q) res += rooms[Q].min_cost;
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100050;
int n, m;
int f[maxn];
vector<int> buf1[maxn], buf2[maxn];
bool vis1[maxn] = {}, vis2[maxn] = {};
bool go[maxn] = {};
vector<int> todel;
void bfs(vector<int> *buf, bool *vis, int xx, int t) {
for (int i = 0; i < (n); ++i)
if (f[i] == xx && !vis[i]) {
vis[i] = true;
queue<int> q;
q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
for (vector<int>::iterator it = (buf[x]).begin(); it != (buf[x]).end();
++it)
if (!vis[*it]) {
if (f[*it] == t) {
if (xx == 2) vis[*it] = true;
} else {
vis[*it] = true;
q.push(*it);
}
}
}
}
}
int main(void) {
scanf("%d%d", &n, &m);
for (int i = 0; i < (n); ++i) scanf("%d", f + i);
for (int i = 0; i < (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
buf1[a].push_back(b);
buf2[b].push_back(a);
}
bfs(buf1, vis1, 1, 1);
bfs(buf2, vis2, 2, 1);
for (int i = 0; i < (n); ++i) printf("%d\n", vis1[i] && vis2[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[int(3e5 + 10)], team[int(3e5 + 10)][3];
bool b[int(3e5 + 10)];
int main() {
int n;
scanf("%d ", &n);
for (int i = 0; i < 3 * n; i++) {
int num;
scanf("%d ", &num);
a[num] = i;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++) scanf("%d ", &team[i][j]);
int k;
scanf("%d ", &k);
int i, j;
bool cont = true;
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
if (team[i][j] == k) cont = false;
if (!cont) break;
}
if (!cont) break;
}
int k1, k2;
if (j == 0) k1 = 1, k2 = 2;
if (j == 1) k1 = 2, k2 = 0;
if (j == 2) k1 = 0, k2 = 1;
int p = team[i][j], p1 = team[i][k1], p2 = team[i][k2];
if (a[p] > a[p1] || a[p] > a[p2]) {
for (int i = 1; i <= 3 * n; i++)
if (i != k) printf("%d ", i);
return 0;
}
for (int j = 0; j <= i; j++)
for (int st = 0; st < 3; st++) b[team[j][st]] = true;
for (int j = 1; j <= max(p1, p2); j++)
if (b[j] && j != k) printf("%d ", j);
for (int j = max(p1, p2) + 1; j <= 3 * n; j++) b[j] = false;
for (int j = 1; j <= 3 * n; j++)
if (!b[j] && j != k) printf("%d ", j);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
pair<int, int> mat[maxn][maxn];
int org[maxn][maxn];
int n, m, q;
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
mat[i][j] = make_pair(i, j);
}
}
memset(org, 0, sizeof org);
for (int i = 1; i <= q; i++) {
int t, r, c, x;
pair<int, int> tmp;
scanf("%d", &t);
if (t == 1) {
scanf("%d", &r);
tmp = mat[r][1];
for (int j = 1; j < m; j++) {
mat[r][j] = mat[r][j + 1];
}
mat[r][m] = tmp;
} else if (t == 2) {
scanf("%d", &c);
tmp = mat[1][c];
for (int j = 1; j < n; j++) {
mat[j][c] = mat[j + 1][c];
}
mat[n][c] = tmp;
} else {
scanf("%d%d%d", &r, &c, &x);
org[mat[r][c].first][mat[r][c].second] = x;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", org[i][j]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dirx[] = {1, 0, -1, 0};
int diry[] = {0, 1, 0, -1};
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
temp;
vector<int> v[102];
int main() {
int a;
cin >> a;
for (int i = 0; i < 2 * a; i++) {
int x;
scanf("%d", &x);
v[x].push_back(i + 1);
}
for (int i = 1; i <= a; i++) {
if (v[i][1] - v[i][0] == 1) continue;
pq.push(make_pair(v[i][0], v[i][1]));
}
int ans = 0;
while (!pq.empty()) {
pair<int, int> u = pq.top();
pq.pop();
int fst = u.second;
ans += u.second - u.first - 1;
while (!pq.empty()) {
u = pq.top();
pq.pop();
if (fst > u.first && u.second > fst)
temp.push(make_pair(u.first + 1, u.second));
else if (fst > u.first && u.second < fst)
temp.push(make_pair(u.first + 1, u.second + 1));
else
temp.push(make_pair(u.first, u.second));
}
while (!temp.empty()) {
u = temp.top();
if (u.second - u.first == 1) {
temp.pop();
continue;
}
temp.pop();
pq.push(u);
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long from, to, w, c;
edge(long long from, long long to, long long w, long long c)
: from(from), to(to), w(w), c(c) {}
bool operator<(const edge& e) const { return ((w > e.w)); }
};
void O_o() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
vector<vector<int> > adj;
bool vis[10050];
void dfs(int node) {
if (vis[node]) return;
vis[node] = 1;
for (auto i : adj[node]) {
if (!vis[i]) dfs(i);
}
}
int main() {
O_o();
long long n;
cin >> n;
adj.resize(n + 50);
for (int i = 1; i <= int(n); i++) {
int x;
cin >> x;
adj[i].push_back(x);
adj[x].push_back(i);
}
long long ans = 0;
for (int i = 1; i <= int(n); i++) {
if (!vis[i]) {
dfs(i);
ans++;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, q, k, tim, ans;
int dep[200005], fa[200005][21];
int a[200005], inp[200005], dfn[200005];
int st[200005], top;
vector<int> G[200005], VT[200005];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
(x *= 10) += ch - '0';
ch = getchar();
}
return x * f;
}
inline void add_edge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
void dfs(int u, int c_fa) {
dep[u] = dep[c_fa] + 1;
fa[u][0] = c_fa;
dfn[u] = ++tim;
for (int i = 1; i <= 18; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
for (int v : G[u]) {
if (v == c_fa) continue;
dfs(v, u);
}
}
inline int get_lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 18; ~i; i--)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return y;
for (int i = 18; ~i; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
inline bool cmp(int a, int b) { return dfn[a] < dfn[b]; }
inline void ins(int x) {
if (top == 1) {
st[++top] = x;
return;
}
int lca = get_lca(x, st[top]);
if (lca == st[top]) {
st[++top] = x;
return;
}
while (top > 1 && dfn[st[top - 1]] >= dfn[lca])
VT[st[top - 1]].push_back(st[top]), top--;
if (lca != st[top]) VT[lca].push_back(st[top]), st[top] = lca;
st[++top] = x;
}
void dp(int x) {
if (!VT[x].size()) return;
int cnt = 0;
for (int y : VT[x]) dp(y), cnt += inp[y], inp[y] = 0;
VT[x].clear();
if (inp[x])
ans += cnt;
else if (cnt >= 2)
ans++;
else if (cnt)
inp[x] = 1;
}
int main() {
n = read();
for (int i = 1; i < n; i++) add_edge(read(), read());
dep[0] = 1;
dfs(1, 0);
q = read();
while (q--) {
k = read();
for (int i = 1; i <= k; i++) a[i] = read(), inp[a[i]] = 1;
for (int i = 1; i <= k; i++)
if (inp[fa[a[i]][0]] == 1) {
for (int j = 1; j <= k; j++) inp[a[j]] = 0;
puts("-1");
goto end_loop;
}
sort(a + 1, a + 1 + k, cmp);
st[top = 1] = 1;
for (int i = 1; i <= k; i++)
if (a[i] != 1) ins(a[i]);
while (top > 0) VT[st[top - 1]].push_back(st[top]), top--;
ans = 0;
dp(1);
inp[1] = 0;
printf("%d\n", ans);
end_loop:;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[11111];
int main() {
scanf("%d", &n);
int m = (1 << (n + 1)) - 1;
for (int i = 2; i <= m; i++) scanf("%d", &a[i]);
int ans = 0;
for (int i = m; i >= 2; i--)
if (i % 2) {
int add = max(a[i], a[i - 1]) - min(a[i], a[i - 1]);
ans += add;
a[i / 2] += max(a[i], a[i - 1]);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
string n;
cin >> n;
int count = 0;
string s;
s = "";
int place = 0;
string c[n.size()];
for (int i = n.size() - 1; i >= 0; i--) {
c[i] = n[i];
if (n[i] == '0') {
continue;
} else {
count++;
if (i == n.size() - 1) {
s += c[i] + " ";
} else if (i == n.size() - 2) {
s += c[i] + "0 ";
} else if (i == n.size() - 3) {
s += c[i] + "00 ";
} else if (i == n.size() - 4) {
s += c[i] + "000 ";
} else {
s += "10000";
}
}
}
cout << count << endl;
cout << s << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int ans = 0;
int a, b;
cin >> a >> b;
if (a == b && b == 0)
ans = 0;
else if (a == b)
ans = 1;
else {
if (abs(a - b) & 1)
ans = -1;
else
ans = 2;
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int z[110];
int main() {
int n, a, k;
set<int> s;
cin >> n >> k;
long long sum = 0;
int max = -1;
for (int i = 0; i < n; i++) {
cin >> a;
z[a]++;
s.insert(a);
if (z[a] > max) max = z[a];
}
max = k * ((max / k) + (bool)(max % k));
long long count = 0;
count = max * s.size() - n;
;
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 205, MOD = 1e9 + 7;
struct point {
long long x, y;
point() {}
point(long long _x, long long _y) : x(_x), y(_y) {}
friend point operator-(const point a, const point b) {
return point(a.x - b.x, a.y - b.y);
}
friend long long operator*(const point a, const point b) {
return a.x * b.y - a.y * b.x;
}
} pts[MAXN];
int n;
bool vis[MAXN][MAXN];
long long f[MAXN][MAXN];
long long dp(int l, int r) {
if (vis[l][r]) return f[l][r];
vis[l][r] = true;
long long& res = f[l][r];
if (l == r - 1) return res = 1;
for (int k = l + 1; k < r; ++k)
if ((pts[r] - pts[l]) * (pts[r] - pts[k]) > 0) {
res += dp(l, k) * dp(k, r);
res %= MOD;
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> pts[i].x >> pts[i].y;
pts[n] = pts[0];
long long area = 0;
for (int i = 0; i < n; ++i) area += pts[i] * pts[i + 1];
if (area < 0) reverse(pts, pts + n), pts[n] = pts[0];
cout << dp(0, n - 1) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, row[53];
string mat[53];
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(10);
}
bool check(long long x, set<long long> &s) {
for (long long i = x + 1; i < n; i++) {
if (!row[i]) {
for (auto k : s) {
if (mat[i][k] == '#') {
row[i] = 1;
for (long long j = 0; j < m; j++) {
if ((mat[i][j] == '#' && s.find(j) == s.end()) ||
(mat[i][j] == '.' && s.find(j) != s.end()))
return false;
}
}
}
}
}
return true;
}
int main() {
fastio();
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> mat[i];
}
for (long long i = 0; i < n; i++) {
if (!row[i]) {
row[i] = 1;
set<long long> s;
for (long long j = 0; j < m; j++) {
if (mat[i][j] == '#') s.insert(j);
}
if (!check(i, s)) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int a[51][51];
int main() {
int n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) cin >> a[i][j];
int x, y;
int sol = 10000;
cin >> x >> y;
for (long long i = 1; i <= n - x + 1; i++)
for (long long j = 1; j <= m - y + 1; j++) {
int counter = 0;
for (long long i1 = i; i1 <= i + x - 1; i1++)
for (long long j1 = j; j1 <= j + y - 1; j1++)
if (a[i1][j1]) ++counter;
if (counter < sol) sol = counter;
}
for (long long i = 1; i <= n - y + 1; i++)
for (long long j = 1; j <= m - x + 1; j++) {
int counter = 0;
for (long long i1 = i; i1 <= i + y - 1; i1++)
for (long long j1 = j; j1 <= j + x - 1; j1++)
if (a[i1][j1]) ++counter;
if (counter < sol) sol = counter;
}
cout << sol;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s, res = "";
cin >> s;
long long int i = 0, j = (long long int)s.size() - 1,
k = (long long int)s.size() / 2, f = 0;
while (k > 0) {
if (j - i + 1 <= 3) {
res += s[i];
k--;
f = 1;
} else if (s[i] == s[j]) {
res += s[i];
k -= 2;
i++;
j--;
} else if (s[i + 1] == s[j]) {
res += s[i + 1];
k -= 2;
i += 2;
j--;
} else if (s[i] == s[j - 1]) {
res += s[i];
k -= 2;
i++;
j -= 2;
} else if (s[i + 1] == s[j - 1]) {
res += s[i + 1];
k -= 2;
i += 2;
j -= 2;
}
}
cout << res;
reverse(res.begin(), res.end());
if (f == 1) {
cout << res.substr(1, (long long int)res.size() - 1);
} else
cout << res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 100005;
int a[N], b[N];
int main() {
int t;
cin >> t;
while (t--) {
int m, n = 1, k = -1, cnt = 1;
cin >> m;
cin >> a[1];
b[1] = cnt;
for (int i = 2; i <= m; i++) {
cin >> a[i];
if (a[i] == a[i - 1])
b[i] = b[i - 1], k = i;
else {
b[i] = 3 - cnt;
cnt = 3 - cnt;
n = 2;
}
}
if (a[1] != a[m] && b[1] == b[m]) {
if (k > 0)
for (int j = k; j <= m; j++) b[j] = 3 - b[j];
else
b[m] = 3, n = 3;
}
cout << n << endl;
for (int j = 1; j <= m; j++) cout << b[j] << " ";
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e3 + 7;
int a[MAX][MAX], b[MAX][MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[1][i];
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= n - i + 1; ++j)
a[i][j] = a[i - 1][j] ^ a[i - 1][j + 1];
for (int i = 1; i <= n; ++i) b[1][i] = a[1][i];
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= n - i + 1; ++j)
b[i][j] = max(a[i][j], max(b[i - 1][j], b[i - 1][j + 1]));
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
int len = r - l + 1;
cout << b[len][l] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<int> g[200100];
bool vis[200100];
int n, m, k, path[200100 * 2], cnt;
void dfs(int from) {
vis[from] = 1;
path[++cnt] = from;
for (int i = 0; i < (int)g[from].size(); i++) {
int to = g[from][i];
if (!vis[to]) {
dfs(to);
path[++cnt] = from;
}
}
}
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
cnt = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
int maxC = (2 * n + k - 1) / k;
for (int i = 0; i < k; i++) {
int c = min(maxC, cnt);
if (c) {
printf("%d", c);
for (int j = 0; j < c && cnt; j++) printf(" %d", path[cnt--]);
printf("\n");
} else
printf("1 1\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char a[1000007];
int main() {
scanf("%s", a);
int lm = strlen(a);
string ans = "";
int i = 0;
int lt = 0;
while (i < lm) {
if (i) {
if (i + 2 < lm - 1 && a[i] == 'd' && a[i + 1] == 'o' && a[i + 2] == 't')
ans.push_back('.'), i = i + 3;
else if (!lt && i + 1 < lm - 1 && a[i] == 'a' && a[i + 1] == 't')
ans.push_back('@'), lt = 1, i = i + 2;
else
ans.push_back(a[i]), i++;
} else
ans.push_back(a[i]), i++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, x, rt[35], y, z, l, i, j;
long long a[100500], b[100500];
vector<long long> f;
long double pre[155];
long double dp[2][1015][115];
pair<long long, long long> tasks[115];
int main() {
pre[0] = 1;
long double p = 10. / 9;
for (int i = 1; i <= 120; i++) pre[i] = pre[i - 1] * p;
long long t;
cin >> t;
long long itr = 0;
while (t--) {
long long ans = 0;
cin >> n;
long double CC, T;
cin >> CC >> T;
for (int i = 0; i < 2; i++) {
for (int j = 0; j <= 1000; j++)
for (int k = 0; k <= 100; k++) dp[i][j][k] = 1e+18;
}
dp[0][0][0] = 0;
long long cur = 0, nxt = 1;
for (int i = 0; i < n; i++) cin >> tasks[i].first >> tasks[i].second;
sort(tasks, tasks + n);
reverse(tasks, tasks + n);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i * 10 + 10; j++)
for (int k = 0; k <= i + 1; k++) dp[nxt][j][k] = 1e+18;
for (int j = 0; j <= i * 10; j++) {
for (int k = 0; k <= i; k++) {
long double t = dp[cur][j][k];
long double A = 1. / CC;
long double B = -(T + 1. / CC) + 10. * k;
long double C = t;
long double D = B * B - 4 * A * C;
if (D >= 0) {
long double dlfjl = (B + sqrt(D)) / (2. * A);
long double dkfj = (-B + sqrt(D)) / (2. * A);
if (dlfjl > dkfj) swap(dlfjl, dkfj);
long double l = max((double)dlfjl, 1.);
long double r = min(dkfj, 1. + T - 10. * k);
if (l < r) {
if (ans < j) {
ans = j;
}
}
}
if (i == n) continue;
dp[nxt][j][k] = min(dp[nxt][j][k], dp[cur][j][k]);
dp[nxt][j + tasks[i].second][k + 1] =
min(dp[nxt][j + tasks[i].second][k + 1],
dp[cur][j][k] + pre[k + 1] * tasks[i].first);
}
}
swap(cur, nxt);
}
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x;
int max = 0;
int min = 0;
int maxval = 0;
int minval = 10000;
for (int i = 0; i < n; i++) {
cin >> x;
if (x > maxval) {
maxval = x;
max = i;
}
if (x <= minval) {
min = i;
minval = x;
}
}
if (max > min) {
cout << (max - 1) + (n - min) - 1;
} else
cout << (max - 1) + (n - min);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long BigMod(long long b, long long p, long long m) {
long long ret = 1;
while (p > 0) {
if (p % 2 == 1) ret = (ret * b) % m;
p = p >> 1;
b = (b * b) % m;
}
return ret;
}
const int N = 105;
const long long MOD = 1e9 + 7;
int n, x;
string str;
long long dp[N][N][N];
long long sz[N], pw[N];
long long call(int s, int l, int r) {
if (s <= 1) {
if (l != r) return 0;
if (s == 0 and str[l] == '0') return 1;
if (s == 1 and str[l] == '1') return 1;
return 0;
}
if (dp[s][l][r] != -1) return dp[s][l][r];
long long ret = 0;
long long A = call(s - 1, l, r);
long long B = call(s - 2, l, r);
if (l == 0) {
B = (B * pw[s - 1]) % MOD;
}
if (r == n - 1) {
A = (A * pw[s - 2]) % MOD;
}
ret = (A + B) % MOD;
for (int i = l; i < r; i++) {
ret += call(s - 1, l, i) * call(s - 2, i + 1, r);
ret %= MOD;
}
return dp[s][l][r] = ret;
}
int main() {
sz[0] = 1;
sz[1] = 1;
for (int i = 2; i < N; i++) {
sz[i] = (sz[i - 1] + sz[i - 2]) % (MOD - 1);
}
for (int i = 0; i < N; i++) pw[i] = BigMod(2, sz[i], MOD);
cin >> n >> x;
cin >> str;
memset(dp, -1, sizeof(dp));
long long ans = call(x, 0, str.size() - 1);
cout << ans << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 17;
int st[N], op[N], sz[N], dp[N], pid[N], c[N], hd[N], p[N], f[N], g[N], add[N];
double ans[N];
vector<int> adj[N], V[N];
long long sum[N];
int T, pn;
void dfs(int u) {
sz[u] = 1;
dp[u] = dp[p[u]] + 1;
for (auto v : adj[u]) {
dfs(v);
sz[u] += sz[v];
}
}
void dfs1(int u) {
st[u] = ++T;
pid[u] = pn;
if (!hd[pn]) hd[pn] = u;
int w = 0;
for (auto v : adj[u])
if (sz[v] > sz[w]) w = v;
if (w) dfs1(w);
for (auto v : adj[u]) {
if (v != w) {
pn++;
dfs1(v);
}
}
}
long long ret2, ret1;
void renew(int u, int l, int k) {
add[u] += k;
sum[u] += k * l;
}
void push_down(int u, int l) {
if (add[u]) {
renew(u + u, (l + 1) / 2, add[u]);
renew(u + u + 1, l / 2, add[u]);
add[u] = 0;
}
}
void push_up(int u) { sum[u] = sum[u + u] + sum[u + u + 1]; }
void modify(int u, int l, int r, int ll, int rr, int k) {
if (ll <= l && r <= rr) {
renew(u, r - l + 1, k);
return;
}
int mid = l + r >> 1;
push_down(u, r - l + 1);
if (ll <= mid) modify(u + u, l, mid, ll, rr, k);
if (mid < rr) modify(u + u + 1, mid + 1, r, ll, rr, k);
push_up(u);
}
long long query(int u, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return sum[u];
int mid = l + r >> 1;
long long ret = 0;
push_down(u, r - l + 1);
if (ll <= mid) ret += query(u + u, l, mid, ll, rr);
if (mid < rr) ret += query(u + u + 1, mid + 1, r, ll, rr);
return ret;
}
int n;
void update(int u, int k) {
ret1 += k * dp[u];
ret2 += dp[u];
while (u) {
int l = hd[pid[u]];
ret2 += 2 * k * query(1, 1, n, st[l], st[u]);
modify(1, 1, n, st[l], st[u], k);
u = p[l];
}
}
int main() {
int m, q, C;
scanf("%d%d%d%d", &n, &m, &q, &C);
for (int i = 1; i <= n; i++)
scanf("%d", &f[i]), V[f[i]].push_back(i), g[i] = f[i];
for (int i = 2; i <= n; i++) scanf("%d", &p[i]), adj[p[i]].push_back(i);
for (int i = 1; i <= m; i++) scanf("%d", &c[i]);
for (int i = 1; i <= q; i++) {
scanf("%d", &op[i]);
if (op[i] == 1) {
int x, w;
scanf("%d%d", &x, &w);
V[g[x]].push_back(-x);
g[x] = w;
V[g[x]].push_back(x);
} else {
int k;
scanf("%d", &k);
V[k].push_back(n + i);
}
}
dfs(1);
dfs1(1);
set<int> S;
for (int i = 1; i <= m; i++) {
for (auto e : S) update(e, -1);
S.clear();
ret2 = 0, ret1 = 0;
for (int event : V[i]) {
if (event < 0) {
S.erase(-event);
update(-event, -1);
} else if (event <= n) {
S.insert(event);
update(event, 1);
} else {
ans[event - n] = (long double)(ret2 * c[i] * c[i] -
2 * ret1 * c[i] * C + C * 1LL * C * n) /
n;
}
}
}
for (int i = 1; i <= q; i++)
if (op[i] == 2) printf("%.10lf\n", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int mod = 1000000007;
const int gmod = 3;
const int inf = 1039074182;
const double eps = 1e-9;
const long long llinf = 2LL * inf * inf;
template <typename T1, typename T2>
inline void chmin(T1 &x, T2 b) {
if (b < x) x = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &x, T2 b) {
if (b > x) x = b;
}
inline void chadd(int &x, int b) {
x += b - mod;
x += (x >> 31 & mod);
}
template <typename T1, typename T2>
inline void chadd(T1 &x, T2 b) {
x += b;
if (x >= mod) x -= mod;
}
template <typename T1, typename T2>
inline void chmul(T1 &x, T2 b) {
x = 1LL * x * b % mod;
}
template <typename T1, typename T2>
inline void chmod(T1 &x, T2 b) {
x %= b, x += b;
if (x >= b) x -= b;
}
template <typename T>
inline T mabs(T x) {
return (x < 0 ? -x : x);
}
using namespace std;
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, vector<T> vec) {
cout << "{";
for (int i = 0; i < (int)vec.size(); i++) {
cout << vec[i];
if (i != (int)vec.size() - 1) cout << ',';
}
cout << "}";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
cout << "(" << p.first << ',' << p.second << ")";
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, set<T, T2> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, multiset<T, T2> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, queue<T> q) {
vector<T> t;
while (q.size()) {
t.push_back(q.front());
q.pop();
}
cout << t;
return cout;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &cout, map<T1, T2, T3> m) {
for (auto &x : m) {
cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
}
return cout;
}
template <typename T1, typename T2>
void operator+=(pair<T1, T2> &x, const pair<T1, T2> y) {
x.first += y.first;
x.second += y.second;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &x, const pair<T1, T2> &y) {
return make_pair(x.first + y.first, x.second + y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &x, const pair<T1, T2> &y) {
return make_pair(x.first - y.first, x.second - y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> x) {
return make_pair(-x.first, -x.second);
}
template <typename T>
vector<vector<T>> operator~(vector<vector<T>> vec) {
vector<vector<T>> v;
int n = vec.size(), m = vec[0].size();
v.resize(m);
for (int i = 0; i < m; i++) {
v[i].resize(n);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
v[i][j] = vec[j][i];
}
}
return v;
}
void print0x(int x) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
std::reverse(vec.begin(), vec.end());
for (int i = 0; i < (int)vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
template <typename T>
void print0x(T x, int len) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
reverse(vec.begin(), vec.end());
for (int i = (int)vec.size(); i < len; i++) {
putchar('0');
}
for (size_t i = 0; i < vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.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...);
}
using namespace std;
int h, q;
struct Node {
Node *l = 0, *r = 0;
double sum = 0;
};
Node *root;
vector<int> trace;
void update(Node *&x, const vector<int> &trace, int depth, double e) {
if (!x) x = new Node();
x->sum += e;
if ((int)trace.size() == depth) return;
update(trace[depth] ? x->r : x->l, trace, depth + 1, e);
}
double dfs(Node *x, double hp) {
if (!x) return hp;
if (x->sum < hp) return hp;
return (dfs(x->l, max(hp, x->sum - (x->l ? x->l->sum : 0))) +
dfs(x->r, max(hp, x->sum - (x->r ? x->r->sum : 0)))) /
2;
}
char buf[105];
int main() {
root = new Node();
cin >> h >> q;
while (q--) {
scanf("%s", buf);
if (buf[0] == 'a') {
int x, v;
scanf("%d%d", &x, &v);
trace.clear();
while (x > 1) {
trace.push_back(x & 1);
x >>= 1;
}
reverse(trace.begin(), trace.end());
update(root, trace, 0, v);
} else {
printf("%.5f\n", dfs(root, 0));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int ans = n;
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
ans = min(ans, y - x + 1);
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) printf("%d ", i % ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, int>, pair<long long, int> > mp;
pair<long long, int> cal(long long n, int x) {
if (n == 0) return make_pair(0, 0);
if (n < 10) return make_pair(1, max(0, (int)(x - n)));
pair<long long, int> now = make_pair(n, x);
if (mp.count(now)) return mp[now];
pair<long long, int> ans = make_pair(0, 0);
long long ten = 1;
while (ten <= n / 10) ten *= 10;
while (true) {
int df = n / ten;
int nx = max(df, x);
pair<long long, int> cur = cal(n % ten, nx);
ans.first += cur.first;
n -= n % ten;
if (cur.second > 0)
n -= cur.second;
else if (nx > 0)
n -= nx, ++ans.first;
if (df == 0) break;
}
ans.second = -n;
mp[now] = ans;
return ans;
}
int main() {
long long n;
cin >> n;
cout << cal(n, 0).first << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
map<int, vector<pair<int, int>>> mp;
vector<pair<int, int>> shoes;
long long memo[MAXN][4];
long long calcState(int ind, int mask) {
if (memo[ind][mask] != -1) {
return memo[ind][mask];
}
if (ind == shoes.size()) {
return 0;
}
auto it = mp.find(shoes[ind].first);
long long answer = calcState(ind + 1, 0);
if (it != mp.end()) {
bool mode = false;
if (ind != shoes.size() - 1 &&
shoes[ind].first + 1 == shoes[ind + 1].first) {
mode = true;
}
for (int i = 0; i < it->second.size(); i++) {
if (it->second[i].first < shoes[ind].second) continue;
answer =
max(answer, shoes[ind].second + calcState(ind + 1, (1 << i) * mode));
}
}
it = mp.find(shoes[ind].first - 1);
if (it != mp.end()) {
for (int i = 0; i < it->second.size(); i++) {
if (((mask >> i) & 1) == 1) continue;
if (it->second[i].first < shoes[ind].second) continue;
answer = max(answer, shoes[ind].second + calcState(ind + 1, 0));
}
}
memo[ind][mask] = answer;
return answer;
}
long long value;
vector<pair<int, int>> answer;
map<pair<int, int>, int> shoe2Index;
void recover(int ind, int mask) {
if (ind == shoes.size()) {
return;
}
auto it = mp.find(shoes[ind].first);
if (0 + calcState(ind + 1, 0) == value) {
value -= 0;
recover(ind + 1, 0);
return;
}
if (it != mp.end()) {
bool mode = false;
if (ind != shoes.size() - 1 &&
shoes[ind].first + 1 == shoes[ind + 1].first) {
mode = true;
}
for (int i = 0; i < it->second.size(); i++) {
if (it->second[i].first < shoes[ind].second) continue;
if (shoes[ind].second + calcState(ind + 1, (1 << i) * mode) == value) {
answer.push_back({it->second[i].second, shoe2Index[shoes[ind]]});
value -= shoes[ind].second;
recover(ind + 1, (1 << i) * mode);
return;
}
}
}
it = mp.find(shoes[ind].first - 1);
if (it != mp.end()) {
for (int i = 0; i < it->second.size(); i++) {
if (((mask >> i) & 1) == 1) continue;
if (it->second[i].first < shoes[ind].second) continue;
if (shoes[ind].second + calcState(ind + 1, 0) == value) {
answer.push_back({it->second[i].second, shoe2Index[shoes[ind]]});
value -= shoes[ind].second;
recover(ind + 1, 0);
return;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int c, s;
cin >> c >> s;
shoes.push_back({s, c});
shoe2Index[{s, c}] = i;
}
sort(shoes.begin(), shoes.end());
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int d, l;
cin >> d >> l;
mp[l].push_back({d, i});
}
for (auto it = mp.begin(); it != mp.end(); it++) {
sort(it->second.begin(), it->second.end(), greater<pair<int, int>>());
while (it->second.size() > 2) it->second.pop_back();
}
memset(memo, -1, sizeof(memo));
value = calcState(0, 0);
recover(0, 0);
cout << calcState(0, 0) << '\n';
cout << answer.size() << '\n';
for (pair<int, int> item : answer) {
cout << item.first + 1 << " " << item.second + 1 << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using vi = vector<int>;
struct pto {
ll x, y;
pto(ll x = 0, ll y = 0) : x(x), y(y) {}
pto operator-(pto a) { return pto(x - a.x, y - a.y); }
ll operator^(pto a) { return x * a.y - y * a.x; }
bool left(pto q, pto r) { return ((q - *this) ^ (r - *this)) > 0; }
bool operator<(const pto &a) const {
return x < a.x || (x == a.x && y < a.y);
}
bool operator==(const pto &a) const { return x == a.x && y == a.y; }
};
using vp = vector<pto>;
void chull(vp &v, vp &w) {
w.clear();
sort(v.begin(), v.end());
for (pto p : v) {
while (int(w.size()) >= 2 &&
w[int(w.size()) - 1].left(w[int(w.size()) - 2], p))
w.pop_back();
w.emplace_back(p);
}
w.pop_back();
int k = int(w.size());
reverse(v.begin(), v.end());
for (pto p : v) {
while (int(w.size()) >= k + 2 &&
w[int(w.size()) - 1].left(w[int(w.size()) - 2], p))
w.pop_back();
w.emplace_back(p);
}
w.pop_back();
}
int main() {
int n;
cin >> n;
vp v(n);
for (pto &p : v) cin >> p.x >> p.y;
int m;
cin >> m;
vp w(m);
for (pto &p : w) cin >> p.x >> p.y;
vp ps = v;
ps.insert(ps.end(), w.begin(), w.end());
vp chps;
chull(ps, chps);
sort(v.begin(), v.end());
sort(chps.begin(), chps.end());
cout << (chps == v ? "YES" : "NO") << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
while (cin >> a >> b >> c >> d >> e >> f)
cout << (b * d * f > a * c * e || (c == 0 && d > 0) ||
(a == 0 && b > 0 && c > 0 && d > 0)
? "Ron"
: "Hermione")
<< endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100 * 1000;
const int MAXD = 200;
const long double INF = 1e10;
const long double ep = 1e-17;
pair<pair<int, int>, int> a[MAX + 10];
int out[MAX + 10];
int n, k, h;
bool can_do(long double m) {
int p = k;
for (int i = n - 1; i >= 0 && p; i--)
if ((long double)p * h / a[i].first.second <= m) out[p--] = a[i].second;
if (p == 0) return true;
return false;
}
long double bin_search(long double s, long double e, int d = 0) {
if (d == MAXD) return e;
long double m = (s + e) / 2;
if (can_do(m))
return bin_search(s, m, d + 1);
else
return bin_search(m, e, d + 1);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> h;
for (int i = 0; i < n; i++) cin >> a[i].first.first, a[i].second = i;
for (int i = 0; i < n; i++) cin >> a[i].first.second;
sort(a, a + n);
long double ret = bin_search(0, INF);
can_do(ret);
for (int i = 1; i <= k; i++) cout << out[i] + 1 << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
long long int i = 1;
while (b != 0) {
if (b < i) {
break;
}
b = b - i;
i = (i + 1) % a;
if (i == 0) {
i = a;
}
}
cout << b << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
int n, t, i, j, a[1000005];
long long s[1000005], mx, mn = 1000000000000ll;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i += 2) {
a[i] = (i << 1) - 1;
a[i + n] = (i << 1);
}
for (i = 2; i <= n; i += 2) {
a[i] = (i << 1);
a[i + n] = (i << 1) - 1;
}
for (i = 1; i <= n * 2; i++) s[i] = s[i - 1] + a[i];
for (i = n; i <= 2 * n; i++) {
mx = max(mx, s[i] - s[i - n]);
mn = min(mn, s[i] - s[i - n]);
}
for (i = 1; i < n; i++) {
mx = max(mx, s[i] + s[n * 2] - s[n + i]);
mn = min(mn, s[i] + s[n * 2] - s[n + i]);
}
if (mx - mn <= 1) {
printf("YES\n");
for (i = 1; i <= n * 2; i++) printf("%d ", a[i]);
} else
printf("NO\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222, K = 15;
void push(string s, bool a[K][1 << K]) {
int n = s.size();
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = i; j < n && j - i + 1 < K; j++) {
x |= (s[j] == '1') << (j - i);
a[j - i + 1][x] = true;
}
}
}
void push(bool a[K][1 << K], bool b[K][1 << K]) {
for (int i = 0; i < K; i++) {
for (int j = 0; j < 1 << i; j++) b[i][j] |= a[i][j];
}
}
bool a[N][K][1 << K];
string s[N], pre[N], suf[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
push(s[i], a[i]);
pre[i] = suf[i] = s[i];
}
int lim = 1 << K;
int m;
cin >> m;
for (int i = n + 1; i <= n + m; i++) {
int x, y;
cin >> x >> y;
push(a[x], a[i]), push(a[y], a[i]);
push(suf[x] + pre[y], a[i]);
pre[i] = pre[x], suf[i] = suf[y];
if ((int)pre[i].length() < lim)
pre[i] =
(pre[i] + pre[y])
.substr(0, min(lim, (int)(pre[i].length() + pre[y].length())));
if ((int)suf[i].length() < lim)
suf[i] =
(suf[x] + suf[i])
.substr(max(0, (int)(suf[x].length() + suf[i].length() - lim)));
int k;
for (k = 1; k < K; k++) {
int ok = 1;
for (int j = 0; j < 1 << k; j++)
if (!a[i][k][j]) ok = 0;
if (!ok) break;
}
cout << k - 1 << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if ((n - 2) % 3 == 0) {
cout << "1"
<< " "
<< "2"
<< " " << n - 3 << endl;
} else {
cout << "1"
<< " "
<< "1"
<< " " << n - 2 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long a[200000];
long long n;
bool cmp(const long long &x, const long long &y) {
long long t1 = (x + 1) * (n - x) * a[x];
long long t2 = (y + 1) * (n - y) * a[y];
return t1 < t2;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long b[n];
for (int i = 0; i < n; i++) cin >> b[i];
sort(b, b + n);
long long p[n];
for (int i = 0; i < n; i++) {
p[i] = i;
}
sort(p, p + n, cmp);
map<long long, long long> idx;
for (int i = 0; i < n; i++) {
idx[p[i]] = b[n - i - 1];
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long temp = (long long)a[p[i]] * idx[p[i]];
temp %= mod;
temp *= (long long)(p[i] + 1);
temp %= mod;
temp = (long long)temp * (n - p[i]);
temp %= mod;
ans += temp;
ans %= mod;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 107;
int dp[N][N][N][2];
int a[N], n;
int call(int o, int e, int p, bool x) {
if (p > n || e < 0 || o < 0) return 1000;
if (a[p] && a[p] % 2 != x) return 1000;
if (!a[p] && x && o <= 0) return 1000;
if (!a[p] && !x && e <= 0) return 1000;
if (p == n) {
if (a[p]) return 0;
if (x && o > 0) return 0;
if (!x && e > 0) return 0;
return 1000;
}
int &ret = dp[o][e][p][x];
if (ret != -1) return ret;
ret = 1000;
if (a[p]) {
ret = min(ret, call(o, e, p + 1, !x) + 1);
ret = min(ret, call(o, e, p + 1, x));
} else {
if (x) {
ret = min(ret, call(o - 1, e, p + 1, x));
ret = min(ret, call(o - 1, e, p + 1, !x) + 1);
} else {
ret = min(ret, call(o, e - 1, p + 1, !x) + 1);
ret = min(ret, call(o, e - 1, p + 1, x));
}
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
memset(dp, -1, sizeof dp);
int e = 0, o = 0;
map<int, bool> mp;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mp[a[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (mp[i]) continue;
i & 1 ? o++ : e++;
}
cout << min(call(o, e, 1, 0), call(o, e, 1, 1)) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char* my_strrev(char* str) {
char* left = str;
char* rigth = str;
while (*str++)
;
str -= 2;
while (left < str) {
char c = *left;
*left++ = *str;
*str-- = c;
}
return rigth;
}
int main() {
char** din = new char*[1];
for (int i = 0; i < 1; i++) {
din[i] = new char[2];
}
for (int i = 0; i < 1; i++) {
cin >> din[i];
}
int n;
cin >> n;
char** array = new char*[n];
for (int i = 0; i < n; i++) {
array[i] = new char[2];
}
for (int i = 0; i < n; i++) {
cin >> array[i];
}
int c = 0;
for (int i = 0; i < n; i++) {
if (strncmp(my_strrev(array[i]), din[0], 1) == 0) {
c = 1;
}
array[i] = my_strrev(array[i]);
}
for (int i = 0; i < n; i++) {
if (strcmp(array[i], din[0]) == 0) {
cout << "YES";
return 0;
}
}
din[0] = my_strrev(din[0]);
int a = 0;
for (int i = 0; i < n; i++) {
if (strncmp(array[i], din[0], 1) == 0) {
a = 1;
}
}
if (a == 1 && c == 1) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 10000010;
const long long mod = 998244353;
inline long long power(long long a, long long t) {
long long res = 1;
while (t) {
if (t & 1) res = res * a % mod;
a = a * a % mod;
t >>= 1;
}
return res;
}
int n, m, k, cnt, f[maxn], inv[maxn], pw[maxn], pr[maxn], c[maxn];
int main() {
scanf("%d %d %d", &n, &m, &k);
m = power(m, mod - 2);
c[0] = inv[1] = pw[1] = 1;
c[1] = n;
for (long long i = 2; i <= k; ++i) {
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
c[i] = 1ll * c[i - 1] * inv[i] % mod * (n - i + 1) % mod;
if (!pw[i]) {
pr[++cnt] = i;
pw[i] = power(i, k);
}
for (long long j = 1; j <= cnt && i * pr[j] <= k; ++j) {
pw[i * pr[j]] = 1ll * pw[i] * pw[pr[j]] % mod;
if (i % pr[j] == 0) break;
}
}
if (n <= k + 1) {
long long mul = power(mod + 1 - m, n - 1) * m % mod,
invq = power(mod + 1 - m, mod - 2), res = 0;
for (int i = 1; i <= n; ++i) {
res = (res + mul * c[i] % mod * pw[i]) % mod;
mul = mul * invq % mod * m % mod;
}
printf("%lld", res);
} else {
long long c2, mul, res = 0;
mul = c2 = f[k] = 1;
for (int i = k - 1; i; --i) {
c2 = c2 * (n - i - 1) % mod * inv[k - i] % mod;
mul = mul * (mod - m) % mod;
f[i] = (c2 * mul + (mod + 1 - m) * f[i + 1]) % mod;
}
mul = m;
for (int i = 1; i <= k; ++i) {
res = (res + 1ll * pw[i] * c[i] % mod * mul % mod * f[i]) % mod;
mul = mul * m % mod;
}
printf("%lld", res);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int DIM = 1005;
int dp[DIM][DIM], pos[DIM][DIM];
int num[DIM][DIM], ord[DIM][DIM];
int cst[10], dig[DIM];
char str[DIM];
struct Struct {
int a, b, id;
Struct(int _a = 0, int _b = 0, int _id = 0) : a(_a), b(_b), id(_id) {}
} aux[DIM];
void process(int v[DIM], char str[DIM]) {
v[0] = strlen(str + 1);
for (int i = 1; i <= v[0]; ++i)
v[i] = (str[v[0] - i + 1] == '?' ? -1 : str[v[0] - i + 1] - '0');
}
inline bool cmp(Struct s1, Struct s2) {
if (s1.a != s2.a) return s1.a > s2.a;
return s1.b < s2.b;
}
int main(void) {
cin >> (str + 1);
process(num[0], str);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
memset(str, 0, sizeof str);
cin >> (str + 1);
process(num[i], str);
}
int mx = 0;
for (int i = 0; i <= n; ++i) mx = max(mx, num[i][0]);
for (int i = 1; i <= n; ++i) ord[0][i] = i;
for (int j = 1; j <= mx; ++j) {
for (int i = 1; i <= n; ++i) aux[i] = Struct(num[i][j], ord[j - 1][i], i);
sort(aux + 1, aux + n + 1, cmp);
for (int i = 1; i <= n; ++i) ord[j][aux[i].id] = i;
}
for (int j = 0; j <= mx; ++j)
for (int i = 1; i <= n; ++i) pos[j][ord[j][i]] = i;
for (int c = 0; c <= 9; ++c) cin >> cst[c];
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int j = 1; j <= mx; ++j) {
int le, ri;
if (num[0][0] < j)
le = ri = 0;
else if (num[0][j] >= 0)
le = ri = num[0][j];
else if (num[0][0] == j)
le = 1, ri = 9;
else
le = 0, ri = 9;
for (int d = le; d <= ri; ++d) {
int nr = 0, cs = 0;
for (int i = 1; i <= n; ++i) {
dig[i] = num[i][j] + d;
if (dig[i] >= 10) {
++nr;
cs += cst[dig[i] - 10];
dig[i] -= 10;
} else if (!(dig[i] == 0 and j > max(num[0][0], num[i][0])))
cs += cst[dig[i]];
}
for (int msk = 0; msk <= n; ++msk) {
if (msk) {
int ps = pos[j - 1][msk];
if (!(dig[ps] == 0 and j > max(num[0][0], num[ps][0])))
cs -= cst[dig[ps]];
dig[ps]++;
if (dig[ps] >= 10) {
++nr;
cs += cst[dig[ps] - 10];
dig[ps] -= 10;
} else if (!(dig[ps] == 0 and j > max(num[0][0], num[ps][0])))
cs += cst[dig[ps]];
}
if (dp[j - 1][msk] < 0) continue;
dp[j][nr] = max(dp[j][nr], dp[j - 1][msk] + cs);
}
}
}
int ans = 0;
for (int msk = 0; msk <= n; ++msk) {
if (dp[mx][msk] < 0) continue;
ans = max(ans, dp[mx][msk] + cst[1] * msk);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1.01e9;
inline long double eps(long double x, long double y) {
long double EPS = (abs(x) + abs(y) + 1) * 1e-13;
return EPS;
}
struct pt {
long double x, y;
pt() {}
pt(long double xx, long double yy) : x(xx), y(yy) {}
void read() {
double xx, yy;
scanf("%lf%lf", &xx, &yy);
x = xx, y = yy;
}
};
inline pt operator+(pt p1, pt p2) { return pt(p1.x + p2.x, p1.y + p2.y); }
inline pt operator-(pt p1, pt p2) { return pt(p1.x - p2.x, p1.y - p2.y); }
inline pt operator*(pt p, long double c) { return pt(p.x * c, p.y * c); }
inline pt operator*(long double c, pt p) { return pt(p.x * c, p.y * c); }
inline long double len(pt p) { return sqrt(p.x * p.x + p.y * p.y); }
inline long double dist(pt p1, pt p2) {
long double dx = p1.x - p2.x;
long double dy = p1.y - p2.y;
return sqrt(dx * dx + dy * dy);
}
inline long double scal(pt p1, pt p2) { return p1.x * p2.x + p1.y * p2.y; }
inline long double vect(pt p1, pt p2) { return p1.x * p2.y - p1.y * p2.x; }
inline bool operator<(pt p1, pt p2) {
return p1.x < p2.x - eps(p1.x, p2.x) ||
(p1.x < p2.x + eps(p1.x, p2.x) && p1.y < p2.y - eps(p1.y, p2.y));
}
const int N = 1010;
pt R[N];
pt b[N];
pt a[N];
pt s[N];
int sc = 0;
pt c[N];
int cc = 0;
int n, m;
long double RAD = 1e4;
pt inv(pt X) {
long double z = (X.x * X.x + X.y * X.y) / RAD;
return pt(X.x / z, X.y / z);
}
void convexhull() {
sort(a, a + m);
cc = 0;
sc = 0;
for (int i = 0; (i) < (m); ++i) {
while (sc >= 2 &&
vect(a[i] - s[sc - 1], s[sc - 1] - s[sc - 2]) >
-eps(len(a[i] - s[sc - 1]), len(s[sc - 1] - s[sc - 2])))
--sc;
s[sc++] = a[i];
}
for (int i = 0; (i) < (sc - 1); ++i) c[cc++] = s[i];
sc = 0;
for (int i = m - 1; i >= 0; --i) {
while (sc >= 2 &&
vect(a[i] - s[sc - 1], s[sc - 1] - s[sc - 2]) >
-eps(len(a[i] - s[sc - 1]), len(s[sc - 1] - s[sc - 2])))
--sc;
s[sc++] = a[i];
}
for (int i = 0; (i) < (sc - 1); ++i) c[cc++] = s[i];
}
long double dist(pt X, pt A, pt B) {
pt dir = B - A;
dir = dir * (1. / len(dir));
pt Y = A + dir * scal(X - A, dir);
return dist(X, Y);
}
long double res = 1e100;
void solve() {
convexhull();
c[cc] = c[0];
for (int i = 0; (i) < (cc); ++i)
if (vect(c[i], c[i + 1]) < eps(len(c[i]), len(c[i + 1]))) {
res = 1e100;
return;
}
for (int i = 0; (i) < (cc); ++i) {
res = min(res, dist(pt(0, 0), c[i], c[i + 1]));
}
}
int findL(pt p) {
int x = 0;
for (int k = 10; k >= 0; --k) {
int y = ((x - (1LL << (k))) % cc + cc) % cc;
int z = (x + (1LL << (k))) % cc;
if (vect(c[x] - p, c[y] - p) > 0) x = y;
if (vect(c[x] - p, c[z] - p) > 0) x = z;
}
while (1) {
int y = (x - 1 + cc) % cc;
if (vect(c[x] - p, c[y] - p) > -eps(len(c[x] - p), len(c[y] - p)))
x = y;
else
break;
}
return x;
}
int findR(pt p) {
int x = 0;
for (int k = 10; k >= 0; --k) {
int y = ((x - (1LL << (k))) % cc + cc) % cc;
int z = (x + (1LL << (k))) % cc;
if (vect(c[x] - p, c[y] - p) < 0) x = y;
if (vect(c[x] - p, c[z] - p) < 0) x = z;
}
while (1) {
int y = (x + 1 + cc) % cc;
if (vect(c[x] - p, c[y] - p) < eps(len(c[x] - p), len(c[y] - p)))
x = y;
else
break;
}
return x;
}
int inside(pt p) {
if (vect(c[1] - c[0], p - c[0]) < -eps(len(c[1] - c[0]), len(p - c[0])))
return 0;
if (vect(p - c[0], c[cc - 1] - c[0]) <
-eps(len(p - c[0]), len(c[cc - 1] - c[0])))
return 0;
int l = 1;
int r = cc - 2;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (vect(c[mid] - c[0], p - c[0]) > -eps(len(c[mid] - c[0]), len(p - c[0])))
l = mid;
else
r = mid - 1;
}
return vect(c[l + 1] - c[l], p - c[l]) >
-eps(len(c[l + 1] - c[l]), len(p - c[l])) &&
vect(c[0] - c[l + 1], p - c[l + 1]) >
-eps(len(c[0] - c[l + 1]), len(p - c[l + 1]));
}
pt z[N];
int cnt[N];
void solve2() {
for (int i = 0; (i) < (cc + 1); ++i) cnt[i] = 0;
convexhull();
c[cc] = c[0];
if (cc <= 2) {
res = 0;
return;
}
int val = 0;
for (int i = 0; (i) < (n); ++i) {
if (inside(z[i])) continue;
if (cc <= 2) {
res = 0;
return;
}
int x = findL(z[i]);
int y = findR(z[i]);
cnt[x]++;
cnt[y]--;
if (x > y) val++;
}
for (int i = 0; (i) < (cc); ++i) {
val += cnt[i];
if (val > 0) {
res = min(res, dist(pt(0, 0), c[i], c[i + 1]));
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; (i) < (n); ++i) R[i].read();
for (int i = 0; (i) < (m); ++i) b[i].read();
for (int i = 0; (i) < (n); ++i) {
for (int j = 0; (j) < (m); ++j) a[j] = inv(b[j] - R[i]);
solve();
}
for (int i = 0; (i) < (m); ++i) {
for (int j = 0; (j) < (m); ++j) {
if (i != j) a[j] = inv(b[j] - b[i]);
}
for (int j = 0; (j) < (n); ++j) z[j] = inv(R[j] - b[i]);
a[i] = pt(0, 0);
solve2();
}
if (res < 1e-14)
printf("-1\n");
else
printf("%.10f\n", (double)(0.5 * RAD / res));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
queue<long long int> q;
vector<long long int> v;
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
if (i & 1) {
for (int j = 0; j < m; j++) {
cout << "#";
}
cout << endl;
} else {
if ((i / 2) % 2 != 0) {
for (int i = 0; i < m - 1; i++) {
cout << ".";
}
cout << "#" << endl;
} else {
cout << "#";
for (int i = 1; i < m; i++) {
cout << ".";
}
cout << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, g, start, hea[2332333], cnt = 1, tot, inf;
struct R {
long long to, val, nex;
} r[2332333];
long long pos[2332333][2];
void add(long long u, long long v, long long w) {
r[++cnt] = (R){v, w, hea[u]};
hea[u] = cnt;
}
void build(long long x, long long l, long long r) {
if (l == r) {
pos[x][0] = pos[x][1] = l;
return;
}
pos[x][0] = ++tot;
pos[x][1] = ++tot;
long long mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
add(pos[x][0], pos[x << 1][0], 0);
add(pos[x][0], pos[x << 1 | 1][0], 0);
add(pos[x << 1][1], pos[x][1], 0);
add(pos[x << 1 | 1][1], pos[x][1], 0);
return;
}
long long w, aim;
void que(long long x, long long l, long long r, long long st, long long en,
long long t) {
if (l == st && r == en) {
if (t == 0)
add(aim, pos[x][t], w);
else
add(pos[x][t], aim, w);
return;
}
long long mid = (l + r) >> 1;
if (en <= mid) {
que(x << 1, l, mid, st, en, t);
return;
}
if (st > mid) {
que(x << 1 | 1, mid + 1, r, st, en, t);
return;
}
que(x << 1, l, mid, st, mid, t);
que(x << 1 | 1, mid + 1, r, mid + 1, en, t);
return;
}
long long d[2332333];
bool used[2332333];
struct P {
long long p, d;
} U, V;
struct cmp {
bool operator()(P &p1, P &p2) { return p1.d > p2.d; }
};
priority_queue<P, vector<P>, cmp> q;
void Dj() {
memset(d, 38, sizeof(d));
inf = d[0];
d[start] = 0;
q.push((P){start, 0});
while (!q.empty()) {
U = q.top();
q.pop();
if (used[U.p]) continue;
used[U.p] = 1;
for (long long i = hea[U.p]; i > 0; i = r[i].nex) {
V.p = r[i].to;
V.d = U.d + r[i].val;
if (V.d < d[V.p]) {
d[V.p] = V.d;
q.push(V);
}
}
}
}
int main() {
cin >> n >> g >> start;
tot = n;
build(1, 1, n);
long long t, a, b, u, v;
for (long long i = 1; i <= g; i++) {
scanf("%I64d", &t);
if (t == 1) {
scanf("%I64d%I64d%I64d", &u, &v, &w);
add(u, v, w);
} else if (t == 2) {
scanf("%I64d%I64d%I64d%I64d", &u, &a, &b, &w);
aim = u;
que(1, 1, n, a, b, 0);
} else if (t == 3) {
scanf("%I64d%I64d%I64d%I64d", &v, &a, &b, &w);
aim = v;
que(1, 1, n, a, b, 1);
}
}
Dj();
for (long long i = 1; i <= n; i++) printf("%I64d ", d[i] == inf ? -1 : d[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int isprime(int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
long long fastexp(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 factorial(long long n) {
long long res = 1;
for (int i = 1; i <= n; i++) {
res = ((res % 1000000007) * (i % 1000000007)) % 1000000007;
}
return res;
}
long long ncr(long long n, long long r) {
long long nf = (factorial(n) % 1000000007);
long long nrf = (fastexp(factorial(n - r), 1000000007 - 2) % 1000000007);
long long rf = (fastexp(factorial(r), 1000000007 - 2) % 1000000007);
long long ans = (nf * ((nrf * rf) % 1000000007)) % 1000000007;
return ans;
}
int findparent(int a, vector<int>& par) {
if (par[a] < 0) return a;
return par[a] = findparent(par[a], par);
}
void ubr(int a, int b, vector<int>& par, vector<int>& rank) {
if (a == b) return;
if (rank[a] > rank[b]) {
par[b] = a;
rank[a] += rank[b];
} else {
par[a] = b;
rank[b] += rank[a];
}
}
struct edge {
int a, b, w;
};
const int NODES = 10007;
void matrixMul(vector<vector<long long>>& identity,
vector<vector<long long>>& mt, int n) {
vector<vector<long long>> res(n, vector<long long>(n, 0));
for (int(i) = (0); (i) < (n); ++(i)) {
for (int(j) = (0); (j) < (n); ++(j)) {
for (int(k) = (0); (k) < (n); ++(k)) {
res[i][j] =
(res[i][j] + (mt[i][k] * identity[k][j]) % 1000000007) % 1000000007;
}
}
}
identity = res;
}
void matrixExpo(vector<vector<long long>>& mt, int n, long long exp) {
vector<vector<long long>> identity(n, vector<long long>(n, 0));
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (n); ++(j)) {
if (i == j) identity[i][j] = 1;
}
while (exp) {
if (exp % 2 == 1) {
matrixMul(identity, mt, n);
}
matrixMul(mt, mt, n);
exp /= 2;
}
mt = identity;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
auto T = clock();
int test, sno = 0;
test = 1;
while (sno++ < test) {
int n, m;
cin >> n >> m;
vector<int> v(m);
for (int(i) = (0); (i) < (m); ++(i)) cin >> v[i];
set<int> diff;
vector<int> possible(m, 0);
map<int, int> mp;
for (int(i) = (0); (i) < (m); ++(i)) {
if (!((diff).find(v[i]) != (diff).end()))
diff.insert(v[i]);
else {
mp[v[i]]++;
}
if (diff.size() == n) {
diff.clear();
possible[i] = 1;
for (auto itr = mp.begin(); itr != mp.end(); itr++) {
if (itr->second > 0) {
diff.insert(itr->first);
itr->second--;
}
}
}
cout << possible[i];
}
}
cerr << "TIME: " << double(clock() - T) / CLOCKS_PER_SEC << "s"
<< "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const int INF = 1e9;
const long long MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
bool C[MAXN];
int X[MAXN], Y[MAXN], P[MAXN];
vector<int> G[MAXN], V[MAXN], H[MAXN], VX, VY;
vector<pair<int, int> > E;
set<int> DX[MAXN], DY[MAXN];
int GetPar(int v) { return P[v] == v ? v : P[v] = GetPar(P[v]); }
void Merge(int v, int u) {
v = GetPar(v), u = GetPar(u);
if (v == u) return (void)(C[v] = 1);
if ((int)(DX[v].size()) + (int)(DY[v].size()) <
(int)(DX[u].size()) + (int)(DY[u].size()))
swap(v, u);
for (int x : DX[u]) DX[v].insert(x);
for (int y : DY[u]) DY[v].insert(y);
P[u] = v;
C[v] |= C[u];
}
int Power(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1LL * a * a % MOD)
if (b & 1) res = 1LL * res * a % MOD;
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> X[i] >> Y[i], VX.push_back(X[i]), VY.push_back(Y[i]);
sort(VX.begin(), VX.end()), sort(VY.begin(), VY.end());
VX.resize(unique(VX.begin(), VX.end()) - VX.begin()),
VY.resize(unique(VY.begin(), VY.end()) - VY.begin());
for (int i = 0; i < n; i++) {
X[i] = lower_bound(VX.begin(), VX.end(), X[i]) - VX.begin();
Y[i] = lower_bound(VY.begin(), VY.end(), Y[i]) - VY.begin();
V[X[i]].push_back(i);
H[Y[i]].push_back(i);
}
for (int i = 0; i < n; i++) P[i] = i, DX[i].insert(X[i]), DY[i].insert(Y[i]);
for (int i = 0; i < n; i++)
sort(V[i].begin(), V[i].end(), [&](int a, int b) { return Y[a] < Y[b]; });
for (int i = 0; i < n; i++)
sort(H[i].begin(), H[i].end(), [&](int a, int b) { return X[a] < X[b]; });
for (int x = 0; x < n; x++) {
for (int i = 1; i < (int)(V[x].size()); i++) {
int v = V[x][i - 1], u = V[x][i];
Merge(v, u);
}
}
for (int y = 0; y < n; y++) {
for (int i = 1; i < (int)(H[y].size()); i++) {
int v = H[y][i - 1], u = H[y][i];
Merge(v, u);
}
}
int ans = 1;
for (int i = 0; i < n; i++)
if (P[i] == i) {
int x = (int)(DX[i].size()), y = (int)(DY[i].size());
ans = 1LL * ans * (Power(2, x + y) - !C[i]) % MOD;
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long T, n, t;
void solve() {
long long int mx = 0, ans = 0, flag = 0, a, i, j, k, x, y, a1, a2, b1, b2, xs,
ys, t, dist, b;
cin >> x >> y >> a1 >> a2 >> b1 >> b2;
cin >> xs >> ys >> t;
a = x;
b = y;
vector<pair<long long, long long>> v;
while (1) {
v.push_back(make_pair(a, b));
a = a * a1 + b1;
b = b * a2 + b2;
if (a > 30000000000000000 || b > 30000000000000000) break;
}
for (i = 0; i < v.size(); i++) {
dist = abs(xs - v[i].first) + abs(ys - v[i].second);
for (j = 0; j < v.size(); j++) {
ans =
dist + abs(v[i].first - v[j].first) + abs(v[i].second - v[j].second);
if (ans <= t) mx = max(mx, abs(j - i) + 1);
}
}
cout << mx;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 105;
int n, a[N], cnt[N];
short dp[N][N][N * N];
int pre[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), ++cnt[a[i]];
dp[0][0][0] = 1;
int mx = 0;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i) {
mx += a[i];
memcpy(dp[i], dp[i - 1], sizeof dp[i]);
for (int j = mx; j >= a[i]; --j)
for (int k = i; k >= 1; --k) dp[i][k][j] += dp[i - 1][k - 1][j - a[i]];
if (pre[a[i]]) {
for (int j = mx; j >= a[i]; --j)
for (int k = i; k >= 1; --k)
dp[i][k][j] -= dp[pre[a[i]] - 1][k - 1][j - a[i]];
}
pre[a[i]] = i;
}
int ans = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= mx; ++j)
if (dp[n][i][j] == 1) {
int ok = 0;
if (j % i == 0 && cnt[j / i] >= i) {
++ok;
ans = max(ans, i);
}
if (i != n && (mx - j) % (n - i) == 0 &&
cnt[(mx - j) / (n - i)] >= n - i) {
++ok;
ans = max(ans, n - i);
}
if (ok == 2) return printf("%d\n", n), 0;
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e9;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long tests;
cin >> tests;
while (tests--) {
long long n;
cin >> n;
long long arr[2 * n];
for (long long i = 0; i < (long long)2 * n; i++) cin >> arr[i];
if (n == 2) {
cout << "1 2\n";
continue;
}
vector<long long> vec;
for (long long i = 0; i < (long long)2 * n; i++) {
if (arr[i] & 1)
vec.emplace_back(1);
else
vec.emplace_back(0);
}
vector<pair<long long, long long> > ans;
bool vis[2 * n];
memset(vis, 0, sizeof(vis));
long long cnt = 0;
for (long long i = 0; i < (long long)2 * n; i++) {
if (vec[i] == 1 && vis[i] == 0) {
for (long long j = 0; j < 2 * n; j++) {
if (j != i && vec[j] == 1 && vis[j] == 0) {
vis[i] = 1;
vis[j] = 1;
ans.emplace_back(make_pair(i + 1, j + 1));
cnt++;
break;
}
}
} else if (vec[i] == 0 && vis[i] == 0) {
for (long long j = 0; j < 2 * n; j++) {
if (j != i && vec[j] == 0 && vis[j] == 0) {
vis[i] = 1;
vis[j] = 1;
ans.emplace_back(make_pair(i + 1, j + 1));
cnt++;
break;
}
}
}
if (cnt >= n - 1) break;
}
for (auto itr : ans) {
cout << itr.first << " " << itr.second << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const int MAXK = 2016;
const int MOD = 1e9 + 7;
void addeq(int &x, int y) {
x += y;
if (x >= MOD) {
x -= MOD;
}
}
int add(int x, int y) {
addeq(x, y);
return x;
}
void subtreq(int &x, int y) {
x -= y;
if (x < 0) {
x += MOD;
}
}
int subtr(int x, int y) {
subtreq(x, y);
return x;
}
int mult(int x, int y) { return 1ll * x * y % MOD; }
void multeq(int &x, int y) { x = mult(x, y); }
int inv(int x) {
int v = 1;
for (int i = MOD - 2; i; i >>= 1) {
if (i & 1) {
multeq(v, x);
}
multeq(x, x);
}
return v;
}
int N, M, K;
pair<int, int> A[MAXK];
bool extra;
int dp[23][MAXK];
int sval[23];
int fact[MAXN], ifact[MAXN];
void precomp() {
fact[0] = fact[1] = ifact[0] = ifact[1] = 1;
for (int i = 2; i < MAXN; i++) {
fact[i] = mult(fact[i - 1], i);
ifact[i] = inv(fact[i]);
}
}
int cho(int x, int y) { return mult(fact[x], mult(ifact[y], ifact[x - y])); }
int path(pair<int, int> p1, pair<int, int> p2) {
int dx = p2.first - p1.first, dy = p2.second - p1.second;
return dx >= 0 && dy >= 0 ? cho(dx + dy, dx) : 0;
}
int main() {
precomp();
scanf("%d %d %d %d", &N, &M, &K, &sval[0]);
for (int i = 1; i < 23; i++) {
sval[i] = (sval[i - 1] + 1) / 2;
}
for (int i = 1; i <= K; i++) {
scanf("%d %d", &A[i].first, &A[i].second);
}
sort(A + 1, A + K + 1);
if (A[K] != pair<int, int>(N, M)) {
extra = true;
A[++K] = pair<int, int>(N, M);
}
for (int num = 1; num < 23; num++) {
for (int i = 1; i <= K; i++) {
dp[num][i] = path(pair<int, int>(1, 1), A[i]);
for (int j = 1; j < i; j++) {
subtreq(dp[num][i], mult(path(A[j], A[i]), dp[num][j]));
}
for (int j = 1; j < num; j++) {
subtreq(dp[num][i], dp[j][i]);
}
}
}
int ans = 0;
int totpath = path(pair<int, int>(1, 1), A[K]), bigpath = totpath;
for (int i = 1; i < 23; i++) {
addeq(ans, mult(sval[i - extra], dp[i][K]));
subtreq(bigpath, dp[i][K]);
}
addeq(ans, bigpath);
printf("%d\n", mult(ans, inv(totpath)));
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long m = n / (2 * (k + 1));
printf("%lld %lld %lld\n", m, m * k, n - (m * (k + 1)));
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.