solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int g[20][20];
long long dp[1 << 20][20];
int n, m, ini;
long long calc(int mask, int x) {
long long& resp = dp[mask][x];
if (resp != -1) return resp;
resp = 0;
if (g[x][ini] && __builtin_popcount(mask) >= 3) resp++;
for (int i = ini; i < n; i++) {
if (mask & (1 << i)) continue;
if (!g[x][i]) continue;
resp += calc(mask | (1 << i), i);
}
return resp;
}
int main() {
int a, b;
while (scanf("%d%d", &n, &m) == 2) {
memset(g, 0, sizeof g);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
g[a][b] = g[b][a] = 1;
}
long long R = 0;
for (int i = 0; i < n; i++) {
memset(dp, -1, sizeof dp);
ini = i;
R += calc((1 << i), i);
}
cout << (R >> 1) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long LL_INF = (long long)2e18 + 5;
int main() {
int n, k;
cin >> n >> k;
vector<long long int> a;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<long long int> pre(n + 1, 0), suf(n + 1, 0);
for (int i = 0; i < n; i++) pre[i + 1] = pre[i] + a[i];
for (int i = n - 1; i >= 0; i--) suf[i] = suf[i + 1] + a[i];
long long int ans = LL_INF;
for (int i = 0, j = 0; i < n; i = j) {
long long int val = a[i];
while (j < n && a[j] == val) j++;
if (j - i >= k) {
ans = 0;
break;
}
int need = k - (j - i);
int before = i;
int after = n - j;
long long int bc = before * val - pre[i];
long long int ac = suf[j] - after * val;
if (before >= need) {
ans = min(ans, bc - (before - need));
}
if (after >= need) {
ans = min(ans, ac - (after - need));
}
ans = min(ans, ac + bc - (before + after - need));
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, p[505050], a[505050], b[505050];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 2; i <= n; i++)
if (p[i] == 0) {
p[i] = i;
for (j = i; j <= n / i; j++)
if (p[i * j] == 0) p[i * j] = i;
}
a[1] = 0;
for (i = 2; i <= n; i++) {
a[i] = a[i - 1];
if (p[i] == i) a[i]++;
}
b[1] = a[n] + 1;
for (i = 2; i <= n / 2; i++) b[i] = b[i - 1] + min(a[p[i]], a[n / i]);
j = 1;
for (i = 2; i <= n; i++) {
cout << j << " ";
if (b[j] == i) j++;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
long long sqrt2(long long x) {
long long res = sqrt(x) - 1e-7;
while (res * res <= x) res++;
return res - 1;
}
long long f[1000100][7];
void pre() {
for (int i = 1; i < 1000100; i++) {
for (int j = 1; j <= 6; j++) {
f[i][j] = (f[i - 1][j] + power(i, j, mod)) % mod;
}
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long m;
cin >> m;
pre();
long long val = (m % mod) * ((m % mod) + 1) % mod * ((m % mod) + 2) % mod;
long long ans = 0;
for (long long x = 1; x * x <= m; x++) {
long long y = sqrt2(m - x * x);
ans = (ans + val * (y + 1) % mod +
(x * x % mod) * ((x * x % mod) - 1) % mod *
(2 * (x * x % mod) - 4 - 3 * (m % mod)) % mod * (y + 1) % mod +
2 * f[y][6] % mod +
f[y][4] * (6 * (x * x % mod) - 6 - 3 * (m % mod)) % mod +
f[y][2] *
(2 * (x * x % mod) * ((x * x % mod) - 1) % mod +
(2 * (x * x % mod) - 4 - 3 * (m % mod)) *
(2 * (x * x % mod) - 1) % mod) %
mod) %
mod;
}
ans = (4 * ans + (m % mod) * ((m % mod) + 1) % mod * ((m % mod) + 2) % mod) *
166666668 % mod;
cout << (ans + mod) % mod << endl;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
vector<long long> flash(long long n) {
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
return a;
}
void Shazam() {
long long n;
cin >> n;
vector<long long> a = flash(n);
long long h25 = 0, h50 = 0, h100 = 0;
for (long long i = 0; i < n; i++) {
if (i == 0) {
if (a[i] != 25) {
cout << "NO"
<< "\n";
return;
}
h25++;
continue;
}
if (a[i] == 25) {
h25++;
continue;
}
if (a[i] == 50) {
if (h25 != 0) {
h25--;
h50++;
} else {
cout << "NO"
<< "\n";
return;
}
continue;
}
if (a[i] == 100) {
if (h50 >= 1 && h25 >= 1) {
h25--;
h50--;
} else if (h25 >= 3) {
h25 -= 3;
} else {
cout << "NO"
<< "\n";
return;
}
}
}
cout << "YES"
<< "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
Shazam();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x[3], y[3], f[3];
for (int i = 0; i < (3); ++i) cin >> x[i];
for (int i = 0; i < (3); ++i) cin >> y[i];
for (int i = 0; i < (3); ++i) f[i] = x[i] - y[i];
sort(f, f + 3);
for (int i = 0; i < (3); ++i)
for (int j = 0; j < (i); ++j) {
int tmp = min(-f[j], f[i] / 2);
tmp = max(tmp, 0);
f[j] += tmp;
f[i] -= tmp * 2;
}
bool flag = 0;
for (int i = 0; i < (3); ++i)
if (f[i] < 0) flag = 1;
if (!flag)
puts("Yes");
else
puts("No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[10000], b[10000];
int main() {
int n, i, f, j, r = 1, s = 0;
scanf("%i", &n);
for (i = 0; i < n; i++) {
scanf("%i %i", &a[i], &b[i]);
}
a[i] = 100000;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - (i + 1); j++) {
if (b[j] < b[j + 1]) {
b[j] ^= b[j + 1];
b[j + 1] ^= b[j];
b[j] ^= b[j + 1];
a[j] ^= a[j + 1];
a[j + 1] ^= a[j];
a[j] ^= a[j + 1];
}
if (b[j] == b[j + 1] && a[j] < a[j + 1]) {
b[j] ^= b[j + 1];
b[j + 1] ^= b[j];
b[j] ^= b[j + 1];
a[j] ^= a[j + 1];
a[j + 1] ^= a[j];
a[j] ^= a[j + 1];
}
}
}
j = 0;
for (i = r; i > 0; i--) {
s += a[j];
i += b[j];
if (a[j + 1] == 100000) break;
j++;
}
printf("%i", s);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, long long> mp2;
unordered_map<long long, long long> mp;
unordered_set<long long> st;
vector<long long> vv, v;
int main() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
int n;
long long cnt = 0;
cin >> n;
while (n--) {
int x;
cin >> x;
if (x == 1) {
++cnt;
long long z;
cin >> z;
mp[cnt] = z;
st.insert(cnt);
} else {
long long l, c;
cin >> l >> c;
mp2[{cnt + 1, cnt + (c * l)}] = l;
v.push_back(cnt + 1);
cnt += (c * l);
vv.push_back(cnt);
}
}
int k;
cin >> k;
while (k--) {
long long idx;
cin >> idx;
while (true) {
if (st.count(idx)) {
cout << mp[idx] << " ";
break;
}
long long l = 0, r = v.size() - 1, z, t;
while (l <= r) {
long long mid = (l + r) / 2;
if (v[mid] > idx)
r = mid - 1;
else if (v[mid] <= idx)
z = v[mid], l = mid + 1;
}
l = 0, r = vv.size() - 1;
while (l <= r) {
long long mid = (l + r) / 2;
if (vv[mid] >= idx)
t = vv[mid], r = mid - 1;
else if (vv[mid] < idx)
l = mid + 1;
}
idx -= z;
++idx;
idx %= mp2[{z, t}];
if (!idx) idx = mp2[{z, t}];
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void __print(unsigned x) { cerr << x; }
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
void __print(char x) { cerr << '\'' << x << '\''; }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const int N = 1e6 + 16;
vector<int> prime;
int freq[N];
bitset<N> vis;
void sieve() {
vis[0] = 0;
for (int i = 3; i * i < N; i += 2)
if (vis[i] == 0)
for (int j = i * i, k = i << 1; j < N; j += k) vis[j] = 1;
prime.push_back(2);
for (int i = 3; i < N; i += 2)
if (!vis[i]) prime.push_back(i);
}
void solve() {
int n;
cin >> n;
cout << freq[n] - freq[(int)sqrt(n)] + 1 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
sieve();
freq[0] = 0;
freq[1] = 1;
for (int x : prime) freq[x] = 1;
for (int i = 2; i < N; i += 1) {
freq[i] += freq[i - 1];
}
int tc;
cin >> tc;
while (tc--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e7 + 10;
const long long Mod = 1e9 + 7;
map<string, int> mName;
int n;
int expA, expB, expC;
int numA, numB, numC;
int bestA, bestB, bestC;
long long maxn, minn, ans1, ans2;
bool likeOther[10][10];
int nowTeam[10];
int bestTeam[10];
bool used[10];
vector<int> teamA, teamB, teamC;
void prework() {
mName["Anka"] = 1;
mName["Chapay"] = 2;
mName["Cleo"] = 3;
mName["Troll"] = 4;
mName["Dracul"] = 5;
mName["Snowy"] = 6;
mName["Hexadecimal"] = 7;
}
void dfs(int Team, int num) {
if (Team == 4) {
long long tempLike = 0;
for (int i = 1; i <= 7; i++)
for (int j = 1; j <= 7; j++)
if (likeOther[i][j])
if (nowTeam[i] == nowTeam[j]) tempLike++;
ans2 = max(ans2, tempLike);
return;
}
if (Team == 1) {
for (int i = 1; i <= 7; i++)
if (!used[i]) {
used[i] = true;
nowTeam[i] = 1;
if (num + 1 == bestA)
dfs(Team + 1, 0);
else
dfs(Team, num + 1);
used[i] = false;
}
}
if (Team == 2) {
for (int i = 1; i <= 7; i++)
if (!used[i]) {
used[i] = true;
nowTeam[i] = 2;
if (num + 1 == bestB)
dfs(Team + 1, 0);
else
dfs(Team, num + 1);
used[i] = false;
}
}
if (Team == 3) {
for (int i = 1; i <= 7; i++)
if (!used[i]) {
used[i] = true;
nowTeam[i] = 3;
if (num + 1 == bestC)
dfs(Team + 1, 0);
else
dfs(Team, num + 1);
used[i] = false;
}
}
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
prework();
cin >> n;
ans1 = 1e10;
for (int i = 1; i <= n; i++) {
string a, b, c;
cin >> a >> b >> c;
likeOther[mName[a]][mName[c]] = true;
}
cin >> expA >> expB >> expC;
for (numA = 1; numA <= 5; numA++)
for (numB = 1; numA + numB <= 6; numB++) {
numC = 7 - numA - numB;
maxn = 0;
minn = 1e10;
maxn = max(expA / numA, max(expB / numB, expC / numC));
minn = min(expA / numA, min(expB / numB, expC / numC));
if (maxn - minn < ans1 || (maxn - minn == ans1 && minn != 1)) {
ans1 = maxn - minn;
bestA = numA;
bestB = numB;
bestC = numC;
}
}
dfs(1, 0);
cout << ans1 << " " << ans2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int x, y, k,
counter = 0, m, n, a1 = 4, a2 = 9, b1 = 3, b2 = 8, c1 = 2, c2 = 7, d1 = 5,
d2 = 10, e1 = 1, e2 = 6, a = 0, b = 0, c = 0, d = 0, e = 0;
cin >> x >> y;
if (a1 <= y) {
a++;
}
if (a2 <= y) {
a++;
}
if (b1 <= y) {
b++;
}
if (b2 <= y) {
b++;
}
if (c1 <= y) {
c++;
}
if (c2 <= y) {
c++;
}
if (d1 <= y) {
d++;
}
if (d2 <= y) {
d++;
}
if (e1 <= y) {
e++;
}
if (e2 <= y) {
e++;
}
for (int i = 0; i <= y; i++) {
if (a1 + 10 <= y) {
a++;
a1 = a1 + 10;
}
if (a2 + 10 <= y) {
a++;
a2 = a2 + 10;
}
if (b1 + 10 <= y) {
b++;
b1 = b1 + 10;
}
if (b2 + 10 <= y) {
b++;
b2 = b2 + 10;
}
if (c1 + 10 <= y) {
c++;
c1 = c1 + 10;
}
if (c2 + 10 <= y) {
c++;
c2 = c2 + 10;
}
if (d1 + 10 <= y) {
d++;
d1 = d1 + 10;
}
if (d2 + 10 <= y) {
d++;
d2 = d2 + 10;
}
if (e1 + 10 <= y) {
e++;
e1 = e1 + 10;
}
if (e2 + 10 <= y) {
e++;
e2 = e2 + 10;
}
}
for (int i = 1; i <= x; i++) {
m = i % 5;
if (m == 1) counter += a;
if (m == 2) counter += b;
if (m == 3) counter += c;
if (m == 4) counter += e;
if (m == 0) counter += d;
}
cout << counter;
}
| 1 |
#include <bits/stdc++.h>
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
using namespace std;
bool cmp(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
if (a.first.first == b.first.first) {
return a.first.second > b.first.second;
}
return a.first.first < b.first.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, n, m, k, cnt = 0, ans = 0, t = 1;
cin >> n >> m;
vector<pair<pair<long long, long long>, long long> > v;
for (i = 0; i < m; i++) {
cin >> k >> j;
v.push_back(make_pair(make_pair(k, j), i));
}
sort(v.begin(), v.end(), cmp);
if (v[0].first.second == 0 || (n > 2 && v[0].first.second == 0))
return cout << -1, 0;
map<long long, pair<long long, long long> > mm;
k = 1;
long long f = 1, s = 3, z = 0;
map<pair<long long, long long>, long long> vis;
for (i = 0; i < v.size(); i++) {
if (v[i].first.second == 1) {
cnt++;
mm[v[i].second] = make_pair(k, k + 1);
k++;
} else {
z++;
if (z > (cnt * (cnt + 1)) / 2 - cnt) return cout << -1, 0;
if (s > k || vis[make_pair(f, s)]) {
while (1) {
s++;
if (s > k) {
f++;
if (f > k - 2) f = 1;
s = f + 2;
}
if (!vis[make_pair(f, s)]) break;
}
}
mm[v[i].second] = make_pair(f, s);
vis[make_pair(f, s)] = 1;
s++;
}
}
for (auto it : mm) cout << it.second.first << " " << it.second.second << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 5;
const long long MAXBITS = 22;
long long N, M;
long long A[MAXN];
struct Tree;
Tree *newNode();
struct Tree {
Tree *pl, *pr;
long long l, r;
vector<long long> val, lazy;
void updateVal() {
for (long long i = 0; i < MAXBITS; i++) {
val[i] = pl->val[i] + pr->val[i];
}
}
void propagate() {
pl->apply(lazy), pr->apply(lazy), fill(lazy.begin(), lazy.end(), 0);
}
void apply(vector<long long> &x) {
for (long long i = 0; i < MAXBITS; i++) {
if (x[i] == 0) continue;
lazy[i] ^= x[i], val[i] = (r - l) - val[i];
}
}
void build(long long curl, long long curr) {
l = curl, r = curr;
lazy.resize(MAXBITS);
val.resize(MAXBITS);
fill(lazy.begin(), lazy.end(), 0);
if (l + 1 == r) {
for (long long i = 0; i < MAXBITS; i++) {
val[i] = (A[l] & (1 << i)) ? 1 : 0;
}
return;
}
pl = newNode();
pl->build(l, l + r >> 1);
pr = newNode();
pr->build(l + r >> 1, r);
updateVal();
}
void modify(long long curl, long long curr, vector<long long> &x) {
if (curl <= l && r <= curr) {
apply(x);
return;
}
if (curr <= l || r <= curl) return;
propagate();
pl->modify(curl, curr, x);
pr->modify(curl, curr, x);
updateVal();
}
long long query(long long curl, long long curr) {
long long ans = 0;
if (curl <= l && r <= curr) {
for (long long i = 0; i < MAXBITS; i++) {
ans += val[i] * (1 << i);
}
return ans;
}
if (curr <= l || r <= curl) return 0;
propagate();
return pl->query(curl, curr) + pr->query(curl, curr);
}
};
long long bufSize = MAXN * 2;
Tree buf[(long long)MAXN * 2];
Tree *newNode() { return &buf[--bufSize]; }
Tree *seg;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (long long i = 0; i < N; i++) {
cin >> A[i];
}
seg = newNode();
seg->build(0, N);
long long M;
cin >> M;
for (long long i = 0; i < M; i++) {
long long t;
cin >> t;
if (t == 1) {
long long a, b;
cin >> a >> b;
a--, b--;
long long ans = 0;
cout << seg->query(a, b + 1) << endl;
} else {
long long a, b, x;
cin >> a >> b >> x;
a--, b--;
vector<long long> modify(MAXBITS);
for (long long bit = 0; bit < MAXBITS; bit++) {
modify[bit] = (x & (1 << bit)) ? 1 : 0;
}
seg->modify(a, b + 1, modify);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
string s;
cin >> n >> s;
long long ans = 0;
for (long long i = 0; i < n; i++) {
if ((s[i] - '0') % 2 == 0) {
ans += i + 1;
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout.precision(30);
long long t = 1;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
if (abs(x - y) <= z && z != 0)
cout << "?";
else {
if (x > y)
cout << "+";
else if (x == y)
cout << 0;
else
cout << "-";
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
long long a[1000002] = {};
long long b[1000002] = {};
string s = "", ss = "";
long long n, m, k, w;
long long ans;
long long mod = 1e9 + 7;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int t = 1;
while (t--) {
cin >> m;
cin >> s;
n = s.size();
ans = 0;
vector<long long> v;
v.push_back(0);
for (long long i = 0; i < n; i++)
if (s[i] - '0') v.push_back(i + 1);
v.push_back(n + 1);
if (v.size() - 2 < m) {
cout << "0\n";
continue;
}
if (!m) {
long long c = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == '0')
c++;
else {
ans += c * (c + 1) / 2;
c = 0;
}
}
ans += c * (c + 1) / 2;
cout << ans << "\n";
continue;
}
for (long long i = 1; i < v.size() - 1; i++) {
if (i + m >= v.size()) break;
long long te = v[i] - v[i - 1] - 1;
ans += te;
ans++;
long long te1 = v[i + m] - v[i + m - 1] - 1;
ans += te1;
ans += te * te1;
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, i, j, l, k, x, y, a, b, cnt[3], sum[3];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> a >> b >> k;
vector<long long int> v;
long long int cnt = 0;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
if ((x % (a + b)) > a || (x % (a + b)) == 0) {
v.push_back(x);
} else {
cnt++;
}
}
vector<long long int> vacant;
for (long long int i = 0; i < v.size(); i++) {
if ((v[i] % (a + b)) == 0) {
vacant.push_back(ceil((a + b) / (long double)a) - 1);
} else {
vacant.push_back(ceil((v[i] % (a + b)) / (long double)a) - 1);
}
}
sort(vacant.begin(), vacant.end());
long long int pow = 0;
for (auto x : vacant) {
pow += x;
if (k < pow) {
break;
}
cnt++;
}
cout << (cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
int main(int argc, const char* argv[]) {
int n, m, k, x = 0, y = 0;
cin >> n >> m >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1)
x++;
else
y++;
}
if (x < m) {
int p = min(m - x, y);
x += p;
y -= p;
}
x -= m;
y -= k;
cout << max(0, x) + max(0, y);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[(int)(1e5 + 10)][(1 << 8) + 5];
struct nod {
long long a;
long long s[10];
} mem[(int)(1e5 + 10)];
int cmp(nod x, nod y) { return x.a > y.a; }
int cnt(int n) {
int res = 0;
while (n) {
if (n & 1) res++;
n >>= 1;
}
return res;
}
int main() {
int n, p, k;
scanf("%d%d%d", &n, &p, &k);
for (int i = 0; i < n; i++) scanf("%lld", &mem[i].a);
for (int j = 0; j < n; j++)
for (int i = 0; i < p; i++) scanf("%lld", &mem[j].s[i]);
sort(mem, mem + n, cmp);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 1 << p; j++) {
dp[i][j] = dp[i - 1][j];
if (i - 1 - cnt(j) < k && i - 1 >= cnt(j)) dp[i][j] += mem[i - 1].a;
for (int t = 0; t < p; t++)
if (j >= 1 << t && j & (1 << t))
dp[i][j] = max(dp[i][j], dp[i - 1][j - (1 << t)] + mem[i - 1].s[t]);
}
}
printf("%lld", dp[n][(1 << p) - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
const long long inf = 1e18;
int d, n, m, x[N], p[N], cur, r[N];
long long ans = inf, carry;
pair<int, int> a[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> d >> n >> m;
for (int i = 1; i <= m; i++) cin >> a[i].first >> a[i].second;
vector<int> st;
sort(a + 1, a + m + 1);
for (int i = 1; i <= m; i++) x[i] = a[i].first, p[i] = a[i].second;
for (int i = m; i >= 0; i--) {
r[i] = i;
while (st.size() && p[st.back()] >= p[i]) {
r[i] = r[st.back()];
st.pop_back();
}
st.push_back(i);
}
for (int i = 0, j = 0; i <= m; i++) {
if (cur < 0) {
ans = inf;
break;
}
while (j + 1 <= m && x[j + 1] - x[i] <= n) j++;
if (n >= d - x[i]) {
long long dist = d - x[i];
long long cost = carry;
if (dist > cur) cost += 1ll * (dist - cur) * p[i];
ans = min(ans, cost);
}
if (j < r[i] + 1) {
carry += 1ll * (n - cur) * p[i];
cur = n;
} else {
long long dist = x[r[i] + 1] - x[i];
if (dist > cur) {
carry += 1ll * (dist - cur) * p[i];
cur = dist;
}
}
cur -= (x[i + 1] - x[i]);
}
if (ans == inf) ans = -1;
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[400000];
int main() {
long long ans = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << a[0];
return 0;
}
sort(a, a + n);
for (int i = 0; i < n - 1; i++) ans += a[i] * (i + 2);
ans += a[n - 1] * n;
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t, x, s;
int main() {
scanf("%d%d%d", &t, &s, &x);
if (((x - t) % s == 0 || (x - t) % s == 1) && (x - t) >= 0 && (x - t) != 1) {
printf("YES");
return 0;
} else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
pair<int, int> a[n];
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
if (n == 3) {
cout << a[n - 1].first - a[0].first << ' ' << 1 << "\n1 1 1";
return 0;
}
map<long long int, int> ind;
long long int dp[n], pre[n];
memset(dp, 0, sizeof dp);
memset(pre, 0, sizeof pre);
dp[2] = pre[2] = a[3].first - a[2].first;
ind[dp[2]] = 2;
for (int i = 3; i + 3 < n; i++) {
dp[i] = pre[i - 3] + a[i + 1].first - a[i].first;
pre[i] = max(pre[i - 1], dp[i]);
if (ind.find(dp[i]) == ind.end()) ind[dp[i]] = i;
}
vector<int> cut;
int i = n - 4;
while (i >= 2) {
i = ind[pre[i]];
cut.push_back(i);
i -= 3;
}
int ans[n], t = 1, teams = cut.size() + 1;
for (i = 0; i < n; i++) {
ans[a[i].second] = t;
if (!cut.empty() && cut.back() == i) {
t++;
cut.pop_back();
}
}
cout << a[n - 1].first - a[0].first - pre[n - 4] << ' ' << teams << '\n';
for (int e : ans) cout << e << ' ';
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
struct edge {
int i, j, w;
};
const int maxn = 500;
int n, m, k;
bool vis[maxn][maxn][11];
int dp[maxn][maxn][11];
vector<edge> adj[maxn][maxn];
int solve(int i, int j, int k) {
if (vis[i][j][k]) {
return dp[i][j][k];
}
if (k == 0) {
return 0;
}
int mn = 1 << 30;
for (auto [i2, j2, w] : adj[i][j]) {
mn = min(mn, w + solve(i2, j2, k - 1));
}
dp[i][j][k] = mn;
vis[i][j][k] = 1;
return mn;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m >> k;
if (k & 1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << -1 << ' ';
}
cout << '\n';
}
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m - 1; j++) {
int w; cin >> w;
adj[i][j].push_back({ i,j + 1,w });
adj[i][j + 1].push_back({ i,j,w });
}
}
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < m; j++) {
int w; cin >> w;
adj[i][j].push_back({ i + 1,j,w });
adj[i + 1][j].push_back({ i,j,w });
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << 2*solve(i, j, k/2) << ' ';
}
cout << '\n';
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ull = unsigned long long int;
using dd = double;
using ldd = long double;
ll mod = 1e9 + 7;
int _size = 1 << 18;
vector<ll> tree(_size << 1, 1);
ll get(int v, int l, int r, int fl, int fr) {
if (r <= l || fr <= l || r <= fl) return 1;
if (fl <= l && r <= fr) return tree[v];
return get(v << 1, l, (r + l) >> 1, fl, fr) *
get(v << 1 | 1, (r + l) >> 1, r, fl, fr) % (mod - 1);
}
ll bp(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
void solve() {
int n;
cin >> n;
map<int, int> hv;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
++hv[x];
}
ll mp = 1;
for (auto k : hv) {
tree[_size + k.first] = k.second + 1;
}
for (int i = _size - 1; i > 0; --i)
tree[i] = tree[i << 1] * tree[i << 1 | 1] % (mod - 1);
ll ans = 1;
for (auto j : hv) {
mp = get(1, 0, _size, 0, j.first) * get(1, 0, _size, j.first + 1, _size) %
(mod - 1);
ll MU = 1;
ll curr = 1;
for (int i = 0; i < j.second; ++i) {
curr = curr * j.first % mod;
MU = MU * curr % mod;
}
ans = ans * bp(MU, mp) % mod;
mp = mp * (j.second + 1) % mod;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
t = 1;
for (int i = 0; i < t; ++i) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> prime;
void sieve(long long int n) {
bool bakh[n + 1];
memset(bakh, true, sizeof(bakh));
for (long long int p = 2; p * p <= n; p++) {
if (bakh[p] == true) {
for (long long int i = p * p; i <= n; i += p) bakh[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (bakh[p]) prime.push_back(p);
}
long long int eulertotient(long long int z) {
long long int fac = z;
for (long long int i = 0; prime[i] * prime[i] <= z; i++) {
if (z % prime[i] == 0) {
fac -= (fac / prime[i]);
while (z % prime[i] == 0) z /= prime[i];
}
}
if (z > 1) fac -= (fac / z);
return fac;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
long long int ans = (a * b) / g;
return ans;
}
long long int modInverse(long long int a, long long int m) {
long long int hvf = gcd(a, m);
if (hvf == 1) return power(a, m - 2, m);
return -1;
}
void multiply(long long int F[2][2], long long int M[2][2]) {
long long int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void powermat(long long int F[2][2], long long int n) {
if (n == 0 || n == 1) return;
long long int M[2][2] = {{1, 1}, {1, 0}};
powermat(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
long long int fib(long long int n) {
long long int F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
powermat(F, n - 1);
return F[0][0];
}
bool mark[200005];
vector<long long int> adj[200005];
long long int mx;
void dfs(long long int v) {
mark[v] = true;
mx = max(mx, v);
for (auto j : adj[v]) {
if (!mark[j]) dfs(j);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, m, a, b, ans = 0;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
mx = 1;
dfs(1);
for (long long int i = 2; i <= n; i++) {
if (mark[i]) continue;
if (i <= mx) {
ans++;
dfs(i);
} else {
dfs(i);
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mult_mod(long long x, long long y, long long mod) {
return (x * y - (long long)(x / (long double)mod * y + 1e-3) * mod + mod) %
mod;
}
long long pow_mod(long long a, long long b, long long p) {
long long res = 1;
while (b) {
if (b & 1) res = mult_mod(res, a, p);
a = mult_mod(a, a, p);
b >>= 1;
}
return res % p;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int t, n, a, b, c, cnt;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
string ans;
cnt = 0;
cin >> n >> a >> b >> c >> s;
for (int i = 0; i < n; i++) {
ans += '#';
if (s[i] == 'R' && b) {
ans[i] = 'P';
b--;
cnt++;
} else if (s[i] == 'P' && c) {
ans[i] = 'S';
c--;
cnt++;
} else if (s[i] == 'S' && a) {
ans[i] = 'R';
a--;
cnt++;
}
}
if (cnt < (n + 1) / 2)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) {
if (ans[i] == '#') {
if (a) {
ans[i] = 'R';
a--;
} else if (b) {
ans[i] = 'P';
b--;
} else if (c) {
ans[i] = 'S';
c--;
}
}
}
cout << ans << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> d >> n;
long long int ilosc = 0;
for (int i = 0; i < n - 1; i++) {
int p;
cin >> p;
ilosc += (d - p);
}
cin >> d;
cout << ilosc << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int dp[n];
dp[0] = 0;
int max = 0;
for (int i = 1; i < n; ++i) {
if (a[i] == a[i - 1]) {
dp[i] = 0;
} else {
dp[i] = dp[i - 1] + 1;
}
max = std::max(dp[i], max);
}
cout << max + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long exp(long long x, long long y) {
x %= 1000000007;
long long res = 1;
while (y) {
if (y & 1) res = res * x % 1000000007;
x = x * x % 1000000007;
y >>= 1;
}
return res;
}
long long fact(long long n) {
long long res = 1;
for (long long i = 2; i <= n; ++i) (res *= i) %= 1000000007;
return res;
}
bool isprime(int n) {
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) return 0;
return 1;
}
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
s = '1' + s;
s = s + '1';
int ans = 0;
int i = 0, j = 0;
while (j <= n) {
if (s[j] != '.') {
++j;
continue;
}
if (s[j] == '.') i = j;
while (j <= n && s[j] == '.') ++j;
ans += (j - i - 1);
}
const int inf = int(4e5);
while (m--) {
int x;
char ch;
cin >> x >> ch;
if ((s[x] == '.' && ch == '.') || (s[x] != '.' && ch != '.')) {
cout << ans << '\n';
} else {
int get = 0;
if (s[x] == '.' && ch != '.') {
if (s[x + 1] == '.') --get;
if (s[x - 1] == '.') --get;
ans += get;
} else {
if (s[x + 1] == '.') ++get;
if (s[x - 1] == '.') ++get;
ans += get;
}
cout << ans << '\n';
s[x] = ch;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int m, h, arr[1005];
int main() {
int i, j, n, k, a, b;
double ret;
while (scanf("%d%d%d", &n, &m, &h) == 3) {
h--;
j = 0;
for (i = 0; i < m; i++) {
scanf("%d", &arr[i]);
if (i == h) arr[i]--;
j += arr[i];
}
n--;
if (j < n)
printf("-1.0\n");
else if (arr[h] == 0)
printf("0.0\n");
else {
ret = 1;
a = j - arr[h];
b = j;
for (i = 0; i < n; i++) {
ret *= (double)(a - i) / (double)(b - i);
}
printf("%.6lf\n", 1.0 - ret);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <typename T>
void DBG(const char* name, T&& H) {
cerr << name << " = " << H << ')' << '\n';
}
template <typename T, typename... Args>
void DBG(const char* names, T&& H, Args&&... args) {
const char* NEXT = strchr(names + 1, ',');
cerr.write(names, NEXT - names) << " = " << H << " |";
DBG(NEXT + 1, args...);
}
using ll = long long;
using ld = long double;
const long long mod = 1e9 + 7;
const long double PI = acos(-1.0);
const long long INF = 1e18;
const int maxN = 1e5 + 1;
int N, M;
vector<vector<pair<int, int>>> graph(maxN);
vector<bool> blocked(maxN, false);
void bad() {
cout << "No solution\n";
exit(0);
}
int dfs(int node) {
vector<int> freeedge, toVis;
for (auto i : graph[node]) {
if (blocked[i.second]) continue;
toVis.push_back(i.first);
blocked[i.second] = 1;
}
for (auto i : toVis) {
int end = dfs(i);
if (end != -1) {
cout << node << " " << i << " " << end << '\n';
} else
freeedge.push_back(i);
}
while (freeedge.size() >= 2) {
cout << freeedge.back() << " " << node << " "
<< freeedge[freeedge.size() - 2] << '\n';
freeedge.pop_back();
freeedge.pop_back();
}
if (freeedge.size())
return freeedge.back();
else
return -1;
}
void Solve() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
graph[a].push_back({b, i});
graph[b].push_back({a, i});
}
if (M % 2) bad();
dfs(1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--) {
Solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int INF = 1000000001;
const int MAXN = 5000;
int n, m;
int x[MAXN];
int dp[MAXN];
int ans;
int main() {
cin >> n >> m;
double xi;
for (int i = 0; i < n; i++) {
cin >> x[i] >> xi;
}
memset(dp, 0, sizeof(dp));
int max = 1;
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (int j = 0; j < i; j++) {
if (x[j] <= x[i]) {
dp[i] = dp[j] + 1 > dp[i] ? dp[j] + 1 : dp[i];
;
max = max > dp[i] ? max : dp[i];
;
}
}
}
cout << (n - max) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cover[1005][1005], n;
int pd(int x, int y) {
if ((x < 1) || (x > n) || (y < 1) || (y > n)) return 0;
if ((x - 1 < 1) || (x + 1 > n) || (y - 1 < 1) || (y + 1 > n)) return 0;
if (cover[x][y] == 0) return 0;
if (cover[x - 1][y] == 0) return 0;
if (cover[x][y - 1] == 0) return 0;
if (cover[x - 1][y - 1] == 0) return 0;
if (cover[x][y + 1] == 0) return 0;
if (cover[x + 1][y] == 0) return 0;
if (cover[x + 1][y + 1] == 0) return 0;
if (cover[x - 1][y + 1] == 0) return 0;
if (cover[x + 1][y - 1] == 0) return 0;
return 1;
}
int main() {
int m;
scanf("%d%d", &n, &m);
memset(cover, 0, sizeof(cover));
int i, x, y;
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
cover[x][y] = 1;
if (pd(x, y)) {
printf("%d\n", i);
return 0;
}
if (pd(x - 1, y)) {
printf("%d\n", i);
return 0;
}
if (pd(x - 1, y - 1)) {
printf("%d\n", i);
return 0;
}
if (pd(x, y - 1)) {
printf("%d\n", i);
return 0;
}
if (pd(x + 1, y)) {
printf("%d\n", i);
return 0;
}
if (pd(x, y + 1)) {
printf("%d\n", i);
return 0;
}
if (pd(x + 1, y + 1)) {
printf("%d\n", i);
return 0;
}
if (pd(x + 1, y - 1)) {
printf("%d\n", i);
return 0;
}
if (pd(x - 1, y + 1)) {
printf("%d\n", i);
return 0;
}
}
printf("-1\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
vector<long long> p;
map<long long, long long> edge;
set<long long> rest;
void delete_edge(long long ind) {
if (edge.count(ind) == 0) return;
edge.erase(edge[ind]);
edge.erase(ind);
}
long long myturn() {
if (edge.size()) {
long long ind1 = edge.begin()->first;
long long ind2 = edge.begin()->second;
delete_edge(ind1);
if (p[ind1] > p[ind2])
return ind1;
else
return ind2;
}
return max_element(p.begin(), p.end()) - p.begin();
}
long long juryturn() {
long long res;
cin >> res;
return res - 1;
}
int main() {
ios_base::sync_with_stdio(0);
long long n, m;
cin >> n >> m;
p.resize(2 * n);
for (auto &i : p) cin >> i;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
a--, b--;
edge[a] = b;
edge[b] = a;
}
for (long long i = 0; i < 2 * n; i++) {
rest.insert(i);
}
long long t;
cin >> t;
t--;
long long last = -1;
while (rest.size()) {
if (t == 0) {
if (edge.count(last)) {
last = edge[last];
delete_edge(last);
} else
last = myturn();
cout << last + 1 << endl;
} else {
last = juryturn();
}
rest.erase(last);
p[last] = -INF;
t ^= 1;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct node {
int sum, rmx, lmx, mn, mx, d;
node(int sum = 0, int rmx = 0, int lmx = 0, int mn = 0, int mx = 0, int d = 0)
: sum(sum), rmx(rmx), lmx(lmx), mn(mn), mx(mx), d(d) {}
} t[4 * N];
char s[N];
int n, k;
void update(int k) {
t[k].sum = t[k << 1].sum + t[k << 1 | 1].sum;
t[k].rmx = max(t[k << 1].rmx,
max(t[k << 1 | 1].rmx - t[k << 1].sum,
t[k << 1 | 1].mx + t[k << 1].sum - 2 * t[k << 1].mn));
t[k].lmx = max(t[k << 1].lmx,
max(t[k << 1 | 1].lmx - t[k << 1].sum,
t[k << 1].mx - 2 * (t[k << 1 | 1].mn + t[k << 1].sum)));
t[k].mn = min(t[k << 1].mn, t[k << 1 | 1].mn + t[k << 1].sum);
t[k].mx = max(t[k << 1].mx, t[k << 1 | 1].mx + t[k << 1].sum);
t[k].d = max(max(t[k << 1].d, t[k << 1 | 1].d),
max(t[k << 1 | 1].rmx - t[k << 1].sum + t[k << 1].mx,
t[k << 1].lmx + t[k << 1 | 1].mx + t[k << 1].sum));
}
void build(int l, int r, int k) {
if (l == r) {
int x = s[l] == '(' ? 1 : -1;
t[k] = node(x, -x, -x, x, x, 0);
return;
}
int m = l + r >> 1;
build(l, m, k << 1);
build(m + 1, r, k << 1 | 1);
update(k);
}
void fix(int l, int r, int k, int x) {
if (l == r) {
build(l, r, k);
return;
}
int m = l + r >> 1;
if (x <= m)
fix(l, m, k << 1, x);
else
fix(m + 1, r, k << 1 | 1, x);
update(k);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
n = n * 2 - 2;
build(1, n, 1);
printf("%d\n", t[1].d);
for (int i = 1; i <= k; i++) {
int l, r;
scanf("%d%d", &l, &r);
swap(s[l], s[r]);
fix(1, n, 1, l);
fix(1, n, 1, r);
printf("%d\n", t[1].d);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, pos = 0;
cin >> n >> k;
int min = 0;
int arr[100000];
if (k == 1) {
cout << "1";
} else {
for (i = 0; i < n; i++) {
cin >> arr[i];
min += arr[i];
}
int j;
for (i = 0; i < k; i++) {
int s = 0;
for (j = i; j < n; j = j + k) {
s += arr[j];
}
if (s < min) {
min = s;
pos = i + 1;
}
}
cout << pos;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void find(long long int n) {
long long int ans = n, t = 2;
while (n >= t) {
ans += n / t;
t *= 2;
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long int a;
cin >> a;
find(a);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
if (z == 0) {
if (x > y) cout << "+";
if (x < y) cout << "-";
if (x == y) cout << "0";
} else {
if (x > y + z)
cout << "+";
else if (y > x + z)
cout << "-";
else
cout << "?";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[4];
int D[4];
int check(int p1, int p2) {
if (D[1 - p1] > A[p2] && A[p1] > D[5 - p2]) return 1;
if (D[1 - p1] < A[p2] && A[p1] < D[5 - p2]) return 3;
return 2;
}
int main() {
cin >> D[0] >> A[0];
cin >> D[1] >> A[1];
cin >> D[2] >> A[2];
cin >> D[3] >> A[3];
int results[4];
results[0] = check(0, 2);
results[1] = check(0, 3);
results[2] = check(1, 2);
results[3] = check(1, 3);
if (results[0] == 1 && results[1] == 1) {
cout << "Team 1" << endl;
return 0;
}
if (results[2] == 1 && results[3] == 1) {
cout << "Team 1" << endl;
return 0;
}
if (results[0] != 3 && results[1] != 3) {
cout << "Draw" << endl;
return 0;
}
if (results[2] != 3 && results[3] != 3) {
cout << "Draw" << endl;
return 0;
}
cout << "Team 2" << endl;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define inf ll(1e9)
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin>>T;
while(T--)
{
int n;
cin>>n;
vector<ll>arr(n+1);
for(int i=1; i<=n; i++)
cin>>arr[i];
set<ll>st;
vector<ll>ans;
for(int i=1; i<=n; i++){
if(i==1){
st.insert(arr[i]);
ans.push_back(arr[i]);
}
else{
if(arr[i]==arr[i-1]){
st.insert(-inf);
st.insert(inf);
ans.push_back(inf);
ans.push_back(inf);
}
else if(arr[i]>arr[i-1]){
if(arr[i]>*st.upper_bound(arr[i-1])){
break;
}
else{
st.insert(arr[i]);
st.insert(inf);
ans.push_back(arr[i]);
ans.push_back(inf);
}
}
else{
if(arr[i-1]!=*st.begin() && *prev(st.lower_bound(arr[i-1]))>arr[i]){
break;
}
else{
st.insert(arr[i]);
st.insert(-inf);
ans.push_back(arr[i]);
ans.push_back(-inf);
}
}
}
}
if(ans.size()!=(2*n-1))
cout<<"NO\n";
else
cout<<"YES\n";
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
const int N = 1e5 + 10;
int n, m, k, a[N][6], p[6], lg[N], ans[6];
int st[6][N][25];
bool can(int len) {
for (int i = 0; i + len <= n; i++) {
int l = i, r = i + len;
for (int j = 0; j < m; j++) {
int k = lg[r - l];
ans[j] = max(st[j][l][k], st[j][r - (1 << k)][k]);
}
int sum = 0;
for (int i = 0; i < m; i++) sum += ans[i];
if (sum <= k) return 1;
}
return 0;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
for (int i = 2; i <= n; i++) lg[i] = lg[i / 2] + 1;
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) st[j][i][0] = a[i][j];
for (int k = 1; k < 23; k++)
for (int i = 0; i + (1 << k) <= n; i++)
st[j][i][k] = max(st[j][i][k - 1], st[j][i + (1 << (k - 1))][k - 1]);
}
int l = 0, r = n + 1;
while (l < r) {
int m = (l + r + 1);
m /= 2;
if (can(m))
l = m;
else
r = m - 1;
}
can(l);
if (l == 0) {
for (int i = 0; i < m; i++) printf("0 ");
return 0 * puts("");
}
for (int i = 0; i < m; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int mod2 = 1e9 + 9;
const long long int maxn = 5e5 + 5;
const long long int maxn1 = 1e7 + 1;
const int root = 1e6 + 5;
const long long inf = 1e18 + 18;
double pie4 = 3.1415926535;
long long int cnt[30];
vector<long long int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
long long int i, j, idx = -1;
cin >> s;
for (i = 0; i < int(s.size()); i++) {
cnt[s[i] - 'a']++;
}
for (i = 0; i < 26; i++) {
if (cnt[i] % 2) v.push_back(i);
}
for (i = 0, j = int(v.size()) - 1; i < int(v.size()) && i <= j; i++, j--) {
if (i == j)
idx = v[i];
else {
cnt[v[i]]++;
cnt[v[j]]--;
}
}
v.clear();
for (i = 0; i < 26; i++) {
for (j = 0; j < cnt[i] / 2; j++) {
cout << char(i + 'a');
v.push_back(i);
}
}
if (idx != -1) cout << char(idx + 'a');
reverse(v.begin(), v.end());
for (i = 0; i < int(v.size()); i++) cout << char(v[i] + 'a');
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void yay(int flag) {
if (flag == 0)
cout << "NO";
else
cout << "YES";
cout << endl;
}
int eve(long long int x) {
if (x % 2 == 0) return 1;
return 0;
}
void solve() {
string s;
cin >> s;
int n = s.size();
cout << (n + 1) * 26 - n;
}
int main() {
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) {
solve();
cout << " \n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 20;
int col[maxn];
struct node {
int u, v;
int tonext;
} e[maxn];
int first[maxn];
int num;
void add(int u, int v) {
++num;
e[num].u = u;
e[num].v = v;
e[num].tonext = first[u];
first[u] = num;
}
int tot[maxn];
int lentot;
int dp[maxn];
struct bfsnode {
int cur, cnt;
bfsnode(int a, int b) : cur(a), cnt(b) {}
};
queue<struct bfsnode> que;
bool vis[maxn];
void bfs() {
memset(vis, false, sizeof vis);
for (int i = 1; i <= lentot; ++i) {
que.push(bfsnode(tot[i], 0));
dp[tot[i]] = 0;
}
while (!que.empty()) {
struct bfsnode t = que.front();
que.pop();
for (int i = first[t.cur]; i; i = e[i].tonext) {
int v = e[i].v;
if (vis[v]) continue;
if (dp[v] <= t.cnt + 1) continue;
vis[v] = true;
dp[v] = t.cnt + 1;
que.push(bfsnode(v, t.cnt + 1));
}
}
}
int ansc[maxn][25];
int deep[maxn];
int fa[maxn];
void init_LCA(int cur) {
ansc[cur][0] = fa[cur];
for (int i = 1; i <= 24; ++i) {
ansc[cur][i] = ansc[ansc[cur][i - 1]][i - 1];
}
for (int i = first[cur]; i; i = e[i].tonext) {
int v = e[i].v;
if (v == fa[cur]) continue;
fa[v] = cur;
deep[v] = deep[cur] + 1;
init_LCA(v);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 24; i >= 0; --i) {
if (deep[ansc[x][i]] >= deep[y]) {
x = ansc[x][i];
}
}
if (x == y) return x;
for (int i = 24; i >= 0; --i) {
if (ansc[x][i] != ansc[y][i]) {
x = ansc[x][i];
y = ansc[y][i];
}
}
return ansc[x][0];
}
int dis[maxn];
void dfs(int cur, int step) {
dis[cur] = min(dis[cur], step);
for (int i = first[cur]; i; i = e[i].tonext) {
int v = e[i].v;
if (vis[v]) continue;
vis[v] = true;
dfs(v, step + 1);
}
}
void work() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
memset(dis, 0x3f, sizeof dis);
dis[1] = 0;
vis[1] = true;
dfs(1, 0);
memset(dp, 0x3f, sizeof dp);
col[1] = 1;
tot[++lentot] = 1;
bfs();
lentot = 0;
fa[1] = 1;
deep[1] = 0;
init_LCA(1);
int magic = (int)sqrt(m);
for (int i = 1; i <= m; ++i) {
int flag, which;
scanf("%d%d", &flag, &which);
if (flag == 1) {
tot[++lentot] = which;
} else {
int ans = dp[which];
for (int i = 1; i <= lentot; ++i) {
int haha = LCA(which, tot[i]);
ans = min(ans, dis[which] + dis[tot[i]] - 2 * dis[haha]);
}
printf("%d\n", ans);
}
if (lentot >= magic) {
bfs();
lentot = 0;
}
}
}
int main() {
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cerr.tie(NULL);
}
int main() {
fast();
unsigned long long over = pow(2, 32);
string s;
int i;
unsigned long long num = 0;
stack<unsigned long long> loop;
loop.push(1);
int n;
cin >> n;
while (n--) {
cin >> s;
if (s == "add") {
num += loop.top();
if (num >= over) {
cout << "OVERFLOW!!!";
return 0;
}
} else if (s == "for") {
cin >> i;
loop.push(min(over, loop.top() * i));
} else {
loop.pop();
}
}
cout << num;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
inline long long read() {
long long t = 0, dp = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') dp = -1;
c = getchar();
}
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
return t * dp;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void write_p(long long x) {
write(x);
putchar(' ');
}
const int N = 2e5 + 5;
int a[N], b[5], gg1, gg2, n, ans, top, q[N];
const int inf = 1e9;
inline int pd(int x) {
if (x & 1)
if (a[x - 1] <= a[x])
return 0;
else
return 1;
if (!(x & 1))
if (a[x - 1] >= a[x])
return 0;
else
return 1;
}
inline int ky(int x, int y) {
int tmp = 0;
swap(a[x], a[y]);
tmp = pd(x) + pd(y);
if (x + 1 != y) tmp += pd(x + 1);
if (y + 1 != x) tmp += pd(y + 1);
swap(a[x], a[y]);
tmp -= pd(x) + pd(y);
if (x + 1 != y) tmp -= pd(x + 1);
if (y + 1 != x) tmp -= pd(y + 1);
return tmp;
}
map<int, int> mp[N];
int main() {
a[0] = -1;
n = read();
if (n & 1)
a[n + 1] = -1;
else
a[n + 1] = 0;
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n - 1; ++i) {
if (i & 1)
if (a[i] >= a[i + 1]) q[++top] = i;
if (!(i & 1))
if (a[i] <= a[i + 1]) q[++top] = i;
}
if (top > 4) return puts("0"), 0;
for (int i = 1; i <= n; ++i)
if ((!pd(i)) || (!pd(i + 1))) {
for (int j = 1; j <= n; ++j) {
if (j == i || mp[i][j]) continue;
if (ky(i, j) == top) mp[i][j] = mp[j][i] = 1, ans++;
}
}
writeln(ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1;
inline char getc() {
return (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class T>
inline void read(T &x) {
char ch;
int f = 1;
x = 0;
while (isspace(ch = getc()))
;
if (ch == '-') ch = getc(), f = -1;
do x = x * 10 + ch - '0';
while (isdigit(ch = getc()));
x *= f;
}
template <class T, class... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <class T>
inline void write(T x) {
static char stk[128];
int top = 0;
if (x == 0) {
putc('0');
return;
}
if (x < 0) putc('-'), x = -x;
while (x) stk[top++] = x % 10, x /= 10;
while (top) putc(stk[--top] + '0');
}
template <class T, class... Args>
inline void write(T x, Args... args) {
write(x);
putc(' ');
write(args...);
}
inline void space() { putc(' '); }
inline void endl() { putc('\n'); }
struct _flush {
~_flush() { flush(); }
} __flush;
}; // namespace io
using io::endl;
using io::flush;
using io::getc;
using io::putc;
using io::read;
using io::space;
using io::write;
const int N = 120005;
const int INF = 1e9;
int p[N];
struct value {
int v;
ll c;
value() : v(+INF), c(0) {}
value(int _v, ll _c) : v(_v), c(_c) {}
};
value operator+(const value &a, const value &b) {
if (a.v < b.v)
return a;
else if (b.v < a.v)
return b;
else
return {a.v, a.c + b.c};
}
struct node {
value mn, sum, scnt;
int inc;
} t[N * 4];
void up(int x) {
t[x].mn = t[x << 1].mn + t[x << 1 | 1].mn;
t[x].sum = t[x << 1].sum + t[x << 1 | 1].sum;
}
void tag_mn(int x, int v) {
t[x].scnt.v -= v;
t[x].mn.v += v;
t[x].inc += v;
}
void tag_sum(int x, value v) {
t[x].sum = t[x].sum + value(t[x].mn.v + v.v, t[x].mn.c * v.c);
t[x].scnt = t[x].scnt + v;
}
void down(int x) {
if (t[x].inc) {
tag_mn(x << 1, t[x].inc);
tag_mn(x << 1 | 1, t[x].inc);
t[x].inc = 0;
}
if (t[x].scnt.c) {
tag_sum(x << 1, t[x].scnt);
tag_sum(x << 1 | 1, t[x].scnt);
t[x].scnt = value();
}
}
void modify(int x, int l, int r, int ql, int qr, int d) {
if (ql <= l && r <= qr) return tag_mn(x, d);
int mid = (l + r) >> 1;
down(x);
if (ql <= mid) modify(x << 1, l, mid, ql, qr, d);
if (qr > mid) modify(x << 1 | 1, mid + 1, r, ql, qr, d);
up(x);
}
void cumulate(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return tag_sum(x, {0, 1});
int mid = (l + r) >> 1;
down(x);
if (ql <= mid) cumulate(x << 1, l, mid, ql, qr);
if (qr > mid) cumulate(x << 1 | 1, mid + 1, r, ql, qr);
up(x);
}
value sum(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return t[x].sum;
int mid = (l + r) >> 1;
down(x);
if (ql <= mid && qr <= mid) return sum(x << 1, l, mid, ql, qr);
if (ql > mid && qr > mid) return sum(x << 1 | 1, mid + 1, r, ql, qr);
return sum(x << 1, l, mid, ql, qr) + sum(x << 1 | 1, mid + 1, r, ql, qr);
}
void build(int x, int l, int r) {
if (l == r) {
t[x].mn = {0, 1};
t[x].sum = {+INF, 0};
t[x].inc = 0;
t[x].scnt = {+INF, 0};
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
up(x);
}
void upall(int x, int l, int r) {
if (l == r) return;
int mid = (l + r) >> 1;
down(x);
upall(x << 1, l, mid);
upall(x << 1 | 1, mid + 1, r);
up(x);
}
vector<pair<int, int>> Q[N];
ll res[N];
int mx[N], mxt = 0;
int mn[N], mnt = 0;
int main() {
int n, qc;
read(n);
for (int i = 1; i <= n; ++i) read(p[i]);
read(qc);
for (int i = 1; i <= qc; ++i) {
int l, r;
read(l, r);
Q[r].emplace_back(l, i);
}
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
while (mxt && p[i] > p[mx[mxt]]) {
modify(1, 1, n, mx[mxt - 1] + 1, mx[mxt], -p[mx[mxt]]);
--mxt;
}
modify(1, 1, n, mx[mxt] + 1, i, p[i]);
mx[++mxt] = i;
while (mnt && p[i] < p[mn[mnt]]) {
modify(1, 1, n, mn[mnt - 1] + 1, mn[mnt], p[mn[mnt]]);
--mnt;
}
modify(1, 1, n, mn[mnt] + 1, i, -p[i]);
mn[++mnt] = i;
modify(1, 1, n, 1, i, -1);
cumulate(1, 1, n, 1, i);
for (auto [l, id] : Q[i]) {
auto ret = sum(1, 1, n, l, i);
res[id] = ret.c * int(ret.v == -1);
}
}
for (int i = 1; i <= qc; ++i) write(res[i]), endl();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(double(-1));
const double INF = 1e10;
const double EPS = 1e-8;
inline double sqr(double x) { return x * x; }
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
void in() { scanf("%lf%lf", &x, &y); }
};
bool operator<(const PT &p1, const PT &p2) {
if (fabs(p1.x - p2.x) > EPS) return p1.x < p2.x;
return p1.y + EPS < p2.y;
}
bool operator==(const PT &p1, const PT &p2) {
return fabs(p1.x - p2.x) < EPS && fabs(p1.y - p2.y) < EPS;
}
PT operator+(PT p1, PT p2) { return PT(p1.x + p2.x, p1.y + p2.y); }
PT operator-(PT p1, PT p2) { return PT(p1.x - p2.x, p1.y - p2.y); }
PT operator*(PT p, double c) { return PT(p.x * c, p.y * c); }
PT operator/(PT p, double c) { return PT(p.x / c, p.y / c); }
double dis(PT p) { return sqrt(sqr(p.x) + sqr(p.y)); }
double dis2(PT p) { return sqr(p.x) + sqr(p.y); }
double dis2(PT p1, PT p2) { return sqr(p1.x - p2.x) + sqr(p1.y - p2.y); }
double dis(PT p1, PT p2) { return sqrt(dis2(p1, p2)); }
double vect(PT p1, PT p2) { return p1.x * p2.y - p2.x * p1.y; }
double scal(PT p1, PT p2) { return p1.x * p2.x + p1.y * p2.y; }
double getAngle(PT p) { return atan2(p.y, p.x); }
double vect(PT p, PT p1, PT p2) { return vect(p1 - p, p2 - p); }
double scal(PT p, PT p1, PT p2) { return scal(p1 - p, p2 - p); }
double getAngle(PT p, PT p1, PT p2) {
return getAngle(p2 - p) - getAngle(p1 - p);
}
double getAngle180(PT p, PT p1, PT p2) {
return acos(scal(p, p1, p2) / dis(p, p1) / dis(p, p2));
}
double disToLine(PT p, PT p1, PT p2) {
return fabs(vect(p, p1, p2)) / dis(p1, p2);
}
double disToSeg(PT p, PT p1, PT 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(PT p, PT p1, PT p2) { return fabs(vect(p1 - p, p2 - p)) < EPS; }
bool onSeg(PT p, PT p1, PT 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;
}
PT projection(PT a, PT b, PT p) {
return a + (a - b) * (scal(p - a, a - b) / dis2(a - b));
}
int posLineLine(PT p1, PT p2, PT p3, PT p4, PT &p) {
double s1 = vect(p1, p2, p3), s2 = vect(p1, p2, p4);
if (fabs(s1 - s2) < EPS) {
if (fabs(s1) < EPS) return 2;
return 0;
}
p = p3 + (p4 - p3) * s1 / (s1 - s2);
return 1;
}
int posCirLine(PT p, double r, PT p1, PT p2, PT *q) {
double a, b, c, d2, d;
a = dis2(p1, p2);
b = scal(p1, p, p2);
c = dis2(p, p1) - sqr(r);
d2 = sqr(b) - a * c;
if (d2 < -EPS) return 0;
d = sqrt(fabs(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(PT p1, double r1, PT p2, double r2, PT *q) {
double dx, dy, d, e, f2, f;
dx = p2.x - p1.x, dy = p2.y - p1.y;
d = dis(p1, p2);
e = (sqr(r1) - sqr(r2) + sqr(d)) / 2 / d;
f2 = sqr(r1) - sqr(e);
if (f2 < -EPS) return 0;
f = sqrt(fabs(f2));
q[0] = PT(p1.x + (e * dx - f * dy) / d, p1.y + (e * dy + f * dx) / d);
q[1] = PT(p1.x + (e * dx + f * dy) / d, p1.y + (e * dy - f * dx) / d);
if (f2 < EPS) return 1;
return 2;
}
double calcArea(PT *p, int n) {
double rlt = 0;
for (int i = 0; i < n; i++) rlt += vect(p[i], p[(i + 1) % n]);
return rlt / 2;
}
int inPolygon(PT p, PT *q, int m) {
PT p1, p2;
int k = 0;
for (int i = 0; i < m; i++) {
p1 = q[i], p2 = q[(i + 1) % m];
if (onSeg(p, p1, p2)) return 2;
if (p1.y > p2.y) swap(p1, p2);
if (p1.y < p.y + EPS && p.y + EPS < p2.y && vect(p, p1, p2) > 0) k++;
}
return k % 2;
}
int convex_hull(PT *p, int n, PT *q) {
sort(p, p + n);
n = unique(p, p + n) - p;
if (n == 1) {
q[0] = p[0];
return 1;
}
int m = 0;
for (int i = 0; i < n; i++) {
while (m > 1 && vect(q[m - 2], q[m - 1], p[i]) < EPS) m--;
q[m++] = p[i];
}
int k = m;
for (int i = n - 2; i >= 0; i--) {
while (m > k && vect(q[m - 2], q[m - 1], p[i]) < EPS) m--;
q[m++] = p[i];
}
return --m;
}
const int N = 110000;
PT P[N], Q[2];
int n;
double a;
PT A, B;
int flg[N];
bool can(double x) {
vector<pair<double, int> > vec;
for (int i = 0; i < n; i++)
if (posCirCir(A, x, P[i], dis(P[i], B), Q))
for (int j = 0; j < 2; j++)
vec.push_back(pair<double, int>(getAngle(Q[j] - A), i));
sort(vec.begin(), vec.end());
memset(flg, 0, sizeof flg);
int cnt = 0;
vector<int> sta;
for (auto &t : vec) {
int u = t.second;
if (!flg[u])
sta.push_back(u), flg[u] = 1;
else {
if (sta.back() != u) return 1;
sta.pop_back();
}
}
return 0;
}
int main() {
scanf("%d%lf", &n, &a);
A = PT(-a, 0), B = PT(a, 0);
for (int i = 0; i < n; i++) P[i].in();
double st = 0, en = a * 2;
for (int times = 0; times < 100; times++) {
double md = (st + en) / 2;
if (can(md))
en = md;
else
st = md;
}
printf("%.10lf\n", st);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<int> ch;
vector<bool> vis1;
vector<int> par(1000000);
vector<int> sz(1000000);
void print(vector<int> v) {
vector<int>::iterator it = v.begin();
while (it != v.end()) {
cout << *it << " ";
it++;
}
cout << endl;
}
void create(int n) {
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int fp(int n) {
if (par[n] == n) return n;
return par[n] = fp(par[n]);
}
void merg(int x, int y) {
x = fp(x);
y = fp(y);
if (sz[x] < sz[y]) {
swap(x, y);
}
par[y] = x;
sz[x] += sz[y];
}
int main() {
int n;
cin >> n;
vector<int> occ(101);
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
occ[v[i]]++;
}
int nc = 0;
int gtt = -1;
map<int, int> M;
for (int i = 1; i <= 100; i++) {
if (occ[i] == 1) {
nc++;
M[i] = 1;
} else if (occ[i] > 2) {
gtt = i;
}
}
if (nc % 2 == 0) {
string s;
int prev = 66;
for (int i = 0; i < n; i++) {
if (M[v[i]] == 1) {
s += char(131 - prev);
prev = 131 - prev;
} else {
s += 'A';
}
}
cout << "YES" << endl << s << endl;
} else if (nc % 2 == 1 && gtt != -1) {
int x;
bool d = 0;
string s;
int prev = 66;
for (int i = 0; i < n; i++) {
if (M[v[i]] == 1 || (v[i] == gtt && d == 0)) {
s += char(131 - prev);
prev = 131 - prev;
if (v[i] == gtt) {
d = 1;
x = 131 - prev;
}
} else if (v[i] == gtt && d == 1) {
s += char(x);
} else {
s += 'A';
}
}
cout << "YES" << endl << s << endl;
} else {
cout << "NO" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[300000], t[500001];
int N = 0;
int M = 0;
void prec() {
for (int i = 0; i <= 500000; i++) t[i] = 0;
for (int i = 0; i <= n; i++) {
int buf = a[i];
int sign = 1;
if (buf < 0) sign = -1;
buf = abs(buf);
for (int j = 0; buf; j++, buf /= 2)
if (buf % 2) t[j + i] += sign;
}
N = 0;
for (int i = 0; i < 500000; i++) {
if (t[i] >= 0) {
t[i + 1] += t[i] / 2;
t[i] %= 2;
} else {
t[i + 1] -= (abs(t[i]) + 1) / 2;
t[i] = abs(t[i]) % 2;
}
if (t[i] != 0) N = i;
}
if (t[500000] != 0) N = 500000;
M = 0;
for (int i = 0; i < 500000; i++)
if (t[i] != 0) {
M = i;
break;
}
}
long long pw2[60];
int main() {
pw2[0] = 1;
for (int i = 1; i < 60; i++) pw2[i] = pw2[i - 1] + pw2[i - 1];
scanf("%d %d", &n, &k);
for (int i = 0; i <= n; i++) scanf("%d", &a[i]);
prec();
if (t[N] < 0) {
for (int i = 0; i <= n; i++) a[i] = -a[i];
prec();
}
if (N - M > 40) {
printf("0\n");
return 0;
}
long long val = 0;
for (int i = M; i <= N; i++) {
val = val + pw2[i - M] * t[i];
}
while (M > n) {
M--;
val *= 2;
if (val > 3 * 1ll * k) {
printf("0\n");
return 0;
}
}
int answer = 0;
for (int i = min(n, M); i >= 0; i--) {
if ((a[i] - val) <= k && a[i] - val >= -k && !(a[i] - val == 0 && i == n)) {
answer++;
}
val = val * 2;
if (val > 3 * 1ll * k) break;
}
cout << answer << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
vector<pair<int, int> > g;
cin >> k;
if (k % 2 == 0) {
cout << "NO" << endl;
return 0;
}
if (k == 1) {
cout << "YES" << endl;
cout << "2 1" << endl;
cout << "1 2" << endl;
return 0;
}
int group = 2 * (k - 1);
int halfGroup = group / 2;
int topA = 2, botA = topA + halfGroup - 1;
int topB = 2 + halfGroup, botB = topB + halfGroup - 1;
int offset = 1 + group;
for (int i = 2; i < 2 + halfGroup; i++) {
g.push_back(make_pair(1, i));
g.push_back(make_pair(1 + offset, i + offset));
}
g.push_back(make_pair(topA, topB));
g.push_back(make_pair(topA + offset, topB + offset));
g.push_back(make_pair(botA, botB));
g.push_back(make_pair(botA + offset, botB + offset));
for (int i = topA + 1; i < botA - 1; i += 2) {
g.push_back(make_pair(i, i + 1));
g.push_back(make_pair(i + offset, i + 1 + offset));
}
for (int i = topB; i < botB; i++) {
g.push_back(make_pair(i, i + 1));
g.push_back(make_pair(i + offset, i + 1 + offset));
}
for (int i = topA; i <= botA; i++) {
for (int j = topB; j <= botB; j++) {
if (i + halfGroup == j) continue;
g.push_back(make_pair(i, j));
g.push_back(make_pair(i + offset, j + offset));
}
}
g.push_back(make_pair(1, 1 + offset));
int n = group * 2 + 2;
int m = g.size();
cout << "YES" << endl;
cout << n << " " << m << endl;
for (int i = 0; i < g.size(); i++) {
cout << g[i].first << " " << g[i].second << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
clock_t start = clock();
int gcd(int a, int b) { return (a == 0) ? b : gcd(b % a, a); }
int power(int a, int n) {
int p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
int powm(int a, int n, int mod_) {
int p = 1;
while (n) {
if (n % 2) {
p = (((p % mod_) * 1LL * (a % mod_)) % mod_);
}
n >>= 1;
a = (((a % mod_) * 1LL * (a % mod_)) % mod_);
}
return p % mod_;
}
int powi(int a, int mod_) { return powm(a, mod_ - 2, mod_); }
std::vector<std::vector<pair<int, int>>> ans;
vector<vector<int>> a;
void three(int i, int j) {
vector<pair<int, int>> v;
int l, r;
for (l = 1; l >= 0; --l) {
for (r = 1; r >= 0; --r) {
if (a[i + l][j + r]) {
v.push_back({i + l, j + r});
a[i + l][j + r] = 0;
}
}
}
ans.push_back(v);
}
void two(int i, int j) {
vector<pair<int, int>> v;
int l, r;
int cnt = 0;
for (l = 1; l >= 0; --l) {
for (r = 1; r >= 0; --r) {
if (a[i + l][j + r]) {
++cnt;
v.push_back({i + l, j + r});
a[i + l][j + r] = 0;
break;
}
}
if (cnt) break;
}
cnt = 0;
for (l = 1; l >= 0; --l) {
for (r = 1; r >= 0; --r) {
if (make_pair(i + l, j + r) != v[0] and a[i + l][j + r] == 0) {
++cnt;
v.push_back({i + l, j + r});
a[i + l][j + r] = 1;
}
if (cnt == 2) break;
}
if (cnt == 2) break;
}
ans.push_back(v);
three(i, j);
}
void one(int i, int j) {
vector<pair<int, int>> v;
int l, r;
int cnt = 0;
for (l = 1; l >= 0; --l) {
for (r = 1; r >= 0; --r) {
if (a[i + l][j + r]) {
v.push_back({i + l, j + r});
a[i + l][j + r] = 0;
++cnt;
break;
}
}
if (cnt) break;
}
cnt = 0;
for (l = 1; l >= 0; --l) {
for (r = 1; r >= 0; --r) {
if (make_pair(i + l, j + r) != v[0]) {
++cnt;
v.push_back({i + l, j + r});
a[i + l][j + r] = 1;
}
if (cnt == 2) break;
}
if (cnt == 2) break;
}
ans.push_back(v);
two(i, j);
}
void four(int i, int j) {
vector<pair<int, int>> v;
v.push_back({i + 1, j + 1});
v.push_back({i, j + 1});
v.push_back({i + 1, j});
a[i + 1][j + 1] = a[i + 1][j] = a[i][j + 1] = 0;
ans.push_back(v);
one(i, j);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int mn, mx;
int n, m, k, t, i, j, sum = 0, flag = 0, cnt = 0;
int x = 0, y = 0, z, l = 0, r = 0, q;
int TC = 1, tc = 0;
cin >> TC;
while (tc++ < TC) {
cin >> n >> m;
a.assign(n, vector<int>(m));
string s;
for (i = 0; i < n; ++i) {
cin >> s;
for (j = 0; j < m; ++j) a[i][j] = s[j] - '0';
}
ans.clear();
if (n % 2 and m % 2 and a[n - 1][m - 1] == 1) {
vector<pair<int, int>> v;
i = n - 2;
j = m - 2;
v.push_back({i + 1, j + 1});
v.push_back({i, j + 1});
v.push_back({i + 1, j});
a[i + 1][j + 1] ^= 1;
a[i + 1][j] ^= 1;
a[i][j + 1] ^= 1;
ans.push_back(v);
}
if (n % 2) {
for (j = 0; j < m - 1; j += 2) {
cnt = 0;
i = n - 2;
vector<pair<int, int>> v;
if (a[n - 1][j]) {
v.push_back({n - 1, j});
++cnt;
a[n - 1][j] = 0;
}
if (a[n - 1][j + 1]) {
v.push_back({n - 1, j + 1});
++cnt;
a[n - 1][j + 1] = 0;
}
if (cnt == 0) continue;
v.push_back({n - 2, j});
++cnt;
a[n - 2][j] ^= 1;
if (cnt < 3) {
v.push_back({n - 2, j + 1});
++cnt;
a[n - 2][j + 1] ^= 1;
}
ans.push_back(v);
}
}
if (m % 2) {
for (i = 0; i < n - 1; i += 2) {
cnt = 0;
j = m - 2;
vector<pair<int, int>> v;
if (a[i][m - 1]) {
v.push_back({i, m - 1});
++cnt;
a[i][m - 1] = 0;
}
if (a[i + 1][m - 1]) {
v.push_back({i + 1, m - 1});
++cnt;
a[i + 1][m - 1] = 0;
}
if (cnt == 0) continue;
v.push_back({i, m - 2});
++cnt;
a[i][m - 2] ^= 1;
if (cnt < 3) {
v.push_back({i + 1, m - 2});
++cnt;
a[i + 1][m - 2] ^= 1;
}
ans.push_back(v);
}
}
for (i = 0; i < n - 1; i += 2) {
for (j = 0; j < m - 1; j += 2) {
cnt = 0;
for (l = 0; l < 2; ++l) {
for (r = 0; r < 2; ++r) {
if (a[i + l][j + r]) ++cnt;
}
}
if (cnt == 4) four(i, j);
if (cnt == 3) three(i, j);
if (cnt == 2) two(i, j);
if (cnt == 1) one(i, j);
}
}
cout << (int)((ans).size()) << '\n';
for (i = 0; i < (int)((ans).size()); ++i) {
for (j = 0; j < 3; ++j) {
cout << ans[i][j].first + 1 << ' ' << ans[i][j].second + 1 << ' ';
}
cout << '\n';
}
};
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void prb(int upper) {
for (int i = 10; i >= 0; i--) {
if ((upper & (1 << i)) > 0)
cout << 1;
else
cout << 0;
}
cout << '\n';
}
long long n, k;
long long cnt(long long K) {
long long lower = K;
long long upper = K + (K % 2 == 0 ? 1 : 0);
long long tot = 0;
while (upper <= n) {
tot += upper - lower + 1;
lower = lower << 1;
upper = (upper << 1) + 1;
}
upper = min(upper, n);
tot += max(upper - lower + 1, 0LL);
return tot;
}
long long solveeven() {
long long r = n;
if (r & 1 != 0) r--;
long long l = 1;
r = r / 2;
while (l < r) {
long long m = l + (r - l + 1) / 2;
m = m * 2;
if (cnt(m) >= k) {
l = m / 2;
} else {
r = m / 2 - 1;
}
}
if (cnt(2 * l) < k) return 0;
return l * 2;
}
long long solveodd() {
long long r = n;
if (r & 1 == 0) r--;
long long l = 0;
r = r / 2;
while (l < r) {
long long m = (l) + (r - l + 1) / 2;
m = m * 2 + 1;
if (cnt(m) >= k) {
l = m / 2;
} else {
r = m / 2 - 1;
}
}
return l * 2 + 1;
}
int main() {
cin >> n >> k;
long long ans = 0;
ans = max(solveeven(), solveodd());
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
int mutlakDeger(int a) {
if (a < 0) return -a;
return a;
}
int main() {
int a, b, steps;
scanf("%d %d %d", &a, &b, &steps);
if (steps >= (mutlakDeger(a) + mutlakDeger(b)) &&
(steps % 2) == (mutlakDeger(a) + mutlakDeger(b)) % 2)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
long long int answer = 0;
while (n > 1) {
answer += n;
n /= 2;
}
cout << answer + 1 << '\n';
}
signed main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p[1111];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int n, x;
cin >> n;
n *= 2;
vector<pair<int, pair<int, int> > > v;
for (int i = 2; i <= n; ++i)
for (int j = 1; j < i; ++j) {
cin >> x;
v.push_back({x, {i, j}});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); ++i) {
if (p[v[i].second.first] == 0 && p[v[i].second.second] == 0) {
p[v[i].second.first] = v[i].second.second;
p[v[i].second.second] = v[i].second.first;
}
}
for (int i = 1; i <= n; ++i) cout << p[i] << " \n"[i == n];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
struct bit {
int q[N], n;
bit(long long x = 0) {
memset(q, 0, sizeof(q));
n = 0;
while (x) {
q[n] = x & 1;
x >>= 1;
n++;
}
if (!q[n]) n--;
}
} ss, sx;
int main() {
long long x, s;
while (cin >> s >> x) {
ss = bit(s);
sx = bit(x);
int n = max(ss.n, sx.n);
long long ans = 1;
int flg = 0;
for (int i = n; i >= 1; i--) {
int a = ss.q[i], b = sx.q[i];
int &c = ss.q[i - 1];
switch (a) {
case 0: {
if (b) flg = 1;
break;
}
case 1: {
if (b)
ans *= 2;
else
c += 2;
break;
}
case 2: {
if (b) {
ans *= 2;
c += 2;
}
break;
}
case 3: {
if (b)
flg = 1;
else {
c += 2;
}
}
}
if (flg) break;
}
int a = ss.q[0], b = sx.q[0];
if (a == b || (a == 2 && b == 0)) {
if (a == b && a == 1) ans *= 2;
} else
flg = 1;
if (flg)
puts("0");
else {
if (s == x) ans -= 2;
cout << ans << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int rows, w;
cin >> rows >> w;
vector<long long int> ans(w + 1);
for (int row = 0; row < rows; row++) {
int n;
cin >> n;
vector<int> a(n), perm(n), l(n), r(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
perm[i] = i;
l[i] = i;
r[i] = w - (n - i);
}
sort(perm.begin(), perm.end(), [&](int i, int j) { return a[i] > a[j]; });
set<int> ids;
for (int i = 0; i < n; i++) {
auto it = ids.upper_bound(perm[i]);
if (it != ids.end()) {
r[perm[i]] = min(r[perm[i]], l[*it] - 1);
}
if (it != ids.begin()) {
it--;
l[perm[i]] = max(l[perm[i]], r[*it] + 1);
}
ids.insert(perm[i]);
}
int preff = -1, suff = w;
int mx = w - n - 1;
for (int i = 0; i < n; i++) {
if (l[i] > mx || a[i] >= 0) {
break;
}
preff = min(r[i], mx);
l[i] = preff + 1;
}
int mn = n;
for (int i = n - 1; i >= 0; i--) {
if (r[i] < mn || a[i] >= 0) {
break;
}
suff = max(l[i], mn);
r[i] = suff - 1;
}
for (int i = 0; i < n; i++) {
if (l[i] <= r[i]) {
if (l[i] <= w) ans[l[i]] += a[i];
if (r[i] + 1 <= w) ans[r[i] + 1] -= a[i];
}
}
}
for (int i = 1; i <= w; i++) {
ans[i] += ans[i - 1];
}
for (int i = 0; i < w; i++) {
cout << ans[i] << ' ';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int n, r, c;
string w[MAXN];
int l[MAXN];
int s[MAXN];
int t[MAXN];
int fa[MAXN][21];
int x[MAXN];
int main() {
cin >> n >> r >> c;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) l[i] = w[i].length() + 1;
c++;
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + l[i];
for (int i = 1; i <= n; i++) {
int L = i - 1, R = n;
while (L < R) {
int mid = (L + R + 1) / 2;
if (s[mid] - s[i - 1] <= c)
L = mid;
else
R = mid - 1;
}
t[i] = L;
}
for (int i = 1; i <= n; i++) fa[i][0] = t[i] + 1;
fa[n + 1][0] = n + 1;
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n + 1; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
for (int i = 1; i <= n; i++) {
int p = i;
for (int j = 0; j <= 20; j++)
if ((1 << j) & r) p = fa[p][j];
x[i] = p;
}
int ans = -10000, o = 1;
for (int i = 1; i <= n; i++)
if (x[i] - i > ans) ans = x[i] - i, o = i;
int now = 0;
bool flag = false;
for (int i = o; i < x[o]; i++) {
if (now + l[i] > c) {
cout << endl;
now = 0;
flag = false;
}
now += l[i];
if (flag) cout << ' ';
cout << w[i];
flag = true;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300010], b[300010];
long long mins[300010], top1, maxs[300010], top2;
long long tot[300010 << 2], tree[300010 << 2], tag[300010 << 2];
void build(int o, int l, int r) {
if (l == r) {
tot[o] = 1;
return;
}
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
tot[o] = tot[o << 1] + tot[o << 1 | 1];
}
void add(int o, int l, int r, int L, int R, int w) {
if (L <= l && r <= R) {
tree[o] += w;
tag[o] += w;
return;
}
int mid = (l + r) >> 1;
if (tag[o]) {
tag[o << 1] += tag[o];
tag[o << 1 | 1] += tag[o];
tree[o << 1] += tag[o];
tree[o << 1 | 1] += tag[o];
tag[o] = 0;
}
if (mid >= L) add(o << 1, l, mid, L, R, w);
if (mid < R) add(o << 1 | 1, mid + 1, r, L, R, w);
tree[o] = min(tree[o << 1], tree[o << 1 | 1]);
tot[o] = (tree[o << 1] == tree[o] ? tot[o << 1] : 0) +
(tree[o << 1 | 1] == tree[o] ? tot[o << 1 | 1] : 0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
a[x] = y;
}
build(1, 1, n);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
while (top1 && a[mins[top1]] > a[i])
add(1, 1, n, mins[top1 - 1] + 1, mins[top1], a[mins[top1]]), --top1;
while (top2 && a[maxs[top2]] < a[i])
add(1, 1, n, maxs[top2 - 1] + 1, maxs[top2], -a[maxs[top2]]), --top2;
add(1, 1, n, 1, i, -1);
mins[++top1] = maxs[++top2] = i;
add(1, 1, n, mins[top1 - 1] + 1, mins[top1], -a[i]);
add(1, 1, n, maxs[top2 - 1] + 1, maxs[top2], a[i]);
ans += tot[1];
}
printf("%lld", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
set<int> ans;
ans.insert(0);
int i = 1;
for (; i * i <= n; i++) {
ans.insert(i);
ans.insert(n / i);
}
cout << ans.size() << '\n';
for (int u : ans) cout << u << ' ';
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int __SIZE = 1 << 18;
char ibuf[__SIZE], *iS, *iT;
template <typename T>
inline void read(T &x) {
char ch, t = 0;
x = 0;
while (!isdigit(ch = (iS == iT
? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)))
t |= ch == '-';
while (isdigit(ch))
x = x * 10 + (ch ^ 48),
ch = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
x = t ? -x : x;
}
inline char read_alpha() {
char c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
while (!isalpha(c) && c != EOF)
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
return c;
}
inline int read_int() {
int x;
return read(x), x;
}
inline long long read_ll() {
long long x;
return read(x), x;
}
template <typename T>
inline void chkmin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline void chkmax(T &a, T b) {
a = a > b ? a : b;
}
const int MAXN = 100010;
long long x[MAXN];
long long y[MAXN];
long long z[MAXN];
long long l[5], r[5];
inline int check(long long val, int n, int tp = 0) {
for (int i = 1; i < 5; i++) l[i] = -3e18, r[i] = 3e18;
for (int i = 1; i <= n; i++) {
chkmax(l[1], x[i] + y[i] + z[i] - val);
chkmin(r[1], x[i] + y[i] + z[i] + val);
chkmax(l[2], -x[i] + y[i] + z[i] - val);
chkmin(r[2], -x[i] + y[i] + z[i] + val);
chkmax(l[3], x[i] - y[i] + z[i] - val);
chkmin(r[3], x[i] - y[i] + z[i] + val);
chkmax(l[4], x[i] + y[i] - z[i] - val);
chkmin(r[4], x[i] + y[i] - z[i] + val);
}
for (int i = 1; i < 5; i++)
if (l[i] > r[i]) return 0;
for (int rt = 0; rt < 2; rt++) {
long long tl[5], tr[5];
tl[1] = (l[1] - 3 * rt + 1) >> 1, tr[1] = (r[1] - 3 * rt) >> 1;
for (int i = 2; i < 5; i++)
tl[i] = (l[i] - rt + 1) >> 1, tr[i] = (r[i] - rt) >> 1;
int flag = 1;
for (int i = 1; i < 5; i++)
if (tl[i] > tr[i]) flag = 0;
if (!flag) continue;
long long sl = tl[2] + tl[3] + tl[4];
long long sr = tr[2] + tr[3] + tr[4];
if (tl[1] <= sr && sl <= tr[1]) {
if (tp) {
long long a = tl[2], b = tl[3], c = tl[4], lim = tl[1];
if (a + b + c < lim) a += min(tr[2] - tl[2], lim - a - b - c);
if (a + b + c < lim) b += min(tr[3] - tl[3], lim - a - b - c);
if (a + b + c < lim) c += min(tr[4] - tl[4], lim - a - b - c);
printf("%lld %lld %lld\n", b + c + rt, a + c + rt, a + b + rt);
}
return 1;
}
}
return 0;
}
int main() {
int Cases = read_int();
while (Cases--) {
int n = read_int();
for (int i = 1; i <= n; i++)
x[i] = read_ll(), y[i] = read_ll(), z[i] = read_ll();
long long l = 0, r = 3e18, res;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid, n))
res = mid, r = mid - 1;
else
l = mid + 1;
}
check(res, n, 1);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int DP[300010][22], level[300010], dis1, dis2, maxdis, u, n;
list<int> s1, s2;
bool check1[300010], check2[300010];
int lca(int a, int b) {
if (level[a] > level[b]) swap(a, b);
int d = level[b] - level[a];
for (int i = 0; i < 20; i++)
if (d & (1 << i)) b = DP[b][i];
if (a == b) return a;
for (int i = 20 - 1; i >= 0; i--)
if (DP[a][i] != DP[b][i]) a = DP[a][i], b = DP[b][i];
return DP[a][0];
}
int dis(int u, int v) {
int hold = lca(u, v);
return level[u] + level[v] - 2 * level[hold];
}
int main() {
scanf("%d", &n);
level[1] = 1;
DP[1][0] = 1;
s1.clear();
s2.clear();
s1.push_back(1);
check1[1] = 1;
maxdis = 1;
for (int v = 2; v <= n + 1; v++) {
scanf("%d", &u);
level[v] = level[u] + 1;
DP[v][0] = u;
for (int i = 1; (1 << i) < level[v]; i++) {
DP[v][i] = DP[DP[v][i - 1]][i - 1];
}
dis1 = s1.size() ? dis(v, *s1.begin()) : 0;
dis2 = s2.size() ? dis(v, *s2.begin()) : 0;
if (max(dis1, dis2) > maxdis) {
maxdis = max(dis1, dis2);
if (maxdis == dis1) {
for (const auto& u : s2) {
if (dis(u, v) == maxdis) {
if (!check1[u]) {
s1.push_back(u);
check1[u] = 1;
}
check2[u] = 0;
}
}
s2.clear();
s2.push_back(v);
check2[v] = 1;
} else {
for (auto const& u : s1) {
if (dis(u, v) == maxdis) {
if (!check2[u]) {
s2.push_back(u);
check2[u] = 1;
}
check1[u] = 0;
}
}
s1.clear();
s1.push_back(v);
check1[v] = 1;
}
} else if (max(dis1, dis2) == maxdis) {
if (dis1 >= dis2)
s2.push_back(v), check2[v] = 1;
else
s1.push_back(v), check1[v] = 1;
}
printf("%d\n", int(s1.size() + s2.size()));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void reader(int *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(long long *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(double *x) { scanf("%lf", x); }
int reader(char c[]) {
int i, s = 0;
for (;;) {
(i) = getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
(i) = getchar();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T *x, S *y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T *x, S *y, U *z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T *x, S *y, U *z, V *w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(double x, char c) {
printf("%.15f", x);
putchar(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) putchar(c[i]);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) putchar(x[i]);
putchar(c);
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
int i;
if (!n) {
putchar('\n');
return;
}
for (i = 0; i < n - 1; i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
char memarr[77000000];
void *mem = memarr;
int getPrime(int N, int res[]) {
int i, a, b, s = 1, f[4780], S = 1;
const int r = 23000;
bool B[r], *p = B;
N /= 2;
res[0] = 2;
b = min(r, N);
for (i = 1; i < b; i++) p[i] = 1;
for (i = 1; i < b; i++)
if (p[i]) {
res[s++] = 2 * i + 1;
f[S] = 2 * i * (i + 1);
if (f[S] < N) {
for (; f[S] < r; f[S] += res[S]) p[f[S]] = 0;
S++;
}
}
for (a = r; a < N; a += r) {
b = min(a + r, N);
p -= r;
for (i = a; i < b; i++) p[i] = 1;
for (i = 1; i < S; i++)
for (; f[i] < b; f[i] += res[i]) p[f[i]] = 0;
for (i = a; i < b; i++)
if (p[i]) res[s++] = 2 * i + 1;
}
return s;
}
int ps, p[100000];
int N, L[333], C[333];
int lis[20], liss;
int dp[5000];
int main() {
int i, j, k, x, mask;
int res = 1000000000, tmp;
ps = getPrime(100000, p);
reader(&N);
for (i = 0; i < N; i++) reader(L + i);
for (i = 0; i < N; i++) reader(C + i);
for (k = 0; k < N; k++) {
j = L[k];
liss = 0;
for (i = 0; i < ps; i++) {
if (p[i] * p[i] > j) break;
if (j % p[i] == 0) {
while (j % p[i] == 0) j /= p[i];
lis[liss++] = p[i];
}
}
if (j > 1) lis[liss++] = j;
for (i = 0; i < 1 << liss; i++) dp[i] = 1000000000;
dp[0] = 0;
for (x = 0; x < N; x++)
if (k != x) {
mask = 0;
for (i = 0; i < liss; i++)
if (L[x] % lis[i]) mask |= (1 << i);
for (i = 0; i < 1 << liss; i++)
dp[i | mask] = min(dp[i | mask], dp[i] + C[x]);
}
res = min(res, dp[(1 << liss) - 1] + C[k]);
}
if (res >= 1000000000) res = -1;
writerLn(res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long const INF = 999999999999999999;
bool Xor(bool a, bool b) { return (a || b) && (!a || !b) || (!a && !b); }
bool U = false, D = false, R = false, L = false;
vector<long long> X(0);
vector<long long> Y(0);
bool Check(long long x, long long y) {
for (int i = 0; i < X.size(); ++i) {
if (X[i] == x && Y[i] == y) return false;
}
return false;
}
void Clear() {
U = false;
D = false;
L = false;
R = false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, y = 0, x = 0;
cin >> n;
long long mil = 210000;
long long ans = 0;
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
switch (c) {
case 'R': {
if (L) {
ans++;
Clear();
}
R = true;
x++;
break;
}
case 'L': {
if (R) {
ans++;
Clear();
}
L = true;
x--;
break;
}
case 'U': {
if (D) {
ans++;
Clear();
}
U = true;
y++;
break;
}
case 'D': {
if (U) {
ans++;
Clear();
}
D = true;
y--;
break;
}
}
}
if (!Check(x, y)) ans++;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 8e5 + 1;
const double PI = acos(-1.0);
const long long mod = 1e9 + 7;
long long po(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
int n;
long long tot;
bool vis1[100001], vis2[100001];
char v[maxn];
struct trie {
int cnt;
int node[maxn][26];
vector<int> val[maxn][2];
void insert(char *x, int len, int fl, int idx) {
int now = 0;
val[now][fl].push_back(idx);
for (int i = 0; i < len; i++) {
int k = x[i] - 'a';
if (node[now][k] == 0) {
++cnt;
node[now][k] = cnt;
}
now = node[now][k];
val[now][fl].push_back(idx);
}
}
} tr;
vector<pair<int, int> > ans;
void dfs(int x, int dep) {
for (int i = 0; i < 26; i++) {
if (tr.node[x][i]) {
dfs(tr.node[x][i], dep + 1);
}
}
for (int i = 0; i < tr.val[x][0].size(); i++) {
int k1 = tr.val[x][0][i];
if (vis1[k1]) continue;
for (int j = 0; j < tr.val[x][1].size(); j++) {
int k2 = tr.val[x][1][j];
if (vis2[k2]) continue;
vis1[k1] = vis2[k2] = 1;
tot += dep;
ans.push_back(make_pair(k1, k2));
break;
}
}
}
void init() { tr.cnt = 0; }
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", v);
int len = strlen(v);
tr.insert(v, len, 0, i);
}
for (int i = 1; i <= n; i++) {
scanf("%s", v);
int len = strlen(v);
tr.insert(v, len, 1, i);
}
tot = 0;
dfs(0, 0);
printf("%lld\n", tot);
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
int main() {
init();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma hdrstop
using namespace std;
#pragma argsused
int main(int argc, char* argv[]) {
int n;
cin >> n;
if (n == 2) {
cout << "-1";
return 0;
}
cout << "6" << endl;
cout << "10" << endl;
cout << "15" << endl;
for (int i = 2; i <= n - 2; ++i) {
printf("%d\n", 15 * i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double PI = 4.00 * (atan(1));
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int row, col, size;
cin >> row >> col;
long long int matrix[row][col];
for (long long int i = 0; i < row; i++) {
for (long long int j = 0; j < col; j++) {
cin >> matrix[i][j];
}
}
long long int posrow[row][col];
long long int poscol[row][col];
long long int sizerow[row];
long long int sizecol[col];
set<long long int> s1;
map<long long int, long long int> pos;
vector<long long int> final;
for (long long int i = 0; i < row; i++) {
s1.clear();
final.clear();
for (long long int j = 0; j < col; j++) {
s1.insert(matrix[i][j]);
}
final.insert(final.begin(), s1.begin(), s1.end());
size = final.size();
sizerow[i] = size;
for (long long int j = 0; j < size; j++) {
pos[final[j]] = j + 1;
}
for (long long int j = 0; j < col; j++) {
posrow[i][j] = pos[matrix[i][j]];
}
}
for (long long int i = 0; i < col; i++) {
s1.clear();
final.clear();
set<long long int> s1;
for (long long int j = 0; j < row; j++) {
s1.insert(matrix[j][i]);
}
final.insert(final.begin(), s1.begin(), s1.end());
vector<long long int> final(s1.begin(), s1.end());
map<long long int, long long int> pos;
size = final.size();
sizecol[i] = size;
for (long long int j = 0; j < size; j++) {
pos[final[j]] = j + 1;
}
for (long long int j = 0; j < row; j++) {
poscol[j][i] = pos[matrix[j][i]];
}
}
long long int diffx1, diffy1, diffx2, diffy2, ans;
for (long long int i = 0; i < row; i++) {
for (long long int j = 0; j < col; j++) {
diffx1 = posrow[i][j];
diffx2 = (sizerow[i] - diffx1);
diffy1 = poscol[i][j];
diffy2 = (sizecol[j] - diffy1);
long long int ans = max(diffx1, diffy1);
ans += max(diffx2, diffy2);
cout << ans << " ";
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
bool b[26] = {0};
char s[3001];
int len, cnt_occ = 0, cnt_letter = 0;
void init_b() {
for (int i = 0; i < 26; i++) b[i] = false;
}
int main() {
scanf("%s", s);
len = strlen(s);
for (int i = 0; i < len; i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
cnt_occ = 0;
cnt_letter = 0;
init_b();
} else {
if (b[s[i] - 'a'] == false) {
cnt_letter++;
b[s[i] - 'a'] = true;
}
cnt_occ++;
}
if (cnt_occ > 2 && cnt_letter >= 2) {
printf(" ");
init_b();
cnt_occ = 0;
cnt_letter = 0;
if (s[i] != 'a' && s[i] != 'e' && s[i] != 'i' && s[i] != 'o' &&
s[i] != 'u') {
b[s[i] - 'a'] = true;
cnt_letter = 1;
cnt_occ = 1;
}
}
printf("%c", s[i]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
while (n--) {
int x, y;
scanf("%d %d", &x, &y);
int res = int(x / y);
res *= y;
if ((y - int(y / 2) - (y & 1)) + res <= x)
printf("%d\n", (y - int(y / 2) - (y & 1)) + res);
else
printf("%d\n", x);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 4 * atan((long double)1);
const long long mod = 1e9 + 7;
const long long inf = 1e9;
const long long llinf = 1e18;
const long long nax = 0;
long long w, h;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> w >> h;
long long ans = 0;
for (int i = 2; i <= h; i += 2) {
for (int j = 2; j <= w; j += 2) {
ans += (h - (i - 1)) * (w - (j - 1));
}
}
cout << ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> edge[maxn];
int de[maxn];
int main() {
int n, m, u, v, q;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &u, &v);
if (u > v) swap(u, v);
edge[u].push_back(v);
de[u]++;
de[v]++;
}
long long res = 0;
for (int i = 1; i <= n; i++)
res += 1ll * edge[i].size() * (de[i] - edge[i].size());
printf("%lld\n", res);
scanf("%d", &q);
while (q--) {
scanf("%d", &v);
res -= 1ll * edge[v].size() * (de[v] - edge[v].size());
for (auto x : edge[v]) {
res -= 1ll * edge[x].size() * (de[x] - edge[x].size());
edge[x].push_back(v);
res += 1ll * edge[x].size() * (de[x] - edge[x].size());
}
edge[v].clear();
printf("%lld\n", res);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<int> g[200 * 1000 + 5];
int a[200 * 1000 + 5], dist[200 * 1000 + 5];
ll ans = 0, dp[200 * 1000 + 5], sum = 0;
void dfs1(int u, int p = -1) {
dp[u] = a[u];
for (int v : g[u]) {
if (v == p) continue;
dist[v] = dist[u] + 1;
dfs1(v, u);
dp[u] += dp[v];
}
}
void dfs2(int u, ll cur, int p = -1) {
ans = max(ans, cur);
for (int v : g[u]) {
if (v == p) continue;
cur += sum - 2 * dp[v];
dfs2(v, cur, u);
cur -= sum - 2 * dp[v];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(0);
for (int i = 0; i < n; i++) {
ans += 1LL * dist[i] * a[i];
}
dfs2(0, ans);
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000 + 1;
struct Edge {
int u, v, w;
} e[maxn];
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, sum;
int a[maxn], pre[maxn], sz[maxn];
bool cmp(Edge a, Edge b) { return a.w < b.w; }
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
int main() {
n = read();
for (int i = 1; i < n; i++) {
e[i].u = read();
e[i].v = read();
e[i].w = read();
}
sort(e + 1, e + n, cmp);
for (int i = 1; i <= n; i++) {
a[i] = read();
pre[i] = i;
sz[i] = 1;
sum += a[i];
}
for (int i = 1; i < n; i++) {
int u = find(e[i].u), v = find(e[i].v);
pre[u] = v;
sz[v] += sz[u];
a[v] += a[u];
if (sz[v] > sum - a[v]) {
printf("%d\n", e[i].w);
return 0;
}
}
puts("0");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
inline long long int add(long long int a, long long int b) {
return (a % mod + b % mod) % mod;
}
inline long long int sub(long long int a, long long int b) {
return (a % mod - b % mod + mod) % mod;
}
inline long long int mul(long long int a, long long int b) {
a %= mod;
b %= mod;
return a * b % mod;
}
inline long long int power(long long int a, long long int b,
long long int MOD) {
a %= mod;
long long int res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= MOD;
}
a = a * a;
a %= MOD;
b >>= 1;
}
return res;
}
clock_t time_p = clock();
void time() {
time_p = clock() - time_p;
cerr << "Time elapsed : " << (long double)(time_p) / CLOCKS_PER_SEC << endl;
}
signed main() {
long long int t = 1;
cin >> t;
while (t--) {
long long int n, k, i, j, temp, x, f;
bool ok = false, improve = false, again = true;
set<long long int> klist, flist;
scanf("%lld", &n);
temp = n;
set<long long int>::iterator itr;
for (i = 0; i < n; i++) {
scanf("%lld", &k);
ok = false;
while (k--) {
scanf("%lld", &x);
klist.insert(x);
}
for (itr = klist.begin(); itr != klist.end(); ++itr) {
if (flist.find(*itr) == flist.end()) {
flist.insert(*itr);
ok = true;
break;
}
}
klist.clear();
if (!ok && again) {
improve = true;
again = false;
f = i + 1;
}
}
if (!improve)
printf("OPTIMAL\n");
else {
printf("IMPROVE\n");
for (i = 1; i <= n; i++) {
if (flist.find(i) == flist.end()) {
temp = i;
break;
}
}
printf("%lld %lld\n", f, temp);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
while (cin >> a >> b) {
if (b > a) {
cout << 0 << '\n';
continue;
}
if (b == a) {
cout << "infinity" << '\n';
continue;
}
int ans = 0;
int n = a - b;
for (int i = 1; i <= int(sqrt(double(n))); i++) {
if (n % i == 0) {
if (i > b) {
ans++;
}
if (n / i > b && n / i != i) ans++;
}
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool cmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool cmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int n, ln, rn, r[1234], a[1234][1234], b[1234][1234];
pair<int, int> l[1234];
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 1; i <= n - 3; i++) scanf("%d%d", &j, &k), a[j][k] = a[k][j] = 1;
for (i = 1; i <= n - 3; i++) scanf("%d%d", &j, &k), b[j][k] = b[k][j] = 1;
for (i = 2; i <= n; i++)
for (j = n; j > i + 1; j--) {
if (a[i][j]) {
l[++ln] = make_pair(i, j);
a[i][j] = a[j][i] = 0;
}
}
for (i = 2; i <= n; i++)
for (j = n; j > i + 1; j--)
if (b[i][j]) {
for (k = j - 1; k > i; k--)
if (b[i][k] || k == i + 1) break;
r[++rn] = k;
b[i][j] = b[j][i] = 0;
b[1][k] = b[k][1] = 1;
}
printf("%d\n", ln + rn);
for (i = 1; i <= ln; i++) printf("%d %d\n", l[i].first, l[i].second);
for (i = rn; i; i--) printf("1 %d\n", r[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200000 + 10], n, A, totalsum, res[200000 + 10];
bool check(int x, int i) {
long long sum = totalsum;
sum -= arr[i];
sum += x;
return sum >= A;
}
bool check2(int x, int i) {
long long sum = n - 1;
sum += x;
return sum <= A;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> A;
totalsum = 0;
for (int i = 0; i < (int)n; i++) cin >> arr[i], totalsum += arr[i];
for (int i = 0; i < (int)n; i++) {
long long f = 1, l = arr[i] + 1, ans;
while (f < l) {
long long mid = (f + l) / 2;
if (check(mid, i)) {
l = mid;
ans = mid;
} else {
f = mid + 1;
}
}
res[i] = ans - 1;
}
for (int i = 0; i < (int)n; i++) {
long long f = 1, l = arr[i] + 1, ans;
while (f < l) {
long long mid = (f + l) / 2;
if (check2(mid, i)) {
f = mid + 1;
ans = mid;
} else {
l = mid;
}
}
res[i] += (arr[i] - ans);
}
for (int i = 0; i < (int)n; i++) cout << res[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200200], b[200200], tmp;
int c[200200], t[200200], ans[200200];
void plusnm(int k) {
for (; k <= n; k += (k & (-k))) t[k]++;
}
void decnm(int k) {
for (; k <= n; k += (k & (-k))) t[k]--;
}
int Ctot(int k) {
int ans = 0;
for (; k; k -= (k & (-k))) ans += t[k];
return ans;
}
int Cans(int k) {
int ret = 0, tot = 0;
for (int i = (1 << 20); i; i >>= 1)
if (ret + i <= n && Ctot(ret + i) < k) ret += i;
ret++;
return ret;
}
int main() {
memset(c, 0, sizeof c);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) a[i]++;
memset(t, 0, sizeof(t));
for (int i = n; i > 0; i--) tmp = a[i], a[i] = Ctot(a[i]), plusnm(tmp);
for (int i = 1; i <= n; i++) b[i]++;
memset(t, 0, sizeof(t));
for (int i = n; i > 0; i--) tmp = b[i], b[i] = Ctot(b[i]), plusnm(tmp);
for (int i = 1; i <= n; i++) c[i] = a[i] + b[i];
for (int i = n; i > 0; i--) {
c[i - 1] += c[i] / (n - i + 1);
c[i] %= n - i + 1;
}
memset(t, 0, sizeof(t));
for (int i = 1; i <= n; i++) plusnm(i);
for (int i = 1; i <= n; i++) {
ans[i] = Cans(c[i] + 1);
decnm(ans[i]);
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i] - 1);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, q, v[N], mx, f[N], l[N], r[N], cum[N], res[N];
int main(int argc, char **argv) {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; ++i) {
scanf("%d", v + i);
if (v[i] < N) {
++f[v[i]];
mx = max(mx, v[i]);
}
}
for (int i = 0; i < q; ++i) scanf("%d%d", l + i, r + i);
for (int i = 1; i <= mx; ++i)
if (f[i] >= i) {
for (int j = 0; j < n; ++j) cum[j + 1] = cum[j] + (v[j] == i);
for (int j = 0; j < q; ++j) res[j] += cum[r[j]] - cum[l[j] - 1] == i;
}
for (int i = 0; i < q; ++i) printf("%d\n", res[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename IntType>
void read(IntType& val) {
val = 0;
int c;
bool inv = false;
while (!isdigit(c = getchar()))
if (c == '-') inv = true;
do {
val = (val << 1) + (val << 3) + c - '0';
} while (isdigit(c = getchar()));
if (inv) val = -val;
}
template <>
void read<string>(string& str) {
str.clear();
int c;
while (iscntrl(c = getchar()) || c == ' ' || c == '\t')
;
do {
str.push_back(c);
} while (!(iscntrl(c = getchar()) || c == ' ' || c == '\t'));
}
const int MaxN = 50 + 10;
int n;
string str;
int a[MaxN][MaxN];
int l[MaxN][MaxN], c[MaxN][MaxN];
int dp[MaxN][MaxN][MaxN][MaxN];
int dfs(int xs, int ys, int xt, int yt) {
;
if (xs > xt || ys > yt) return 0;
if (dp[xs][ys][xt][yt] >= 0) return dp[xs][ys][xt][yt];
dp[xs][ys][xt][yt] = max(xt - xs + 1, yt - ys + 1);
for (int i = (xs); i <= (xt); ++i)
if (l[i][yt] - l[i][ys - 1] == 0)
dp[xs][ys][xt][yt] = min(dp[xs][ys][xt][yt],
dfs(xs, ys, i - 1, yt) + dfs(i + 1, ys, xt, yt));
for (int i = (ys); i <= (yt); ++i)
if (c[xt][i] - c[xs - 1][i] == 0)
dp[xs][ys][xt][yt] = min(dp[xs][ys][xt][yt],
dfs(xs, ys, xt, i - 1) + dfs(xs, i + 1, xt, yt));
return dp[xs][ys][xt][yt];
}
int main(int argc, char* argv[]) {
read(n);
for (int i = (1); i <= (n); ++i) {
read(str);
for (int j = (1); j <= (n); ++j) {
a[i][j] = (str[j - 1] == '#');
l[i][j] = l[i][j - 1] + a[i][j];
c[i][j] = c[i - 1][j] + a[i][j];
}
};
;
memset(dp, -1, sizeof(dp));
printf("%d\n", dfs(1, 1, n, n));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int r, h, c;
int main() {
cin >> r >> h;
c += 2 * (h / r);
h %= r;
double h2, r2;
h2 = h;
r2 = r;
if (h2 >= r2 / 2) {
c += 2;
if (4 * h2 * h2 >= 3 * r2 * r2) c++;
} else {
c += 1;
}
cout << c << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<pair<int, int>, pair<int, int> > > a;
int res[100005];
int c[100005];
multiset<pair<pair<int, int>, int> > s;
multiset<pair<pair<int, int>, int> >::iterator it;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d%d", &l, &r);
a.push_back(pair<pair<int, int>, pair<int, int> >(pair<int, int>(l, -r),
pair<int, int>(1, i)));
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int first, second, z;
scanf("%d%d%d", &first, &second, &z);
c[i] = z;
a.push_back(pair<pair<int, int>, pair<int, int> >(
pair<int, int>(first, -second), pair<int, int>(0, i)));
}
sort(a.begin(), a.end());
for (int i = 0; i < (int)a.size(); i++) {
int l = a[i].first.first, r = -a[i].first.second, type = a[i].second.first,
pos = a[i].second.second;
if (type == 0)
s.insert(pair<pair<int, int>, int>(pair<int, int>(r, c[pos]), pos));
else {
it = s.lower_bound(pair<pair<int, int>, int>(pair<int, int>(r, -1), -1));
if (it == s.end()) {
printf("NO\n");
return 0;
}
pair<pair<int, int>, int> val = (*it);
s.erase(it);
int first = val.first.first, second = val.first.second, z = val.second;
res[pos] = z;
if (second > 1)
s.insert(
pair<pair<int, int>, int>(pair<int, int>(first, second - 1), z));
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", res[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {-1, 1, 0, 0, -1, -1, 1, 1};
int dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};
inline void prep() {
cin.tie(0);
cin.sync_with_stdio(0);
}
int n, m;
string grid[101];
vector<pair<int, pair<int, int>>> res;
bool isvalid(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && grid[x][y] != '.');
}
void expand(int i, int j) {
int x = 0;
bool ok = false;
while (!ok) {
x++;
for (int k = 0; k < 4; k++)
if (!isvalid(i + x * dx[k], j + x * dy[k])) ok = true;
if (!ok)
for (int k = 0; k < 4; k++) grid[i + x * dx[k]][j + x * dy[k]] = 'a';
}
if (x != 1) {
grid[i][j] = 'a';
res.push_back({x - 1, {i + 1, j + 1}});
}
}
int main() {
prep();
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> grid[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (grid[i][j] == '*' || grid[i][j] == 'a') expand(i, j);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (grid[i][j] == '*') {
cout << "-1\n";
return 0;
}
cout << res.size() << "\n";
for (auto it : res)
cout << it.second.first << " " << it.second.second << " " << it.first
<< "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[100005];
char ch[15][5];
int min(int x, int y) { return x < y ? x : y; }
int main() {
cin >> s;
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> ch[i];
int len = (int)strlen(s);
int ans = 0;
for (int i = 0; i < n; i++) {
int k = 0;
while (k < len) {
int num1 = 0;
int num2 = 0;
bool flag = false;
while (k < len && (s[k] == ch[i][0] || s[k] == ch[i][1])) {
flag = true;
if (s[k] == ch[i][0])
num1++;
else
num2++;
k++;
}
ans += min(num1, num2);
if (!flag) k++;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
template <typename T, size_t N>
struct MakeVector {
template <typename... Args,
typename R = std::vector<decltype(MakeVector<T, N - 1>::make_vector(
std::declval<Args>()...))>>
static R make_vector(std::size_t first, Args... sizes) {
auto inner = MakeVector<T, N - 1>::make_vector(sizes...);
return R(first, inner);
}
};
template <typename T>
struct MakeVector<T, 1> {
template <typename R = std::vector<T>>
static R make_vector(std::size_t size, const T& value) {
return R(size, value);
}
};
template <typename T, typename... Args>
auto make_vector(Args... args)
-> decltype(MakeVector<T, sizeof...(Args) - 1>::make_vector(args...)) {
return MakeVector<T, sizeof...(Args) - 1>::make_vector(args...);
}
template <typename T>
class IntegerIterator
: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
public:
explicit IntegerIterator(int value) : value(value) {}
IntegerIterator& operator++() {
++value;
return *this;
}
IntegerIterator operator++(int) {
IntegerIterator copy = *this;
++value;
return copy;
}
IntegerIterator& operator--() {
--value;
return *this;
}
IntegerIterator operator--(int) {
IntegerIterator copy = *this;
--value;
return copy;
}
T operator*() const { return value; }
bool operator==(IntegerIterator rhs) { return value == rhs.value; }
bool operator!=(IntegerIterator rhs) { return !(*this == rhs); }
private:
T value;
};
template <typename T>
class IntegerRange {
public:
IntegerRange(T begin, T end) : begin_(begin), end_(end) {}
IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }
private:
T begin_;
T end_;
};
template <typename T>
class ReversedIntegerRange {
public:
ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) {}
std::reverse_iterator<IntegerIterator<T>> begin() const {
return std::reverse_iterator<IntegerIterator<T>>(
IntegerIterator<T>(begin_));
}
std::reverse_iterator<IntegerIterator<T>> end() const {
return std::reverse_iterator<IntegerIterator<T>>(IntegerIterator<T>(end_));
}
private:
T begin_;
T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
;
return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
;
return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
;
return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
;
return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
;
return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
;
return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
;
return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
;
return ReversedIntegerRange<T>(from + 1, to);
}
using namespace std;
class TaskD {
public:
void solve(std::istream& in, std::ostream& out) {
int n, k, s;
in >> n >> k >> s;
s = min(n * n, s);
int INF = 1000000000;
auto dp = make_vector<int>(2, k + 1, s + 1, INF);
vector<int> q(n);
for (int i : range(n)) {
in >> q[i];
}
dp[0][0][0] = 0;
for (int prefix = 0; prefix < n; ++prefix) {
for (int got = 0; got <= k && got <= prefix; ++got) {
for (int used = 0; used <= s; ++used) {
if (dp[prefix % 2][got][used] == INF) continue;
dp[(prefix + 1) % 2][got][used] =
min(dp[(prefix + 1) % 2][got][used], dp[prefix % 2][got][used]);
if (got + 1 <= k && used + prefix - got <= s) {
dp[(prefix + 1) % 2][got + 1][used + prefix - got] =
min(dp[(prefix + 1) % 2][got + 1][used + prefix - got],
dp[prefix % 2][got][used] + q[prefix]);
}
}
}
dp[(prefix) % 2] = make_vector<int>(k + 1, s + 1, INF);
}
int ans = INF;
for (int z = 0; z <= s; ++z) {
ans = min(ans, dp[n % 2][k][z]);
}
out << ans << "\n";
}
};
int main() {
std::ios_base::sync_with_stdio(false);
TaskD solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
in.tie(0);
out << std::fixed;
out.precision(20);
solver.solve(in, out);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string a, b;
cin >> a >> b;
vector<int> ans1, ans2;
a += '0', b += '0';
for (int i = 1; i <= n; i++) {
if (a[i] != a[i - 1]) ans1.push_back(i);
if (b[i] != b[i - 1]) ans2.push_back(i);
}
ans1.insert(ans1.end(), ans2.rbegin(), ans2.rend());
cout << ans1.size() << " ";
for (auto i : ans1) cout << i << " ";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N1 = 1000010;
const long long N2 = 2000010;
const long long mod1 = 1e2 + 7;
const long long mod2 = 1e9 + 7;
long long a1[N1], p, q, r;
long long n;
long long leftMin[N1];
long long rightMin[N1];
long long leftMax[N1];
long long rightMax[N1];
long long maxProduct() {
long long max_product = -3e18;
leftMax[0] = a1[0];
leftMin[0] = a1[0];
for (int i = 1; i < n; i++) {
leftMax[i] = max(leftMax[i - 1], a1[i]);
leftMin[i] = min(leftMin[i - 1], a1[i]);
}
rightMax[n - 1] = a1[n - 1];
rightMin[n - 1] = a1[n - 1];
for (int j = n - 2; j >= 0; j--) {
rightMax[j] = max(rightMax[j + 1], a1[j]);
rightMin[j] = min(rightMin[j + 1], a1[j]);
}
for (int i = 0; i < n; i++) {
long long max1 = max(q * a1[i] + p * leftMax[i] + r * rightMax[i],
q * a1[i] + p * leftMin[i] + r * rightMin[i]);
long long max2 = max(q * a1[i] + p * leftMax[i] + r * rightMin[i],
q * a1[i] + p * leftMin[i] + r * rightMax[i]);
max_product = max(max_product, max(max1, max2));
}
return max_product;
}
int main() {
cin >> n >> p >> q >> r;
;
for (int i = 0; i < n; i++) cin >> a1[i];
;
long long x = maxProduct();
cout << x << "\n";
;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
const double eps = 1e-8;
const double pi = acos(-1.0);
void file() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
const int maxn = 105;
int a, b;
int op[2];
int judge(int c, int d) {
int res;
printf("? %d %d\n", c, d);
fflush(stdout);
scanf("%d", &res);
return res;
}
namespace BakuretsuMahou {
void Explosion() {
int flag = ((judge(a, b) < 0) ? 0 : 1);
for (int i = 30; i >= 1; i--) {
int x = judge(a ^ (1 << (i - 1)), b);
int y = judge(a, b ^ (1 << (i - 1)));
if (x == y) {
if (flag)
a ^= (1 << (i - 1));
else
b ^= (1 << (i - 1));
flag = (x == 1);
} else if (x == -1 && y == 1)
a ^= (1 << (i - 1)), b ^= (1 << (i - 1));
}
printf("! %d %d\n", a, b);
}
} // namespace BakuretsuMahou
int main() {
BakuretsuMahou::Explosion();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct UF {
int n;
vector<int> root, r;
vector<pair<int &, int>> ops;
UF(int n) : root(n + 1), r(n + 1, 1) {
for (int i = 1; i <= n; ++i) root[i] = i;
}
int fs(int u) {
while (root[u] != u) u = root[u];
return u;
}
void modify(int &a, int b) {
ops.emplace_back(a, a);
a = b;
}
bool js(int u, int v) {
u = fs(u), v = fs(v);
if (u == v) return false;
if (r[u] < r[v]) swap(u, v);
modify(root[v], u);
modify(r[u], r[u] + r[v]);
return true;
}
void rb(int bot) {
while (ops.size() > bot) {
ops.back().first = ops.back().second;
ops.pop_back();
}
}
};
const int N = 5e5 + 7;
struct query {
int u, v, w, id;
query(int u, int v, int w, int id) : u(u), v(v), w(w), id(id) {}
bool operator<(const query &o) const {
if (w != o.w) return w < o.w;
return id < o.id;
}
};
int n, m;
vector<query> qe;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v, w;
cin >> u >> v >> w;
qe.emplace_back(query(u, v, w, N));
}
int q;
cin >> q;
for (int j = 1; j <= q; ++j) {
int k;
cin >> k;
for (int i = 1; i <= k; ++i) {
int p;
cin >> p;
qe.emplace_back(query(qe[p - 1].u, qe[p - 1].v, qe[p - 1].w, j));
}
}
sort(qe.begin(), qe.end());
UF uf(n);
vector<int> ans(q + 1, 1);
for (int i = 0, j; i < qe.size(); i = j) {
j = i;
int cq = qe[j].id;
if (cq == N) {
do {
uf.js(qe[j].u, qe[j].v);
++j;
} while (j < qe.size() && qe[j].w == qe[j - 1].w &&
qe[j].id == qe[j - 1].id);
} else {
int sback = uf.ops.size();
bool flag = true;
do {
if (!flag) {
++j;
continue;
}
if (!uf.js(qe[j].u, qe[j].v)) {
ans[qe[j].id] &= 0;
flag = false;
++j;
continue;
}
++j;
} while (j < qe.size() && qe[j].w == qe[j - 1].w &&
qe[j].id == qe[j - 1].id);
uf.rb(sback);
}
}
for (int i = 1; i <= q; ++i)
if (ans[i])
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
long long int n, m;
while (t--) {
cin >> n >> m;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
long long int sum = 0;
for (int i = 1; i < n; i++) {
sum += arr[i];
}
if (sum + arr[0] >= m) {
cout << m << "\n";
} else {
cout << sum + arr[0] << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
long long x, n, m;
while (t--) {
cin >> x;
for (n = 2; n < 100000; n++) {
m = n / sqrt(n * n - x);
if (n > 0 && m > 0 && n * n - (n / m) * (n / m) == x) {
cout << n << " " << m << '\n';
break;
}
}
if (n == 100000) cout << "-1\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {+1, -1, +0, +0};
int dy[] = {+0, +0, +1, -1};
int KingX[] = {+0, +0, +1, -1, -1, +1, -1, +1};
int KingY[] = {-1, +1, +0, +0, +1, +1, -1, -1};
int KnightX[] = {-2, -2, -1, -1, 1, 1, 2, 2};
int KnightY[] = {-1, 1, -2, 2, -2, 2, -1, 1};
template <class T>
inline T bigmod(T b, T p, T M) {
T ret = 1;
for (; p > 0; p >>= 1) {
if (p & 1) ret = (ret * b) % M;
b = (b * b) % M;
}
return (T)ret;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return a * b / gcd<T>(a, b);
}
template <class T>
inline T power(T b, T p) {
unsigned long long int x = 1;
while (p--) x *= b;
return x;
}
const long long int mod = 1000000007;
struct point {
int x, y;
point() {}
point(int x, int y) {
this->x = x;
this->y = y;
}
void input() {
int xx, yy;
scanf("%d %d", &xx, &yy);
x = xx;
y = yy;
}
};
long long int triArea_includesSign(point a, point b, point c) {
long long int ret = 0;
ret += (a.x * b.y) - (b.x * a.y);
ret += (b.x * c.y) - (c.x * b.y);
ret += (c.x * a.y) - (a.x * c.y);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
int n;
scanf("%d", &n);
point arr[n + 5];
for (int i = 0; i < n + 1; i++) {
arr[i].input();
}
int cnt = 0;
for (int i = 1; i < n; i++) {
long long int area = triArea_includesSign(arr[i - 1], arr[i], arr[i + 1]);
if (area > 0) cnt++;
}
printf("%d\n", cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
const int MAXN = 1e6 + 5;
pair<int, int> arr[MAXN];
int a[MAXN];
int b[MAXN];
struct tmp {
int mn, mx;
bool good;
} seg[4 * MAXN];
set<int> s1[MAXN];
set<int> s2[MAXN];
map<pair<int, int>, int> m1;
int N = 1e6;
bool check(int x) {
for (int i = 1; i <= N; i++) {
a[i] = 1e9;
b[i] = -1;
}
for (int i = 1; i <= x; i++) {
if (arr[i].first % 2 == 0) {
b[(arr[i].first) / 2] = max(b[(arr[i].first) / 2], arr[i].second);
} else {
a[(arr[i].first + 1) / 2] = min(a[(arr[i].first + 1) / 2], arr[i].second);
}
}
a[0] = 1e9;
for (int i = 1; i <= N; i++) {
if (a[i] == 1e9) {
a[i] = a[i - 1];
continue;
}
a[i] = min(a[i - 1], a[i]);
}
b[N + 1] = 0;
for (int i = N; i >= 1; i--) {
if (b[i] == -1) {
b[i] = b[i + 1];
continue;
}
b[i] = max(b[i + 1], b[i]);
}
for (int i = 1; i < N; i++) {
if (a[i] <= b[i] && b[i] != 1e9 && a[i] != 0 && a[i] != 1e9 && b[i] != 0) {
return false;
}
}
return true;
}
void build(int curr, int l, int r) {
if (l == r) {
seg[curr].mn = 1e9;
seg[curr].mx = 0;
seg[curr].good = true;
return;
}
int mid = (l + r) / 2;
build(2 * curr, l, mid);
build(2 * curr + 1, mid + 1, r);
seg[curr].mn = min(seg[2 * curr].mn, seg[2 * curr + 1].mn);
seg[curr].mx = max(seg[2 * curr].mx, seg[2 * curr + 1].mx);
seg[curr].good = seg[2 * curr].good && seg[2 * curr + 1].good;
}
void update(int curr, int l, int r, int pos) {
if (l == r) {
if (!s1[pos].size()) {
seg[curr].mn = 1e9;
} else {
seg[curr].mn = *(s1[pos].begin());
}
if (!s2[pos].size()) {
seg[curr].mx = 0;
} else {
seg[curr].mx = *(s2[pos].rbegin());
}
seg[curr].good = seg[curr].mn > seg[curr].mx;
return;
}
int mid = (l + r) / 2;
if (pos <= mid) {
update(2 * curr, l, mid, pos);
} else {
update(2 * curr + 1, mid + 1, r, pos);
}
seg[curr].good = seg[2 * curr].mn > seg[2 * curr + 1].mx;
seg[curr].mn = min(seg[2 * curr].mn, seg[2 * curr + 1].mn);
seg[curr].mx = max(seg[2 * curr].mx, seg[2 * curr + 1].mx);
seg[curr].good &= (seg[2 * curr].good && seg[2 * curr + 1].good);
}
int main() {
cin >> n >> m >> q;
build(1, 1, N);
while (q--) {
int x, y;
cin >> x >> y;
if (m1[make_pair(x, y)]) {
m1[make_pair(x, y)]--;
int pos = (x + 1) / 2;
int par = x % 2;
if (!par) {
s2[pos].erase(y);
} else {
s1[pos].erase(y);
}
} else {
m1[make_pair(x, y)]++;
int pos = (x + 1) / 2;
int par = x % 2;
if (!par) {
s2[pos].insert(y);
} else {
s1[pos].insert(y);
}
}
update(1, 1, N, (x + 1) / 2);
if (seg[1].good) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = (int)2e9 + 7;
const long long LINF = (long long)4e18;
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) c = getchar();
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
string nextString(bool flag = false) {
char ch;
string ans = "";
do {
ch = getchar();
} while (ch <= ' ');
while (1) {
ans += ch;
ch = getchar();
if (!flag) {
if (ch <= ' ') break;
} else {
if (ch < ' ') break;
}
}
return ans;
}
char nextChar() {
char ch;
do {
ch = getchar();
} while (ch <= ' ');
return ch;
}
void read(string& s) { s = nextString(); }
void read(char& c) { c = nextChar(); }
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T, typename... R>
void read(T& a, R&... r) {
read(a);
read(r...);
}
int n, c;
const int N = 2e5 + 10;
int _next[N], cnt[N];
bool ok(int add) {
int cur = c;
int coin = _next[c];
while (coin > add) {
cur -= min(cnt[coin], cur / coin) * coin;
coin = min(_next[cur], _next[coin - 1]);
}
if (cur >= add) cur -= add;
while (cur > 0 && coin > 0) {
cur -= min(cnt[coin], cur / coin) * coin;
coin = min(_next[cur], _next[coin - 1]);
}
return cur == 0;
}
void ex(int x) {
cout << x;
exit(0);
}
int32_t main() {
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
read(c, n);
for (int i = 0; i < n; ++i) {
int x;
read(x);
cnt[x]++;
}
_next[0] = 0;
for (int i = 1; i <= c; ++i) {
_next[i] = _next[i - 1];
if (cnt[i]) _next[i] = i;
}
for (int i = 1; i <= c; ++i) {
if (!ok(i)) {
ex(i);
}
}
cout << "Greed is good\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, m;
cin >> n >> m;
vector<int> y1_map(20001), y2_map(20001);
for (int i = 0; i < n; i++) {
int key;
cin >> key;
key += 10000;
y1_map[key]++;
}
for (int i = 0; i < m; i++) {
int key;
cin >> key;
key += 10000;
y2_map[key]++;
}
vector<int> y1, y2;
for (int i = 0; i <= 20000; i++) {
if (y1_map[i]) {
y1.push_back(i);
}
if (y2_map[i]) {
y2.push_back(i);
}
}
vector<int> sum_map(40001);
for (int num1 : y1) {
for (int num2 : y2) {
int sum = num1 + num2;
sum_map[sum] += y1_map[num1] + y2_map[num2];
}
}
vector<int> sum;
for (int i = 0; i <= 40000; i++) {
if (sum_map[i]) {
sum.push_back(i);
}
}
int result = 0;
for (int i = 0; i < sum.size(); i++) {
int s1 = sum[i];
for (int j = i; j < sum.size(); j++) {
int s2 = sum[j];
int candidate = sum_map[s1] + sum_map[s2];
if (candidate <= result) {
continue;
}
for (int num1 : y1) {
if (s1 - num1 < 0) {
break;
}
if (y2_map[s1 - num1] && y2_map[s2 - num1]) {
candidate -= y1_map[num1];
}
}
if (candidate <= result) {
continue;
}
for (int num2 : y2) {
if (s1 - num2 < 0) {
break;
}
if (y1_map[s1 - num2] && y1_map[s2 - num2]) {
candidate -= y2_map[num2];
}
}
result = max(result, candidate);
}
}
cout << result << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
long long a[200010];
long long num[200010];
struct SEG_Tree {
struct SEG {
int l;
int r;
long long max;
long long lazy;
} t[800010];
void push_up(int cur) { t[cur].max = t[((cur) << 1 | 1)].max; }
void push_down(int cur) {
t[((cur) << 1)].max += t[cur].lazy;
t[((cur) << 1)].lazy += t[cur].lazy;
t[((cur) << 1 | 1)].max += t[cur].lazy;
t[((cur) << 1 | 1)].lazy += t[cur].lazy;
t[cur].lazy = 0;
}
void modify(int cur, int l, int r, long long c) {
if (t[cur].l > r || t[cur].r < l) return;
if (t[cur].l >= l && t[cur].r <= r) {
t[cur].max += c;
t[cur].lazy += c;
return;
}
push_down(cur);
modify(((cur) << 1), l, r, c);
modify(((cur) << 1 | 1), l, r, c);
push_up(cur);
}
int query(int cur, long long lim) {
if (t[cur].l == t[cur].r) return t[cur].l;
push_down(cur);
return (t[((cur) << 1)].max >= lim) ? query(((cur) << 1), lim)
: query(((cur) << 1 | 1), lim);
}
long long getnum(int cur, int pos) {
if (t[cur].l == t[cur].r) return t[cur].max;
push_down(cur);
return (pos <= t[((cur) << 1)].r) ? getnum(((cur) << 1), pos)
: getnum(((cur) << 1 | 1), pos);
}
void build(int cur, int l, int r) {
t[cur].l = l;
t[cur].r = r;
if (t[cur].l == t[cur].r) {
t[cur].max = a[l];
return;
}
int mid = (l + r) >> 1;
build(((cur) << 1), l, mid);
build(((cur) << 1 | 1), mid + 1, r);
push_up(cur);
}
} t;
signed main() {
int n = inp();
int q = inp();
for (int i = 1; i <= n; i++) {
num[i] = inp();
a[i] = a[i - 1] + num[i];
}
t.build(1, 1, n);
while (q--) {
int x = inp();
int c = inp();
t.modify(1, x, n, c - num[x]);
num[x] = c;
int cur = 1;
if (t.getnum(1, 1) == 0) {
printf("1\n");
continue;
}
while (true) {
long long num = t.getnum(1, cur);
if (t.getnum(1, n) < (num << 1)) {
printf("-1\n");
break;
}
cur = t.query(1, num << 1);
if (t.getnum(1, cur) == (t.getnum(1, cur - 1) << 1)) {
printf("%d\n", cur);
break;
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long i, k, n, t = 0, a[1000009];
int main() {
string s;
cin >> k >> s;
a[0] = 1;
for (i = 0; i < s.length(); i++) {
if (s[i] == '1') t++;
if (t >= k) n += a[t - k];
a[t]++;
}
cout << n;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long int dist[1000000];
long long int ocurre[1000000];
long long int absolut(long long int x) {
if (x < 0) return -x;
return x;
}
void simular(int pos, int d) {
long long int sol = 0;
for (;;) {
ocurre[pos]--;
if (d == 1 and pos == n)
d = -1;
else if (d == -1 and pos == 1)
d = 1;
if (ocurre[pos + d] == 0) break;
sol += absolut(dist[pos + d] - dist[pos]);
pos += d;
}
cout << sol << endl;
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> dist[i];
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int ind;
cin >> ind;
ocurre[ind]++;
}
if (n == 2 and ocurre[1] >= ocurre[2]) simular(1, 1);
if (n == 2) simular(2, -1);
if (ocurre[2] % 2) {
if (2 * ocurre[1] > ocurre[2]) simular(1, 1);
simular(2, 1);
}
if (ocurre[n - 1] % 2) {
if (2 * ocurre[n] > ocurre[n - 1]) simular(n, -1);
simular(n - 1, -1);
}
if (ocurre[2] % 2 == 0 and 2 * ocurre[1] > ocurre[2]) simular(1, 1);
if (ocurre[2] % 2 == 0 and 2 * ocurre[1] < ocurre[2]) simular(2, 1);
if (ocurre[n - 1] % 2 == 0 and 2 * ocurre[n] > ocurre[n - 1]) simular(n, -1);
if (ocurre[n - 1] % 2 == 0 and 2 * ocurre[n] < ocurre[n - 1])
simular(n - 1, -1);
for (int i = 2; i < n - 1; i++) {
if (ocurre[i] > ocurre[i + 1]) simular(i, -1);
if (ocurre[i] < ocurre[i + 1]) simular(i + 1, 1);
}
for (int i = 2; i < n; i++) {
if (dist[i + 1] - dist[i] != dist[2] - dist[1]) {
cout << -1 << endl;
exit(0);
}
}
if (ocurre[1])
simular(1, 1);
else
simular(2, 1);
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.