solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long add(long long a, long long b, long long c) {
long long res = a + b;
return (res >= c ? res - c : res);
}
long long mod_neg(long long a, long long b, long long c) {
long long res;
if (abs(a - b) < c)
res = a - b;
else
res = (a - b) % c;
return (res < 0 ? res + c : res);
}
long long mul(long long a, long long b, long long c) {
long long res = (long long)a * b;
return (res >= c ? res % c : res);
}
template <typename T>
T power(T e, T n) {
T x = 1, p = e;
while (n) {
if (n & 1) x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T>
T mdpower(T e, T n, T m) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mul(x, p, m);
p = mul(p, p, m);
n >>= 1;
}
return x;
}
template <typename T>
T extended_euclid(T a, T b, T &x, T &y) {
T xx = 0, yy = 1;
y = 0;
x = 1;
while (b) {
T q = a / b, t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
template <typename T>
T mod_inverse(T a, T n) {
T x, y, z = 0;
T d = extended_euclid(a, n, x, y);
return (d > 1 ? -1 : mod_neg(x, z, n));
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
map<char, set<long long>> mp;
long long n = s.size();
for (long long i = 0; i < n; i++) {
mp[s[i]].insert(i);
}
long long q;
cin >> q;
while (q--) {
long long type, a;
cin >> type >> a;
a--;
if (type == 1) {
char replace;
cin >> replace;
char currChar = s[a];
mp[currChar].erase(a);
s[a] = replace;
mp[replace].insert(a);
} else {
long long b;
cin >> b;
long long count = 0;
for (char x = 'a'; x <= 'z'; x++) {
if (mp[x].size() == 0) continue;
auto it = mp[x].lower_bound(a);
if (it != mp[x].end()) {
if (*it < b) {
count++;
}
}
}
cout << count << "\n";
}
}
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[15];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%s", s + 1);
int f = 0;
for (int i = 5; i <= 9; i++) {
int cnt10 = 0, cnt20 = 0, cnt11 = 0, cnt21 = 0;
for (int j = 1; j <= i; j += 2) {
if (s[j] == '1') {
cnt10++;
cnt11++;
}
if (s[j] == '?') {
cnt11++;
}
}
for (int j = 2; j <= i; j += 2) {
if (s[j] == '1') {
cnt20++;
cnt21++;
}
if (s[j] == '?') {
cnt21++;
}
}
if ((cnt21 - cnt10 > (10 - i) / 2) ||
(cnt11 - cnt20 > (10 - i + 1) / 2)) {
printf("%d\n", i);
f = 1;
break;
}
}
if (f == 0) {
puts("10");
}
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
long long n, i, cnt = 0, m = 0;
scanf("%lld", &n);
int s[n];
for (i = 0; i < n; i++) scanf("%lld", &s[i]);
for (i = 0; i < n - 1; i++) {
if (s[i] * 2 >= s[i + 1])
cnt++;
else {
m = (m > cnt) ? m : cnt;
cnt = 0;
}
}
m = (m > cnt) ? m : cnt;
printf("%lld\n", m + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const int maxn = 1e5 + 5;
const int maxm = (maxn << 2) + 2e6;
struct Node {
int x, r, q;
bool operator<(const Node &A) const { return r > A.r; }
};
Node a[maxn];
map<int, int> Hashq, Hashx;
int root[maxn];
long long sum[maxm];
int lch[maxm], rch[maxm];
int dfn;
void build(int &k, int l, int r) {
k = ++dfn;
sum[k] = 0;
if (l == r) return;
int mid = l + r >> 1;
build(lch[k], l, mid);
build(rch[k], mid + 1, r);
}
inline void pushup(int k) { sum[k] = sum[lch[k]] + sum[rch[k]]; }
inline void newnode(int old, int k) {
sum[k] = sum[old];
lch[k] = lch[old];
rch[k] = rch[old];
}
void update(int old, int &k, int l, int r, int p, int x) {
k = ++dfn;
newnode(old, k);
if (l == r) {
sum[k] += x;
return;
}
int mid = l + r >> 1;
if (p <= mid) update(lch[old], lch[k], l, mid, p, x);
if (mid + 1 <= p) update(rch[old], rch[k], mid + 1, r, p, x);
pushup(k);
}
long long query(int k, int l, int r, int L, int R) {
if (L <= l && R >= r) return sum[k];
int mid = l + r >> 1;
long long ret = 0;
if (L <= mid) ret += query(lch[k], l, mid, L, R);
if (mid + 1 <= R) ret += query(rch[k], mid + 1, r, L, R);
return ret;
}
int main() {
std::ios::sync_with_stdio(false);
int n, m;
scanf("%d%d", &n, &m);
vector<int> X;
for (int i = 0; i < n; i++)
scanf("%d%d%d", &a[i].x, &a[i].r, &a[i].q), X.push_back(a[i].x);
(sort(X.begin(), X.end())),
X.resize(distance(X.begin(), unique(X.begin(), X.end())));
int N = X.size();
for (int i = 0; i < n; i++) {
int pos = lower_bound(X.begin(), X.end(), a[i].x) - X.begin();
Hashx[a[i].x] = pos;
}
sort(a, a + n);
dfn = 0;
int tot = 0;
long long ans = 0;
build(root[tot++], 0, N - 1);
for (int i = 0; i < n; i++) {
int base = max(0, a[i].q - m);
int top = a[i].q + m;
int l = lower_bound(X.begin(), X.end(), a[i].x - a[i].r) - X.begin();
int r = upper_bound(X.begin(), X.end(), a[i].x + a[i].r) - X.begin() - 1;
for (int j = base; j <= top; j++) {
if (Hashq.find(j) == Hashq.end()) continue;
ans += query(root[Hashq[j]], 0, N - 1, l, r);
}
int old = root[Hashq[a[i].q]];
Hashq[a[i].q] = tot++;
update(old, root[Hashq[a[i].q]], 0, N - 1, Hashx[a[i].x], 1);
}
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
long long n;
int k;
int a[100];
int b[100][MAXN];
long long get_ans(int i, long long N) {
if (N == 0) return 0;
if (i >= k) return N;
if (N < MAXN && b[i][N] != -1) return b[i][N];
long long res = get_ans(i + 1, N) - get_ans(i + 1, N / a[i]);
if (N < MAXN) b[i][N] = res;
return res;
}
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) cin >> a[i];
sort(a, a + k, greater<int>());
memset(b, -1, sizeof b);
cout << get_ans(0, n) << endl;
}
| 9 |
#include <bits/stdc++.h>
void dfs(long node, const std::vector<std::vector<long> > &g,
std::vector<bool> &visited, long dist, long &maxDist, long &furthest) {
if (visited[node]) {
return;
}
visited[node] = true;
if (dist > maxDist) {
furthest = node;
maxDist = dist;
}
for (long p = 0; p < g[node].size(); p++) {
long u = g[node][p];
if (visited[u]) {
continue;
}
dfs(u, g, visited, dist + 1, maxDist, furthest);
}
return;
}
int main() {
long n, m;
scanf("%ld %ld", &n, &m);
std::vector<std::vector<long> > g(n);
for (long p = 1; p < n; p++) {
long x, y;
scanf("%ld %ld", &x, &y);
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
std::vector<bool> visitedA(n, 0);
long maxDist(0), furthest(0);
dfs(0, g, visitedA, 0, maxDist, furthest);
std::vector<bool> visitedB(n, 0);
dfs(furthest, g, visitedB, 0, maxDist, furthest);
printf("%ld\n", maxDist);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x, y, f[10][10];
double dp[10][10];
int main() {
for (int i = (0); i < (10); i++)
for (int j = (0); j < (10); j++) cin >> f[i][j];
for (int i = (0); i < (10); i++) {
for (int j = i & 1 ? 9 : 0; j < 10 && j >= 0; j += i & 1 ? -1 : 1) {
if (i == 0 && j < 7) {
if (j) dp[i][j] = 6.0;
} else
for (int k = (1); k < (7); k++) {
x = i, y = j;
y += (i & 1 ? 1 : -1) * k;
if (y > 9)
x--, y = 19 - y;
else if (y < 0)
x--, y = -y - 1;
dp[i][j] += (1 + min(dp[x][y], dp[x - f[x][y]][y])) / 6;
}
}
}
printf("%.10f\n", dp[9][0]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int check(string &a, string &b) {
if (a.size() > b.size())
return 0;
else {
int l = a.size() - 1;
int r = b.size() - 1;
int ans = 1;
while (l >= 0) {
if (a[l] == b[r]) {
l--;
r--;
} else {
ans = 0;
break;
}
}
return ans;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long n;
cin >> n;
long long arr[n];
long sq = 0, nsq = 0;
long long hash[n];
vector<long long> flag;
vector<long long> arr1;
for (long i = 0; i < n; i++) {
cin >> arr[i];
long temp = sqrt(arr[i]);
if (temp * temp == arr[i]) {
arr1.push_back(arr[i]);
hash[i] = -1;
sq++;
} else {
nsq++;
hash[i] = min(arr[i] - temp * temp, (temp + 1) * (temp + 1) - arr[i]);
flag.push_back(hash[i]);
}
}
if (sq == nsq)
cout << 0 << endl;
else if (sq > nsq) {
long check = 0;
long count = 0;
sort(arr1.begin(), arr1.end());
for (long i = arr1.size() - 1; i >= 0; i--) {
if (check == (sq - nsq) / 2) break;
if (arr1[i] == 0) {
count += 2;
check++;
} else {
count++;
check++;
}
}
cout << count << endl;
} else {
long long count = 0;
sort(flag.begin(), flag.end());
for (long i = 0; i < (nsq - sq) / 2; i++) {
count += flag[i];
}
cout << count << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5;
const int mod = 1000000007;
const int inf = 1e9;
const double pi = acos(-1.0);
const double eps = 1e-8;
struct unionset {
int fat[1003], len;
void init(int x) {
len = x;
for (int i = 0; i < x; i++) fat[i] = i;
return;
}
int getf(int x) {
if (fat[x] == x) return x;
return fat[x] = getf(fat[x]);
}
void un(int x, int y) {
fat[getf(y)] = getf(x);
return;
}
};
struct tree_array {
int c[1003];
int v[1003], len;
int get_low(int x) { return x & (-x); }
void init(int x) {
len = x;
for (int i = 0; i < x; i++) c[i] = v[i] = 0;
return;
}
void add(int x, int value) {
v[x] += value;
while (x <= len) {
c[x] += value;
x += get_low(x);
}
return;
}
int sum(int x) {
int ans = 0;
while (x > 0) {
ans += c[x];
x -= get_low(x);
}
return ans;
}
};
int pow_mod(int a, int b, int c) {
long long ans = 1, tmp = a;
while (b) {
if (b & 1) ans = ans * tmp % c;
tmp = tmp * tmp % c;
b >>= 1;
}
return ans;
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
class ColorfulCoins {
public:
int minQueries(vector<long long> values) {
int xx[100];
int n = values.size() - 1;
for (int i = 0; i < values.size(); i++) xx[i] = values[i + 1] / values[i];
if (n == 0) return 0;
int cnt = n, tag[100] = {0};
while (cnt > 0) {
int id = 0, bb = 0;
for (int i = 0; i < n; i++)
if (tag[i] == 0 && xx[i] > bb) {
id = i;
bb = xx[i];
}
tag[id] = 1;
cnt--;
}
}
};
vector<int> qnext[N];
struct bb {
int l, r;
bool operator<(const bb &a) const {
if (l == a.l) return r < a.r;
return l < a.l;
}
} qlist[N], tmp[N];
int cnt[N];
int vvv[N];
bool xt[N];
int main() {
int i, n, p;
scanf("%d%d", &n, &p);
for (i = 0; i < n; i++) {
tmp[i].r = i + 1;
int l, r;
scanf("%d%d", &l, &r);
if (l > r) swap(l, r);
qlist[i].l = l;
qlist[i].r = r;
cnt[l]++;
tmp[l - 1].l++;
tmp[r - 1].l++;
cnt[r]++;
}
sort(tmp, tmp + n);
for (i = 0; i < n; i++) vvv[i] = tmp[i].l;
sort(qlist, qlist + n);
for (i = 0; i < n; i++)
if (i == n - 1 ||
!(qlist[i + 1].l == qlist[i].l && qlist[i + 1].r == qlist[i].r)) {
qnext[qlist[i].l].push_back(qlist[i].r);
qnext[qlist[i].r].push_back(qlist[i].l);
}
long long ans = 0;
int num = 1, l = qlist[0].l, r = qlist[0].r;
for (i = 1; i < n; i++)
if (qlist[i].l == l && qlist[i].r == r)
num++;
else {
if (cnt[l] + cnt[r] - num >= p) ans++;
num = 1;
l = qlist[i].l;
r = qlist[i].r;
}
if (cnt[l] + cnt[r] - num >= p) ans++;
for (i = n - 1; i > 0; i--) {
if (tmp[i].l < p - tmp[i].l) break;
int num = vvv + i - lower_bound(vvv, vvv + n, p - tmp[i].l);
int u = tmp[i].r;
xt[u] = true;
for (int j = 0; j < qnext[u].size(); j++)
if (cnt[qnext[u][j]] >= p - tmp[i].l && !xt[qnext[u][j]]) num--;
ans += num;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = 1000000000000000000;
long long mpow(long long a, long long b) {
a %= mod;
if (!b) return 1;
long long temp = mpow(a, b / 2);
temp = (temp * temp) % mod;
if (b % 2) return (a * temp) % mod;
return temp;
}
long long pow_(long long a, long long b) {
if (!b) return 1;
long long temp = pow_(a, b / 2);
temp = (temp * temp);
if (b % 2) return (a * temp);
return temp;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPalin(string s) {
int i = 0, j = s.size() - 1;
while (i < j) {
if (s[i++] != s[j--]) {
return false;
}
}
return true;
}
long long cl(long long a, long long b) {
if (a % b) return 1 + a / b;
return a / b;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
long long f[200001];
long long mod_inv(long long n, long long MOD) { return mpow(n, MOD - 2); }
long long nCr(long long n, long long r, long long MOD) {
return (f[n] * ((mod_inv(f[r], MOD) * mod_inv(f[n - r], MOD)) % MOD)) % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) {
long long int n, m, i, j, a[500002], b[500002];
long long int cn = 0, flag = 0, num, k, ans = 0, sum = 0;
string s;
vector<pair<long long int, long long int> > vp;
map<long long int, long long int> mapp;
cin >> n >> k;
vector<long long int> v(k, 1);
sum = k;
for (i = k - 1; i >= 0; i--) {
while (sum + v[i] <= n) {
sum += v[i];
v[i] *= 2;
}
}
if (sum != n)
cout << "NO\n";
else {
cout << "YES\n";
for (auto x : v) cout << x << " ";
cout << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> start;
map<int, int> mp;
int n, v[400002], k, lim, nr, ans;
int main() {
cin >> n >> k;
k = 8 * k;
int aux = k / n;
if (aux > 30)
lim = n;
else
lim = min((1 << aux), n);
for (int i = 1; i <= n; i++) {
cin >> v[i];
if (mp.find(v[i]) == mp.end()) {
nr++;
mp[v[i]] = 1;
}
}
if (nr <= lim) {
cout << 0;
} else {
int dif = nr - lim;
sort(v + 1, v + n + 1);
start.push_back(0);
for (int i = 1; i <= n; i++)
if (v[i] != v[i - 1]) start.push_back(i);
ans = n + 1;
ans = min(ans, n - start[start.size() - dif] + 1);
ans = min(ans, start[dif + 1] - 1);
for (int i = 1; i < dif; i++) {
int aux = start[i + 1] - 1;
int aux2 = dif - i;
aux += n - start[start.size() - aux2] + 1;
ans = min(ans, aux);
}
cout << ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int cost, s;
};
node a[11000], b[11000];
int pos1[100010], pos2[100010], vis1[100010], vis2[100010];
bool cmp(node x, node y) { return x.cost > y.cost; }
bool cmp1(node x, node y) { return x.cost < y.cost; }
int main() {
int n, s;
while (~scanf("%d%d", &n, &s)) {
getchar();
int q, w;
memset(vis1, 0, sizeof(vis1));
memset(vis2, 0, sizeof(vis2));
int sum1 = 0, sum2 = 0;
char ch;
for (int i = 1; i <= n; i++) {
scanf("%c%d%d", &ch, &q, &w);
getchar();
if (ch == 'B') {
if (vis1[q] == 0) {
a[sum1].cost = q;
a[sum1].s = w;
pos1[q] = sum1;
sum1++;
vis1[q] = 1;
} else {
a[pos1[q]].s += w;
}
}
if (ch == 'S') {
if (vis2[q] == 0) {
b[sum2].cost = q;
b[sum2].s = w;
pos2[q] = sum2;
sum2++;
vis2[q] = 1;
} else {
b[pos2[q]].s += w;
}
}
}
sort(b, b + sum2, cmp1);
sort(a, a + sum1, cmp);
int minn = min(sum2, s);
for (int i = minn - 1; i >= 0; i--) printf("S %d %d\n", b[i].cost, b[i].s);
for (int i = 0; i < sum1 && i < s; i++)
printf("B %d %d\n", a[i].cost, a[i].s);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int Mod = 1e9 + 7;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
int n, mx = -1;
cin >> n;
vector<long long int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<long long int> ls(n, -1), rs(n, n);
stack<int> s;
s.push(n - 1);
for (int i = n - 1; i >= 0; i--) {
if (s.empty()) {
s.push(i);
continue;
}
while (!s.empty() && h[s.top()] > h[i]) {
ls[s.top()] = i;
s.pop();
}
s.push(i);
}
while (!s.empty()) s.pop();
s.push(0);
for (int i = 1; i < n; i++) {
if (s.empty()) {
s.push(i);
continue;
}
while (!s.empty() && h[s.top()] > h[i]) {
rs[s.top()] = i;
s.pop();
}
s.push(i);
}
for (int i = 0; i < n; i++) {
if (ls[i] == -1)
ls[i] = (i + 1) * h[i];
else
ls[i] = (i - ls[i]) * h[i] + ls[ls[i]];
}
for (int i = n - 1; i >= 0; i--) {
if (rs[i] == n)
rs[i] = (n - i) * h[i];
else
rs[i] = (rs[i] - i) * h[i] + rs[rs[i]];
}
long long int peak = -1, idx = -1;
for (int i = 0; i < n; i++) {
if (ls[i] + rs[i] - h[i] > peak) {
idx = i;
peak = ls[i] + rs[i] - h[i];
}
}
vector<int> ans(n, 0);
int i = idx - 1, j = idx + 1;
ans[idx] = h[idx];
while (i >= 0) {
if (h[i] > ans[i + 1])
ans[i] = ans[i + 1];
else
ans[i] = h[i];
i--;
}
while (j <= n - 1) {
if (h[j] > ans[j - 1])
ans[j] = ans[j - 1];
else
ans[j] = h[j];
j++;
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class str {
public:
char s[100001];
int len;
str() { len = 0; }
str(const string& ss, int breakp) {
len = 0;
int carry = 0, curr;
for (int i = ss.size() - 1, j = breakp - 1;
(i >= breakp) || (j >= 0) || (carry > 0); i--, j--, len++) {
curr = carry;
if (j >= 0) curr += (ss[j] - '0');
if (i >= breakp) curr += (ss[i] - '0');
s[100001 - (len + 1)] = ('0' + (curr % 10));
carry = curr / 10;
}
}
int cmp(const str& s2) {
if (s2.len > len) return -1;
if (len > s2.len) return 1;
for (int i = 0; i < len; i++) {
if (s[i + (100001 - len)] > s2.s[i + (100001 - len)]) return 1;
if (s[i + (100001 - len)] < s2.s[i + (100001 - len)]) return -1;
}
return 0;
}
void print() {
for (int i = 100001 - len; i < 100001; i++) {
cout << s[i];
}
cout << endl;
}
};
int main() {
int L, i;
string S;
cin >> L >> S;
vector<int> cand;
if ((L & 1) && S[L / 2] != '0') cand.push_back(L / 2);
for (i = (L / 2) - 1; i > 0; i--)
if (S[i] != '0') break;
if (i > 0) cand.push_back(i);
for (i = ((L + 1) / 2); i < L; i++)
if (S[i] != '0') break;
if (i < L) cand.push_back(i);
str curr, ans = str(S, cand[0]);
for (i = 1; i < cand.size(); i++) {
curr = str(S, cand[i]);
if (ans.cmp(curr) > 0) {
ans = curr;
}
}
ans.print();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x < y ? x : y;
}
const int N = 3010;
const long double eps = 1e-10;
long double p[N], u[N];
struct Node {
long double v;
int a, b;
bool operator>(const Node &f) const {
if (fabs(v - f.v) > eps) return v - f.v > eps;
if (b != f.b) return b < f.b;
return a < f.a;
}
} f[N];
void work(int n, long double v1, long double v2) {
f[0] = (Node){0, 0, 0};
for (int i = 1; i <= n; i++) {
f[i] = f[i - 1];
long double v = f[i].v;
int a = f[i].a, b = f[i].b;
chkmax(f[i], (Node){v + p[i] - v1, a + 1, b});
chkmax(f[i], (Node){v + u[i] - v2, a, b + 1});
chkmax(f[i], (Node){v + p[i] + u[i] - p[i] * u[i] - v1 - v2, a + 1, b + 1});
}
}
int main() {
ios::sync_with_stdio(false);
int n, a, b;
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++) cin >> u[i];
long double l = 0, r = 1, tl, tr;
while (l + eps < r) {
long double mid = (l + r) / 2;
tl = 0, tr = 1;
while (tl + eps < tr) {
long double Mid = (tl + tr) / 2;
work(n, mid, Mid);
if (f[n].b <= b)
tr = Mid;
else
tl = Mid;
}
work(n, mid, tr);
if (f[n].a <= a)
r = mid;
else
l = mid;
}
work(n, r, tr);
cout << fixed << setprecision(10) << f[n].v + a * r + b * tr << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int lis(int A[], int size) {
int *lis, i, j, Max = 0;
lis = (int *)malloc(sizeof(int) * size);
for (i = 0; i < size; i++) {
lis[i] = 1;
}
for (i = 0; i < size; i++) {
for (j = 0; j < i; j++) {
if (A[i] >= A[j] && lis[i] < (lis[j] + 1)) lis[i] = lis[j] + 1;
}
}
Max = lis[0];
for (i = 0; i < size; i++) {
Max = max(Max, lis[i]);
}
return Max;
}
int main() {
int n, i, T, tmp, j;
cin >> n >> T;
tmp = min(n, T);
int A[n], B[tmp * n];
for (i = 0; i < n; i++) {
cin >> A[i];
B[i] = A[i];
}
for (i = 1; i < tmp; i++) {
for (j = 0; j < n; j++) {
B[i * n + j] = B[j];
}
}
int Ans = lis(B, tmp * n);
int ctr = 1, Max = 1;
sort(A, A + n);
for (i = n - 2; i >= 0; i--) {
if (A[i] == A[i + 1]) {
ctr++;
} else {
ctr = 1;
}
Max = max(Max, ctr);
}
tmp = max(0, T - n);
Ans += tmp * Max;
cout << Ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = INT_MAX;
const long long LINF = LLONG_MAX;
const int N = 1e6 + 20;
int a[N], n, res;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int g = 0;; g++)
if ((g * g + g) / 2 > a[i]) {
res ^= (g - 1);
break;
}
}
if (res == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void input() {
int i, n, x, xmax = 0;
long long tt = 0;
scanf("%d", &n);
for ((i) = 0; (i) < (n); (i)++)
scanf("%d", &x), tt += x, xmax = ((xmax) > (x) ? (xmax) : (x));
long long dau = xmax, cuoi = tt, giua;
while (dau <= cuoi) {
giua = (dau + cuoi) >> 1;
if (giua * (n - 1) >= tt)
cuoi = giua - 1;
else
dau = giua + 1;
}
printf("%I64d", dau);
}
int main() {
input();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
const int N = 505;
int fa[N], sz[N], q[N];
vector<int> lea, s;
bool cmp(int a, int b) { return sz[a] < sz[b]; }
int get(vector<int> &s, vector<int> &t, int id) {
writeln(s.size());
for (auto i : s) wri(i);
puts("");
writeln(t.size());
for (auto i : t) wri(i);
puts("");
cout << id << endl;
fflush(stdout);
int jb = read();
return jb;
}
void bao(int id, vector<int> v) {
if (v.size() == 1) {
fa[v[0]] = id;
for (auto it = lea.begin(); it != lea.end(); it++) {
if (*it == v[0]) {
lea.erase(it);
return;
}
}
return;
}
int mid = v.size() / 2;
vector<int> V = v;
V.resize(mid);
if (get(s, V, id)) bao(id, V);
V = v;
V.erase(V.begin(), V.begin() + mid);
if (get(s, V, id)) bao(id, V);
}
int main() {
int n = read();
sz[1] = n;
s.resize(1);
vector<int> t(n - 1), V;
s[0] = 1;
for (int i = 1; i < n; i++) t[i - 1] = i + 1;
for (int i = 1; i <= n; i++) q[i] = i;
for (int i = 2; i <= n; i++) {
sz[i] = get(s, t, i);
if (sz[i] == 1)
lea.push_back(i);
else
V.push_back(i);
}
sort(V.begin(), V.end(), cmp);
for (auto i : V) {
bao(i, lea);
lea.push_back(i);
}
puts("ANSWER");
for (int i = 2; i <= n; i++) {
if (!fa[i]) fa[i] = 1;
wri(fa[i]);
writeln(i);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
void solve(std::istream& in, std::ostream& out) {
int a, ta, b, tb;
in >> a >> ta >> b >> tb;
string s;
in >> s;
int t0 = ((s[0] - '0') * 10 + (s[1] - '0')) * 60 + (s[3] - '0') * 10 +
(s[4] - '0');
int res = 0;
for (int t = 5 * 60; t < 60 * 24; t += b)
if (t + tb > t0 && t < t0 + ta) ++res;
out << res << endl;
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
cin >> n;
int p[n], q[n];
for (int i = 0; i < n; i++) {
cin >> p[i] >> q[i];
}
for (int i = 0; i < n; i++) {
if (q[i] - p[i] >= 2) count++;
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
int x[110000], y[110000], n;
set<pair<int, int> > sx, sy;
int work(set<pair<int, int> > &sx, set<pair<int, int> > &sy) {
if (sx.size() == 1) return 1;
set<pair<int, int> >::iterator it1, it2, it3, it4;
it1 = sx.begin();
it2 = sx.end();
it2--;
it3 = sy.begin();
it4 = sy.end();
it4--;
set<pair<int, int> > dx, dy;
auto renew = [&](bool flag, set<pair<int, int> >::iterator i) {
int t = i->second;
pair<int, int> tmp = make_pair((i->first == x[t] ? y[t] : x[t]), t);
if (!flag) {
dx.insert(*i);
dy.insert(tmp);
sy.erase(tmp);
sx.erase(i);
} else {
dy.insert(*i);
dx.insert(tmp);
sx.erase(tmp);
sy.erase(i);
}
};
for (;;) {
int tmp;
tmp = it1->first;
if ((++it1)->first > tmp + 1) {
for (auto i = sx.begin(); i != it1;) {
auto I = i++;
renew(0, I);
}
return work(dx, dy) + work(sx, sy);
}
tmp = it3->first;
if ((++it3)->first > tmp + 1) {
for (auto i = sy.begin(); i != it3;) {
auto I = i++;
renew(1, I);
}
return work(dx, dy) + work(sx, sy);
}
if (it1 == it2) break;
tmp = it2->first;
if ((--it2)->first < tmp - 1) {
for (auto i = ++it2; i != sx.end();) {
auto I = i++;
renew(0, I);
}
return work(dx, dy) + work(sx, sy);
}
tmp = it4->first;
if ((--it4)->first < tmp - 1) {
for (auto i = ++it4; i != sy.end();) {
auto I = i++;
renew(1, I);
}
return work(dx, dy) + work(sx, sy);
}
if (it1 == it2) break;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &x[i], &y[i]);
for (int i = 1; i <= n; ++i)
sx.insert(make_pair(x[i], i)), sy.insert(make_pair(y[i], i));
printf("%d\n", work(sx, sy));
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, qu, f[100005], v[100005 + 100005], o[100005 + 100005], p, s[100005],
r, fr[100005], to[100005], si[100005], curm, grp[100005], gr, rt[100005];
bool u[100005], vis[100005];
vector<int> b[100005], c[100005], q[100005], ans[100005];
void bd(int a, int b) {
v[++p] = b;
o[p] = f[a];
f[a] = p;
}
void merge(vector<int> &a, vector<int> b) {
vector<int> c;
int l = 0, r = 0;
while (l < a.size() || r < b.size()) {
if (l == a.size())
c.push_back(b[r++]);
else if (r == b.size())
c.push_back(a[l++]);
else if (a[l] < b[r])
c.push_back(a[l++]);
else
c.push_back(b[r++]);
}
a = c;
if (a.size() > 11) a.resize(11);
}
void size(int x, int y) {
s[x] = vis[x] = 1;
for (int i = (f[x]); i; i = o[i])
if (v[i] != y && !u[v[i]]) {
size(v[i], x);
s[x] += s[v[i]];
}
}
void pick(int x, int y, int z) {
int m = s[z] - s[x];
for (int i = (f[x]); i; i = o[i])
if (v[i] != y && !u[v[i]]) {
pick(v[i], x, z);
m = max(m, s[v[i]]);
}
if (m < curm) {
curm = m;
r = x;
}
}
void group(int x, int y, int z) {
grp[x] = z;
for (int i = (f[x]); i; i = o[i])
if (v[i] != y && !u[v[i]]) group(v[i], x, z);
}
void dfs(int x, int y) {
c[x] = c[y];
merge(c[x], b[x]);
for (int i = (0); i < (q[x].size()); i++) {
int d = q[x][i];
if (vis[fr[d]] && vis[to[d]] && grp[fr[d]] != grp[to[d]]) {
merge(ans[d], c[x]);
rt[d] = r;
}
}
for (int i = (f[x]); i; i = o[i])
if (v[i] != y && !u[v[i]]) dfs(v[i], x);
}
void reset(int x, int y) {
vis[x] = 0;
for (int i = (f[x]); i; i = o[i])
if (v[i] != y && !u[v[i]]) reset(v[i], x);
}
void root(int x) {
size(x, 0);
curm = 100005;
pick(x, 0, x);
grp[r] = 0;
gr = 1;
u[r] = 1;
for (int i = (f[r]); i; i = o[i])
if (!u[v[i]]) group(v[i], r, gr++);
for (int i = (0); i < (q[r].size()); i++) {
int d = q[r][i];
if (vis[fr[d]] && vis[to[d]]) rt[d] = r;
}
for (int i = (f[r]); i; i = o[i])
if (!u[v[i]]) dfs(v[i], 0);
reset(r, 0);
for (int i = (f[r]); i; i = o[i])
if (!u[v[i]]) root(v[i]);
}
int main() {
scanf("%d %d %d", &n, &m, &qu);
for (int i = (1); i < (n); i++) {
int a, b;
scanf("%d %d", &a, &b);
bd(a, b);
bd(b, a);
}
for (int i = (1); i <= (m); i++) {
int t;
scanf("%d", &t);
b[t].push_back(i);
}
for (int i = (1); i <= (n); i++)
if (b[i].size() > 11) b[i].resize(11);
for (int i = (1); i <= (qu); i++) {
scanf("%d %d %d", &fr[i], &to[i], &si[i]);
q[fr[i]].push_back(i);
q[to[i]].push_back(i);
}
root(1);
for (int i = (1); i <= (qu); i++) {
merge(ans[i], b[rt[i]]);
if (ans[i].size() > si[i]) ans[i].resize(si[i]);
printf("%d", ans[i].size());
for (int j = (0); j < (ans[i].size()); j++) printf(" %d", ans[i][j]);
puts("");
}
scanf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n;
long long x[maxn], y[maxn];
int main() {
scanf("%d", &n);
if (n & 1) return puts("NO"), 0;
for (int i = 1; i <= n; i++) scanf("%lld %lld", x + i, y + i);
x[n + 1] = x[1];
y[n + 1] = y[1];
int mid = n / 2;
for (int i = 1; i <= mid; i++) {
if ((x[i + 1] - x[i]) + (x[mid + i + 1] - x[mid + i]) ||
(y[i + 1] - y[i]) + (y[mid + 1 + i] - y[mid + i]))
return puts("NO"), 0;
}
puts("YES");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int dp[5005][5005];
void add(int floor, int l, int r, int d) {
dp[floor][l] = (dp[floor][l] + d) % mod;
dp[floor][r] = (dp[floor][r] - d + mod) % mod;
}
int main() {
int n, a, b, k;
while (~scanf("%d", &n)) {
scanf("%d%d%d", &a, &b, &k);
dp[0][a] = 1;
int i = 0, count = 0;
while (i < k) {
for (int j = 1; j <= n; j++) {
if (j == b)
continue;
else {
int x = abs(j - b) - 1;
add(i + 1, max(j - x, 1), j, dp[i][j]);
add(i + 1, j + 1, min(j + x + 1, n + 1), dp[i][j]);
}
}
int move = 0;
for (int j = 1; j <= n; j++) {
move = (move + dp[i + 1][j]) % mod;
dp[i + 1][j] = move;
}
i++;
}
for (int i = 0; i < n; i++) count = (count + dp[k][i + 1]) % mod;
printf("%d\n", count);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
long long LCM(long long a, long long b) { return a * (b / GCD(a, b)); }
const double EPS = 10e-7;
const double INF = (1LL << 62);
struct Point {
double x;
double y;
};
int K[100];
Point xy[100];
Point circumcircle(int i, int j, int k) {
Point A = xy[i], B = xy[j], C = xy[k];
double x = K[i] * (B.y - C.y) + K[j] * (C.y - A.y) + K[k] * (A.y - B.y);
double y = K[i] * (C.x - B.x) + K[j] * (A.x - C.x) + K[k] * (B.x - A.x);
double d = 2.0 * (A.x * (B.y - C.y) + B.x * (C.y - A.y) + C.x * (A.y - B.y));
x /= d;
y /= d;
Point p;
p.x = x;
p.y = y;
return p;
}
double sign(Point &p1, Point &p2, Point &p3) {
return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
}
bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
double s1, s2, s3;
s1 = sign(p, v1, v2);
s2 = sign(p, v2, v3);
s3 = sign(p, v3, v1);
return (s1 > EPS && s2 > EPS && s3 > EPS) ||
(s1 < -EPS && s2 < -EPS && s3 < -EPS);
}
double dist(Point A, Point B) {
double d1 = (A.x - B.x), d2 = (A.y - B.y);
return d1 * d1 + d2 * d2;
}
Point median(Point A, Point B) {
Point m;
m.x = (A.x + B.x) / 2;
m.y = (A.y + B.y) / 2;
return m;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < (N); ++i) {
cin >> xy[i].x >> xy[i].y;
}
for (int i = 0; i < (N); ++i) {
K[i] = xy[i].x * xy[i].x + xy[i].y * xy[i].y;
}
double maxDist = -1;
for (int i = 0; i < (N); ++i) {
for (int j = 0; j < (N); ++j) {
if (i == j) continue;
Point cc;
double rad = INF;
for (int k = 0; k < (N); ++k) {
if (k != i && k != j) {
Point c = circumcircle(i, j, k);
double s1 = sign(xy[i], xy[j], xy[k]), s2 = sign(xy[i], xy[j], c);
if (inside(xy[i], xy[j], xy[k], c) && (s1 > EPS && s2 > EPS)) {
if (rad > dist(c, xy[i])) {
rad = min(dist(c, xy[i]), rad);
cc = c;
}
}
}
}
bool ok = true;
for (int kk = 0; kk < (N); ++kk) {
if (kk != i && kk != j && rad > dist(cc, xy[kk])) {
ok = false;
break;
}
}
if (ok && rad != INF) {
maxDist = max(maxDist, rad);
}
ok = true;
int count = 0;
Point mid = median(xy[i], xy[j]);
for (int k = 0; k < (N); ++k) {
if (k != i && k != j) {
if (dist(xy[i], mid) > dist(xy[k], mid)) {
ok = false;
break;
} else if (abs(dist(xy[i], mid) - dist(xy[k], mid)) < EPS)
count++;
}
}
if (ok && count >= 2) {
maxDist = max(maxDist, dist(mid, xy[i]));
}
}
}
if (maxDist != -1)
cout << sqrt(maxDist) << endl;
else
cout << -1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[300][300];
char s[4 * 300][4 * 300];
char t[2 * 7][4][4] = {
{"...", "...", "..."}, {"...", ".O.", "..."}, {"..O", "...", "O.."},
{"..O", ".O.", "O.."}, {"O.O", "...", "O.O"}, {"O.O", ".O.", "O.O"},
{"O.O", "O.O", "O.O"}, {"...", "...", "..."}, {"...", ".O.", "..."},
{"O..", "...", "..O"}, {"O..", ".O.", "..O"}, {"O.O", "...", "O.O"},
{"O.O", ".O.", "O.O"}, {"OOO", "...", "OOO"}};
int n, m;
int d[300], b[300];
int main() {
int i, j, k, f, ii, jj;
scanf("%d%d", &n, &m);
for (i = 0; i < 4 * n + 1; scanf("%s", s[i]), i++)
;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
for (k = 0; k < 2 * 7; k++) {
f = 1;
for (ii = 0; ii < 3; ii++) {
for (jj = 0; jj < 3; jj++) {
if (t[k][ii][jj] != s[4 * i + 1 + ii][4 * j + 1 + jj]) f = 0;
}
}
if (f == 1) a[i][j] |= k / 7 + 1;
}
}
}
d[0] = 1;
for (j = 0; j < m; j++) {
for (i = 0; i < n && (a[i][j] & 1); i++)
;
if (i == n && n % 2 == 0) d[j + 1] = (d[j + 1] + d[j]) % 1000000007;
if (j + 1 < m) {
b[0] = 1;
for (i = 0; i < n; b[i + 1] = 0, i++)
;
for (i = 0; i < n; i++) {
if ((a[i][j] & 2) && (a[i][j + 1] & 2))
b[i + 1] = (b[i + 1] + b[i]) % 1000000007;
if (i + 1 < n && (a[i][j] & 1) && (a[i][j + 1] & 1) &&
(a[i + 1][j] & 1) && (a[i + 1][j + 1] & 1))
b[i + 2] = (b[i + 2] + b[i]) % 1000000007;
}
for (i = 0; i < n && ((a[i][j] & 1) && (a[i][j + 1] & 1)); i++)
;
if (i == n && n % 2 == 0) b[n] = (b[n] + 1000000007 - 1) % 1000000007;
d[j + 2] = (d[j + 2] + (long long)d[j] * b[n]) % 1000000007;
}
}
printf("%d\n", d[m]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1000 * 100 + 17, inf = 1e9;
int n, d, a[MAXN], m, ans;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> d;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> m;
sort(a + 1, a + n + 1);
int i = 1;
while (m > 0 and i <= n) {
ans += a[i];
i++;
m--;
}
ans -= d * m;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int calc(int n, vector<int> input) {
map<int, int> process;
for (int i = 0; i < n; i++) process[input[i]]++;
int sum = 1;
for (int i = 0; i < n; i++) sum = sum + max(0, process[i] - 1);
return sum;
}
int main() {
int n;
cin >> n;
vector<int> input(n);
for (int i = 0; i < n; i++) cin >> input[i];
cout << calc(n, input) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, w[100005], a;
int licz(int q) {
if (q == 2) return 2;
int wyn = q * (q - 1) / 2;
if (q % 2 == 0) return wyn + q / 2;
return wyn + 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) scanf("%d%d", &a, &w[i]);
sort(w, w + m);
int ile = 1;
while (licz(ile) <= n) ++ile;
long long wyn = 0LL;
for (int i = m - 1; i >= max(m - ile + 1, 0); i--) wyn += w[i];
cout << wyn << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a;
char s[20];
bool check(int x) {
while (x > 0) {
int y = x % 10;
x /= 10;
if (y == 8) return true;
}
return false;
}
int main() {
cin >> s;
if (s[0] == '-') {
int cnt = 1;
for (int i = strlen(s) - 1; i > 0; i--) {
int c = s[i] - '0';
a += c * cnt;
cnt *= 10;
}
if (a <= 8) {
int x = sqrt(a * a);
printf("%d", 8 + x);
return 0;
}
int x = sqrt(a * a);
if (x == 9) {
printf("%d", 1);
return 0;
}
for (int i = 1; i <= 10; i++) {
if (check(x - i)) {
printf("%d", i);
return 0;
}
}
}
int cnt = 1;
for (int i = strlen(s) - 1; i >= 0; i--) {
int c = s[i] - '0';
a += c * cnt;
cnt *= 10;
}
for (int i = 1; i <= 10; i++) {
if (check(a + i)) {
printf("%d", i);
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<string> v;
multiset<string> ms;
set<string> st;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
ms.insert(s);
st.insert(s);
}
int ans = 0;
for (auto u : st) {
ans += ms.count(u) - 1;
}
for (int i = 0; i < n; i++) {
if (ms.count(v[i]) == 1) {
continue;
}
auto it = ms.find(v[i]);
ms.erase(it);
for (int j = '0'; j <= '9'; j++) {
v[i][0] = char(j);
bool t = true;
for (int z = 0; z < n; z++) {
if (z == i) continue;
if (v[z] == v[i]) {
t = false;
break;
}
}
if (t) {
break;
}
}
}
cout << ans << endl;
for (auto u : v) {
cout << u << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int IN() {
int x = 0, f = 0, ch;
for (; (ch = getchar()) < '0' || ch > '9';) f = (ch == '-');
for (; ch >= '0' && ch <= '9'; (ch = getchar())) x = x * 10 + ch - '0';
return f ? -x : x;
}
int N, D, C, A[100005], st[100005];
map<vector<int>, int> G;
set<int> F;
map<pair<int, int>, int> H;
struct Lin {
int v, next;
} E[100005 << 1];
void Link(int u, int v) {
E[++D] = (Lin){v, st[u]};
st[u] = D;
A[u]++;
E[++D] = (Lin){u, st[v]};
st[v] = D;
A[v]++;
}
int DFS(int u, int f) {
if (H.count(make_pair(u, f))) return H[make_pair(u, f)];
vector<int> B;
for (int i = st[u], v; i; i = E[i].next)
if ((v = E[i].v) != f) B.push_back(DFS(v, u));
sort(B.begin(), B.end());
if (!G[B]) G[B] = ++C;
return H[make_pair(u, f)] = G[B];
}
int main(int argc, char* argv[]) {
N = IN();
for (int i = 2, lim = N; i <= lim; i++) Link(IN(), IN());
for (int i = 1, lim = N; i <= lim; i++)
if (A[i] < 4) F.insert(DFS(i, 0));
cout << F.size() << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
inline int read() {
int data = 0, w = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9') data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
const int maxn(1e5 + 10);
struct edge {
int next, to;
} e[maxn << 1];
int head[maxn], e_num, n, m, vis[maxn], d[maxn], deg[maxn];
std::vector<int> vec[3];
inline void add_edge(int from, int to) {
e[++e_num] = (edge){head[from], to};
head[from] = e_num, ++deg[to];
}
void Set(int x) {
vis[x] = 0;
if (!d[x]) d[x] = 1;
for (int i = head[x]; i; i = e[i].next)
if (vis[e[i].to]) Set(e[i].to);
}
int findCir(int x, int f) {
vis[x] = 1;
for (int i = head[x]; i; i = e[i].next)
if (!vis[e[i].to]) {
if (findCir(e[i].to, x)) return 1;
} else if (e[i].to != f)
return 1;
return 0;
}
int findDeg(int x, int f) {
if (f && deg[x] == 3) return d[x] = 2, 1;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != f)
if (findDeg(e[i].to, x)) {
d[x] = 2;
return 1;
}
return 0;
}
void dfs(int x, int f, std::vector<int> &v) {
v.push_back(x);
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != f) dfs(e[i].to, x, v);
}
int main() {
for (int T = read(); T--;) {
n = read(), m = read();
memset(head, 0, (n + 1) << 2), memset(vis, 0, (n + 1) << 2);
memset(d, 0, (n + 1) << 2), memset(deg, 0, (n + 1) << 2), e_num = 0;
for (int i = 1, a, b; i <= m; i++)
a = read(), b = read(), add_edge(a, b), add_edge(b, a);
int f = 0;
for (int i = 1; !f && i <= n; i++)
if (!vis[i])
if ((f = findCir(i, 0))) Set(i);
for (int i = 1; !f && i <= n; i++)
if (deg[i] > 3) {
d[i] = 2, Set(i), f = 1;
}
for (int i = 1; !f && i <= n; i++)
if (deg[i] == 3)
if ((f = findDeg(i, 0))) memset(vis, 1, sizeof vis), Set(i);
for (int i = 1; !f && i <= n; i++)
if (deg[i] == 3) {
int cur = 0;
vec[0].clear(), vec[1].clear(), vec[2].clear();
for (int j = head[i]; j; j = e[j].next) dfs(e[j].to, i, vec[cur++]);
if (vec[0].size() > vec[1].size()) std::swap(vec[0], vec[1]);
if (vec[0].size() > vec[2].size()) std::swap(vec[0], vec[2]);
if (vec[1].size() > vec[2].size()) std::swap(vec[1], vec[2]);
if (vec[1].size() == 1 ||
(vec[0].size() == 1 && vec[1].size() == 2 && vec[2].size() < 5))
continue;
f = 1;
if (vec[2].size() >= 5) {
d[i] = 6, d[vec[0][0]] = 3, d[vec[1][0]] = 4, d[vec[1][1]] = 2;
for (int j = 0; j < 5; j++) d[vec[2][j]] = 5 - j;
} else {
d[i] =
(vec[0].size() + 1) * (vec[1].size() + 1) * (vec[2].size() + 1);
for (int j = 0; j < 3; j++)
for (int k = 0; k < (int)vec[j].size(); k++)
d[vec[j][k]] = d[i] / (vec[j].size() + 1) * (vec[j].size() - k);
}
}
if (!f) {
puts("NO");
continue;
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d%c", d[i], " \n"[i == n]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
char str[100005];
struct node {
int x, y;
};
int a[100005], vis[100005], r[100005];
vector<int> aa, bb;
vector<int> t1, t2;
queue<int> tc;
int n, mm;
long long m;
void doit() {
aa.clear();
bb.clear();
memset(vis, 0, sizeof(vis));
;
scanf("%d", &n);
while (!tc.empty()) tc.pop();
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int id = 0;
int lll;
for (int i = 1; i <= n; i++)
if (a[i] == 3) {
if (id) {
aa.push_back(id);
bb.push_back(i);
}
r[i] = ++id;
if (id > n) {
puts("-1");
return;
}
aa.push_back(r[i]);
bb.push_back(i);
lll = i;
}
int ok = 0;
while (id > 0) {
for (int i = lll + 1; i <= n; i++)
if (a[i] == 2 && !vis[i]) {
if (id) {
aa.push_back(id);
bb.push_back(i);
}
vis[i] = 2;
ok = 1;
r[i] = ++id;
aa.push_back(r[i]);
bb.push_back(i);
break;
}
if (ok) break;
for (int i = lll + 1; i <= n; i++)
if (a[i] == 1 && !vis[i]) {
if (id) {
aa.push_back(id);
bb.push_back(i);
}
vis[i] = 1;
ok = 1;
r[i] = ++id;
aa.push_back(r[i]);
bb.push_back(i);
break;
}
if (!ok) {
puts("-1");
return;
}
if (ok) break;
}
for (int j = 1; j <= n; j++)
if (vis[j] == 2) {
ok = 0;
for (int i = j + 1; i <= n; i++) {
if (a[i] == 1 && !vis[i]) {
aa.push_back(id);
bb.push_back(i);
ok = 1;
id++;
vis[i] = 1;
break;
}
}
if (!ok) {
puts("-1");
return;
}
}
int sz;
int top;
for (int i = n; i >= 1; i--) {
if (vis[i]) continue;
if (a[i] == 1) {
r[i] = ++id;
aa.push_back(r[i]);
bb.push_back(i);
tc.push(i);
}
if (a[i] == 2) {
if (tc.empty()) {
puts("-1");
return;
}
top = tc.front();
tc.pop();
aa.push_back(r[top]);
bb.push_back(i);
}
}
sz = int(aa.size());
printf("%d\n", sz);
for (int i = 0; i <= sz - 1; i++) printf("%d %d\n", aa[i], bb[i]);
}
int main() { doit(); }
| 5 |
// Problem: G. Forbidden Value
// Contest: Codeforces - Educational Codeforces Round 99 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1455/problem/G
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#define int long long
#define double long double
using namespace std;
inline int read()
{
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9')
{
if (ch == '-')
w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const int MAXN = 2e5 + 10;
const int INF = 1e18;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const double PI = acos(-1.0);
int n, s;
struct Node
{
int offset;
map<int, int> mp;
multiset<int> ms;
};
vector<Node> vec;
void update(Node &node, int y, int v)
{
if (node.mp.count(y))
{
node.ms.erase(node.ms.find(node.mp[y]));
}
node.mp[y] = v;
node.ms.insert(v);
}
signed main()
{
n = read(), s = read();
int skip = 0;
vec.push_back({});
vec.back().offset = 0;
vec.back().mp[0] = 0;
vec.back().ms.insert(0);
for (int i = 0; i < n; i++)
{
string op;
int y, v;
cin >> op;
if (op[0] == 's')
{
y = read(), v = read();
if (skip) continue;
int minV = *vec.back().ms.begin() - v;
vec.back().offset += v;
if (y != s)
{
update(vec.back(), y, minV);
}
}
else if (op[0] == 'i')
{
y = read();
if (!skip && vec.back().mp.count(y))
{
int val = vec.back().mp[y] + vec.back().offset;
vec.back().ms.erase(vec.back().ms.find(vec.back().mp[y]));
vec.back().mp.erase(y);
vec.push_back({});
vec.back().offset = 0;
update(vec.back(), y, val);
}
else
{
skip++;
}
}
else
{
if (skip) skip--;
else
{
if (vec[vec.size() - 1].mp.size() > vec[vec.size() - 2].mp.size())
{
swap(vec[vec.size() - 1], vec[vec.size() - 2]);
}
auto &outer = vec[vec.size() - 2];
for (auto x : vec.back().mp)
{
if (!outer.mp.count(x.first) || (outer.offset + outer.mp[x.first] > vec.back().offset + x.second))
{
int val = vec.back().offset + x.second - outer.offset;
update(outer, x.first, val);
}
}
vec.pop_back();
}
}
}
cout << vec.back().offset + *vec.back().ms.begin() << endl;
return 0;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> sti;
char fr[33], to[33];
int pr[605][605], pt;
int main() {
int n, a, b, k, f;
scanf("%d%d%d%d%d", &n, &a, &b, &k, &f);
int prv = -1, ans = 0;
for (int i = 0; i < n; i++) {
scanf("%s%s", fr, to);
int x, y;
if (sti.count(fr))
x = sti[fr];
else {
x = pt;
sti[fr] = pt++;
}
if (sti.count(to))
y = sti[to];
else {
y = pt;
sti[to] = pt++;
}
int c = x == prv ? b : a;
ans += c;
pr[x][y] += c;
pr[y][x] += c;
prv = y;
}
priority_queue<int> pq;
for (int i = 0; i < pt; i++)
for (int j = i + 1; j < pt; j++) {
if (pr[i][j] > f) pq.emplace(pr[i][j] - f);
}
while (k-- && !pq.empty()) {
ans -= pq.top();
pq.pop();
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef class Point {
public:
int x, y;
Point() {}
Point(int x, int y) : x(x), y(y) {}
} Point;
typedef class Line {
public:
Point v;
int a, b;
double ang;
Line(Point v, int a, int b) : v(v), a(a), b(b) { ang = atan2(v.y, v.x); }
bool operator<(Line b) const { return ang < b.ang; }
} Line;
Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
const int N = 303;
int n;
Point P[N];
long long dp[N][5][N];
vector<Line> E;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &P[i].x, &P[i].y);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i ^ j) {
E.emplace_back(P[j] - P[i], i, j);
}
}
}
sort(E.begin(), E.end());
for (auto e : E) {
int a = e.a, b = e.b;
dp[b][0][a] = 1;
for (int t = 0; t < 4; t++) {
for (int c = 1; c <= n; c++) {
dp[b][t + 1][c] += dp[a][t][c];
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans += dp[i][4][i];
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
const int INF = 100000;
const int N = 22;
char st[N][N];
int n, dp[2 * N][1 << 20];
bool mark[2 * N][1 << 20];
int cnt, x[N], y[N];
int minimize(int d, int m);
int maximize(int d, int m) {
if (d == 2 * n - 2) return 0;
if (mark[d][m]) return dp[d][m];
int &cur = dp[d][m];
cur = -INF;
mark[d][m] = true;
cnt = 0;
int neig = 0;
for (int j = 0; j < n; ++j) {
if ((m >> j) & 1) {
x[cnt] = j;
y[cnt] = d - j;
int yy = d + 1 - j;
if (yy >= 0 && yy < n) neig |= (1 << j);
yy = d - j;
if (j != n - 1 && yy >= 0 && yy < n) neig |= (1 << (j + 1));
++cnt;
}
}
int mask[26];
memset(mask, 0, sizeof mask);
for (int x = 0; x <= d + 1; ++x) {
if (x >= n) break;
int y = d + 1 - x;
if (y < 0 || y >= n) continue;
mask[st[x][y] - 'a'] |= (1 << x);
}
for (int c = 0; c < 26; ++c) {
int to = (neig & mask[c]);
if (!to) continue;
if (c == 0)
cur = max(cur, minimize(d + 1, to) + 1);
else if (c == 1)
cur = max(cur, minimize(d + 1, to) - 1);
else
cur = max(cur, minimize(d + 1, to));
}
return cur;
}
int minimize(int d, int m) {
if (d == 2 * n - 2) return 0;
if (mark[d][m]) return dp[d][m];
int &cur = dp[d][m];
cur = INF;
mark[d][m] = true;
cnt = 0;
int neig = 0;
for (int j = 0; j < n; ++j) {
if ((m >> j) & 1) {
x[cnt] = j;
y[cnt] = d - j;
int yy = d + 1 - j;
if (yy >= 0 && yy < n) neig |= (1 << j);
yy = d - j;
if (j != n - 1 && yy >= 0 && yy < n) neig |= (1 << (j + 1));
++cnt;
}
}
int mask[26];
memset(mask, 0, sizeof mask);
for (int x = 0; x <= d + 1; ++x) {
if (x >= n) break;
int y = d + 1 - x;
if (y < 0 || y >= n) continue;
mask[st[x][y] - 'a'] |= (1 << x);
}
for (int c = 0; c < 26; ++c) {
int to = (neig & mask[c]);
if (!to) continue;
if (c == 0)
cur = min(cur, maximize(d + 1, to) + 1);
else if (c == 1)
cur = min(cur, maximize(d + 1, to) - 1);
else
cur = min(cur, maximize(d + 1, to));
}
return cur;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> st[i];
int coef = 0;
if (st[0][0] == 'a') coef = 1;
if (st[0][0] == 'b') coef = -1;
int res = minimize(0, 1) + coef;
if (res > 0)
puts("FIRST");
else if (res == 0)
puts("DRAW");
else
puts("SECOND");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, i, x, y, sol;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x >> y;
sol = max(sol, x + y);
}
cout << sol;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, y = 3;
cin >> n;
n = n / 2;
y = y * n;
cout << y;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int t, i, min;
cin >> t;
while (t--) {
cin >> str;
int count_0 = 0, count_1 = 0;
for (i = 0; i < str.length(); i++) {
if (str[i] == '0') {
count_0++;
} else {
count_1++;
}
}
if (count_0 > count_1) {
min = count_1;
} else {
min = count_0;
}
if (min % 2 == 0) {
cout << "NET"
<< "\n";
} else {
cout << "DA"
<< "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
const double EPS = 1e-8;
using namespace std;
int main() {
int n, w, m;
while (cin >> n >> w >> m) {
bool ok = true;
double target = (double)n * w / m;
vector<double> p(m, 0.0);
vector<vector<pair<int, double> > > ans(m);
for (int i = 0; i < (int)n; i++) {
double left = w;
int cnt = 0;
while (left > EPS) {
for (int j = 0; j < (int)m; j++) {
if (p[j] + EPS < target) {
if (target - p[j] > left + EPS) {
p[j] += left;
ans[j].push_back(make_pair(i, left));
left = 0;
break;
} else {
left -= (target - p[j]);
ans[j].push_back(make_pair(i, target - p[j]));
p[j] = target;
break;
}
}
}
cnt++;
if (cnt > 2) break;
}
if (cnt > 2) {
ok = false;
break;
}
}
if (ok) {
puts("YES");
for (int i = 0; i < (int)m; i++) {
for (int j = 0; j < (int)ans[i].size(); j++) {
if (j != 0) putchar(' ');
printf("%d %.8f", ans[i][j].first + 1, ans[i][j].second);
}
cout << endl;
}
} else {
puts("NO");
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T max1(T a, T b, T c) {
return max1(max1(a, b), c);
}
template <class T>
inline T max1(T a, T b, T c, T d) {
return max1(max1(a, b, c), d);
}
template <class T>
inline T max1(T a, T b, T c, T d, T e) {
return max1(max1(a, b, c, d), e);
}
template <class T>
inline T min1(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T min1(T a, T b, T c) {
return min1(min1(a, b), c);
}
template <class T>
inline T min1(T a, T b, T c, T d) {
return min1(min1(a, b, c), d);
}
template <class T>
inline T min1(T a, T b, T c, T d, T e) {
return min1(min1(a, b, c, d), e);
}
template <class T>
inline T lowb(T num) {
return num & (-num);
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / abs1(a) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename t>
inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
inline int bitnum(unsigned int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(unsigned long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitnum(long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitmaxl(unsigned int a) {
if (a) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
if (a) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(unsigned long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
inline int bitmaxl(long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
long long pow(long long n, long long m, long long mod = 0) {
if (m < 0) return 0;
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int maxn = 300100;
char str[maxn];
int dp[maxn];
int nxt[maxn][30];
long long cnt[30];
int l;
int main() {
ios_base::sync_with_stdio(0);
scanf("%s", str);
l = strlen(str);
memset(nxt, -1, sizeof(nxt));
for (int i = l - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][str[i] - 'a'] = i;
}
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < l; i++) {
int arr[30];
for (int j = 0; j < 26; j++) {
arr[j] = nxt[i][j];
if (arr[j] == -1) arr[j] = l;
}
sort(arr, arr + 26);
arr[26] = l;
for (int j = 0; j <= 25; j++) cnt[j + 1] += arr[j + 1] - arr[j];
}
int lans = 26;
for (; cnt[lans] == 0; lans--)
;
printf("%d\n", lans);
for (int i = 1; i <= lans; i++) printf("%I64d\n", cnt[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 53, INF = 1e18, MOD = 1e9 + 7;
long long dis[N][N][2], way[N][N][2];
long long POW(long long a, long long b) {
if (b == 0) return 1;
long long ans = POW(a, b / 2);
ans *= ans;
ans %= MOD;
if (b % 2) ans *= a;
ans %= MOD;
return ans;
}
long long C(long long a, long long b) {
if (b == 0) return 1;
long long ans = 1, res = 1;
for (long long i = b - a + 1; i <= b; i++) ans *= i, ans %= MOD;
for (long long i = 1; i <= a; i++) res *= i, res %= MOD;
return (ans * POW(res, MOD - 2)) % MOD;
}
inline void BFS(long long a, long long b, long long k) {
queue<pair<pair<long long, long long>, bool> > q;
for (long long i = 0; i <= a; i++)
for (long long j = 0; j <= b; j++) dis[i][j][0] = dis[i][j][1] = INF;
dis[a][b][0] = 0;
way[a][b][0] = 1;
q.push({{a, b}, 0});
while (!q.empty()) {
long long x = q.front().first.first, y = q.front().first.second,
t = q.front().second;
q.pop();
if (t) {
x = a - x;
y = b - y;
}
for (long long i = 0; i <= x; i++) {
for (long long j = 0; j <= y; j++) {
if (i + j > 0 && i * 50 + j * 100 <= k) {
long long nx, ny;
if (t) {
x = a - x;
y = b - y;
nx = x + i, ny = y + j;
} else {
nx = x - i, ny = y - j;
}
if (dis[nx][ny][!t] > dis[x][y][t] + 1) {
dis[nx][ny][!t] = dis[x][y][t] + 1;
q.push({{nx, ny}, !t});
}
if (dis[nx][ny][!t] == dis[x][y][t] + 1) {
if (t)
way[nx][ny][!t] +=
(way[x][y][t] * C(i, a - x) * C(j, b - y)) % MOD;
else
way[nx][ny][!t] += (way[x][y][t] * C(i, x) * C(j, y)) % MOD;
way[nx][ny][!t] %= MOD;
}
if (t) {
x = a - x;
y = b - y;
}
}
}
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
long long a = 0, b = 0;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
if (x == 50)
a++;
else
b++;
}
BFS(a, b, k);
if (dis[0][0][1] >= INF)
cout << -1 << endl << 0;
else
cout << dis[0][0][1] << endl << way[0][0][1];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, k, q, p;
scanf("%d", &n);
int A[120][120];
int B[120], C[120];
memset(B, 0, sizeof(B));
memset(C, 0, sizeof(C));
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
char ch;
do {
scanf("%c", &ch);
} while ((ch != 'E') && (ch != '.'));
if (ch == 'E')
A[i][j] = 0;
else {
A[i][j] = 1;
B[i] = 1;
C[j] = 1;
}
}
j = 0;
for (i = 0; i < n; i++) j += B[i];
if (j == n) {
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (A[i][j] == 1) break;
printf("%d %d\n", i + 1, j + 1);
}
return 0;
}
j = 0;
for (i = 0; i < n; i++) j += C[i];
if (j == n) {
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (A[j][i] == 1) break;
printf("%d %d\n", j + 1, i + 1);
}
return 0;
}
printf("-1\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long L[10005];
long long R[10005];
char ASK[10005][20];
long long ask[10005];
int len[10005];
void deal(long long &a, char str[]) {
int i, tlen = strlen(str);
a = 0;
long long pls = 1;
for (i = tlen - 1; i >= 4; i--) {
a += ((str[i] - '0') * pls);
pls *= 10;
}
}
void Init(int n) {
int i;
for (i = 0; i < n; i++) {
len[i] = strlen(ASK[i]) - 4;
deal(ask[i], ASK[i]);
}
}
void solve() {
int i;
long long pls = 10;
L[1] = 1989;
R[1] = 1998;
for (i = 2; i <= 9; i++) {
L[i] = L[i - 1] + pls;
pls *= 10;
R[i] = L[i] + pls - 1;
}
}
int main() {
int n, i;
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) {
scanf("%s", ASK[i]);
}
Init(n);
solve();
for (i = 0; i < n; i++) {
long long v = ask[i];
if (len[i] == 1) {
if (v == 9) {
cout << 1989 << endl;
} else {
cout << "199";
printf("%d\n", v);
}
} else if (len[i] == 2) {
if (v == 99) {
cout << 1999 << endl;
} else {
cout << "20";
printf("%02d\n", v);
}
} else if (len[i] == 3) {
if (v == 99) {
cout << 2099 << endl;
} else if (100 <= v && v <= 999) {
cout << "2";
printf("%03d\n", v);
} else {
cout << "3";
printf("%03d\n", v);
}
} else if (len[i] == 4) {
if (v <= 3098) {
cout << "1";
printf("%04d\n", v);
} else {
printf("%04d\n", v);
}
} else if (len[i] == 5) {
if (v <= 13098) {
cout << "1";
printf("%05d\n", v);
} else {
printf("%05d\n", v);
}
} else if (len[i] == 6) {
if (v <= 113098) {
cout << "1";
printf("%06d\n", v);
} else {
printf("%06d\n", v);
}
} else if (len[i] == 7) {
if (v <= 1113098) {
cout << "1";
printf("%07d\n", v);
} else {
printf("%07d\n", v);
}
} else if (len[i] == 8) {
if (v <= 11113098) {
cout << "1";
printf("%08d\n", v);
} else {
printf("%08d\n", v);
}
} else if (len[i] == 9) {
if (v <= 111113098) {
cout << "1";
printf("%09d\n", v);
} else {
printf("%09d\n", v);
}
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int new_pow(int a, int b, int c) {
long long tmp = a;
while (b > 0) {
if (b % 2) c = (c * tmp) % 1000000007;
b >>= 1;
tmp = (tmp * tmp) % 1000000007;
}
return c;
}
int main() {
int n, k;
cin >> n >> k;
int ans;
ans = new_pow(n - k, n - k, 1);
ans = new_pow(k, k - 1, ans);
cout << ans << endl;
;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 155, MOD = 1e9 + 7;
int64_t dp[2][4][NMAX][NMAX];
int64_t sdp[2][4][NMAX][NMAX];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int64_t ans = 0;
for (int i = 1, u = 1; i <= n; ++i, u ^= 1) {
memset(dp[u], 0, sizeof dp[u]);
memset(sdp[u], 0, sizeof sdp[u]);
for (int p = 0; p < 4; ++p) {
for (int j = 1; j <= m; ++j) {
for (int k = j; k <= m; ++k) {
dp[u][p][j][k] = (sdp[u ^ 1][p][j][k] + (p == 0)) % MOD;
ans = (ans + dp[u][p][j][k]) % MOD;
}
}
}
for (int j = m; j > 0; --j) {
for (int k = j; k <= m; ++k) {
sdp[u][0][j][k] = sdp[u][0][j + 1][k] + sdp[u][0][j][k - 1] -
sdp[u][0][j + 1][k - 1] + dp[u][0][j][k];
sdp[u][0][j][k] %= MOD;
}
}
for (int j = 1; j <= m; ++j) {
for (int k = j; k <= m; ++k) {
sdp[u][1][j][k] = sdp[u][1][j - 1][k] + sdp[u][1][j][k - 1] -
sdp[u][1][j - 1][k - 1] + dp[u][1][j][k] +
dp[u][0][j - 1][k];
sdp[u][1][j][k] %= MOD;
}
}
for (int j = m; j > 0; --j) {
for (int k = m; k >= j; --k) {
sdp[u][2][j][k] = sdp[u][2][j + 1][k] + sdp[u][2][j][k + 1] -
sdp[u][2][j + 1][k + 1] + dp[u][2][j][k] +
dp[u][0][j][k + 1];
sdp[u][2][j][k] %= MOD;
}
}
for (int j = 1; j <= m; ++j) {
for (int k = m; k >= j; --k) {
sdp[u][3][j][k] = sdp[u][3][j - 1][k] + sdp[u][3][j][k + 1] -
sdp[u][3][j - 1][k + 1] + dp[u][3][j][k] +
dp[u][0][j - 1][k + 1] + dp[u][1][j][k + 1] +
dp[u][2][j - 1][k];
sdp[u][3][j][k] %= MOD;
}
}
}
ans %= MOD;
if (ans < 0) ans += MOD;
cout << ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
void solve(int x) {
for (int i = (x); i >= (1); i--) printf("%d %d\n", i, x + 1);
for (int i = (x); i >= (1); i--) printf("%d %d\n", i, x + 2);
printf("%d %d\n", x + 1, x + 3), printf("%d %d\n", x + 2, x + 4);
for (int i = (1); i <= (x); i++) printf("%d %d\n", i, x + 4);
for (int i = (1); i <= (x); i++) printf("%d %d\n", i, x + 3);
printf("%d %d\n", x + 1, x + 4), printf("%d %d\n", x + 2, x + 3);
printf("%d %d\n", x + 1, x + 2), printf("%d %d\n", x + 3, x + 4);
}
int main() {
int n;
scanf("%d", &n);
if (n % 4 == 2 || n % 4 == 3) {
puts("NO");
return 0;
}
puts("YES");
for (int x = n % 4; x < n; x += 4) solve(x);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int r() {
int xy;
scanf("%d", &xy);
return xy;
}
bool odw[1000007];
const int mod = 1000000007;
long long ile[1000007];
long long cc[1000007];
long long dp[1000007];
int main() {
long long wyn = 1;
int p, k;
scanf("%d%d", &p, &k);
for (int i = 0; i < p; i++) {
if (!odw[i]) {
int dl = 0;
long long akt = i;
while (!odw[akt]) {
odw[akt] = 1;
akt = ((long long)k * akt) % p;
dl++;
}
cc[dl]++;
}
}
for (int i = 1; i <= p; i++) {
dp[i] = ((long long)cc[i] * i) % mod;
}
for (int i = 1; i <= p; i++) {
ile[i] = (ile[i] + dp[i]) % mod;
for (int j = i + i; j <= p; j += i) {
ile[j] = (dp[i] + ile[j]) % mod;
}
}
for (int i = 1; i <= p; i++) {
if (i == 1) {
for (int j = 0; j < cc[i] - 1; j++) wyn = (wyn * (long long)cc[i]) % mod;
} else {
for (int j = 0; j < cc[i]; j++) wyn = (wyn * (long long)ile[i]) % mod;
}
}
if (k == 1) wyn = (wyn * ile[1]) % mod;
printf("%d", (int)wyn);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int V = 100010;
const int E = 400040;
int head[V], nxt[E], cur[E], ne;
inline void addEdge(int u, int v) {
cur[ne] = v, nxt[ne] = head[u];
head[u] = ne++;
}
bool vist[V];
int dist[V];
bool solved(int n, int m, int s, int t) {
priority_queue<pair<int, int> > q;
memset(dist, 0x3f, n << 2);
dist[s] = 0;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<int, int> tmp = q.top();
q.pop();
if (tmp.second == t) {
return true;
}
if (tmp.first != -dist[tmp.second]) {
continue;
}
if (vist[tmp.second]) {
dist[tmp.second] = 0;
} else if (dist[tmp.second] == m) {
continue;
}
for (int i = head[tmp.second]; i; i = nxt[i]) {
int v = cur[i];
if (dist[v] > dist[tmp.second] + 1) {
dist[v] = dist[tmp.second] + 1;
q.push(make_pair(-dist[v], v));
}
}
}
return false;
}
int main() {
int n, m, k, s, t, u, v;
ne = 1;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; ++i) {
scanf("%d", &u);
vist[u] = true;
}
for (int i = 0; i < m; ++i) {
scanf("%d %d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
scanf("%d %d", &s, &t);
int l = 1, r = n;
while (l < r) {
int m = (l + r) >> 1;
if (solved(n + 1, m, s, t)) {
r = m;
} else {
l = m + 1;
}
}
printf("%d\n", (r == n) ? -1 : r);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Nn = 1e5 + 5;
struct node {
int v, s, id, h;
node() {}
node(int a, int b, int c) {
v = a;
s = b;
id = c;
h = 0;
}
bool operator<(const node &a) const {
if (h == a.h)
return h > a.h;
else if (v == a.v)
return s > a.s;
else
return v > a.v;
}
};
int v[Nn], s[Nn];
int n;
priority_queue<node> q;
struct point {
int x, y;
} e[Nn];
int m = 0;
int main() {
cin >> n;
node t;
for (int i = 0; i < n; i++) {
scanf("%d%d", &t.v, &t.s);
t.id = i;
if (t.v == 1) q.push(t);
v[i] = t.v;
s[i] = t.s;
}
int mv, ms;
while (!q.empty()) {
t = q.top();
q.pop();
mv = v[t.id];
ms = s[t.id];
if (mv == 1) {
s[ms] ^= t.id;
e[++m].x = t.id;
e[m].y = ms;
v[ms]--;
if (v[ms] == 1) {
q.push(node(v[ms], s[ms], ms));
}
} else if (mv == 0) {
continue;
} else {
t.v = v[t.id];
t.s = s[t.id];
t.h++;
q.push(t);
}
}
cout << m << endl;
for (int i = 1; i <= m; i++) {
printf("%d %d\n", e[i].x, e[i].y);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
long long a, b, c, s;
cin >> T;
while (T--) {
cin >> a >> b >> c >> s;
if (s - a * c < 0) {
s %= c;
if (b >= s) {
cout << "YES\n";
} else
cout << "NO\n";
} else if (s - a * c == 0) {
cout << "YES\n";
} else {
s -= a * c;
if (b >= s) {
cout << "YES\n";
} else
cout << "NO\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
long long lcm(long long x, long long y) { return x / gcd(x, y) * y; }
long long binpow(long long a, long long p) {
if (!p) return 1;
long long g = binpow(a, p >> 1);
if (p % 2 == 0)
return (g * g) % 1000000007;
else
return (((g * g) % 1000000007) * a) % 1000000007;
}
long long rev(long long n) { return binpow(n, (long long)1000000007 - 2LL); }
void solve(int test_number);
int main() {
cout.setf(ios::fixed);
cout.precision(20);
cerr.setf(ios::fixed);
cerr.precision(3);
int n = 1;
for (int i = 0; i < n; ++i) solve(i + 1);
}
long long sa, sb;
int n;
int cnt;
long long cur[100100];
long long a[100100];
int sz = 0;
void solve(int test_number) {
sa = sb = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> cnt;
for (int j = 0; j < cnt; j++) {
cin >> cur[j];
}
for (int j = 0; j < cnt / 2; j++) sa += cur[j];
for (int j = cnt / 2 + cnt % 2; j < cnt; j++) sb += cur[j];
if (cnt % 2 == 1) {
a[sz] = cur[cnt / 2];
sz++;
}
}
sort(a, a + sz, greater<int>());
for (int i = 0; i < sz; i++)
if (i % 2 == 0)
sa += a[i];
else
sb += a[i];
cout << sa << ' ' << sb << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 444444;
pair<int, int> a[N];
int b[N], ans[N];
int n, h, i, k;
int main() {
scanf("%d %d", &n, &h);
for (i = 0; i < n; i++) {
int foo;
scanf("%d", &foo);
a[i] = make_pair(foo, i + 1);
}
sort(a, a + n);
for (i = 0; i < n; i++) b[i] = a[i].first;
int diff = (b[n - 1] + b[n - 2]) - (b[0] + b[1]);
int km = 0;
for (k = 1; k < n; k++) {
int other;
int small = (int)1e9;
if (k >= 2) {
other = b[1] + b[2];
if (other < small) small = other;
}
other = b[0] + b[1] + h;
if (other < small) small = other;
if (k < n - 1) {
other = b[0] + b[k + 1];
if (other < small) small = other;
}
int big = b[n - 1] + h;
if (k == n - 1)
big += b[0];
else
big += b[k];
other = b[n - 1] + b[n - 2];
if (other > big) big = other;
if (big - small < diff) {
diff = big - small;
km = k;
}
}
printf("%d\n", diff);
for (i = 1; i <= n; i++) ans[i] = 1;
for (i = 1; i <= km; i++) ans[a[i].second] = 2;
for (i = 1; i < n; i++) printf("%d ", ans[i]);
printf("%d\n", ans[n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
constexpr ll inf = 1000000000;
constexpr ll mod = 1000000007;
constexpr long double eps = 1e-15;
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2> p) {
os << to_string(p.first) << " " << to_string(p.second);
return os;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (ll i = 0; i < (int)v.size(); i++) {
if (i) os << " ";
os << to_string(v[i]);
}
return os;
}
struct modint {
ll n;
public:
modint(const ll n = 0) : n((n % mod + mod) % mod) {}
static modint pow(modint a, int m) {
modint r = 1;
while (m > 0) {
if (m & 1) {
r *= a;
}
a = (a * a);
m /= 2;
}
return r;
}
modint& operator++() {
*this += 1;
return *this;
}
modint& operator--() {
*this -= 1;
return *this;
}
modint operator++(int) {
modint ret = *this;
*this += 1;
return ret;
}
modint operator--(int) {
modint ret = *this;
*this -= 1;
return ret;
}
modint operator~() const { return (this->pow(n, mod - 2)); }
friend bool operator==(const modint& lhs, const modint& rhs) {
return lhs.n == rhs.n;
}
friend bool operator<(const modint& lhs, const modint& rhs) {
return lhs.n < rhs.n;
}
friend bool operator>(const modint& lhs, const modint& rhs) {
return lhs.n > rhs.n;
}
friend modint& operator+=(modint& lhs, const modint& rhs) {
lhs.n += rhs.n;
if (lhs.n >= mod) lhs.n -= mod;
return lhs;
}
friend modint& operator-=(modint& lhs, const modint& rhs) {
lhs.n -= rhs.n;
if (lhs.n < 0) lhs.n += mod;
return lhs;
}
friend modint& operator*=(modint& lhs, const modint& rhs) {
lhs.n = (lhs.n * rhs.n) % mod;
return lhs;
}
friend modint& operator/=(modint& lhs, const modint& rhs) {
lhs.n = (lhs.n * (~rhs).n) % mod;
return lhs;
}
friend modint operator+(const modint& lhs, const modint& rhs) {
return modint(lhs.n + rhs.n);
}
friend modint operator-(const modint& lhs, const modint& rhs) {
return modint(lhs.n - rhs.n);
}
friend modint operator*(const modint& lhs, const modint& rhs) {
return modint(lhs.n * rhs.n);
}
friend modint operator/(const modint& lhs, const modint& rhs) {
return modint(lhs.n * (~rhs).n);
}
};
istream& operator>>(istream& is, modint m) {
is >> m.n;
return is;
}
ostream& operator<<(ostream& os, modint m) {
os << m.n;
return os;
}
long long extgcd(long long a, long long b, long long& x, long long& y) {
long long d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
long long mod_inverse(long long a, long long m) {
long long x, y;
if (extgcd(a, m, x, y) == 1)
return (m + x % m) % m;
else
return -1;
}
vector<long long> fact(3030303 + 1, inf);
long long mod_fact(long long n, long long& e) {
if (fact[0] == inf) {
fact[0] = 1;
if (3030303 != 0) fact[1] = 1;
for (ll i = 2; i <= 3030303; ++i) {
fact[i] = (fact[i - 1] * i) % mod;
}
}
e = 0;
if (n == 0) return 1;
long long res = mod_fact(n / mod, e);
e += n / mod;
if ((n / mod) % 2 != 0) return (res * (mod - fact[n % mod])) % mod;
return (res * fact[n % mod]) % mod;
}
long long mod_comb(long long n, long long k) {
if (n < 0 || k < 0 || n < k) return 0;
long long e1, e2, e3;
long long a1 = mod_fact(n, e1), a2 = mod_fact(k, e2),
a3 = mod_fact(n - k, e3);
if (e1 > e2 + e3) return 0;
return (a1 * mod_inverse((a2 * a3) % mod, mod)) % mod;
}
using mi = modint;
mi mod_pow(mi a, ll n) {
mi ret = 1;
mi tmp = a;
while (n > 0) {
if (n % 2) ret *= tmp;
tmp = tmp * tmp;
n /= 2;
}
return ret;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<vector<int>> d;
vector<vector<int>> ch;
vector<vector<int>> g;
int dfs(int v, int p, int de, int root) {
d[v][root] = de;
d[root][v] = de;
int ret = 1;
for (ll i = 0; i < (int)g[v].size(); i++) {
if (g[v][i] == p) continue;
ch[v][g[v][i]] = dfs(g[v][i], v, de + 1, root);
ret += ch[v][g[v][i]];
}
return ret;
}
vector<vector<ll>> memo;
ll dp(ll x, ll y) {
if (memo[x][y] != -1) return memo[x][y];
if (x == y) {
return memo[x][y] = 0;
}
ll ret = 0;
ll k1 = 0, k2 = 0, mx = 0;
for (ll i = 0; i < (int)g[x].size(); i++) {
if (d[x][y] > d[g[x][i]][y]) {
k1 = ch[g[x][i]][x];
} else {
mx = max(mx, dp(g[x][i], y));
}
}
for (ll i = 0; i < (int)g[y].size(); i++) {
if (d[y][x] > d[g[y][i]][x]) {
k2 = ch[g[y][i]][y];
} else {
mx = max(mx, dp(x, g[y][i]));
}
}
ret += k1 * k2 + mx;
return memo[x][y] = ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
g.resize(n);
d.assign(n, vector<int>(n, 0));
ch.assign(n, vector<int>(n, 0));
memo.assign(n, vector<ll>(n, -1));
for (ll i = 0; i < (int)n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
for (ll i = 0; i < (int)n; i++) {
dfs(i, -1, 0, i);
}
ll ans = 0;
for (ll i = 0; i < (int)n; i++)
for (ll j = 0; j < (int)n; j++) ans = max(ans, dp(i, j));
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
n = 2 * n;
int ar[n + 10];
int i, j, k, cnt = 0, mx = 0;
for (i = 1; i <= n; i++) {
cin >> ar[i];
if (ar[i] % 2 == 0)
cnt++;
else
mx++;
}
int e = 0, oo = 0;
if (cnt >= (n - 2)) {
for (i = 1; i <= n; i++) {
if (ar[i] % 2 == 0) {
cout << i;
e++;
if (e % 2 == 0)
cout << endl;
else
cout << " ";
}
if (e == (n - 2)) break;
}
} else if (mx >= (n - 2)) {
for (i = 1; i <= n; i++) {
if (ar[i] % 2 == 1) {
cout << i;
e++;
if (e % 2 == 0)
cout << endl;
else
cout << " ";
}
if (e == (n - 2)) break;
}
} else {
if (cnt % 2 == 1) cnt--;
if (mx % 2 == 1) mx--;
for (i = 1; i <= n; i++) {
if (ar[i] % 2 == 1) {
cout << i;
e++;
if (e % 2 == 0)
cout << endl;
else
cout << " ";
}
if (e == mx) break;
}
k = e;
e = 0;
for (i = 1; i <= n; i++) {
if (ar[i] % 2 == 0) {
cout << i;
e++;
if (e % 2 == 0)
cout << endl;
else
cout << " ";
}
if (e == cnt || (k + e) == n - 2) break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l;
cin >> l;
string s;
cin >> s;
if (l < 26) {
cout << "NO\n";
return 0;
}
int f[26] = {};
for (int i = 0; i < l; i++) f[tolower(s[i]) - 'a']++;
for (int i = 0; i < 26; i++)
if (f[i] == 0) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long N, M;
int p[1000005];
bool f[1000005];
int cal(int m) {
int n = 1;
while (m) {
n <<= 1;
m >>= 1;
}
return n - 1;
}
int main() {
int i, j;
cin >> N;
M = (1 + N) * N;
cout << M << endl;
(memset(p, 0, sizeof(p)));
(memset(f, 0, sizeof(f)));
for (i = N; i >= 0; --i) {
if (f[i]) continue;
j = cal(i) - i;
;
p[i] = j;
p[j] = i;
f[i] = f[j] = 1;
}
for (i = 0; i <= N; ++i) printf("%d ", p[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, k, t;
int main() {
cin >> n >> m >> k;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) cin >> t;
cout << m * (m - 1) / 2 << endl;
if (k == 0) {
for (i = m - 1; i >= 0; --i)
for (j = 0; j < i; ++j) cout << j + 1 << ' ' << j + 2 << endl;
} else {
for (i = m - 1; i >= 0; --i)
for (j = 0; j < i; ++j) cout << j + 2 << ' ' << j + 1 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long sum = 0, ff = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') sum = sum * 10 + ch - '0', ch = getchar();
return sum * ff;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e5 + 7;
int n;
long long a[N];
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
if (n == 1) {
puts("1 1");
write(-a[n]), puts("");
puts("1 1");
puts("0");
puts("1 1");
puts("0");
return 0;
}
write(1), printf(" "), write(n - 1), puts("");
for (int i = 1; i <= n - 1; i++)
write(a[i] * (n - 1)), printf(" "), a[i] *= n;
puts("");
write(n), printf(" "), write(n), puts("");
write(-(a[n] % n)), a[n] -= (a[n] % n), puts("");
write(1), printf(" "), write(n), puts("");
for (int i = 1; i <= n; i++) write(-a[i]), printf(" ");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
const long long int inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI = acos(-1);
long long int i, j, k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a - b) < eps; }
inline long long int power(long long int x, long long int n,
long long int m = LLONG_MAX) {
long long int res = 1;
x = (x % m + m) % m;
while (n) {
if (n & 1) res = (res * x) % m;
x = (x * x) % m;
n >>= 1;
}
return res;
}
long long int fact[2000];
long long int modinv(long long int x) { return power(x, mod - 2, mod); }
long long int ncr(long long int n, long long int r) {
if (n < 0 || r < 0 || n < r) return 0;
if (n == r || r == 0) return 1;
long long int p = fact[n], q = fact[n - r];
q *= fact[r];
q %= mod;
p *= modinv(q);
p %= mod;
return p;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
int t = 1;
fact[0] = 1;
for (i = (1); i <= (1500); ++i) fact[i] = (fact[i - 1] * i) % mod;
while (t--) solve();
return 0;
}
long long int dp[1005], n, a[1005];
long long int compute(int idx) {
if (idx == n + 1) return 0;
if (a[idx] <= 0) return 0;
if (dp[idx] != -1) return dp[idx];
int l = a[idx] + 1, i;
long long int val = 0;
for (i = (idx + l - 1); i <= (n); ++i) {
long long int t = ncr(i - idx, l - 1) * (compute(i + 1));
t %= mod;
val += t;
val %= mod;
}
val += ncr(n - idx, l - 1);
val %= mod;
return dp[idx] = val;
}
void solve() {
cin >> n;
for (i = (1); i <= (n); ++i) cin >> a[i];
memset(dp, -1, sizeof(dp));
long long int ans = 0;
for (i = (1); i <= (n); ++i) {
ans += compute(i);
ans %= mod;
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const int InfCost = 3002;
struct MinimumCostMaximumFlow {
static const int InfCapacity = 10;
struct Edge {
int to;
int rev;
int capacity;
int cost;
};
vector<vector<Edge> > g;
void init(int n) { g.assign(n, vector<Edge>()); }
void add(int i, int j, int capacity = InfCapacity, int cost = int()) {
Edge e, f;
e.to = j, f.to = i;
e.capacity = capacity, f.capacity = 0;
e.cost = cost, f.cost = -cost;
g[i].push_back(e);
g[j].push_back(f);
g[i].back().rev = (int)g[j].size() - 1;
g[j].back().rev = (int)g[i].size() - 1;
}
void addB(int i, int j, int capacity = InfCapacity, int cost = int()) {
add(i, j, capacity, cost);
add(j, i, capacity, cost);
}
pair<int, int> minimumCostMaximumFlow(int s, int t, int f = InfCapacity,
bool bellmanFord = false) {
int n = g.size();
vector<int> dist(n);
vector<int> prev(n);
vector<int> prevEdge(n);
pair<int, int> total = make_pair(0, 0);
vector<int> potential(n);
while (f > 0) {
fill(dist.begin(), dist.end(), InfCost);
if (bellmanFord || total.second == 0) {
dist[s] = 0;
for (int k = 0; k < n; k++) {
bool update = false;
for (int i = 0; i < n; i++)
if (dist[i] != InfCost)
for (int ei = 0; ei < (int)g[i].size(); ei++) {
const Edge &e = g[i][ei];
if (e.capacity <= 0) continue;
int j = e.to;
int d = dist[i] + e.cost;
if (dist[j] > d) {
dist[j] = d;
prev[j] = i;
prevEdge[j] = ei;
update = true;
}
}
if (!update) break;
}
} else {
vector<bool> vis(n);
priority_queue<pair<int, int> > q;
q.push(make_pair(-0, s));
dist[s] = 0;
while (!q.empty()) {
int i = q.top().second;
q.pop();
if (vis[i]) continue;
vis[i] = true;
for (int ei = 0; ei < (int)g[i].size(); ei++) {
const Edge &e = g[i][ei];
if (e.capacity <= 0) continue;
int j = e.to;
int d = dist[i] + e.cost + potential[i] - potential[j];
if (d < dist[i]) d = dist[i];
if (dist[j] > d) {
dist[j] = d;
prev[j] = i;
prevEdge[j] = ei;
q.push(make_pair(-d, j));
}
}
}
}
if (dist[t] == InfCost) break;
if (!bellmanFord)
for (int i = 0; i < n; i++) potential[i] += dist[i];
int d = f;
int distt = 0;
for (int v = t; v != s;) {
int u = prev[v];
const Edge &e = g[u][prevEdge[v]];
d = min(d, e.capacity);
distt += e.cost;
v = u;
}
f -= d;
total.first += d * distt;
total.second += d;
for (int v = t; v != s; v = prev[v]) {
Edge &e = g[prev[v]][prevEdge[v]];
e.capacity -= d;
g[e.to][e.rev].capacity += d;
}
}
return total;
}
};
int n, arr[3002];
int last1[100005], last2[10];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
MinimumCostMaximumFlow mcmf;
mcmf.init(1 + 1 + 2 * n + 1);
int src = 0, sink = 1 + 1 + 2 * n;
mcmf.add(src, 1, 4, 0);
for (int i = 1; i <= n; i++) {
mcmf.add(1 + i, 1 + n + i, 1, -1);
mcmf.add(1, 1 + i, 1, 0);
mcmf.add(1 + n + i, sink, 1, 0);
}
memset(last1, -1, sizeof(last1));
memset(last2, -1, sizeof(last2));
for (int i = n; i >= 1; i--) {
if (last1[arr[i]] != -1) mcmf.add(1 + i, 1 + last1[arr[i]], n + 2, 0);
if (last2[arr[i] % 7] != -1)
mcmf.add(1 + i, 1 + last2[arr[i] % 7], n + 2, 0);
if (last1[arr[i] - 1] != -1)
mcmf.add(1 + n + i, 1 + last1[arr[i] - 1], 1, 0);
if (last1[arr[i] + 1] != -1)
mcmf.add(1 + n + i, 1 + last1[arr[i] + 1], 1, 0);
if (last2[arr[i] % 7] != -1)
mcmf.add(1 + n + i, 1 + last2[arr[i] % 7], 1, 0);
last1[arr[i]] = i;
last2[arr[i] % 7] = i;
}
cout << -mcmf.minimumCostMaximumFlow(src, sink, 4, true).first;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long gcd(unsigned long long a, unsigned long long b) {
return (b == 0 ? a : gcd(b, a % b));
}
long long n, m, r, z, x, l, k, a, h, res, tmp;
string s;
vector<vector<long long> > g;
void solve() {
res = 0;
tmp = 0;
cin >> n >> m;
long long v1[n + 2];
long long v2[n + 2];
long long sum[n + 2];
for (int i = 1; i <= n; i++) cin >> v1[i];
for (int i = 1; i <= n; i++) cin >> v2[i];
for (int i = 1; i <= n; i++)
if (v2[i] == 0)
sum[i] = sum[i - 1] + v1[i];
else
sum[i] = sum[i - 1], res += v1[i];
for (int i = m; i <= n; i++) tmp = max(tmp, sum[i] - sum[i - m]);
cout << res + tmp;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, long long> a[100010];
long long pow4[40];
void preprocess() {
for (int i = 1; i < 32; i++) pow4[i] = pow(4, (double)i);
}
bool comp(pair<int, long long> a, pair<int, long long> b) {
return a.first < b.first;
}
int main() {
preprocess();
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a, a + n, comp);
for (int i = 0; i < n - 1; i++) {
int d = a[i + 1].first - a[i].first;
if (d > 14)
a[i].second = 0;
else
a[i].second -= a[i + 1].second * pow4[d];
if (a[i].second > 0)
a[i + 1].second += (a[i].second % pow4[d] == 0)
? (a[i].second / pow4[d])
: (a[i].second / pow4[d]) + 1;
}
for (int i = 1; i < 32; i++)
if (pow4[i] >= a[n - 1].second) {
cout << a[n - 1].first + i << endl;
break;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T& first) {
return first * first;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const double EPS = 1 - 9;
char TEMPORARY_CHAR;
const int INF = 1e9;
inline void input(int& a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = 10 * a + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline void out(int a) {
if (!a) putchar('0');
if (a < 0) {
putchar('-');
a = -a;
}
char s[10];
int i;
for (i = 0; a; ++i) {
s[i] = '0' + a % 10;
a /= 10;
}
for (int j = (i)-1; j >= 0; j--) putchar(s[j]);
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
struct et {
int t, l, r;
};
int main() {
int r, h;
cin >> r >> h;
h *= 2, r *= 2;
h -= r / 2;
if (h < 0) {
cout << "1" << endl;
return 0;
}
int ans = 2 * (h / r + 1);
int m = h % r;
if (m + r > 0.5 * (sqrt(3.0L) + 1) * r) ans++;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool remin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool remax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int nxt() {
int first;
scanf("%d", &first);
return first;
}
long long gcd(long long a, long long b) {
a = abs(a);
b = abs(b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
struct pt {
long double first, second;
pt() {}
pt(long double first, long double second) : first(first), second(second) {}
inline pt operator-(const pt &r) const {
return pt(first - r.first, second - r.second);
}
inline pt operator+(const pt &r) const {
return pt(first + r.first, second + r.second);
}
inline pt operator*(const long double &r) const {
return pt(first * r, second * r);
}
inline long double sqlen() const {
return abs(first * first + second * second);
}
inline long double len() const { return sqrt(sqlen()); }
inline bool operator<(const pt &r) const {
if (first != r.first) return first < r.first;
return second < r.second;
}
inline bool operator==(const pt &r) const {
return first == r.first && second == r.second;
}
};
ostream &operator<<(ostream &os, const pt &p) {
return os << "(" << p.first << "," << p.second << ")";
}
inline long double cross(const pt &l, const pt &r) {
return l.first * r.second - l.second * r.first;
}
inline long double dot(const pt &l, const pt &r) {
return l.first * r.first + l.second * r.second;
}
long long pwmod(long long a, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
template <typename T>
inline T sqr(T first) {
return first * first;
}
struct DSU {
vector<int> p;
vector<int> sz;
void init(int n) {
p.resize(n);
sz.resize(n);
for (int i = 0; i < (int)(n); i++) {
p[i] = i;
sz[i] = 1;
}
}
int get(int v) {
if (p[v] == v) return v;
return p[v] = get(p[v]);
}
void unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
p[b] = a;
sz[a] += sz[b];
}
};
const int N = 1000 * 100 + 10;
const int LG = 20;
vector<pair<int, int> > g[N];
int up[N][LG];
int ty[N][LG];
int tin[N];
int tout[N];
int timer = 0;
void dfs(int v, int p, int tt = -1) {
tin[v] = timer++;
up[v][0] = p;
ty[v][0] = tt;
for (int i = 1; i < LG; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
if (ty[up[v][i - 1]][i - 1] == -1 || ty[v][i - 1] == -1 ||
ty[v][i - 1] != ty[up[v][i - 1]][i - 1]) {
ty[v][i] = -1;
} else {
ty[v][i] = ty[v][i - 1];
}
}
for (auto pa : g[v]) {
dfs(pa.first, v, pa.second);
}
tout[v] = timer++;
}
inline bool isUpper(int a, int b) {
return tin[a] <= tin[b] && tout[b] <= tout[a];
}
bool get1(int a, int b) {
if (a == b) return false;
if (!isUpper(b, a)) return false;
for (int i = LG - 1; i >= 0; --i) {
if (!isUpper(up[a][i], b)) {
if (ty[a][i] != 0) return false;
a = up[a][i];
}
}
return ty[a][0] == 0;
}
bool get2(int a, int b) {
if (a == b) return false;
if (isUpper(a, b)) return false;
for (int i = LG - 1; i >= 0; --i) {
if (!isUpper(up[b][i], a)) {
if (ty[b][i] != 0) return false;
b = up[b][i];
}
}
if (!isUpper(b, a)) {
if (ty[b][0] != 0) return false;
b = up[b][0];
}
for (int i = LG - 1; i >= 0; --i) {
if (!isUpper(up[a][i], b)) {
if (ty[a][i] != 1) {
return false;
}
a = up[a][i];
}
}
return ty[a][0] == 1;
}
void solve() {
int n = nxt();
DSU dsu;
dsu.init(n);
vector<int> roots;
for (int i = 0; i < (int)(n); i++) {
int p = nxt();
int t = nxt();
if (p != -1) {
dsu.unite(i, p - 1);
g[p - 1].push_back(make_pair(i, t));
} else {
roots.push_back(i);
}
}
for (int v : roots) {
timer = 0;
dfs(v, v);
}
int q = nxt();
for (int i = 0; i < (int)(q); i++) {
int t = nxt();
int v = nxt() - 1;
int u = nxt() - 1;
if (dsu.get(v) != dsu.get(u)) {
cout << "NO\n";
continue;
}
bool res;
if (t == 1) {
res = get1(u, v);
} else {
res = get2(u, v);
}
cout << (res ? "YES" : "NO") << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
double cl0 = clock();
solve();
cerr << "Time: " << (clock() - cl0) / CLOCKS_PER_SEC << std::endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int MX = 1e5 + 5;
const int mod = 1e9 + 7;
char str[MX];
int main() {
scanf("%s", str);
int len = strlen(str);
long long ans = 1, num = 1;
for (int i = 0; i < len; i++) {
if (str[i] == 'a')
num++;
else if (str[i] == 'b') {
ans = ans * num % mod;
num = 1;
}
}
ans = ans * num % mod;
ans -= 1;
cout << ans << endl;
return 0;
}
| 3 |
// Create your own template by modifying this file!
#include <array>
#include <string>
#include <vector>
#include <climits>
#include <cstring>
#include <map>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <cassert>
#include <deque>
#include <stack>
#include <functional>
#include <bitset>
#include <numeric>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB emplace_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<int> VVI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
#ifdef DEBUG
#define debug(...) {printf("[DEBUG] ");W(__VA_ARGS__);}
#else
#define debug(...)
#endif
int MOD = 1e9+7;
void ADD(LL& x,LL v){x=(x+v)%MOD;if(x<0)x+=MOD;}
/*}}}*/
const int SIZE = 1<<20;
template<class T> void MIN(T& a, const T& b) { a = min(a, b); }
template<class T> void MAX(T& a, const T& b) { a = max(a, b); }
void print(const VI& s) {
REP(i, SZ(s)) {
printf("%d%c", s[i], i == SZ(s) - 1 ? '\n' : '.');
}
}
void solve() {
int N;
R(N);
int a;
R(a);
VI s = {1};
W(1);
REP(i, N-1) {
R(a);
if (a == 1) {
s.PB(a);
} else {
while (s.back() != a - 1) {
s.pop_back();
}
s.back() = a;
}
print(s);
}
}
int main() {
#if 1
CASET{
solve();
}
#else
solve();
#endif
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 2e9;
const double PI = acos(-1);
const long long M = 1e9 + 7;
long long oor(long long a, long long b) { return (a | b); }
struct mseg {
int best, a1[10];
int& operator[](int x) { return a1[x]; }
} seg[800010];
mseg change(mseg& seg, int vl) {
int x = vl;
for (int i = 0; i <= 9; ++i) {
if (x % 10 == 0)
seg[i] = oo;
else
seg[i] = vl;
x /= 10;
}
seg.best = oo;
return seg;
}
mseg marge(mseg a, mseg b) {
mseg seg;
seg.best = min(b.best, a.best);
for (int i = 0; i <= 9; ++i) {
seg[i] = min(a[i], b[i]);
if (a[i] != oo && b[i] != oo) seg.best = min(a[i] + b[i], seg.best);
}
return seg;
}
int a[200010];
void build(int n, int s, int e) {
if (s == e - 1) {
change(seg[n], a[s]);
return;
}
build(n * 2, s, (s + e) / 2);
build(n * 2 + 1, (s + e) / 2, e);
seg[n] = marge(seg[n * 2], seg[n * 2 + 1]);
}
mseg get(int n, int s, int e, int l, int r) {
if (s == l && e == r) return seg[n];
if ((s + e) / 2 >= r) return get(n * 2, s, (s + e) / 2, l, r);
if ((s + e) / 2 <= l) return get(n * 2 + 1, (s + e) / 2, e, l, r);
return marge(get(n * 2, s, (s + e) / 2, l, (s + e) / 2),
get(n * 2 + 1, (s + e) / 2, e, (s + e) / 2, r));
}
void update(int n, int s, int e, int at, int vl) {
if (s == e - 1) {
change(seg[n], vl);
return;
}
int md = (s + e) / 2;
if (md > at)
update(n * 2, s, md, at, vl);
else
update(n * 2 + 1, md, e, at, vl);
seg[n] = marge(seg[n * 2], seg[n * 2 + 1]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
build(1, 0, n);
while (m--) {
int t;
cin >> t;
if (t - 1) {
int l, r;
cin >> l >> r;
l--;
int x = get(1, 0, n, l, r).best;
cout << (x == oo ? -1 : x) << endl;
} else {
int pos, vl;
cin >> pos >> vl;
pos--;
update(1, 0, n, pos, vl);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2,fma,tune=native")
template <typename T>
void print(T&& x) {
cout << x << "\n";
}
template <typename T, typename... S>
void print(T&& x, S&&... y) {
cout << x << ' ';
print(y...);
}
const long long Mod = 1000000007, Mod2 = 998244353;
const long long MOD = Mod2;
const long long maxn = 100005;
long long n, val[11] = {49, 10, 0, 2, 5, 9, 3, 9, 5, 2, 0}, dp[maxn][12], res;
string str;
void orzck() {
cin >> str;
n = ((long long)str.size());
for (long long i = (0); i < ((long long)(11)); i++) dp[n - 1][i] = 0;
for (long long i = (n - 2); i >= ((long long)(0)); i--)
for (long long j = (0); j < ((long long)(11)); j++) {
if (j <= str[i + 1] - '0')
dp[i][j] = 0;
else
dp[i][j] = dp[i + 1][(val[j] + str[i + 1] - '0') % 11] + 1;
}
for (long long i = (0); i < ((long long)(n)); i++)
if (str[i] != '0') res += 1 + dp[i][str[i] - '0'], 826;
print(res);
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cout << fixed << setprecision(15);
long long t;
t = 1;
while (t--) orzck();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int>> f;
vector<pair<long long int, long long int>> f2;
long long int number, threshold, rich, value;
long long int binarysearch(long long int a) {
long long int low = a;
long long int high = f2.size() - 1;
long long int mid;
long long int answer;
while (low <= high) {
mid = (low + high) / 2;
if (f2[mid].first - f2[a].first < threshold) {
answer = mid;
low = mid + 1;
} else
high = mid - 1;
}
return answer;
}
int main() {
cin >> number >> threshold;
for (int i = 0; i < number; i++) {
cin >> rich >> value;
f.push_back(make_pair(rich, value));
}
sort(f.begin(), f.end());
f2.push_back(make_pair(0, 0));
f2.push_back(make_pair(f[0].first, f[0].second));
for (int i = 2; i < f.size() + 1; i++)
f2.push_back(make_pair(f[i - 1].first, f2[i - 1].second + f[i - 1].second));
long long int totalvalue = 0;
for (int i = 1; i < f2.size(); i++) {
long long int curr = f2[binarysearch(i)].second - f2[i - 1].second;
if (curr > totalvalue) totalvalue = curr;
}
cout << totalvalue;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
long long ans = pow((long long)2, n + 1) - 2;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ABS(int a) {
if (a < 0) a = -a;
return a;
}
bool cmp(pair<int, int> a, pair<int, int> b) {
return (ABS(a.first) + ABS(a.second)) < (ABS(b.first) + ABS(b.second));
}
int main() {
int n, m, k, i, j;
int a[310];
int x;
int u, v;
int root;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i <= n; i++) a[i] = 1;
u = v = 0;
for (i = 0; i < k; i++) {
scanf("%d", &x);
if (0 == u)
u = x;
else if (0 == v)
v = x;
a[x] = 0;
}
if (k == n) {
cout << -1 << endl;
return 0;
}
for (i = 1; i <= n; i++)
if (1 == a[i]) break;
root = i;
int cnt = (n * (n - 1)) / 2 - (k - 1);
if (cnt >= m) {
for (i = 1; i <= n; i++)
if (i != root) printf("%d %d\n", root, i);
m -= n - 1;
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
if (i != root && j != root)
if ((i == u && !a[j]) || (j == u && !a[i]) || (i == u && j == v) ||
(i == v && j == u))
;
else {
if (0 == m) break;
printf("%d %d\n", i, j);
m--;
}
}
}
} else
cout << -1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (int)(1e9 + 1e6);
const long long LINF = (long long)(4e18);
const double EPS = 1e-14;
mt19937 ggen;
void solve();
int main() {
iostream::sync_with_stdio(false);
cin.tie(0);
ggen = mt19937(1337);
solve();
}
void solve() {
int n;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort((a).begin(), (a).end());
if (n == 1) {
cout << -1;
return;
}
if (n == 2) {
if (a[0].first == a[1].first) {
cout << -1;
return;
}
}
cout << n - 1;
cout << endl;
for (int i = n - 1; i > 0; --i) {
cout << a[i].second + 1 << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[100001];
int dist[100001];
int main(void) {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
memset(dist, -1, sizeof(dist));
dist[0] = 0;
queue<int> que;
que.push(0);
while (que.size()) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
if (dist[G[v][i]] == -1) {
dist[G[v][i]] = dist[v] + 1;
que.push(G[v][i]);
}
}
}
int id = 0;
for (int i = 0; i < n; i++) {
if (dist[id] < dist[i]) {
id = i;
}
}
memset(dist, -1, sizeof(dist));
dist[id] = 0;
que.push(id);
while (que.size()) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
if (dist[G[v][i]] == -1) {
dist[G[v][i]] = dist[v] + 1;
que.push(G[v][i]);
}
}
}
int res = 0;
for (int i = 0; i < n; i++) {
res = max(res, dist[i]);
}
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
inline int read() {
int s = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) s = (s << 3) + (s << 1) + (c ^ 48), c = getchar();
return s;
}
int n, m, a[N], b[N], f[N][N], pre[N][N], out[N], cnt, ii, jj;
int main() {
n = read();
a[0] = b[0] = -1000000000;
for (register int i = 1; i <= n; i++) a[i] = read();
m = read();
for (register int i = 1; i <= m; i++) b[i] = read();
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= m; j++)
if (a[i] == b[j]) {
for (register int k = 0; k < j; k++)
if (b[k] < a[i] && f[i - 1][k] + 1 > f[i][j])
f[i][j] = f[i - 1][k] + 1, pre[i][j] = k;
} else
f[i][j] = f[i - 1][j], pre[i][j] = j;
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= m; j++)
if (f[i][j] > f[ii][jj]) ii = i, jj = j;
printf("%d\n", f[ii][jj]);
for (; ii; jj = pre[ii--][jj])
if (f[ii][jj] != f[ii - 1][pre[ii][jj]]) out[++cnt] = a[ii];
for (register int i = cnt; i; i--) printf("%d ", out[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5;
const int M = 36;
const int maxn = 2e7 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3e;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline int ksm(int x, int y, int z) {
int ret = 1;
while (y) {
if (y & 1) ret = (ret * x) % z;
x = (x * x) % z;
y >>= 1;
}
return ret;
}
inline int ksm(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (ret * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return ret;
}
inline int INV(int x) { return ksm(x, mod - 2); }
int n, m, x, y;
double dp[N][N];
double p[N];
int t[N];
signed main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
p[i] = read();
t[i] = read();
p[i] /= 100;
}
dp[0][0] = 1;
double sum = 0;
for (int i = 1; i <= n; i++) {
double ans = 0;
double tp = pow(1 - p[i], t[i]);
for (int j = i; j <= m; j++) {
ans += dp[i - 1][j - 1];
if (j - t[i] >= 1) ans -= dp[i - 1][j - t[i] - 1] * tp;
dp[i][j] = ans * p[i];
if (j - t[i] >= 0) dp[i][j] += dp[i - 1][j - t[i]] * tp;
ans *= 1 - p[i];
sum += dp[i][j];
}
}
printf("%.9lf\n", sum);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct coordinate {
int x, y;
};
int a, x, y;
coordinate c[10];
int main() {
cin >> a >> x >> y;
if (x >= a || x <= -a || y % a == 0) {
cout << -1 << endl;
return 0;
}
int q = y / a + 1;
if ((q == 1 || q % 2 == 0) && (x * 2 >= a || x * 2 <= -a)) {
cout << -1 << endl;
return 0;
}
if (q % 2 == 1 && q != 1 && x == 0) {
cout << -1 << endl;
return 0;
}
if (q == 1 || q % 2 == 0) {
if (q == 1) {
cout << 1 << endl;
} else {
cout << q + q / 2 - 1 << endl;
}
return 0;
} else {
int num = q + q / 2 - 1;
if (x < 0) {
cout << num << endl;
} else {
cout << num + 1 << endl;
}
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50 + 5;
int a[N][N], b[N][N], x[N], y[N], val[N];
vector<pair<int, int> > in, out;
int n, m, last = 1;
void move(int x1, int y1, int x2, int y2) {
out.push_back({x1, y1});
in.push_back({x2, y2});
a[x2][y2] = a[x1][y1];
a[x1][y1] = 0;
}
void build() {
for (int i = 1; i <= n; i++)
if (a[i][1]) {
int tmp = i;
while (tmp > 1 && !a[tmp - 1][1]) move(tmp, 1, tmp - 1, 1), tmp--;
last++;
}
for (int j = 2; j <= n; j++)
for (int i = n; i >= 0; i--)
if (a[i][j]) {
int tmp = j;
while (tmp > 2) move(i, tmp, i, tmp - 1), tmp--;
tmp = i;
while (tmp < last) move(tmp, 2, tmp + 1, 2), tmp++;
move(tmp, 2, tmp, 1);
while (tmp > last) move(tmp, 1, tmp - 1, 1), tmp--;
last++;
}
for (int i = n; i >= 1; i--)
if (a[i][1]) {
int tmp = i;
while (tmp < n && !a[tmp + 1][1]) move(tmp, 1, tmp + 1, 1), tmp++;
}
}
void Swap(int j, int i) {
if (i == j) return;
move(j, 1, j, 2);
for (int k = j - 1; k >= i; k--) {
move(k, 1, k + 1, 1);
move(k + 1, 2, k, 2);
}
move(i, 2, i, 1);
}
void Go(int i, int num) {
int tmp = i;
while (tmp > 1 && !a[tmp - 1][1] && tmp > x[num])
move(tmp, 1, tmp - 1, 1), tmp--;
int hp = 1;
while (hp < y[num]) move(tmp, hp, tmp, hp + 1), hp++;
while (tmp < x[num]) move(tmp, y[num], tmp + 1, y[num]), tmp++;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
a[x[i]][y[i]] = i;
}
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
b[x[i]][y[i]] = i;
}
if (n == 1) return cout << 0, 0;
build();
int tmp = 1;
for (int j = n; j >= 2; j--)
for (int i = n; i >= 1; i--)
if (b[i][j]) val[b[i][j]] = tmp++;
for (int i = 1; i <= n; i++)
if (b[i][1]) val[b[i][1]] = tmp++;
for (int i = 1; i <= m; i++)
for (int j = n - last + 2; j <= n; j++)
if (val[a[j][1]] == i) Swap(j, n - last + 1 + i);
for (int i = n - last + 2; i <= n; i++) Go(i, a[i][1]);
cout << in.size() << '\n';
for (int i = 0; i < in.size(); i++)
cout << out[i].first << " " << out[i].second << " " << in[i].first << " "
<< in[i].second << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int l, b, f, n, c, d, g, p;
bool ff;
struct au {
int p, l, n;
au(int pp = 0, int ll = 0, int nn = 0) {
p = pp;
l = ll;
n = nn;
}
};
vector<au> a;
vector<bool> t;
int main() {
cin >> l >> b >> f >> n;
for (int i = 0; i < n; i++) {
cin >> c >> d;
if (c == 1) {
t.assign(l, true);
for (int i = 0; i < a.size(); i++)
for (int j = max(0, a[i].p - f - d + 1);
j < min(l, a[i].p + a[i].l + b); j++)
t[j] = false;
p = -1;
for (int i = 0; i <= l - d && p == -1; i++)
if (t[i]) {
p = i;
}
if (p != -1) a.push_back(au(p, d, i + 1));
cout << p << "\n";
} else {
ff = true;
for (int i = 0; ff && i < a.size(); i++)
if (d == a[i].n) {
a.erase(a.begin() + i, a.begin() + i + 1);
ff = false;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (n == 1) {
if (k == 0)
printf("1\n");
else
printf("-1\n");
return 0;
}
int ile = n / 2;
if (ile > k) {
printf("-1\n");
return 0;
}
int wyn = k - ile + 1;
printf("%d %d ", wyn, wyn * 2);
for (int i = 0; i < n - 2; ++i) printf("%d ", 2 * wyn + i + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[999];
int main() {
int i, n, m, res = 0, sum = 0;
scanf("%d", &n);
for (i = 0; i < 12; i++) {
scanf("%d", &a[i]);
}
sort(a, a + 12, greater<int>());
for (i = 0; i < 12; i++) {
sum += a[i];
if (n != 0 && sum >= n) {
res = i + 1;
break;
}
}
if (sum < n)
printf("-1");
else
printf("%d", res);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int k;
while (cin >> k) {
if (k > 36)
cout << "-1" << endl;
else if (k == 1)
cout << "6" << endl;
else if (k == 2)
cout << "8" << endl;
else if (k == 3)
cout << "86" << endl;
else if (k == 4)
cout << "88" << endl;
else if (k == 5)
cout << "886" << endl;
else if (k == 6)
cout << "888" << endl;
else if (k == 7)
cout << "8886" << endl;
else if (k == 8)
cout << "8888" << endl;
else if (k == 9)
cout << "88886" << endl;
else if (k == 10)
cout << "88888" << endl;
else if (k == 11)
cout << "888886" << endl;
else if (k == 12)
cout << "888888" << endl;
else if (k == 13)
cout << "8888886" << endl;
else if (k == 14)
cout << "8888888" << endl;
else if (k == 15)
cout << "88888886" << endl;
else if (k == 16)
cout << "88888888" << endl;
else if (k == 17)
cout << "888888886" << endl;
else if (k == 18)
cout << "888888888" << endl;
else if (k == 19)
cout << "8888888886" << endl;
else if (k == 20)
cout << "8888888888" << endl;
else if (k == 21)
cout << "88888888886" << endl;
else if (k == 22)
cout << "88888888888" << endl;
else if (k == 23)
cout << "888888888886" << endl;
else if (k == 24)
cout << "888888888888" << endl;
else if (k == 25)
cout << "8888888888886" << endl;
else if (k == 26)
cout << "8888888888888" << endl;
else if (k == 27)
cout << "88888888888886" << endl;
else if (k == 28)
cout << "88888888888888" << endl;
else if (k == 29)
cout << "888888888888886" << endl;
else if (k == 30)
cout << "888888888888888" << endl;
else if (k == 31)
cout << "8888888888888886" << endl;
else if (k == 32)
cout << "8888888888888888" << endl;
else if (k == 33)
cout << "88888888888888886" << endl;
else if (k == 34)
cout << "88888888888888888" << endl;
else if (k == 35)
cout << "888888888888888886" << endl;
else if (k == 36)
cout << "888888888888888888" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2000 + 1;
const int mod = 1e9 + 7;
void addto(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int mul(int a, int b) { return ((long long)a * b) % mod; }
int mpow(int a, int n) {
int r = 1;
while (n > 0) {
if (n & 1) r = mul(r, a);
a = mul(a, a);
n >>= 1;
}
return r;
}
int A[MAX_N], h, N;
int dp[MAX_N][MAX_N];
int rec(int n, int k) {
if (k < 0) return 0;
if (n == N) return k == 0;
int& ans = dp[n][k];
if (ans != -1) return ans;
ans = 0;
if (A[n] == k) {
addto(ans, rec(n + 1, k));
addto(ans, mul(rec(n + 1, k - 1), k));
}
if (A[n] == k + 1) {
addto(ans, rec(n + 1, k + 1));
addto(ans, mul(rec(n + 1, k), k + 1));
}
return ans;
}
int main() {
while (scanf("%d%d", &N, &h) != EOF) {
for (int i = 0; i < N; i++) {
scanf("%d", A + i);
A[i] = h - A[i];
}
memset(dp, -1, sizeof dp);
printf("%d\n", rec(0, 0));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 512;
namespace PQ {
const int P = -1, Q = -2;
enum col { White = 0, Gray, Black };
struct node {
int v;
node *son, *bro;
col c;
inline node() {}
inline node(int v, node *son, node *bro, col c)
: v(v), son(son), bro(bro), c(c) {}
} pool[N << 2], *bin;
int pt;
inline void init() { pt = 0, bin = 0; }
inline node *NEW() {
if (bin) {
node *p = bin;
bin = bin->bro;
return p;
} else
return pool + (pt++);
}
inline void DELETE(node *p) { p->bro = bin, bin = p; }
inline node *newSubtree(node *p, int k) {
return p->bro ? (new (NEW()) node(k, p, 0, White)) : p;
}
inline node **tail(node *p) {
if (!p) return NULL;
for (; p->bro; p = p->bro)
;
return &p->bro;
}
inline void add(node *p, node *q) { *(tail(p)) = q; }
inline void reverse(node *p) {
node *pre = 0, *nex, *i;
for (i = p->son; i; i = nex) nex = i->bro, i->bro = pre, pre = i;
p->son = pre;
}
inline bool check(node *p) {
int cnt[3] = {0, 0, 0}, lc = 0;
for (p = p->son; p; p = p->bro) {
if (p->c < lc) return 0;
lc = p->c, cnt[p->c]++;
}
return cnt[Gray] <= 1;
}
inline void assign(node *p) {
if (p->v == P) {
node *h = 0, *s, **hl = &h, **sl = &p->son;
for (s = *sl; s; s = s->bro)
if (s->c == Gray)
*hl = s, hl = &s->bro;
else
*sl = s, sl = &s->bro;
*sl = 0, sl = &p->son;
for (s = p->son; s; s = s->bro)
if (s->c == Black)
*hl = s, hl = &s->bro;
else
*sl = s, sl = &s->bro;
*sl = h;
*hl = 0;
} else if (!check(p))
reverse(p);
}
inline node *splitWhite(node *p) {
node **q = &p->son;
for (p = p->son; p; q = &p->bro, p = p->bro)
if (p->c != White) {
*q = 0;
return p;
}
return 0;
}
inline int cntGray(node *p) {
int cnt = 0;
for (; p && p->c == Gray; p = p->bro) ++cnt;
return cnt;
}
struct PQTree {
int n;
node *rt;
inline void init(int n) {
this->n = n;
int i;
rt = new (NEW()) node(P, 0, 0, White);
node **lt = &rt->son;
for (i = 1; i <= n; i++) {
*lt = new (NEW()) node(i, 0, 0, White);
lt = &(*lt)->bro;
}
}
char *lim;
inline void walk(node *p, int *&out) {
for (node *s = p->son; s; s = s->bro)
if (s->v > 0)
*++out = s->v;
else
walk(s, out);
}
inline void travel(int *out) { walk(rt, out); }
inline void predfs(node *p) {
if (p->v > 0)
p->c = lim[p->v] == '1' ? Black : White;
else {
int s1 = 0, s2 = 1;
node *s;
for (s = p->son; s; s = s->bro) {
predfs(s);
s1 |= s->c != White;
s2 &= s->c == Black;
}
p->c = (s1 ? s2 ? Black : Gray : White);
}
}
inline bool insdfs(node *p) {
if (p->v > 0 || p->c != Gray) return 1;
if (p->v == P) {
assign(p);
node *h = splitWhite(p);
if (!p->son) {
p->son = h;
int nGray = cntGray(h);
if (nGray == 0)
return 1;
else if (nGray == 1) {
p->v = Q;
node *np = h, *nq = newSubtree(h->bro, P);
nq->c = Black;
p->son = np, np->bro = nq;
} else if (nGray == 2) {
p->v = Q;
node *g1 = h, *g2 = g1->bro;
if (g2->bro) {
node *nq = newSubtree(g2->bro, P);
nq->c = Black;
p->son = g1, g1->bro = nq, nq->bro = g2, g2->bro = 0;
} else {
p->son = g1, g1->bro = g2;
}
} else
return 0;
} else {
node *np = newSubtree(h, P);
np->c = Gray;
np->bro = p->son, p->son = np;
return insdfs(np);
}
}
node *fs = 0, *ls = 0;
for (node *s = p->son; s; s = s->bro)
if (s->c != White) {
if (!fs) fs = s;
ls = s;
}
if (fs == ls) return insdfs(fs);
for (node *s = fs->bro; s != ls; s = s->bro)
if (s->c != Black) return 0;
int ti;
for (ti = 0; ti <= 1; ti++) {
if (ti == 1) reverse(p), swap(fs, ls);
while (fs->c != Black) {
assign(fs);
if (!check(fs)) return 0;
node *h = splitWhite(fs);
if (fs->v == P) {
int nGray = cntGray(h);
if (!nGray) {
h = newSubtree(h, P);
h->c = Black;
} else {
if (h->bro) {
h->bro = newSubtree(h->bro, P);
h->bro->c = Black;
}
}
} else {
if (fs->son) {
node *nex = fs->son;
while (nex->bro) nex = nex->bro;
nex->bro = fs->bro, fs->bro = fs->son, fs->son = 0;
fs = nex;
}
}
add(h, fs->bro);
fs->bro = h;
fs = fs->bro;
}
if (ti == 1) reverse(p), swap(fs, ls);
}
for (node *s = p->son, **pre = &p->son; s; s = *pre) {
if (s->v > 0)
pre = &s->bro;
else {
if (!s->son)
*pre = s->bro, DELETE(s);
else if (!s->son->bro)
*pre = s->son, s->son->bro = s->bro, DELETE(s);
else
pre = &s->bro;
}
}
return 1;
}
inline bool ins(char *s) {
lim = s;
predfs(rt);
return insdfs(rt);
}
};
} // namespace PQ
char s[N][N];
int res[N];
PQ::PQTree T;
int main() {
int i, j, n;
scanf("%d", &n);
T.init(n);
for (i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (i = 1; i <= n; i++)
if (!T.ins(s[i])) {
printf("NO");
return 0;
}
T.travel(res);
printf("YES\n");
for (i = 1; i <= n; putchar('\n'), i++)
for (j = 1; j <= n; j++) putchar(s[i][res[j]]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
const long long N = 200005;
long long hi, ls, n, X[N], t, A[N], bk[N];
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> t;
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
for (int i = 0; i < n; ++i) {
cin >> X[i], --X[i];
}
for (int i = 0; i < n; ++i) {
if ((X[i] < i || (i < n - 1 && X[i] > X[i + 1])) ||
(X[i] != i &&
(X[X[i]] != X[i] || (X[i] + 1 < n && A[X[i] + 1] - 1 == A[X[i]])))) {
cout << "No", std::exit(0);
}
}
for (int i = 0; i < n; ++i) {
if (X[i] > i) {
for (int j = max(hi, 1ll + i); j < X[i] + 1; ++j) {
bk[j] = 1;
}
hi = max(hi, X[i]);
}
}
cout << "Yes\n";
for (int i = 0; i < n; ++i)
(i < n - 1 && bk[i + 1] ? hi = A[i + 1] + t : hi = A[i] + t),
(i > 0 && hi == ls ? cout << hi + 1 << " " : cout << hi << " "),
ls = hi;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m = 0;
int lsh[100010];
struct Question {
int f, x;
} que[100010];
struct Segment_Tree {
long long data[5];
int num, l, r;
} a[100010 << 2];
inline int read() {
int date = 0, w = 1;
char c = 0;
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
date = date * 10 + c - '0';
c = getchar();
}
return date * w;
}
inline void pushup(int rt) {
a[rt].num = a[rt << 1].num + a[rt << 1 | 1].num;
for (int i = 0; i < 5; i++)
a[rt].data[i] = a[rt << 1].data[i] +
a[rt << 1 | 1].data[((i - a[rt << 1].num) % 5 + 5) % 5];
}
void buildtree(int l, int r, int rt) {
a[rt].l = l;
a[rt].r = r;
a[rt].num = 0;
if (l >= r) return;
int mid = l + r >> 1;
buildtree(l, mid, rt << 1);
buildtree(mid + 1, r, rt << 1 | 1);
}
void update(int k, int c, long long v, int rt) {
if (a[rt].l == a[rt].r) {
a[rt].data[1] += v;
a[rt].num += c;
return;
}
int mid = a[rt].l + a[rt].r >> 1;
if (k <= mid)
update(k, c, v, rt << 1);
else
update(k, c, v, rt << 1 | 1);
pushup(rt);
}
void work() {
for (int i = 1, x; i <= n; i++) {
if (que[i].f == 1) {
x = lower_bound(lsh + 1, lsh + m + 1, que[i].x) - lsh;
update(x, 1, que[i].x, 1);
} else if (que[i].f == -1) {
x = lower_bound(lsh + 1, lsh + m + 1, que[i].x) - lsh;
update(x, -1, -que[i].x, 1);
} else
cout << a[1].data[3] << endl;
}
}
void init() {
char ch[2];
n = read();
for (int i = 1, x; i <= n; i++) {
scanf("%s", ch);
if (ch[0] == 'a') {
x = read();
lsh[++m] = que[i].x = x;
que[i].f = 1;
} else if (ch[0] == 'd') {
x = read();
que[i].x = x;
que[i].f = -1;
} else
que[i].f = 0;
}
sort(lsh + 1, lsh + m + 1);
m = unique(lsh + 1, lsh + m + 1) - lsh - 1;
buildtree(1, m, 1);
}
int main() {
init();
work();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long Pow(long long x, long long y, long long m) {
if (y == 0) return 1;
long long p = Pow(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
set<long long> pr[100004];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j;
long long n, m;
cin >> n;
vector<long long> a(n);
for (i = 0; i < n; i++) cin >> a[i];
long long c = 0, sz = n;
for (i = 0; i < n; i++) pr[a[i]].insert(i);
sort(a.begin(), a.end());
long long pos = 0;
for (i = 0; i < n; i++) {
auto x = pr[a[i]].lower_bound(pos);
if (x == pr[a[i]].end()) {
c += sz;
pos = 0;
x = pr[a[i]].lower_bound(pos);
}
pos = *x;
pr[a[i]].erase(x);
sz--;
}
cout << c + n << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char map[110];
int pos[3][2], ans[2], all[2] = {0, 0};
int i, j, n, m, k = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", map);
for (j = 0; j < m; j++) {
if (map[j] == '*') {
all[0] += i + 1;
pos[k][0] = i + 1;
pos[k][1] = j + 1;
all[1] += j + 1;
k++;
}
}
}
int flag = 0;
for (i = 0; i < 3 && !flag; i++) {
for (j = 0; j < 3 && !flag; j++) {
if (pos[i][0] != pos[j][0] && pos[j][1] != pos[i][1]) {
ans[0] = 2 * (pos[i][0] + pos[j][0]) - all[0];
ans[1] = 2 * (pos[i][1] + pos[j][1]) - all[1];
flag = 1;
}
}
}
printf("%d %d\n", ans[0], ans[1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
const int xn = 2e5 + 10;
const int xm = 5e5;
const int SQ = 320;
const int sq = 1e3 + 10;
const long long inf = 1e18 + 10;
long long power(long long a, long long b) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2) % md
: power(a * a % md, b / 2) % md));
}
int n, nxt[xn], ans[xn], cnt;
string a;
bool Mark[xn];
stack<int> st;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> a;
for (int i = 0; i < n; i++) {
if (Mark[i]) continue;
int pnt = i;
cnt++;
ans[pnt] = cnt;
while (pnt < n) {
int last = pnt;
for (int j = pnt + 1; j < n; j++) {
if (!Mark[j] && a[j] >= a[pnt]) {
pnt = j;
break;
}
}
if (pnt == last) break;
ans[pnt] = cnt;
Mark[pnt] = true;
}
}
cout << cnt << '\n';
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int dp[100001];
void solve(){
int n, q;
string s;
cin >> n >> q >> s;
for(int i = 0; i < n; i++){
dp[i+1] = dp[i] + (int)s[i] - 96;
}
int l, r;
while(q--){
cin >> l >> r;
cout << dp[r] - dp[l-1] << '\n';
}
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int T = 1;
//cin >> T;
while(T--){
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline void read(t& res) {
char ch;
while (ch = getchar(), !isdigit(ch))
;
res = ch ^ 48;
while (ch = getchar(), isdigit(ch)) res = res * 10 + (ch ^ 48);
}
template <class t>
inline void print(t x) {
if (x > 9) print(x / 10);
putchar(x % 10 + 48);
}
const int e = 3e5 + 5, z1 = 29, z2 = 31, h1 = 1e9 + 7, h2 = 1e9 + 9;
struct node {
int s1, s2, len;
node() {}
node(int _s1, int _s2, int _len) : s1(_s1), s2(_s2), len(_len) {}
} up[e], down[e];
vector<int> a[e], b[e], g[e];
int n, top[e], son[e], m, f[20][e], dep[e], mx[e];
int p1[e], p2[e], fa[e], dfn[e], id[e << 1], tim, logn[e << 1], c[21][e << 1];
int q1[e], q2[e], inv1, inv2;
char s[e];
inline bool operator==(node a, node b) { return a.s1 == b.s1 && a.s2 == b.s2; }
inline node operator+(node a, node b) {
return node(((long long)a.s1 * p1[b.len] + b.s1) % h1,
((long long)a.s2 * p2[b.len] + b.s2) % h2, a.len + b.len);
}
inline int ksm(int x, int y, int mod) {
int res = 1;
while (y) {
if (y & 1) res = (long long)res * x % mod;
y >>= 1;
x = (long long)x * x % mod;
}
return res;
}
inline void dfs1(int u, int pa) {
int i;
fa[u] = pa;
dep[u] = dep[pa] + 1;
mx[u] = dep[u];
s[u] -= 'a' - 1;
dfn[u] = ++tim;
id[tim] = u;
for (i = 0; i < 18; i++) f[i + 1][u] = f[i][f[i][u]];
node a = down[pa], b = up[pa];
down[u] = node(((long long)z1 * a.s1 + s[u]) % h1,
((long long)z2 * a.s2 + s[u]) % h2, a.len + 1);
up[u] = node((b.s1 + (long long)p1[b.len] * s[u]) % h1,
(b.s2 + (long long)p2[b.len] * s[u]) % h2, b.len + 1);
for (auto v : g[u])
if (v != pa) {
f[0][v] = u;
dfs1(v, u);
if (mx[v] > mx[u]) mx[u] = mx[v], son[u] = v;
id[++tim] = u;
}
}
inline void dfs2(int u, int pa, int fi) {
top[u] = fi;
if (son[u]) dfs2(son[u], u, fi);
for (auto v : g[u])
if (v != pa && v != son[u]) dfs2(v, u, v);
}
inline int cmp(int x, int y) { return dep[x] < dep[y] ? x : y; }
inline void init() {
int i, j;
logn[0] = -1;
for (i = 1; i <= tim; i++) logn[i] = logn[i >> 1] + 1, c[0][i] = id[i];
for (j = 1; (1 << j) <= tim; j++)
for (i = 1; i + (1 << j) - 1 <= tim; i++)
c[j][i] = cmp(c[j - 1][i], c[j - 1][i + (1 << j - 1)]);
}
inline int lca(int l, int r) {
l = dfn[l];
r = dfn[r];
if (l > r) swap(l, r);
int k = logn[r - l + 1];
return cmp(c[k][l], c[k][r - (1 << k) + 1]);
}
inline int anc(int x, int k) {
if (!k) return x;
int y = logn[k], to;
x = f[y][x];
k -= (1 << y);
to = top[x];
if (dep[to] <= dep[x] - k)
return b[to][dep[x] - k - dep[to]];
else
return a[to][dep[to] - dep[x] + k];
}
inline int sub1(int x, int y) {
(x -= y) < 0 && (x += h1);
return x;
}
inline int sub2(int x, int y) {
(x -= y) < 0 && (x += h2);
return x;
}
inline node query_up(int x, int y) {
node a = up[x], b = up[y];
return node((long long)sub1(a.s1, b.s1) * q1[b.len] % h1,
(long long)sub2(a.s2, b.s2) * q2[b.len] % h2, a.len - b.len);
}
inline node query_down(int x, int y) {
node a = down[y], b = down[x];
return node(sub1(a.s1, (long long)b.s1 * p1[a.len - b.len] % h1),
sub2(a.s2, (long long)b.s2 * p2[a.len - b.len] % h2),
a.len - b.len);
}
inline node calc(int x, int y, int z, int len) {
int d1 = dep[x] - dep[z] + 1, d2 = dep[x] + dep[y] - 2 * dep[z] + 1;
if (len <= d1) {
int u = anc(x, len - 1);
return query_up(x, fa[u]);
} else {
int u = anc(y, d2 - len);
return query_up(x, fa[z]) + query_down(z, u);
}
}
inline int query(int x, int y, int u, int v) {
int z = lca(x, y), w = lca(u, v), res = 0, l = 1,
r = min(dep[x] + dep[y] - 2 * dep[z], dep[u] + dep[v] - 2 * dep[w]) + 1;
while (l <= r) {
int mid = l + r >> 1;
if (calc(x, y, z, mid) == calc(u, v, w, mid))
res = mid, l = mid + 1;
else
r = mid - 1;
}
return res;
}
int main() {
read(n);
int i, x, y, u, v, j;
scanf("%s", s + 1);
for (i = 1; i < n; i++) {
read(x);
read(y);
g[x].emplace_back(y);
g[y].emplace_back(x);
}
inv1 = ksm(z1, h1 - 2, h1);
inv2 = ksm(z2, h2 - 2, h2);
p1[0] = p2[0] = q1[0] = q2[0] = 1;
for (i = 1; i <= n; i++) {
p1[i] = (long long)p1[i - 1] * z1 % h1;
p2[i] = (long long)p2[i - 1] * z2 % h2;
q1[i] = (long long)q1[i - 1] * inv1 % h1;
q2[i] = (long long)q2[i - 1] * inv2 % h2;
}
dfs1(1, 0);
dfs2(1, 0, 1);
init();
for (i = 1; i <= n; i++)
if (top[i] == i) {
int x = i;
for (j = 0; j <= mx[i] - dep[i]; j++) a[i].emplace_back(x), x = fa[x];
x = i;
while (x) b[i].emplace_back(x), x = son[x];
}
read(m);
while (m--) {
read(x);
read(y);
read(u);
read(v);
print(query(x, y, u, v));
putchar('\n');
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 80;
const int INF = 0x3f3f3f3f;
int dp[MAXN][MAXN][MAXN][2];
int VV[MAXN];
int KK[MAXN];
int XX[MAXN];
int sv, sk, sx;
int find(int *data, int l, int r, int d) {
int cnt = 0;
for (int i = l; i < r && data[i] < d; i++) {
cnt++;
}
return cnt;
}
int main() {
memset(dp, 0x3f, sizeof(dp));
int n;
char c;
scanf("%d%*c", &n);
for (int i = 0; i < n; i++) {
scanf("%c", &c);
if (c == 'V')
VV[sv++] = i;
else if (c == 'K')
KK[sk++] = i;
else
XX[sx++] = i;
}
dp[0][0][0][0] = 0;
for (int v = 0; v <= sv; v++)
for (int k = 0; k <= sk; k++)
for (int x = 0; x <= sx; x++)
for (int t = 0; t < 2; t++) {
int aly = dp[v][k][x][t];
if (v < sv) {
int cost = find(KK, k, sk, VV[v]);
cost += find(XX, x, sx, VV[v]);
dp[v + 1][k][x][1] = min(dp[v + 1][k][x][1], aly + cost);
}
if (k < sk && t == 0) {
int cost = find(VV, v, sv, KK[k]);
cost += find(XX, x, sx, KK[k]);
dp[v][k + 1][x][0] = min(dp[v][k + 1][x][0], aly + cost);
}
if (x < sx) {
int cost = find(VV, v, sv, XX[x]);
cost += find(KK, k, sk, XX[x]);
dp[v][k][x + 1][0] = min(dp[v][k][x + 1][0], aly + cost);
}
}
int ans = INF;
ans = min(dp[sv][sk][sx][0], dp[sv][sk][sx][1]);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1);
const double pi2 = pi * 2.0;
char answer[100];
double iabs(const double &k) { return k < 0 ? -k : k; }
class Point {
public:
double x, y;
Point(const double &a = 0, const double &b = 0) : x(a), y(b) {}
Point operator+(const Point &k) {
return Point(this->x + k.x, this->y + k.y);
}
Point operator-(const Point &k) {
return Point(this->x - k.x, this->y - k.y);
}
Point operator*(const double &k) { return Point(this->x * k, this->y * k); }
Point operator/(const double &k) { return Point(this->y / k, this->y / k); }
double operator^(const Point &k) { return this->x * k.y - this->y * k.x; }
double length() { return sqrt(this->x * this->x + this->y * this->y); }
double dis2(const Point &k) {
return (this->x - k.x) * (this->x - k.x) +
(this->y - k.y) * (this->y - k.y);
}
void output() {
sprintf(answer, "%.10lf", this->x);
printf("%s ", answer);
sprintf(answer, "%.10lf", this->y);
printf("%s\n", answer);
}
Point turn(const double &th) {
return Point((this->x * cos(th) - this->y * sin(th)),
(this->x * sin(th) + this->y * cos(th)));
}
bool operator<(const Point &k) {
if (this->x == k.x) return this->y < k.y;
return this->x < k.x;
}
};
Point p0;
Point v0;
Point v[8], buff;
vector<Point> ans;
vector<Point>::iterator it, it2;
void solve() {
double a, b, c, d;
double k, len;
while (scanf("%lf%lf%lf%lf%lf%lf%lf%lf", &p0.x, &p0.y, &v0.x, &v0.y, &a, &b,
&c, &d) == 8) {
len = v0.length();
k = (b / len);
v[0] = v0 * k;
k = (-d / len);
buff = v0 * k;
v[2] = v[1] = v0.turn(pi / 2.0);
k = (a / (2.0 * len));
v[1] = v[1] * k;
k = (c / (2.0 * len));
v[2] = v[2] * k;
v[5] = Point(-v[2].x, -v[2].y);
v[6] = Point(-v[1].x, -v[1].y);
v[3] = buff + v[2];
v[4] = buff + v[5];
for (int i = 0; i < 7; ++i) {
(p0 + v[i]).output();
}
}
}
int main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, M = 1000000007;
cin >> a >> b;
cout << ((((b - 1) * b / 2) % M) * ((b * ((a * (a + 1) / 2) % M) + a) % M)) %
M;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n, i, j;
char s[100001];
vector<int> v[26];
string ans = "";
scanf("%s", s);
scanf("%d", &k);
n = strlen(s);
if ((long long)n * (n + 1) / 2 < k) {
puts("No such line.");
return 0;
}
for (i = 0; i < n; i++) {
v[s[i] - 'a'].push_back(i);
}
while (1) {
long long sum = 0;
long long p = 0;
for (i = 0; i < 26; i++) {
if (sum + v[i].size() >= k) {
ans += 'a' + i;
printf("%s\n", ans.c_str());
return 0;
}
for (j = 0; j < v[i].size(); j++) {
sum += n - v[i][j];
if (sum >= k) break;
}
if (j < v[i].size()) {
vector<int> w[26];
k -= p;
k -= v[i].size();
for (j = 0; j < v[i].size(); j++) {
if (v[i][j] + 1 < n) {
w[s[v[i][j] + 1] - 'a'].push_back(v[i][j] + 1);
}
}
for (j = 0; j < 26; j++) v[j] = w[j];
ans += 'a' + i;
break;
}
p = sum;
}
}
printf("%s\n", ans.c_str());
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int p = 100003;
int n, m;
int main() {
printf("%d %d\n", p, p);
scanf("%d%d", &n, &m);
printf("1 2 %d\n", p - n + 2);
for (int i = 2; i < n; ++i) printf("%d %d 1\n", i, i + 1);
m -= n - 1;
int i = 0, j = n;
while (m--) {
++j;
if (j > n) {
++i;
j = i + 2;
}
printf("%d %d 1000000000\n", i, j);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
using namespace ::std;
const int maxn = 3e6 + 500;
const int inf = 1e9 + 800;
const int mod = 1e9 + 7;
const long double pi = 3.14159265359;
complex<long double> a[maxn];
complex<long double> b[maxn];
void fft(complex<long double> a[], int n, int logg, int inv) {
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0; j < logg; j++) {
if ((i & (1 << j))) x |= (1 << (logg - j - 1));
}
if (x > i) swap(a[i], a[x]);
}
for (int len = 2; len <= n; len *= 2) {
complex<long double> wn = polar((long double)1, 2 * inv * pi / len);
for (int i = 0; i < n; i += len) {
complex<long double> pw;
pw.real(1);
pw.imag(0);
for (int j = 0; j < len / 2; j++) {
complex<long double> x = a[i + j] + pw * a[i + j + len / 2];
complex<long double> y = a[i + j] - pw * a[i + j + len / 2];
a[i + j] = x;
a[i + j + len / 2] = y;
pw *= wn;
}
}
}
if (inv == -1) {
for (int i = 0; i < n; i++) {
a[i] /= n;
}
}
}
void zarb(int n, int logg) {
fft(a, n, logg, 1);
fft(b, n, logg, 1);
for (int i = 0; i < n; i++) {
a[i] *= b[i];
}
fft(a, n, logg, -1);
}
bool sa[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> m >> n;
int sn = n;
a[0].real(1);
b[0].real(1);
for (int i = 0; i < m; i++) {
int v;
cin >> v;
sa[v] = 1;
a[v].real(1);
b[v].real(1);
}
m = 1;
int logg = 0;
while (m < n) {
m *= 2;
logg++;
}
n = m;
n *= 2;
logg++;
zarb(n, logg);
vector<int> vec;
for (int i = 1; i <= sn; i++) {
if (!sa[i] && a[i].real() > 0.5) {
cout << "NO" << endl;
;
return 0;
}
if (a[i].real() > 0.5 && a[i].real() < 2.5) vec.push_back(i);
}
cout << "YES" << endl << vec.size() << endl;
for (auto e : vec) cout << e << ' ';
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.