solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string res = "";
for (int i = 0; i < (n + 3) / 4; i++) {
res += '8';
}
for (int i = 0; i < n - (n + 3) / 4; i++) {
res += '9';
}
reverse(res.begin(), res.end());
cout << res << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int mod;
inline int add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
inline int mult(int a, int b) { return (long long)a * b % mod; }
inline int pot(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = mult(ret, a);
a = mult(a, a);
b >>= 1;
}
return ret;
}
long long int rj = 0;
vector<vector<pair<int, int> > > graf;
vector<bool> obraden;
vector<int> vel;
vector<int> pot_10;
vector<int> inv_pot_10;
int rek(int cvor, int par) {
vel[cvor] = 1;
for (auto sus : graf[cvor]) {
if (obraden[sus.first] || sus.first == par) continue;
vel[cvor] += rek(sus.first, cvor);
}
return vel[cvor];
}
map<int, int> mapa;
void dodaj(int cvor, int par, int dub, int broj, bool sta) {
if (sta)
mapa[broj]++;
else
mapa[broj]--;
for (auto sus : graf[cvor]) {
if (obraden[sus.first] || sus.first == par) continue;
dodaj(sus.first, cvor, dub + 1, add(broj, mult(pot_10[dub], sus.second)),
sta);
}
return;
}
void update(int cvor, int par, int dub, int broj) {
if (broj == 0)
rj += mapa[0] + 1;
else
rj += mapa[mod - broj];
for (auto sus : graf[cvor]) {
if (obraden[sus.first] || sus.first == par) continue;
update(sus.first, cvor, dub + 1,
add(broj, mult(inv_pot_10[dub + 1], sus.second)));
}
return;
}
void dek(int cvor) {
vel[cvor] = rek(cvor, -1);
int n = vel[cvor];
bool nasao = 0;
int par = -1;
while (!nasao) {
nasao = 1;
for (auto sus : graf[cvor]) {
if (obraden[sus.first] || sus.first == par) continue;
if (vel[sus.first] > n / 2) {
nasao = 0;
par = cvor;
cvor = sus.first;
break;
}
}
}
obraden[cvor] = 1;
dodaj(cvor, -1, 0, 0, 1);
mapa[0]--;
rj += mapa[0];
for (auto sus : graf[cvor]) {
if (!obraden[sus.first]) {
dodaj(sus.first, cvor, 1, sus.second, 0);
update(sus.first, cvor, 1, mult(sus.second, inv_pot_10[1]));
dodaj(sus.first, cvor, 1, sus.second, 1);
}
}
dodaj(cvor, -1, 0, 0, 0);
mapa[0]++;
for (auto sus : graf[cvor]) {
if (!obraden[sus.first]) dek(sus.first);
}
return;
}
int main() {
int n;
scanf("%d%d", &n, &mod);
if (mod == 1) {
printf("%lld\n", (long long int)n * (n - 1));
return 0;
}
graf.insert(graf.begin(), n, vector<pair<int, int> >());
obraden.insert(obraden.begin(), n, 0);
vel.resize(n);
pot_10.resize(n);
inv_pot_10.resize(n);
pot_10[0] = inv_pot_10[0] = 1;
int jkd;
for (long long int i = mod;; i += mod) {
if ((i + 1) % 10 == 0) {
jkd = (i + 1) / 10;
break;
}
}
for (int i = 1; i < n; i++) {
pot_10[i] = mult(pot_10[i - 1], 10);
inv_pot_10[i] = mult(inv_pot_10[i - 1], jkd);
}
int a, b, c;
for (int i = 0; i < (n - 1); i++) {
scanf("%d%d%d", &a, &b, &c);
c %= mod;
graf[a].push_back(make_pair(b, c));
graf[b].push_back(make_pair(a, c));
}
dek(0);
printf("%lld\n", rj);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
const long long MOD = 1e9 + 7;
long long fac[MAXN], nxl[MAXN], nxr[MAXN], fun[MAXN];
long long qpow(long long a, long long n) {
a %= MOD;
long long res = 1;
for (; n; n >>= 1) {
if (n & 1) {
res = res * a % MOD;
}
a = a * a % MOD;
}
return res;
}
long long inv(long long x) { return qpow(x, MOD - 2); }
int main() {
int n, k;
cin >> n >> k;
fac[0] = 1;
nxl[0] = n;
nxr[k + 2] = 1;
for (int i = 1; i <= k + 1; i++) {
fac[i] = fac[i - 1] * i % MOD;
nxl[i] = nxl[i - 1] * (n - i) % MOD;
fun[i] = qpow(i, k) + fun[i - 1] % MOD;
}
for (int i = k + 1; i >= 0; i--) {
nxr[i] = nxr[i + 1] * (n - i) % MOD;
}
long long ans = 0;
for (int i = 1; i <= k + 1; i++) {
long long op = (k + 1 - i) & 1 == 1 ? -1 : 1;
ans = (ans + op * fun[i] * nxl[i - 1] % MOD * nxr[i + 1] % MOD *
inv(fac[i]) % MOD * inv(fac[k + 1 - i]) % MOD) %
MOD;
ans = (ans + MOD) % MOD;
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int q;
long long g, r;
long long gr;
long long li[101000];
long long sl[101000];
long long qu[101000];
long long ans[101000];
long long dp[101000];
long long ev[201000];
inline long long mod(long long a, long long b) {
a %= b;
if (a < 0) a += b;
return a;
}
long long tre[1010000];
inline void down(int np) {
if (tre[np] != -1) {
tre[np * 2] = tre[np * 2 + 1] = tre[np];
tre[np] = -1;
}
}
inline void add(int np, int l, int r, int x, int y, int c) {
if (x == y) return;
if (l == x && r == y) {
tre[np] = c;
return;
}
down(np);
int m = (l + r) / 2;
if (x <= m && y >= m) {
add(np * 2, l, m, x, m, c);
add(np * 2 + 1, m, r, m, y, c);
} else if (x >= m) {
add(np * 2 + 1, m, r, x, y, c);
} else {
add(np * 2, l, m, x, y, c);
}
}
inline int que(int np, int l, int r, int x) {
if (tre[np] != -1) return tre[np];
if (r == l + 1) return tre[np];
down(np);
int m = (l + r) / 2;
if (x >= m)
return que(np * 2 + 1, m, r, x);
else
return que(np * 2, l, m, x);
}
int evc;
inline int lshua(int x) { return upper_bound(ev, ev + evc, x) - ev - 1; }
inline void build() {
int i;
memset(tre, -1, sizeof(tre));
evc = 0;
ev[evc++] = 0;
for (i = 0; i < n; i++) {
ev[evc++] = mod(g - sl[i], gr);
ev[evc++] = mod(g + r - sl[i], gr);
}
sort(ev, ev + evc);
evc = unique(ev, ev + evc) - ev;
dp[n] = 0;
for (i = n - 1; i >= 0; i--) {
long long sp = mod(0 - sl[i], gr);
int k = que(1, 0, evc, lshua(sp));
if (k == -1)
dp[i] = sl[n] - sl[i];
else {
long long qq = sl[k] - sl[i];
qq = (qq / gr + 1) * gr;
qq += dp[k];
dp[i] = qq;
}
long long e1 = mod(g - sl[i], gr);
long long e2 = mod(g + r - sl[i], gr);
int ee1 = lshua(e1);
int ee2 = lshua(e2);
if (ee1 < ee2)
add(1, 0, evc, ee1, ee2, i);
else {
add(1, 0, evc, ee1, evc, i);
add(1, 0, evc, 0, ee2, i);
}
}
}
inline void solve() {
int i;
build();
for (i = 0; i < q; i++) {
long long qq = qu[i];
long long rr = qq / gr;
qq %= gr;
int qqq = lshua(qq);
int k = que(1, 0, evc, qqq);
if (k == -1)
ans[i] = qu[i] + sl[n];
else {
qq += sl[k];
qq = (qq / gr + 1) * gr;
qq += dp[k];
ans[i] = qq + rr * gr;
}
}
}
int main() {
int i;
scanf("%d%I64d%I64d", &n, &g, &r);
gr = g + r;
for (i = 0; i <= n; i++) {
scanf("%I64d", &li[i]);
sl[i] = li[i];
if (i) sl[i] += sl[i - 1];
}
scanf("%d", &q);
for (i = 0; i < q; i++) scanf("%I64d", &qu[i]);
solve();
for (i = 0; i < q; i++) printf("%I64d\n", ans[i]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
enum colour { BLACK, RED };
template <class data>
class redblack {
public:
redblack *left, *right, *par;
int subTreeSize;
colour color;
data compVal;
data subTreeSum;
data sumOfMax(int k) {
if (subTreeSize <= k) return subTreeSum;
long long ret = 0;
if (right != NULL) {
ret += right->sumOfMax(k);
k -= right->subTreeSize;
}
if (k <= 0) return ret;
ret += compVal * min(k, nodeSize());
k -= nodeSize();
if (k <= 0) return ret;
ret += left->sumOfMax(k);
return ret;
}
redblack *root() {
if (par != NULL) return par->root();
return this;
}
static redblack *create() {
redblack *tree = new redblack();
return tree;
}
int nodeSize() { return values.size(); }
vector<data> getValues() { return values; }
redblack find(data val) {
if (isNil) return NULL;
if (compVal == val) return this;
redblack next = getNext(val);
if (next == NULL) return NULL;
return next.find(val);
}
redblack *treeMin() {
if (left == NULL) return this;
return treeMin(left);
}
redblack *treeMax() {
if (right == NULL) return this;
return treeMax(right);
}
redblack *succesor() {
if (isNil) return NULL;
if (right != NULL) return treeMin(right);
redblack *pr = par, *ptr = this;
while (pr != NULL && ptr == pr->right) {
ptr = pr;
pr = ptr->par;
}
return pr;
}
redblack *predecessor() {
if (isNil) return NULL;
if (left != NULL) return treeMax(left);
redblack *pr = par, *ptr = this;
while (pr != NULL && ptr == pr->left) {
ptr = pr;
pr = ptr->par;
}
return pr;
}
bool remove(data val) {
if (isNil) return false;
if (compVal == val) {
if (values.size()) {
values.pop_back();
subTreeSize--;
subTreeSum -= val;
return true;
}
return false;
}
redblack *next = getNext(val);
if (next == NULL) return false;
bool deleted = next->remove(val);
if (deleted) {
subTreeSize--;
subTreeSum -= val;
}
return deleted;
}
redblack *insert(data val) {
if (isNil) {
isNil = false;
par = left = right = NULL;
compVal = val;
values.push_back(val);
subTreeSize = 1;
subTreeSum = val;
color = BLACK;
return this;
}
if (compVal == val) {
values.push_back(val);
subTreeSize++;
subTreeSum += val;
return this;
}
redblack *next = getNext(val);
if (next == NULL) {
redblack *node = new redblack(this, val);
if (val > compVal)
right = node;
else
left = node;
subTreeSize++;
subTreeSum += val;
return node;
}
redblack *inserted = next->insert(val);
subTreeSize++;
subTreeSum += val;
if (par == NULL) inserted->insertBalance();
return inserted;
}
redblack *getNext(data val) {
if (compVal > val) return left;
return right;
}
void clear() {
if (left != NULL) left->clear();
if (right != NULL) right->clear();
delete (this);
}
private:
bool isNil;
vector<data> values;
redblack() {
par = left = right = NULL;
isNil = true;
color = RED;
subTreeSize = 0;
subTreeSum = 0;
}
redblack(redblack *parent, data val) {
left = right = NULL;
par = parent;
isNil = false;
color = RED;
compVal = val;
values.push_back(val);
subTreeSize = 1;
subTreeSum = val;
}
void rightRotate() {
redblack *x = this, *y = x->left;
if (x->isNil || y == NULL || y->isNil) return;
x->left = y->right;
if (y->right != NULL) y->right->par = x;
y->par = x->par;
if (x->par != NULL) {
if (x->par->left == x)
x->par->left = y;
else
x->par->right = y;
}
y->right = x;
x->par = y;
y->subTreeSize = x->subTreeSize;
x->subTreeSize = x->nodeSize() +
((x->left != NULL) ? x->left->subTreeSize : 0) +
((x->right != NULL) ? x->right->subTreeSize : 0);
y->subTreeSum = x->subTreeSum;
x->subTreeSum = x->nodeSize() * x->compVal +
((x->left != NULL) ? x->left->subTreeSum : 0) +
((x->right != NULL) ? x->right->subTreeSum : 0);
}
void leftRotate() {
redblack *x = this, *y = x->right;
if (x->isNil || y == NULL || y->isNil) return;
x->right = y->left;
if (y->left != NULL) y->left->par = x;
y->par = x->par;
if (x->par != NULL) {
if (x->par->left == x)
x->par->left = y;
else
x->par->right = y;
}
y->left = x;
x->par = y;
y->subTreeSize = x->subTreeSize;
x->subTreeSize = x->nodeSize() +
((x->left != NULL) ? x->left->subTreeSize : 0) +
((x->right != NULL) ? x->right->subTreeSize : 0);
y->subTreeSum = x->subTreeSum;
x->subTreeSum = x->nodeSize() * x->compVal +
((x->left != NULL) ? x->left->subTreeSum : 0) +
((x->right != NULL) ? x->right->subTreeSum : 0);
}
void insertBalance() {
redblack *x = this, *y;
while (x->par != NULL && x->par->color == RED) {
if (x->par->par == NULL) return;
if (x->par == x->par->par->left) {
y = x->par->par->right;
if (y != NULL && y->color == RED) {
x->par->color = y->color = BLACK;
x->par->par->color = RED;
x = x->par->par;
} else {
if (x == x->par->right) {
x = x->par;
x->leftRotate();
}
x->par->color = BLACK;
x->par->par->color = RED;
x->par->par->rightRotate();
}
} else {
y = x->par->par->left;
if (y != NULL && y->color == RED) {
x->par->color = y->color = BLACK;
x->par->par->color = RED;
x = x->par->par;
} else {
if (x == x->par->left) {
x = x->par;
x->rightRotate();
}
x->par->color = BLACK;
x->par->par->color = RED;
x->par->par->leftRotate();
}
}
}
this->root()->color = BLACK;
}
};
int n, len, k;
int a[200000];
long long solve() {
long long ret = 0, posSum = 0;
int i;
redblack<long long> *tree = redblack<long long>::create();
for (i = 0; i < (len - 1); i++) {
if (a[i] < 0)
tree->root()->insert(-a[i]);
else
posSum += a[i];
}
for (i = len - 1; i < n; i++) {
if (a[i] < 0)
tree->root()->insert(-a[i]);
else
posSum += a[i];
long long maxTreeSum = tree->root()->sumOfMax(k);
long long noChange = tree->root()->subTreeSum - maxTreeSum;
ret = max(ret, maxTreeSum + posSum - noChange);
if (a[i + 1 - len] < 0)
tree->root()->remove(-a[i + 1 - len]);
else
posSum -= a[i + 1 - len];
}
tree->root()->clear();
return ret;
}
int main(void) {
int i;
cin >> n >> len;
for (i = 0; i < n; i++) {
cin >> a[i];
}
cin >> k;
long long ans = 0;
ans = max(ans, solve());
for (i = 0; i < n; i++) {
a[i] = -a[i];
}
ans = max(ans, solve());
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool solve() {
int n, m, c, v;
cin >> m >> n;
vector<vector<int>> arr(m, vector<int>(n));
for (int i = 0; i < m; i++) {
cin >> c;
for (int j = 0; j < c; j++) {
cin >> v;
arr[i][v - 1] = true;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < i; j++) {
bool vis = false;
for (int idx = 0; !vis && idx < n; idx++)
vis = (arr[i][idx] && arr[j][idx]);
if (!vis) return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve() ? cout << "possible\n" : cout << "impossible\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> v[n + 1];
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int res = 0;
vector<array<int, 2>> dp(n + 1, {0, 0});
vector<int> d(n + 1, 0);
function<void(int, int)> dfs = [&](int a, int p) {
d[a] = v[a].size();
res = max(res, d[a]);
dp[a] = {d[a] - 1, 1};
vector<int> zero, one;
for (int to : v[a]) {
if (to == p) continue;
dfs(to, a);
zero.push_back(max(dp[to][0], dp[to][1]));
one.push_back(dp[to][0]);
dp[a][0] = max(dp[a][0], max(dp[to][0], dp[to][1]) + d[a] - 2);
dp[a][1] = max(dp[a][1], dp[to][0] + 1);
res = max(res, max(dp[to][0], dp[to][1]) + d[a] - 1);
res = max(res, dp[to][0] + 1);
}
sort(zero.begin(), zero.end(), greater<int>());
sort(one.begin(), one.end(), greater<int>());
if (zero.size() >= 2) {
res = max(res, zero[0] + zero[1] + d[a] - 2);
res = max(res, one[0] + one[1] + 1);
}
};
dfs(1, 0);
cout << res << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string a, s;
cin >> a >> s;
if ((long long)a.size() != (long long)s.size()) {
return cout << "NO\n", 0;
}
long long n = (long long)a.size();
for (long long i = 0; i < n; i++) {
s[i] = (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u');
}
for (long long i = 0; i < n; i++) {
a[i] = (a[i] == 'a' || a[i] == 'e' || a[i] == 'i' || a[i] == 'o' ||
a[i] == 'u');
}
for (long long i = 0; i < n; i++) {
if (s[i] != a[i]) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double EPS = 1e-9;
inline int sgn(double a) { return a < -EPS ? -1 : a > EPS; }
struct node {
long long v;
int id;
int date;
node(long long a = 0, int b = 0, int c = 0) {
v = a;
id = b;
date = c;
}
};
bool cmp(node x, node y) { return x.v < y.v; }
int n, m, k;
long long s;
long long a[maxn];
long long b[maxn];
int t[maxn];
long long c[maxn];
int p1[maxn];
int p2[maxn];
vector<node> ans;
bool judge(int x) {
ans.clear();
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
node xx = node((long long)(a[p1[x]] * c[i]), i, p1[x]);
ans.push_back(xx);
} else {
node xx = node((long long)(b[p2[x]] * c[i]), i, p2[x]);
ans.push_back(xx);
}
}
sort(ans.begin(), ans.end(), cmp);
long long sum = 0;
for (int i = 0; i < k; i++) {
sum += ans[i].v;
}
return sum <= s;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> s;
p1[0] = 1;
p2[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] < a[p1[i - 1]]) {
p1[i] = i;
} else
p1[i] = p1[i - 1];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (b[i] < b[p2[i - 1]])
p2[i] = i;
else
p2[i] = p2[i - 1];
}
for (int i = 1; i <= m; i++) {
cin >> t[i] >> c[i];
}
int l = 0;
int r = n + 1;
int mid;
while (l + 1 < r) {
mid = (l + r) >> 1;
if (judge(mid)) {
r = mid;
} else
l = mid;
}
if (r == n + 1) {
cout << -1 << "\n";
return 0;
}
judge(r);
int tt = 0;
for (int i = 0; i < k; i++) {
tt = max(tt, ans[i].date);
}
cout << tt << "\n";
for (int i = 0; i < k; i++) {
cout << ans[i].id << " " << ans[i].date << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, c = 0;
cin >> n;
int a, b;
vector<int> v;
for (int i = 1; i <= n; i++) {
cin >> a;
v.push_back(a);
}
int d = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i] == 5)
c++;
else
d++;
}
if (c >= 9 && d > 0)
b = c - (c % 9);
else
b = 10;
if (d == 0 && b % 9 != 0) {
cout << -1;
return 0;
}
if (d > 0 && b % 9 == 0) {
for (int i = 1; i <= b; i++) cout << 5;
for (int i = 1; i <= d; i++) cout << 0;
} else if (d > 0)
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool uax(T &x, T y) {
return (y > x) ? x = y, true : false;
}
template <typename T>
inline bool uin(T &x, T y) {
return (y < x) ? x = y, true : false;
}
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ": " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = false;
string r = "{";
for (auto x : v) {
if (f) r += ", ";
r += to_string(x);
f = true;
}
return r += "}";
}
template <typename A>
string to_string(vector<vector<A>> v) {
string r;
for (auto x : v) r += "\n" + to_string(x);
return r;
}
int Nerr;
template <typename A>
string to_string(A *p) {
return to_string(vector<A>(p, p + Nerr));
}
void err(istream_iterator<string>) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " =: " << to_string(a) << "; ";
err(++it, args...);
}
template <typename T>
void kek(T ans) {
cout << ans << endl;
exit(0);
}
int const MOD = 1e9 + 7;
long long const INF = 1e18 + 42;
const int N = 1e5 + 42;
vector<int> g[N];
int cov[N];
int nei[N];
int cnt[N];
multiset<int> cs[N];
multiset<int> ns[N];
int ans;
void pre(int u = 0, int p = -1) {
cnt[u] = -1;
cs[u] = {0};
ns[u] = {1};
for (int v : g[u])
if (v ^ p) {
pre(v, u);
cs[u].insert(nei[v] + cnt[v]);
ns[u].insert(max(1 + cov[v], nei[v] + cnt[v]));
cnt[u]++;
}
cov[u] = *cs[u].rbegin();
nei[u] = *ns[u].rbegin();
}
void dfs(int u = 0, int p = -1) {
cov[u] = *cs[u].rbegin();
nei[u] = *ns[u].rbegin();
uax(ans, 1 + cov[u]);
--cnt[u];
for (int v : g[u])
if (v != p) {
cs[u].erase(cs[u].find(nei[v] + cnt[v]));
ns[u].erase(ns[u].find(max(nei[v] + cnt[v], 1 + cov[v])));
cov[u] = *cs[u].rbegin();
nei[u] = *ns[u].rbegin();
cs[v].insert(nei[u] + cnt[u]);
ns[v].insert(max(nei[u] + cnt[u], 1 + cov[u]));
++cnt[v];
dfs(v, u);
--cnt[v];
cs[v].erase(cs[v].find(nei[u] + cnt[u]));
ns[v].erase(ns[v].find(max(nei[u] + cnt[u], 1 + cov[u])));
cov[v] = *cs[v].rbegin();
nei[v] = *ns[v].rbegin();
cs[u].insert(nei[v] + cnt[v]);
ns[u].insert(max(nei[v] + cnt[v], 1 + cov[v]));
}
++cnt[u];
}
int32_t main() {
cin.tie(nullptr)->sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v, --u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
pre(), dfs(), kek(ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<long long, int> m;
long long sum = 0;
int ans = n - 1;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
sum += x;
m[sum]++;
ans = min(ans, n - m[sum]);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
int arr[4];
for (i = 0; i < 4; ++i) {
cin >> arr[i];
}
string str;
cin >> str;
int sum = 0;
int index;
for (i = 0; str[i] != '\0'; ++i) {
index = str[i] - '0';
sum = sum + arr[index - 1];
}
cout << sum;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
double min;
double dist;
double time;
cin >> a >> b;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int lx, ly, lv;
cin >> lx >> ly >> lv;
dist = sqrt(((lx - a) * (lx - a)) + ((ly - b) * (ly - b)));
if (dist == 0) {
min = 0;
printf("%.20lf", min);
return 0;
}
time = (double)((double)dist / (double)lv);
if (i == 0) {
min = time;
continue;
} else if (time < min)
min = time;
}
printf("%.20lf", min);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, n, ymax, i, flag, x, y[100001] = {0}, z[100001] = {0};
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
flag = 0;
cin >> a;
z[y[a]]--;
y[a]++;
z[y[a]]++;
ymax = max(ymax, y[a]);
if (z[1] == i) flag = 1;
if (z[i] == 1) flag = 1;
if (z[1] == 1 && z[ymax] * ymax == i - 1) flag = 1;
if (z[ymax - 1] * (ymax - 1) == i - ymax && z[ymax] == 1) flag = 1;
if (flag) x = i;
}
cout << x << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000;
const int INF = 0x3f3f3f3f;
const int MOD = 1000000009;
template <class T>
void Read(T &x) {
x = 0;
char c = getchar();
bool flag = 0;
while (c < '0' || '9' < c) {
if (c == '-') flag = 1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (flag) x = -x;
}
int n;
int dp[MAXN + 10];
int main() {
Read(n);
n = n / 2;
int ans = 0, t = 1;
dp[1] = 1;
for (int i = 2; i <= n; ++i) {
ans = (ans + 4ll * t) % MOD;
dp[i] = (dp[i - 1] * 2 + 3) % MOD;
t = 1ll * t * dp[i] % MOD;
}
printf("%d\n", 2 * (1ll * ans * ans % MOD + 4ll * ans % MOD + 5) % MOD);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, i, j, ex, ey, sx, sy;
string res;
queue<pair<int, int> > Q;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int D[51][51];
bool F[257];
char A[51][51];
void push(int x, int y, int z) {
if ((x >= 0 && x < n) && (y >= 0 && y < m) && F[A[x][y]] && D[x][y] == -1) {
D[x][y] = z;
Q.push(make_pair(x, y));
}
}
void rec(int i, int j) {
int x, y, x2, y2, z;
char c;
string str;
set<pair<int, int> > S;
set<pair<int, int> >::iterator it;
if (i == k) {
memset(D, -1, sizeof D);
push(ex, ey, 0);
while (!Q.empty()) {
x = Q.front().first;
y = Q.front().second;
Q.pop();
for (i = 0; i < 4; i++) push(x + dx[i], y + dy[i], D[x][y] + 1);
}
if (D[sx][sy] != -1) {
Q.push(make_pair(sx, sy));
str = "";
while (str.size() < D[sx][sy]) {
c = 'z';
while (!Q.empty()) {
x = Q.front().first;
y = Q.front().second;
cout << flush;
Q.pop();
for (i = 0; i < 4; i++) {
x2 = x + dx[i];
y2 = y + dy[i];
if ((x2 >= 0 && x2 < n) && (y2 >= 0 && y2 < m) &&
D[x2][y2] == D[x][y] - 1) {
if (A[x2][y2] < c) {
c = A[x2][y2];
S.clear();
}
if (A[x2][y2] == c) S.insert(make_pair(x2, y2));
}
}
}
for (it = S.begin(); it != S.end(); it++) Q.push(*it);
str += c;
}
if (res == "S" || str.size() < res.size() ||
(str.size() == res.size() && str < res))
res = str;
}
} else
for (; j <= 'z'; j++) {
F[j] = 1;
rec(i + 1, j + 1);
F[j] = 0;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) {
scanf("%s", A[i]);
for (j = 0; j < m; j++)
if (A[i][j] == 'S') {
sx = i;
sy = j;
} else if (A[i][j] == 'T') {
ex = i;
ey = j;
}
}
F['S'] = F['T'] = 1;
res = "S";
rec(0, 'a');
printf("%s\n", res == "S" ? "-1" : res.substr(0, res.size() - 1).c_str());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<int> row(m, 1e9);
int ans = 0;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
row[a - 1] = min(row[a - 1], b);
}
for (int i = 0; i < m; ++i) ans += row[i];
cout << min(k, ans) << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k, p, a[100005], dp[100005];
bool t(long long int x) {
long long int cnt = 0, ans = 0;
for (int i = 1; i <= n; i++) dp[i] = 0;
for (int i = 1; i <= n; i++) {
if (i > k) cnt -= dp[i - k];
p = a[i] + cnt;
if (x > p) {
dp[i] = x - p;
cnt += x - p;
ans += x - p;
}
}
if (ans <= m)
return true;
else
return false;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long int l = 1, r = 2e9, mid = 0;
while (l < r) {
mid = (l + r) / 2 + 1;
if (t(mid))
l = mid;
else
r = mid - 1;
}
cout << l;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int maxn = 100010;
int t[maxn], T[maxn], x[maxn], cost[maxn];
int n, m;
long long calc(int i, int cnt) {
long long res = (long long)cost[i] * cnt;
long long tm = m;
long long p = T[i] - t[i];
tm -= p * (cnt - 1);
if (tm > p) res += x[i] * tm;
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d%d%d%d", &t[i], &T[i], &x[i], &cost[i]);
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (T[i] - t[i] <= 0) {
ans += cost[i] + x[i] * (long long)m;
} else {
int l = 1;
int r = m;
while (r - l >= 3) {
int m1 = l + (r - l) / 3;
int m2 = r - (r - l) / 3;
long long v1 = calc(i, m1);
long long v2 = calc(i, m2);
if (v1 < v2)
r = m2;
else
l = m1;
}
long long best = calc(i, 1);
int p = (T[i] - t[i]);
best = min(best, calc(i, (m + p - 1) / p));
for (int j = l; j <= r; ++j) best = min(best, calc(i, j));
ans += best;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int ret = 0, f = 1;
for (; c < '0' || c > '9'; f = c == '-' ? -1 : 1, c = getchar())
;
for (; '0' <= c && c <= '9'; ret = ret * 10 + c - '0', c = getchar())
;
return ret * f;
}
int main() {
for (int T = read(); T; T--) {
int n = read();
if (n <= 5) {
printf("%d\n", n - 1);
} else {
int l = 2, r = n, x, ret = -1;
while (l <= r) {
x = l + r >> 1;
if ((long long)x * x + x <= 2ll * n) {
ret = x;
l = x + 1;
} else {
r = x - 1;
}
}
assert(ret >= 0);
printf("%lld\n",
max(n - ret + ret * (ret - 1ll) / 2, n - ret - 1ll << 1));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int check_bills(int num, int count) {
if (num >= 100) {
while (num >= 100) {
num -= 100;
count++;
}
check_bills(num, count);
}
if (num >= 20) {
while (num >= 20) {
num -= 20;
count++;
}
check_bills(num, count);
}
if (num >= 10) {
while (num >= 10) {
num -= 10;
count++;
}
check_bills(num, count);
}
if (num >= 5) {
while (num >= 5) {
num -= 5;
count++;
}
check_bills(num, count);
}
if (num >= 1) {
while (num >= 1) {
num -= 1;
count++;
}
}
return count;
}
int min_bills(int num) {
if (num % 100 == 0) {
return num / 100;
} else {
int count = 0;
return check_bills(num, count);
}
}
int main() {
int num;
cin >> num;
cout << min_bills(num) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, count = 0, flag, x = 0;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> a[i][j];
}
for (int i = 0; i < n; i++) {
flag = 0;
for (int j = 0; j < m; j++) {
if (a[i][j] == 'S') {
flag = 1;
break;
}
}
if (flag == 0) {
x++;
count += m;
}
}
for (int i = 0; i < m; i++) {
flag = 0;
for (int j = 0; j < n; j++) {
if (a[j][i] == 'S') {
flag = 1;
break;
}
}
if (flag == 0) count += n - x;
}
cout << count << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long XX[8] = {+1, +1, +1, 0, 0, -1, -1, -1};
long long YY[8] = {+1, 0, -1, +1, -1, +1, 0, -1};
long long dx[4] = {-1, 1, 0, 0};
long long dy[4] = {0, 0, 1, -1};
long long n, m, k;
string s, t;
long long dp[1001][1001][12][2];
long long solve(long long i, long long j, long long k, long long fl) {
if (i == n or j == m) {
return (k == 0) ? 0 : -1e18;
}
if (k == 0) return 0;
if (dp[i][j][k][fl] != -1) return dp[i][j][k][fl];
long long ans = -1e18;
ans = max(ans, solve(i + 1, j, k - fl, 0));
ans = max(ans, solve(i, j + 1, k - fl, 0));
if (s[i] == t[j]) {
ans = max(ans, 1 + solve(i + 1, j + 1, k, 1));
ans = max(ans, 1 + solve(i + 1, j + 1, k - 1, 0));
}
return dp[i][j][k][fl] = ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
cin >> s >> t;
memset(dp, -1, sizeof(dp));
cout << solve(0, 0, k, 0) << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int x, y;
bool operator<(const P &a) const {
if (x != a.x) return x < a.x;
return y < a.y;
}
};
long long x, y, z, mod = 1000000007;
vector<int> v[111111];
int i, n, m, k, a, d, b, c;
int e;
int o[1];
int l[2];
int j[1];
queue<int> q;
P u[1];
char r[1], r1[3];
bool as(P a, P b) { return a.x < b.x; }
int main() {
scanf("%d", &a);
for (int t = 1; t < a; t++) {
scanf("%d %d", &n, &m);
v[n].push_back(m);
v[m].push_back(n);
}
for (int t = 1; t <= a; t++)
if (v[t].size() == 2) {
puts("NO");
return 0;
}
puts("YES");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < n + 1; j++)
for (int k = 0; k < n + 1; k++)
for (int w = 0; w < n + 1; w++)
if (2 * i + 3 * j + 4 * k + 5 * w == m && i + j + k + w == n) {
cout << i;
return 0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, x = 0, z = 0;
cin >> n;
vector<long long> a(n), s(n), pr(n);
vector<vector<long long>> dety(n);
for (long long j = 1; j < n; j++) {
cin >> x;
pr[j] = x - 1;
dety[pr[j]].push_back(j);
}
for (long long j = 0; j < n; j++) {
cin >> s[j];
}
a[0] = s[0];
queue<long long> q;
q.push(0);
while (!q.empty()) {
long long v = q.front();
q.pop();
long long mi = 1000000000000;
for (long long u : dety[v]) {
q.push(u);
if (s[u] < mi) {
mi = s[u];
};
}
if (s[v] == -1) {
if (mi == 1000000000000) {
mi = s[pr[v]];
}
s[v] = mi;
a[v] = s[v] - s[pr[v]];
if (s[pr[v]] > s[v]) {
cout << -1;
return 0;
}
for (long long u : dety[v]) {
a[u] = s[u] - s[v];
}
}
}
long long otv = 0;
for (long long j = 0; j < n; j++) {
otv += a[j];
}
cout << otv;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long linf = 1e18;
const int MOD = 1e9 + 7;
const int N = 2e5 + 10;
int n, a[N];
long long ssum[N];
pair<long long, long long> line[N], b[N << 2];
long long cal(pair<long long, long long> a, long long x) {
return a.first * x + a.second;
}
void push_down(int node, int L, int R, pair<long long, long long> cur) {
long long cL = cal(b[node], L), cR = cal(b[node], R);
long long nL = cal(cur, L), nR = cal(cur, R);
if (nL <= cL && nR <= cR) {
b[node] = cur;
return;
}
if (nL >= cL && nR >= cR) return;
int mid = (L + R) / 2;
long long cM = cal(b[node], mid), nM = cal(cur, mid);
if (nL <= cL) {
if (nM <= cM) {
push_down(node * 2 + 1, mid + 1, R, b[node]);
b[node] = cur;
} else
push_down(node * 2, L, mid, cur);
return;
}
if (nM >= cM)
push_down(node * 2 + 1, mid + 1, R, cur);
else {
push_down(node * 2, L, mid, b[node]);
b[node] = cur;
}
}
void update(int node, int L, int R, int l, int r,
pair<long long, long long> cur) {
if (L > r || R < l) return;
if (l <= L && R <= r) {
push_down(node, L, R, cur);
return;
}
update(node * 2, L, (L + R) / 2, l, r, cur);
update(node * 2 + 1, (L + R) / 2 + 1, R, l, r, cur);
}
long long get(int node, int L, int R, int idx) {
if (L > idx || R < idx) return linf;
long long ans = cal(b[node], idx);
if (L < R)
ans = min(ans, min(get(node * 2, L, (L + R) / 2, idx),
get(node * 2 + 1, (L + R) / 2 + 1, R, idx)));
return ans;
}
void prepare() {
scanf("%d", &n);
for (auto i = (1); i <= (n); i++) scanf("%d", a + i);
for (auto i = (n); i >= (1); i--) ssum[i] = ssum[i + 1] + a[i];
line[n + 1] = pair<long long, long long>(0, 0);
for (auto i = (n); i >= (1); i--)
line[i] = pair<long long, long long>(-ssum[i],
line[i + 1].second + 1LL * i * a[i]);
for (auto i = (0); i < (N << 2); i++)
b[i] = pair<long long, long long>(inf, linf);
for (auto i = (1); i <= (n + 1); i++) update(1, 0, n, 0, i - 1, line[i]);
}
long long solve() {
long long ans = -linf;
for (auto i = (0); i < (n); i++)
ans = max(ans, line[i + 1].second - ssum[i + 1] * i - get(1, 0, n, i));
return ans;
}
int main() {
prepare();
cout << solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int main() {
int n;
cin >> n;
string s;
cin >> s;
long long ans = 0;
long long cnt1 = 0;
stack<char> sh;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
if (cnt1 == 0) {
sh.push('(');
} else {
cnt1--;
ans++;
}
} else {
if (sh.empty()) {
cnt1++;
} else {
sh.pop();
}
}
}
if (cnt1 != 0 || !sh.empty()) {
cout << -1 << endl;
} else {
printf("%lld\n", ans * 2);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mymap;
int m, p[1050];
char output[10][20] = {"pro", "hardcore", "average", "random", "noob"};
int cal(int pos) {
pos *= 100;
if (pos <= m)
return 0;
else if (pos <= m * 10)
return 1;
else if (pos <= m * 20)
return 2;
else if (pos <= m * 50)
return 3;
else
return 4;
}
int main() {
int n, second;
string name;
while (cin >> n) {
mymap.clear();
while (n--) {
cin >> name >> second;
if (mymap.find(name) == mymap.end() || mymap[name] < second)
mymap[name] = second;
}
m = 0;
for (map<string, int>::iterator it = mymap.begin(); it != mymap.end(); it++)
p[m++] = (*it).second;
sort(p, p + m);
p[m] = p[m - 1] + 1;
cout << m << endl;
for (map<string, int>::iterator it = mymap.begin(); it != mymap.end();
it++) {
name = (*it).first;
second = (*it).second;
second = m - (upper_bound(p, p + m + 1, second) - p);
cout << name + " " + output[cal(second)] << endl;
}
cout << endl;
;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
char c = getchar();
int x = 0;
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + c - '0';
return x;
}
const int N = 2e5 + 5, Mod = 1e9 + 7;
int a[N], b[N], pri[N], tot, phi[N], mu[N], n, dep[N], fa[N], top[N], son[N],
size[N], st[N], ed[N], tid;
int vis[N], ans, cnt, stk[N], f[N], g[N], dp[N];
bool p[N], vu[N];
vector<int> e[N], now, ne[N];
void upd(int& x, int y) {
x = (y < 0 ? (x + y < 0 ? x + y + Mod : x + y)
: (x + y >= Mod ? x + y - Mod : x + y));
}
inline int po(int x, int y = Mod - 2) {
int r = 1;
for (; y; y >>= 1, x = (1ll * (x) * (x) % Mod))
if (y & 1) r = (1ll * (r) * (x) % Mod);
return r;
}
void dfs(int u) {
size[u] = 1;
for (auto v : e[u])
if (v != fa[u]) {
fa[v] = u, dep[v] = dep[u] + 1, dfs(v);
size[u] += size[v];
if (size[v] > size[son[u]]) son[u] = v;
}
}
void dfs2(int u, int tp) {
st[u] = ++tid, top[u] = tp;
if (son[u]) dfs2(son[u], tp);
for (auto v : e[u])
if (v != fa[u] && v != son[u]) dfs2(v, v);
ed[u] = tid;
}
inline int lca(int u, int v) {
while (top[u] ^ top[v])
dep[top[u]] > dep[top[v]] ? u = fa[top[u]] : v = fa[top[v]];
return dep[u] < dep[v] ? u : v;
}
bool cmp(int x, int y) { return st[x] < st[y]; }
void idfs(int u, int fa) {
dp[u] = vu[u] * phi[a[u]];
upd(cnt, (1ll * (dep[u]) * ((1ll * (dp[u]) * (dp[u]) % Mod)) % Mod));
for (auto v : ne[u])
if (v != fa) {
idfs(v, u);
upd(cnt,
(1ll * (2) *
((1ll * (dep[u]) * ((1ll * (dp[u]) * (dp[v]) % Mod)) % Mod)) % Mod));
upd(dp[u], dp[v]);
}
}
int main() {
n = gi(), phi[1] = mu[1] = 1;
for (int i = 2; i <= n; ++i) {
if (!p[i]) pri[++tot] = i, mu[i] = -1, phi[i] = i - 1;
for (int j = 1; i * pri[j] <= n && j <= tot; ++j) {
p[i * pri[j]] = true;
if (i % pri[j] == 0) {
phi[i * pri[j]] = phi[i] * pri[j];
break;
}
mu[i * pri[j]] = -mu[i], phi[i * pri[j]] = phi[i] * (pri[j] - 1);
}
}
for (int i = 1; i <= n; ++i) a[i] = gi(), b[a[i]] = i;
for (int i = 1; i < n; ++i) {
int u = gi(), v = gi();
e[u].push_back(v), e[v].push_back(u);
}
dep[1] = 1, dfs(1), dfs2(1, 1);
for (int i = 1; i <= n; ++i) {
int s1 = 0, s2 = 0;
cnt = 0;
now.clear();
for (int j = i; j <= n; j += i)
if (b[j]) {
vis[b[j]] = i, now.push_back(b[j]), vis[b[j]] = i, vu[b[j]] = true;
upd(s1, (1ll * (dep[b[j]]) * (phi[j]) % Mod)), upd(s2, phi[j]);
}
sort(now.begin(), now.end(), cmp);
const int lim = now.size();
for (int j = 1; j < lim; ++j) {
int l = lca(now[j], now[j - 1]);
if (vis[l] != i) now.push_back(l), vis[l] = i;
}
if (vis[1] != i) now.push_back(1);
sort(now.begin(), now.end(), cmp);
int tp = 0;
for (auto x : now) {
for (; tp && ed[stk[tp]] < st[x]; --tp)
;
if (tp) ne[stk[tp]].push_back(x);
stk[++tp] = x;
}
idfs(1, 0), cnt = Mod - (1ll * (2) * (cnt) % Mod);
upd(cnt, (1ll * (2) * ((1ll * (s1) * (s2) % Mod)) % Mod));
for (auto x : now) dp[x] = vu[x] = 0, ne[x].clear();
g[i] = cnt;
}
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; j += i) upd(f[i], mu[j / i] * g[j]);
for (int i = 1; i <= n; ++i)
upd(ans, (1ll * (f[i]) * ((1ll * (i) * (po(phi[i])) % Mod)) % Mod));
ans = (1ll * (ans) * (po((1ll * (n) * (n - 1) % Mod))) % Mod);
printf("%d", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 20;
const long long mod = 1e9 + 7;
char a[10][110];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n, k, flag = 0;
cin >> n >> k;
for (int i = 1; i <= 4; ++i)
for (int j = 1; j <= n; ++j) a[i][j] = '.';
if (k % 2) {
if (n % 2) {
flag = 1;
k--;
a[2][(n + 1) / 2] = '#';
int cnt = k / 2, i = 2;
while (cnt) {
a[2][i] = '#';
cnt--;
if (!cnt) break;
a[3][i] = '#';
cnt--;
i++;
}
cnt = k / 2, i = n - 1;
while (cnt) {
a[2][i] = '#';
cnt--;
if (!cnt) break;
a[3][i] = '#';
cnt--;
i--;
}
}
} else {
flag = 1;
int i = 2;
while (k) {
a[2][i] = a[3][i] = '#';
k -= 2;
i++;
}
}
if (flag) {
cout << "YES" << endl;
for (int i = 1; i <= 4; ++i) {
for (int j = 1; j <= n; ++j) cout << a[i][j];
cout << endl;
}
} else
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long max_n = 2e5 + 5;
long long t, n, k;
long long a[max_n];
bool v[max_n + 1] = {false};
long long l[max_n] = {0}, r[max_n] = {0};
int main() {
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
k = 1;
for (int i = 0; i < n; ++i) {
v[a[i]] = true;
while (v[k]) ++k;
l[i] = k - 1;
}
for (int i = 1; i <= n; ++i) v[i] = false;
k = 1;
for (int i = n - 1; i >= 0; --i) {
v[a[i]] = true;
while (v[k]) ++k;
r[i] = k - 1;
}
vector<long long> l1;
l1.clear();
for (int i = 0; i < n - 1; ++i) {
if (l[i] == (i + 1) and r[i + 1] == (n - i - 1)) l1.push_back(i + 1);
}
cout << l1.size() << endl;
for (int i = 0; i < l1.size(); ++i)
cout << l1[i] << " " << (n - l1[i]) << endl;
for (int i = 0; i < n; ++i) {
l[i] = 0;
r[i] = 0;
v[i + 1] = false;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[(int)2e5];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int cur = 0;
long long ans = 0;
vector<int> p;
for (int i = 1; i <= n; i++) {
if (a[i] < cur) {
ans += cur - a[i] - 1;
p.push_back(i);
continue;
}
if (a[i] == cur) {
cur++;
continue;
}
if (a[i] > cur) {
int k = a[i] - cur;
for (int j = 0; j < k; j++) {
int t = p.back();
ans += (i - t);
p.pop_back();
}
cur = a[i] + 1;
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, sum = 0;
cin >> n;
vector<long long> A(n);
set<long long> V;
V.insert(0);
for (i = 0; i < n; i++) {
cin >> A[i];
}
int count = 0;
for (i = 0; i < n; i++) {
sum += A[i];
if (V.find(sum) != V.end()) {
V.clear();
V.insert(0);
count++;
sum = A[i];
}
V.insert(sum);
}
cout << count << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int fun(string bs) {
long long int ans = 0;
long long int pw = 1;
for (long long int i = bs.length() - 1; i >= 0; i--) {
if (bs[i] == '1') {
ans = (ans + pw + 1000003) % 1000003;
}
pw = (pw * 2) % 1000003;
}
return ans;
}
void solve() {
unordered_map<char, string> map;
map['>'] = "1000";
map['<'] = "1001";
map['+'] = "1010";
map['-'] = "1011";
map['.'] = "1100";
map[','] = "1101";
map['['] = "1110";
map[']'] = "1111";
string s;
cin >> s;
string bs;
for (long long int i = 0; i < s.length(); i++) {
string temp = map[s[i]];
bs = bs + temp;
}
long long int ans = fun(bs);
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int a[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n >> x;
int ans = -1;
for (__typeof((n)) i = (0); i < (n); i += 1) {
int y;
cin >> a[i];
y = a[i];
if (s.find(y) == s.end()) {
s.insert(y);
} else {
ans = 0;
}
}
if (ans == 0) {
cout << 0;
return 0;
}
set<int> s1;
int temp = -1;
for (__typeof((n)) i = (0); i < (n); i += 1) {
if ((a[i] & x) == a[i]) continue;
if (s.find(a[i] & x) != s.end()) {
temp = 1;
break;
} else if (s1.find(a[i] & x) != s1.end()) {
temp = 2;
} else {
s1.insert(a[i] & x);
}
}
cout << temp;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 1;
int n, c[1050];
inline int Read() {
int x = 0;
char y;
do y = getchar();
while (y < '0' || y > '9');
do x = x * 10 + y - '0', y = getchar();
while (y >= '0' && y <= '9');
return x;
}
inline void In(int x, int y) {
int i, j, k, l = 0;
for (i = 2; i * i <= x; i++)
while (x % i == 0) x /= i, c[i] += y;
if (x > 1) c[x] += y;
return;
}
inline void C(int x, int y) {
for (int i = x + 1; i <= y; i++) In(i, 1);
for (int i = 2; i <= y - x; i++) In(i, -1);
return;
}
int main() {
int i, j, k, l, q = 0, w, e;
n = Read();
for (i = 1; i <= n; i++) w = Read(), C(w - 1, w - 1 + q), q += w;
for (i = 2; i <= 1000; i++)
for (j = 1; j <= c[i]; j++) ans = (ans * i) % 1000000007;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int w = 0, n, k;
string a, c;
int v[100001][2];
void dfs(int i, bool b) {
if (i > n) {
cout << "YES" << '\n';
exit(0);
};
if (i < w) return;
if (b) {
if (c[i] == 'X') return;
} else {
if (a[i] == 'X') return;
}
if (v[i][b]) return;
v[i][b] = 1;
w++;
dfs(i - 1, b);
dfs(i + k, !b);
dfs(i + 1, b);
w--;
}
int main() {
cin >> n >> k >> a >> c;
dfs(0, 0);
{
cout << "NO" << '\n';
exit(0);
};
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
string a, b;
cin >> a >> b;
cout << a[0];
for (i = 1; i < a.size(); i++) {
if (a[i] < b[0]) {
cout << a[i];
} else {
break;
}
}
cout << b[0];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 100;
int dp[maxn][maxn], pre[maxn][maxn];
void solve(string s) {
int n = s.length();
for (int i = n - 1; i >= 1; i--) {
for (int j = i; j < n; j++) {
if (i == j) {
dp[i][j] = 1;
} else if (s[i] == s[j]) {
dp[i][j] = (j - i == 1) ? 1 : dp[i + 1][j - 1];
} else {
dp[i][j] = 0;
}
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < n; j++) {
pre[i][j] = dp[i][j] + pre[i][j - 1] - pre[i - 1][j - 1] + pre[i - 1][j];
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
string temp = "#" + s;
memset(dp, 0, sizeof(dp));
memset(pre, 0, sizeof(pre));
solve(temp);
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
cout << pre[b][b] - pre[a - 1][b] - pre[b][a - 1] + pre[a - 1][a - 1]
<< "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char s[55];
char t[55];
getchar();
gets(s);
gets(t);
int ans[100050];
memset(ans, 0, sizeof(ans));
int ct = 0;
int i, j;
int key = 0;
for (i = 0; i < n; i++) {
key = 0;
for (j = i; j < n; j++) {
if (t[i] == s[j]) {
key = 1;
if (i != j) {
while (j - 1 >= i) {
swap(s[j - 1], s[j]);
j--;
ct++;
ans[ct] = j + 1;
}
}
break;
}
}
if (key == 0) {
break;
}
}
if (key == 0)
cout << -1 << endl;
else {
cout << ct << endl;
if (ct > 0) {
cout << ans[1];
for (i = 2; i <= ct; i++) cout << ' ' << ans[i];
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
int i;
int num;
int s = 0, x = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &num);
if (num == 5) s++;
if (num == 0) x++;
}
s = s / 9 * 9;
if (x == 0) {
printf("-1");
return 0;
} else if (s == 0) {
printf("0");
return 0;
}
for (i = 0; i < s; i++) printf("5");
for (i = 0; i < x; i++) printf("0");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[100005];
long n;
long k;
long a[26];
char c1[26];
long b[26];
void qsort(int first, int last) {
int i = first, j = last, x = a[(i + j) / 2];
do {
while (a[i] < x) {
i++;
}
while (a[j] > x) {
j--;
}
if (i <= j) {
if (i != j) {
swap(a[i], a[j]);
swap(c1[i], c1[j]);
}
i++;
j--;
}
} while (i <= j);
if (i < last) {
qsort(i, last);
}
if (j > first) {
qsort(first, j);
}
}
int main() {
n = 0;
char c;
long i, j;
for (i = 0; i < 26; i++) {
a[i] = 0;
b[i] = 0;
}
while (scanf("%c", &c) == 1 && c != 10 && c != 13) {
s[n] = c;
a[c - 'a']++;
n++;
}
cin >> k;
long k1 = n - k;
if (k1 <= 0) {
cout << "0\n";
return 0;
}
if (k1 < 2) {
cout << 1 << "\n";
cout << s[0];
return 0;
}
for (i = 0; i < 26; i++) {
c1[i] = 'a' + i;
}
qsort(0, 25);
i = 25;
while (k1 > 0) {
j = min(k1, a[i]);
k1 -= j;
b[c1[i] - 'a'] = j;
i--;
}
cout << (25 - i) << "\n";
for (i = 0; i < n; i++) {
if (b[s[i] - 'a'] > 0) {
cout << s[i];
b[s[i] - 'a']--;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, i, e[101], r[101], k, ans;
using namespace std;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> e[i] >> r[i];
}
cin >> k;
for (int i = 1; i <= n; i++) {
if (k > r[i]) ans++;
}
cout << n - ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20, MAXT = 10, MAXK = 4, MAXR = 2;
int n, t, f[MAXN + 2][MAXK + 2][MAXT + 2][MAXR + 2];
int Ans;
int main() {
scanf("%d%d", &n, &t);
f[2][2][1][1] = 1;
f[2][3][1][1] = 2;
f[2][4][1][1] = 3;
for (int i = 3; i <= n; i++)
for (int j = 1; j <= 4; j++)
for (int k = 1; k <= t; k++) {
for (int r = 4; r > j; r--)
f[i][j][k][0] += f[i - 1][r][k][0] + f[i - 1][r][k][1];
for (int r = 1; r < j; r++)
f[i][j][k][1] += f[i - 1][r][k][1] + f[i - 1][r][k - 1][0];
}
for (int i = 1; i <= MAXK; i++) Ans += f[n][i][t][0];
printf("%d\n", Ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int findInd(char c) {
if (c >= 'a' && c <= 'z') return c - 'a';
if (c >= '0' && c <= '9') return c - '0' + 26;
return 36;
}
struct Node {
char c;
set<int> cnt;
Node *nxt[40];
Node(char cc) {
c = cc;
for (int i = 0; i < 40; i++) nxt[i] = NULL;
}
} * root[40];
Node *findLeaf(string str, bool isUpdate, int listInd) {
int i, ind;
Node *cur = NULL;
for (i = 0; i < str.size(); i++) {
ind = findInd(str[i]);
if (i == 0) {
if (root[ind] == NULL) {
if (isUpdate == false) return NULL;
root[ind] = new Node(str[i]);
}
cur = root[ind];
} else {
if (cur->nxt[ind] == NULL) {
if (isUpdate == false) return NULL;
cur->nxt[ind] = new Node(str[i]);
}
cur = cur->nxt[ind];
}
if (isUpdate) {
cur->cnt.insert(listInd);
}
}
return cur;
}
void updateString(string wrd, int listInd) {
Node *cur;
for (int i = 0; i < wrd.size(); i++) {
cur = findLeaf(wrd.substr(i), true, listInd);
}
}
int main() {
int n, i, q;
Node *cur;
string s, allStr[10010];
set<int>::iterator it;
for (i = 0; i < 40; i++) {
root[i] = NULL;
}
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s;
allStr[i] = s;
updateString(s, i);
}
cin >> q;
while (q--) {
cin >> s;
cur = findLeaf(s, false, -1);
if (cur == NULL) {
cout << 0 << " -" << endl;
} else {
it = cur->cnt.begin();
cout << cur->cnt.size() << " " << allStr[(*it)] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char _c;
bool _f;
template <class T>
inline void IN(T &x) {
x = 0, _f = 0;
while (_c = getchar(), !isdigit(_c))
if (_c == '-') _f = 1;
while (isdigit(_c)) x = x * 10 + _c - '0', _c = getchar();
if (_f) x = -x;
}
const int mod = 998244353;
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline void sub(int &x, int y) {
x -= y;
if (x < 0) x += mod;
}
inline void pls(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline int dec(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int modpow(int x, long long y, int res = 1) {
for (y = (y + mod - 1) % (mod - 1); y; y >>= 1, x = mul(x, x))
if (y & 1) res = mul(x, res);
return res;
}
template <class T>
inline void chkmin(T &x, T y) {
if (x > y) x = y;
}
template <class T>
inline void chkmax(T &x, T y) {
if (x < y) x = y;
}
const int LogN = 20;
int lim, tim, inv[LogN];
vector<int> w[LogN], rev[LogN];
inline void init_w(int len = 1 << 19) {
w[19].resize(len), w[19][0] = 1, w[19][1] = modpow(3, (mod - 1) >> 20);
for (int i = 2; i < len; ++i) w[19][i] = mul(w[19][i - 1], w[19][1]);
for (int i = 18; i >= 0; --i) {
w[i].resize(len >>= 1);
for (int j = 0; j < len; ++j) w[i][j] = w[i + 1][j << 1];
}
}
inline void init_r(int len) {
for (lim = 1, tim = 0; lim < len; lim <<= 1, ++tim)
;
if (rev[tim].size()) return;
rev[tim].resize(lim), inv[tim] = modpow(lim, -1);
for (int i = 0; i < lim; ++i)
rev[tim][i] = (rev[tim][i >> 1] >> 1) | ((i & 1) << (tim - 1));
}
inline void ntt(vector<int> &f, short typ) {
static unsigned long long g[1 << 20 | 5];
for (int i = 0; i < lim; ++i) g[rev[tim][i]] = f[i];
for (int p = 1, s = 0, t = 0; p < lim; p <<= 1, ++t)
for (int k = 0; k < lim; k += p << 1)
for (int l = k; l < k + p; ++l)
s = mul(g[l + p] % mod, w[t][l - k]), g[l + p] = g[l] + mod - s,
g[l] += s;
for (int i = 0; i < lim; ++i) f[i] = g[i] % mod;
if (~typ) return;
std ::reverse(++f.begin(), f.end());
for (int i = 0; i < lim; ++i) f[i] = mul(f[i], inv[tim]);
}
const int N = 1e5 + 5;
const int inv2 = modpow(2, -1);
int n, m, a[N], b[N], fac[N];
vector<int> f[N << 2][4], g[2][4];
void solve(int x, int l, int r, bool typ) {
const int len = r - l + 2;
for (int o = 0; o < 4; ++o) f[x][o].resize(len);
if (l == r) return f[x][(b[l] == 1) * 3][1] = 1 + (b[l] != 1), void();
const int mid = l + r >> 1, lc = x << 1, rc = x << 1 | 1;
solve(lc, l, mid, 0), solve(rc, mid + 1, r, 1);
const int ln = mid - l + 2, rn = r - mid + 1;
for (int o0 = 0; o0 < 4; ++o0)
for (int o1 = 0; o1 < 4; ++o1) {
int t0 = (o0 & 1) | (o1 & 2), t2 = (o0 & 2) | (o1 & 1),
val = (t2 == 3) ? 2 : (t2 == 0 ? inv2 : 1);
pls(f[x][t0][2], mul(f[lc][o0][1], f[rc][o1][1]));
pls(f[x][0][1], mul(mul(f[lc][o0][1], f[rc][o1][1]), val));
for (int i = 3; i <= ln; ++i)
pls(f[x][t0][i], mul(f[lc][o0][i - 1], f[rc][o1][1]));
for (int j = 3; j <= rn; ++j)
pls(f[x][t0][j], mul(f[lc][o0][1], f[rc][o1][j - 1]));
for (int i = 2; i < ln; ++i)
pls(f[x][o0 & 1][i], mul(mul(f[lc][o0][i], f[rc][o1][1]), val));
for (int j = 2; j < rn; ++j)
pls(f[x][o1 & 2][j], mul(mul(f[lc][o0][1], f[rc][o1][j]), val));
}
init_r(len);
for (int t0 = 0; t0 < 4; ++t0) g[0][t0].resize(lim), g[1][t0].resize(lim);
for (int o0 = 0; o0 < 4; ++o0)
f[lc][o0][0] = f[lc][o0][1] = 0, f[lc][o0].resize(lim), ntt(f[lc][o0], 1);
for (int o1 = 0; o1 < 4; ++o1)
f[rc][o1][0] = f[rc][o1][1] = 0, f[rc][o1].resize(lim), ntt(f[rc][o1], 1);
for (int o0 = 0; o0 < 4; ++o0)
for (int o1 = 0; o1 < 4; ++o1) {
int t0 = (o0 & 1) | (o1 & 2), t2 = (o0 & 2) | (o1 & 1),
val = (t2 == 3) ? 2 : (t2 == 0 ? inv2 : 1);
for (int i = 0; i < lim; ++i)
g[0][t0][i] = mul(f[lc][o0][i], f[rc][o1][i]);
ntt(g[0][t0], -1);
for (int i = 4; i < len; ++i) pls(f[x][t0][i], g[0][t0][i]);
for (int i = 4; i < len; ++i) pls(f[x][t0][i - 1], mul(g[0][t0][i], val));
}
}
int main() {
init_w();
IN(n);
for (int i = 1; i <= n; ++i) IN(a[i]);
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = mul(fac[i - 1], i);
bool flag = false;
for (int l = 1, r; l <= n; l = r + 1) {
if (r = l + a[l] - 1, r > n) {
flag = true;
break;
}
for (int i = l; i <= r; ++i)
if (a[i] != a[l]) flag = true;
b[++m] = a[l];
}
if (flag) return puts("0"), 0;
solve(1, 1, m, 0);
int ans = 0;
for (int i = 1; i <= m; ++i)
for (int o = 0; o < 4; ++o)
pls(ans, mul(f[1][o][i], mul(fac[i], ((m - i) & 1) ? mod - 1 : 1)));
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
string filename = "input";
bool is_p[100000];
vector<int> pref[6][100000];
vector<int> primes;
vector<vector<int> > mat;
int mem[1000];
int go(int row) {
if (row == mat.size()) {
return 1;
}
int tval = 0;
if (row == 2) {
for (int _n(mat.size()), i(2); i < _n; i++) {
tval *= 10;
tval += mat[i][1];
}
if (mem[tval] != -1) return mem[tval];
}
int val = 0;
int cnt_z = 0;
for (int _n(row), i(0); i < _n; i++) {
val = val * 10 + mat[row][i];
if (val == 0) ++cnt_z;
}
int len = 0;
if (val == 0) {
len = mat.size() - row + 1;
} else {
len = mat.size() - cnt_z;
}
const vector<int>& prefs = pref[len][val];
int ret = 0;
for (int _n(prefs.size()), i(0); i < _n; i++) {
int p = prefs[i];
for (int j = mat[row].size() - 1; j >= row; --j, p /= 10) {
mat[row][j] = mat[j][row] = p % 10;
}
ret += go(row + 1);
}
if (row == 2) mem[tval] = ret;
return ret;
}
int main() {
memset(pref, 0, sizeof(pref));
memset(is_p, true, sizeof(is_p));
is_p[0] = is_p[1] = false;
for (int i = 2; i < 100000; ++i) {
if (is_p[i]) {
primes.push_back(i);
for (int j = 2; i * j < 100000; ++j) is_p[i * j] = false;
}
}
for (int _n(primes.size()), i(0); i < _n; i++) {
ostringstream ccout;
ccout << primes[i];
string s = ccout.str();
int p = primes[i];
for (int _n(6), len(s.size() + 1); len < _n; len++)
pref[len][0].push_back(p);
int d0 = 0;
for (int _n(s.size()), j(0); j < _n; j++) {
d0 *= 10;
d0 += (s[j] - '0');
pref[s.size()][d0].push_back(p);
}
}
int T;
scanf("%d", &T);
for (int _n(T), test(0); test < _n; test++) {
int p;
scanf("%d", &p);
mat = vector<vector<int> >(1, vector<int>());
while (p) {
mat[0].push_back(p % 10);
p /= 10;
}
reverse((mat[0]).begin(), (mat[0]).end());
for (int _n(mat[0].size() - 1), i(0); i < _n; i++)
mat.push_back(vector<int>(mat[0].size(), 0));
for (int _n(mat.size()), i(1); i < _n; i++) {
mat[i][0] = mat[0][i];
}
memset(mem, -1, sizeof(mem));
int res = go(1);
cout << res << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111;
const int MO = 1e9 + 7;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
int AD(int& x, int y) {
x += y;
if (x >= MO) x -= MO;
if (x < 0) x += MO;
}
int mul(int x, int y) { return (long long)x * y % MO; }
int fpow(int x, int y = MO - 2) {
if (!y) return 1;
int z = fpow(x, y >> 1);
z = mul(z, z);
if (y & 1) return mul(z, x);
return z;
}
int r, p[4], q[4], e[N][N];
int m, a[N][N][N], t[N];
int n, b[N][N], c[N], d[N];
int main() {
int i, j, k, x, y, z;
cin >> r;
x = 0;
for (i = 0; i < 4; i = i + 1) cin >> p[i], x += p[i];
for (i = 0; i < 4; i = i + 1) p[i] = mul(p[i], fpow(x)), q[i] = fpow(p[i]);
for (i = -r; i <= r; i = i + 1) {
x = 0;
for (j = -r; j <= r; j = j + 1) {
if (i * i + j * j <= r * r) {
e[i + r][j + r] = 1;
if (!x) {
m++;
a[i + r][j + r][m] = 1;
}
x++;
}
}
}
for (j = 0; j <= r + r; j = j + 1) {
for (i = 0; i <= r + r; i = i + 1) {
if (!e[i][j]) continue;
for (k = 0; k <= m; k = k + 1) t[k] = a[i][j][k];
for (z = 0; z < 3; z = z + 1) {
x = i + dx[z], y = j + dy[z];
if (x >= 0 && y >= 0 && e[x][y]) {
for (k = 0; k <= m; k = k + 1) AD(t[k], -mul(p[z], a[x][y][k]));
}
}
AD(t[0], -1);
if (e[i][j + 1]) {
for (k = 0; k <= m; k = k + 1) a[i][j + 1][k] = mul(t[k], q[3]);
} else {
n++;
for (k = 0; k <= m; k = k + 1) b[n][k] = t[k];
}
}
}
for (j = 1; j <= m; j = j + 1) {
for (i = 1; i <= n; i = i + 1)
if (b[i][j] && !c[i]) break;
if (i > n) continue;
x = fpow(b[i][j]);
for (k = 0; k <= m; k = k + 1) b[i][k] = mul(b[i][k], x);
z = i;
c[z] = j;
for (i = 1; i <= n; i = i + 1) {
x = b[i][j];
if (i == z || !x) continue;
for (k = 0; k <= m; k = k + 1) AD(b[i][k], -mul(b[z][k], x));
}
}
d[0] = 1;
for (i = 1; i <= n; i = i + 1) d[c[i]] = MO - b[i][0];
x = 0;
for (k = 0; k <= m; k = k + 1) AD(x, mul(a[r][r][k], d[k]));
cout << x;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 300010;
long long n, a[Maxn], K;
struct node {
long long x, p;
} o, p;
bool operator<(node x, node y) { return x.p < y.p; }
priority_queue<node> q;
long long ans[Maxn];
int main() {
long long i, j, k;
scanf("%I64d%I64d", &n, &K);
for (i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (i = 1; i <= K; i++) {
o.x = i;
o.p = a[i];
q.push(o);
}
long long ret = 0;
for (i = K + 1; i <= K + n; i++) {
if (i <= n) {
o.x = i;
o.p = a[i];
q.push(o);
}
o = q.top();
q.pop();
ret += i * o.p;
ans[o.x] = i;
}
for (i = 1; i <= n; i++) ret -= i * a[i];
printf("%I64d\n", ret);
for (i = 1; i <= n; i++) printf("%I64d ", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long int n, m;
cin >> n;
while (n--) {
long long int x;
cin >> x;
long long int c = 0;
for (long long int i = 3; i <= 180; i++) {
if ((x * i) % 180 == 0 && x <= ((180 * (i - 2)) / i)) {
cout << i << "\n";
c = -1;
break;
}
}
if (x == 179) {
cout << 360 << "\n";
continue;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, maxn = 7000000, p = 993217;
int tree[7777777], ls[7777777], rs[7777777], sz[7777777], rd[7777777],
val[7777777], all, q, tp, x, y, mx;
bool used[7777777];
struct treenode {
int rt1, rt2;
bool bad;
treenode() { rt1 = rt2 = bad = 0; }
} t[444444];
int pw[111111], n, k, a[111111];
int Get(int x) { return ((rand() << 13) + rand()) % x + 1; }
int getnext() {
while (used[all]) all++;
used[all] = 1;
rd[all] = Get(100000000);
return all;
}
void pushup(int node) {
sz[node] = sz[ls[node]] + sz[rs[node]] + 1;
tree[node] = (1ll * tree[ls[node]] * pw[sz[rs[node]] + 1] +
1ll * val[node] * pw[sz[rs[node]]] + tree[rs[node]]) %
mod;
}
int merge(int x, int y) {
if (!x || !y) return x ^ y;
int pos = getnext();
if (rd[x] <= rd[y]) {
ls[pos] = ls[x];
val[pos] = val[x];
rs[pos] = merge(rs[x], y);
} else {
rs[pos] = rs[y];
val[pos] = val[y];
ls[pos] = merge(x, ls[y]);
}
pushup(pos);
return pos;
}
void split(int x, int &rt1, int &rt2, int y) {
if (!x) {
rt1 = rt2 = 0;
return;
}
if (y <= sz[ls[x]]) {
rt2 = getnext();
rs[rt2] = rs[x];
val[rt2] = val[x];
split(ls[x], rt1, ls[rt2], y);
pushup(rt2);
} else {
rt1 = getnext();
ls[rt1] = ls[x];
val[rt1] = val[x];
split(rs[x], rs[rt1], rt2, y - sz[ls[x]] - 1);
pushup(rt1);
}
}
void pup(treenode &a, treenode b, treenode c) {
if (b.bad || c.bad) {
a.bad = 1;
return;
}
a.rt1 = a.rt2 = a.bad = 0;
int rt, rtt;
if (sz[b.rt2] > sz[c.rt1]) {
rt = rtt = 0;
split(b.rt2, rt, rtt, sz[c.rt1]);
if (tree[rt] != tree[c.rt1]) {
a.bad = 1;
return;
}
a.rt2 = merge(c.rt2, rtt);
a.rt1 = b.rt1;
} else {
rt = rtt = 0;
split(c.rt1, rt, rtt, sz[b.rt2]);
if (tree[rt] != tree[b.rt2]) {
a.bad = 1;
return;
}
a.rt1 = merge(b.rt1, rtt);
a.rt2 = c.rt2;
}
}
void build(int l, int r, int node) {
mx = max(mx, node);
if (l == r) {
if (a[l] < 0) {
t[node].rt1 = getnext();
val[t[node].rt1] = tree[t[node].rt1] = -a[l];
sz[t[node].rt1] = 1;
} else {
t[node].rt2 = getnext();
val[t[node].rt2] = tree[t[node].rt2] = a[l];
sz[t[node].rt2] = 1;
}
return;
}
int mid = (l + r) >> 1;
build(l, mid, node << 1);
build(mid + 1, r, (node << 1) | 1);
pup(t[node], t[node << 1], t[(node << 1) | 1]);
}
void upd(int x, int l, int r, int node, int y) {
if (l == r) {
sz[t[node].rt1] = sz[t[node].rt2] = val[t[node].rt1] = val[t[node].rt2] =
tree[t[node].rt1] = tree[t[node].rt2] = 0;
ls[t[node].rt1] = rs[t[node].rt1] = ls[t[node].rt2] = rs[t[node].rt2] = 0;
t[node].rt1 = t[node].rt2 = t[node].bad = 0;
if (y < 0) {
t[node].rt1 = getnext();
val[t[node].rt1] = tree[t[node].rt1] = -y;
sz[t[node].rt1] = 1;
} else {
t[node].rt2 = getnext();
val[t[node].rt2] = tree[t[node].rt2] = y;
sz[t[node].rt2] = 1;
}
return;
}
int mid = (l + r) >> 1;
if (x > mid)
upd(x, mid + 1, r, (node << 1) | 1, y);
else
upd(x, l, mid, node << 1, y);
pup(t[node], t[node << 1], t[(node << 1) | 1]);
}
treenode query(int beg, int en, int l, int r, int node) {
if (l > en || r < beg) return treenode();
if (l >= beg && r <= en) return t[node];
int mid = (l + r) >> 1;
treenode res;
pup(res, query(beg, en, l, mid, node << 1),
query(beg, en, mid + 1, r, (node << 1) | 1));
return res;
}
void dfs(int x) {
if (!x || used[x]) return;
used[x] = 1;
dfs(ls[x]);
dfs(rs[x]);
}
void refresh() {
memset(used, 0, sizeof(used));
for (int i = 1; i <= mx; i++) {
dfs(t[i].rt1);
dfs(t[i].rt2);
}
for (int i = 1; i <= all; i++) {
if (!used[i]) {
tree[i] = val[i] = ls[i] = rs[i] = rd[i] = sz[i] = 0;
}
}
all = 1;
}
int main() {
scanf("%d%d", &n, &k);
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = 1ll * pw[i - 1] * p % mod;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
all = 1;
build(1, n, 1);
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &tp, &x, &y);
if (tp == 1) {
upd(x, 1, n, 1, y);
} else {
treenode nw = query(x, y, 1, n, 1);
if (nw.bad || nw.rt1 || nw.rt2)
printf("No\n");
else
printf("Yes\n");
}
if (all > maxn) {
refresh();
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200005];
int dp[200005], n, sz[200005];
void dfs(int u, int h) {
if (g[u].size() == 0) {
dp[u] = 1;
sz[u] = 1;
return;
}
if (h == 0)
dp[u] = 0;
else
dp[u] = 1000000007;
for (int i = 0; i < g[u].size(); i++) {
int j = g[u][i];
dfs(j, 1 - h);
sz[u] += sz[j];
if (h == 0)
dp[u] += dp[j];
else
dp[u] = min(dp[u], dp[j]);
}
}
void go(int u, int h) {
if (g[u].size() == 0) {
dp[u] = 1;
return;
}
dp[u] = 0;
int m = 0;
for (int i = 0; i < g[u].size(); i++) {
int j = g[u][i];
go(j, 1 - h);
if (h == 0)
dp[u] = max(dp[u], sz[u] - sz[j] + dp[j]);
else {
dp[u] += dp[j];
m++;
}
}
if (h) dp[u] -= m - 1;
}
int main() {
int T, i, j, k, m;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &j, &k);
g[j].push_back(k);
}
dfs(1, 1);
m = sz[1];
printf("%d ", m - dp[1] + 1);
go(1, 1);
printf("%d\n", m - dp[1] + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010;
int n, m, cnt;
long long ans;
int to[maxn << 1], nxt[maxn << 1], head[maxn << 1], fa[maxn], q[maxn];
long long siz[maxn], f[maxn];
struct node {
long long x, y;
} p[maxn];
inline void add(int a, int b) {
to[cnt] = b, nxt[cnt] = head[a], head[a] = cnt++;
}
bool cmp(const node &a, const node &b) {
return (a.x == b.x) ? (a.y < b.y) : (a.x < b.x);
}
void dfs(int x) {
int i, y;
siz[x] = 1;
for (i = head[x]; i != -1; i = nxt[i])
if (to[i] != fa[x]) y = to[i], fa[y] = x, dfs(y), siz[x] += siz[y];
f[x] = (siz[x] - 1) * siz[x] / 2;
if (siz[x] == 1) return;
m = 0;
for (i = head[x]; i != -1; i = nxt[i])
if (to[i] != fa[x]) {
y = to[i];
f[x] = min(f[x], f[y] + (siz[x] - siz[y]) * (siz[x] - siz[y] - 1) / 2);
ans =
max(ans, n * (n - 1ll) - f[y] - (n - siz[y]) * (n - siz[y] - 1) / 2);
p[++m].x = siz[y],
p[m].y = -((siz[y] * siz[y] + siz[y]) / 2 - n * siz[y] + f[y]);
}
sort(p + 1, p + m + 1, cmp);
int h = 1, t = 0;
q[++t] = 1;
for (i = 2; i <= m; i++) {
while (h < t &&
(p[q[h + 1]].y - p[q[h]].y) >= p[i].x * (p[q[h + 1]].x - p[q[h]].x))
h++;
ans = max(ans, n * (n - 1ll) / 2 - p[i].x * p[q[h]].x + p[i].y + p[q[h]].y);
while (h < t && (p[q[t]].y - p[q[t - 1]].y) * (p[i].x - p[q[t]].x) <
(p[i].y - p[q[t]].y) * (p[q[t]].x - p[q[t - 1]].x))
t--;
q[++t] = i;
}
}
inline int rd() {
int ret = 0, f = 1;
char gc = getchar();
while (gc < '0' || gc > '9') {
if (gc == '-') f = -f;
gc = getchar();
}
while (gc >= '0' && gc <= '9') ret = ret * 10 + gc - '0', gc = getchar();
return ret * f;
}
int main() {
n = rd();
int i, a, b;
memset(head, -1, sizeof(head));
for (i = 1; i < n; i++) a = rd(), b = rd(), add(a, b), add(b, a);
dfs(1);
printf("%lld", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const long long int mod = 1e9 + 7;
const long long int MAX = LLONG_MAX;
const long long int MIN = LLONG_MIN;
const long long int mxsize = 2 * 1e6;
vector<long long int> adj[mxsize];
long long int vis[mxsize] = {0};
void dfs(long long int node) {
vis[node] = 1;
for (long long int i = 0; i < adj[node].size(); i++) {
long long int child = adj[node][i];
if (!vis[child]) {
dfs(child);
}
}
}
long long int power(long long int x, long long int y) {
long long int res = 1;
while (x) {
if (x % 2) {
res = (res * y) % mod;
}
x = x / 2;
y = (y * y) % mod;
}
return res % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long int z = 0, o = 0;
long long int f = 0, k = 0;
long long int n = s.length();
for (long long int i = 0; i < n; i++) {
if (s[i] == '0') {
z++;
f = 1;
} else {
if (f == 1) {
k++;
f = 0;
}
o++;
}
}
if (f == 1) k++;
if (z == 0) {
cout << 0 << "\n";
} else if (o == 0) {
cout << 1 << "\n";
} else {
long long int x = min(2 * 1LL, k);
cout << x << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if ((ax - bx) * (ax - bx) + (ay - by) * (ay - by) ==
(bx - cx) * (bx - cx) + (by - cy) * (by - cy) &&
(ay - by) * 1.0 / (ax - bx) != (by - cy) * 1.0 / (bx - cx))
cout << "yes\n";
else
cout << "no\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float d, l, v1, v2;
scanf("%f%f%f%f", &d, &l, &v1, &v2);
float ans = (l - d) / (v1 + v2);
if (ans < 0) ans = 0;
printf("%.6f", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, degin[1001005];
vector<int> gg[1001005];
vector<int> source, target;
int p[20], g[20], ses, k, u[1001005];
void dfs(int v) {
if (u[v] == ses) return;
u[v] = ses;
for (int to : gg[v]) dfs(to);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y;
gg[x].push_back(y);
++degin[y];
}
for (int i = 1; i <= n; ++i) {
if (degin[i] == 0) source.push_back(i);
if (gg[i].size() == 0) target.push_back(i);
}
k = source.size();
if (k != target.size()) throw;
for (int i = 0; i < k; ++i) {
++ses;
dfs(source[i]);
for (int j = 0; j < k; ++j)
if (u[target[j]] == ses) g[i] |= (1 << j);
}
for (int mask = (1 << k) - 1; --mask;) {
int cur = 0;
for (int i = 0; i < k; ++i)
if ((mask >> i) & 1) cur |= g[i];
if (__builtin_popcount(cur) == __builtin_popcount(mask)) {
cout << "NO" << endl;
exit(0);
}
}
cout << "YES" << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ar[100];
vector<pair<pair<int, int>, pair<int, int> > > v;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int check(long long a, long long b) {
while (b != 1) {
while (a % b == 0) a /= b;
b = gcd(a, b);
}
if (a == 1) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
while (n--) {
long long p, q, b;
cin >> p >> q >> b;
if (p == 0) {
cout << "Finite\n";
continue;
}
long long hcf = gcd(p, q);
p /= hcf;
q /= hcf;
int flg = check(q, b);
if (!flg)
cout << "Infinite\n";
else
cout << "Finite\n";
}
}
| 4 |
#include <bits/stdc++.h>
int n, m, a[100010], b[100010], lpos[100010], rpos[100010];
bool check(long long r) {
lpos[0] = 0;
for (int i = 0; i < m; i++) {
while (lpos[i] < n && a[lpos[i]] < b[i] - r) ++lpos[i];
lpos[i + 1] = lpos[i];
}
rpos[m - 1] = n - 1;
for (int i = m - 1; i >= 0; i--) {
while (rpos[i] >= 0 && a[rpos[i]] > b[i] + r) --rpos[i];
if (i - 1 >= 0) rpos[i - 1] = rpos[i];
}
if (lpos[0] > 0 || rpos[m - 1] < n - 1) return 0;
for (int i = 1; i < m; i++) {
if (lpos[i] > rpos[i - 1] + 1) return 0;
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < m; i++) scanf("%d", b + i);
int left = -1, right = 2000000010, mid;
while (right - left > 1) {
mid = left + (right - left) / 2;
if (check(mid))
right = mid;
else
left = mid;
}
printf("%d", right);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200], b[200];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
map<int, int> mp;
memset(a, 0, sizeof(a));
int cnt = 0;
for (int i = 1; i < m; i++) {
int x;
if (a[b[i]]) {
x = (b[i] + a[b[i]]) % n;
if (x == 0) x = n;
if (x != b[i + 1]) return printf("-1\n"), 0;
} else {
x = (b[i + 1] - b[i] + n) % n;
if (x == 0) x = n;
a[b[i]] = x;
if (mp[x]) return printf("-1\n"), 0;
mp[x]++;
cnt++;
}
}
int x = 1;
for (int i = 1; i <= n; i++) {
if (a[i] == 0) {
while (mp[x]) x++;
a[i] = x;
x++;
}
cout << a[i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
int n, m;
cin >> n >> m;
vector<vector<int>> a(m, vector<int>(n + 1));
for (int i = 0; i < m; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
vector<int> ren(n + 1);
for (int i = 1; i <= n; i++) {
ren[a[0][i]] = i;
}
for (int i = 0; i < m; i++) {
for (int j = 1; j <= n; j++) {
a[i][j] = ren[a[i][j]];
}
}
vector<int> len(n + 1, n);
for (int i = 0; i < m; i++) {
int cur = 1;
for (int j = 1; j <= n; j++) {
if (cur < j) cur++;
while (cur < n && a[i][cur + 1] == a[i][cur] + 1) cur++;
len[a[i][j]] = min(len[a[i][j]], a[i][cur]);
}
}
long long ans = 0;
int now = 1;
while (now <= n) {
int cur = len[now] - now + 1;
ans += (cur + 1LL) * cur / 2LL;
now = len[now] + 1;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, a[105], x, ans, l, r, m, k, s;
inline void up(long long& a, long long b) {
if (a > b) a = b;
}
inline long long sum(long long x) {
long long s = 0;
for (long long j = 1; j <= n; ++j) s += 1ll * (a[j] + x - 1) / x * x - a[j];
return s;
}
int main() {
cin >> n >> k;
for (i = 1; i <= n; ++i) cin >> a[i];
j = n + 1;
for (i = 1; x < 1ll << 40; i = x + 1) {
x = 1ll << 40;
for (j = 1; j <= n; ++j)
if (a[j] > i) up(x, (a[j] - 1) / ((a[j] - 1) / i));
if (sum(x) <= k)
ans = x;
else if (sum(i) <= k) {
l = i;
r = x;
while (l < r) {
m = (l + r + 1) >> 1;
if (sum(m) <= k)
l = m;
else
r = m - 1;
}
ans = l;
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, m, n, sum = 0;
cin >> n;
int s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
cin >> m;
while (m--) {
cin >> x >> y;
sum = s[x - 1] - y;
s[x] += s[x - 1] - y;
s[x - 2] += (s[x - 1] - 1) - sum;
s[x - 1] = 0;
}
for (int i = 0; i < n; i++) {
cout << s[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int c[N], a[N], d[N];
int l[N], r[N];
vector<int> vec[N];
int tot = 0;
int sum(int x) {
int res = 0;
while (x) res += c[x], x -= x & -x;
return res;
}
void add(int x, int d, int n) {
while (x <= n) c[x] += d, x += x & -x;
}
void dfs(int u, int fa) {
l[u] = ++tot;
for (int i = 0; i < vec[u].size(); i++) {
int v = vec[u][i];
if (v == fa) continue;
d[v] = -d[u];
dfs(v, u);
}
r[u] = tot;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
vec[u].push_back(v);
vec[v].push_back(u);
}
d[1] = 1;
dfs(1, 0);
for (int i = 1; i <= m; i++) {
int op, u, val;
scanf("%d %d", &op, &u);
if (op == 1) {
scanf("%d", &val);
if (d[u] > 0) {
add(l[u], val, n);
add(r[u] + 1, -val, n);
} else {
add(l[u], -val, n);
add(r[u] + 1, val, n);
}
} else {
int ans = a[u];
if (d[u] > 0)
ans += sum(l[u]);
else
ans -= sum(l[u]);
printf("%d\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000002;
int n, p[N], q[N];
vector<int> evenC[N];
bool vis[N], vis1[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &p[i]);
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
int node = i;
vector<int> a;
while (!vis[node]) {
vis[node] = true;
a.push_back(node);
node = p[node];
}
if (((int)(a).size()) & 1) {
for (int j = 0; j <= ((int)(a).size()) / 2 - 1; ++j)
q[a[j]] = a[j + ((int)(a).size()) / 2 + 1];
for (int j = 0; j <= ((int)(a).size()) / 2; ++j)
q[a[j + ((int)(a).size()) / 2]] = a[j];
} else {
if (evenC[((int)(a).size())].empty()) {
evenC[((int)(a).size())] = a;
continue;
}
vector<int> &b = evenC[((int)(a).size())];
for (int j = 0; j <= ((int)(a).size()) - 1; ++j) {
q[a[j]] = b[j];
q[b[j]] = a[(j + 1) % ((int)(a).size())];
}
b.clear();
a.clear();
}
}
for (int i = 1; i <= n; ++i)
if (!q[i]) return printf("-1\n"), 0;
for (int i = 1; i <= n; ++i) printf("%d ", q[i]);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400005, S = 200;
struct node {
long long w, pre, spre, sw, sn;
} a[N];
int cnt;
long long getll() {
char c;
long long r = 0;
do c = getchar();
while (c < '0' || c > '9');
do {
r = r * 10 + c - '0';
c = getchar();
} while (c >= '0' && c <= '9');
return r;
}
void add(long long r, long long w) {
a[++cnt].w = w;
while (r && a[r].w < a[cnt].w) r = a[r].pre;
a[cnt].pre = r;
if (r && a[r].sn < S) {
a[cnt].spre = a[r].spre;
a[cnt].sw = a[r].sw + a[cnt].w;
a[cnt].sn = a[r].sn + 1;
} else {
a[cnt].spre = r;
a[cnt].sw = a[cnt].w;
a[cnt].sn = 1;
}
}
int query(long long r, long long x) {
int ret = 0;
while (r && x >= a[r].sw) {
ret += a[r].sn;
x -= a[r].sw;
r = a[r].spre;
}
while (r && x >= a[r].w) {
ret++;
x -= a[r].w;
r = a[r].pre;
}
return ret;
}
int main() {
long long cn, p, q, x, last = 0;
cn = getll();
cnt = 1;
a[1].sn = 1;
while (cn--) {
x = getll();
p = getll();
q = getll();
p ^= last;
q ^= last;
if (x == 1)
add(p, q);
else
printf("%d\n", int(last = query(p, q)));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int V = 2100;
vector<int> vec[V];
int id[V], pre[V], low[V], s[V], stop, cnt, scnt;
void tarjan(int v, int n) {
int t, minc = low[v] = pre[v] = cnt++;
vector<int>::iterator pv;
s[stop++] = v;
for (pv = vec[v].begin(); pv != vec[v].end(); ++pv) {
if (-1 == pre[*pv]) tarjan(*pv, n);
if (low[*pv] < minc) minc = low[*pv];
}
if (minc < low[v]) {
low[v] = minc;
return;
}
do {
id[t = s[--stop]] = scnt;
low[t] = n;
} while (t != v);
++scnt;
}
int main() {
int n, v;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%d", &v);
if (v != 0) vec[i].push_back(j);
}
stop = cnt = scnt = 0;
for (int i = 0; i < n; i++) pre[i] = -1;
for (int i = 0; i < n; ++i) {
if (-1 == pre[i]) tarjan(i, n);
}
if (scnt == 1)
puts("YES");
else
puts("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> a >> b >> n;
for (int i = 0; i < 10; i++) {
if ((10 * a + i) % b == 0) {
cout << a << i;
while (--n) cout << 0;
cout << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
template <class Iter>
void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp = 0; begin != end; ++begin) {
if (sp)
putchar(' ');
else
sp = true;
printf(fmt, *begin);
}
putchar('\n');
}
template <unsigned MOD>
struct ModInt {
static const unsigned static_MOD = MOD;
unsigned x;
void undef() { x = (unsigned)-1; }
bool isnan() const { return x == (unsigned)-1; }
inline int geti() const { return (int)x; }
ModInt() { x = 0; }
ModInt(const ModInt &y) { x = y.x; }
ModInt(int y) {
if (y < 0 || (int)MOD <= y) y %= (int)MOD;
if (y < 0) y += MOD;
x = y;
}
ModInt(unsigned y) {
if (MOD <= y)
x = y % MOD;
else
x = y;
}
ModInt(long long y) {
if (y < 0 || MOD <= y) y %= MOD;
if (y < 0) y += MOD;
x = y;
}
ModInt(unsigned long long y) {
if (MOD <= y)
x = y % MOD;
else
x = y;
}
ModInt &operator+=(const ModInt y) {
if ((x += y.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(const ModInt y) {
if ((x -= y.x) & (1u << 31)) x += MOD;
return *this;
}
ModInt &operator*=(const ModInt y) {
x = (unsigned long long)x * y.x % MOD;
return *this;
}
ModInt &operator/=(const ModInt y) {
x = (unsigned long long)x * y.inv().x % MOD;
return *this;
}
ModInt operator-() const { return (x ? MOD - x : 0); }
ModInt inv() const {
unsigned a = MOD, b = x;
int u = 0, v = 1;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0) u += MOD;
return ModInt(u);
}
ModInt pow(long long y) const {
ModInt b = *this, r = 1;
if (y < 0) {
b = b.inv();
y = -y;
}
for (; y; y >>= 1) {
if (y & 1) r *= b;
b *= b;
}
return r;
}
friend ModInt operator+(ModInt x, const ModInt y) { return x += y; }
friend ModInt operator-(ModInt x, const ModInt y) { return x -= y; }
friend ModInt operator*(ModInt x, const ModInt y) { return x *= y; }
friend ModInt operator/(ModInt x, const ModInt y) { return x *= y.inv(); }
friend bool operator<(const ModInt x, const ModInt y) { return x.x < y.x; }
friend bool operator==(const ModInt x, const ModInt y) { return x.x == y.x; }
friend bool operator!=(const ModInt x, const ModInt y) { return x.x != y.x; }
};
const long long MOD = 1000000007;
const int MAX = 100;
ModInt<MOD> inv[MAX + 1], fact[MAX + 1], fact_inv[MAX + 1];
void init() {
inv[1] = 1;
for (int i = 2; i <= MAX; i++) inv[i] = inv[MOD % i] * (MOD - MOD / i);
fact[0] = fact_inv[0] = 1;
for (int i = 1; i <= MAX; i++) {
fact[i] = fact[i - 1] * i;
fact_inv[i] = fact_inv[i - 1] * inv[i];
}
}
ModInt<MOD> nCk(int n, int k) {
return fact[n] * fact_inv[k] * fact_inv[n - k];
}
int N, P;
int C[55];
ModInt<MOD> dp[55][55][55][55];
void MAIN() {
scanf("%d%d", &N, &P);
for (int i = 0, i_len = (N); i < i_len; ++i) scanf("%d", C + i);
init();
dp[0][0][0][0] = 1;
for (int i = 0, i_len = (N); i < i_len; ++i)
for (int EB = 0, EB_len = (i + 1); EB < EB_len; ++EB)
for (int EW = 0, EW_len = (i + 1 - EB); EW < EW_len; ++EW)
for (int OB = 0, OB_len = (i + 1 - EB - EW); OB < OB_len; ++OB) {
ModInt<MOD> val = dp[i][EB][EW][OB];
if (val.x == 0u) continue;
int OW = i - EB - EW - OB;
if (C[i] != 1) {
for (int ow = 0, ow_len = (OW + 1); ow < ow_len; ++ow) {
int mypath = (ow + 1) & 1;
int nEB = EB + (mypath == 0);
int nOB = OB + (mypath == 1);
dp[i + 1][nEB][EW][nOB] += val * nCk(OW, ow) * (1LL << (i - OW));
}
}
if (C[i] != 0) {
for (int ob = 0, ob_len = (OB + 1); ob < ob_len; ++ob) {
int mypath = (ob + 1) & 1;
int nEW = EW + (mypath == 0);
int nOW = OW + (mypath == 1);
dp[i + 1][EB][nEW][OB] += val * nCk(OB, ob) * (1LL << (i - OB));
}
}
}
ModInt<MOD> ans = 0;
for (int EB = 0, EB_len = (N + 1); EB < EB_len; ++EB)
for (int EW = 0, EW_len = (N + 1 - EB); EW < EW_len; ++EW)
for (int OB = 0, OB_len = (N + 1 - EB - EW); OB < OB_len; ++OB) {
int OW = N - EB - EW - OB;
int parity = (OB + OW) & 1;
if (parity == P) ans += dp[N][EB][EW][OB];
}
printf("%d\n", ans.geti());
}
int main() {
int TC = 1;
for (int tc = 0, tc_len = (TC); tc < tc_len; ++tc) MAIN();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int mpow(int base, long long exp);
void ipgraph(int m);
void DFS(int n);
bool isprime(int n);
int gcd(int a, int b);
void rstgraph(int n);
const int mod = pow(10, 9) + 7;
const int N = 3e5, M = N;
vector<int> g[N];
int vis[N];
int nodes = 0;
void iluzn() {
int l, r, a;
cin >> l >> r >> a;
if (l == r) {
a = a / 2;
cout << (l + a) * 2;
} else {
int x = abs(l - r);
int mn = min(l, r);
int mx = max(l, r);
if (a >= x) {
a -= x;
a = a / 2;
cout << (mx + a) * 2;
} else {
mn += a;
cout << mn * 2;
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1, i;
while (t--) iluzn();
return 0;
}
int mpow(int base, long long exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % mod;
base = ((long long)base * base) % mod;
exp >>= 1;
}
return result;
}
bool isprime(int n) {
if (n < 2) return false;
for (int x = 2; x * x <= n; x++) {
if (n % x == 0) return false;
}
return true;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void ipgraph(int m) {
int u, v;
while (m--) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
}
void DFS(int n) {
++nodes;
vis[n] = 1;
for (vector<int>::iterator i = g[n].begin(); i != g[n].end(); i++) {
if (!vis[*i]) DFS(*i);
}
}
void rstgraph(int n) {
int i;
for (i = 0; i < n + 1; i++) {
g[i].clear();
vis[i] = 0;
}
nodes = 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int t;
cin >> t;
long long int b[10] = {0};
b[2] = 1;
b[3] = 1;
b[5] = 1;
b[7] = 1;
while (t--) {
long long int n;
cin >> n;
string a;
cin >> a;
string d;
d += a;
sort(a.begin(), a.end());
long long int x;
long long int k = 0;
for (int i = 0; i < a.size(); i++) {
x = (int)a[i];
x -= 48;
if (b[x] == 0) {
k = 1;
break;
}
}
if (k == 1) {
cout << 1 << "\n";
cout << x << "\n";
continue;
}
string c;
for (int i = 0; i < a.size(); i++) {
if (a[i] == a[i + 1]) {
k = 1;
c += a[i];
c += a[i];
break;
}
}
if (k == 1) {
cout << 2 << "\n";
cout << c << "\n";
continue;
}
cout << 2 << "\n";
k = 0;
a.clear();
a += d;
for (long long int i = 0; i < a.size(); i++) {
for (long long int j = i + 1; j < a.size(); j++) {
if (a[i] == '2' && a[j] == '7') {
cout << 27 << "\n";
k = 1;
break;
} else if (a[i] == '2' && a[j] == '5') {
cout << 25 << "\n";
k = 1;
break;
} else if (a[i] == '3' && a[j] == '5') {
cout << 35 << "\n";
k = 1;
break;
} else if (a[i] == '5' && a[j] == '7') {
cout << 57 << "\n";
k = 1;
break;
} else if (a[i] == '3' && a[j] == '2') {
cout << 32 << "\n";
k = 1;
break;
} else if (a[i] == '5' && a[j] == '2') {
cout << 52 << "\n";
k = 1;
break;
} else if (a[i] == '7' && a[j] == '5') {
cout << 75 << "\n";
k = 1;
break;
} else if (a[i] == '7' && a[j] == '2') {
cout << 72 << "\n";
k = 1;
break;
} else
;
}
if (k == 1) break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int MAXN = 1e3 + 3;
int n, m, c, t, A[MAXN], f;
int main() {
scanf("%d%d%d", &n, &m, &c);
for (int i = 1; i <= m; i++) {
scanf("%d", &t);
if (t <= c / 2) {
for (int j = 1; j <= n; j++)
if (!A[j] || A[j] > t) {
A[j] = t, f = j;
break;
}
} else {
for (int j = n; j >= 1; j--)
if (!A[j] || A[j] < t) {
A[j] = t, f = j;
break;
}
}
printf("%d\n", f);
fflush(stdout);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2E5 + 10;
const int INF = 0x3f3f3f3f;
int n, m, k;
int cnt[30];
bool dp[N];
char a[N];
void Read_Input() {
scanf("%d%d%d\n", &n, &m, &k);
scanf("%s", a + 1);
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= k; i++) cnt[a[i] - 'A' + 1]++;
}
void Solve() {
int ans = INF;
dp[0] = 1;
for (int i = 1; i <= k; i++) dp[i] = 0;
for (int c = 1; c <= 26; c++)
for (int i = k; i >= cnt[c]; i--) dp[i] |= dp[i - cnt[c]];
for (int i = n; i <= k - m; i++)
if (dp[i]) {
puts("0");
return;
}
for (int x = 1; x <= 26; x++) {
for (int i = k; i >= 1; i--) dp[i] = 0;
for (int c = 1; c <= 26; c++) {
if (c == x) continue;
for (int i = k; i >= cnt[c]; i--) dp[i] |= dp[i - cnt[c]];
}
if (cnt[x] == 0) continue;
for (int i = 0; i <= cnt[x]; i++) {
int j = n - i + cnt[x] + m - k;
if (dp[max(0, n - i)] && dp[max(0, m - j)])
ans = min(ans, min(n, i) * min(m, j));
}
}
printf("%d\n", ans);
}
int main() {
int TC;
scanf("%d\n", &TC);
while (TC--) {
Read_Input();
Solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
int get(int x, int y, int z, int w) {
int mask1 = (x << 0) | (y << 1);
int mask2 = (z << 0) | (w << 1);
return mask1 | mask2;
}
long long fa[2][2][2][2];
long long cnt[2][2];
int main() {
int n;
string a, b;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
int x = a[i] - '0';
int y = b[i] - '0';
for (int z = 0; z < 2; z++) {
for (int w = 0; w < 2; w++) {
fa[z][w][x][y] += cnt[z][w];
}
}
cnt[x][y]++;
}
long long res = 0;
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
for (int z = 0; z < 2; z++) {
for (int w = 0; w < 2; w++) {
if (get(x, y, z, w) == get(y, x, z, w)) continue;
res += fa[x][z][y][w];
}
}
}
}
cout << res << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
long long int n = s.size(), i, j;
vector<long long int> a(n, 0), res;
a[0] = s[0] - '0';
for (i = 1; i < n; i++) {
if (s[i] == '1') a[i] = (s[i] - '0') + a[i - 1];
}
for (i = 1; i < n; i++) {
if (!a[i] and a[i - 1]) {
res.push_back(a[i - 1]);
}
}
if (a[n - 1]) res.push_back(a[n - 1]);
sort(res.begin(), res.end(), greater<long long int>());
long long int score = 0;
for (i = 0; i < res.size(); i += 2) {
score += res[i];
}
cout << score << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> v;
long long t, i, r;
for (i = 0; i < 100000; i++) {
r = ((i * (i + 1)) / 2);
v.push_back(r);
}
vector<long long>::iterator it, itr;
cin >> t;
for (i = 0; i < t; i++) {
long long a, b, x;
cin >> a >> b;
long long d = abs(a - b);
it = lower_bound(v.begin(), v.end(), d);
for (itr = it; itr != v.end(); itr++) {
if (abs(*itr - d) % 2 == 0) {
x = itr - v.begin();
cout << x << endl;
break;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int MAXN = 505;
const int MAXM = 1000005;
int n, m, c[MAXM];
vector<int> v[MAXN];
int a[MAXN];
long long dp[MAXN][MAXN];
long long calc(int L, int R) {
if (R <= L) return 1;
if (dp[L][R] != -1) return dp[L][R];
int j = L;
long long ret = 0;
for (int i = L; i <= R; i++) {
if (a[i] < a[j]) j = i;
ret = (ret + calc(L, j - 1) * calc(j + 1, i) % MOD * calc(i + 1, R)) % MOD;
}
return dp[L][R] = ret;
}
long long solve(int L, int R) {
if (R < L) return 1;
long long ret = 1;
int k = 0;
for (int i = L; i <= R;) {
for (int j = 0; j < (int)v[c[i]].size(); j++) {
if (j > 0) ret = ret * solve(v[c[i]][j - 1] + 1, v[c[i]][j] - 1) % MOD;
}
a[k++] = c[i];
i = v[c[i]].back() + 1;
}
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) dp[i][j] = -1;
ret = ret * calc(0, k - 1) % MOD;
return ret;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d", &c[i]);
c[i]--;
v[c[i]].push_back(i);
}
set<int> s;
s.insert(-1);
s.insert(m);
long long res = 1;
for (int i = 0; i < n; i++) {
int L = v[i].front(), R = v[i].back();
int d = *s.lower_bound(L);
if (d <= R) {
printf("0\n");
return 0;
}
for (int x : v[i]) s.insert(x);
}
printf("%I64d\n", solve(0, m - 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, x, y;
string A, B;
cin >> A >> B;
for (x = 0; A[x] == B[x];) x++;
for (y = B.size(); y >= 0 && A[y + 1] == B[y];) y--;
printf("%d\n", x > y ? x - y : 0);
for (i = y + 1; i <= x; i++) cout << i + 1 << " ";
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int next(long long int v) {
long long int t = v | (v - 1);
return (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctz(v) + 1));
}
std::vector<long long int> filter(std::vector<long long int>& v,
long long int mask) {
std::vector<long long int> res;
while (mask) {
res.push_back(v[__builtin_ctz(mask)]);
mask &= mask - 1;
}
return res;
}
std::set<std::vector<long long int>> get_subsets(std::vector<long long int> arr,
long long int k) {
std::set<std::vector<long long int>> second;
long long int max = (1 << arr.size());
for (long long int v = (1 << k) - 1; v < max; v = next(v)) {
second.insert(filter(arr, v));
}
return second;
}
long long compute_hash(string second) {
const int p = 31;
const int m = 1e9 + 9;
long long hash_value = 0;
long long p_pow = 1;
for (char c : second) {
hash_value = (hash_value + (c - 'a' + 1) * p_pow) % m;
p_pow = (p_pow * p) % m;
}
return hash_value;
}
map<long long int, long long int> has;
signed main() {
std::ios::sync_with_stdio(false);
long long int t;
cin >> t;
while (t--) {
long long int l1, r1, l2, r2;
cin >> l1 >> r1 >> l2 >> r2;
vector<long long int> v, v2;
v.push_back(l1);
v.push_back(r1);
v2.push_back(l2);
v2.push_back(r2);
bool poss = false;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (v[i] != v2[j]) {
cout << v[i] << " " << v2[j] << "\n";
poss = true;
break;
}
}
if (poss) break;
}
if (poss) continue;
cout << l1 << " " << l2 + 1 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 132674;
int n;
vector<int> L, D, R, U;
vector<int> Left, Down;
bool _check(int x, int y) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (L[i] <= x && x <= R[i] && D[i] <= y && y <= U[i]) cnt++;
}
return cnt >= n - 1;
}
int main() {
cin >> n;
L.resize(n);
D.resize(n);
R.resize(n);
U.resize(n);
for (int i = 0; i < n; i++) {
cin >> L[i] >> D[i] >> R[i] >> U[i];
}
Left = L, Down = D;
nth_element(Left.begin(), Left.begin() + 1, Left.end(), greater<int>());
nth_element(Down.begin(), Down.begin() + 1, Down.end(), greater<int>());
pair<int, int> p[4];
p[0] = make_pair(Left[0], Down[0]);
p[1] = make_pair(Left[0], Down[1]);
p[2] = make_pair(Left[1], Down[0]);
p[3] = make_pair(Left[1], Down[1]);
for (int i = 0; i < 4; i++)
if (_check(p[i].first, p[i].second)) {
cout << p[i].first << ' ' << p[i].second;
goto End;
}
cout << "Can't find";
End:
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool sieve[400005];
vector<int> prime;
void fill(int N) {
for (int a = 2; a <= N; a++) {
if (!sieve[a]) {
prime.push_back(a);
for (int b = a * 2; b <= N; b += a) {
sieve[b] = 1;
}
}
}
}
int c1 = 0, c2 = 0;
vector<int> hasil;
bool masukan(int n) {
int divi2 = min(n / 2, c2);
c2 -= divi2;
n -= (divi2 * 2);
int divi1 = min(n, c1);
c1 -= divi1;
n -= divi1;
if (n > 0) {
c1 += divi1;
c2 += divi2;
return 0;
} else {
for (int z = 0; z < divi2; z++) {
hasil.push_back(2);
}
for (int z = 0; z < divi1; z++) {
hasil.push_back(1);
}
return 1;
}
}
int main() {
fill(400000);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int a = 0; a < n; a++) {
int inp;
cin >> inp;
if (inp == 1)
c1++;
else
c2++;
}
int suma = 0;
for (int z = 0; z < prime.size(); z++) {
int tmp = prime[z];
int tr = tmp - suma;
if (!masukan(tr)) break;
suma = prime[z];
}
while (c1 > 0) {
hasil.push_back(1);
c1--;
}
while (c2 > 0) {
hasil.push_back(2);
c2--;
}
for (int z = 0; z < hasil.size(); z++) {
if (z > 0) cout << " ";
cout << hasil[z];
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
getline(cin, s1);
getline(cin, s2);
int i;
for (i = 0; i < s1.size(); i++) {
if (s1[i] == s2[i] || (s1[i] == (char)((int)s2[i] + 32)) ||
(s1[i] == (char)((int)s2[i] - 32))) {
continue;
} else
break;
}
if (i == s1.size())
cout << 0;
else {
if ((int)s1[i] < 97) s1[i] = (char)((int)s1[i] + 32);
if ((int)s2[i] < 97) s2[i] = (char)((int)s2[i] + 32);
if ((int)s1[i] > (int)s2[i])
cout << 1;
else
cout << -1;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long p, l, r, k;
struct Matrix {
long long d[2][2];
Matrix() { d[0][1] = d[1][0] = d[0][0] = d[1][1] = 0; }
};
Matrix operator*(const Matrix& a, const Matrix& b) {
Matrix ans;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
ans.d[i][j] = (ans.d[i][j] + a.d[i][k] * b.d[k][j]) % p;
return ans;
}
Matrix pow(Matrix base, long long exp) {
Matrix ans, mul = base;
ans.d[0][0] = ans.d[1][1] = 1;
while (exp) {
if (exp % 2) ans = ans * mul;
mul = mul * mul;
exp /= 2;
}
return ans;
}
long long fib(long long i) {
Matrix m;
m.d[0][0] = m.d[0][1] = m.d[1][0] = 1;
return pow(m, i).d[1][0];
}
void proc(long long pos, long long& ans) {
long long ub = r / pos, lb = l / pos;
if (l % pos) lb++;
if (ub - lb + 1 >= k) ans = max(ans, pos);
}
int main() {
cin >> p >> l >> r >> k;
long long ans = 0;
for (long long i = 1; i * i <= r; i++) {
proc(i, ans);
proc(r / i, ans);
}
for (long long i = 1; i * i <= l; i++)
if (l % i)
proc(l / (i - 1), ans);
else
proc(l / i, ans);
cout << fib(ans) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, mx = -1;
string s[1001];
int main(int argc, char** argv) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < 7; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == '1') sum++;
}
mx = max(mx, sum);
}
cout << mx;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INFLL = 1e18 + 1;
const int MAX = 200001;
const long long MOD = 1000000007;
long long inq(long long k, long long q) {
if (q == 0) return 1;
long long l = inq(k, q / 2);
if (q % 2 == 0)
return l * l % MOD;
else
return (l * l) % MOD * k % MOD;
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long cubr(long long a) {
long long l = -1, r = 1e6 + 2;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (mid * mid * mid > a)
r = mid;
else
l = mid;
}
return l;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long possible(long long q) {
if (q == INF) return -1;
return q;
}
bool correct(int x, int xx) {
if (x < 0) return 0;
if (x >= xx) return 0;
return 1;
}
long long dsumm(long long x, long long k) {
long long y = 1;
long long z = 0;
for (int i = 0; y < 1e18; i++) {
z += x / y % k;
y *= k;
}
return z;
}
long long dcount(long long x) {
long long y = 1;
long long z = 0;
int c[100];
for (int i = 0; i < 10; i++) c[i] = 0;
for (int i = 0; x > 0; i++) {
if (c[x / y % 10] == 0) z++;
c[x / y % 10] = 1;
x /= 10;
}
return z;
}
long long lg10(long long x) {
if (x == 0) return 0;
return lg10(x / 10) + 1;
}
long long n, m, k;
struct three {
int x, y, z;
};
long long t[200000];
vector<int> res(11);
vector<three> p;
vector<three> sollutions[2048];
void upd(int a, int b, int c, int x) {
if (a >= x || b >= x || c >= x) return;
res[a] ^= 1;
res[b] ^= 1;
res[c] ^= 1;
p.push_back({a, b, c});
return;
}
void perebor(int x) {
for (int i = 0; i < (1 << 10); i++) sollutions[i].resize(0);
for (int i = 0; i < (1 << 20); i++) {
for (int j = 0; j < x; j++) res[j] = 0;
p.resize(0);
if ((i & (1 << 0))) upd(0, 1, 2, x);
if ((i & (1 << 1))) upd(1, 2, 3, x);
if ((i & (1 << 2))) upd(2, 3, 4, x);
if ((i & (1 << 3))) upd(3, 4, 5, x);
if ((i & (1 << 4))) upd(4, 5, 6, x);
if ((i & (1 << 5))) upd(5, 6, 7, x);
if ((i & (1 << 6))) upd(6, 7, 8, x);
if ((i & (1 << 7))) upd(7, 8, 9, x);
if ((i & (1 << 8))) upd(0, 2, 4, x);
if ((i & (1 << 9))) upd(1, 3, 5, x);
if ((i & (1 << 10))) upd(2, 4, 6, x);
if ((i & (1 << 11))) upd(3, 5, 7, x);
if ((i & (1 << 12))) upd(4, 6, 8, x);
if ((i & (1 << 13))) upd(5, 7, 9, x);
if ((i & (1 << 14))) upd(0, 3, 6, x);
if ((i & (1 << 15))) upd(1, 4, 7, x);
if ((i & (1 << 16))) upd(2, 5, 8, x);
if ((i & (1 << 17))) upd(3, 6, 9, x);
if ((i & (1 << 18))) upd(0, 4, 8, x);
if ((i & (1 << 19))) upd(1, 5, 9, x);
long long gen = 0;
for (int j = 0; j < x; j++) gen = gen * 2 + res[j];
if (p.size() < sollutions[gen].size() || sollutions[gen].size() == 0)
sollutions[gen] = p;
}
}
vector<int> ruines(11);
vector<three> ans;
vector<three> pre_ans;
void upd(int a, int b, int c) {
ruines[a] ^= 1;
ruines[b] ^= 1;
ruines[c] ^= 1;
pre_ans.push_back({a, b, c});
}
void sauce(int i) {
if (i == 1) upd(8, 9, 10);
if (i == 2) upd(7, 8, 9);
if (i == 3) upd(6, 7, 8);
if (i == 4) upd(5, 6, 7);
if (i == 5) upd(4, 5, 6);
if (i == 6) upd(3, 4, 5);
if (i == 7) upd(6, 8, 10);
if (i == 8) upd(5, 7, 9);
if (i == 9) upd(4, 6, 8);
if (i == 10) upd(3, 5, 7);
if (i == 11) upd(2, 4, 6);
if (i == 12) upd(1, 3, 5);
if (i == 13) upd(4, 7, 10);
if (i == 14) upd(3, 6, 9);
if (i == 15) upd(2, 5, 8);
if (i == 16) upd(1, 4, 7);
if (i == 17) upd(0, 3, 6);
if (i == 18) upd(2, 6, 10);
if (i == 19) upd(1, 5, 9);
if (i == 20) upd(0, 4, 8);
if (i == 21) upd(0, 5, 10);
}
void another(int pos) {
for (int i = 0; i < 22; i++) {
for (int j = 0; j < 22; j++) {
for (int i2 = 0; i2 < 11; i2++) ruines[i2] = 0;
pre_ans.resize(0);
sauce(i);
sauce(j);
if (t[pos] == ruines[5] && t[pos + 1] == ruines[6] &&
t[pos + 2] == ruines[7] && t[pos + 3] == ruines[8] &&
t[pos + 4] == ruines[9] && t[pos + 5] == ruines[10]) {
t[pos - 1] ^= ruines[4];
t[pos - 2] ^= ruines[3];
t[pos - 3] ^= ruines[2];
t[pos - 4] ^= ruines[1];
t[pos - 5] ^= ruines[0];
t[pos + 1] ^= ruines[6];
t[pos + 2] ^= ruines[7];
t[pos + 3] ^= ruines[8];
t[pos + 4] ^= ruines[9];
t[pos + 5] ^= ruines[10];
t[pos] ^= ruines[5];
for (int i2 = 0; i2 < pre_ans.size(); i2++) {
three F = pre_ans[i2];
F.x += pos - 4;
F.y += pos - 4;
F.z += pos - 4;
ans.push_back(F);
}
return;
}
}
}
}
int main() {
cin >> n;
k = n;
for (int(i) = 0; (i) != (n); i++) cin >> t[i];
if (n <= 10) {
perebor(n);
long long gen = 0;
for (int i = 0; i < n; i++) gen = gen * 2 + t[i];
if (gen != 0 && sollutions[gen].size() == 0) {
cout << "NO";
return 0;
} else {
cout << "YES\n";
cout << sollutions[gen].size() << endl;
for (int i = 0; i < sollutions[gen].size(); i++) {
cout << 1 + sollutions[gen][i].x << " " << 1 + sollutions[gen][i].y
<< " " << 1 + sollutions[gen][i].z << "\n";
}
return 0;
}
}
k = n - 6;
while (k >= 5) {
another(k);
k -= 6;
}
perebor(10);
long long gen = 0;
for (int i = 0; i < 10; i++) gen = gen * 2 + t[i];
for (int i = 0; i < sollutions[gen].size(); i++) {
three F = sollutions[gen][i];
F.x++;
F.y++;
F.z++;
ans.push_back(F);
}
cout << "YES\n";
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].x << " " << ans[i].y << " " << ans[i].z << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
vector<int> h[150010], t[150010], s[150010];
void cal1(int A, int B, int C, int D) {
int res = 0;
for (int i = 1; i <= n; i++) {
int sum1 = 0, sum2 = 0;
for (int j = 1; j <= m; j += 2) {
if (i & 1) {
sum1 += (s[i][j] != A) + (j < m && s[i][j + 1] != B);
sum2 += (s[i][j] != B) + (j < m && s[i][j + 1] != A);
} else {
sum1 += (s[i][j] != C) + (j < m && s[i][j + 1] != D);
sum2 += (s[i][j] != D) + (j < m && s[i][j + 1] != C);
}
}
if (sum1 < sum2) {
for (int j = 1; j <= m; j += 2) {
if (i & 1)
t[i][j] = A, t[i][j + 1] = B;
else
t[i][j] = C, t[i][j + 1] = D;
}
res += sum1;
} else {
for (int j = 1; j <= m; j += 2) {
if (i & 1)
t[i][j] = B, t[i][j + 1] = A;
else
t[i][j] = D, t[i][j + 1] = C;
}
res += sum2;
}
}
if (res < ans) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) h[i][j] = t[i][j];
ans = res;
}
}
void cal2(int A, int B, int C, int D) {
int res = 0;
for (int i = 1; i <= m; i++) {
int sum1 = 0, sum2 = 0;
for (int j = 1; j <= n; j += 2) {
if (i & 1) {
sum1 += (s[j][i] != A) + (j < n && s[j + 1][i] != B);
sum2 += (s[j][i] != B) + (j < n && s[j + 1][i] != A);
} else {
sum1 += (s[j][i] != C) + (j < n && s[j + 1][i] != D);
sum2 += (s[j][i] != D) + (j < n && s[j + 1][i] != C);
}
}
if (sum1 < sum2) {
for (int j = 1; j <= n; j += 2) {
if (i & 1)
t[j][i] = A, t[j + 1][i] = B;
else
t[j][i] = C, t[j + 1][i] = D;
}
res += sum1;
} else {
for (int j = 1; j <= n; j += 2) {
if (i & 1)
t[j][i] = B, t[j + 1][i] = A;
else
t[j][i] = D, t[j + 1][i] = C;
}
res += sum2;
}
}
if (res < ans) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) h[i][j] = t[i][j];
ans = res;
}
}
int get(char ch) {
if (ch == 'A') return 0;
if (ch == 'G') return 1;
if (ch == 'T') return 2;
return 3;
}
int C(int x) {
if (x == 0) return 'A';
if (x == 1) return 'G';
if (x == 2) return 'T';
return 'C';
}
int main() {
char ch;
int a, b;
scanf("%d%d", &n, &m);
ans = n * m;
for (int i = 0; i <= n + 5; i++)
for (int j = 0; j <= m + 5; j++)
h[i].push_back(0), t[i].push_back(0), s[i].push_back(0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf(" %c", &ch), s[i][j] = get(ch);
for (int i = 0; i <= 3; i++)
for (int j = 0; j <= 3; j++) {
if (i == j) continue;
for (a = 0; a <= 3; a++)
if (i != a && j != a) break;
for (b = a + 1; b <= 3; b++)
if (i != b && j != b) break;
cal1(i, j, a, b);
cal1(i, j, b, a);
cal2(i, j, a, b);
cal2(i, j, b, a);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", C(h[i][j]));
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
int n, m, k, q;
map<string, int> names;
int eu[1500], ev[1500];
struct group {
set<int> people;
set<int> keys;
set<int> rooms;
friend bool operator<(const group &a, const group &b) {
if (a.people != b.people) return a.people < b.people;
if (a.rooms != b.rooms) return a.rooms < b.rooms;
return a.keys < b.keys;
}
friend bool operator==(const group &a, const group &b) {
return a.people == b.people && a.keys == b.keys && a.rooms == b.rooms;
}
void reset() {
people.clear();
keys.clear();
rooms.clear();
}
bool haskey(int x) { return keys.find(x) != keys.end(); }
};
int getname(char *s) {
if (names.find(string(s)) == names.end()) {
names[s] = q++;
}
return names[s];
}
group g[1500];
char s[1000];
int wh[1500];
bool dead[1500];
vector<group> calc() {
vector<group> res;
for (int i = 0; i < n; i++) g[i].reset();
for (int i = 0; i < k; i++) {
int room, cnt;
scanf("%s%d%d", s, &room, &cnt);
room--;
g[room].people.insert(getname(s));
for (int j = 0; j < cnt; j++) {
int x;
scanf("%d", &x);
x--;
g[room].keys.insert(x);
}
}
for (int i = 0; i < n; i++) {
wh[i] = i;
g[i].rooms.insert(i);
}
memset(dead, false, sizeof(dead));
bool ok = true;
while (ok) {
ok = false;
for (int i = 0; i < m; i++)
if (wh[eu[i]] != wh[ev[i]]) {
if (g[wh[eu[i]]].haskey(i) || g[wh[ev[i]]].haskey(i)) {
ok = true;
int g1 = wh[ev[i]];
int g2 = wh[eu[i]];
for (int j = 0; j < n; j++)
if (wh[j] == g2) wh[j] = g1;
dead[g2] = true;
g[g1].keys.insert(g[g2].keys.begin(), g[g2].keys.end());
g[g1].people.insert(g[g2].people.begin(), g[g2].people.end());
g[g1].rooms.insert(g[g2].rooms.begin(), g[g2].rooms.end());
}
}
}
for (int i = 0; i < n; i++)
if (!dead[i]) res.push_back(g[i]);
sort(res.begin(), res.end());
return res;
}
void solve() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d%d", &eu[i], &ev[i]);
eu[i]--;
ev[i]--;
}
vector<group> s1 = calc();
vector<group> s2 = calc();
printf("%s", s1 == s2 ? "YES" : "NO");
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
inline void read(int& r) {
register char c;
r = 0;
do c = getchar();
while (c < '0' || c > '9');
do r = r * 10 + c - '0', c = getchar();
while (c >= '0' && c <= '9');
}
std::pair<int, int> a[100001];
int dp[2][777], l;
int main() {
int n, m, h, r, x, y, ans = 0;
read(n), read(m);
h = (n < sqrt(m * 6) ? n : sqrt(m * 6)), r = n - h;
while (m--) {
read(x), read(y);
if (x <= r)
ans += 3;
else
a[l++] = std::pair<int, int>(y, x);
}
bool cur = true, nxt = false;
int cnt, tmp, p = 0, i, j;
std::sort(a, a + l);
dp[0][0] = dp[1][0] = 1048476;
for (i = 1; i < h; i++) dp[0][i] = 1048576;
for (i = 1; i <= n; i++) {
cur ^= 1, nxt ^= 1, cnt = 0;
tmp = dp[cur][h] + h * (h + 1) / 2 + 2;
for (j = 1; j <= h; j++) {
dp[nxt][j] = (dp[cur][j - 1] < tmp ? dp[cur][j - 1] : tmp) + cnt;
dp[nxt][j] = (dp[nxt][j - 1] < dp[nxt][j] ? dp[nxt][j - 1] : dp[nxt][j]);
if (a[p] == std::pair<int, int>(i, r + j)) p++, cnt += 3;
tmp -= h - j + 1;
}
dp[nxt][h] =
(dp[nxt][h] < dp[cur][h] + cnt ? dp[nxt][h] : dp[cur][h] + cnt);
}
printf("%d\n", dp[nxt][h] + ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <ll mod>
struct ModInt {
ll v;
ll mod_pow(ll x, ll n) const {
return (!n) ? 1 : (mod_pow((x * x) % mod, n / 2) * ((n & 1) ? x : 1)) % mod;
}
ModInt(ll a = 0) : v(a >= mod ? a % mod : a) {}
ModInt operator+(const ModInt& b) const {
return (v + b.v >= mod ? ModInt(v + b.v - mod) : ModInt(v + b.v));
}
ModInt operator-() const { return ModInt(-v); }
ModInt operator-(const ModInt& b) const {
return (v - b.v < 0 ? ModInt(v - b.v + mod) : ModInt(v - b.v));
}
ModInt operator*(const ModInt& b) const { return (v * b.v) % mod; }
ModInt operator/(const ModInt& b) const {
return (v * mod_pow(b.v, mod - 2)) % mod;
}
bool operator==(const ModInt& b) const { return v == b.v; }
ModInt& operator+=(const ModInt& b) {
v += b.v;
if (v >= mod) v -= mod;
return *this;
}
ModInt& operator-=(const ModInt& b) {
v -= b.v;
if (v < 0) v += mod;
return *this;
}
ModInt& operator*=(const ModInt& b) {
(v *= b.v) %= mod;
return *this;
}
ModInt& operator/=(const ModInt& b) {
(v *= mod_pow(b, mod - 2)) %= mod;
return *this;
}
ModInt pow(ll x) { return ModInt(mod_pow(v, x)); }
operator int() const { return int(v); }
operator long long int() const { return v; }
};
template <ll mod>
ostream& operator<<(ostream& out, ModInt<mod> a) {
return out << a.v;
}
template <ll mod>
istream& operator>>(istream& in, ModInt<mod> a) {
in >> a.v;
return in;
}
template <typename NumType>
struct Combination {
int LIMIT;
vector<NumType> fact_, finv_;
Combination() {}
Combination(int LIMIT_) : LIMIT(LIMIT_), fact_(LIMIT + 1), finv_(LIMIT + 1) {
fact_[0] = finv_[LIMIT] = NumType(1);
for (int i = 1; i <= LIMIT; i++) {
fact_[i] = fact_[i - 1] * NumType(i);
}
finv_[LIMIT] /= fact_[LIMIT];
for (int i = LIMIT - 1; i >= 0; i--) {
finv_[i] = finv_[i + 1] * NumType(i + 1);
}
}
inline NumType fact(int k) const { return fact_[k]; }
inline NumType finv(int k) const { return finv_[k]; }
NumType P(int n, int r) const {
if (r < 0 or n < r) return NumType(0);
return fact_[n] * finv_[n - r];
}
NumType C(int n, int r) const {
if (r < 0 or n < r) return NumType(0);
return fact_[n] * finv_[n - r] * finv_[r];
}
NumType H(int n, int r) const {
if (n < 0 or r < 0) return NumType(0);
return r == 0 ? NumType(0) : C(n + r - 1, r);
}
NumType B(int n, int k) const {
if (n == 0) return NumType(1);
k = min(n, k);
NumType ret(0);
vector<NumType> pref(k + 1);
pref[0] = NumType(1);
for (int i = 1; i <= k; i++) {
if (i & 1)
pref[i] = pref[i - 1] - finv_[i];
else
pref[i] = pref[i - 1] + finv_[i];
}
for (int i = 1; i <= k; i++) {
ret += NumType(i).pow(n) * finv_[i] * pref[k - i];
}
return ret;
}
NumType S(int n, int k) const {
if (n < k) return NumType(0);
NumType ans(0);
for (int i = 0; i <= k; i++) {
NumType val = C(k, i) * NumType(i).pow(n);
if ((k - i) % 2)
ans -= val;
else
ans += val;
}
return ans * finv_[k];
}
};
ll mod_pow(ll n, ll k, ll mod) {
ll res = 1;
for (; k > 0; k >>= 1) {
if (k & 1) (res *= n) %= mod;
(n *= n) %= mod;
}
return res;
}
template <typename NumType>
vector<NumType> get_inv_table(int N, int P) {
vector<NumType> res;
for (int i = 0; i < N; i++) {
res.emplace_back(NumType(mod_pow(i, P - 2, P)));
}
return res;
}
template <typename NumType>
struct SpecificLagrangePolynomial {
Combination<NumType> comb;
vector<NumType> x, y, inv_table;
bool use_inv_table;
SpecificLagrangePolynomial() : comb(), x(), y() {}
SpecificLagrangePolynomial(vector<NumType> x_, vector<NumType> y_, int P)
: comb(P - 1), x(x_), y(y_), use_inv_table(P > 0) {
const int LIMIT = 2000010;
if (P < LIMIT) use_inv_table = true;
if (use_inv_table) {
inv_table = get_inv_table<NumType>(P, P);
}
}
NumType interpolate(NumType p) {
NumType pre(1);
int N = y.size(), pv = int(p);
if (pv < N) return y[pv];
for (int i = 0; i < N; i++) {
pre *= NumType(pv - i);
}
NumType res(0);
for (int i = 0; i < N; i++) {
NumType numer(0), denom(1);
if (use_inv_table)
numer = pre * inv_table[pv - i];
else
numer = pre / NumType(pv - i);
denom *= comb.finv(N - 1 - i) * comb.finv(i);
if ((N - 1 - i) % 2)
res -= numer * denom * y[i];
else
res += numer * denom * y[i];
}
return res;
}
};
void ECR065_E() {
const int MOD = 1000003;
using mint = ModInt<MOD>;
const int DEG = 11;
auto eval_expr = [&](vector<mint>& expr, mint x) {
mint base(1), res(0);
for (int i = 0; i < DEG; i++) {
res += expr[i] * base;
base *= x;
}
return res;
};
vector<mint> x, y, expr;
vector<int> raw_expr = {1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0};
for (int i = 0; i < DEG; i++) {
expr.emplace_back(mint(raw_expr[i]));
}
for (int i = 0; i < DEG; i++) {
x.push_back(mint(i));
cout << "? " << i << endl;
int res;
cin >> res;
y.push_back(mint(res));
}
SpecificLagrangePolynomial<mint> lp(x, y, MOD);
for (int i = 0; i < MOD; i++) {
if (lp.interpolate(i) == mint(0)) {
cout << "! " << i << endl;
return;
}
}
cout << "! " << -1 << endl;
}
int main() {
ECR065_E();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int cut[105], grow[105], netcut[105];
void solve(long long int caseno) {
long long int i, j, n, curx, mm = -1;
cin >> n >> curx;
for (i = 0; i < n; i++) {
cin >> cut[i] >> grow[i];
mm = max(mm, cut[i]);
netcut[i] = cut[i] - grow[i];
}
sort(netcut, netcut + n, greater<long long int>());
if (netcut[0] > 0) {
if (curx <= mm) {
cout << 1 << '\n';
} else {
long long int ans = 0;
long long int diff = curx - mm;
ans += diff / netcut[0];
curx -= ans * netcut[0];
if (curx > mm) {
ans++;
curx -= netcut[0];
}
ans++;
cout << ans << '\n';
}
} else {
if (curx <= mm) {
cout << 1 << '\n';
} else {
cout << -1 << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
for (long long int i = 1; i <= t; i++) {
solve(i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
const long long int N = 3e5 + 5;
long long int pow(long long int x, long long int y, long long int m) {
long long int res = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) {
res *= x;
res %= m;
}
y = y / 2;
x = (x * x) % m;
}
return res;
}
long long int fact[N], fact1[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int i, j, tc;
tc = 1;
fact[0] = 1;
for (i = 1; i < N; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= mod;
}
while (tc--) {
long long int n, k;
cin >> n >> k;
vector<pair<long long int, long long int> > v;
vector<long long int> st;
for (i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
v.push_back({a, 1});
v.push_back({b + 1, -1});
}
sort(v.begin(), v.end());
for (i = 0; i < N; i++) {
if (i >= (k - 1)) {
long long int num = fact[i];
long long int denom = pow(fact[k - 1], mod - 2, mod);
long long int denom1 = pow(fact[i - k + 1], mod - 2, mod);
num *= denom;
num %= mod;
num *= denom1;
num %= mod;
fact1[i] = num;
}
}
if (k == 1) {
cout << n << "\n";
return 0;
}
long long int ans = 0;
long long int cnt = 0;
for (i = 0; i < v.size(); i++) {
long long int sec = v[i].second;
if (sec == -1)
cnt--;
else
cnt++;
if (cnt == k && sec == 1) {
ans += 1;
ans %= mod;
} else if (cnt > k && sec == 1) {
ans += (fact1[cnt - 1]);
ans %= mod;
}
}
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x, a, b;
cin >> n >> x >> a >> b;
long long mn = min(a, b);
long long mx = max(a, b);
while (x--) {
if (mn != 1)
mn--;
else if (mx != n)
mx++;
}
cout << (mx - mn) << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
int N, K;
vector<vector<LL>> A;
LL dp[3001][3001];
LL ans;
void proc(int l, int r) {
if (l + 1 == r) {
LL tmp = 0;
for (int i = 0; i < (A[l].size()); i++)
tmp = max(tmp, dp[1][K - i] + A[l][i]);
ans = max(ans, tmp);
return;
}
int m = (l + r) / 2;
int z = r - l;
for (int i = l; i < m; i++) {
int k = A[i].size() - 1;
LL a = A[i].back();
for (int j = 0; j < k; j++) dp[z - 1][j] = dp[z][j];
for (int j = k; j <= K; j++) dp[z - 1][j] = max(dp[z][j - k] + a, dp[z][j]);
z--;
}
proc(m, r);
z = r - l;
for (int i = m; i < r; i++) {
int k = A[i].size() - 1;
LL a = A[i].back();
for (int j = 0; j < k; j++) dp[z - 1][j] = dp[z][j];
for (int j = k; j <= K; j++) dp[z - 1][j] = max(dp[z][j - k] + a, dp[z][j]);
z--;
}
proc(l, m);
}
int main() {
scanf("%d%d", &N, &K);
A.resize(N);
for (int i = 0; i < (N); i++) {
int t;
scanf("%d", &t);
A[i].resize(t + 1);
for (int j = 0; j < (t); j++) {
int a;
scanf("%d", &a);
A[i][j + 1] = a;
}
A[i].resize(min((int)A[i].size(), K + 1));
for (int j = 0; j < (A[i].size() - 1); j++) A[i][j + 1] += A[i][j];
}
ans = 0;
for (int i = 0; i < (3001); i++) dp[N][i] = 0;
proc(0, N);
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const long long INF = 2 * 1e17 + 7;
const int base = 2e5 + 1;
const int MAX = 1e5 + 2;
const double EPS = 1e-9;
const double PI = acos(-1.);
const int MAXN = 2 * 1e6 + 1;
int main() {
int n, t;
cin >> n >> t;
int res = 0;
vector<int> cnt(n);
for (long long j = (0); j < (t); ++j) {
int x;
cin >> x;
cnt[x - 1]++;
}
sort(cnt.begin(), cnt.end());
cout << cnt[0];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
auto SOLUTION_FUNCTION(void) -> void {
string s;
cin >> s;
string t;
cin >> t;
reverse(s.begin(), s.end());
puts((s == t) ? "YES" : "NO");
return;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << setprecision(10);
cout << fixed;
cout << boolalpha;
int testcase = 1;
while (testcase--) {
SOLUTION_FUNCTION();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename TT>
ostream &operator<<(ostream &s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, vector<T> t) {
for (int i = 0; i < t.size(); i++) s << t[i] << " ";
return s;
}
char s[155][155];
int dp[155][155], pre[155], last[155], n, m;
int fun(int first, int second, int d) {
if (first >= n) return 0;
if (first == n - 1) {
if (d == 0 && pre[first] < second) return 1000000007;
if (d && last[first] > second) return 1000000007;
if (d == 0) return max(0, last[first] - second);
if (d) return max(0, second - pre[first]);
}
int &res = dp[first][second];
if (res + 1) return res;
res = 1000000007;
if (d == 0) {
if (pre[first] < second) return res = 1000000007;
int pos = max(last[first], last[first + 1]);
pos = max(pos, second);
for (int i = pos; i < m; i++)
res = min(res, i - second + 1 + fun(first + 1, i, 1));
} else {
if (last[first] > second) return res = 1000000007;
int pos = min(pre[first], pre[first + 1]);
pos = min(pos, second);
for (int i = pos; i >= 0; i--)
res = min(res, second - i + 1 + fun(first + 1, i, 0));
}
return res;
}
int main() {
int i, j, t = 0;
while (~scanf("%d%d", &n, &m)) {
for (i = 0; i < n; i++) {
scanf("%s", s[i]);
pre[i] = m + 1;
last[i] = -1;
for (j = 0; j < m; j++)
if (s[i][j] == 'W') {
if (pre[i] == m + 1) pre[i] = j;
last[i] = j;
}
}
while (n >= 0 && pre[n - 1] == m + 1) n--;
memset(dp, -1, sizeof(dp));
int ans = fun(0, 0, 0);
printf("%d\n", ans);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toStr(T x) {
stringstream ss;
ss << x;
return ss.str();
}
template <class T1, class T2>
string toStr(pair<T1, T2> x) {
return toStr(x.first) + ": " + toStr(x.second);
}
template <class T>
string containerToStr(T v) {
string r = "[";
for (__typeof(v.begin()) it = v.begin(); it != v.end(); ++it) {
if (r != "[") r += ", ";
r += toStr(*it);
}
return r + "]";
}
template <class T>
string toStr(vector<T> v) {
return containerToStr(v);
}
template <class T>
string toStr(set<T> v) {
return containerToStr(v);
}
template <class T1, class T2>
string toStr(map<T1, T2> v) {
return containerToStr(v);
}
string Bob(string s);
string Alice(string s) {
if (((int)((s).size())) == 2) return s;
string r = "11";
for (int i = 0; i < ((int)((s).size())); ++i) {
string t = s.substr(0, i) + s.substr(i + 1);
t = Bob(t);
r = min(r, t);
}
return r;
}
string Bob(string s) {
if (((int)((s).size())) == 2) return s;
string r = "00";
for (int i = 0; i < ((int)((s).size())); ++i) {
string t = s.substr(0, i) + s.substr(i + 1);
t = Alice(t);
r = max(r, t);
}
return r;
}
string get(string s) {
int c1 = 0, c0 = 0;
for (int i = 0; i < ((int)((s).size())); ++i) {
if (s[i] == '1')
++c1;
else
++c0;
}
int n = ((int)((s).size()));
if (c1 == c0 || c1 - 1 == c0) {
if (s[n - 1] == '0')
return "10";
else
return "01";
}
if (c0 > c1) return "00";
return "11";
}
pair<int, int> get1(string s) {
int c1 = 0, c0 = 0;
for (int i = 0; i < ((int)((s).size())); ++i) {
if (s[i] == '1')
++c1;
else
++c0;
}
return make_pair(c0, c1);
}
char S[1 << 20];
int main() {
scanf("%s", S);
int c1 = 0, c0 = 0, c = 0;
for (int i = 0; S[i]; ++i) {
if (S[i] == '1') ++c1;
if (S[i] == '0') ++c0;
if (S[i] == '?') ++c;
}
vector<string> v;
int n = c1 + c0 + c;
char ch = S[n - 1];
if (n & 1) {
if (c0 <= n / 2 && c1 <= n / 2 + 1) {
if (ch == '1') {
v.push_back("01");
} else if (ch == '0') {
v.push_back("10");
} else {
if (c1 + 1 <= n / 2 + 1) v.push_back("01");
if (c0 + 1 <= n / 2) v.push_back("10");
}
}
if (c0 < n / 2) v.push_back("11");
if (c1 < n / 2 + 1) v.push_back("00");
} else {
if (c0 <= n / 2 && c1 <= n / 2) {
if (ch == '1') {
v.push_back("01");
} else if (ch == '0') {
v.push_back("10");
} else {
if (c1 + 1 <= n / 2) v.push_back("01");
if (c0 + 1 <= n / 2) v.push_back("10");
}
}
if (c0 < n / 2) v.push_back("11");
if (c1 < n / 2) v.push_back("00");
}
sort((v).begin(), (v).end());
for (int i = 0; i < ((int)((v).size())); ++i) {
cout << v[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main(void) {
int x1, y1;
int x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int min = abs(x1 - x2), max = abs(y1 - y2);
if (min > max) {
int t = max;
max = min;
min = t;
}
printf("%d\n", max);
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.