solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, k;
string a;
bool IsOK() {
for (int i = 0; i < k; i++)
for (int j = i + k; j < n; j += k)
if (a[j] != a[i]) return false;
return true;
}
void Propagate() {
for (int i = 0; i < k; i++)
for (int j = i + k; j < n; j += k) a[j] = a[i];
}
int IncPos() {
int p = -1;
for (int i = 0; i < k; i++)
if (a[i] < '9') p = i;
return p;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a;
if (IsOK()) {
cout << n << '\n' << a << '\n';
return 0;
}
string t = a;
Propagate();
if (a >= t) {
cout << n << '\n' << a << '\n';
return 0;
}
int p = IncPos();
if (p != -1) {
a[p]++;
for (int i = p + 1; i < k; i++) a[i] = '0';
}
Propagate();
cout << n << '\n' << a << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, ans;
int x[1000006];
int main() {
cin >> n >> m >> k;
if (n == 101) return 0;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
x[i] = c - '0';
}
reverse(x + 1, x + n + 1);
for (int i = 1; i <= m; i++) {
if (i == k + 1 && !x[i]) {
ans++;
} else if (i != k + 1 && x[i]) {
ans++;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int g[10], n, k, x, ans = 0;
void pre();
int grundy(int x);
int main() {
cin >> n >> k;
pre();
for (int i = 0; i < n; i++) {
cin >> x;
ans ^= grundy(x);
}
if (ans)
cout << "Kevin\n";
else
cout << "Nicky\n";
}
void pre() {
g[0] = 0;
g[1] = 1;
g[2] = k & 1 ? 0 : 2;
g[3] = (k & 1) ? 1 : 0;
g[4] = k & 1 ? 2 : 1;
g[5] = 0;
g[6] = 1 + 1 * (k & 1);
}
int grundy(int x) {
if (x < 7) return g[x];
if (k % 2 == 0) return !(x & 1);
if (x & 1) return 0;
if (grundy(x / 2) == 1)
return 2;
else
return 1;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, a[4005], b[4005], p = 4001;
bool c[4005][4005];
map<int, int> mr;
vector<int> v[4005];
int main() {
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a[i] >> b[i];
++mr[a[i]];
++mr[b[i]];
c[a[i]][b[i]] = c[b[i]][a[i]] = 1;
v[a[i]].push_back(b[i]);
v[b[i]].push_back(a[i]);
}
for (i = 0; i < m; i++) {
for (j = 0; j < v[a[i]].size(); j++) {
if (v[a[i]][j] != b[i] && c[b[i]][v[a[i]][j]]) {
p = min(p, mr[a[i]] + mr[b[i]] + mr[v[a[i]][j]] - 6);
}
}
}
if (p == 4001) {
p = -1;
}
cout << p;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while(t--) {
int n;
cin >> n;
vector<int> a(n);
for(int i = 0; i < n; i++) {
cin >> a[i];
}
auto Good = [&] (int l,int r) {
for(int i = l; i <= r; i++) {
for(int j = i + 1; j <= r; j++) {
for(int k = j + 1; k <= r; k++) {
if(a[i] >= a[j] && a[j] >= a[k]) {
return false;
}
if(a[i] <= a[j] && a[j] <= a[k]) {
return false;
}
}
}
}
return true;
};
int ans = 0;
for(int i = 0, j = 0; i < n; i++) {
while(!Good(j, i)) {
j++;
}
ans += i - j + 1;
}
cout << ans << '\n';
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(105);
bool a[MAXN][2];
int g[MAXN][MAXN][3][3];
int solve(int l, int r, int m1, int m2) {
if (l > r) return 0;
if (g[l][r][m1][m2] != -1) return g[l][r][m1][m2];
int t[MAXN] = {0};
for (int i = l; i <= r; i++)
for (int j = 0; j < 2; j++) {
if (a[i][0] || a[i][1]) continue;
if (i != l && a[i - 1][j ^ 1]) continue;
if (i != r && a[i + 1][j ^ 1]) continue;
if (i == l && m1 == (j ^ 1) + 1) continue;
if (i == r && m2 == (j ^ 1) + 1) continue;
int m3 = j + 1;
t[solve(l, i - 1, m1, m3) ^ solve(i + 1, r, m3, m2)] = 1;
}
int num = 0;
while (t[num]) num++;
return g[l][r][m1][m2] = num;
}
int main() {
int r, n;
scanf("%d%d", &r, &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x][y - 1] = 1;
}
memset(g, -1, sizeof(g));
if (solve(1, r, 0, 0) != 0)
printf("WIN");
else
printf("LOSE");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, -1, 1};
char in() {
static char buf[10001], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 10000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class Tp>
void read(register Tp &s) {
s = 0;
register bool neg = 0;
register char c;
while (!isdigit(c = in()))
if (c == '-') neg = 1;
while (s = (s << 3) + (s << 1) + c - 48, isdigit(c = in()))
;
s = (neg ? -s : s);
}
template <class Tp>
void write(register Tp x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <class Tp>
void print(const Tp &x, const char &end) {
write(x);
putchar(end);
}
template <class Tp>
Tp pow(register Tp x, register Tp p, const Tp &mod) {
register Tp res = 1;
for (; p; p >>= 1, x = (x * x) % mod)
if (p & 1) res = (res * x) % mod;
return res;
}
int comp(const double &x, const double &y) {
const double d = x - y, eps = 1e-8;
return (d <= eps && d >= -eps) ? 0 : (d > eps ? 1 : -1);
}
template <class Tp>
Tp sqr(const Tp &x) {
return x * x;
}
template <class Tp>
Tp gcd(const Tp &x, const Tp &y) {
return ((!y) ? x : gcd(y, x % y));
}
template <class Tp>
Tp inv(const Tp &x, const Tp &MOD) {
return pow(x, MOD - 2, MOD);
}
template <class Tp>
Tp lowbit(const Tp &x) {
return x & -x;
}
int n;
int main() {
cin >> n;
int s = sqrt(n) + 0.500;
int num = n - s + 1;
for (;;) {
for (int i = (1); i <= (s); ++i) printf("%d ", num + i - 1);
num -= s;
if (num <= 0) {
for (int i = (1); i <= (num + s - 1); ++i) printf("%d ", i);
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 10;
int n, k;
struct node {
int l[MAXK], r[MAXK], c;
node() {
memset(l, 0, sizeof(l));
memset(r, 0, sizeof(r));
c = 0;
}
} x;
bool operator<(const node &aa, const node &bb) {
for (int i = 0; i < k; i++)
if (aa.r[i] > bb.l[i]) return 0;
return 1;
}
set<node> st;
set<node>::iterator it;
int main() {
scanf("%d%d", &n, &k);
while (n--) {
for (int i = 0; i < k; i++) scanf("%d", &x.l[i]), x.r[i] = x.l[i];
x.c = 1;
while (!st.empty()) {
it = st.find(x);
if (it == st.end()) break;
x.c += (*it).c;
for (int i = 0; i < k; i++)
x.l[i] = min(x.l[i], (*it).l[i]), x.r[i] = max(x.r[i], (*it).r[i]);
st.erase(it);
}
st.insert(x);
printf("%d\n", (*--st.end()).c);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int mod = 1e9 + 7;
template <class T>
inline void readInt(T &n) {
n = 0;
T ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
n = n * sign;
}
long long a[100005], b[100005];
bool arr[10000];
int main() {
for (int i = ((int)(0)); i < ((int)(10000)); i++) arr[i] = true;
long long ans = 0;
long long n, k;
cin >> n;
for (int i = ((int)(0)); i < ((int)(n)); i++) {
cin >> a[i] >> b[i];
arr[a[i]] = false;
}
for (int i = ((int)(0)); i < ((int)(n)); i++) {
int flag = 0;
for (int j = ((int)(0)); j < ((int)(n)); j++) {
if (i == j) continue;
if (a[i] == b[j]) flag = 1;
}
if (flag == 0) ans++;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t, p;
cin >> s >> t;
auto n = s.length();
int d = 0;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
d++;
}
}
if (d & 1) {
cout << "impossible" << endl;
} else {
string p(n, '0');
int sd = 0, td = 0;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
if (sd < td) {
p[i] = t[i];
sd++;
} else {
p[i] = s[i];
td++;
}
}
}
cout << p << endl;
}
}
| 1 |
#include <bits/stdc++.h>
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
using namespace std;
template <class myType>
void p(vector<myType>& v) {
for (myType i : v) cout << i << " ";
cout << endl;
}
template <class myType>
void pv(vector<vector<myType>>& vv) {
for (auto& v : vv) p(v);
}
template <class myType>
void GetInputV(vector<myType>& v, int n) {
v.resize(n);
for (myType& i : v) cin >> i;
}
template <class myType>
void GetInputVV(vector<vector<myType>>& vv, int m, int n) {
vv.resize(m);
for (vector<myType>& v : vv) GetInputV(v, n);
}
void same(vector<vector<int>>& A, vector<vector<int>>& B) {
for (int i = 0; i < A.size(); i++) {
for (int j = 0; j < A[0].size(); j++) {
if (A[i][j] != B[i][j]) {
cout << "No" << endl;
return;
}
}
}
cout << "Yes" << endl;
}
void flip(vector<vector<int>>& A, int i, int j) {
A[i][j] = !A[i][j];
A[i + 1][j] = !A[i + 1][j];
A[i][j + 1] = !A[i][j + 1];
A[i + 1][j + 1] = !A[i + 1][j + 1];
}
int main() {
int m, n;
cin >> m >> n;
vector<vector<int>> A, B;
GetInputVV(A, m, n);
GetInputVV(B, m, n);
for (int i = 0; i < m - 1; i++) {
for (int j = 0; j < n - 1; j++) {
if (A[i][j] != B[i][j]) {
flip(A, i, j);
}
}
}
same(A, B);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 17;
const long long INF = 3e18 + 7;
vector<pair<long long, long long> > g[maxn];
vector<long long> path;
set<pair<long long, long long> > myst;
bool mark[maxn];
long long n, m, last, sp[maxn], par[maxn];
long long ext_min() {
pair<long long, long long> ret = *myst.begin();
myst.erase(ret);
return ret.second;
}
void update(long long v) {
mark[v] = true;
for (long long i = 0; i < g[v].size(); i++) {
if (!mark[g[v][i].first]) {
long long u = g[v][i].first;
myst.erase(make_pair(sp[u], u));
if (sp[u] > sp[v] + g[v][i].second) par[u] = v;
sp[u] = min(sp[u], sp[v] + g[v][i].second);
myst.insert(make_pair(sp[u], u));
}
}
}
inline void dijkstra(long long v) {
fill(sp, sp + n + 10, INF);
sp[v] = 0;
update(v);
for (long long i = 1; i < n; i++) {
long long u = ext_min();
update(u);
}
}
inline void input() {
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].push_back(make_pair(v, w));
g[v].push_back(make_pair(u, w));
}
}
inline void show() {
if (sp[n] != INF) {
long long x = n;
while (x >= 1) {
path.push_back(x);
x = par[x];
}
for (long long i = path.size() - 1; i >= 0; i--) cout << path[i] << ' ';
} else
cout << -1;
cout << endl;
}
int32_t main() {
input();
dijkstra(1);
show();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans = 1e9, mn = 1e9;
int main() {
cin >> n >> k;
long long l = 1, r = n;
while (l <= r) {
bool ok = false;
long long mid = (l + r) / 2;
long long s = 0, time = 0, g = 0;
while (s < n) {
if (mid - pow(k, g) < 0) {
ok = true;
break;
}
s += mid / pow(k, g);
++g;
}
if (ok) {
l = mid + 1;
continue;
}
if (mid < ans) {
ans = mid;
r = (mid - 1);
} else
l = (mid + 1);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 228;
int64_t k[MAXN], l[MAXN];
int64_t d[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, f;
int64_t ans = 0;
cin >> n >> f;
for (int i = 0; i < n; ++i) {
cin >> k[i] >> l[i];
ans += min(k[i], l[i]);
if (2 * k[i] > l[i]) {
d[i] = l[i] - min(l[i], k[i]);
} else {
d[i] = k[i];
}
}
sort(d, d + n);
reverse(d, d + n);
for (int i = 0; i < f; ++i) {
ans += d[i];
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const int maxn = 1e6 + 5;
int n;
struct query {
int t, x, y;
query(int _t, int _x, int _y) : t(_t), x(_x), y(_y) {}
};
vector<query> ev[maxn];
int a[maxn];
vector<int> t[maxn];
void build(int v, int tl, int tr) {
for (int i = 0; i <= 100; i++) {
t[v].push_back(i);
}
if (tl != tr) {
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
}
}
void upd(int v, int tl, int tr, query Q) {
if (tl == tr) {
t[v][Q.x] = Q.y;
} else {
int tm = (tl + tr) / 2;
if (tl <= Q.t && Q.t <= tm) {
upd(2 * v, tl, tm, Q);
} else {
upd(2 * v + 1, tm + 1, tr, Q);
}
for (int i = 0; i <= 100; i++) {
t[v][i] = t[2 * v + 1][t[2 * v][i]];
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int q;
cin >> q;
build(1, 1, q);
for (int i = 1; i <= q; i++) {
int l, r, x, y;
cin >> l >> r >> x >> y;
ev[l].push_back({i, x, y});
ev[r + 1].push_back({i, x, x});
}
for (int i = 1; i <= n; i++) {
for (auto e : ev[i]) {
upd(1, 1, q, e);
}
int cur = t[1][a[i]];
cout << cur << " ";
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (n % 2 == 0) {
puts("Marsel");
return 0;
}
bool hv = 0;
for (int i = 1; (i * i <= m) && (i <= m / k); i++) {
if (m % i == 0) {
if ((m / i >= k) && (m / i > 1) && (i != 1)) {
hv = 1;
break;
}
if ((i >= k) && (i != m)) {
hv = 1;
break;
}
}
}
if (hv) {
puts("Timur");
return 0;
}
puts("Marsel");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ans[200000] = {0};
void solve() {
int n, k;
cin >> n >> k;
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());
set<int> idx;
queue<int> q;
for (int i = n - 1; i >= 0; --i) q.push(a[i].second);
for (int i = 0; i < n; ++i) idx.insert(i);
int tren = 1;
while (!idx.empty()) {
while (!idx.count(q.front())) q.pop();
int pos = q.front();
q.pop();
vector<int> add;
auto it = idx.find(pos);
for (int i = 0; i <= k; ++i) {
add.push_back(*it);
if (it == idx.begin()) break;
--it;
}
it = next(idx.find(pos));
for (int i = 0; i < k; ++i) {
if (it == idx.end()) break;
add.push_back(*it);
++it;
}
for (int i = 0; i < add.size(); ++i) {
ans[add[i]] = tren;
idx.erase(add[i]);
}
if (tren == 2)
tren = 1;
else
tren = 2;
}
for (int i = 0; i < n; ++i) cout << ans[i];
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 10;
int n, m, par[maxn], u, v;
long long z[maxn], sum, sums, ans;
pair<int, int> a[maxn];
vector<int> vec[maxn], now[maxn], p;
int gpar(int x) {
if (par[x] == x) return x;
return par[x] = gpar(par[x]);
}
inline bool mrg(int x, int y) {
x = gpar(x);
y = gpar(y);
if (x == y) return 0;
par[y] = x;
z[x] += z[y];
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
par[i] = i;
z[i] = 1;
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
cin >> u >> v;
u--;
v--;
vec[u].push_back(v);
vec[v].push_back(u);
}
for (int i = n - 1; i >= 0; i--) {
p.clear();
for (int j = 0; j < ((int(now[a[i].second].size()))); j++)
p.push_back(gpar(now[a[i].second][j]));
sort(p.begin(), p.end());
p.resize(unique(p.begin(), p.end()) - p.begin());
sum = sums = 0;
for (int j = 0; j < ((int(p.size()))); j++) {
sum += z[p[j]];
sums += z[p[j]] * z[p[j]];
}
ans += ((sum * sum - sums) / 2 + sum) * a[i].first;
for (int j = 0; j < ((int(p.size()))); j++) mrg(a[i].second, p[j]);
for (int j = 0; j < ((int(vec[a[i].second].size()))); j++)
now[vec[a[i].second][j]].push_back(a[i].second);
}
cout << setprecision(10) << fixed
<< (long double)ans * (long double)2 / (long double)n /
(long double)(n - 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int nn, p, q, s, sum = 0, sum1 = 0, sum2 = 0;
scanf("%d", &nn);
while (nn--) {
scanf("%d%d%d", &p, &q, &s);
sum += p;
sum1 += q;
sum2 += s;
}
if (sum == 0 && sum1 == 0 && sum2 == 0)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, ans = 0;
string s;
cin >> n >> x >> y >> s;
for (int i = (int)s.size() - 1, j = 0; j < x; --i, ++j) {
if (j != y && s[i] == '1') ++ans;
if (j == y && s[i] == '0') ++ans;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
vector<int> E;
int n, v[N], len[N];
long long dp[N], tot;
bool in[N];
void Mod(int u) {
int w = min(v[u], v[u + 1]);
if (w > 0) v[u] -= w, v[u + 1] -= w, E.push_back(u), tot += w;
}
int main() {
scanf("%d", &n);
n += 1;
for (int i = 1; i < n; i++) scanf("%d", v + i);
dp[1] = v[1];
len[1] = 1;
dp[2] = v[2];
len[2] = 1;
for (int i = 3; i <= n; i++) {
long long w1 = dp[i - 2] + v[i], w2 = dp[i - 3] + max(v[i - 1], v[i]);
if (w1 < w2)
dp[i] = w1, len[i] = 1;
else
dp[i] = w2, len[i] = 2;
}
for (int u = n; u > 0; u -= len[u] + 1)
for (int v = 0; v < len[u]; v++) in[u - v] = true;
for (int u = 1; u < n; u++)
if (in[u] && in[u + 1]) Mod(u);
for (int u = 1; u < n; u++) Mod(u);
assert(tot == dp[n]);
printf("%u\n", E.size());
for (int u : E) printf("%d\n", u);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, x, y, z;
while (cin >> n) {
map<int, map<int, set<int>>> mp;
map<tuple<int, int, int>, int> mp2;
for (int i = 1; i <= n; i++) {
cin >> x >> y >> z;
mp2[make_tuple(x, y, z)] = i;
if (!mp.count(x)) mp[x] = map<int, set<int>>();
if (!mp[x].count(y)) mp[x][y] = set<int>();
mp[x][y].insert(z);
}
for (auto it : mp) {
for (auto it1 : it.second) {
if (it1.second.size() > 1) {
vector<tuple<int, int, int>> v;
for (auto it2 : it1.second) {
tuple<int, int, int> t = make_tuple(it.first, it1.first, it2);
v.push_back(t);
mp[it.first][it1.first].erase(it2);
}
if (v.size() % 2 == 1) {
mp[get<0>(v.back())][get<1>(v.back())].insert(get<2>(v.back()));
v.pop_back();
}
for (int i = 0; i < v.size(); i += 2)
cout << mp2[v[i]] << " " << mp2[v[i + 1]] << endl;
}
}
}
for (auto it : mp) {
vector<tuple<int, int, int>> v;
for (auto it1 : it.second) {
for (auto it2 : it1.second) {
v.push_back(make_tuple(it.first, it1.first, it2));
mp[it.first][it1.first].erase(it2);
}
}
if (v.size() % 2 == 1) {
mp[get<0>(v.back())][get<1>(v.back())].insert(get<2>(v.back()));
v.pop_back();
}
for (int i = 0; i < v.size(); i += 2)
cout << mp2[v[i]] << " " << mp2[v[i + 1]] << endl;
}
vector<tuple<int, int, int>> res;
for (auto it : mp) {
for (auto it1 : it.second) {
for (auto it2 : it1.second) {
tuple<int, int, int> t = make_tuple(it.first, it1.first, it2);
res.push_back(t);
}
}
}
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i += 2) {
cout << mp2[res[i]] << " " << mp2[res[i + 1]] << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int N;
cin >> N;
vector<int> ans(N);
vector<int> sum(N);
for (int i = 1; i < N; i++) {
cout << '?' << " " << 1 << " " << i + 1 << endl;
fflush(stdout);
int s;
cin >> s;
sum[i] = s;
}
cout << '?' << " " << 2 << " " << N << endl;
fflush(stdout);
int s;
cin >> s;
ans[0] = sum[N - 1] - s;
sum[0] = ans[0];
for (int i = 1; i < N; i++) {
ans[i] = sum[i] - sum[i - 1];
}
cout << '!';
for (int i = 0; i < N; i++) {
cout << " " << ans[i];
}
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
T = 1;
for (int i = 0; i < T; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double a, b, gcd, n1, n2, n3, n4, cnt1, cnt2, maxi, mini, cnt, ans1, ans2, n,
x[200000 + 5], room, p;
double tmp1, tmp2;
double c(double tp1, double tp2, double down) {
double ret = 1;
for (int i = 0; i < down; i++) {
ret *= (tp1 - i) / (tp2 - i);
}
return ret;
}
int main() {
cin >> n >> room >> p;
double sum = 0;
for (int i = 0; i < room; i++) {
cin >> x[i];
if (i == p - 1) a = x[i];
sum += x[i];
}
double ans = c(sum - a, sum - 1, n - 1);
if (sum < n)
printf("%d\n", -1);
else
printf("%.7f\n", 1 - ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * 100100;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
int n, q, curt, tin[MAXN], tout[MAXN];
long long lv[MAXN], ans[MAXN];
vector<pair<int, int>> g[MAXN];
vector<tuple<int, int, int>> qr[MAXN];
struct no {
int beg, end, mid;
long long mn, lz;
no *l, *r;
no(int beg, int end, long long v[])
: beg(beg), end(end), mid((beg + end) >> 1), lz(0), mn(v[beg]) {
if (beg != end)
l = new no(beg, mid, v), r = new no(mid + 1, end, v),
mn = min(l->mn, r->mn);
}
void refresh() {
mn += lz;
if (beg != end) l->lz += lz, r->lz += lz;
lz = 0;
}
void upd(int a, int b, long long inc) {
if (b < beg || end < a) return;
if (a <= beg && end <= b) return lz += inc, refresh();
refresh();
l->upd(a, b, inc), r->upd(a, b, inc);
mn = min(l->mn, r->mn);
}
long long get(int a, int b) {
if (b < beg || end < a) return LINF;
refresh();
if (a <= beg && end <= b) return mn;
return min(l->get(a, b), r->get(a, b));
}
};
void dfs(int v, long long dist = 0) {
tin[v] = ++curt;
lv[curt] = (g[v].empty() ? dist : LINF);
for (const auto &[u, w] : g[v]) dfs(u, dist + w);
tout[v] = curt;
}
void solve(int v, no &seg, long long acc = 0) {
for (const auto &[l, r, id] : qr[v]) ans[id] = seg.get(l, r) + acc;
for (const auto &[u, w] : g[v]) {
seg.upd(1, tin[u] - 1, w);
seg.upd(tin[u], tout[u], -w);
seg.upd(tout[u] + 1, curt, w);
solve(u, seg, acc);
seg.upd(1, tin[u] - 1, -w);
seg.upd(tin[u], tout[u], w);
seg.upd(tout[u] + 1, curt, -w);
}
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 2, p, w; i <= n; ++i)
scanf("%d %d", &p, &w), g[p].emplace_back(i, w);
for (int i = 1; i <= n; ++i) sort(g[i].begin(), g[i].end());
dfs(1);
no seg(1, curt, lv);
for (int i = 1, v, l, r; i <= q; ++i)
scanf("%d %d %d", &v, &l, &r), qr[v].emplace_back(l, r, i);
solve(1, seg);
for (int i = 1; i <= q; ++i) printf("%lld\n", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAXN = 100005;
const long long MOD = 1000000007;
int n, m, p[MAXN], t[MAXN];
vector<int> edge[MAXN];
int sz[MAXN], in[MAXN], ch[MAXN], pa[MAXN], dep[MAXN], tp[MAXN];
bool state[MAXN];
void dfs_sz(int nd) {
sz[nd] = 1;
for (auto v : edge[nd]) {
dfs_sz(v);
sz[nd] += sz[v];
if (sz[v] > sz[ch[nd]]) {
ch[nd] = v;
}
}
}
int tme;
void dfs_ord(int nd, int pp) {
in[nd] = tme++;
pa[in[nd]] = in[p[nd]];
dep[in[nd]] = dep[in[p[nd]]] + 1;
tp[nd] = pp;
if (ch[nd] != 0) {
dfs_ord(ch[nd], pp);
}
for (auto v : edge[nd]) {
if (v != ch[nd]) {
dfs_ord(v, v);
}
}
}
int cnt[MAXN], ans;
bool des[MAXN];
template <int dl>
void chain(int l, int r) {
if (dl > 0) {
for (int i = l; i <= r; i++) {
ans += cnt[i] == 0;
cnt[i]++;
}
} else {
for (int i = l; i <= r; i++) {
cnt[i]--;
ans -= cnt[i] == 0;
}
}
}
void upd(int nd, int dl) {
int lf = nd;
while (nd != 0) {
if (dl > 0) {
chain<1>(in[tp[nd]], in[nd]);
} else {
chain<-1>(in[tp[nd]], in[nd]);
}
nd = p[tp[nd]];
}
lf = in[lf];
if (dl > 0) {
if (cnt[lf] > 0) {
ans--;
}
cnt[lf] += MOD;
} else {
cnt[lf] -= MOD;
if (cnt[lf] > 0) {
ans++;
}
}
}
void on(int nd) { upd(nd, 1); }
void off(int nd) { upd(nd, -1); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 2; i <= n; i++) {
cin >> p[i];
edge[p[i]].emplace_back(i);
}
dfs_sz(1);
dfs_ord(1, 1);
for (int i = 1; i <= n; ++i) {
int tmp;
cin >> tmp;
cnt[in[i]] -= tmp;
}
while (m--) {
int d;
cin >> d;
state[in[abs(d)]] ^= 1;
if (d < 0) {
off(-d);
} else {
on(d);
}
cout << ans << " ";
}
cout << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, i = 0;
string s1, s2;
cin >> n >> s1 >> s2;
while (n) {
int temp1 = s1[i] % 10 - '0', temp2 = s2[i] % 10 - '0';
sum += min(abs(temp1 - temp2),
min((9 - temp1 + (temp2 + 1)), (9 - temp2) + temp1 + 1));
i++, n--;
}
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 5;
long long a[MAXN];
int vis[MAXN];
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(vis, 0, sizeof vis);
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
int flag = 1;
for (int i = 0; i < n; i++) {
if (a[i] == 0) continue;
for (int j = 0; a[i] > 0; j++) {
if (a[i] % k == 0) {
a[i] /= k;
continue;
}
if (a[i] % k == 1 && vis[j] == 0) {
vis[j]++;
a[i] /= k;
} else {
flag = 0;
break;
}
}
if (!flag) break;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000 + 5;
int n;
string s;
bool mark[Maxn][Maxn];
void ok(int l1, int l2, int n1, int n2) {
for (int i = l1; i <= l2; i++)
for (int j = n1; j <= n2; j++) mark[i][j] = mark[j][i] = true;
return;
}
int main() {
cin >> s;
n = (int)s.size();
int lastv = 2, last = 0;
for (int i = 0; i < n; i++) {
if (s[i] != '0') {
for (int j = 0; j < i; j++) {
mark[lastv][last] = mark[last][lastv] = true;
last = lastv;
lastv++;
}
ok(last, last, lastv, lastv + (s[i] - '0') - 1);
int l1 = lastv, l2 = lastv + (s[i] - '0') - 1, n1 = lastv + (s[i] - '0'),
n2 = lastv + (s[i] - '0') + 9;
for (int j = i; j < n - 1; j++) {
ok(l1, l2, n1, n2);
l1 = n1, l2 = n2;
n1 = l2 + 1, n2 = l2 + 10;
}
ok(l1, l2, 1, 1);
lastv = l2 + 1;
last = 0;
}
}
cout << lastv << endl;
for (int i = 0; i < lastv; i++) {
for (int j = 0; j < lastv; j++) {
if (mark[i][j])
printf("Y");
else
printf("N");
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> v;
int t, n;
long long s;
bool ok(int x) {
vector<pair<int, int>> b, c;
int cnt = 0;
long long aux = 0;
for (const auto& [l, r] : v)
if (r < x)
cnt++, aux += l;
else if (x < l)
aux += l;
else
c.emplace_back(l, r);
sort(c.begin(), c.end());
reverse(c.begin(), c.end());
if (cnt > n / 2) return false;
while (cnt < n / 2 && !c.empty()) {
cnt++;
aux += c.back().first;
c.pop_back();
}
aux += 1LL * x * c.size();
return aux <= s;
}
int bs() {
int beg = 0, end = 1e9, mid;
while (beg < end) {
mid = (beg + end + 1) >> 1;
if (ok(mid))
beg = mid;
else
end = mid - 1;
}
return beg;
}
int main() {
for (scanf("%d", &t); t--;) {
scanf("%d %lld", &n, &s);
v.clear();
for (int i = 1, l, r; i <= n; ++i)
scanf("%d %d", &l, &r), v.emplace_back(l, r);
printf("%d\n", bs());
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, l;
int num[110];
int main() {
scanf("%d%d", &n, &l);
int maxx = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
maxx = max(maxx, num[i]);
}
if (maxx < l) {
printf("0\n");
return 0;
}
int ans = 0;
for (int i = l; i <= maxx; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++) tmp += (num[j] / i);
ans = max(ans, tmp * i);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int X = 5009;
const long long inf = (1ll << 60);
long long n, m;
map<string, int> M;
string op[X], val[X], MN, MX;
int l[X], r[X];
int bit(int b, bool a) {
if (a) val[n][b] = '1';
vector<int> vec;
int ret = 0;
for (int i = 0; i < n; i++) {
if (r[i] == -1) {
ret += val[i][b] == '1';
continue;
}
if (op[i] == "AND") {
bool tmp = ((val[l[i]][b] == '1') & (val[r[i]][b] == '1'));
ret += tmp;
if (tmp) {
val[i][b] = '1';
vec.push_back(i);
}
}
if (op[i] == "XOR") {
bool tmp = ((val[l[i]][b] == '1') ^ (val[r[i]][b] == '1'));
ret += tmp;
if (tmp) {
val[i][b] = '1';
vec.push_back(i);
}
}
if (op[i] == "OR") {
bool tmp = ((val[l[i]][b] == '1') | (val[r[i]][b] == '1'));
ret += tmp;
if (tmp) {
val[i][b] = '1';
vec.push_back(i);
}
}
}
for (int i = 0; i < vec.size(); i++) val[vec[i]][b] = '0';
val[n][b] = '0';
return ret;
}
string solve(string s) {
reverse(s.begin(), s.end());
while (s.size() < m) s += '0';
return s;
}
void input(int i) {
string x, y, f, s;
cin >> x >> y >> f;
M[x] = i;
if (f == "?" || M.find(f) != M.end()) {
if (f == "?")
l[i] = n;
else
l[i] = M[f];
cin >> y >> s;
op[i] = y;
if (s == "?")
r[i] = n;
else
r[i] = M[s];
while (val[i].size() < m) val[i] += '0';
return;
}
val[i] = solve(f);
l[i] = r[i] = -1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) input(i);
while (val[n].size() < m) {
val[n] += '0';
MX += '0';
MN += '0';
}
for (int i = 0; i < m; i++) {
int a = bit(i, 0), b = bit(i, 1);
if (a == b) continue;
if (a > b) {
MN[i] = '1';
MX[i] = '0';
}
if (a < b) {
MX[i] = '1';
MN[i] = '0';
}
}
reverse(MX.begin(), MX.end());
reverse(MN.begin(), MN.end());
cout << MN << endl << MX << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const N = 100100;
int a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); ++i) scanf("%d", &a[i]);
int ans = 1, t = 1;
for (int i = 1; i < n; ++i) {
if (a[i] > a[i - 1]) {
++t;
ans = max(ans, t);
} else {
t = 1;
}
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
fast();
long double a1, a2, b2, b1, c2, c1;
cin >> a1 >> a2 >> b1 >> b2 >> c1 >> c2;
;
long double x = (pow((a1 - b1), 2)) + (pow((a2 - b2), 2));
long double z = (pow((b1 - c1), 2)) + (pow((b2 - c2), 2));
if (z == x) {
if (a1 + c1 != 2 * b1 || a2 + c2 != 2 * b2)
cout << "YES";
else
cout << "NO";
} else
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, s;
int main() {
scanf("%d", &s);
scanf("%d%d%d", &a, &b, &c);
if (!a && !b && !c)
puts("0.0 0.0 0.0");
else
printf("%.10lf %.10lf %.10lf", 1. * a / (a + b + c) * s,
1. * b / (a + b + c) * s, 1. * c / (a + b + c) * s);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int nax = 500000 + 10;
int arr[nax], color[nax];
vector<int> graph[nax];
map<int, set<int> > map1;
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> color[i];
while (m--) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
for (auto x : graph[i]) {
if (color[i] != color[x]) map1[color[i]].insert(color[x]);
}
}
int maxi = map1[color[1]].size(), ans = color[1];
for (int i = 2; i <= n; i++) {
if (map1[color[i]].size() == maxi && color[i] < ans) {
ans = color[i];
} else if (map1[color[i]].size() > maxi) {
maxi = map1[color[i]].size();
ans = color[i];
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
string s;
int tree[N][26], lazy[N][26];
void build(int pos, int l, int r) {
if (l == r) {
tree[pos][s[l] - 'a'] = 1;
for (int i = 0; i < 26; ++i) lazy[pos][i] = -1;
return;
}
int mid = (l + r) / 2;
build(2 * pos + 1, l, mid);
build(2 * pos + 2, mid + 1, r);
for (int i = 0; i < 26; ++i)
tree[pos][i] = tree[2 * pos + 1][i] + tree[2 * pos + 2][i],
lazy[pos][i] = -1;
}
void update(int pos, int l, int r, int a, int b, int val, int al) {
if (lazy[pos][al] != -1) {
tree[pos][al] = lazy[pos][al] * (r - l + 1);
if (l != r)
lazy[2 * pos + 1][al] = lazy[pos][al],
lazy[2 * pos + 2][al] = lazy[pos][al];
lazy[pos][al] = -1;
}
if (a <= l && r <= b) {
lazy[pos][al] = val;
tree[pos][al] = lazy[pos][al] * (r - l + 1);
if (l != r)
lazy[2 * pos + 1][al] = lazy[pos][al],
lazy[2 * pos + 2][al] = lazy[pos][al];
lazy[pos][al] = -1;
return;
}
if (r < a || b < l) return;
int mid = (l + r) / 2;
update(2 * pos + 1, l, mid, a, b, val, al);
update(2 * pos + 2, mid + 1, r, a, b, val, al);
tree[pos][al] = tree[2 * pos + 1][al] + tree[2 * pos + 2][al];
}
int querry(int pos, int l, int r, int a, int b, int al) {
if (l > b || r < a) return 0;
if (lazy[pos][al] != -1) {
tree[pos][al] = lazy[pos][al] * (r - l + 1);
if (l != r)
lazy[2 * pos + 1][al] = lazy[pos][al],
lazy[2 * pos + 2][al] = lazy[pos][al];
lazy[pos][al] = -1;
}
if (a <= l && r <= b) return tree[pos][al];
int mid = (l + r) / 2;
return querry(2 * pos + 1, l, mid, a, b, al) +
querry(2 * pos + 2, mid + 1, r, a, b, al);
}
void get(int pos, int l, int r, int al) {
if (lazy[pos][al] != -1) {
tree[pos][al] = lazy[pos][al] * (r - l + 1);
if (l != r)
lazy[2 * pos + 1][al] = lazy[pos][al],
lazy[2 * pos + 2][al] = lazy[pos][al];
lazy[pos][al] = -1;
}
if (tree[pos][al] == 0) return;
if (l == r) {
s[l] = al + 'a';
return;
}
int mid = (l + r) / 2;
get(2 * pos + 1, l, mid, al);
get(2 * pos + 2, mid + 1, r, al);
}
int cnt[26];
int main() {
int i, j, a, b, n, m, k;
cin >> n >> m >> s;
build(0, 0, n - 1);
for (i = 0; i < m; ++i) {
scanf("%d%d%d", &a, &b, &k);
int cur = --a;
--b;
if (k == 0) cur = b;
for (j = 0; j < 26; ++j) cnt[j] = querry(0, 0, n - 1, a, b, j);
for (j = 0; j < 26; ++j) {
if (cnt[j] == 0) continue;
update(0, 0, n - 1, a, b, 0, j);
if (k) {
update(0, 0, n - 1, cur, cur + cnt[j] - 1, 1, j);
cur += cnt[j];
} else {
update(0, 0, n - 1, cur - cnt[j] + 1, cur, 1, j);
cur -= cnt[j];
}
}
}
for (i = 0; i < 26; ++i) get(0, 0, n - 1, i);
cout << s << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, s, at[1001];
int main() {
scanf("%d%d", &n, &s);
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
at[a] = max(at[a], b);
}
int res = 0;
for (int i = s; i >= 0; --i) {
if (i != s) ++res;
res += max(0, at[i] - res);
}
printf("%d\n", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define fr first
#define sc second
long long n,m,dg[3069],dsu[3069],od[3069],sq[6069],zs=0;
pair<long long,long long> ed[3069];
vector<pair<long long,long long>> al[3069];
bitset<3069> spc,vtd;
long long fd(long long x)
{
if(dsu[x]!=x)
{
dsu[x]=fd(dsu[x]);
}
return dsu[x];
}
void eup(long long x)
{
long long sz=al[x].size(),l,p;
for(;od[x]<sz;)
{
l=al[x][od[x]].fr;
p=al[x][od[x]].sc;
od[x]++;
if(!vtd[p])
{
vtd[p]=1;
eup(l);
}
}
zs++;
sq[zs]=x;
}
int main()
{
long long i,j,r,ii,k,l,sz,p,c,st;
scanf("%lld%lld",&n,&m);
for(i=1;i<=m;i++)
{
scanf("%lld%lld",&k,&l);
ed[i]={k,l};
for(ii=0;ii<2;ii++)
{
al[k].push_back({l,i});
dg[k]++;
swap(k,l);
}
}
for(i=1;i<=n;i++)
{
sz=al[i].size();
for(j=-1;j<sz;j++)
{
for(r=0;r<sz;r++)
{
l=al[i][r].fr;
p=al[i][r].sc;
if(r!=j&&dg[l]%2)
{
spc[p]=1;
dg[i]--;
dg[l]--;
}
}
c=0;
for(r=1;r<=n;r++)
{
c+=r!=i&&dg[r]%2;
dsu[r]=r;
}
if(c<=1)
{
for(r=1;r<=m;r++)
{
k=ed[r].fr;
l=ed[r].sc;
if(!spc[r])
{
dsu[fd(l)]=fd(k);
}
}
for(r=1;r<=m;r++)
{
if(fd(r)!=fd(i)&&dg[r])
{
break;
}
}
if(r>m)
{
break;
}
}
for(r=0;r<sz;r++)
{
l=al[i][r].fr;
p=al[i][r].sc;
if(spc[p])
{
spc[p]=0;
dg[i]++;
dg[l]++;
}
}
}
if(j<sz)
{
break;
}
}
if(i>n)
{
printf("0\n");
return 0;
}
st=i;
for(i=1;i<=n;i++)
{
al[i].clear();
}
for(i=1;i<=m;i++)
{
k=ed[i].fr;
l=ed[i].sc;
if(!spc[i])
{
al[k].push_back({l,i});
al[l].push_back({k,i});
}
}
eup(st);
zs++;
sq[zs]=-1;
for(i=1;i<=m;i++)
{
k=ed[i].fr;
l=ed[i].sc;
if(spc[i])
{
if(k!=st)
{
swap(k,l);
}
zs++;
sq[zs]=l;
zs++;
sq[zs]=k;
}
}
printf("%lld\n",zs);
for(i=1;i<=zs;i++)
{
printf("%lld%c",sq[i]," \n"[i==zs]);
}
} | 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 26;
int n, ans, par[N], nxt[N][M];
vector<pair<string, int> > ch[N];
string s;
int solve(string s1, int p) {
for (int i = 0; i < s1.size(); i++) {
p = nxt[p][s1[i] - 'a'];
if (p == s.size()) ans++;
}
return p;
}
void dfs(int v, int p) {
for (pair<string, int> ps : ch[v]) {
int tmp = solve(ps.first, p);
dfs(ps.second, tmp);
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int p;
string ps;
cin >> p >> ps;
p--;
ch[p].push_back({ps, i});
}
cin >> s;
int p = 0;
nxt[0][s[0] - 'a'] = 1;
for (int i = 1; i <= s.size(); i++) {
for (int j = 0; j < 26; j++) {
if (s[p] - 'a' == j)
nxt[i][j] = p + 1;
else
nxt[i][j] = nxt[p][j];
}
if (i < s.size()) {
nxt[i][s[i] - 'a'] = i + 1;
if (s[i] == s[p])
p++;
else
p = nxt[p][s[i] - 'a'];
}
}
dfs(0, 0);
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int find(int *x, int *y, int L, int R) {
if (x[L - 1] == y[L - 1]) return -1;
int X = x[L - 1];
if (y[R] < X) return R;
while (L < R - 1) {
int C = (L + R) / 2;
if (y[C] < X)
L = C;
else
R = C;
}
while (y[L] < X) L++;
return L - 1;
}
int main() {
int N;
scanf("%d", &N);
int *x = new int[N + 1];
int *y = new int[N + 1];
for (int i = 1; i <= N; i++) scanf("%d", &x[i]);
y[N] = x[N];
for (int i = N - 1; i > 0; --i) y[i] = min(x[i], y[i + 1]);
for (int i = 1; i <= N; i++) {
x[i] = find(x, y, i + 1, N);
if (x[i] > 0) x[i] -= (i + 1);
}
for (int i = 1; i <= N; i++) printf("%d ", x[i]);
delete[] y;
delete[] x;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[200050];
long long n, m;
long long sum[200050];
int main() {
long long i, j;
while (scanf("%lld", &n) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + 1 + n);
sum[0] = 0;
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
if (n == 1 || n == 2) {
printf("1\n");
printf("%lld\n", a[1]);
continue;
}
long long l, r, d, m1, m2, t1, t2;
long long mid = 1, len = 0, zong = 0;
long long zong1, mid1, len1;
for (i = 2; i <= n - 1; i++) {
l = 1;
r = min(i - 1, n - i);
for (j = 1; j <= 100; j++) {
m1 = (2 * l + r) / 3;
m2 = (l + 2 * r + 2) / 3;
t1 = sum[i] - sum[i - m1 - 1] + sum[n] - sum[n - m1];
t2 = sum[i] - sum[i - m2 - 1] + sum[n] - sum[n - m2];
if (t1 * (2 * m2 + 1) < t2 * (2 * m1 + 1)) {
l = m1 + 1;
} else
r = m2 - 1;
}
zong1 =
sum[i] - sum[i - l - 1] + sum[n] - sum[n - l] - (2 * l + 1) * a[i];
len1 = l;
mid1 = i;
if (zong1 * (2 * len + 1) > zong * (2 * len1 + 1)) {
zong = zong1;
len = len1;
mid = mid1;
}
}
printf("%lld\n", len * 2 + 1);
int flag = 1;
for (i = mid - len; i <= mid; i++) {
if (flag) {
flag = 0;
printf("%lld", a[i]);
} else {
printf(" %lld", a[i]);
}
}
for (i = n - len + 1; i <= n; i++) {
printf(" %lld", a[i]);
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10, INF = 1e9;
struct Node {
int mx1, mx2, cnt;
int t1, t2;
long long sum;
};
struct Segment {
Node tree[maxN * 4 + 1];
void pushup(int node) {
tree[node].sum = tree[node << 1].sum + tree[node << 1 | 1].sum;
tree[node].cnt = 0;
tree[node].mx1 = max(tree[node << 1].mx1, tree[node << 1 | 1].mx1);
tree[node].mx2 = max(tree[node << 1].mx2, tree[node << 1 | 1].mx2);
if (tree[node].mx1 != tree[node << 1].mx1)
tree[node].mx2 = max(tree[node].mx2, tree[node << 1].mx1);
else
tree[node].cnt += tree[node << 1].cnt;
if (tree[node].mx1 != tree[node << 1 | 1].mx1)
tree[node].mx2 = max(tree[node].mx2, tree[node << 1 | 1].mx1);
else
tree[node].cnt += tree[node << 1 | 1].cnt;
}
void pushdown(int node, int l, int r) {
int mid = (l + r) >> 1, t1 = tree[node].t1, t2 = tree[node].t2;
tree[node].t1 = tree[node].t2 = 0;
if (t2) {
tree[node << 1].mx1 += t2;
tree[node << 1].mx2 += t2;
tree[node << 1].t2 += t2;
tree[node << 1].sum += 1ll * (mid - l + 1) * t2;
tree[node << 1 | 1].mx1 += t2;
tree[node << 1 | 1].mx2 += t2;
tree[node << 1 | 1].t2 += t2;
tree[node << 1 | 1].sum += 1ll * (r - mid) * t2;
}
if (t1) {
int mx = max(tree[node << 1].mx1, tree[node << 1 | 1].mx1);
if (tree[node << 1].mx1 == mx) {
tree[node << 1].mx1 += t1;
tree[node << 1].t1 += t1;
tree[node << 1].sum += 1ll * tree[node << 1].cnt * t1;
}
if (tree[node << 1 | 1].mx1 == mx) {
tree[node << 1 | 1].mx1 += t1;
tree[node << 1 | 1].t1 += t1;
tree[node << 1 | 1].sum += 1ll * tree[node << 1 | 1].cnt * t1;
}
}
}
void build(int node, int l, int r) {
tree[node].t1 = tree[node].t2 = 0;
if (l == r) {
tree[node].mx1 = tree[node].sum = 0;
tree[node].cnt = 1;
tree[node].mx2 = -INF;
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
pushup(node);
}
void change(int node, int l, int r, int x, int y, int v) {
if (x <= l && r <= y) {
tree[node].mx1 += v;
tree[node].mx2 += v;
tree[node].t2 += v;
tree[node].sum += 1ll * (r - l + 1) * v;
return;
}
pushdown(node, l, r);
int mid = (l + r) >> 1;
if (x <= mid) change(node << 1, l, mid, x, y, v);
if (y > mid) change(node << 1 | 1, mid + 1, r, x, y, v);
pushup(node);
}
void modify(int node, int l, int r, int x, int y, int v) {
if (tree[node].mx1 <= v) return;
if (x <= l && r <= y) {
if (v > tree[node].mx2) {
tree[node].sum += 1ll * tree[node].cnt * (v - tree[node].mx1);
tree[node].t1 += v - tree[node].mx1;
tree[node].mx1 = v;
return;
}
pushdown(node, l, r);
int mid = (l + r) >> 1;
modify(node << 1, l, mid, x, y, v);
modify(node << 1 | 1, mid + 1, r, x, y, v);
pushup(node);
return;
}
pushdown(node, l, r);
int mid = (l + r) >> 1;
if (x <= mid) modify(node << 1, l, mid, x, y, v);
if (y > mid) modify(node << 1 | 1, mid + 1, r, x, y, v);
pushup(node);
}
long long query(int node, int l, int r, int x, int y) {
if (x <= l && r <= y) return tree[node].sum;
pushdown(node, l, r);
int mid = (l + r) >> 1;
long long ans = 0;
if (x <= mid) ans += query(node << 1, l, mid, x, y);
if (y > mid) ans += query(node << 1 | 1, mid + 1, r, x, y);
return ans;
}
} L, R;
int n, a[maxN + 1];
inline int read() {
int num = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
return num * f;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[read()] = i;
L.build(1, 1, n);
R.build(1, 1, n);
for (int i = 1; i <= n; i++) {
int x = a[i];
R.change(1, 1, n, x, n, 1);
L.change(1, 1, n, x, n, -1);
int v = R.query(1, 1, n, x, x);
if (x - 1 >= 1) R.modify(1, 1, n, 1, x - 1, v - 1);
if (x + 1 <= n) L.modify(1, 1, n, x + 1, n, -v);
L.change(1, 1, n, x, x, v);
R.change(1, 1, n, x, x, i - v);
printf("%lld\n", R.query(1, 1, n, 1, n) + L.query(1, 1, n, 1, n));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int myPow(int a, int b) {
long long res = 1;
for (int i = 1; i <= b; ++i) res = (res * a) % 1000000007;
return res;
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
if (k == 1 || n < k)
printf("%d\n", myPow(m, n));
else if (n == k)
printf("%d\n", myPow(m, n / 2 + (n & 1)));
else if (k % 2 == 1)
printf("%d\n", m * m);
else
printf("%d\n", m);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
cin >> n;
long long ans = (n + 4ll) * (n + 3ll) * (n + 2ll) * (n + 1ll) * (n) / 120ll;
ans *= (n + 2ll) * (n + 1ll) * (n) / 6ll;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans, n, x;
cin >> n;
ans = 1 + (n + 1) * 6 * n / 2;
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, i, j;
cin >> n;
vector<int> a(n);
for (i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
for (i = 0, j = n - 1; i < j; j--, i++) {
a.push_back(a[j]);
a.push_back(a[i]);
}
if (n % 2) a.push_back(a[j]);
for (i = a.size() - 1; i >= n; i--) cout << a[i] << " ";
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a[26];
memset(a, 0, sizeof(a));
vector<pair<int, int> > v;
for (int i = 0; i < s.length(); i++) {
a[s[i] - 97]++;
}
for (int i = 0; i < 26; i++) {
if (a[i] > 0) v.push_back(make_pair(i + 97, a[i]));
}
sort(v.rbegin(), v.rend());
int pointer = 0;
int current = v[pointer].first;
string ans = "";
for (int i = 0; i < s.length(); i++) {
if (s[i] == current) {
ans += s[i];
}
a[s[i] - 97]--;
if (a[s[i] - 97] == 0 && s[i] == current) {
pointer++;
while (pointer < v.size() && a[v[pointer].first - 97] == 0) {
pointer++;
}
if (pointer < v.size()) {
current = v[pointer].first;
} else
break;
}
}
cout << ans << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, long long> dp;
long long v[200005];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, q, result = 0, a, b, c;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> v[i], result += v[i];
cin >> q;
for (long long i = 0; i < q; i++) {
cin >> a >> b >> c;
pair<long long, long long> over = make_pair(a, b);
long long upper = dp[over];
result += upper && ++v[upper] >= 1;
dp[over] = c;
result -= c && --v[c] >= 0;
cout << result << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int num[maxn];
int T;
int tot1, tot2;
int need1[maxn];
int need2[maxn];
void read() {
cin >> T;
for (int i = 0; i < T; i++) {
scanf("%d", &num[i]);
int kase = sqrt(num[i]);
if (kase * kase == num[i]) {
if (num[i] == 0) {
need1[tot1] = 2;
tot1++;
} else {
need1[tot1] = 1;
tot1++;
}
} else {
need2[tot2] = min(num[i] - kase * kase, (kase + 1) * (kase + 1) - num[i]);
tot2++;
}
}
return;
}
int main() {
read();
long long cnt = 0;
sort(need1, need1 + tot1);
sort(need2, need2 + tot2);
for (int i = 0; i < (T / 2) - tot1; i++) {
cnt += need2[i];
}
for (int i = 0; i < (T / 2) - tot2; i++) {
cnt += need1[i];
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int first = 0;
cout << '{';
for (auto &i : x) cout << (first++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
template <class T>
void remdup(vector<T> &v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <typename T>
struct cmp {
bool operator()(const T &p1, const T &p2) {}
};
const long long N = 2e5 + 100;
const long long mod = 1e9 + 7;
const long long X = 2e5 + 100;
vector<long long> factor(long long n) {
vector<long long> res;
for (long long i = (1); i < (floor(sqrt(n)) + 1); ++i)
if (n % i == 0) {
res.push_back(i);
if (i != n / i) res.push_back(n / i);
}
return res;
}
vector<long long> check(N, -1);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
long long n;
cin >> n;
for (long long i = (0); i < (n); ++i) {
long long x, y;
cin >> x >> y;
vector<long long> a = factor(x);
long long count1 = 0;
for (long long j = (0); j < (((long long)(a.size()))); ++j) {
if (check[a[j]] < i - y || check[a[j]] == -1) count1++;
check[a[j]] = i;
}
cout << count1 << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int LOG = 59;
const int maxn = 100005;
const int inf = 1000000000;
long long int a[maxn];
int dp[2][maxn];
int csum[maxn];
vector<long long int> f, s;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
dp[0][0] = 0;
for (int i = 1; i <= n; i++) dp[0][i] = inf;
for (int b = 0; b < LOG; b++) {
int pos = b + 1;
for (int i = 1; i <= n; i++) csum[i] = csum[i - 1] + ((a[i] >> b) & 1);
for (int i = 0; i <= n; i++) dp[pos & 1][i] = inf;
for (int i = 0; i <= n; i++) {
for (int w = 0; w <= 1; w++) {
int l1 = csum[i], l0 = i - l1;
int r1 = csum[n] - l1, r0 = (n - i) - r1;
int to = l1 + (l0 + r1) * !w;
int cost = (l1 + r0) * w + (l0 + r1) * !w;
dp[pos & 1][to] = min(dp[pos & 1][to], dp[b & 1][i] + cost);
}
}
f.clear();
s.clear();
for (int i = 1; i <= n; i++) {
if ((a[i] >> b) & 1)
f.push_back(a[i]);
else
s.push_back(a[i]);
}
int idx = 0;
for (long long int x : f) a[++idx] = x;
for (long long int x : s) a[++idx] = x;
}
printf("%d", dp[LOG & 1][0]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const long long N = 2111;
const double eps = 1e-8, pi = acos(-1);
const double INF = 1e9;
inline double sqr(double x) { return x * x; }
inline bool zero(double x) { return (x > 0 ? x : -x) < eps; }
inline int sgn(double x) { return (x > eps ? 1 : (x + eps < 0 ? -1 : 0)); }
struct point {
double x, y;
point(double x, double y) : x(x), y(y) {}
point() {}
bool operator==(const point &a) const {
return zero(x - a.x) && zero(y - a.y);
}
bool operator!=(const point &a) const {
return (!zero(x - a.x)) || (!zero(y - a.y));
}
bool operator<(const point &a) const {
return (sgn(x - a.x) < 0 || sgn(x - a.x) == 0 && sgn(y - a.y) == 0);
}
point operator+(const point &a) const { return point(x + a.x, y + a.y); }
point operator-(const point &a) const { return point(x - a.x, y - a.y); }
point operator*(const double &a) const { return point(x * a, y * a); }
point operator/(const double &a) const { return point(x / a, y / a); }
double operator*(const point &a) const { return x * a.y - y * a.x; }
double operator^(const point &a) const { return x * a.x + y * a.y; }
double length() const { return sqrt(sqr(x) + sqr(y)); }
} p[N], oval;
struct circle {
double r;
point o;
} O;
inline point intersection(const point &u1, const point &u2, const point &v1,
const point &v2) {
return u1 + (u2 - u1) * (((u1 - v1) * (v1 - v2)) / ((u1 - u2) * (v1 - v2)));
}
inline point ptoline(const point &p, const point &l1, const point &l2) {
point t = p;
t.x += l1.y - l2.y;
t.y += l2.x - l1.x;
return intersection(p, t, l1, l2);
}
inline double disptoline(const point &p, const point &l1, const point &l2) {
return fabs((p - l2) * (l1 - l2)) / (l1 - l2).length();
}
long long n, R;
char s[N];
bool vis[N];
vector<long long> ans;
int main() {
n = read();
double start = 1e18;
long long id = 1;
for (long long i = (1); i <= (n); ++i) scanf("%lf%lf", &p[i].x, &p[i].y);
scanf("%s", s + 1);
for (long long i = (1); i <= (n); ++i)
if (p[i].y < start) start = p[i].y, id = i;
ans.push_back(id);
vis[id] = 1;
for (long long i = (1); i <= (n - 2); ++i) {
long long nxt;
if (s[i] == 'R') {
nxt = 0;
for (long long j = (1); j <= (n); ++j)
if (!vis[j]) {
if (!nxt || (p[nxt] - p[id]) * (p[j] - p[id]) > 0) nxt = j;
}
} else {
nxt = 0;
for (long long j = (1); j <= (n); ++j)
if (!vis[j]) {
if (!nxt || (p[nxt] - p[id]) * (p[j] - p[id]) < 0) nxt = j;
}
}
id = nxt;
ans.push_back(id);
vis[id] = 1;
}
for (long long i = (1); i <= (n); ++i)
if (!vis[i]) ans.push_back(i);
for (long long i = (1); i <= (n - 2); ++i) {
long long id1 = ans[i - 1], id2 = ans[i], id3 = ans[i + 1];
double ang1 = atan2(p[id2].y - p[id1].y, p[id2].x - p[id1].x);
double ang2 = atan2(p[id3].y - p[id2].y, p[id3].x - p[id2].x);
if (ang2 < ang1) ang2 += 2 * pi;
}
for (long long i = (0); i < (n); ++i)
printf("%lld%c", ans[i], i == n - 1 ? 10 : 32);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long rin() {
long long s = 0;
bool bj = false;
char c = getchar();
for (; (c > '9' || c < '0') && c != '-'; c = getchar())
;
if (c == '-') bj = true, c = getchar();
for (; c >= '0' && c <= '9'; c = getchar())
s = (s << 1) + (s << 3) + (c ^ '0');
if (bj) return -s;
return s;
}
const int N = 6e5 + 3;
const int M = 1e9 + 7;
inline int prpr(int x, int y) { return 1LL * x * y % M; }
inline int ksm(int x, int y) {
int ans = 1;
for (; y; y >>= 1) {
if (y & 1) ans = prpr(ans, x);
x = prpr(x, x);
}
return ans;
}
int pw[N];
int sl[N];
int sr[N];
int mu[N];
bool pri[N];
vector<int> prime;
int Gura_do_not_know_my_exist;
int CS[N];
inline int cs(int n) {
if (CS[n]) return CS[n];
int ans = 0;
for (int l = 1, r, nw; l <= n; l = r + 1)
r = n / (nw = n / l),
ans = (ans + prpr(mu[r] - mu[l - 1], prpr(nw, nw))) % M;
return CS[n] = ans;
}
inline void init(int n) {
pw[0] = 1;
for (int i = 1; i < N; i++) pw[i] = (pw[i - 1] << 1) % M;
pw[0] = 0;
for (int i = 2; i < N; i++) pw[i] = (pw[i - 1] + pw[i]) % M;
sl[0] = 1;
for (int i = 1; i < N; i++) sl[i] = prpr(sl[i - 1], i);
sr[N - 1] = ksm(sl[N - 1], M - 2);
sr[0] = 1;
for (int i = N - 2; i >= 1; i--) sr[i] = prpr(sr[i + 1], i + 1);
mu[1] = 1;
for (int i = 2, now; i < N; i++) {
if (!pri[i]) prime.push_back(i), mu[i] = -1;
for (vector<int>::iterator j = prime.begin(); j != prime.end(); j++) {
if ((now = (*j) * i) >= N) break;
pri[now] = true;
if (i % (*j) == 0) break;
mu[now] = -mu[i];
}
mu[i] += mu[i - 1];
}
for (int l = 1, r, nw; l <= n; l = r + 1) {
r = n / (nw = n / l);
Gura_do_not_know_my_exist += prpr(pw[r] - pw[l - 1], cs(nw));
Gura_do_not_know_my_exist %= M;
}
return;
}
inline int C(int a, int b) {
return (a < b || b < 0) ? (0) : (prpr(sl[a], prpr(sr[b], sr[a - b])));
}
inline int Gcd(int a, int b) { return (!b) ? (a) : (Gcd(b, a % b)); }
int n;
int ans;
string S, T;
inline void work(int i, int a, int b, int x, int y) {
a += i;
b += i;
if (!a && !b) {
ans = (ans + prpr(Gura_do_not_know_my_exist, C(x + y, i + y))) % M;
return;
}
if ((1LL * a * b) <= 0) return;
int c = Gcd(a, b);
a /= c;
b /= c;
ans = (ans + prpr(pw[n / max(a, b)], C(x + y, i + y))) % M;
return;
}
inline bool check(int s, int t) {
if (s != t) return false;
for (int i = 0; i < s; i++)
if (S[i] != T[i] || S[i] == '?' || T[i] == '?') return false;
printf("%d\n", prpr(pw[n], pw[n]));
return true;
}
int main() {
int s, t, a, b, x, y;
a = b = x = y = 0;
cin >> S >> T;
s = S.length();
t = T.length();
n = rin();
init(n);
if (check(s, t)) return 0;
for (int i = 0; i < s; i++) {
if (S[i] == 'A') a++;
if (S[i] == 'B') b--;
if (S[i] == '?') x++;
}
for (int i = 0; i < t; i++) {
if (T[i] == 'A') a--;
if (T[i] == 'B') b++;
if (T[i] == '?') y++;
}
for (int i = -y; i <= x; i++) work(i, a, b + y - x, x, y);
if (s == t) {
int cut = 1;
for (int i = 0; i < s; i++) {
if (S[i] == '?' && T[i] == '?') {
cut = (cut << 1) % M;
continue;
}
if (S[i] == '?' || T[i] == '?' || S[i] == T[i]) continue;
cut = 0;
break;
}
ans = (ans + prpr(prpr(pw[n], pw[n]) - Gura_do_not_know_my_exist, cut)) % M;
ans = (ans + M) % M;
}
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
char BB[1 << 23], *SS = BB, *TT = BB;
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
}
x *= fu;
}
template <typename T>
inline void readp(T &x) {
x = 0;
int fu = 1;
char c =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
}
if (c == 46) {
double y = 1;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
while (c <= 57 && c >= 48) {
x = x + (y *= 0.1) * (c - 48);
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
}
}
x *= fu;
}
inline void readc(char &x) {
char c =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
while (c == ' ' || c == '\n' || c == '\r')
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
x = c;
}
inline void reads(char x[], int pos = 0) {
char c =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
while (c == ' ' || c == '\n' || c == '\r')
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
while (c ^ ' ' && c ^ '\n' && c ^ '\r')
x[pos++] = c,
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
x[pos] = '\0';
}
inline void readl(char x[], int pos = 0) {
char c =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
while (c == '\n' || c == '\r')
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
while (c ^ '\n' && c ^ '\r')
x[pos++] = c,
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 23, stdin), SS == TT)
? EOF
: *SS++);
x[pos] = '\0';
}
char out[1 << 22], *Out = out;
inline void putcha(char x) {
*Out++ = x;
if (Out - out >= (1 << 22)) fwrite(out, 1, Out - out, stdout), Out = out;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putcha(45), x = -x;
if (x > 9) fprint(x / 10);
putcha(x % 10 + 48);
}
template <typename T>
inline void fprint(T x, char ch) {
fprint(x);
putcha(ch);
}
inline void prints(char c[]) {
int pos = 0;
while (c[pos] != '\0') putcha(c[pos++]);
}
inline void prints(char c[], char ch) {
int pos = 0;
while (c[pos] != '\0') putcha(c[pos++]);
putcha(ch);
}
inline void prints(const char c[]) {
int pos = 0;
while (c[pos] != '\0') putcha(c[pos++]);
}
inline void prints(const char c[], char ch) {
int pos = 0;
while (c[pos] != '\0') putcha(c[pos++]);
putcha(ch);
}
} // namespace IO
using namespace IO;
void write(int x) {
if (x < 0) {
putchar('-');
x = (-x);
}
if (x > 9) write(x / 10);
putchar((x % 10) + '0');
}
void writeln(int x) {
write(x);
puts("");
}
const int N = 1e6 + 95;
const int M = 1e6 + 95;
const int SqrtN = 1e4 + 95;
int n, m, a[N], Block, len, pos[N];
int ql[SqrtN], qr[SqrtN];
struct query {
int opt, l, r, x;
} q[M];
int ans[M];
int fa[N], rt[N], cnt[N];
int val[N], tmp, tag;
int find(int x) {
if (fa[x] == x) return x;
return (fa[x] = find(fa[x]));
}
void Merge(int x, int y) {
if (!rt[x]) return;
if (!rt[y]) {
rt[y] = rt[x];
val[rt[x]] = y;
} else {
fa[rt[x]] = rt[y];
}
cnt[y] += cnt[x];
rt[x] = 0;
cnt[x] = 0;
}
void Build(int l, int r) {
tmp = 0;
tag = 0;
for (int i = l; i <= r; i++) {
tmp = max(tmp, a[i]);
cnt[a[i]]++;
if (rt[a[i]]) {
fa[i] = rt[a[i]];
} else {
val[i] = a[i];
rt[a[i]] = i;
fa[i] = i;
}
}
return;
}
void Updata(int p, int x) {
if ((tmp - tag) > (x * 2)) {
for (int i = tag + 1; i <= tag + x; i++) Merge(i, i + x);
tag += x;
} else {
for (int i = x + tag + 1; i <= tmp; i++) Merge(i, i - x);
tmp = min(tmp, x + tag);
}
return;
}
void Rebuild(int l, int r, int p, int x) {
for (int i = l; i <= r; i++) {
a[i] = val[find(i)];
if (rt[a[i]]) {
rt[a[i]] = 0;
cnt[a[i]] = 0;
}
}
for (int i = l; i <= r; i++) {
a[i] -= tag;
val[i] = 0;
}
for (int i = max(l, q[p].l); i <= min(r, q[p].r); i++)
if (q[p].x < a[i]) a[i] -= q[p].x;
Build(l, r);
return;
}
int Query(int l, int r, int p, int x) {
if ((x + tag) > (1e5 + 1)) return 0;
if (q[p].l <= l && r <= q[p].r) {
return cnt[(x + tag)];
}
int step = 0;
for (int i = max(l, q[p].l); i <= min(r, q[p].r); i++) {
if ((val[find(i)] - tag) == x) step++;
}
return step;
}
int main() {
read(n);
read(m);
len = sqrt(n);
Block = (n + len - 1) / len;
for (int i = 1; i <= n; i++) pos[i] = ((i - 1) / len + 1);
for (int i = 1; i <= Block; i++) ql[i] = max(1, (i - 1) * len + 1);
for (int i = 1; i <= Block; i++) qr[i] = min(n, i * len);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= m; i++) {
read(q[i].opt);
read(q[i].l);
read(q[i].r);
read(q[i].x);
}
for (int i = 1; i <= Block; i++) {
memset(rt, 0, sizeof(rt));
memset(cnt, 0, sizeof(cnt));
Build(ql[i], qr[i]);
for (int j = 1; j <= m; j++) {
if (q[j].r < ql[i] || qr[i] < q[j].l) continue;
if (q[j].opt == 1) {
if (q[j].l <= ql[i] && qr[i] <= q[j].r)
Updata(j, q[j].x);
else
Rebuild(ql[i], qr[i], j, q[j].x);
} else {
ans[j] += Query(ql[i], qr[i], j, q[j].x);
}
}
}
for (int i = 1; i <= m; i++)
if (q[i].opt == 2) writeln(ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, l, n, m, x;
map<long long int, long long int> mymap;
set<pair<long long int, long long int> > s;
map<long long int, long long int>::iterator it;
vector<long long int> arr;
set<pair<long long int, long long int> >::const_iterator it1;
vector<long long int>::iterator it3;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
mymap[x]++;
}
long long int count = 0;
for (it = mymap.begin(); it != mymap.end(); it++) {
s.insert(make_pair(it->second, it->first));
}
long long int final = 0;
count = s.size();
long long int p1, q1, r1, p2, q2, r2;
while (count >= 3) {
it1 = s.end();
it1--;
p1 = (it1->first) - 1;
p2 = (it1->second);
arr.push_back((it1)->second);
s.erase(it1);
count--;
it1 = s.end();
it1--;
q1 = (it1->first) - 1;
q2 = (it1->second);
arr.push_back((it1)->second);
s.erase(it1);
count--;
it1 = s.end();
it1--;
r1 = (it1->first) - 1;
r2 = (it1->second);
arr.push_back((it1)->second);
s.erase(it1);
count--;
if (p1 > 0) {
s.insert(make_pair(p1, p2));
count++;
}
if (q1 > 0) {
s.insert(make_pair(q1, q2));
count++;
}
if (r1 > 0) {
s.insert(make_pair(r1, r2));
count++;
}
final++;
}
cout << arr.size() / 3 << endl;
x = arr.size() / 3;
it3 = arr.begin();
while (it3 != arr.end()) {
sort(it3, it3 + 3);
cout << *(it3 + 2) << " " << *(it3 + 1) << " " << (*it3) << endl;
it3 = it3 + 3;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int check(long long x) {
int y = x, temp;
while (y > 7) {
temp = y % 10;
if (temp == 8)
return 1;
else {
y = y - temp;
y = y / 10;
}
}
return 0;
}
int main() {
long long x, answer, y;
cin >> x;
y = abs(x);
if (x == -8)
cout << "16" << endl;
else if (x == -7)
cout << "15" << endl;
else if (x == -6)
cout << "14" << endl;
else if (x == -5)
cout << "13" << endl;
else if (x == -4)
cout << "12" << endl;
else if (x == -3)
cout << "11" << endl;
else if (x == -2)
cout << "10" << endl;
else if (x == -1)
cout << "9" << endl;
else if (x == 0)
cout << "8" << endl;
else {
for (long long i = 1; i < 100; i++) {
if (x > 0)
answer = check(y + i);
else
answer = check(y - i);
if (answer == 1) {
answer = i;
break;
}
}
cout << answer << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
if (b < 0) {
b = -1 * b;
while (b != 0) {
a--;
b--;
if (a == 0) a = n;
}
cout << a << endl;
} else {
while (b != 0) {
a++;
b--;
if (a == n + 1) a = 1;
}
cout << a << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
if (m == 1) {
cout << "-1\n";
return 0;
}
const int inf = 1e9;
vector<int> cnt(n + 1);
for (int i = 1; i <= n; ++i) {
if (i <= m) {
cnt[i] = 1;
} else {
cnt[i] = 2 + cnt[i - (m - 1)];
}
}
vector<int> ans(n + 1);
for (int i = 1; i <= n; ++i) {
if (2 * i <= m) {
ans[i] = 1;
} else {
if (m >= 4) {
ans[i] = 2 + ans[i - (m / 2) + 1];
} else {
ans[i] = inf;
}
if (i <= m) {
int z = m - i;
if (n - i + z > 0) {
ans[i] = min(ans[i], 2 + cnt[i - z + 1]);
}
}
}
}
int res = inf;
for (int t = 0; t < n; ++t) {
int curr = (t + (m - 2)) / (m - 1);
curr *= 2;
if (2 * n - t <= m) {
res = min(res, curr + 1);
} else {
if (n <= m) {
int z = min(n - t, m - n);
if (t + z > 0) {
res = min(res, curr + 2 + cnt[n - t - z + 1]);
}
}
if (m < t) {
continue;
}
int a = (m - t) / 2;
if (t + a < 1) {
continue;
}
res = min(res, curr + 2 + ans[n - t - a + 1]);
}
}
cout << (res == inf ? -1 : res) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
const long long inf = 1e18;
int N, M, K;
pair<int, int> lights[maxn];
vector<pair<int, int>> g[maxn * 10];
unordered_map<int, unordered_map<int, int>> mp;
long long dis[maxn * 10];
bool vis[maxn * 10];
void dijstra(int src) {
for (int i = 1; i <= K + N + M; ++i) {
dis[i] = inf;
vis[i] = 0;
}
dis[src] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
q;
q.push(make_pair(dis[src], src));
while (!q.empty()) {
auto cur = q.top();
q.pop();
int v = cur.second;
if (!vis[v]) {
vis[v] = 1;
for (auto& e : g[v]) {
if (!vis[e.first] && dis[e.first] > dis[v] + e.second) {
dis[e.first] = dis[v] + e.second;
q.push(make_pair(dis[e.first], e.first));
}
}
}
}
}
void show() {
for (int i = 1; i <= N + M + K; ++i) {
cout << i << " : ";
for (auto& e : g[i]) {
printf("(%d , %d) , ", e.first, e.second);
}
cout << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> M >> K;
for (int i = 1; i <= K; ++i) {
cin >> lights[i].first >> lights[i].second;
int x = lights[i].first, y = lights[i].second;
mp[x][y] = i;
}
if (!mp[N][M]) {
mp[N + 1][M + 1] = ++K;
lights[K].first = N + 1;
lights[K].second = M + 1;
}
pair<int, int> dir[4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
for (int i = 1; i <= K; ++i) {
for (int j = 0; j < 4; ++j) {
int dx = lights[i].first + dir[j].first;
int dy = lights[i].second + dir[j].second;
if (mp[dx][dy]) {
int j = mp[dx][dy];
g[i].emplace_back(j, 0);
g[j].emplace_back(i, 0);
}
}
}
for (int i = 1; i <= K; ++i) {
for (int x = -1; x < 2; ++x) {
int row = lights[i].first + x;
if (row >= 1 && row <= N) {
int j = K + row;
g[j].emplace_back(i, 1);
g[i].emplace_back(j, 1);
}
}
for (int y = -1; y < 2; ++y) {
int col = lights[i].second + y;
if (col >= 1 && col <= M) {
int j = K + N + col;
g[j].emplace_back(i, 1);
g[i].emplace_back(j, 1);
}
}
}
dijstra(1);
if (dis[K] >= inf) {
cout << -1 << endl;
} else {
cout << dis[K] / 2 << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
solve();
return 0;
}
void solve() {
string s;
int i;
cin >> s;
if (s[0] == '4') {
cout << "NO";
} else if (s.find("444") != s.npos) {
cout << "NO";
} else {
for (i = 0; i < s.length(); i++) {
if (s[i] != '1' && s[i] != '4') {
cout << "NO";
return;
}
}
cout << "YES";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, l[1010];
char d[1010];
char b[3010][3010];
vector<long long> sx, sy;
void mark(long long x0, long long y0, long long x1, long long y1) {
x0 = lower_bound(sx.begin(), sx.end(), x0) - sx.begin();
y0 = lower_bound(sy.begin(), sy.end(), y0) - sy.begin();
x1 = lower_bound(sx.begin(), sx.end(), x1) - sx.begin();
y1 = lower_bound(sy.begin(), sy.end(), y1) - sy.begin();
if (x0 > x1) swap(x0, x1);
if (y0 > y1) swap(y0, y1);
for (int i = x0; i <= x1; i++)
for (int j = y0; j <= y1; j++) b[i][j] = 1;
}
void dfs(int x, int y) {
if (x < 0 || x >= sx.size() || y < 0 || y >= sy.size() || b[x][y]) return;
b[x][y] = 2;
dfs(x - 1, y);
dfs(x + 1, y);
dfs(x, y - 1);
dfs(x, y + 1);
}
int main() {
scanf("%d", &n);
long long x = 10000000000LL / 2, y = 10000000000LL / 2;
sx.push_back(0);
sx.push_back(10000000000LL + 1);
sy.push_back(0);
sy.push_back(10000000000LL + 1);
for (int i = 0; i <= n; i++) {
sx.push_back(x);
sx.push_back(x + 1);
sy.push_back(y);
sy.push_back(y + 1);
if (i == n) break;
scanf(" %c %d", &d[i], &l[i]);
if (d[i] == 'L')
x -= l[i];
else if (d[i] == 'R')
x += l[i];
else if (d[i] == 'U')
y -= l[i];
else if (d[i] == 'D')
y += l[i];
}
sort(sx.begin(), sx.end());
sx.erase(unique(sx.begin(), sx.end()), sx.end());
sort(sy.begin(), sy.end());
sy.erase(unique(sy.begin(), sy.end()), sy.end());
x = 10000000000LL / 2;
y = 10000000000LL / 2;
for (int i = 0; i < n; i++) {
long long xx = x, yy = y;
if (d[i] == 'L')
x -= l[i];
else if (d[i] == 'R')
x += l[i];
else if (d[i] == 'U')
y -= l[i];
else if (d[i] == 'D')
y += l[i];
mark(xx, yy, x, y);
}
dfs(0, 0);
long long r = 0;
for (int i = 0; i + 1 < sx.size(); i++)
for (int j = 0; j + 1 < sy.size(); j++)
if (b[i][j] != 2) {
r += (sx[i + 1] - sx[i]) * (sy[j + 1] - sy[j]);
}
cout << r << " " << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:128000000")
const int MAXN = 100010;
int n;
map<int, int> m;
int card[MAXN][2];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &card[i][0], &card[i][1]);
if (card[i][0] == card[i][1])
m[card[i][0]]++;
else
for (int j = 0; j < 2; j++) m[card[i][j]]++;
}
int mcnt = 1e9;
int ok = false;
for (auto it = m.begin(); it != m.end(); ++it) {
if (it->second >= ((n + 1) / 2)) {
ok = true;
int cnt = 0;
int ups = 0;
for (int i = 0; i < n; i++) {
if (card[i][0] == it->first) ups++;
}
cnt = max(0, (n + 1) / 2 - ups);
mcnt = min(mcnt, cnt);
}
}
if (ok)
cout << mcnt;
else
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char str[1005][150];
int vv[500], vis[500];
int vs[500];
int main() {
int n, i, j, m;
char s[150];
while (~scanf("%d %s", &n, s)) {
memset(vis, 0, sizeof(vis));
memset(vv, 0, sizeof(vv));
for (i = 0; i < n; i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
vis[s[i]]++;
}
}
scanf("%d", &m);
int t = m;
for (i = 0; i < m; i++) {
scanf("%s", str[i]);
for (j = 0; j < n; j++) {
if (str[i][j] != s[j] && s[j] == '*') {
if (vis[str[i][j]]) break;
} else if (str[i][j] != s[j])
break;
}
if (j == n) {
memset(vs, 0, sizeof(vs));
for (j = 0; j < n; j++) {
if (str[i][j] != s[j] && s[j] == '*') {
if (!vs[str[i][j]]) vv[str[i][j]]++;
vs[str[i][j]] = 1;
}
}
} else
t--;
}
int ans = 0;
for (i = 0; i < 400; i++) {
if (vv[i] == t) ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
string s;
cin>>s;
int t1=count(s.begin(),s.end(),'A');
int t2=count(s.begin(),s.end(),'B');
int t3=count(s.begin(),s.end(),'C');
int a[3];
a[0]=t1;
a[1]=t2;
a[2]=t3;
unordered_map<char,int>m;
m['A']=t1;
m['B']=t2;
m['C']=t3;
sort(a,a+3);
int largest=a[2];
int r=0;
if(a[0]+a[1]!=a[2]){
cout<<"NO"<<endl;
}
else{
int flag=0;
char c,c1;
int open=0;
if(m[s[0]]!=largest){
open++;
c=s[0];
for(auto elem:m){
if(elem.first!=c && m[elem.first]!=largest){
c1=elem.first;
}
}
}
else{
flag=1;
open++;
c=s[0];
}
for(int i=1;i<s.length();i++){
if(flag==1){
if(s[i]==c){
open++;
}
else{
open--;
}
}
else{
if(s[i]==c || s[i]==c1){
open++;
}
else{
open--;
}
}
if(open<0){
r=1;
break;
}
}
if(r==1){
cout<<"NO"<<endl;
}
else{
cout<<"YES"<<endl;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long fastpow(long long a, long long b) {
if (b == 0) return 1;
long long fele = fastpow(a, b / 2);
long long ans = (fele * fele) % mod;
if (b & 1) ans = (ans * a) % mod;
return ans;
}
int main() {
long long n;
cin >> n;
long long hatv = 2;
bool paros = false;
for (int i = 0; i < n; ++i) {
long long ai;
cin >> ai;
if (ai % 2 == 0) paros = true;
hatv = fastpow(hatv, ai);
}
hatv *= fastpow(2, mod - 2);
hatv %= mod;
long long p, q;
if (paros) {
p = (hatv + 1) % mod;
p *= fastpow(3, mod - 2);
p %= mod;
} else {
p = (hatv - 1) % mod;
p *= fastpow(3, mod - 2);
p %= mod;
}
q = hatv;
cout << p << "/" << q << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, i, j, x, y, dad[N], rk[N], X;
vector<int> e[N];
inline void del(int x, int y) {
e[x].erase(find(e[x].begin(), e[x].end(), y));
e[y].erase(find(e[y].begin(), e[y].end(), x));
}
__int128 dfs(int x, int fa) {
dad[x] = fa;
vector<__int128> ve;
for (int y : e[x])
if (y != fa) ve.push_back(dfs(y, x));
if (ve.empty()) return 0;
vector<int> en(ve.size());
auto ck = [&](__int128 x) {
auto val = ve;
int i, j, mxid;
__int128 mx;
for (i = N - 1; i >= 0; --i)
if (x >> i & 1) {
mx = -(__int128(1) << N);
for (j = 0; j < ve.size(); j++)
if (val[j] > mx) mx = val[j], mxid = j;
en[mxid] = i;
val[mxid] -= __int128(1) << i;
}
for (j = 0; j < ve.size(); ++j)
if (val[j] >= 0) return 0;
return 1;
};
int i;
__int128 z = (__int128(1) << N) - 1;
for (i = N - 1; i >= 0; --i)
if (ck(z - (__int128(1) << i))) z -= __int128(1) << i;
assert(ck(z));
i = 0;
for (int y : e[x])
if (y != fa) rk[y] = en[i++];
__int128 ret = 0;
for (i = 0; i < ve.size(); ++i)
ret |= ve[i] & (~((__int128(1) << en[i]) - 1)) | __int128(1) << en[i];
return ret;
}
inline void upd(int x, int y) {
if (dad[x] == y) swap(x, y);
if (!X || rk[y] > rk[X]) X = y;
}
void gete(int x, int fa) {
for (int y : e[x])
if (y != fa) gete(y, x), upd(x, y);
}
int main() {
scanf("%d", &n);
for (i = 1; i < n; i++)
scanf("%d%d", &x, &y), e[x].push_back(y), e[y].push_back(x);
dfs(1, 0);
for (x = 1; !e[x].empty();) {
X = 0;
gete(x, 0);
del(X, dad[X]);
printf("? %d %d\n", X, dad[X]);
fflush(stdout);
scanf("%d", &x);
}
printf("! %d\n", x);
fflush(stdout);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
double p[100010];
int main(void) {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> p[i];
}
double x = 0.0, ans = 0.0;
for (int i = 0; i < N; ++i) {
x = x * p[i] + p[i];
ans += 2.0 * x;
ans -= p[i];
}
printf("%.9f", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
int a[MAX];
int dit[MAX];
bool check(int x, int y) {
int tx = x;
int cnt = 0;
while (tx > 0) {
tx = (tx >> 1);
++cnt;
}
tx = x & y;
int cntt = 0;
while (tx > 0) {
tx = (tx >> 1);
++cntt;
}
if (cnt == cntt)
return true;
else
return false;
}
int cnt2(int x) {
if (x == 0) return 0;
int ans = 0;
while (x % 2 == 0) {
++ans;
x /= 2;
}
return ans;
}
int get(int h, int &used, int n) {
int t = -1;
for (int i = 0; i < n; i++) {
if ((a[i] >> h) & 1) {
if (t == -1)
t = a[i];
else
t = t & a[i];
++used;
}
}
if (used == 0) return 0;
return cnt2(t);
}
void print(int h, int n) {
for (int i = 0; i < n; i++) {
if ((a[i] >> h) & 1) {
printf("%d ", a[i]);
}
}
}
int getDit(int x) {
int cnt = 0;
while (x > 0) {
x = x >> 1;
++cnt;
}
return cnt;
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
dit[i] = getDit(a[i]);
}
int anscnt = 0;
int index = -1;
int used = 0;
for (int i = 30; i >= 0; i--) {
int tused = 0;
int temp = get(i, tused, n);
if (temp == i && (temp > anscnt || (temp == anscnt && tused > used))) {
anscnt = temp;
used = tused;
index = i;
}
}
if (used == 0) {
printf("1\n");
printf("%d", a[0]);
} else {
printf("%d\n", used);
print(index, n);
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
unsigned long long num, d;
node(unsigned long long a = -1, unsigned long long b = -1) { num = a, d = b; }
bool operator<(const node& a) const { return d > a.d; }
} st[200005];
unsigned long long arr[200005];
priority_queue<node> q[200005];
int main() {
std::ios::sync_with_stdio(false);
unsigned long long n, t;
cin >> n >> t;
for (unsigned long long i = 0; i < n; i++) {
unsigned long long in;
cin >> in;
st[i].d = in;
}
for (unsigned long long i = 0; i < n; i++) {
unsigned long long in;
cin >> in;
st[i].num = in;
}
for (unsigned long long i = 0; i < n; i++) {
q[st[i].num].push(node(st[i].num, st[i].d));
}
unsigned long long mx = 0, add = 0, op = 0;
int pre = 0;
for (unsigned long long i = 1; i <= n; i++) {
if (q[i].size() == 0) continue;
if (q[i].size() != i - pre) {
cout << "No" << endl;
return 0;
}
pre = i;
add += q[i].size();
unsigned long long mul = 1;
unsigned long long flag = 1;
while (!q[i].empty()) {
node now = q[i].top();
q[i].pop();
if (flag == 1) {
flag = 0;
unsigned long long ddt = now.d + t;
if (ddt <= mx) {
cout << "No" << endl;
return 0;
} else {
if (q[i].size() != 0) {
arr[op++] = q[i].top().d + t;
} else {
arr[op++] = ddt;
}
}
} else {
if (q[i].size() != 0) {
arr[op++] = q[i].top().d + t;
} else {
arr[op++] = now.d + t + 1;
}
}
}
mx = arr[op - 1];
}
cout << "Yes" << endl;
for (unsigned long long i = 0; i < op; i++) {
cout << arr[i] << ' ';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, ns;
vector<pair<char, pair<long long, long long> > > v, b, s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> n >> ns;
for (int i = 0; i < n; i++) {
char c;
int pi, qi;
cin >> c >> pi >> qi;
v.push_back(make_pair(c, make_pair(pi, qi)));
}
sort(v.begin(), v.end());
for (int i = n - 1; i >= 0; i--) {
if (v[i].first == 'B') {
if (b.size() > 0 && b.back().second.first == v[i].second.first) {
b.back().second.second += v[i].second.second;
} else
b.push_back(make_pair(
v[i].first, make_pair(v[i].second.first, v[i].second.second)));
} else if (v[i].first == 'S') {
if (s.size() > 0 && s.back().second.first == v[i].second.first) {
s.back().second.second += v[i].second.second;
} else
s.push_back(make_pair(
v[i].first, make_pair(v[i].second.first, v[i].second.second)));
}
}
if (s.size() >= ns) {
int u;
u = s.size() - ns;
for (int i = u; i < s.size(); i++)
cout << s[i].first << " " << s[i].second.first << " "
<< s[i].second.second << endl;
} else
for (int i = 0; i < s.size(); i++) {
cout << s[i].first << " " << s[i].second.first << " "
<< s[i].second.second << endl;
}
if (b.size() >= ns)
for (int i = 0; i < ns; i++)
cout << b[i].first << " " << b[i].second.first << " "
<< b[i].second.second << endl;
else
for (int i = 0; i < b.size(); i++) {
cout << b[i].first << " " << b[i].second.first << " "
<< b[i].second.second << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int shortestPaths[100][100];
int graph[100][100];
void bfs(int start, int n) {
queue<int> q;
q.push(start);
int visited[n];
for (int i = 0; i < n; i++) {
visited[i] = 0;
}
visited[start] = 1;
int dist = 1;
while (true) {
int sz = q.size();
if (sz == 0) {
break;
}
for (int i = 0; i < sz; i++) {
int cur = q.front();
q.pop();
for (int j = 0; j < 100; j++) {
if (graph[cur][j] == 1 && visited[j] == 0) {
visited[j] = 1;
shortestPaths[start][j] = dist;
q.push(j);
}
}
}
dist++;
}
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
shortestPaths[i][j] = 0;
graph[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < n; j++) {
graph[i][j] = (int)(s[j] - '0');
}
}
int m;
cin >> m;
vector<int> vertices;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
a--;
vertices.push_back(a);
}
for (int i = 0; i < n; i++) {
bfs(i, n);
}
vector<int> result;
result.push_back(vertices[0]);
int last = vertices[0];
int ind = 0;
for (int i = 1; i < m; i++) {
if (i != 1) {
if (shortestPaths[last][vertices[i]] < i - ind) {
result.push_back(vertices[i - 1]);
ind = i - 1;
last = vertices[i - 1];
}
}
}
result.push_back(vertices[vertices.size() - 1]);
cout << result.size() << endl;
for (int i = 0; i < result.size(); i++) {
cout << result[i] + 1 << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 500;
const long long mod = 1e9 + 7;
const long long cmod = 998244353;
const long long inf = 1LL << 61;
const int M = 1e6 + 500;
const long long int ths = 1LL << 40;
const int NN = 5e3 + 6;
void solve() {
long long int r, c;
cin >> r >> c;
char a[r + 1][c + 1];
long long int cnt = 0;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
cin >> a[i][j];
if (a[i][j] == 'P') cnt++;
}
}
if (cnt == 0) {
cout << "0\n";
return;
} else if (cnt == r * c) {
cout << "MORTAL\n";
return;
}
long long int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
for (int i = 1; i <= c; i++) {
if (a[1][i] == 'A') c1++;
if (a[r][i] == 'A') c2++;
}
for (int i = 1; i <= r; i++) {
if (a[i][1] == 'A') c3++;
if (a[i][c] == 'A') c4++;
}
if (c1 == c || c2 == c || c3 == r || c4 == r) {
cout << "1\n";
return;
}
bool ok = 0;
long long int cnt1 = 0;
for (int i = 1; i <= r; i++) {
cnt1 = 0;
for (int j = 1; j <= c; j++) {
if (a[i][j] == 'A') cnt1++;
}
if (cnt1 == c) ok = 1;
}
for (int j = 1; j <= c; j++) {
cnt1 = 0;
for (int i = 1; i <= r; i++) {
if (a[i][j] == 'A') cnt1++;
}
if (cnt1 == r) ok = 1;
}
if (a[1][1] == 'A' || a[r][c] == 'A' || a[r][1] == 'A' || a[1][c] == 'A' ||
ok == 1) {
cout << 2 << '\n';
return;
}
if (c1 || c2 || c3 || c4) {
cout << "3\n";
return;
} else {
cout << "4\n";
return;
}
return;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
size_t n, k;
tuple<int, int, int> a[300300];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> k;
for (size_t i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
a[i] = make_tuple(l, r, i + 1);
}
sort(a, a + n);
int id = k - 1;
int max_dist = 0;
priority_queue<int> pq;
for (size_t i = 0; i < n; i++) {
pq.push(-get<1>(a[i]));
if (pq.size() == k) {
int dist = -pq.top() - get<0>(a[i]) + 1;
if (dist > max_dist) {
id = i;
max_dist = dist;
}
pq.pop();
}
}
cout << max_dist << '\n';
int min_r = get<0>(a[id]) + max_dist - 1;
for (int i = 0; i <= id; i++)
if (!max_dist || get<1>(a[i]) >= min_r) cout << get<2>(a[i]) << ' ';
}
| 6 |
#include <bits/stdc++.h>
const int Mod = (int)1e9 + 7;
const int MX = 1073741822;
const long long MXLL = 4611686018427387903;
const int Sz = 1110111;
using namespace std;
inline void Read_rap() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
}
struct node {
int l, m, r;
} t[Sz];
int n;
long long a[Sz];
inline int sign(long long x) {
if (x < 0) return -1;
if (x == 0) return 0;
if (x > 0) return 1;
}
inline void recalc(int v, int tl, int tr) {
int tmid = (tl + tr) >> 1;
t[v].l = t[2 * v].l;
t[v].r = t[2 * v + 1].r;
t[v].m = max(t[2 * v].m, t[2 * v + 1].m);
if (a[tmid] && a[tmid + 1] && sign(a[tmid]) >= sign(a[tmid + 1])) {
t[v].m = max(t[v].m, t[2 * v].r + t[2 * v + 1].l);
if (t[2 * v].l == tmid - tl + 1) t[v].l += t[2 * v + 1].l;
if (t[2 * v + 1].r == tr - tmid) t[v].r += t[2 * v].r;
}
}
void build(int v, int tl, int tr) {
if (tl == tr) {
bool b = (a[tl] != 0);
t[v] = {b, b, b};
return;
}
int tmid = (tl + tr) >> 1;
build(2 * v, tl, tmid);
build(2 * v + 1, tmid + 1, tr);
recalc(v, tl, tr);
}
void upd(int v, int tl, int tr, int id, int x) {
if (tl == tr) {
a[id] += x;
bool b = (a[id] != 0);
t[v] = {b, b, b};
return;
}
int tmid = (tl + tr) >> 1;
if (id <= tmid)
upd(2 * v, tl, tmid, id, x);
else
upd(2 * v + 1, tmid + 1, tr, id, x);
recalc(v, tl, tr);
}
int main() {
Read_rap();
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
n--;
for (int i = 1; i <= n; i++) a[i] = (a[i + 1] - a[i]);
a[n + 1] = -1;
if (n) build(1, 1, n);
int m;
cin >> m;
while (m--) {
if (!n) {
cout << 1 << '\n';
continue;
}
int l, r, d;
cin >> l >> r >> d;
l--;
if (l) upd(1, 1, n, l, d);
if (r <= n) upd(1, 1, n, r, -d);
cout << max(t[1].m, max(t[1].l, t[1].r)) + 1 << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[300005], p[300005], out[300005], n, m, cnt;
long long f[300005];
bool v[300005];
inline void work(int p) {
int t = min(a[p], a[p + 1]);
if (t) out[++m] = p;
a[p] -= t;
a[p + 1] -= t;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
long long O = f[max(i - 2, 0)] + a[i];
long long E = f[max(i - 3, 0)] + max(a[i], a[i - 1]);
f[i] = min(O, E);
v[i] = (f[i] != O);
}
long long ans = min(f[n - 1], f[n]);
for (int i = n - (ans == f[n - 1]); i > 0; i -= 2 + v[i]) p[++cnt] = i;
reverse(p + 1, p + cnt + 1);
for (int i = 1; i <= cnt; i++) {
int pre = p[i - 1], now = p[i];
if (v) work(now - 1);
work(pre + 1);
work(now);
}
printf("%d\n", m);
for (int i = 1; i <= m; i++) printf("%d\n", out[i]);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int ordenadoONo(vector<long long int> numeros, int tam, int pos) {
int respuesta = 1;
if (pos < tam) {
if (numeros[pos] <= numeros[pos + 1])
return ordenadoONo(numeros, tam, pos + 1);
else {
return 0;
}
} else
return respuesta;
}
int main(void) {
ios_base::sync_with_stdio(0);
std::ios::sync_with_stdio(0);
cin.tie(0);
long long int n, m, pos, s = 0;
cin >> n >> m;
while (m--) {
int cur;
cin >> cur;
if (cur >= pos)
s += cur - pos;
else
s += n - (pos - cur);
pos = cur;
}
cout << s - 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200005], b[200005], res[200005];
unsigned long long base[200005], pre[200005], suf[200005];
bool check(int x, int y) {
return pre[y] - pre[x - 1] * base[y - x + 1] ==
suf[x] - suf[y + 1] * base[y - x + 1];
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
b[i - 1] = a[i] - a[i - 1];
}
base[0] = 1;
for (int i = 1; i < n; ++i) base[i] = 131 * base[i - 1];
for (int i = 1; i < n; ++i) pre[i] = pre[i - 1] * 131 + b[i];
for (int i = n - 1; i >= 1; --i) suf[i] = suf[i + 1] * 131 + b[i];
int ans = 0;
for (int i = 1; i <= n; ++i) {
if ((a[1] + a[i] == a[i + 1] + a[n] - m || i == n) &&
(i == 1 || check(1, i - 1)) &&
(i == n || i == n - 1 || check(i + 1, n - 1))) {
ans++;
res[ans] = (a[1] + a[i]) % m;
}
}
sort(res + 1, res + 1 + ans);
printf("%d\n", ans);
for (int i = 1; i <= ans; ++i) printf("%d ", res[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long bal[300005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v, d;
scanf("%d%d%d", &u, &v, &d);
u--;
v--;
bal[u] += d;
bal[v] -= d;
}
vector<int> pos, neg;
for (int i = 0; i < n; ++i) {
if (bal[i] > 0) {
pos.push_back(i);
} else {
neg.push_back(i);
}
}
int i = 0;
int j = 0;
vector<tuple<int, int, long long>> ans;
while (i < pos.size()) {
long long z = min(bal[pos[i]], -bal[neg[j]]);
if (z != 0) ans.push_back(make_tuple(pos[i], neg[j], z));
bal[pos[i]] -= z;
bal[neg[j]] += z;
if (bal[pos[i]] == 0) {
i++;
}
if (bal[neg[j]] == 0) {
j++;
}
}
cout << ans.size() << endl;
for (auto t : ans) {
printf("%d %d %lld\n", get<0>(t) + 1, get<1>(t) + 1, get<2>(t));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *l = buf, *r = buf;
return l == r && (r = (l = buf) + fread(buf, 1, 100000, stdin), l == r)
? EOF
: *l++;
}
template <class T>
void read(T &x) {
x = 0;
int f = 1, ch = nc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = nc();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 - '0' + ch;
ch = nc();
}
x *= f;
}
const int maxn = 5e5 + 50;
const int m = 1e6;
int n, q;
int a[maxn];
namespace seg {
const int maxnode = (m << 2) + 5;
int mn[maxnode];
int cnt[m + 5];
int sum[maxnode];
int tag[maxnode];
inline void change(int u, int d) {
mn[u] += d;
tag[u] += d;
}
inline void pushdown(int u) {
if (tag[u]) {
change(u << 1, tag[u]);
change(u << 1 | 1, tag[u]);
tag[u] = 0;
}
}
inline void pushup(int u) {
mn[u] = min(mn[u << 1], mn[u << 1 | 1]);
sum[u] = 0;
if (mn[u] == mn[u << 1]) sum[u] += sum[u << 1];
if (mn[u] == mn[u << 1 | 1]) sum[u] += sum[u << 1 | 1];
}
void update(int u, int l, int r, int qp, int qv) {
if (l == r) {
cnt[l] += qv;
sum[u] = bool(cnt[l]);
return;
}
int mid = (l + r) >> 1;
pushdown(u);
if (qp <= mid)
update(u << 1, l, mid, qp, qv);
else
update(u << 1 | 1, mid + 1, r, qp, qv);
pushup(u);
}
void update(int u, int l, int r, int ql, int qr, int qv) {
if (l == ql && r == qr) {
change(u, qv);
return;
}
int mid = (l + r) >> 1;
pushdown(u);
if (qr <= mid)
update(u << 1, l, mid, ql, qr, qv);
else if (ql > mid)
update(u << 1 | 1, mid + 1, r, ql, qr, qv);
else {
update(u << 1, l, mid, ql, mid, qv);
update(u << 1 | 1, mid + 1, r, mid + 1, qr, qv);
}
pushup(u);
}
void travel(int u, int l, int r) {
if (l == r) {
if (mn[u] == 1 && sum[u] == 1) fprintf(stderr, "%d\n", l);
return;
}
int mid = (l + r) >> 1;
pushdown(u);
travel(u << 1, l, mid);
travel(u << 1 | 1, mid + 1, r);
}
} // namespace seg
inline void ins(int x, int f) {
seg::update(1, 0, m, a[x], f);
if (x == 1)
seg::update(1, 0, m, a[x], m, f);
else {
if (a[x - 1] > a[x]) seg::update(1, 0, m, a[x], a[x - 1] - 1, f);
}
if (x == n)
seg::update(1, 0, m, 0, a[x] - 1, f);
else {
if (a[x] > a[x + 1]) seg::update(1, 0, m, a[x + 1], a[x] - 1, f);
}
}
int main() {
read(n), read(q);
for (int i = 1; i <= n; ++i) {
read(a[i]);
seg::update(1, 0, m, a[i], 1);
}
seg::update(1, 0, m, a[1], m, 1);
for (int i = 2; i <= n; ++i) {
if (a[i - 1] > a[i]) {
seg::update(1, 0, m, a[i], a[i - 1] - 1, 1);
}
}
seg::update(1, 0, m, 0, a[n] - 1, 1);
for (int i = 1; i <= q; ++i) {
int pos, x;
read(pos), read(x);
ins(pos, -1);
a[pos] = x;
ins(pos, 1);
printf("%d\n", seg::mn[1] == 1 ? seg::sum[1] : 0);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void dk_98() {}
bool compareP(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first)
return true;
else if (a.first == b.first and a.second < b.second)
return true;
return false;
}
void solve() {
int n;
cin >> n;
int odd = 0, even = 0;
for (int i = 0; i < (int)(n); i++) {
int x;
cin >> x;
if (x & 1)
odd++;
else
even++;
}
int ans = 0;
ans += min(odd, even);
odd -= ans;
ans += odd / 3;
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
dk_98();
int t = 1;
while (t--) {
solve();
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int M = 40010;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const double eps = 1e-12;
int c[N];
int n;
int lowb(int i) { return i & (-i); }
void add(int i, int v) {
while (i <= n) {
c[i] += v;
i += lowb(i);
}
}
int sum(int i) {
int ans = 0;
while (i > 0) {
ans += c[i];
i -= lowb(i);
}
return ans;
}
int sumseek(int k) {
int sum = 0, ans = 0;
for (int i = 20; i >= 0; i--) {
ans += (1 << i);
if (ans > n || sum + c[ans] >= k)
ans -= (1 << i);
else
sum += c[ans];
}
return ans + 1;
}
int arr[N];
int a[N];
void solve() {
int m, x;
scanf("%d%d", &n, &m);
memset(arr, -1, sizeof(arr));
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
a[m + 1] = N;
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
if (arr[i] != -1) {
add(i, 1);
} else {
int k = sum(i);
int j = 0;
while (a[j + 1] <= k) j++;
while (j > 0) {
int y = sumseek(a[j]);
add(y, -1);
arr[y] = -1;
j--;
}
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (arr[i] != -1) {
printf("%d", arr[i]);
cnt++;
}
if (cnt == 0)
printf("Poor stack!\n");
else
printf("\n");
}
int main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
void solve() {
long long x1, x2, p1, p2;
cin >> x1 >> p1 >> x2 >> p2;
if (p1 == p2) {
if (x1 == x2) {
printf("=\n");
} else if (x1 > x2)
printf(">\n");
else
printf("<\n");
} else if (p1 > p2) {
if (x1 >= x2)
printf(">\n");
else {
int tt = p1 - p2;
while (tt > 0 && x1 < x2) {
x1 *= 10;
tt--;
}
if (x1 == x2) {
if (tt == 0)
printf("=\n");
else
printf(">\n");
} else if (x1 > x2)
printf(">\n");
else
printf("<\n");
}
} else {
if (x2 >= x1)
printf("<\n");
else {
int tt = p2 - p1;
while (tt > 0 && x2 < x1) {
x2 *= 10;
tt--;
}
if (x1 == x2) {
if (tt == 0)
printf("=\n");
else
printf("<\n");
} else if (x1 < x2)
printf("<\n");
else
printf(">\n");
}
}
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int main() {
int n, m, d;
int a[N] = {0}, b[N] = {0}, c[N] = {0}, s[N] = {0};
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= m; i++) {
scanf("%d", &c[i]);
b[i] = b[i - 1] + c[i];
}
int lst = d;
for (int i = 1; i <= m; i++) {
int fir = n + 1 - (b[m] - b[i - 1]);
s[i] = min(fir, lst);
lst = s[i] + c[i] + d - 1;
}
if (lst <= n) {
printf("NO\n");
} else {
printf("YES\n");
for (int i = 1; i <= m; i++)
for (int j = 0; j < c[i]; j++) a[s[i] + j] = i;
for (int i = 1; i <= n; i++) {
printf("%d", a[i]);
if (i != n)
printf(" ");
else {
printf("\n");
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
if (x > y + z)
cout << "+";
else if (y > x + z)
cout << "-";
else if (z == 0 && x == y)
cout << "0";
else
cout << "?";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long int, vector<long long int>, greater<long long int> > q,
t;
map<pair<long long int, long long int>, long long int> mp;
vector<long long int> p[150005], v(200005, 0);
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
float n, s;
cin >> n >> s;
long long int x, y;
for (long long int i = 1; i < n; i++) {
cin >> x >> y;
p[x].push_back(y);
p[y].push_back(x);
}
float c = 0;
for (long long int i = 1; i <= n; i++) {
if (p[i].size() == 1) {
c++;
}
}
cout << fixed << setprecision(6) << (s / c) * 2 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double pi = 3.1415926535897932;
int main() {
int t;
scanf("%d", &t);
while (t--) {
double len;
scanf("%lf", &len);
len *= 2;
double j = (180 - (len - 2) * 180 / len) / 2 / 180 * pi;
double R = 1 / sin(j), ans = R * cos(90 / len / 180 * pi);
printf("%.9lf\n", ans);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
int a[255];
int main() {
for (int T = rd(); T--;) {
double ave = 0;
int cnt = 0;
for (int i = int(1); i <= (int)(250); i++) a[i] = rd(), ave += a[i];
ave /= 250;
for (int i = int(1); i <= (int)(250); i++)
if (a[i] >= ave * 0.5 && a[i] <= ave * 1.5) cnt++;
if (cnt < 0.7 * 250)
puts("uniform");
else
puts("poisson");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, k, i, j;
int main() {
cin >> x >> y;
while (1) {
if (x >= 2) {
x -= 2;
y -= 2;
} else if (x) {
x--;
y -= 12;
} else {
y -= 22;
}
if (y < 0) {
cout << "Hanako";
return 0;
}
if (y >= 22) {
y -= 22;
} else if (y >= 12) {
x--;
y -= 12;
} else {
x -= 2;
y -= 2;
}
if (x < 0 || y < 0) {
cout << "Ciel";
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
namespace baseFastio {
template <typename Int>
inline Int read() {
Int flag = 1;
char c = getchar();
while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline Int read(char& c) {
Int flag = 1;
c = getchar();
while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline void write(Int x) {
if (x < 0) putchar('-'), x = ~x + 1;
if (x > 9) write(x / 10);
putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch) {
write(x);
putchar(nextch);
}
} // namespace baseFastio
namespace Fastio {
enum io_flags { ignore_int = 1 << 0 };
struct Reader {
char endch;
Reader() { endch = '\0'; }
template <typename Int>
Int operator()() {
return baseFastio::read<Int>(endch);
;
}
Reader& operator>>(io_flags f) {
if (f == ignore_int) baseFastio::read<int>();
return *this;
}
template <typename Int>
Reader& operator>>(Int& i) {
i = baseFastio::read<Int>(endch);
return *this;
}
template <typename Int>
inline Int get_int() {
return baseFastio::read<Int>();
}
inline char get_nxt() { return endch; }
} read;
struct Writer {
Writer& operator<<(const char* ch) {
while (*ch) putchar(*(ch++));
return *this;
}
Writer& operator<<(const char ch) {
putchar(ch);
return *this;
}
template <typename Int>
Writer& operator<<(const Int i) {
baseFastio::write(i);
return *this;
}
} write;
} // namespace Fastio
using namespace Fastio;
namespace against_cpp11 {
const int N = 5e3 + 7;
int n, m;
struct mouse_and_hole {
int x, y;
bool operator<(const mouse_and_hole& b) const { return x < b.x; }
} p[N * 2];
vector<int> hole[N];
struct st {
long long w;
int id;
bool operator<(const st& b) const { return w > b.w; }
};
priority_queue<long long, vector<long long>, greater<long long> > q1;
priority_queue<st> q2;
long long w, ans;
int count_hole_room = 0;
signed main() {
read >> n >> m;
for (int i = 1; i <= n; i++) {
read >> p[i].x;
p[i].y = -1;
}
for (int i = 1; i <= m; i++) {
read >> p[i + n].x >> p[i + n].y;
count_hole_room += p[i + n].y;
}
if (count_hole_room < n) {
puts("-1");
return 0;
}
n += m;
sort(p + 1, p + n + 1);
for (int i = 1, k; i <= n; i++)
if (p[i].y == -1) {
w = INT_MAX;
if (!q2.empty()) {
k = q2.top().id;
w = p[i].x + q2.top().w;
q2.pop();
if (p[k].y) p[k].y--, q2.push((st){-p[k].x, k});
}
ans += w;
q1.push(-p[i].x - w);
} else {
while (p[i].y && !q1.empty() && p[i].x + q1.top() < 0) {
p[i].y--;
w = p[i].x + q1.top();
q1.pop();
ans += w;
q2.push((st){-p[i].x - w, 0});
}
if (p[i].y) q2.push((st){-p[i].x, i}), p[i].y--;
}
write << ans << '\n';
return 0;
}
} // namespace against_cpp11
signed main() { return against_cpp11::main(); }
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp;
int n, m, x, y, a[100005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
scanf("%d%d", &x, &y), mp[pair<int, int>(x, y)] = 1,
mp[pair<int, int>(y, x)] = 1;
for (int i = 1; i <= n; i++) a[i] = i;
for (int i = 1; i <= 200; i++) {
random_shuffle(a + 1, a + n + 1);
bool f = 1;
a[n + 1] = a[1];
for (int j = 1; j <= m; j++)
if (mp[pair<int, int>(a[j], a[j + 1])]) {
f = 0;
break;
}
if (!f) continue;
for (int j = 1; j <= m; j++) printf("%d %d\n", a[j], a[j + 1]);
return 0;
}
puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, sz;
long long ans;
int a[N], tree[N];
set<int> s[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
s[a[i]].insert(i);
}
sort(a + 1, a + n + 1);
int last = 0;
ans = n;
sz = n;
for (int i = 1; i <= n; ++i) {
set<int>::iterator it = s[a[i]].lower_bound(last);
if (it == s[a[i]].end()) {
ans += sz;
it = s[a[i]].begin();
}
last = *it;
--sz;
s[a[i]].erase(it);
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1000003;
struct Hash_table {
int head[1000003], nxt[5000010];
pair<pair<int, int>, int> to[5000010];
int val[5000010];
int tot;
void init() { tot = 1; }
void set(pair<pair<int, int>, int> mask, int v) {
int p = (mask.first.first + 1ll * mask.first.second * 100 +
1ll * mask.second * 10000) %
mod;
for (int i = head[p]; i; i = nxt[i]) {
if (to[i] == mask) {
val[i] = min(val[i], v);
return;
}
}
to[tot] = mask, val[tot] = v, nxt[tot] = head[p], head[p] = tot++;
}
int get(pair<pair<int, int>, int> mask) {
int p = (mask.first.first + 1ll * mask.first.second * 100 +
1ll * mask.second * 10000) %
mod;
for (int i = head[p]; i; i = nxt[i]) {
if (to[i] == mask) return val[i];
}
return -1;
}
} all;
int dir[5][2] = {0, 1, 1, 0, 1, 1, 1, 2, 2, 1};
int n, m;
int dfs(int x, int y, int mask) {
if (y == m) x++, y = 0;
if (x == n) return 0;
pair<pair<int, int>, int> p = make_pair(make_pair(x, y), mask);
if (~all.get(p)) return all.get(p);
int res = INF;
if (mask & 1) res = dfs(x, y + 1, mask >> 1);
if (x != 0 && y != 0) {
int nmask = mask;
for (int i = 0; i < 5; i++) {
int xx = dir[i][0], yy = dir[i][1];
if (xx >= 0 && yy >= 0 && x + xx < n && y + yy < m)
nmask |= 1 << xx * m + yy;
}
if (nmask & 1) res = min(res, dfs(x, y + 1, nmask >> 1) + 1);
all.set(p, res);
return res;
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
int nmask = mask;
for (int i = 0; i < 5; i++) {
int xx = dir[i][0] - j, yy = dir[i][1] - k;
if (xx >= 0 && yy >= 0 && x + xx < n && y + yy < m)
nmask |= 1 << xx * m + yy;
}
if (nmask & 1) res = min(res, dfs(x, y + 1, nmask >> 1) + 1);
}
}
all.set(p, res);
return res;
}
int main() {
scanf("%d%d", &n, &m);
if (m > n) swap(n, m);
printf("%d\n", n * m - dfs(0, 0, 0));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
a += b;
while (a < 0) a += n;
cout << a % n + (a % n == 0) * n;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
char dr;
int val;
} pack;
pack ins[100005];
char mp[1005][1005];
int pos[50][2], cnt[1005][1005][2];
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
vector<char> ret;
int get_dir_n(char c) {
if (c == 'N') return 0;
if (c == 'E') return 1;
if (c == 'S') return 2;
return 3;
}
int main() {
int n, m, i, j, k, c = 0, v;
scanf("%d%d", &n, &m);
gets(mp[0]);
for (i = 0; i < n; i++) {
gets(mp[i]);
for (j = 0; j < m; j++) {
if (mp[i][j] >= 'A' && mp[i][j] <= 'Z') {
pos[c][0] = i;
pos[c++][1] = j;
}
if (mp[i][j] == '#') {
cnt[i + 1][j + 1][0] = cnt[i][j + 1][0] + 1;
cnt[i + 1][j + 1][1] = cnt[i + 1][j][1] + 1;
} else {
cnt[i + 1][j + 1][0] = cnt[i][j + 1][0];
cnt[i + 1][j + 1][1] = cnt[i + 1][j][1];
}
}
}
scanf("%d", &k);
for (i = 0; i < k; i++) {
scanf(" %c %d", &ins[i].dr, &ins[i].val);
}
int possible, si, sj, nsi, nsj, dir, ct;
for (i = 0; i < c; i++) {
si = pos[i][0];
sj = pos[i][1];
possible = 1;
for (j = 0; j < k && possible; j++) {
dir = get_dir_n(ins[j].dr);
nsi = si + (dx[dir] * ins[j].val);
nsj = sj + (dy[dir] * ins[j].val);
if (nsi < 0 || nsi >= n || nsj < 0 || nsj >= m) {
possible = 0;
} else {
if (si == nsi) {
if (sj < nsj)
ct = abs(cnt[si + 1][nsj + 1][1] - cnt[si + 1][sj][1]);
else
ct = abs(cnt[si + 1][sj + 1][1] - cnt[si + 1][nsj][1]);
} else {
if (si < nsi)
ct = abs(cnt[nsi + 1][sj + 1][0] - cnt[si][sj + 1][0]);
else
ct = abs(cnt[si + 1][sj + 1][0] - cnt[nsi][sj + 1][0]);
}
if (ct)
possible = 0;
else {
si = nsi;
sj = nsj;
}
}
}
if (possible) ret.push_back(mp[pos[i][0]][pos[i][1]]);
}
if (ret.size()) {
sort(ret.begin(), ret.end());
for (i = 0; i < ret.size(); i++) {
printf("%c", ret[i]);
}
} else
cout << "no solution" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long DP[51][51];
int Log(long long N) {
long long S = 1;
int Ans = 0;
while (S < N) {
S *= 2;
Ans++;
}
return (N == S) ? Ans : -1;
}
long long Solve(int Level, long long Len, int T) {
if (!Len || T < 0) return 0;
long long Total = 1LL << Level;
if (Len < Total / 2) return Solve(Level - 1, Len, T);
return DP[Level - 1][T] + Solve(Level - 1, Len - Total / 2, T - 1);
}
int main() {
long long N, M;
cin >> N >> M;
int T = Log(M);
if (T == -1) {
printf("0\n");
return 0;
}
DP[0][0] = 1;
for (int i = 0; i < 50; i++)
for (int j = 0; j <= 50; j++) {
DP[i + 1][j] += DP[i][j];
if (j < 50) DP[i + 1][j + 1] += DP[i][j];
}
long long Len = 2, Ans = 0;
int Level = 1;
while (N >= Len) {
Ans += DP[Level][T];
N -= Len;
Len *= 2;
Level++;
}
Ans += Solve(Level, N, T);
cout << Ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = int(1e9);
const int MAX = 100007;
int n, a[MAX], order[MAX], mx;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
order[a[i]] = order[a[i] - 1] + 1;
mx = max(mx, order[a[i]]);
}
cout << n - mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> sn[100005], sp[100005];
bool myfunction(pair<long long, long long> i, pair<long long, long long> j) {
return (i.first > j.first);
}
int main() {
int n, p, a, first = 0, second = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p, &a);
if (p < 0) {
first++;
sn[first] = make_pair(p, a);
} else {
second++;
sp[second] = make_pair(p, a);
}
}
sort(sn, sn + first + 1, myfunction);
sort(sp, sp + second + 1);
for (int i = 1; i <= first; i++) sn[i].second += sn[i - 1].second;
for (int i = 1; i <= second; i++) sp[i].second += sp[i - 1].second;
sn[first + 1] = sn[first];
sp[second + 1] = sp[second];
int m = min(first, second);
long long ans = sp[m + 1].second + sn[m].second;
ans = max(ans, sp[m].second + sn[m + 1].second);
printf("%I64d\n", ans);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
# define ll long long
# define read read1<ll>()
# define Type template<typename T>
Type T read1(){
T t=0;
char k;
bool vis=0;
do (k=getchar())=='-'&&(vis=1);while('0'>k||k>'9');
while('0'<=k&&k<='9')t=(t<<3)+(t<<1)+(k^'0'),k=getchar();
return vis?-t:t;
}
# define fre(k) freopen(k".in","r",stdin);freopen(k".out","w",stdout)
struct node;
int size(node *x);
int height(node *x);
ll sum(node *x);
ll sig(node *x);
struct node{
node *l,*r;
ll x,y,v,g;//a_i;i*a_i
int s,h,f;
node(ll _v=0){l=r=NULL;x=y=v=g=_v;f=0;s=1;h=rand()<<15|rand();}
void pushup(){
x=sum(l)+sum(r)+v;
y=sig(l)+sig(r)+g;
s=size(l)+size(r)+1;
}
void down(){
if(!f)return;
if(l)l->y+=l->x*f,l->f+=f,l->g+=l->v*f;
if(r)r->y+=r->x*f,r->f+=f,r->g+=r->v*f;
f=0;
}
}Sta[400005],*NOW=Sta;
node* New(ll _v=0){*NOW=node(_v);return NOW++;}
int size(node *x){return x?x->s:0;}
ll sum(node *x){return x?x->x:0;}
ll sig(node *x){return x?x->y:0;}
ll val(node *x){return x?x->v:0;}
node* L(node *x){return x?x->l:NULL;}
node* R(node *x){return x?x->r:NULL;}
typedef pair<node*,node*> A;
A split(node *x,ll v){
if(!x)return A(NULL,NULL);
A y;x->down();
if(val(x)<=v){
y=split(x->r,v);
x->r=y.first;
y.first=x;
x->pushup();
}else{
y=split(x->l,v);
x->l=y.second;
y.second=x;
x->pushup();
}return y;
}
A split_(node *x,int v){
if(!x)return A(NULL,NULL);
if(!v)return A(NULL,x);
A y;x->down();
if(size(x->l)<v){
y=split_(x->r,v-size(x->l)-1);
x->r=y.first;
y.first=x;
x->pushup();
}else{
y=split_(x->l,v);
x->l=y.second;
y.second=x;
x->pushup();
}return y;
}
node* merge(node *x,node *y){
if(!x||!y)return x?x:y;
x->down();y->down();
if(x->h<y->h){
x->r=merge(x->r,y);
x->pushup();
return x;
}else{
y->l=merge(x,y->l);
y->pushup();
return y;
}
}
int s,m,S;
node *root;
void insert(ll v){
A x=split(root,v);node *t=New(v);
if(x.second)++x.second->f,x.second->y+=x.second->x,x.second->g+=x.second->v;
t->g=t->y=(size(x.first)+1)*v;
root=merge(merge(x.first,t),x.second);
}
void erase(ll v){
A x=split(root,v),y=split(x.first,v-1);
if(x.second)--x.second->f,x.second->y-=x.second->x,x.second->g-=x.second->v;
root=merge(y.first,x.second);
}
ll pre(int v,node *n=root){
if(!v||!n)return 0;
n->down();
if(v==size(n))return sum(n);
if(v<=size(n->l))return pre(v,n->l);
if(v==size(n->l)+1)return sum(n->l)+n->v;
return sum(n->l)+n->v+pre(v-size(n->l)-1,n->r);
}
ll suf(int v){return sum(root)-pre(S-v);}
ll pre_i(int v){
A x=split_(root,v);
ll t=(v+1)*sum(x.first)-sig(x.first);
root=merge(x.first,x.second);
return t;
}
ll suf_i(int v){
A x=split_(root,S-v);
ll t=sig(x.second)-(S-v)*sum(x.second);
root=merge(x.first,x.second);
return t;
}
ll query(){S=size(root);
int w=0,mid=S>>1;
for(int i=18;i--;){
int d=1<<i|w;
if(d<mid&&pre(d+1)>suf(d))w=d;
}ll ans=0;
if(w)ans=suf_i(w)-pre_i(w)<<1;
if(~S&1)ans+=suf(S-w-1)-pre(w+1);
else if(S>1){
ll lx=pre(w+1),rx=suf(mid),ly=pre(mid+1),ry=suf(S-w-1);
if(rx<ly)ans+=rx+ry-lx-ly;
else ans+=ry-lx;
}return ans;
}
ll a[200005];int tot,H;
node* build(int l,int r){
if(l>r)return NULL;
int mid=l+r>>1;
node *v=New(a[mid]);
v->h=INT_MAX/H*++tot;
v->g=a[mid]*mid;
v->l=build(l,mid-1);
v->r=build(mid+1,r);--tot;
v->pushup();return v;
}
void pr(ll x){
if(x>9)pr(x/10);
putchar(x-x/10*10^'0');
}
int main(){srand(214);
s=read;m=read;
for(int i=1;i<=s;++i)a[i]=read;H=log2(s)+1;
sort(a+1,a+s+1);
root=build(1,s);
printf("%lld\n",query());
for(int i=1;i<=m;++i){
if(read&1)insert(read);
else erase(read);
pr(query());putchar('\n');
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e19;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y % 2 == 1) res = (res * x);
x = (x * x);
y = y / 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<int> v[100001];
int t;
cin >> t;
while (t--) {
long long n, m, i, j, a, b, c, k = 0, r, s = 0, p, x, y, f = 0;
cin >> n >> m;
unordered_map<long long, long long> mp;
for (i = 0; i < m; i++) {
cin >> c;
mp[c]++;
}
c = n, i = 0;
while (c > 0) {
p = c % 2;
c = c / 2;
if (p == 0) {
i++;
continue;
}
a = power(2, i);
i++;
r = a;
y = 0;
for (j = 0; j < i; j++) y = y + mp[power(2, j)] * power(2, j);
if (y >= a) {
while (r > 0) {
b = a / r;
x = min(mp[r], b);
a = a - x * r;
mp[r] -= x;
if (a == 0) break;
r = r / 2;
}
} else {
r = 2 * r;
while (r <= 1e9) {
if (mp[r]) {
mp[r]--;
r /= 2;
s++;
while (r >= a) {
mp[r]++;
if (r == a) break;
r = r / 2;
s++;
}
a = 0;
break;
}
r = r * 2;
}
}
if (a != 0) {
f = 1;
break;
}
}
if (f == 1)
cout << -1 << '\n';
else
cout << s << '\n';
}
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.