solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int read() {
bool f = 0;
int x = 0;
char c = getchar();
while (c < '0' || '9' < c) {
if (c == '-') f = 1;
c = getchar();
}
while ('0' <= c && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return !f ? x : -x;
}
int main() {
int n = read(), m = read(), k = read();
if (n + k < m) {
puts("0");
return 0;
}
if (m <= k) {
puts("1");
return 0;
}
double p = 1, q = 1;
for (int i = 0; i <= k; i++) p *= 1.0 * (m - i), q *= 1.0 * (n + i + 1);
printf("%.8lf\n", 1 - p / q);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string a;
cin >> a;
int l = a.length();
int s1 = 0, s2, e1 = l - 1, e2, s3, e3, len = 0, i;
string b;
while (s1 < e1 && a[s1] == a[e1]) {
s1++;
e1--;
}
if (s1 >= e1) {
cout << a << endl;
;
continue;
}
for (i = 0; i <= s1; i++) b = b + a[i];
for (i = e1 + 1; i < l; i++) b = b + a[i];
len = s1 + l - e1;
s2 = s1;
e2 = e1;
while (s2 < e2) {
if (a[s2] != a[e2])
e2--;
else {
s3 = s2;
e3 = e2;
while (s3 < e3 && a[s3] == a[e3]) {
s3++;
e3--;
}
if (s3 >= e3) {
break;
}
e2--;
}
}
if (s3 >= e3) {
if (len < (e2 + 1 + l - 1 - e1)) {
b.clear();
len = e2 + 1 + l - 1 - e1;
for (i = 0; i <= e2; i++) b = b + a[i];
for (i = e1 + 1; i < l; i++) b = b + a[i];
}
}
s2 = s1;
e2 = e1;
while (s2 < e2) {
if (a[s2] != a[e2])
s2++;
else {
s3 = s2;
e3 = e2;
while (s3 < e3 && a[s3] == a[e3]) {
s3++;
e3--;
}
if (s3 >= e3) {
break;
}
s2++;
}
}
if (s3 >= e3) {
if (len < (s1 + l - s2)) {
b.clear();
len = s1 + l - s2;
for (i = 0; i < s1; i++) b = b + a[i];
for (i = s2; i < l; i++) b = b + a[i];
}
}
if (len == 0)
cout << a[0] << endl;
else
cout << b << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)(1e18);
const int mod = inf + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
int a[1000], x, n, m, pos = -1, ans = 0, mx = 0;
string second;
int main() {
cin >> second;
cin >> n;
for (int i = 0; i < 26; i++) {
cin >> a[i];
if (a[i] > mx) mx = a[i];
}
for (int i = 0; i < (int)second.size(); i++) {
ans += a[second[i] - 'a'] * (i + 1);
}
for (int i = (int)second.size() + 1; i <= (int)second.size() + n; i++)
ans += mx * i;
printf("%d", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 88;
int jj, n, m, i;
long long mst;
int par[maxn], dep[maxn], sz[maxn];
vector<pair<int, int> > g[maxn];
int tin[maxn], tout[maxn], up[maxn][19], mm[maxn][19];
bool inost[maxn];
long long ANS[maxn];
struct ww {
int c, id, x, y, z;
ww() {}
} e[maxn];
inline bool operator<(const ww& a, const ww& b) { return (a.z < b.z); }
int fset(int x) {
if (x == par[x]) return x;
return par[x] = fset(par[x]);
}
void unite(int x, int y) {
x = fset(x);
y = fset(y);
if (x == y) return;
if (sz[x] < sz[y]) swap(x, y);
par[y] = x;
sz[x] += sz[y];
}
void dfs(int x, int fa, int de, int ld) {
tin[x] = ++jj;
dep[x] = de;
up[x][0] = fa;
mm[x][0] = ld;
for (int i = 1; i <= 18; i++) {
up[x][i] = up[up[x][i - 1]][i - 1];
mm[x][i] = max(mm[x][i - 1], mm[up[x][i - 1]][i - 1]);
}
for (int i = 0; i < (int)g[x].size(); i++)
if (g[x][i].first != fa) dfs(g[x][i].first, x, de + 1, g[x][i].second);
tout[x] = ++jj;
}
bool anc(int x, int y) { return tin[x] <= tin[y] && tout[x] >= tout[y]; }
int LCA(int x, int y) {
if (anc(x, y)) return x;
if (anc(y, x)) return y;
for (int i = 18; i >= 0; i--)
if (!anc(up[x][i], y)) x = up[x][i];
return up[x][0];
}
int climb(int x, int y) {
int hh = dep[x] - dep[y], re = -2e9;
for (int i = 0; i <= 18; i++)
if (hh & (1 << i)) {
re = max(re, mm[x][i]);
x = up[x][i];
}
return re;
}
int costs[maxn], xx[maxn], yy[maxn], zz[maxn];
int main() {
long long budget;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &e[i].z), zz[i] = e[i].z;
for (int i = 1; i <= m; i++) scanf("%d", &e[i].c), costs[i] = e[i].c;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &e[i].x, &e[i].y);
e[i].id = i;
xx[i] = e[i].x;
yy[i] = e[i].y;
}
cin >> budget;
sort(e + 1, e + m + 1);
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
for (int i = 1; i <= m; i++)
if (fset(e[i].x) != fset(e[i].y)) {
mst += e[i].z;
unite(e[i].x, e[i].y);
g[e[i].x].push_back(make_pair(e[i].y, e[i].z));
g[e[i].y].push_back(make_pair(e[i].x, e[i].z));
inost[e[i].id] = true;
}
dfs(1, 1, 0, -2e9);
long long Min = 9e18;
int bestRoad = -1;
for (int i = 1; i <= m; i++)
if (inost[e[i].id])
ANS[e[i].id] = mst;
else
ANS[e[i].id] = mst + e[i].z -
max(climb(e[i].x, LCA(e[i].x, e[i].y)),
climb(e[i].y, LCA(e[i].x, e[i].y)));
for (int i = 1; i <= m; i++) {
ANS[i] -= (budget / costs[i]);
if (ANS[i] < Min) {
Min = ANS[i];
bestRoad = i;
}
}
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
vector<pair<int, int> > ans;
unite(xx[bestRoad], yy[bestRoad]);
ans.emplace_back(bestRoad, zz[bestRoad] - (budget / costs[bestRoad]));
cout << Min << endl;
for (int i = 1; i <= m; i++) {
if (fset(e[i].x) == fset(e[i].y)) continue;
unite(e[i].x, e[i].y);
ans.emplace_back(e[i].id, e[i].z);
}
for (auto pp : ans) {
printf("%d %d\n", pp.first, pp.second);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double pi = 3.14159265358979323846264338327950288419716939937511;
const double eps = 1e-13;
char ch_ch_ch[1 << 20];
string gs() {
scanf("%s", ch_ch_ch);
return string(ch_ch_ch);
}
string gl() {
gets(ch_ch_ch);
return string(ch_ch_ch);
}
vector<pair<pair<int, int>, int> > buy;
vector<pair<pair<int, int>, int> > shoe;
int n, m;
long long dp[100100][2][2];
void conv(int b, int fb, int sb, int &nfb, int &nsb) {
nfb = nsb = 0;
if (b + 1 < buy.size()) {
if (buy[b + 1].first.first == buy[b].first.first)
nfb = fb, nsb = sb;
else if (buy[b + 1].first.first == buy[b].first.first + 1)
nfb = sb, nsb = 0;
}
}
long long R(int b, int fb, int sb) {
if (b == buy.size()) return 0;
long long &r = dp[b][fb][sb];
if (r != -1) return r;
int fs = buy[b].first.first;
int ss = fs + 1;
int nfb, nsb;
conv(b, fb, sb, nfb, nsb);
r = R(b + 1, nfb, nsb);
int ind =
lower_bound(shoe.begin(), shoe.end(), make_pair(make_pair(fs, 0), 0)) -
shoe.begin();
if (!fb && ind < shoe.size() && shoe[ind].first.first == fs &&
shoe[ind].first.second <= buy[b].first.second) {
conv(b, 1, sb, nfb, nsb);
r = max(r, shoe[ind].first.second + R(b + 1, nfb, nsb));
}
ind = lower_bound(shoe.begin(), shoe.end(), make_pair(make_pair(ss, 0), 0)) -
shoe.begin();
if (!sb && ind < shoe.size() && shoe[ind].first.first == ss &&
shoe[ind].first.second <= buy[b].first.second) {
conv(b, fb, 1, nfb, nsb);
r = max(r, shoe[ind].first.second + R(b + 1, nfb, nsb));
}
return r;
}
vector<pair<int, int> > res;
void Rec(int b, int fb, int sb) {
if (b == buy.size()) return;
int fs = buy[b].first.first;
int ss = fs + 1;
int nfb, nsb;
conv(b, fb, sb, nfb, nsb);
long long r = R(b + 1, nfb, nsb);
int sh = -1;
int ind =
lower_bound(shoe.begin(), shoe.end(), make_pair(make_pair(fs, 0), 0)) -
shoe.begin();
if (!fb && ind < shoe.size() && shoe[ind].first.first == fs &&
shoe[ind].first.second <= buy[b].first.second) {
conv(b, 1, sb, nfb, nsb);
long long cur = shoe[ind].first.second + R(b + 1, nfb, nsb);
if (cur > r) {
r = cur;
sh = 1;
}
}
ind = lower_bound(shoe.begin(), shoe.end(), make_pair(make_pair(ss, 0), 0)) -
shoe.begin();
if (!sb && ind < shoe.size() && shoe[ind].first.first == ss &&
shoe[ind].first.second <= buy[b].first.second) {
conv(b, fb, 1, nfb, nsb);
long long cur = shoe[ind].first.second + R(b + 1, nfb, nsb);
if (cur > r) {
r = cur;
sh = 2;
}
}
if (sh == -1) {
conv(b, fb, sb, nfb, nsb);
Rec(b + 1, nfb, nsb);
} else if (sh == 1) {
conv(b, 1, sb, nfb, nsb);
Rec(b + 1, nfb, nsb);
ind =
lower_bound(shoe.begin(), shoe.end(), make_pair(make_pair(fs, 0), 0)) -
shoe.begin();
res.push_back(make_pair(buy[b].second, shoe[ind].second));
} else {
conv(b, fb, 1, nfb, nsb);
Rec(b + 1, nfb, nsb);
ind =
lower_bound(shoe.begin(), shoe.end(), make_pair(make_pair(ss, 0), 0)) -
shoe.begin();
res.push_back(make_pair(buy[b].second, shoe[ind].second));
}
}
void solution() {
scanf("%d", &n);
for (int i = 0; i < (n); ++i) {
int c, s;
scanf("%d%d", &c, &s);
shoe.push_back(make_pair(make_pair(s, c), i + 1));
}
scanf("%d", &m);
for (int i = 0; i < (m); ++i) {
int c, s;
scanf("%d%d", &c, &s);
buy.push_back(make_pair(make_pair(s, c), i + 1));
}
sort(buy.begin(), buy.end());
sort(shoe.begin(), shoe.end());
memset(dp, -1, sizeof(dp));
cout << R(0, 0, 0) << endl;
Rec(0, 0, 0);
printf("%d\n", res.size());
for (int i = 0; i < (res.size()); ++i)
printf("%d %d\n", res[i].first, res[i].second);
}
int main(int argc, char **argv) {
solution();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000;
int n, a[maxn], freq[101];
int solve(int d, int v) {
unordered_map<int, int> presum;
presum[0] = -1;
int ans = 0;
int sum = 0;
int minsum = 0, maxsum = 0;
for (int i = 0; i < n; i++) {
if (a[i] == d) sum++;
if (a[i] == v) sum--;
if (sum >= minsum && sum <= maxsum) {
ans = max(ans, i - presum[sum]);
} else
presum[sum] = i;
minsum = min(minsum, sum);
maxsum = max(maxsum, sum);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ans = 0;
cin >> n;
int d = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
freq[a[i]] += 1;
if (freq[d] < freq[a[i]]) d = a[i];
}
for (int i = 1; i <= 100; i++) {
if (d == i) continue;
ans = max(ans, solve(d, i));
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
long long a, b;
int alert = 0;
cin >> a >> b;
for (long long i = 1; i * i <= a; i++) {
if (a % i == 0) {
v.push_back(i);
if (i * i == a) alert = 1;
}
}
int k = v.size();
b--;
if (b < v.size()) {
cout << v[b];
} else if (b + alert >= 2 * v.size()) {
cout << -1;
} else {
cout << a / v[2 * v.size() - b - alert - 1];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 10;
const long long inf = 1e18 + 100;
const long long mod = 1e9 + 7;
struct inv {
int l, r;
};
inv interval[200];
int k = 0;
int vis[200];
void dfs(int node) {
vis[node] = 1;
for (int i = 1; i <= k; i++) {
if (vis[i]) {
continue;
}
if (interval[i].l < interval[node].l && interval[i].r > interval[node].l) {
dfs(i);
} else {
if (interval[i].l < interval[node].r &&
interval[node].r < interval[i].r) {
dfs(i);
}
}
}
}
void solve() {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
long long t, x, y;
cin >> t;
if (t == 1) {
k++;
cin >> interval[k].l >> interval[k].r;
} else {
cin >> x >> y;
memset(vis, 0, sizeof(vis));
dfs(x);
if (vis[y]) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500505;
int n, m, a[maxn], head[maxn];
priority_queue<int, vector<int>, greater<int> > q;
long long sum;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), q.push(a[i]);
while (m--) {
int x = 0;
if (q.empty())
printf("0\n");
else {
x = q.top();
q.pop();
while (((long long)x - sum) == 0LL && q.empty() == 0)
x = q.top(), q.pop();
cout << (long long)x - sum << endl;
sum += ((long long)x - sum);
}
}
}
| 1 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
int main() {
long long int res = 0;
long long int b = 0;
long long int n, p;
cin >> n >> p;
char a[n][10];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i >= 0; i--) {
if (strlen(a[i]) > 5) {
b = b * 2;
res = res + b / 2 * p;
b = b + 1;
res = res + p / 2;
} else {
b = b * 2;
res = res + p * b / 2;
}
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
const int maxn = 2 * 1000 * 100 + 100;
int d[maxn], x[maxn];
vector<pair<int, int> > vec;
bool check[maxn];
int main() {
int n, m, f, g, c;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> d[i] >> x[i];
if (d[i] == 1) {
q.push(i);
}
}
while (q.size() > 0) {
while (q.size() > 0 && d[q.front()] == 0) q.pop();
if (q.size() == 0) break;
int s = q.front();
vec.push_back(make_pair(s, x[s]));
x[x[s]] ^= s;
d[x[s]]--;
if (d[x[s]] == 1) {
q.push(x[s]);
}
q.pop();
}
cout << vec.size() << endl;
for (int i = 0; i < vec.size(); i++) {
cout << vec[i].first << " " << vec[i].second << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> pr;
void sieve() {
int i, j;
bitset<3201> prime;
prime.set();
prime[0] = prime[1] = 0;
for (i = 2; i <= 3200; i++) {
if (prime[i] == 1) {
for (j = i * i; j <= 3200; j += i) prime[j] = 0;
pr.push_back(i);
}
}
}
vector<int> pf;
void p_fac(int n) {
int ans = 1;
for (int i = 0; i < pr.size(); i++) {
int ans = 1;
while (n % pr[i] == 0) {
ans *= pr[i];
n /= pr[i];
}
if (ans != 1) pf.push_back(ans);
}
if (n != 1) pf.push_back(n);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i, a;
cin >> n;
vector<pair<int, int> > ans(n);
sieve();
for (i = 0; i < n; i++) {
pf.clear();
cin >> a;
p_fac(a);
if (pf.size() == 1)
ans[i].first = ans[i].second = -1;
else {
ans[i].first = pf[0];
ans[i].second = a / ans[i].first;
}
cout << ans[i].first << ' ';
}
cout << '\n';
for (i = 0; i < n; i++) cout << ans[i].second << ' ';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.second != b.second)
return (a.second < b.second);
else
return (a.first > b.first);
}
bool bysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first != b.first)
return (a.first > b.first);
else
return (a.second < b.second);
}
long long int cnt = 0;
vector<long long int> vis((long long int)1e3 * 2 + 1, 0);
vector<long long int> a[(long long int)1e4 + 1];
void dfs(long long int r) {
vis[r] = 1;
cnt++;
for (auto i : a[r]) {
if (vis[i] == 0) {
dfs(i);
}
}
}
void solve() {
long long int n;
cin >> n;
vector<long long int> a;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
if (x != 0) a.push_back(x);
}
vector<long long int> b;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
if (x != 0) b.push_back(x);
}
long long int x;
long long int cnt = 0;
n--;
for (long long int i = 0; i < n; i++) {
if (a[i] == b[0]) x = i;
}
long long int i = 0;
while (i < n) {
if (x >= n) x = 0;
if (a[x] != b[i]) {
cout << "NO" << endl;
return;
}
i++;
x++;
}
cout << "YES" << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
;
;
long long int t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
long long int m, n, a, tol, arz;
cin >> m;
cin >> n;
cin >> a;
if (m % a == 0) {
tol = m / a;
} else {
tol = (m / a) + 1;
}
if (n % a == 0) {
arz = n / a;
} else {
arz = (n / a) + 1;
}
long long int temp;
temp = tol * arz;
cout << temp;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238463;
const long long int MOD = 1000000007;
list<long long> ls;
vector<long long> v, v1, v2, vv;
set<long long> s;
map<long long, long long> mp;
stack<char> st;
stack<long long> sti;
inline long long fp(long long bs, long long pw) {
long long res = 1;
while (pw > 0) {
if (pw % 2 == 1) {
res = (res * bs) % MOD;
}
bs = (bs * bs) % MOD;
pw = pw / 2;
}
return res;
}
long long pp(long long bs, unsigned long long pw) {
long long ans = 1;
while (pw > 0) {
if (pw & 1) ans = ans * bs;
pw = pw >> 1;
bs = bs * bs;
}
return ans;
}
bool ff22(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, n, m, k, h, p, i, j, a, b, c, x, V, ind, sz,
ans = 0, ans2, mx, sum = 0, ct = 0, ti, q, temp, t2, mn, ptr, ct1, ct2,
cc, ln, diff;
double kh = 4;
bool fl;
string s, sub, sorted, anss;
cin >> t;
while (t--) {
ct = 0;
cin >> s;
n = s.length();
sub = "";
for (i = 0; i < n; i++) sub.push_back('1');
cin >> x;
for (i = 0; i < n; i++) {
long long ms = i - x;
long long pl = i + x;
if (s[i] == '0') {
if (ms >= 0) {
sub[ms] = '0';
}
if (pl < n) {
sub[pl] = '0';
}
}
}
for (i = 0; i < n; i++) {
long long ms = i - x;
long long pl = i + x;
if (s[i] == '1') {
if ((ms >= 0 && sub[ms] == '1') || (pl < n && sub[pl] == '1'))
continue;
else {
ct++;
break;
}
} else {
if ((ms >= 0 && sub[ms] == '1') || (pl < n && sub[pl] == '1')) {
ct++;
break;
}
}
}
if (ct > 0)
cout << -1 << endl;
else
cout << sub << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[6], i;
while (scanf("%d", &arr[0]) == 1) {
for (i = 1; i < 6; i++) {
scanf("%d", &arr[i]);
}
sort(arr, arr + 6);
if (arr[0] < arr[5] && arr[1] == arr[2] && arr[2] == arr[3] &&
arr[3] == arr[4])
printf("Bear\n");
else if (arr[0] < arr[1] && arr[2] == arr[3] && arr[3] == arr[4] &&
arr[4] == arr[5])
printf("Bear\n");
else if (arr[4] < arr[5] && arr[0] == arr[1] && arr[1] == arr[2] &&
arr[2] == arr[3])
printf("Bear\n");
else if (arr[4] == arr[5] && arr[0] == arr[1] && arr[1] == arr[2] &&
arr[2] == arr[3])
printf("Elephant\n");
else if (arr[0] == arr[1] && arr[2] == arr[3] && arr[3] == arr[4] &&
arr[4] == arr[5])
printf("Elephant\n");
else if (arr[0] == arr[5] && arr[1] == arr[2] && arr[2] == arr[3] &&
arr[3] == arr[4])
printf("Elephant\n");
else
printf("Alien\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int maxm = 20005;
const int inf = 1000000000;
struct node {
int u, v, next;
int val, cost;
} s[maxm * 2];
int ind;
int p[maxn];
int que[10000000];
char v[maxn];
void init() {
ind = 0;
memset(p, -1, sizeof(p));
}
inline void insert(int x, int y, int z, int c) {
s[ind].cost = c;
s[ind].u = x;
s[ind].v = y;
s[ind].val = z;
s[ind].next = p[x];
p[x] = ind++;
s[ind].cost = -c;
s[ind].u = y;
s[ind].v = x;
s[ind].val = 0;
s[ind].next = p[y];
p[y] = ind++;
}
int min_cost_max_flow(int n, int source, int sink, int& netcost) {
int pre[maxn], min[maxn], i, t;
int ret = 0;
for (netcost = 0;;) {
for (i = 0; i < n; i++) pre[i] = -1, min[i] = inf;
pre[source] = -1;
min[source] = 0;
int h = 0, r = 0;
que[0] = source;
memset(v, 0, sizeof(v));
v[source] = 1;
while (h <= r) {
t = que[h++];
v[t] = 0;
for (i = p[t]; i != -1; i = s[i].next) {
int to = s[i].v;
if (s[i].val > 0 && min[t] + s[i].cost < min[to]) {
min[to] = min[t] + s[i].cost;
pre[to] = i;
if (v[to] == 0) {
v[to] = 1;
que[++r] = to;
}
}
}
}
if (pre[sink] == -1) break;
t = inf;
for (i = sink; pre[i] != -1;) {
if (s[pre[i]].val < t) t = s[pre[i]].val;
i = s[pre[i]].u;
}
netcost += min[sink] * t;
ret += t;
for (i = sink; pre[i] != -1;) {
s[pre[i]].val -= t;
s[pre[i] ^ 1].val += t;
i = s[pre[i]].u;
}
}
return ret;
}
int main() {
int n, d;
int a[105], x[105], y[105];
while (cin >> n >> d) {
for (int i = 1; i < n - 1; i++) cin >> a[i];
a[0] = a[n - 1] = 0;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
init();
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (i == j) continue;
int dist = abs(x[j] - x[i]) + abs(y[j] - y[i]);
insert(i, j, 1, d * dist - a[i]);
}
insert(n, 0, 1, 0);
int res;
min_cost_max_flow(n + 1, n, n - 1, res);
cout << res << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n;
cin >> n;
vector<vector<int>> mas;
vector<int> cur(2);
for (i = 0; i < n; i++) {
cin >> cur[0];
cur[1] = i;
mas.push_back(cur);
}
sort(mas.begin(), mas.end());
long long int ans;
ans = 0;
for (i = 1; i < n; i++) {
ans += max(mas[i][1], mas[i - 1][1]) - min(mas[i][1], mas[i - 1][1]);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline void chmin(A &a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A &a, B b) {
if (a < b) a = b;
}
struct data {
long long l, r, s;
data(long long l, long long r, long long s) : l(l), r(r), s(s) {}
};
signed main() {
long long N, C;
cin >> N >> C;
deque<data> d;
long long dx = 0, dy = 0;
vector<long long> T(N);
vector<long long> A(2 * N);
for (long long i = 0; i < (2 * N - 1); i++) cin >> A[i];
T[0] = min(C, A[0]);
d.push_back(data(0, T[0], 0));
for (long long i = 1; i < N; i++) {
dx += A[i * 2 - 1];
dy += A[i * 2 - 1];
if (A[i * 2 - 1]) d.push_front(data(-dx, A[i * 2 - 1] - dx, -dy));
while (d.size() && d.front().l + dx < T[i - 1]) {
if (d.front().r + dx <= T[i - 1]) {
d.pop_front();
} else {
d.front().s += T[i - 1] - (d.front().l + dx);
d.front().l = T[i - 1] - dx;
}
}
dx -= T[i - 1];
dx += A[i * 2];
dy += A[i * 2];
if (A[i * 2]) d.push_front(data(-dx, A[i * 2] - dx, -dy));
while (d.size() && d.back().s + dy + d.back().r - d.back().l > C) {
if (d.back().s + dy >= C)
d.pop_back();
else
d.back().r = C - (d.back().s + dy) + d.back().l;
}
if (d.size()) T[i] = d.back().r + dx;
}
cout << accumulate((T).begin(), (T).end(), 0ll) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long prime[100005];
void seive() {
memset(prime, 1, sizeof(prime));
prime[0] = 0;
prime[1] = 0;
for (long long i = 2; i * i <= 100000; i++) {
if (prime[i] == 1) {
for (long long j = i * i; j <= 100000; j += i) prime[j] = 0;
}
}
}
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans % 1000000007 * a % 1000000007) % 1000000007;
a = (a * a) % 1000000007;
b = b / 2;
}
return ans;
}
void swap(long long *a, long long *b) {
long long c = *a;
*a = *b;
*b = c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
bool codechef = 0;
long long t = 1;
if (codechef) cin >> t;
while (t--) {
long long n;
cin >> n;
long long i, j, a[n];
double sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + n);
if (sum / n >= 4.5) {
cout << "0";
return 0;
}
long long ct = 0;
for (i = 0; i < n; i++) {
if (a[i] != 5) {
sum += (5 - a[i]);
ct++;
}
if (sum / n >= 4.5) {
cout << ct;
return 0;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int l = 1, h, i, n, x, t, q, y = -1, z = 0, a = 0, b = 0, c = 0, k,
sum = 0, m, d = 0, r, w, j, ans, s, mini = INT_MAX,
maxi = INT_MIN;
bool cou;
float kl;
long long int count = 0;
t = 1;
vector<bool> sie(1000001, 0);
char cg;
string str, std;
a = 1;
while (t--) {
cin >> n >> m;
vector<int> vec(n);
map<int, bool> mp;
for (i = 0; i < n; ++i) cin >> vec[i];
for (i = 0; i < m; ++i) {
cin >> x;
mp[x] = 1;
}
for (i = 0; i < n; ++i) {
if (mp[vec[i]]) cout << vec[i] << " ";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 9;
const int mod = 1e9 + 7;
int arr[maxn];
int now;
struct NODE {
int minn;
int minid;
int cnt;
} ST[maxn << 2];
void pushup(int rt) {
ST[rt].cnt = ST[rt << 1].cnt + ST[rt << 1 | 1].cnt;
ST[rt].minn = min(ST[rt << 1].minn, ST[rt << 1 | 1].minn);
if (ST[rt << 1].minn <= ST[rt << 1 | 1].minn)
ST[rt].minid = ST[rt << 1].minid;
else
ST[rt].minid = ST[rt << 1 | 1].minid;
}
void build(int l, int r, int rt) {
if (l == r) {
ST[rt].minn = arr[l];
ST[rt].minid = l;
ST[rt].cnt = 1;
return;
}
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
void update(int a, int l, int r, int rt) {
if (l == r) {
ST[rt].minn = inf;
ST[rt].cnt = 0;
return;
}
int m = l + r >> 1;
if (a <= m)
update(a, l, m, rt << 1);
else
update(a, m + 1, r, rt << 1 | 1);
pushup(rt);
}
int query(int a, int b, int l, int r, int rt) {
if (a <= l && b >= r) return ST[rt].cnt;
int m = l + r >> 1;
int ret = 0;
if (a <= m) ret += query(a, b, l, m, rt << 1);
if (b > m) ret += query(a, b, m + 1, r, rt << 1 | 1);
return ret;
}
int query2(int a, int b, int l, int r, int rt) {
if (a <= l && b >= r && ST[rt].minn == ST[1].minn)
return ST[rt].minid;
else if (a <= l && b >= r)
return -1;
int m = l + r >> 1;
int a1 = -1, a2 = -1;
if (a <= m) a1 = query2(a, b, l, m, rt << 1);
if (b > m) a2 = query2(a, b, m + 1, r, rt << 1 | 1);
if (a1 == -1 && a2 == -1)
return -1;
else if (a1 != -1)
return a1;
else
return a2;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
build(1, n, 1);
now = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
int nex = query2(now, n, 1, n, 1);
if (nex == -1) nex = query2(1, now, 1, n, 1);
if (nex > now) {
ans += query(now, nex, 1, n, 1);
now = nex;
update(nex, 1, n, 1);
} else {
ans += query(now, n, 1, n, 1) + query(1, nex, 1, n, 1);
now = nex;
update(nex, 1, n, 1);
}
}
printf("%lld\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, mod = 998244353;
template <class o>
inline void qr(o &x) {
x = 0;
char c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + (c ^ 48);
c = getchar();
}
x *= f;
}
template <class o>
void qw(o x) {
if (x / 10) qw(x / 10);
putchar(x % 10 + 48);
}
template <class o>
void pr1(o x) {
if (x < 0) putchar('-'), x = -x;
qw(x);
putchar(' ');
}
template <class o>
void pr2(o x) {
if (x < 0) putchar('-'), x = -x;
qw(x);
puts("");
}
inline int ksm(int a, int b = mod - 2) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
inline int add(int a, int b) { return a += b, a >= mod ? a - mod : a; }
inline int sub(int a, int b) { return a -= b, a < 0 ? a + mod : a; }
int ch[N][26], fail[N], cnt, val[N], top[N];
int ed[N], q[N], v[N];
multiset<int> vals[N];
void bfs() {
int l = 1, r = 0;
for (int c = 0; c < 26; ++c)
if (ch[0][c]) q[++r] = ch[0][c];
for (int x = q[l]; l <= r; x = q[++l]) {
top[x] = val[fail[x]] >= 0 ? fail[x] : top[fail[x]];
for (int c = 0; c < 26; ++c) {
if (!ch[x][c])
ch[x][c] = ch[fail[x]][c];
else
fail[ch[x][c]] = ch[fail[x]][c], q[++r] = ch[x][c];
}
}
}
void solve() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
memset(val, -1, sizeof val);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
int x = 0;
for (auto c : s) {
if (!ch[x][c - 'a']) ch[x][c - 'a'] = ++cnt;
x = ch[x][c - 'a'];
}
ed[i] = x;
val[x] = 0;
v[i] = 0;
vals[x].insert(0);
}
bfs();
for (int i = 1; i <= m; ++i) {
string s;
int op, w;
cin >> op;
if (op == 1) {
int id;
cin >> id >> w;
int x = ed[id];
vals[x].erase(vals[x].find(v[id]));
v[id] = w;
vals[x].insert(w);
val[x] = *vals[x].rbegin();
} else {
int x = 0;
cin >> s;
int ans = -1;
for (auto c : s) {
x = ch[x][c - 'a'];
for (int p = x; p; p = top[p])
if (val[p] > ans) ans = val[p];
}
pr2(ans);
}
}
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, h;
scanf("%d%d%d", &n, &m, &h);
--h;
--n;
int sh, T = 0;
long double inv = 1.0;
for (int i = 0, a; i < m; ++i) {
scanf("%d", &a);
if (i == h) {
--a;
sh = a;
}
T += a;
}
if (T < n) {
printf("-1\n");
return 0;
}
int i = 0, j = n;
for (; i < sh && j < n + sh;) {
if (inv > 1.0) {
inv /= (T - i);
++i;
} else {
inv *= (T - j);
++j;
}
}
while (i < sh) {
inv /= (T - i), ++i;
}
while (j < n + sh) {
inv *= (T - j), ++j;
}
printf("%.7f\n", (double)(1.0 - inv));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long int arr[5005];
long long int fun(long long int l, long long int r) {
if (l > r) return 0;
long long int i = l, curr = l;
long long int ans = 0;
for (i = l; i <= r; ++i) {
if (arr[i] == 0) ans += fun(curr, i - 1), curr = i + 1;
}
long long int ans1 = r - curr + 1;
long long int mn = *min_element(arr + curr, arr + (r + 1));
for (i = curr; i <= r; ++i) arr[i] -= mn;
ans1 = min(ans1, fun(curr, r) + mn);
return ans + ans1;
}
void solve() {
long long int n, i;
cin >> n;
long long int arr[n];
for (i = 0; i < n; ++i) cin >> arr[i];
reverse(arr, arr + n);
for (i = 0; i < n; ++i) cout << arr[i] << " ";
cout << endl;
}
int main() {
fastio();
long long int t;
t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1011;
bitset<MAXN> processed[MAXN];
int DP[MAXN][MAXN], value[MAXN], people;
int nextA[MAXN][MAXN], nextB[MAXN][MAXN];
int recurse(int a, int b) {
if (a >= people) return 0;
if (!processed[a][b]) {
processed[a][b] = true;
int c = b + 1, inter;
DP[a][b] = max(value[a], value[b]) + recurse(c, c + 1);
nextA[a][b] = c;
nextB[a][b] = c + 1;
if (b < people) {
inter = max(value[b], value[c]) + recurse(a, c + 1);
if (inter < DP[a][b]) {
DP[a][b] = inter;
nextA[a][b] = a;
nextB[a][b] = c + 1;
}
}
if (c < people) {
inter = max(value[a], value[c]) + recurse(b, c + 1);
if (inter < DP[a][b]) {
DP[a][b] = inter;
nextA[a][b] = b;
nextB[a][b] = c + 1;
}
}
}
return DP[a][b];
}
int main() {
scanf("%d", &people);
for (int i = 0; i < people; i++) scanf("%d", &value[i]);
printf("%d\n", recurse(0, 1));
int na, nb;
for (int a = 0, b = 1, c; a < people;) {
if (b < people) {
if (nextA[a][b] == b + 1)
printf("%d %d\n", a + 1, b + 1);
else if (nextA[a][b] == a)
printf("%d %d\n", b + 1, b + 2);
else
printf("%d %d\n", a + 1, b + 2);
} else
printf("%d\n", a + 1);
na = nextA[a][b], nb = nextB[a][b];
a = na, b = nb;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 10;
vector<int> g[sz], got[sz];
struct node {
int a, b;
} qry[sz];
struct info {
int minNum, cnt;
} tree[4 * sz];
int lazy[4 * sz], tim, start[sz], stop[sz], ans[sz];
int n, m;
void prop(int lo, int hi, int node) {
if (lo == hi) return;
int mid = lo + hi >> 1, lft = node << 1, rgt = node << 1 | 1;
lazy[lft] += lazy[node], lazy[rgt] += lazy[node];
tree[lft].minNum += lazy[node];
tree[rgt].minNum += lazy[node];
lazy[node] = 0;
}
void build(int lo, int hi, int node) {
if (lo == hi) {
tree[node] = {0, 1};
return;
}
int mid = lo + hi >> 1;
build(lo, mid, node << 1);
build(mid + 1, hi, node << 1 | 1);
tree[node] = {0, tree[node << 1].cnt + tree[node << 1 | 1].cnt};
}
void update(int lo, int hi, int l, int r, int v, int node) {
if (lo > r || hi < l) return;
if (lo >= l && hi <= r) {
tree[node].minNum += v;
lazy[node] += v;
return;
}
if (lazy[node]) prop(lo, hi, node);
int mid = lo + hi >> 1, lft = node << 1, rgt = node << 1 | 1;
update(lo, mid, l, r, v, lft);
update(mid + 1, hi, l, r, v, rgt);
if (tree[lft].minNum < tree[rgt].minNum)
tree[node] = tree[lft];
else if (tree[lft].minNum > tree[rgt].minNum)
tree[node] = tree[rgt];
else
tree[node] = {tree[lft].minNum, tree[lft].cnt + tree[rgt].cnt};
}
void dfs(int u, int p) {
start[u] = ++tim;
for (int &v : g[u]) {
if (v == p) continue;
dfs(v, u);
}
stop[u] = tim;
}
void ans_dfs(int u, int p) {
for (int &idx : got[u]) {
int a = qry[idx].a, b = qry[idx].b;
update(1, tim, start[a], stop[a], 1, 1);
update(1, tim, start[b], stop[b], 1, 1);
}
if (tree[1].minNum == 0)
ans[u] = n - tree[1].cnt - 1;
else
ans[u] = n - 1;
for (int &v : g[u]) {
if (v == p) continue;
ans_dfs(v, u);
}
for (int &idx : got[u]) {
int a = qry[idx].a, b = qry[idx].b;
update(1, tim, start[a], stop[a], -1, 1);
update(1, tim, start[b], stop[b], -1, 1);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d", &u), scanf("%d", &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d", &a), scanf("%d", &b);
qry[i] = {a, b};
got[a].push_back(i), got[b].push_back(i);
}
dfs(1, -1);
build(1, tim, 1);
ans_dfs(1, -1);
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
printf("%d", ans[i] == -1 ? 0 : ans[i]);
}
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int rem = n % 3;
if (rem == 0) {
cout << n + 6 << " " << 6 << endl;
} else if (rem == 1) {
cout << n + 8 << " " << 8 << endl;
} else {
cout << n + 4 << " " << 4 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
char buf_[1 << 21], *p1_ = buf_, *p2_ = buf_;
inline long long in() {
long long s = 0, f = 1;
char x = (p1_ == p2_ && (p2_ = (p1_ = buf_) + fread(buf_, 1, 1 << 21, stdin),
p1_ == p2_)
? EOF
: *p1_++);
for (; x < '0' || x > '9';
x = (p1_ == p2_ && (p2_ = (p1_ = buf_) + fread(buf_, 1, 1 << 21, stdin),
p1_ == p2_)
? EOF
: *p1_++))
if (x == '-') f = -1;
for (; x >= '0' && x <= '9';
x = (p1_ == p2_ && (p2_ = (p1_ = buf_) + fread(buf_, 1, 1 << 21, stdin),
p1_ == p2_)
? EOF
: *p1_++))
s = (s * 10) + (x & 15);
return f == 1 ? s : -s;
}
char _buf[1 << 21];
long long _pos = -1;
inline void flush() { fwrite(_buf, 1, _pos + 1, stdout), _pos = -1; }
inline void pc(char x) {
if (_pos == (1 << 21) - 1) flush();
_buf[++_pos] = x;
}
inline void out(long long x) {
char k[30];
long long pos = 0;
if (!x) return pc('0');
if (x < 0) pc('-'), x = -x;
while (x) k[++pos] = (x % 10) | 48, x /= 10;
for (register long long i = pos; i; i--) pc(k[i]);
}
inline void out(string x) {
long long len = x.size();
for (register long long i = 0; i < len; ++i) pc(x[i]);
}
} // namespace IO
using namespace IO;
const long long A = 5e5 + 5;
const long long INF = 3e18;
long long n, m;
long long G, S;
long long ans = INF;
struct Road {
long long x, y, g, s;
inline friend bool operator<(Road u, Road v) { return u.g < v.g; }
} p[A];
struct LCT {
long long ch[A][2], f[A], rev[A], xg[A], xs[A];
struct MG {
long long x;
MG(long long _x = 0) { x = _x; }
inline friend bool operator<(MG u, MG v) { return p[u.x].g > p[v.x].g; }
};
struct MS {
long long x;
MS(long long _x = 0) { x = _x; }
inline friend bool operator<(MS u, MS v) { return p[u.x].s > p[v.x].s; }
};
multiset<MG> mg;
multiset<MS> ms;
inline long long isroot(long long x) {
return ch[f[x]][0] != x && ch[f[x]][1] != x;
}
inline long long Maxg(long long x, long long y) {
return p[x].g > p[y].g ? x : y;
}
inline long long Maxs(long long x, long long y) {
return p[x].s > p[y].s ? x : y;
}
inline void pushup(long long x) {
xg[x] = Maxg(x, Maxg(xg[ch[x][0]], xg[ch[x][1]]));
xs[x] = Maxs(x, Maxs(xs[ch[x][0]], xs[ch[x][1]]));
}
inline void reverse(long long x) {
if (x) swap(ch[x][0], ch[x][1]), rev[x] ^= 1;
}
inline void pushdown(long long x) {
if (rev[x]) reverse(ch[x][0]), reverse(ch[x][1]), rev[x] ^= 1;
}
inline void rotate(long long x) {
long long y = f[x], z = f[y];
long long k = (ch[y][1] == x);
if (!isroot(y)) ch[z][(ch[z][1] == y)] = x;
f[x] = z, ch[y][k] = ch[x][k ^ 1];
if (ch[x][k ^ 1]) f[ch[x][k ^ 1]] = y;
ch[x][k ^ 1] = y, f[y] = x;
pushup(y);
return;
}
long long st[A], top;
inline void pushpath(long long x) {
top = 0;
st[++top] = x;
for (long long i = x; !isroot(i); i = f[i]) st[++top] = f[i];
for (long long i = top; i; i--) pushdown(st[i]);
return;
}
inline void splay(long long x) {
pushpath(x);
while (!isroot(x)) {
long long y = f[x], z = f[y];
if (!isroot(y)) {
if ((ch[y][1] == x) == (ch[z][1] == y))
rotate(y);
else
rotate(x);
}
rotate(x);
}
pushup(x);
return;
}
inline void access(long long x) {
for (long long y = 0; x; y = x, x = f[x]) splay(x), ch[x][1] = y, pushup(x);
}
inline void makeroot(long long x) { access(x), splay(x), reverse(x); }
inline long long findroot(long long x) {
access(x), splay(x);
while (ch[x][0]) pushdown(x), x = ch[x][0];
return x;
}
inline void split(long long x, long long y) {
makeroot(x);
access(y);
splay(y);
}
inline void link(long long x, long long y) {
makeroot(x);
if (findroot(y) != x) f[x] = y;
}
inline void cut(long long x, long long y) {
makeroot(x);
if (findroot(y) == x && f[x] == y && ch[y][0] == x) f[x] = 0, ch[y][0] = 0;
pushup(y);
}
struct DSU {
long long f[A], num[A];
inline long long find(long long x) {
return f[x] == x ? f[x] : f[x] = find(f[x]);
}
inline void merge(long long x, long long y) {
if (find(x) != find(y))
num[find(y)] += num[find(x)], f[find(x)] = find(y);
}
} D;
inline void work(long long now) {
if (D.find(p[now].x) != D.find(p[now].y)) {
link(p[now].x + m, now);
link(p[now].y + m, now);
mg.insert(MG(now)), ms.insert(MS(now));
D.merge(p[now].x, p[now].y);
} else {
split(p[now].x + m, p[now].y + m);
if (p[xs[p[now].y + m]].s > p[now].s) {
long long t = xs[p[now].y + m];
cut(p[t].x + m, t), cut(p[t].y + m, t);
mg.erase(mg.find(t)), ms.erase(ms.find(t));
link(p[now].x + m, now), link(p[now].y + m, now);
mg.insert(MG(now)), ms.insert(MS(now));
}
}
if (D.num[D.find(1)] == n)
ans = min(ans, p[(*mg.begin()).x].g * G + p[(*ms.begin()).x].s * S);
return;
}
} T;
signed main() {
n = in(), m = in(), G = in(), S = in();
for (long long i = 1; i <= m; i++)
p[i].x = in(), p[i].y = in(), p[i].g = in(), p[i].s = in();
sort(p + 1, p + 1 + m);
for (long long i = 1; i <= n; i++) T.D.f[i] = i, T.D.num[i] = 1;
for (long long i = 1; i <= m; i++) T.work(i);
out(ans == INF ? -1 : ans), pc('\n');
flush();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
map<long long int, long long int> mp;
bool check(int mid) {
vector<int> v;
for (auto it = mp.begin(); it != mp.end(); it++) {
int p = it->second;
int ka = p / mid;
while (ka--) {
v.push_back(int(it->first));
if (v.size() == k) return 1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
int lo = 1, hi = -1, mid, ans = -1;
for (auto it = mp.begin(); it != mp.end(); it++)
hi = max(hi, int(it->second));
while (lo <= hi) {
mid = (hi + lo) / 2;
if (check(mid)) {
ans = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
vector<int> v;
for (auto it = mp.begin(); it != mp.end(); it++) {
int p = it->second;
int ka = p / ans;
while (ka--) {
v.push_back(int(it->first));
if (v.size() == k) {
for (int i = 0; i < k; i++) cout << v[i] << " ";
return 0;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, n, t, a;
cin >> n;
long long int sum = 0, b = 0, arr[n + 2];
int flag = 0;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
std::sort(&arr[0], &arr[n]);
for (i = n - 1; i >= 0; i--) {
if (arr[i] % 2 == 0)
sum = sum + arr[i];
else {
if (flag == 1) {
sum = sum + arr[i] + b;
flag = 0;
} else {
flag = 1;
b = arr[i];
}
}
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int posscount = 0, numh[3001], numnz[3001], n, k, numbu[3001][3002], p;
int main() {
cin >> n >> k;
numh[0] = 0;
numnz[0] = 0;
for (int i = 0; i < n; i++) {
cin >> p;
numh[i + 1] = numh[i];
numnz[i + 1] = numnz[i];
if (p == 100) numh[i + 1]++;
if (p != 0) numnz[i + 1]++;
}
for (int i = 0; i <= 3000; i++)
for (int j = 0; j <= 3001; j++) numbu[i][j] = k + 1;
numbu[0][1] = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j <= n; j++) {
if (numbu[i][j] <= k) posscount++;
if (j < n) {
if (numh[i + 1] == numh[i] && numnz[n] != numnz[j])
numbu[j][j + 1] = min(numbu[j][j + 1], numbu[i][j] + 1);
if (numnz[i + 1] != numnz[i] && numnz[n] != numnz[j])
numbu[j + 1][j + 2] = min(numbu[j + 1][j + 2], numbu[i][j] + 1);
if (numnz[i + 1] != numnz[i] && numh[n] == numh[j])
numbu[i][j + 1] = min(numbu[i][j + 1], numbu[i][j] + 1);
}
}
if (numbu[n][n + 1] <= k) posscount++;
cout << posscount << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1100000;
const double PI = acos(-1);
int n, m, K;
char S[MAXN], T[MAXN];
bool a[4][MAXN], b[4][MAXN];
pair<int, int> s[4][MAXN];
int cnt[4];
int rev[MAXN], res_n;
int res[MAXN], ans;
struct Comp {
double x, y;
Comp operator+(const Comp &r) const { return (Comp){x + r.x, y + r.y}; }
Comp operator-(const Comp &r) const { return (Comp){x - r.x, y - r.y}; }
Comp operator*(const Comp &r) const {
return (Comp){x * r.x - y * r.y, x * r.y + y * r.x};
}
} A[MAXN], B[MAXN], W[MAXN], null;
void dft(Comp *a, int n, bool t) {
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int i = 1, gap = n >> 1; i < n; i <<= 1, gap >>= 1)
for (int j = 0; j < n; j += i << 1) {
Comp *x = a + j, *y = a + j + i, *w = W, tmp;
for (int k = 0; k < i; k++) {
tmp = *y * *w;
*y = *x - tmp, *x = *x + tmp;
x++, y++, w += gap;
}
}
if (!t) {
reverse(a + 1, a + n);
for (int i = 0; i < n; i++) a[i].x = (a[i].x / n + 0.5);
}
}
void mul(int n, int m) {
int len = 0;
m += n, n = 1;
while (n <= m) n <<= 1, len++;
for (int i = 0; i < n; i++) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (len - 1));
W[i] = (Comp){cos(2 * PI * i / n), sin(2 * PI * i / n)};
}
dft(A, n, 1), dft(B, n, 1);
for (int i = 0; i < n; i++) A[i] = A[i] * B[i];
dft(A, n, 0), res_n = n;
}
int main() {
scanf("%d %d %d %s %s", &n, &m, &K, S, T);
for (int i = 0; i < n; i++)
S[i] = S[i] == 'A' ? 0 : (S[i] == 'T' ? 1 : (S[i] == 'C' ? 2 : 3));
for (int i = 0; i < m; i++)
T[i] = T[i] == 'A' ? 0 : (T[i] == 'T' ? 1 : (T[i] == 'C' ? 2 : 3));
for (int i = 0; i < n; i++)
s[(int)S[i]][++cnt[(int)S[i]]] =
make_pair(max(i - K, 0), min(i + K, n - 1));
for (int t = 0, L, R; t < 4; t++) {
sort(s[t] + 1, s[t] + cnt[t] + 1), L = 0, R = -1;
for (int i = 1; i <= cnt[t]; i++) {
L = max(L, s[t][i].first), R = max(R, L - 1);
while (R < s[t][i].second) a[t][++R] = 1;
}
}
for (int i = 0; i < m; i++) b[(int)T[i]][i] = 1;
reverse(b[0], b[0] + m), reverse(b[1], b[1] + m);
reverse(b[2], b[2] + m), reverse(b[3], b[3] + m);
for (int t = 0; t < 4; t++) {
for (int i = 0; i < n; i++) A[i] = (Comp){(double)a[t][i], 0};
for (int i = 0; i < m; i++) B[i] = (Comp){(double)b[t][i], 0};
mul(n - 1, m - 1);
for (int i = 0; i < n; i++) res[i] += (int)A[i].x;
for (int i = 0; i < res_n; i++) A[i] = B[i] = null;
}
for (int i = 0; i < n; i++) ans += res[i] == m;
printf("%d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
const long long mod = 1000000007;
const long long inf = 1000000009;
const long long INF = 1000000000000000009;
const long long big = 1000000000000000;
const long double eps = 0.000000000000000000001;
using namespace std;
vector<pair<long long, long long> > P[105];
long long T[105][1005], K[1005], O[1005];
void solve() {
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) {
long long a;
cin >> a;
}
for (long long i = 1; i <= m; i++) {
long long a, b;
cin >> a >> b;
P[a].push_back(make_pair(b, i));
P[b].push_back(make_pair(a, i));
long long x = min_element(T[a] + 1, T[a] + k + 1) - T[a];
long long y = min_element(T[b] + 1, T[b] + k + 1) - T[b];
T[a][x]++;
T[b][x]++;
K[i] = x;
O[i] = i;
long long czy = 0;
if (T[b][x] - T[b][y] > 2) czy = 1;
long long u = b;
while (czy) {
czy = 0;
for (auto v : P[u]) {
if (O[v.second] != i && K[v.second] == x) {
O[v.second] = i;
K[v.second] = y;
T[u][x]--;
T[u][y]++;
T[v.first][x]--;
T[v.first][y]++;
u = v.first;
czy = 1;
swap(x, y);
break;
}
}
}
}
for (long long i = 1; i <= m; i++) cout << K[i] << "\n";
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, k;
int a[N];
map<int, int> ma;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) a[i] ^= a[i - 1];
for (int i = 0; i <= n; i++) {
int val = (a[i] & 1) ? (a[i] ^ ((1 << k) - 1)) : a[i];
ma[val]++;
}
long long ans = 1LL * n * (n + 1) / 2;
for (auto i : ma) {
int p1 = i.second / 2, p2 = i.second - p1;
ans -= 1LL * p1 * (p1 - 1) / 2 + 1LL * p2 * (p2 - 1) / 2;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) sum = sum * 10 + (ch ^ 48), ch = getchar();
return sum * ff;
}
int Q, a, b, c;
int main() {
Q = read();
for (; Q--;) {
a = read();
b = read();
c = read();
int ans = 0;
ans += min(b, c / 2) * 3;
b = max(0, b - c / 2);
ans += min(a, b / 2) * 3;
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
while (scanf("%d %d", &n, &x) != EOF) {
int min = 0;
int max = 100000;
int i, big, s, a, b, z;
for (i = 0; i < n; i++) {
scanf("%d %d", &a, &b);
if (a > b) {
big = a;
s = b;
} else {
big = b;
s = a;
}
if (s > min) min = s;
if (big < max) max = big;
}
if (x >= min && x <= max)
z = 0;
else
z = (abs(x - max) < abs(x - min)) ? abs(x - max) : abs(x - min);
if (min <= max)
printf("%d", z);
else
printf("%d", -1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
int n, b[N], i, p, q, k, absent[N], winner;
map<int, int> mb;
vector<int> bets[N];
int main() {
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%d%d", &p, b + i);
bets[p].push_back(i);
}
for (i = 1; i <= n; ++i)
if (!bets[i].empty()) mb[bets[i].back()] = i;
scanf("%d", &q);
for (; q; --q) {
scanf("%d", &k);
for (i = 0; i < k; ++i) {
scanf("%d", absent + i);
if (bets[absent[i]].empty())
--i, --k;
else
mb.erase(bets[absent[i]].back());
}
if (mb.empty())
puts("0 0");
else {
winner = mb.rbegin()->second;
mb.erase(mb.rbegin()->first);
if (mb.empty())
printf("%d %d\n", winner, b[bets[winner][0]]);
else
printf("%d %d\n", winner,
b[*upper_bound(bets[winner].begin(), bets[winner].end(),
mb.rbegin()->first)]);
mb[bets[winner].back()] = winner;
}
for (i = 0; i < k; ++i) mb[bets[absent[i]].back()] = absent[i];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long modulo = 1e9 + 7;
template <class X>
void printarr(X arr[], int n) {
for (int i = 0; i < n; ++i) cout << arr[i] << " ";
cout << endl;
}
long long fpow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * a) % modulo;
a = (a * a) % modulo;
n = n >> 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
int x[n];
char y[] = {'R', 'B', 'G'};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
if (y[j] == s[i]) x[i] = j;
}
}
int dp[n][3], dp2[n][3];
for (int i = 0; i < 3; ++i) {
if (x[0] == i)
dp[0][i] = 0;
else
dp[0][i] = 1;
}
for (int i = 1; i < n; ++i) {
if (dp[i - 1][1] > dp[i - 1][2]) {
dp[i][0] = dp[i - 1][2];
dp2[i][0] = 2;
} else {
dp[i][0] = dp[i - 1][1];
dp2[i][0] = 1;
}
if (x[i] != 0) ++dp[i][0];
if (dp[i - 1][0] > dp[i - 1][2]) {
dp[i][1] = dp[i - 1][2];
dp2[i][1] = 2;
} else {
dp[i][1] = dp[i - 1][0];
dp2[i][1] = 0;
}
if (x[i] != 1) ++dp[i][1];
if (dp[i - 1][0] > dp[i - 1][1]) {
dp[i][2] = dp[i - 1][1];
dp2[i][2] = 1;
} else {
dp[i][2] = dp[i - 1][0];
dp2[i][2] = 0;
}
if (x[i] != 2) ++dp[i][2];
}
int ans = INT_MAX;
int finalletter;
for (int i = 0; i < 3; ++i) {
if (ans > dp[n - 1][i]) {
finalletter = i;
ans = dp[n - 1][i];
}
}
char final[n];
final[n - 1] = y[finalletter];
for (int i = n - 1; i > 0; --i) {
final[i - 1] = y[dp2[i][finalletter]];
finalletter = dp2[i][finalletter];
}
cout << ans << endl;
for (int i = 0; i < n; ++i) cout << final[i];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 12345;
vector<int> tree[5 * N];
int A[N];
vector<int> merge(vector<int> &L, vector<int> &R) {
int nl = L.size();
int nr = R.size();
int i = 0, j = 0;
vector<int> ret;
while (i < nl && j < nr) {
if (L[i] < R[j]) {
ret.push_back(L[i++]);
} else {
ret.push_back(R[j++]);
}
}
while (i < nl) ret.push_back(L[i++]);
while (j < nr) ret.push_back(R[j++]);
return ret;
}
void build_tree(int cur, int l, int r) {
if (l == r) {
tree[cur].push_back(A[l]);
return;
}
int mid = l + (r - l) / 2;
build_tree(2 * cur + 1, l, mid);
build_tree(2 * cur + 2, mid + 1, r);
tree[cur] = merge(tree[2 * cur + 1], tree[2 * cur + 2]);
}
int query(int curr, int qs, int qe, int ss, int se, int k) {
if (qe < ss || qs > se) return 0;
if (ss >= qs && se <= qe) {
return lower_bound(tree[curr].begin(), tree[curr].end(), k) -
tree[curr].begin();
}
int mid = (ss + se) / 2;
int l = query(2 * curr + 1, qs, qe, ss, mid, k);
int r = query(2 * curr + 2, qs, qe, mid + 1, se, k);
return l + r;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> A[i];
A[i]--;
}
build_tree(0, 0, n - 1);
while (m--) {
int l, r, x;
cin >> l >> r >> x;
l--, r--, x--;
int idx = query(0, l, r, 0, n - 1, A[x]);
if (x < l || x > r) {
cout << "Yes\n";
continue;
}
int pos = l + idx;
if (pos == x)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
int nex[MAXN], len_pattern, pos, flag;
string pattern;
set<int> s;
void get_next() {
int i = 0, j = -1;
nex[0] = -1;
while (i < len_pattern) {
if (-1 == j || pattern[i] == pattern[j]) {
i++;
j++;
nex[i] = j;
} else
j = nex[j];
}
}
int main() {
cin >> pattern, len_pattern = (int)pattern.size();
get_next();
int len = len_pattern;
for (int i = 1; i < len_pattern; i++) s.insert(nex[i]);
while (0 != nex[len] && -1 != nex[len]) {
if (s.count(nex[len])) {
for (int i = 0; i < nex[len]; i++) cout << pattern[i];
cout << endl;
flag = 1;
break;
}
len = nex[len];
}
if (!flag) cout << "Just a legend" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const long long MOD = 1000000007ll;
const long double PI = acos(-1.0);
const long long INF = 2000000000000000000ll;
const long double EPS = 1e-9;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
T sqr(T a) {
return a * a;
}
bool pal(string &x) {
int n = x.length();
for (int i = 0; i < n / 2; i++) {
if (x[i] != x[n - i - 1]) return 0;
}
return 1;
}
map<string, vector<int> > m;
string rev(string x) {
int n = x.length();
for (int i = 0; i < n / 2; i++) {
swap(x[i], x[n - i - 1]);
}
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, len;
cin >> n >> len;
string s;
int foo;
for (int i = 0; i < n; i++) {
cin >> s >> foo;
m[s].push_back(foo);
}
long long bigsum = 0;
int max_pal = 0;
for (auto &x : m) {
string a = x.first;
string b = rev(a);
if (a > b) continue;
if (a == b) {
int last = inf;
int sum = 0;
int k = 0;
int max_minus = -inf;
for (auto &y : x.second) {
if (y > 0) {
k++;
last = min(last, y);
sum += y;
} else
max_minus = max(max_minus, y);
}
if (k % 2 == 1 && last != inf) {
if (max_minus + last > 0) {
sum += max_minus;
max_pal = max(max_pal, -max_minus);
} else {
sum -= last;
max_pal = max(max_pal, last);
}
}
bigsum += sum;
} else {
vector<int> &v = x.second;
vector<int> &u = m[b];
sort((v).begin(), (v).end(), greater<int>());
sort((u).begin(), (u).end(), greater<int>());
int f = min(u.size(), v.size());
int sum = 0;
for (int i = 0; i < f; i++) {
if (u[i] + v[i] > 0)
sum += u[i] + v[i];
else
break;
}
bigsum += sum;
}
}
cout << bigsum + max_pal;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300300;
int n, m, u, v, i, root = 1, d[N];
bool vis[N];
set<int> ans;
vector<pair<int, int>> edges[N];
bool dfs(int cur) {
if (vis[cur]++) return 1;
int degree = 0;
for (auto& e : edges[cur]) {
if (!dfs(e.first)) {
degree++;
ans.insert(e.second);
}
}
return (d[cur] == -1 || degree % 2 == d[cur]);
}
int main() {
cin >> n >> m;
for (i = 1; i <= n; ++i) {
scanf("%d", d + i);
if (d[i] == -1) {
root = i;
}
}
for (i = 1; i <= m; ++i) {
scanf("%d %d", &u, &v);
edges[u].push_back(make_pair(v, i));
edges[v].push_back(make_pair(u, i));
}
if (!dfs(root)) {
return cout << -1, 0;
}
cout << ans.size() << endl;
for (int x : ans) printf("%d\n", x);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
unsigned int add(const unsigned int x, const unsigned int y) {
return (x + y < 998244353) ? x + y : x + y - 998244353;
}
unsigned int sub(const unsigned int x, const unsigned int y) {
return (x >= y) ? (x - y) : (998244353 - y + x);
}
unsigned int mul(const unsigned int x, const unsigned int y) {
return (unsigned long long)x * y % 998244353;
}
unsigned int mod_pow(unsigned int x, unsigned int n) {
unsigned int res = 1;
while (n > 0) {
if (n & 1) {
res = mul(res, x);
}
x = mul(x, x);
n >>= 1;
}
return res;
}
unsigned int inverse(const unsigned int x) { return mod_pow(x, 998244353 - 2); }
void ntt(vector<int>& a, const bool rev = false) {
unsigned int i, j, k, l, p, q, r, s;
const unsigned int size = a.size();
if (size == 1) return;
vector<int> b(size);
r = rev ? (998244353 - 1 - (998244353 - 1) / size) : (998244353 - 1) / size;
s = mod_pow(3, r);
vector<unsigned int> kp(size / 2 + 1, 1);
for (i = 0; i < size / 2; ++i) kp[i + 1] = mul(kp[i], s);
for (i = 1, l = size / 2; i < size; i <<= 1, l >>= 1) {
for (j = 0, r = 0; j < l; ++j, r += i) {
for (k = 0, s = kp[i * j]; k < i; ++k) {
p = a[k + r], q = a[k + r + size / 2];
b[k + 2 * r] = add(p, q);
b[k + 2 * r + i] = mul(sub(p, q), s);
}
}
swap(a, b);
}
if (rev) {
s = inverse(size);
for (i = 0; i < size; i++) {
a[i] = mul(a[i], s);
}
}
}
vector<int> multiply(const vector<int>& a, const vector<int>& b) {
const int size = (int)a.size() + (int)b.size() - 1;
int t = 1;
while (t < size) {
t <<= 1;
}
vector<int> A(t, 0), B(t, 0);
for (int i = 0; i < (int)a.size(); i++) {
A[i] = a[i];
}
for (int i = 0; i < (int)b.size(); i++) {
B[i] = b[i];
}
ntt(A), ntt(B);
for (int i = 0; i < t; i++) {
A[i] = mul(A[i], B[i]);
}
ntt(A, true);
A.resize(size);
return A;
}
vector<int> binpow(vector<int>& a, int x) {
vector<int> ans(1, 1);
while (x) {
if (x & 1) {
ans = multiply(ans, a);
}
a = multiply(a, a);
x >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
vector<int> a(10, 0);
cin >> n >> k;
while (k--) {
int x;
cin >> x;
a[x] = 1;
}
vector<int> ans = binpow(a, n / 2);
long long res = 0;
for (int i : ans) res = add(res, mul(i, i));
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m1, m2, c;
cin >> n >> m1 >> m2;
int x[n], v1[m1], v2[m2], z[n];
for (int i = 0; i < n; i++) z[i] = x[i] = i + 1;
for (int i = 0; i < m1; i++) {
cin >> v1[i];
for (int j = 0; j < n; j++)
if (v1[i] == x[j]) x[j] = 1;
continue;
}
for (int i = 0; i < m2; i++) cin >> v2[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m2; j++) {
if (z[i] == v2[j]) x[i] = 2;
}
}
for (int i = 0; i < n; i++) cout << x[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int t = 0;
for (int i = 0; i < m; i++)
if (a[i] <= 0) t -= a[i];
cout << t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
register int res = 0, lab = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') lab = -lab;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
res = (res << 3) + (res << 1) + (ch & 15), ch = getchar();
return res * lab;
}
inline void prt(int x, char tail = 0) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) prt(x / 10), x %= 10;
putchar(x | 48);
if (tail) putchar(tail);
}
struct node {
int id, x, y;
bool operator<(const node _cmp) const { return y < _cmp.y; }
bool operator>(const node _cmp) const { return y > _cmp.y; }
};
bool cmp1(node a, node b) { return a > b; }
bool cmp2(node a, node b) { return a < b; }
int n;
node t;
vector<node> v[1005];
int main() {
n = rd();
for (int i = 1; i <= n; ++i) {
t.id = i;
t.x = rd();
t.y = rd();
v[t.x / 1000].push_back(t);
}
for (int i = 0; i <= 1000; ++i)
sort(v[i].begin(), v[i].end(), (i & 1) ? (cmp1) : (cmp2));
for (int i = 0; i <= 1000; ++i) {
for (int j = 0; j < v[i].size(); ++j) prt(v[i][j].id, ' ');
}
fputs("\n", stdout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int oo = 1e9, bpr = 1e9 + 7, N = 1e5 + 100, K = 21;
int n, m, d;
int banned[(1 << 20) + 100];
int c[N][K];
int cnt[K];
inline bool bit(int mask, int pos) { return (mask >> pos) & 1; }
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> d;
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
while (x--) {
int y;
cin >> y;
c[y][i] = 1;
}
}
for (int i = 0; i < m; ++i) c[0][i] = c[n + 1][i] = 1;
for (int i = 0; i <= n; ++i) {
if (i - d >= 0)
for (int j = 0; j < m; ++j) cnt[j] -= c[i - d][j];
for (int j = 0; j < m; ++j) cnt[j] += c[i][j];
int mask = 0;
for (int j = 0; j < m; ++j) mask |= ((cnt[j] == 0) * (1 << j));
banned[mask] = 1;
}
for (int i = 0; i < m; ++i)
for (int mask = 0; mask < (1 << m); ++mask)
if (bit(mask, i)) banned[mask ^ (1 << i)] |= banned[mask];
int ans = oo;
for (int mask = 0; mask < (1 << m); ++mask)
if (!banned[mask]) ans = min(ans, __builtin_popcount(mask));
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
static long long gcd(long long x, long long y) {
return y == 0 ? x : gcd(y, x % y);
}
static long long pwm(long long x, long long n, long long m) {
long long r = 1;
while (n) {
if (n & 1) r = r * x % m;
x = x * x % m;
n >>= 1;
}
return r;
}
int n;
std::vector<int> g[1 << 18];
std::vector<long long> cnt;
long long ans, s[2];
void dfs(int x, int p = 0, int deep = 0) {
cnt[x] = 1;
for (int e : g[x]) {
if (e == p) continue;
dfs(e, x, deep ^ 1);
cnt[x] += cnt[e];
}
++s[deep];
if (p) {
ans += cnt[x] * (n - cnt[x]);
}
}
int solve() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
cnt.resize(n + 1);
dfs(1);
ans = (ans + s[0] * s[1]) / 2;
printf("%lld\n", ans);
return 0;
}
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400005;
const long long MAX = 1e18;
long long fa[maxn][21], last, q, cnt;
;
long long sum[maxn][21], val[maxn];
int main() {
scanf("%d", &q);
for (int i = (int)0; i <= (int)20; i++) sum[1][i] = MAX;
val[1] = 0;
cnt = 1;
val[0] = MAX;
while (q--) {
int op;
long long u, v;
scanf("%d%lld%lld", &op, &u, &v);
u ^= last;
v ^= last;
if (op == 1) {
cnt++;
val[cnt] = v;
if (val[u] >= v)
fa[cnt][0] = u;
else {
for (int i = 20; i >= 0; i--) {
if (val[fa[u][i]] < v) u = fa[u][i];
}
fa[cnt][0] = fa[u][0];
}
sum[cnt][0] = ((fa[cnt][0] == 0) ? MAX : val[fa[cnt][0]]);
for (int i = (int)1; i <= (int)20; i++) {
fa[cnt][i] = fa[fa[cnt][i - 1]][i - 1];
sum[cnt][i] =
((fa[cnt][i] == 0) ? MAX
: sum[fa[cnt][i - 1]][i - 1] + sum[cnt][i - 1]);
}
} else {
if (val[u] > v) {
printf("0\n");
last = 0;
continue;
}
long long ans = 1;
v -= val[u];
for (int i = 20; i >= 0; i--) {
if (sum[u][i] <= v) {
ans += (1 << i);
v -= sum[u][i];
u = fa[u][i];
}
}
last = ans;
printf("%d\n", ans);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mm = 555;
int f[mm][mm][11];
int i, j, k, l, n, m, ans;
char c;
int check(int x, int y, int l) {
if (x + l >= n || y + l >= m) return -1;
int d[4] = {f[x][y][k - 1], f[x][y + l][k - 1], f[x + l][y][k - 1],
f[x + l][y + l][k - 1]};
int i, ret, s;
for (i = 0; i < 4; ++i)
if (d[i] < 0) return -1;
for (i = 0; i < 4; ++i)
if (d[i] != 15) break;
if (i == 4) return 15;
s = d[i];
for (ret = i = 0; i < 4; ++i)
if (d[i] != 15) {
if (d[i] != s) return -1;
} else
ret |= 1 << i;
if (l != 1 && s != ret) return -1;
return ret;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) {
scanf(" %c", &c);
f[i][j][0] = (c == '*') ? 15 : 0;
}
ans = 0;
for (k = 1; (l = (1 << k)) <= n && l <= m; ++k)
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j)
ans += (f[i][j][k] = check(i, j, l >> 1)) > -1 && k > 1;
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int q, cnt = 1, ta;
long long x[400005], y[400005], la, tb, tc;
long long to[400005][19], ma[400005][19], tox[400005][19], sum[400005][19];
int main() {
x[0] = -1;
for (int i = 0; i < 19; i++) {
ma[0][i] = ma[1][i] = -1;
sum[0][i] = sum[1][i] = LLONG_MAX;
}
scanf("%d", &q);
while (q--) {
scanf("%d%lld%lld", &ta, &tb, &tc);
tb ^= la, tc ^= la;
if (ta == 1) {
cnt++;
x[cnt] = tc;
to[cnt][0] = tb;
ma[cnt][0] = x[tb];
for (int i = 1; i < 19; i++) {
to[cnt][i] = to[to[cnt][i - 1]][i - 1];
ma[cnt][i] = max(ma[cnt][i - 1], ma[to[cnt][i - 1]][i - 1]);
}
y[cnt] = cnt;
for (int i = 18; i >= 0; i--)
if (ma[y[cnt]][i] < tc) {
y[cnt] = to[y[cnt]][i];
}
y[cnt] = to[y[cnt]][0];
tox[cnt][0] = y[cnt];
if (y[cnt])
sum[cnt][0] = x[y[cnt]];
else
sum[cnt][0] = LLONG_MAX;
for (int i = 1; i < 19; i++) {
tox[cnt][i] = tox[tox[cnt][i - 1]][i - 1];
if (sum[cnt][i - 1] == LLONG_MAX ||
sum[tox[cnt][i - 1]][i - 1] == LLONG_MAX)
sum[cnt][i] = LLONG_MAX;
else
sum[cnt][i] = sum[cnt][i - 1] + sum[tox[cnt][i - 1]][i - 1];
}
} else {
la = 0;
if (x[tb] <= tc) {
la++;
tc -= x[tb];
for (int i = 18; i >= 0; i--)
if (sum[tb][i] <= tc) {
la += 1 << i;
tc -= sum[tb][i];
tb = tox[tb][i];
}
}
printf("%d\n", la);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, w, a, b;
int main() {
scanf("%d %d %d %d", &n, &w, &a, &b);
if (b == n) b = w * ((b + w - 1) / w);
int ra = (a - 1) / w, rb = (b - 1) / w;
int ma = (a - 1) % w + 1, mb = (b - 1) % w + 1;
if (ra == rb)
printf("1\n");
else if (ma == 1 && mb == w)
printf("1\n");
else if (ma == 1 || mb == w)
printf("2\n");
else if (ra == rb - 1)
printf("2\n");
else if (ma == mb + 1)
printf("2\n");
else
printf("3\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char A[1001][5];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 5; j++) cin >> A[i][j];
}
bool t = false;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 5; j++) {
if (A[i][0] == 'O' && A[i][1] == 'O') {
t = true;
A[i][0] = '+';
A[i][1] = '+';
break;
} else if (A[i][3] == 'O' && A[i][4] == 'O') {
t = true;
A[i][3] = '+';
A[i][4] = '+';
break;
}
}
if (t) break;
}
if (!t)
cout << "NO";
else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 5; j++) cout << A[i][j];
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, t1 = -1, t2;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t2;
if (t2 - t1 == 1) {
t1 = t2;
} else if (t2 > t1) {
printf("%d\n", i);
return 0;
}
}
printf("-1\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 250000 + 10;
const int MAXT = (1 << 20) + 10;
int n;
int a[2 * MAXN], lef[2 * MAXN], mini[MAXT];
int nex[2 * MAXN][20], val[2 * MAXN][20];
void go(int root, int lo, int hi, int pos) {
if (pos < lo || pos > hi) return;
if (lo == hi) {
mini[root] = pos;
return;
}
int mid = (lo + hi) / 2;
go(root * 2, lo, mid, pos);
go(root * 2 + 1, mid + 1, hi, pos);
if (lef[mini[root * 2]] < lef[mini[root * 2 + 1]])
mini[root] = mini[root * 2];
else
mini[root] = mini[root * 2 + 1];
}
int get(int root, int lo, int hi, int st, int fn) {
if (hi < st || fn < lo) return 0;
if (st <= lo && hi <= fn) return mini[root];
int mid = (lo + hi) / 2;
int f1 = get(root * 2, lo, mid, st, fn);
int f2 = get(root * 2 + 1, mid + 1, hi, st, fn);
if (lef[f1] < lef[f2]) return f1;
return f2;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
lef[0] = 2 * n + 1;
for (int i = 1; i <= 2 * n; i++) {
lef[i] = max(1, i - a[i]);
go(1, 1, 2 * n, i);
}
for (int i = 0; i < 20; i++) {
nex[1][i] = 1;
val[1][i] = 1;
}
for (int i = 2; i <= 2 * n; i++) {
nex[i][0] = get(1, 1, 2 * n, lef[i], i - 1);
for (int j = 1; j < 20; j++) nex[i][j] = nex[nex[i][j - 1]][j - 1];
val[i][0] = lef[i];
for (int j = 1; j < 20; j++) val[i][j] = val[nex[i][j - 1]][j - 1];
}
long long ans = 0;
for (int i = n + 1; i <= 2 * n; i++) {
int cur = i;
for (int j = 19; j >= 0; j--)
if (i - n + 1 < val[cur][j]) {
ans += (1 << j);
cur = nex[cur][j];
}
ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << n * m / 2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int PRIME = 999983;
const int MOD = 10007;
const int MULTI = 1000000007;
const double EPS = 1e-9;
class Matrix {
public:
int n, m;
long long a[32][32];
Matrix(int n, int m) : n(n), m(m) { memset(a, 0, sizeof(a)); }
Matrix qpow(int n) {
Matrix res(this->n, this->m);
Matrix base = *this;
memset(res.a, 0x3f, sizeof(res.a));
for (int i = 0; i < res.n; i++) res.a[i][i] = 0;
while (n) {
if (n & 1) res = res.multi(base);
base = base.multi(base);
n >>= 1;
}
return res;
}
Matrix multi(const Matrix &r) {
Matrix res(n, r.m);
memset(res.a, 0x3f, sizeof(res.a));
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < r.m; j++) {
res.a[i][j] = min(res.a[i][j], a[i][k] + r.a[k][j]);
}
}
}
return res;
}
};
int n, m, a[32], b[32];
int dp[32][32][32];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + i);
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i <= n; i++) {
dp[i][0][i] = 0;
for (int j = 0; j < n; j++)
for (int k = 0; k <= n; k++) {
dp[i][j + 1][k + 1] = min(dp[i][j + 1][k + 1], dp[i][j][k] + a[j]);
if (k - 1 >= 0)
dp[i][j + 1][k - 1] = min(dp[i][j + 1][k - 1], dp[i][j][k] + b[j]);
}
}
Matrix ans(n + 1, n + 1);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) ans.a[i][j] = dp[i][n][j];
cout << ans.qpow(m).a[0][0];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _print(T a) {
cerr << a;
}
template <class T>
void _print(vector<T> v) {
cerr << "[";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(set<T> s) {
cerr << "[";
for (T i : s) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> s) {
cerr << "[";
for (T i : s) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(unordered_map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
void solve() {
float n;
cin >> n;
vector<double> a(n);
double sum = 0;
for (double i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a.begin(), a.end(), greater<double>());
sum -= a[0];
double ans = a[0] + sum / (n - 1);
cout << fixed << setprecision(6) << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
cin >> t;
for (long long int i = 1; i <= t; i++) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
for (int j = 1; j < n; j++) {
int res = i * j;
string str;
while (res != 0) {
str += (res % n + '0');
res /= n;
}
for (int i = str.size() - 1; i >= 0; i--) cout << str[i];
cout << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4004;
struct P {
int r, d, p;
bool operator<(const P& p) const { return d > p.d || d == p.d && r > p.r; }
} p[N];
bool b[N];
int n;
vector<pair<int, int> > v;
int main() {
int n, hp, h, c = 0, d = 0;
scanf("%d %d %d", &n, &hp, &h);
for (int i = 0; i < n; i++) {
scanf("%d %d", &p[i].r, &p[i].d);
p[i].p = i + 1;
}
sort(p, p + n);
int nh = hp, ans = 0;
for (int i = 0; c < N; i++, c++) {
nh -= d;
nh = min(nh + h, hp);
if (nh <= 0) {
ans = i;
break;
}
for (int j = 0; j < n; j++) {
if (b[j]) continue;
if (nh * 100 > p[j].r * hp) continue;
d += p[j].d;
b[j] = 1;
v.push_back(pair<int, int>(i, p[j].p));
break;
}
}
if (c == N)
puts("NO");
else {
puts("YES");
printf("%d %d\n", ans, v.size());
for (int i = 0; i < v.size(); i++)
printf("%d %d\n", v[i].first, v[i].second);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int N = 7;
int edge[N][N];
int degree[N];
bool alive[N];
bool visited[N];
void dfs(int x) {
if (visited[x]) return;
visited[x] = 1;
for (int next = (int)0; next < (int)n; next++)
if (edge[x][next] and alive[next]) dfs(next);
}
bool is_connected(int next) {
for (int i = (int)0; i < (int)n; i++) alive[i] = degree[i] > 0;
memset(visited, 0, sizeof(visited));
dfs(next);
for (int i = (int)0; i < (int)n; i++)
if (alive[i] and !visited[i]) return false;
int nodd = 0;
for (int i = (int)0; i < (int)n; i++)
if (degree[i] % 2) nodd++;
if (nodd != 0 and nodd != 2) return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
vector<pair<pair<int, int>, int> > dominoes;
n = 7;
int m;
cin >> m;
for (int i = (int)0; i < (int)m; i++) {
int a, b;
cin >> a >> b;
dominoes.push_back(make_pair(pair<int, int>(a, b), -1));
edge[a][b]++, edge[b][a]++;
degree[a]++, degree[b]++;
}
int nodd = 0;
for (int i = (int)0; i < (int)n; i++)
if (degree[i] % 2) nodd++;
if (nodd != 0 and nodd != 2) {
cout << "No solution\n";
return 0;
}
vector<int> tour(m);
int prev = -1;
for (int i = (int)0; i < (int)n; i++)
if (degree[i] % 2 == 1 and prev == -1) prev = i;
for (int i = (int)0; i < (int)n; i++)
if (degree[i] > 0 and prev == -1) prev = i;
if (!is_connected(prev)) {
cout << "No solution\n";
return 0;
}
for (int i = (int)0; i < (int)m; i++) {
for (int next = (int)0; next < (int)n; next++) {
if (edge[prev][next] == 0) continue;
edge[prev][next]--, edge[next][prev]--;
degree[prev]--, degree[next]--;
if (is_connected(next)) {
for (int j = (int)0; j < (int)m; j++)
if (dominoes[j].second == -1) {
if (dominoes[j].first == pair<int, int>(prev, next)) {
dominoes[j].second = 0;
tour[i] = j;
break;
}
if (dominoes[j].first == pair<int, int>(next, prev)) {
dominoes[j].second = 1;
tour[i] = j;
break;
}
}
prev = next;
break;
}
edge[prev][next]++, edge[next][prev]++;
degree[prev]++, degree[next]++;
}
}
for (int i = (int)0; i < (int)m; i++)
cout << (tour[i] + 1) << ' ' << (dominoes[tour[i]].second ? '-' : '+')
<< "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1000000000000000000;
const long double pi = 3.14159265358979323846264338;
const long long mod = 1000000007;
long long int pow(long long int x, unsigned long long int y, long long int p) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int invmod(long long int a, long long int m) {
return pow(a, m - 2, m);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<long long int> a(n);
vector<long long int> b(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < n; i++) {
cin >> b[i];
}
vector<long long int> diff;
diff.push_back(0);
long long int cnt = 0;
for (long long int i = 0; i < n; i++) {
diff.push_back(b[i] - a[i]);
if (b[i] < a[i]) {
cnt = inf;
}
}
diff.push_back(0);
for (long long int i = 1; i < (long long int)diff.size(); i++) {
if (diff[i] != diff[i - 1]) {
cnt++;
}
}
if (cnt <= 2) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const long long MOD = 1000000007;
const int max_n = 3e5 + 100;
int a[max_n];
int n;
long long ans0 = 0;
long long ans = 0;
void Solve(int x, vector<vector<int>>& vc) {
if (x < 0) return;
vector<vector<int>> vn;
long long res1 = 0, res2 = 0;
for (int i = 0; i < vc.size(); ++i) {
vector<int> v1, v2;
long long cnt1 = 0, cnt2 = 0;
for (int num : vc[i]) {
if ((num >> x) & 1) {
++cnt1;
res1 += cnt2;
v1.push_back(num);
} else {
++cnt2;
res2 += cnt1;
v2.push_back(num);
}
}
if (!v1.empty()) vn.push_back(v1);
if (!v2.empty()) vn.push_back(v2);
}
if (res1 < res2) {
ans0 |= (1 << x);
ans += res1;
} else {
ans += res2;
}
if (!vn.empty()) Solve(x - 1, vn);
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
vector<vector<int>> vc;
vector<int> v;
for (int i = 1; i <= n; ++i) {
int num;
cin >> num;
v.push_back(num);
}
vc.push_back(v);
Solve(31, vc);
cout << ans << " " << ans0 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int xx[] = {-1, 0, 1, 0};
int yy[] = {0, 1, 0, -1};
int main() {
int r, c;
cin >> r >> c;
string mat[r];
for (int i = 0; i < r; i++) cin >> mat[i];
int x, y;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (mat[i][j] == 'E') {
x = i;
y = j;
}
}
}
int dist[1005][1005];
for (int i = 0; i < 1005; i++) {
for (int j = 0; j < 1005; j++) {
dist[i][j] = 1000000007;
}
}
dist[x][y] = 0;
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(make_pair(x, y), 0));
while (!q.empty()) {
int cx = q.front().first.first;
int cy = q.front().first.second;
int d = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int nx = cx + xx[i];
int ny = cy + yy[i];
if (nx < 0 || ny < 0 || nx >= r || ny >= c) continue;
if (mat[nx][ny] == 'T') {
dist[nx][ny] = 0;
continue;
}
if (dist[nx][ny] > dist[cx][cy] + 1) {
dist[nx][ny] = dist[cx][cy] + 1;
q.push(make_pair(make_pair(nx, ny), dist[nx][ny]));
}
}
}
int di;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (mat[i][j] == 'S') {
di = dist[i][j];
}
}
}
int cnt = 0;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (mat[i][j] >= '1' && mat[i][j] <= '9') {
if (dist[i][j] <= di) cnt += mat[i][j] - '0';
}
}
}
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int MODULO = 1e9 + 7;
bool myAssert(bool b);
void testDrivenDevelopment();
int start(int argc = 0, char const *argv[] = NULL);
vector<int> *g;
bool *isvisited;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int a, b, c, d;
long long int misha, vasya;
cin >> a >> b >> c >> d;
misha = max(3 * a / 10, a - a * c / 250);
vasya = max(3 * b / 10, b - d * b / 250);
if (misha > vasya) {
cout << "Misha\n";
} else if (misha < vasya) {
cout << "Vasya\n";
} else {
cout << "Tie\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int k = 4 * n - 2;
for (long long int i = 0; i < n; i++) {
cout << k << " ";
k = k - 2;
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char grid[1013][1013];
int dist[3][1013][1013];
int dX[4] = {-1, 0, 1, 0};
int dY[4] = {0, -1, 0, 1};
const int INF = 1e8;
deque<pair<int, int> > frontier;
void bfs(int s) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dist[s][i][j] = INF;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (grid[i][j] == '1' + s) {
frontier.push_back(make_pair(i, j));
dist[s][i][j] = 0;
}
while (frontier.size() > 0) {
auto p = frontier.front();
frontier.pop_front();
int x = p.first;
int y = p.second;
for (int i = 0; i < 4; i++) {
int nX = x + dX[i];
int nY = y + dY[i];
if (nX < 0 || nX >= n || nY < 0 || nY >= m) continue;
if (dist[s][nX][nY] != INF || grid[nX][nY] == '#') continue;
int cost = (grid[nX][nY] == '.');
dist[s][nX][nY] = dist[s][x][y] + cost;
if (cost)
frontier.push_back(make_pair(nX, nY));
else
frontier.push_front(make_pair(nX, nY));
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %s", &grid[i]);
for (int i = 0; i < 3; i++) bfs(i);
int ans = INF;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int cur = dist[0][i][j] + dist[1][i][j] + dist[2][i][j];
if (grid[i][j] == '.') cur -= 2;
ans = min(ans, cur);
}
if (ans >= INF)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T = 1;
for (int t = 1; t <= T; ++t) {
int64_t n, k;
cin >> n >> k;
if (n == k) {
cout << "infinity\n";
return 0;
}
int64_t diff = n - k;
int count = 0;
for (int64_t i = 1; i * i <= diff; ++i) {
if (diff % i == 0) {
if (n % i == k) {
count += 1;
}
if (diff / i != i and (n % (diff / i)) == k) {
count += 1;
}
}
}
cout << count << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
int main() {
char s[101];
int i, k = 0, b = 0;
scanf("%s", &s);
int len = strlen(s);
for (i = 0; i < len; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
b++;
}
if (s[i] >= 'a' && s[i] <= 'z') {
k++;
}
}
if (k >= b) {
for (i = 0; i < len; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] += 32;
}
}
}
if (b > k) {
for (i = 0; i < len; i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
s[i] -= 32;
}
}
}
printf("%s\n", s);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long double pie = 3.1415926535;
using namespace std;
long long fpow(long long n, long long p) {
;
long long m = 1;
while (p) {
if (p % 2) m *= n;
p >>= 1;
n *= n;
}
return m;
}
long long mfpow(long long n, long long p, long long M) {
long long m = 1;
n %= M;
while (p) {
if (p % 2) m = (m * n) % M;
n = (n * n) % M;
p >>= 1;
}
return m % M;
}
long long min() { return 1e18; }
long long min(long long a) { return a; }
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
template <typename... Args>
long long min(long long a, long long b, Args... args) {
if (a < b)
return min(a, args...);
else
return min(b, args...);
}
long long max() { return -1e18; }
long long max(long long a) { return a; }
long long max(long long a, long long b) {
if (a < b)
return b;
else
return a;
}
template <typename... Args>
long long max(long long a, long long b, Args... args) {
if (a < b)
return max(b, args...);
else
return max(a, args...);
}
const vector<long long> days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool br1, br2, br;
char ch, ch1, ch2;
long long n, k, x, y, z, mini, maxi, l, ind, ini, sum, t, len, r, w, imini, m;
pair<long long, long long> p;
string s, s1, s2;
void solve() {
cin >> n;
for (long long i = 1; i < 1e5; i++) {
if (2 * i - 1 >= n) {
cout << i << endl;
x = 1;
y = 1;
for (long long j = 0; j < n; j++) {
cout << x << " " << y << endl;
if (y == i)
x++;
else
y++;
}
break;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, b, ans = 0, a;
cin >> n >> k;
long long int f[n];
for (int j = 0; j < n; j++) f[j] = 0;
for (int i = 0; i < n; i++) {
cin >> a;
while (a > 0) {
b = a % 10;
a = a / 10;
if (b == 7 || b == 4) {
f[i]++;
}
}
}
for (int u = 0; u < n; u++) {
if (f[u] <= k) ans++;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x1, x2, y1, y2;
cin >> a >> b >> x1 >> y1 >> x2 >> y2;
int t1, t2;
if (x1 >= y1)
t1 = (x1 - y1) / (2 * b);
else
t1 = -(1 + (y1 - x1) / (2 * b));
if (x2 >= y2)
t2 = (x2 - y2) / (2 * b);
else
t2 = -(1 + (y2 - x2) / (2 * b));
int ans1 = abs(t1 - t2);
if (x1 + y1 >= 0)
t1 = (x1 + y1) / (2 * a);
else
t1 = -(1 + (-y1 - x1) / (2 * a));
if (x2 + y2 >= 0)
t2 = (x2 + y2) / (2 * a);
else
t2 = -(1 + (-y2 - x2) / (2 * a));
int ans2 = abs(t1 - t2);
cout << max(ans1, ans2) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int tt;
cin >> tt;
while (tt--) {
long long int x, y, a, b;
cin >> x >> y >> a >> b;
if (min(abs(x - a), abs(y - b)) != 0) {
cout << (min(abs(x - a), abs(y - b)) + 2) + max(abs(x - a), abs(y - b))
<< endl;
} else
cout << max(abs(x - a), abs(y - b)) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 998244353;
const int MAXN = 2e5 + 5;
long long dp1[555][555];
long long f[555];
int n, k;
long long ans;
long long sq(long long x) { return x * x % MOD; }
long long powMod(long long b, long long e) {
return e ? sq(powMod(b, e >> 1)) * (e & 1 ? b : 1) % MOD : 1;
}
void fill1(int max) {
for (int i = 1; i < max + 1; i++) dp1[n - 1][i] = 2;
for (int j = n - 2; j > -1; j--)
for (int i = 0; i < max + 1; i++)
if (i != max)
dp1[j][i] = (dp1[j + 1][i + 1] + dp1[j + 1][1]) % MOD;
else
dp1[j][i] = dp1[j + 1][1] % MOD;
f[max] = dp1[0][1] % MOD;
}
int main() {
scanf("%d %d", &n, &k);
k--;
long long inv = powMod(2, MOD - 2);
for (int i = 1; i < n + 1; i++) fill1(i);
for (int i = 1; i < n + 1; i++)
ans = (ans + f[min(k / i, n)] * ((f[i] - f[i - 1] + MOD) % MOD)) % MOD;
printf("%lld\n", ans * inv % MOD);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
T pow_mod(T a, U b, int mod) {
T r = 1;
for (; b > 0; b >>= 1) {
if (b & 1) r = (long long)r * a % mod;
a = (long long)a * a % mod;
}
return r;
}
const int mod = 998244353;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
int s = 0;
for (auto &i : v) cin >> i, s += i;
int in1 = pow_mod(n - 1, mod - 2, mod);
int is = pow_mod(s, mod - 2, mod);
vector<int> dp(s + 1), dp2(s + 1);
for (int x = s - 1; x >= 0; --x) {
int y = s - x;
int a = (long long)y * is % mod * in1 % mod;
int b = (long long)a * (n - 2) % mod;
int c = (long long)x * is % mod;
int d = pow_mod((1 - b - (long long)a * dp[x + 1] % mod + 2 * mod) % mod,
mod - 2, mod);
if (d == 0) {
assert(count(v.begin(), v.end(), x) == 0 && x > 0);
dp2[x - 1] = 0;
dp2[x - 1] = ((-(long long)a * dp2[x + 1] - 1) % mod + mod) % mod *
pow_mod(c, mod - 2, mod) % mod;
--x;
continue;
}
dp[x] = (long long)c * d % mod;
dp2[x] = ((long long)a * dp2[x + 1] + 1) % mod * d % mod;
}
for (int i = 1; i < s; ++i)
dp2[i] = ((long long)dp[i] * dp2[i - 1] + dp2[i]) % mod;
int sum = 0;
for (auto i : v)
if ((sum += dp2[i]) >= mod) sum -= mod;
cout << (sum - (long long)dp2[0] * (n - 1) % mod + mod) % mod *
pow_mod(n, mod - 2, mod) % mod
<< "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[1010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
int cnt = 0;
bool vis[1010];
memset(vis, 0, sizeof(vis));
while (1) {
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
if (cnt >= a[i]) {
cnt++;
vis[i] = 1;
}
}
if (cnt == n) break;
ans++;
for (int i = n; i >= 1; i--) {
if (vis[i]) continue;
if (cnt >= a[i]) {
cnt++;
vis[i] = 1;
}
}
if (cnt == n) break;
ans++;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-20;
const long long mod = 1000000007;
const long long INF = mod * mod + mod;
struct Line {
long long a, b;
long double inter(const Line& l) const {
return (long double)(l.b - b) / (a - l.a);
}
Line() {}
Line(long long a, long long b) : a(a), b(b) {}
long long get(int x) { return a * 1ll * x + b; }
};
struct Hull {
vector<Line> st;
void push(const Line& l) {
while ((int)(st).size() >= 2) {
const Line& l1 = st[(int)(st).size() - 2];
const Line& l2 = st[(int)(st).size() - 1];
if (l2.a == l.a) {
if (l.b > l2.b) {
st.pop_back();
continue;
} else {
return;
}
}
long double x1 = l1.inter(l2);
long double x2 = l2.inter(l);
if (x2 < x1 + EPS) {
st.pop_back();
} else {
break;
}
}
st.push_back(l);
}
long long get_best(long long x) {
int L = -1;
int R = (int)(st).size() - 1;
while (L < R - 1) {
int M = (L + R) / 2;
long double xx = st[M].inter(st[M + 1]);
if (xx < x) {
L = M;
} else {
R = M;
}
}
long long ans = -INF;
for (int i = max(0, L - 3); i < min((int)(st).size(), R + 4); ++i) {
ans = max(ans, st[i].get(x));
}
return ans;
}
};
const int MAXN = 301000;
vector<Hull> t(4 * MAXN);
vector<vector<Line>> vt(4 * MAXN);
void build(int v, int tl, int tr) {
vt[v].push_back(Line(0, -INF));
if (tl == tr) return;
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
}
void update(int v, int tl, int tr, int l, int r,
std::pair<long long, long long> add) {
if (l > r) return;
if (l == tl && tr == r)
vt[v].push_back(Line(add.first, add.second));
else {
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), add);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, add);
}
}
long long get(int v, int tl, int tr, int pos, long long num) {
if (tl == tr) return t[v].get_best(num);
int tm = (tl + tr) / 2;
if (pos <= tm)
return max(t[v].get_best(num), get(v * 2, tl, tm, pos, num));
else
return max(t[v].get_best(num), get(v * 2 + 1, tm + 1, tr, pos, num));
}
int main() {
int n;
scanf("%d", &n);
build(1, 0, n - 1);
std::vector<int> type(n);
std::vector<std::pair<int, int>> q(n);
std::vector<int> num(n);
std::vector<int> u(n, 0);
for (int i = 0; i < n; i++) {
scanf("%d", &type[i]);
if (type[i] == 1) scanf("%d %d", &q[i].first, &q[i].second);
if (type[i] == 2) scanf("%d", &num[i]);
if (type[i] == 3) scanf("%d", &num[i]);
}
for (int i = n - 1; i >= 0; i--) {
if (u[i]) continue;
if (type[i] == 3) continue;
if (type[i] == 2) {
int l = num[i] - 1;
update(1, 0, n - 1, l, i,
make_pair((long long)q[l].first, (long long)q[l].second));
u[l] = 1;
}
if (type[i] == 1) {
update(1, 0, n - 1, i, n - 1,
make_pair((long long)q[i].first, (long long)q[i].second));
}
}
for (int i = 0; i < 4 * MAXN; i++) {
if (vt[i].size() > 0) {
sort((vt[i]).begin(), (vt[i]).end(), [](Line a, Line b) {
return a.a < b.a || (a.a == b.a && a.b < b.b);
});
for (auto l : vt[i]) t[i].push(l);
}
}
for (int i = 0; i < n; i++) {
if (type[i] == 3) {
long long ans = get(1, 0, n - 1, i, (long long)num[i]);
if (ans == -INF)
printf("EMPTY SET\n");
else
printf("%lld\n", ans);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct matrix {
long long a[10][10];
matrix() { memset(a, 0, sizeof(a)); }
};
int l, r;
matrix operator*(matrix &a, matrix &b) {
int i, j, k;
matrix c;
for (i = 0; i <= 6; ++i)
for (j = 0; j <= 6; ++j) {
for (k = 0; k <= 6; ++k) {
c.a[i][j] += a.a[i][k] * b.a[k][j] % 1000000007;
c.a[i][j] %= 1000000007;
}
}
return c;
}
matrix qp(matrix b, int e) {
matrix t, ans;
t = b;
ans.a[0][0] = ans.a[1][1] = ans.a[2][2] = ans.a[3][3] = ans.a[4][4] =
ans.a[5][5] = ans.a[6][6] = 1;
while (e) {
if (e & 1) ans = ans * t;
t = t * t;
e >>= 1;
}
return ans;
}
long long qp(long long b, int e) {
long long t, ans;
t = b, ans = 1;
while (e) {
if (e & 1) {
ans *= t;
ans %= 1000000007;
}
t *= t;
t %= 1000000007;
e >>= 1;
}
return ans;
}
long long work() {
matrix m0, m1, m2, m3, m4;
long long ans = 0;
int i;
m0.a[0][1] = m0.a[0][3] = m0.a[0][5] = 1;
m0.a[2][1] = m0.a[2][3] = m0.a[2][4] = 1;
m0.a[3][0] = m0.a[3][2] = 1;
m0.a[4][2] = 1, m0.a[5][0] = 1;
for (i = 0; i <= 6; ++i) m0.a[6][i] = 1;
m1 = qp(m0, l - 1);
m2 = qp(m0, l / 2);
m3 = qp(m0, r);
m4 = qp(m0, (r + 1) / 2);
for (i = 0; i < 4; ++i) {
ans += m3.a[6][i] - m1.a[6][i];
ans += m4.a[6][i] - m2.a[6][i];
ans %= 1000000007;
}
ans = ans * qp(2, 1000000007 - 2) % 1000000007;
return ans + 1000000007;
}
int main() {
scanf("%d%d", &l, &r);
printf("%I64d\n", work() % 1000000007);
return (0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long int a[234567];
int bs(int l, int r, int x) {
if (l > r) return n;
int mid = (l + r) >> 1;
if (a[mid] < x)
return bs(mid + 1, r, x);
else {
if (a[mid - 1] < x)
return mid;
else
return bs(l, mid - 1, x);
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int mx = 0;
for (int i = 0; i < n; i++) {
if (i == n - 1) {
mx = max(mx, (long long int)a[i]);
break;
}
if (i > 0 && a[i] == a[i - 1]) continue;
long long int sum = a[i];
long long int lead = a[i];
int current = i + 1;
while (current < n) {
int mult = a[current] / lead + 1;
int in = bs(current, n - 1, mult * lead);
sum += ((in - current) * ((mult - 1) * lead));
current = in;
}
mx = max(mx, sum);
}
cout << mx;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 50;
unordered_map<int, set<int>> mp;
vector<pair<int, int>> res;
int a[N];
int b[N];
bool isLucky(int num) {
while (num) {
if (num % 10 != 4 && num % 10 != 7) {
return false;
}
num /= 10;
}
return true;
}
int main() {
int n;
while (~scanf("%d", &n)) {
mp.clear();
res.clear();
int index = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
if (isLucky(a[i])) {
index = i;
}
mp[a[i]].insert(i);
}
bool sorted = true;
sort(b, b + n);
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
sorted = false;
break;
}
}
if (sorted) {
printf("0\n");
continue;
} else if (index == -1) {
printf("-1\n");
continue;
}
for (int i = 0; i < n; i++) {
set<int> &set1 = mp[a[i]];
if (a[i] != b[i]) {
set<int> &set2 = mp[b[i]];
set<int> &set3 = mp[a[index]];
int j = *set2.begin();
if (index != i && index != j) {
swap(a[index], a[i]);
res.emplace_back(index, i);
swap(a[i], a[j]);
res.emplace_back(i, j);
set1.erase(i);
set2.erase(j);
set3.erase(index);
set1.insert(index);
set3.insert(j);
index = j;
} else {
swap(a[i], a[j]);
res.emplace_back(i, j);
set1.erase(i);
set2.erase(j);
set1.insert(j);
index = index == i ? j : i;
}
} else {
set1.erase(i);
}
}
for (auto it = res.begin(); it != res.end();) {
auto itNext = it;
itNext++;
if (it->first == it->second) {
it = res.erase(it);
} else if (itNext != res.end() && itNext->first == it->first &&
itNext->second == it->second) {
it = res.erase(it);
it = res.erase(it);
} else {
it++;
}
}
printf("%lu\n", res.size());
for (const auto &p : res) {
printf("%d %d\n", p.first + 1, p.second + 1);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int calcTime(int vol, const vector<int>& deltas) {
int ans = 0;
for (int s : deltas) {
if (s > vol) {
return INT_MAX;
}
if (vol >= 2 * s) {
ans += s;
} else {
int add = vol - s;
ans += 2 * (s - add) + add;
}
}
return ans;
}
int main() {
cin.sync_with_stdio(0);
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<int, int> > cars(n);
for (int i = 0; i < n; i++) {
cin >> cars[i].second;
cin >> cars[i].first;
}
sort(cars.begin(), cars.end());
vector<pair<int, int> > cars2;
cars2.reserve(n);
for (int i = n - 1; i >= 0; i--) {
if (i > 0 && cars[i - 1].first == cars[i].first) {
continue;
}
if (cars2.size() > 0 && cars[i].second >= cars2.back().second) {
continue;
}
cars2.push_back(cars[i]);
}
reverse(cars2.begin(), cars2.end());
vector<int> fuel(k + 2);
for (int i = 0; i < k; i++) {
cin >> fuel[i];
}
fuel[k] = 0;
fuel[k + 1] = s;
sort(fuel.begin(), fuel.end());
vector<int> deltas(k + 1);
for (int i = 1; i < fuel.size(); i++) {
deltas[i - 1] = (fuel[i] - fuel[i - 1]);
}
sort(deltas.begin(), deltas.end());
n = cars2.size();
int a = -1;
int b = n - 1;
while (a < b - 1) {
int m = (a + b) / 2;
int testT = calcTime(cars2[m].first, deltas);
if (testT > t) {
a = m;
} else {
b = m;
}
}
if (b >= n || calcTime(cars2[b].first, deltas) > t) {
cout << -1 << endl;
return 0;
}
int bestV = cars2[b].first;
int bestCost = cars2[b].second;
for (int i = 0; i < n; i++) {
if (cars2[i].first >= bestV && cars2[i].second <= bestCost) {
bestCost = cars2[i].second;
}
}
cout << bestCost << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void print_arr(int arr[], int length) {
for (int i = 0; i < length; i++) cout << arr[i];
cout << '\n';
}
int gcd(int a, int b, int res = 1) {
if (a == 0) return b;
if (b == 0) return a;
if (a == b)
return a * res;
else if (a % 2 == 0 && b % 2 == 0)
return gcd(a / 2, b / 2, res * 2);
else if (a % 2 == 0)
return gcd(a / 2, b, res);
else if (b % 2 == 0)
return gcd(a, b / 2, res);
else if (a > b)
return gcd(a - b, b, res);
else
return gcd(a, b - a, res);
}
long long gcdar(long long ar[], long long len) {
long long result = ar[0];
for (long long i = 1; i < len; i++) result = gcd(ar[i], result);
return result;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
string s;
cin >> n >> s;
int ar[10] = {};
for (char x : s) {
if (x == 'L') {
int i = 0;
while (ar[i] == 1) ++i;
ar[i] = 1;
} else if (x == 'R') {
int i = 9;
while (ar[i] == 1) --i;
ar[i] = 1;
} else
ar[x - '0'] = 0;
}
print_arr(ar, 10);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
int s = 0;
int j = 0;
for (int i = 1; i <= n; i++) cin >> a[i - 1];
for (int i = 1; i <= n; i++) {
k -= min(a[i - 1] + s, 8);
if (k <= 0) {
cout << i;
return 0;
}
s += a[i - 1] - min(a[i - 1] + s, 8);
}
cout << -1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<pair<char, int> > v(9);
v[0].first = '6';
v[1].first = '7';
v[2].first = '8';
v[3].first = '9';
v[4].first = 'T';
v[5].first = 'J';
v[6].first = 'Q';
v[7].first = 'K';
v[8].first = 'A';
v[0].second = 6;
v[1].second = 7;
v[2].second = 8;
v[3].second = 9;
v[4].second = 10;
v[5].second = 11;
v[6].second = 12;
v[7].second = 13;
v[8].second = 14;
char trump;
string s1, s2;
long valu_s1, valu_s2;
cin >> trump;
cin >> s1 >> s2;
if (s1[1] == trump && s2[1] != trump)
cout << "YES" << endl;
else if (s1[1] == s2[1]) {
for (int i = 0; i < 9; i++) {
if (s1[0] == v[i].first) valu_s1 = v[i].second;
if (s2[0] == v[i].first) valu_s2 = v[i].second;
}
if (valu_s1 > valu_s2)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
if (n <= m) {
cout << n;
} else {
long long int val = n - m;
long long int l = 0;
long long int r = 3e9;
while (l < r) {
long long int mid = (l + r) / 2;
long long int val1 = (mid * (mid + 1)) / 2;
if (val1 >= val) {
r = mid;
} else {
l = mid + 1;
}
}
cout << l + m;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 200000;
struct Segment {
long long left;
long long right;
bool operator<(const Segment &other) const { return this->left < other.left; }
};
Segment a[1 + MAX_N];
long long sp[1 + MAX_N];
int main() {
long long n, h;
cin >> n >> h;
for (long long i = 1; i <= n; i++) {
long long x, y;
cin >> x >> y;
a[i] = {x, y};
sp[i] = sp[i - 1] + (1LL * (y - x));
}
sort(a + 1, a + n + 1);
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long left = i;
long long right = n;
long long last = 0;
while (left <= right) {
long long med = (left + right) >> 1;
if (1LL * h - (1LL * a[med].right - 1LL * a[i].left) + sp[med] -
sp[i - 1] >
0) {
last = med;
left = med + 1;
} else {
right = med - 1;
}
}
left = a[i].left;
right = a[last].right;
long long tempH = 1LL * h - (right - left) + sp[last] - sp[i - 1];
ans = max(ans, right + tempH - left);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
char str[n];
for (int i = 0; i < n; i++) {
cin >> str[i];
}
int arr[27] = {0};
char c;
for (int i = 0; i < k; i++) {
cin >> c;
arr[c - 'a'] = 1;
}
long long count = 0;
long long ans = 0;
stack<char> s;
for (int i = 0; i < n; i++) {
if (arr[str[i] - 'a'] == 1) {
s.push(str[i]);
} else {
count = 0;
while (!s.empty()) {
s.pop();
count++;
}
ans = ans + (count * (count + 1)) / 2;
}
}
count = 0;
while (!s.empty()) {
s.pop();
count++;
}
ans = ans + (count * (count + 1)) / 2;
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char *argv[]) {
cin.sync_with_stdio(false);
int n, quality[100010];
int a, b;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
quality[a - 1] = b;
}
int maxquality = 0;
for (int i = 0; i < n; ++i) {
if (quality[i] < maxquality) {
cout << "Happy Alex" << endl;
return 0;
}
maxquality = max(maxquality, quality[i]);
}
cout << "Poor Alex" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long pa = 2, pb = 3, mod = 1e9 + 7;
long long n, m, hasa[222222][28], hasb[222222][28], pwa[222222], pwb[222222], x,
y, len, a[28], b[28], c[28], d[28];
char s[222222];
bool used[28], f, cur;
int main() {
pwa[0] = 1;
for (long long i = 1; i <= 200000; i++) pwa[i] = pwa[i - 1] * pa % mod;
pwb[0] = 1;
for (long long i = 1; i <= 200000; i++) pwb[i] = pwb[i - 1] * pb % mod;
scanf("%I64d%I64d%s", &n, &m, s);
hasa[1][s[0] - 'a'] = 1;
hasb[1][s[0] - 'a'] = 1;
for (long long i = 1; i < n; i++) {
for (long long j = 0; j < 26; j++) {
if ('a' + j == s[i])
hasa[i + 1][j] = (hasa[i][j] * pa + 1) % mod;
else
hasa[i + 1][j] = hasa[i][j] * pa % mod;
if ('a' + j == s[i])
hasb[i + 1][j] = (hasb[i][j] * pb + 1) % mod;
else
hasb[i + 1][j] = hasb[i][j] * pb % mod;
}
}
while (m--) {
scanf("%I64d%I64d%I64d", &x, &y, &len);
for (long long i = 0; i < 26; i++) {
a[i] = (hasa[x + len - 1][i] - hasa[x - 1][i] * pwa[len]) % mod;
b[i] = (hasa[y + len - 1][i] - hasa[y - 1][i] * pwa[len]) % mod;
c[i] = (hasb[x + len - 1][i] - hasb[x - 1][i] * pwb[len]) % mod;
d[i] = (hasb[y + len - 1][i] - hasb[y - 1][i] * pwb[len]) % mod;
if (a[i] < 0) a[i] += mod;
if (b[i] < 0) b[i] += mod;
if (c[i] < 0) c[i] += mod;
if (d[i] < 0) d[i] += mod;
}
memset(used, 0, sizeof(used));
f = 0;
for (long long i = 0; i < 26; i++) {
cur = 0;
for (long long j = 0; j < 26; j++) {
if (a[i] == b[j] && c[i] == d[j] && !used[j]) {
used[j] = 1;
cur = 1;
break;
}
}
if (!cur) {
f = 1;
break;
}
}
if (!f)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
const ld pi = acosl(ld(-1));
const ld inf = 1e20;
const ld eps = 1e-8;
inline ld sqr(ld x) { return x * x; }
inline int sgn(ld x) { return (x > eps) - (x < (-eps)); }
inline int cmp(ld x, ld y) { return sgn((x - y) / max(ld(1), fabsl(x))); }
struct point {
ld x, y;
point() {}
point(ld x, ld y) : x(x), y(y) {}
void input() {
int _x, _y;
scanf("%d%d", &_x, &_y);
x = _x, y = _y;
}
void display() { printf("%.10Lf %.10Lf\n", x, y); }
bool operator<(const point &p) const {
if (fabsl(x - p.x) > eps) return x < p.x;
return y + eps < p.y;
}
bool operator==(const point &p) const {
return fabsl(x - p.x) < eps && fabsl(y - p.y) < eps;
}
};
point operator+(point p1, point p2) { return point(p1.x + p2.x, p1.y + p2.y); }
point operator-(point p1, point p2) { return point(p1.x - p2.x, p1.y - p2.y); }
point operator*(point p, ld c) { return point(p.x * c, p.y * c); }
point operator/(point p, ld c) { return point(p.x / c, p.y / c); }
ld dis(point p) { return sqrtl(sqr(p.x) + sqr(p.y)); }
ld dis(point p1, point p2) { return dis(p1 - p2); }
ld dis2(point p) { return sqr(p.x) + sqr(p.y); }
ld dis2(point p1, point p2) { return dis2(p1 - p2); }
ld vect(point p1, point p2) { return p1.x * p2.y - p2.x * p1.y; }
ld vect(point p, point p1, point p2) { return vect(p1 - p, p2 - p); }
ld scal(point p1, point p2) { return p1.x * p2.x + p1.y * p2.y; }
ld scal(point p, point p1, point p2) { return scal(p1 - p, p2 - p); }
ld getAngle(point p) { return atan2l(p.y, p.x); }
ld getAngle(point p, point p1, point p2) {
return acosl(scal(p, p1, p2) / dis(p - p1) / dis(p - p2));
}
point normalize(point p) { return p / dis(p); }
point virt(point p) { return point(-p.y, p.x); }
point rot(point p, ld t) {
return point(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
point polar(point p, ld r, ld t) {
return point(p.x + r * cos(t), p.y + r * sin(t));
}
point projection(point a, point b, point p) {
return a + (a - b) * (scal(p - a, a - b) / dis2(a - b));
}
ld disToLine(point p, point p1, point p2) {
return fabsl(vect(p, p1, p2)) / dis(p1, p2);
}
ld disToSeg(point p, point p1, point p2) {
if (scal(p1, p, p2) < 0) return dis(p, p1);
if (scal(p2, p, p1) < 0) return dis(p, p2);
return disToLine(p, p1, p2);
}
bool onLine(point p, point p1, point p2) {
return fabsl(vect(p1 - p, p2 - p)) < eps;
}
bool onSeg(point p, point p1, point p2) {
if (!onLine(p, p1, p2)) return 0;
return (p1.x - p.x) * (p2.x - p.x) < eps && (p1.y - p.y) * (p2.y - p.y) < eps;
}
bool cross(point p1, point p2, point p3, point p4) {
return vect(p1, p2, p3) * vect(p1, p2, p4) < -eps &&
vect(p3, p4, p1) * vect(p3, p4, p2) < -eps;
}
bool common(point p1, point p2, point p3, point p4) {
if (max(p1.x, p2.x) + eps < min(p3.x, p4.x) ||
max(p3.x, p4.x) + eps < min(p1.x, p2.x))
return 0;
if (max(p1.y, p2.y) + eps < min(p3.y, p4.y) ||
max(p3.y, p4.y) + eps < min(p1.y, p2.y))
return 0;
return vect(p1, p2, p3) * vect(p1, p2, p4) < eps &&
vect(p3, p4, p1) * vect(p3, p4, p2) < eps;
}
int posLineLine(point p1, point p2, point p3, point p4, point &p) {
ld s1 = vect(p1, p2, p3), s2 = vect(p1, p2, p4);
if (fabsl(s1 - s2) < eps) {
if (fabsl(s1) < eps) return 2;
return 0;
}
p = p3 + (p4 - p3) * (s1 / (s1 - s2));
return 1;
}
int posCirLine(point p, ld r, point p1, point p2, point *q) {
ld a = dis2(p1 - p2);
ld b = scal(p1, p, p2);
ld c = dis2(p - p1) - sqr(r);
ld d2 = sqr(b) - a * c;
if (d2 < -eps) return 0;
ld d = sqrtl(fabsl(d2));
q[0] = p1 + (p2 - p1) * ((b + d) / a);
q[1] = p1 + (p2 - p1) * ((b - d) / a);
if (d2 < eps) return 1;
return 2;
}
int posCirCir(point p1, ld r1, point p2, ld r2, point *q) {
if (p1 == p2) return 0;
ld dx = p2.x - p1.x, dy = p2.y - p1.y;
ld d = dis(p1 - p2);
ld e = (sqr(r1) - sqr(r2) + sqr(d)) / 2 / d;
ld f2 = sqr(r1) - sqr(e);
if (f2 < -eps) return 0;
ld f = sqrtl(fabsl(f2));
q[0] = point(p1.x + (e * dx - f * dy) / d, p1.y + (e * dy + f * dx) / d);
q[1] = point(p1.x + (e * dx + f * dy) / d, p1.y + (e * dy - f * dx) / d);
if (f2 < eps) return 1;
return 2;
}
vector<point> convex_hull(vector<point> ps) {
if ((int)ps.size() <= 1) return ps;
int n = ps.size(), k = 0;
sort(ps.begin(), ps.end());
vector<point> ch(2 * n);
for (int i = 0; i < n; ch[k++] = ps[i++])
while (k >= 2 && vect(ch[k - 2], ch[k - 1], ps[i]) < eps) --k;
for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
while (k >= t && vect(ch[k - 2], ch[k - 1], ps[i]) < eps) --k;
ch.resize(k - 1);
return ch;
}
int n, r;
point get(ld alp) { return point((ld)r * cosl(alp), (ld)r * sinl(alp)); }
ld area(point pt[], int n) {
ld ret = 0;
for (int i = 0; i < n; i++) ret += vect(pt[i], pt[(i + 1) % n]);
return fabsl(ret) / 2;
}
int main() {
scanf("%d%d", &n, &r);
ld ang = (ld)2 * pi / n;
point A = get(pi / 2), B = get(pi / 2 + ang * (n / 2));
point C = get(pi / 2 + ang), D = get(pi / 2 + ang * (n / 2 + 2));
point thep;
posLineLine(A, B, C, D, thep);
point pt[4] = {point(0, 0), A, thep, C};
printf("%.20Lf\n", area(pt, 4) * n);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
int main() {
int n;
string second;
cin >> n >> second;
int ans = 0;
vi v;
int t = 0;
for (int i = 0; i < second.size(); i++) {
if (second[i] == 'B')
t++;
else {
if (t != 0) {
ans++;
v.push_back(t);
t = 0;
}
}
}
if (t != 0) {
ans++;
v.push_back(t);
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[5];
int main() {
int n, x, val;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x == 11)
x = 3;
else if (x == 10)
x = 2;
scanf("%d", &val);
vec[x].push_back(val);
}
int cnt = 0;
int ans = 0;
for (auto x : vec[3]) {
ans += x;
cnt++;
}
int mi = 2, ma = 1;
if (vec[2].size() > vec[1].size()) swap(mi, ma);
sort(vec[ma].begin(), vec[ma].end());
reverse(vec[ma].begin(), vec[ma].end());
for (int i = 0; i < vec[mi].size(); i++) {
ans += vec[mi][i];
ans += vec[ma][i];
}
for (int i = vec[mi].size(); i < vec[ma].size(); i++)
vec[0].push_back(vec[ma][i]);
sort(vec[0].begin(), vec[0].end());
reverse(vec[0].begin(), vec[0].end());
for (int i = 0; i < cnt && i < vec[0].size(); i++) ans += vec[0][i];
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long> p(n, 1);
for (int i = 1; i < n; i++) p[i] = p[i - 1] * 10 % mod;
if (n == 1) return cout << 10, 0;
for (int i = 1; i < n - 1; i++) {
long long x = 0;
x += p[n - i] * 18;
x += (n - i - 1) * 81 * p[n - i - 1];
cout << x % mod << " ";
}
cout << 180 << " " << 10 << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long n;
scanf("%ld", &n);
if (n % 2)
printf("%ld\n", (n - 1) / 2);
else {
long tmp = 1;
while (tmp * 2 <= n) tmp *= 2;
printf("%ld\n", (n - tmp) / 2);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[200001];
bool mark[200001];
int ans;
char s[200001], m[200001];
int len1, len2;
bool check(int x) {
int i, j;
memset(mark, false, sizeof(mark));
for (i = 1; i <= x; i++) {
mark[a[i]] = true;
}
j = 1;
for (i = 1; i <= len1; i++) {
if (mark[i]) continue;
if (s[i] == m[j]) j++;
if (j >= len2 + 1) return true;
}
return false;
}
void dfs(int low, int high) {
int mid;
if (low >= high)
return;
else {
mid = (low + high) >> 1;
if (check(mid)) {
ans = mid;
dfs(mid + 1, high);
} else
dfs(low, mid);
}
}
int main() {
int i;
while (~scanf("%s", s + 1)) {
scanf("%s", m + 1);
len1 = strlen(s + 1);
len2 = strlen(m + 1);
for (i = 1; i <= len1; i++) cin >> a[i];
ans = 0;
dfs(0, len1);
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100500;
const int mod = 1e9 + 7;
inline int madd(int x, int y) { return (x + y) % mod; }
struct pt {
long long x, y;
pt() {}
pt(long long X, long long Y) : x(X), y(Y) {}
long long operator*(const pt& p) { return x * p.y - y * p.x; }
pt operator-(const pt& p) { return pt(x - p.x, y - p.y); }
bool operator<(const pt& p) const {
return make_pair(x, y) < make_pair(p.x, p.y);
}
bool operator==(const pt& p) const {
return make_pair(x, y) == make_pair(p.x, p.y);
}
};
int nxt(int x, int n) { return (x + 1) % n; }
int prv(int x, int n) { return (x - 1 + n) % n; }
void split(const vector<pt>& p, vector<pt>& u, vector<pt>& d) {
int mn = 0, mx = 0;
for (int i = 0; i < (int)(p.size()); i++) {
if (p[i] < p[mn]) mn = i;
if (p[mx] < p[i]) mx = i;
}
for (int i = mn; i != mx; i = nxt(i, p.size())) u.push_back(p[i]);
for (int i = mn; i != mx; i = prv(i, p.size())) d.push_back(p[i]);
u.push_back(p[mx]);
d.push_back(p[mx]);
}
int sgn(long long x) { return (x > 0) - (x < 0); }
int relpos(pt a, pt b, pt p) { return sgn((b - a) * (p - a)); }
int relpos(const vector<pt>& a, pt p) {
if (p.x < a[0].x || p.x > a.back().x) return 2;
if (p < a[0]) return -1;
int pos = lower_bound(a.begin(), a.end(), p) - a.begin();
if (a[pos] == p) return 0;
return relpos(a[pos - 1], a[pos], p);
}
vector<pt> a, u, d, b;
void get(vector<pt>& p) {
int n;
cin >> n;
p.resize(n);
for (int i = 0; i < (int)(n); i++) cin >> p[i].x >> p[i].y;
}
int main() {
get(a);
get(b);
split(a, u, d);
for (int i = 0; i < (int)(b.size()); i++) {
if (relpos(u, b[i]) != -1 || relpos(d, b[i]) != 1) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int a[n];
int dl[n], dr[n];
int ans = 0;
int t;
for (int i = 0; i < n; i++) cin >> a[i];
dl[0] = 1;
dr[n - 1] = 1;
for (int i = 1; i < n; i++) {
dl[i] = min(dl[i - 1] + 1, a[i]);
}
for (int i = n - 2; i >= 0; i--) {
dr[i] = min(dr[i + 1] + 1, a[i]);
}
for (int i = 0; i < n; i++) {
t = min(dl[i], dr[i]);
ans = max(ans, t);
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, string> > vec[100010];
bool cmp(pair<int, string> A, pair<int, string> B) { return A.first > B.first; }
int main() {
long long i, n, m, x, y;
string s;
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> s >> x >> y;
vec[x].push_back(make_pair(y, s));
}
for (i = 1; i <= m; i++) {
sort(vec[i].begin(), vec[i].end(), cmp);
}
for (i = 1; i <= m; i++) {
if (vec[i].size() == 2) {
cout << vec[i][0].second << " " << vec[i][1].second << endl;
} else {
if (vec[i][2].first == vec[i][1].first)
cout << "?" << endl;
else
cout << vec[i][0].second << " " << vec[i][1].second << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int N = 1e5 + 2;
int n, cnt[40], cnt1 = 0, mx;
ll a[N];
vector<ll> b;
bool ok(int num) {
int cur = num;
vector<ll> redun = b;
vector<pair<int, ll> > lst;
for (int i = (0); i <= (mx); ++i) {
if (cur > cnt[i]) {
lst.emplace_back(cur - cnt[i], (1LL << (i - 1)));
cur = cnt[i];
} else
for (int j = (1); j <= (cnt[i] - cur); ++j) redun.emplace_back(1LL << i);
}
if (cur) lst.emplace_back(cur, (1LL << mx));
if (((int)(redun).size()) > num) return 0;
sort((redun).begin(), (redun).end(), greater<ll>());
if (redun.empty()) return 1;
int i = 0;
reverse((lst).begin(), (lst).end());
for (pair<int, ll> v : lst) {
if (redun[i] >= v.second * 2) return 0;
i += v.first;
if (i >= ((int)(redun).size())) break;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = (1); i <= (n); ++i) {
cin >> a[i];
int x = __builtin_ctzll(a[i]);
if (a[i] == (1LL << x))
cnt[x]++, mx = max(mx, x);
else
b.emplace_back(a[i]);
}
int num = 0;
cnt1 = cnt[0];
int l = ((int)(b).size()), r = cnt1;
while (l <= r) {
int m = (l + r) >> 1;
if (ok(m))
r = m - 1;
else
l = m + 1;
}
if (l > cnt1)
cout << -1;
else
for (int i = (l); i <= (cnt1); ++i) cout << i << ' ';
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.