solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
string s[1006];
map<string, bool> m;
int main() {
int a, b, c;
cin >> a >> b >> c;
int aa, bb, cc;
cin >> aa >> bb >> cc;
if (a > aa)
if (b < bb)
while (a > (aa + 1) && b < bb) {
a -= 2;
b++;
}
if (c < cc)
while (a > (aa + 1) && c < cc) {
a -= 2;
c++;
}
if (b > bb)
if (c < cc)
while (b > (bb + 1) && c < cc) {
b -= 2;
c++;
}
if (a < aa)
while (b > (bb + 1) && a < aa) {
b -= 2;
a++;
}
if (c > cc)
if (a < aa)
while (c > (cc + 1) && a < aa) {
c -= 2;
a++;
}
if (b < bb)
while (c > (cc + 1) && b < bb) {
c -= 2;
b++;
}
if (a >= aa && b >= bb && c >= cc) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30010, AS = 28;
int cnt[AS];
int memo[AS][AS][N];
int vis[AS][AS][N], tc;
int excess;
int solve(int idx, int last, int rem) {
int &ret = memo[idx][last][rem];
if (vis[idx][last][rem] == tc) return ret;
vis[idx][last][rem] = tc;
if (idx == AS - 1) {
if (cnt[last] < rem) return ret = 1e9;
return ret = max(cnt[last] - rem - excess, 0) * rem;
}
ret = min(solve(idx + 1, idx, rem), solve(idx + 1, last, rem));
if (cnt[idx] < rem) ret = min(ret, solve(idx + 1, last, rem - cnt[idx]));
return ret;
}
int n, m, k;
char str[200100];
int main() {
int T;
scanf("%d", &T);
while (T--) {
tc++;
memset(cnt, 0, sizeof cnt);
scanf("%d", &n), scanf("%d", &m), scanf("%d", &k);
scanf(" %s", str);
for (int i = 0; i < k; ++i) ++cnt[str[i] - 'A'];
excess = k - n - m;
printf("%d\n", solve(0, 26, n));
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<string, string> m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
long long n;
cin >> n;
long long c[n], s[n];
for (long long i = 0; i < n; i++) cin >> s[i];
for (long long i = 0; i < n; i++) cin >> c[i];
long long ans = 100000000000;
for (long long i = 1; i < n - 1; i++) {
long long temp = c[i];
long long cost = 100000000000;
for (long long j = 0; j < i; j++) {
if (s[j] < s[i]) {
cost = min(cost, c[j]);
}
}
temp += cost;
cost = 100000000000;
for (long long j = i + 1; j < n; j++) {
if (s[j] > s[i]) {
cost = min(cost, c[j]);
}
}
temp += cost;
ans = min(ans, temp);
}
if (ans >= 100000000000)
cout << -1 << "\n";
else
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int n;
long long l = 0;
long long a[300010];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%lld", a + i);
}
long long ans = 0;
long long onecnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
onecnt++;
continue;
}
if (a[i] >= 2 * onecnt) {
ans += onecnt;
a[i] -= 2 * onecnt;
onecnt = 0;
onecnt = a[i] % 3;
ans += a[i] / 3;
} else {
ans += a[i] / 2;
onecnt -= a[i] / 2;
onecnt += a[i] % 2;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s[6], ans = 0;
ios::sync_with_stdio(false);
for (int i = 0; i < 6; ++i) cin >> s[i];
bool did = true;
while (did) {
did = false;
for (int i = 0; i < 6; ++i) {
if (s[(i + 5) % 6] > 1 && s[(i + 1) % 6] > 1) {
ans += s[i] * 2 + 1;
++s[i];
--s[(i + 5) % 6];
--s[(i + 1) % 6];
did = true;
}
}
}
for (int i = 0; i < 6; ++i) {
if (s[i] > 1) {
ans += s[i] * 4 + 2;
goto out;
}
}
ans += 6;
out:
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
char s[N], t[N];
int n;
long long ans, res;
void dfs(int x, int op) {
if (!isdigit(s[x + 1] + op)) dfs(x + 1, -op);
if (ans-- > 0) s[x] += op, s[x + 1] += op, cout << x + 1 << ' ' << op << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s >> t;
for (int i = 0; i < n; ++i) ans += abs(res = s[i] - t[i] - res);
if (res) {
cout << -1 << '\n';
return 0;
}
cout << ans << '\n';
ans = min(ans, 100000ll);
for (int i = 0; i < n; ++i)
while (ans > 0 && s[i] != t[i]) dfs(i, s[i] > t[i] ? -1 : 1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, a, b, c, d;
cin >> x >> a >> b >> c >> d;
long long ans = 0;
for (int i = 1; i <= 10000000; i++) {
if (i * c > x) {
break;
}
ans = max(ans, i * a + ((x - i * c) / d) * b);
if (i * d <= x) {
ans = max(ans, i * b + ((x - i * d) / c) * a);
}
}
ans = max(ans, x / c * a);
ans = max(ans, x / d * b);
cout << ans << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
int n;
scanf("%d", &n);
int temp[4];
vector<int> V;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
V.push_back(a);
}
sort(V.begin(), V.end());
if (n == 0) {
cout << "YES" << endl;
printf("%d\n", 1);
printf("%d\n", 1);
printf("%d\n", 3);
printf("%d\n", 3);
} else if (n == 1) {
int x4 = 3 * V[0];
for (int i = V[0]; i < 3001; i++) {
int x3 = 4 * V[0] - i;
int x2 = i;
int x1 = V[0];
if (x1 <= x2 && x2 <= x3 && x3 <= x4) {
cout << "YES" << endl;
printf("%d\n", x2);
printf("%d\n", x3);
printf("%d\n", x4);
return 0;
}
}
cout << "NO" << endl;
} else if (n == 4) {
int a = V[0] + V[1] + V[2] + V[3];
int b = V[1] + V[2];
int c = V[3] - V[0];
if (a == 4 * c && a == 2 * b && b == 2 * c) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else if (n == 2) {
for (int i = 1; i < 1501; i++)
for (int j = 1; j < 1501; j++) {
temp[0] = i;
temp[1] = j;
temp[2] = V[0];
temp[3] = V[1];
sort(temp, temp + 4);
int a = temp[0] + temp[1] + temp[2] + temp[3];
int b = temp[1] + temp[2];
int c = temp[3] - temp[0];
if (a == 4 * c && a == 2 * b && b == 2 * c) {
cout << "YES" << endl;
printf("%d\n", i);
printf("%d\n", j);
return 0;
}
}
cout << "NO" << endl;
} else if (n == 3) {
for (int i = 1; i < 1501; i++) {
temp[0] = V[2];
temp[1] = i;
temp[2] = V[0];
temp[3] = V[1];
sort(temp, temp + 4);
int a = temp[0] + temp[1] + temp[2] + temp[3];
int b = temp[1] + temp[2];
int c = temp[3] - temp[0];
if (a == 4 * c && a == 2 * b && b == 2 * c) {
cout << "YES" << endl;
printf("%d\n", i);
return 0;
}
}
cout << "NO" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char ans[505][505];
int main() {
vector<pair<int, int> > a;
int i, j, k;
int x, y;
int mx = 0;
for (i = 0; i < 3; i++) {
scanf("%d%d", &x, &y);
a.push_back({x, y});
mx = max({mx, x, y});
}
int d = 0;
int l;
for (i = 0; i < 3; i++) {
if (a[i].first == mx || a[i].second == mx) {
for (j = 0; j < min(a[i].first, a[i].second); j++, d++) {
for (k = 0; k < mx; k++) {
ans[d][k] = (char)(i + 'A');
}
}
l = mx - min(a[i].first, a[i].second);
a[i].first = 0;
}
}
bool ac = true;
for (i = 0; i < 3; i++) {
if (a[i].first != 0) {
ac = false;
break;
}
}
if (d != mx) {
ac = false;
}
if (ac) {
printf("%d\n", mx);
for (i = 0; i < mx; i++) {
for (j = 0; j < mx; j++) {
printf("%c", ans[i][j]);
}
printf("\n");
}
return 0;
}
for (i = 0; i < 2; i++) {
for (j = i + 1; j < 3; j++) {
if (a[i].first != 0 && a[j].first != 0) {
if (a[i].first + a[j].first == mx && a[j].second == l) {
printf("%d\n", mx);
for (x = 0; x < d; x++) {
for (y = 0; y < mx; y++) {
printf("%c", ans[x][y]);
}
printf("\n");
}
for (k = 0; k < l; k++) {
for (x = 0; x < a[i].first; x++) {
printf("%c", (char)(i + 'A'));
}
for (x = 0; x < a[j].first; x++) {
printf("%c", (char)(j + 'A'));
}
printf("\n");
}
return 0;
}
if (a[i].second + a[j].first == mx && a[j].second == l) {
printf("%d\n", mx);
for (int dx = 0; dx < d; dx++) {
for (int dy = 0; dy < mx; dy++) {
printf("%c", ans[dx][dy]);
}
printf("\n");
}
for (k = 0; k < l; k++) {
for (x = 0; x < a[i].second; x++) {
printf("%c", (char)(i + 'A'));
}
for (x = 0; x < a[j].first; x++) {
printf("%c", (char)(j + 'A'));
}
printf("\n");
}
return 0;
}
if (a[i].first + a[j].second == mx && a[j].first == l) {
printf("%d\n", mx);
for (int dx = 0; dx < d; dx++) {
for (int dy = 0; dy < mx; dy++) {
printf("%c", ans[dx][dy]);
}
printf("\n");
}
for (k = 0; k < l; k++) {
for (x = 0; x < a[i].first; x++) {
printf("%c", (char)(i + 'A'));
}
for (x = 0; x < a[j].second; x++) {
printf("%c", (char)(j + 'A'));
}
printf("\n");
}
return 0;
}
if (a[i].second + a[j].second == mx && a[j].first == l) {
printf("%d\n", mx);
for (int dx = 0; dx < d; dx++) {
for (int dy = 0; dy < mx; dy++) {
printf("%c", ans[dx][dy]);
}
printf("\n");
}
for (k = 0; k < l; k++) {
for (x = 0; x < a[i].second; x++) {
printf("%c", (char)(i + 'A'));
}
for (x = 0; x < a[j].second; x++) {
printf("%c", (char)(j + 'A'));
}
printf("\n");
}
return 0;
}
}
}
}
printf("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
map<int, int> mp;
for (int i : a) mp[i]++;
vector<pair<pair<int, int>, pair<int, int> > > v;
int itr = 0;
int pre_val = -1;
int from_val = -1;
int from_ind = -1;
for (auto p : mp) {
if (pre_val + 1 < p.first) {
if (pre_val >= 0) {
v.push_back({{from_ind, itr - 1}, {from_val, pre_val}});
}
from_val = p.first;
from_ind = itr;
} else if (pre_val + 1 == p.first && p.second == 1) {
v.push_back({{from_ind, itr}, {from_val, p.first}});
from_ind = itr;
from_val = p.first;
}
itr += p.second;
pre_val = p.first;
}
v.push_back({{from_ind, itr - 1}, {from_val, pre_val}});
int answer = 0;
int l = 0;
int r = 0;
int from = 0;
int to = 0;
for (auto p : v) {
if (answer < p.first.second - p.first.first + 1) {
answer = p.first.second - p.first.first + 1;
from = p.second.first;
to = p.second.second;
l = p.first.first;
r = p.second.second;
}
}
cout << answer << endl;
for (int i = from; i <= to; i++) {
mp[i]--;
cout << i << " ";
}
for (int i = to; i >= from; i--) {
while (mp[i]--) {
cout << i << " ";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char tmp[15][15][15];
bool vis[15][15][15];
int ans = 0, n, m, k;
void dfs(int a, int b, int c) {
if (a < 0 or a >= n) return;
if (b < 0 or b >= m) return;
if (c < 0 or c >= k) return;
if (tmp[a][b][c] == '#' || vis[a][b][c]) return;
vis[a][b][c] = true;
ans++;
dfs(a + 1, b, c);
dfs(a - 1, b, c);
dfs(a, b + 1, c);
dfs(a, b - 1, c);
dfs(a, b, c + 1);
dfs(a, b, c - 1);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> tmp[i][j];
}
}
int fx, fy;
cin >> fx >> fy;
fx--;
fy--;
dfs(0, fx, fy);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int nex[100005][26], ed[100005], d[100005];
int root, l;
struct cmp {
bool operator()(int a, int b) { return d[a] < d[b]; }
};
priority_queue<int, vector<int>, cmp> q[202020];
struct Trie {
int newnode() {
for (int i = 0; i < 26; i++) {
nex[l][i] = -1;
}
ed[l++] = 0;
return l - 1;
}
void init() {
l = 0;
root = newnode();
d[root] = 0;
}
void insert(char buff[]) {
int len = strlen(buff);
int now = root;
for (int i = 0; i < len; i++) {
if (nex[now][buff[i] - 'a'] == -1) {
nex[now][buff[i] - 'a'] = newnode();
d[nex[now][buff[i] - 'a']] = d[now] + 1;
}
now = nex[now][buff[i] - 'a'];
}
ed[now]++;
}
void dfs(int rt) {
if (rt == -1) return;
if (!q[rt].empty()) q[rt].pop();
for (int i = 0; i < 26; i++) {
int son = nex[rt][i];
dfs(son);
while (!q[son].empty()) {
q[rt].push(q[son].top());
q[son].pop();
}
}
if (rt != 0 && ed[rt] == 0 && !q[rt].empty()) {
ed[rt]++;
ed[q[rt].top()]--;
q[rt].pop();
}
if (ed[rt]) {
q[rt].push(rt);
}
}
} trie;
char str[100005];
int main() {
int n;
scanf("%d", &n);
trie.init();
for (int i = 1; i <= n; i++) {
scanf("%s", str);
trie.insert(str);
}
trie.dfs(0);
int ans = 0;
while (!q[0].empty()) {
ans += d[q[0].top()];
q[0].pop();
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int yr = 1, a = 0, arr[1001], n;
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) cin >> arr[i];
for (int i = 0; i < N; i++) {
if (arr[i] == yr) {
v.push_back(2000 + i + 1);
yr++;
a++;
}
}
int sz = v.size();
cout << a << endl;
for (int i = 0; i < sz; i++) {
cout << v[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool SBF(const pair<int, int>& a, const pair<int, int>& b) {
return a.first < b.first;
}
bool SBS(const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second;
}
const long double PI = 3.1415926535;
const int mod = 1e9 + 7;
long long int n, k;
long long int a[5][5], temp = 0;
void solve() {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) cin >> a[i][j];
}
int p[5];
long long int ans = 0;
for (int i = 0; i < 5; i++) p[i] = i;
do {
temp = 0;
temp += a[p[0]][p[1]] + a[p[2]][p[3]];
temp += a[p[1]][p[0]] + a[p[3]][p[2]];
temp += a[p[1]][p[2]] + a[p[3]][p[4]];
temp += a[p[2]][p[1]] + a[p[4]][p[3]];
temp += a[p[2]][p[3]];
temp += a[p[3]][p[2]];
temp += a[p[3]][p[4]];
temp += a[p[4]][p[3]];
if (temp > ans) {
ans = temp;
}
} while (next_permutation(p, p + 5));
cout << ans << "\n";
return;
}
int main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, m;
long long tree[maxn], ans[maxn];
vector<int> G[maxn], D[maxn], X[maxn];
void add(int x, int val) {
while (x <= n) {
tree[x] += val;
x = x + (x & -x);
}
}
long long sum(int x) {
long long ans = 0;
while (x) {
ans += tree[x];
x = x - (x & -x);
}
return ans;
}
void dfs(int x, int fa, int dep) {
for (int i = 0; i < D[x].size(); i++) {
add(min(D[x][i] + dep, n), X[x][i]);
}
ans[x] = sum(n) - sum(dep - 1);
for (int i = 0; i < G[x].size(); i++) {
if (G[x][i] == fa) continue;
dfs(G[x][i], x, dep + 1);
}
for (int i = 0; i < D[x].size(); i++) {
add(min(D[x][i] + dep, n), -X[x][i]);
}
}
int main() {
int x, y, z;
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
D[x].push_back(y);
X[x].push_back(z);
}
dfs(1, 0, 1);
for (int i = 1; i <= n; i++) {
printf("%lld ", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_K = 1e2 + 1, MAX_N = 1e3 + 1;
int n, m, k;
int p10[MAX_N];
int dp[2][MAX_K][MAX_N];
int dfs(int pos, int rem, bool ok) {
if (pos == n) {
if (ok) return 1;
return 0;
}
if (dp[ok][rem][pos] != -1) {
return dp[ok][rem][pos];
}
int lim = 0, ans = 0;
if (pos == n - 1) lim = 1;
for (int i = lim; i <= 9; ++i) {
int nrem = (rem + i * p10[pos]) % k;
bool nok = ok;
if (nrem == 0 and i != 0) nok = true;
ans = (ans + dfs(pos + 1, nrem, nok)) % m;
}
dp[ok][rem][pos] = ans;
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
memset(dp, -1, sizeof(dp));
memset(p10, 0, sizeof(p10));
cin >> n >> k >> m;
p10[0] = 1;
for (int i = 1; i <= n; ++i) {
p10[i] = (p10[i - 1] * 10) % k;
}
cout << dfs(0, 0, 0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
void solve() {
string inp;
re(inp);
inp = inp.substr(4);
ll first = 1989, p10 = 1;
for (int i = 0; i < (int((inp).size()) - 1); i++) first += p10 *= 10;
p10 *= 10;
ll targ = 0;
for (auto& c : inp) targ = 10 * targ + c - '0';
ll ftail = first % p10;
ps(first + (targ - ftail + p10) % p10);
}
int main() {
setIO();
int T;
re(T);
for (int t = 0; t < (T); t++) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, tn, bit[50];
long long a[100005];
struct tree {
int l, r;
tree() { l = r = 0; }
} t[4400000];
inline void add(long long x) {
int v = 0;
for (int i = 41; i >= 0; --i) {
if (x & (1LL << i)) {
if (t[v].r)
v = t[v].r;
else {
t[v].r = ++tn;
v = tn;
}
} else {
if (t[v].l)
v = t[v].l;
else {
t[v].l = ++tn;
v = tn;
}
}
}
}
inline long long Find(long long x) {
long long res = 0;
int v = 0;
for (int i = 41; i >= 0; --i) {
int j = (bool)(x & (1LL << i)) + bit[i];
if (j & 1) {
if (t[v].l) {
res |= (1LL << i);
v = t[v].l;
} else
v = t[v].r;
} else {
if (t[v].r) {
res |= (1LL << i);
v = t[v].r;
} else
v = t[v].l;
}
}
return res;
}
int main() {
scanf("%d", &n);
long long p = 0;
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
p ^= a[i];
}
for (int i = 0; i <= 42; ++i) t[tn++].l = i + 1;
for (int i = 0; i < 42; ++i)
if (p & (1LL << i)) bit[i] = 1;
long long res = p, cur = 0;
for (int i = 1; i <= n; ++i) {
cur ^= a[i];
res = max(res, Find(cur));
add(cur);
}
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long mul(unsigned long long a, unsigned long long b,
unsigned long long p) {
long long res =
a * b - p * (unsigned long long)((long double)a * (long double)b /
(long double)p);
return res + p * (res < 0) - p * (res >= (long long)p);
}
long long qpm(long long a, long long b, long long p) {
long long r = 1;
do
if (b & 1) r = mul(r, a, p);
while (a = mul(a, a, p), b >>= 1);
return r;
}
const int N = 10000000;
bool ip[N];
vector<int> ps;
void sieve() {
memset(ip, 1, sizeof(ip));
ip[1] = 0;
for (int i = 2; i != N; ++i) {
if (ip[i]) ps.push_back(i);
for (int j : ps) {
if (i * j >= N) break;
ip[i * j] = 0;
if (i % j == 0) break;
}
}
}
struct pf {
long long p, c, q;
};
vector<pf> pfd(long long x) {
vector<pf> res;
for (long long p : ps) {
if (p * p > x) break;
if (x % p) continue;
res.push_back({p, 0, 1});
do res.back().c++, res.back().q *= p;
while ((x /= p) % p == 0);
}
if (x != 1) res.push_back({x, 1, x});
return res;
}
long long phi(long long x) {
long long r = x;
for (long long p : ps) {
if (p * p > x) break;
if (x % p) continue;
(r /= p) *= p - 1;
while (x % p == 0) x /= p;
}
if (x != 1) (r /= x) *= x - 1;
return r;
}
long long ord(long long n, long long phn, const vector<pf>& pfs, long long g) {
long long res = 1;
for (pf p : pfs)
for (long long t = qpm(g, phn / p.q, n); t != 1; res *= p.p)
t = qpm(t, p.p, n);
return res;
}
vector<pf> merge(const vector<pf>& p1, const vector<pf>& p2) {
vector<pf> res;
int n1 = p1.size(), n2 = p2.size(), i1 = 0, i2 = 0;
while (i1 != n1 && i2 != n2) {
if (p1[i1].p < p2[i2].p) {
res.push_back(p1[i1]);
i1++;
} else if (p2[i2].p < p1[i1].p) {
res.push_back(p2[i2]);
i2++;
} else {
res.push_back({p1[i1].p, p1[i1].c + p2[i2].c, p1[i1].q * p2[i2].q});
i1++;
i2++;
}
}
while (i1 != n1) res.push_back(p1[i1++]);
while (i2 != n2) res.push_back(p2[i2++]);
return res;
}
long long prod(const vector<pf>& pfs) {
long long r = 1;
for (pf p : pfs) r *= p.q;
return r;
}
void dfs(long long& res, long long g, long long n, const vector<pf>& nf,
const vector<vector<pf>>& wf, int i, long long m, long long phm,
vector<pf>& mf) {
if (i == nf.size()) {
if (m == 1) return;
vector<pf> u = mf, v, w;
for (int i = 0; i != nf.size(); ++i) {
if (!mf[i].c) continue;
u[i].c--;
u[i].q /= u[i].p;
v = merge(v, wf[i]);
}
w = merge(u, v);
long long t = ord(m, phm, w, g % m);
assert(phm % t == 0);
res += phm / t;
} else {
dfs(res, g, n, nf, wf, i + 1, m, phm, mf);
for (int j = 1; j <= nf[i].c; ++j) {
m /= mf[i].p;
mf[i].q /= mf[i].p;
mf[i].c--;
phm /= mf[i].p - (j == nf[i].c);
dfs(res, g, n, nf, wf, i + 1, m, phm, mf);
}
mf[i] = nf[i];
}
}
int main(void) {
sieve();
long long n, g;
scanf("%lld%lld", &n, &g);
long long res = 1;
vector<pf> nf = pfd(n), mf = nf;
vector<vector<pf>> wf;
for (pf p : nf) wf.push_back(p.p == 2 ? vector<pf>(0) : pfd(p.p - 1));
long long phn = 1;
for (pf p : nf) phn *= (p.q / p.p) * (p.p - 1);
dfs(res, g, n, nf, wf, 0, n, phn, mf);
printf("%lld\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int i, j, k, n, t;
bool prime(int p) {
if (p < 4) return 1;
for (int l = 2; l * l <= p; l++) {
if (p % l == 0) return 0;
}
return 1;
}
void F() {
bool z = 0;
for (i = 2; i * i / 2 <= t; i++) {
if (prime(i) && prime(t - i)) {
printf("2\n%d %d\n", i, t - i);
z = 1;
break;
}
}
if (!z) {
for (i = 2; i < t; i++) {
if (prime(i)) {
for (j = 2; j * j / 2 <= t; j++) {
if (prime(j) && prime(t - i - j)) {
printf("3\n%d %d %d\n", i, j, t - i - j);
z = 1;
break;
}
}
}
if (z) break;
}
}
}
void solve() {
int n = 1;
while (n--) {
scanf("%d", &t);
if (prime(t))
printf("1\n%d\n", t);
else {
F();
}
}
}
int main() { solve(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int t;
cin >> t;
for (int qwerty = 0; qwerty < t; ++qwerty) {
int64_t p, q, pp;
cin >> p >> q;
pp = p;
int64_t ans = 1e18;
for (int i = 2; i * i <= q; ++i) {
int cnt1 = 0;
int cnt2 = 0;
while (p % i == 0) {
p /= i;
cnt1++;
}
while (q % i == 0) {
q /= i;
cnt2++;
}
if (cnt1 < cnt2) ans = 1;
if (cnt1 != 0 && cnt2 != 0) {
int cnt = max(0, cnt1 - cnt2 + 1);
int64_t a = 1;
for (int j = 0; j < cnt; ++j) a *= i;
ans = min(ans, a);
}
}
int cnt1 = 0;
int cnt2 = 0;
if (q > 1) {
int qq = q;
while (p % q == 0) {
p /= q;
cnt1++;
}
cnt2 = 1;
if (cnt1 < cnt2) {
ans = 1;
} else {
int cnt = max(0, cnt1 - cnt2 + 1);
int64_t a = 1;
for (int j = 0; j < cnt; ++j) a *= q;
ans = min(ans, a);
}
}
cout << pp / ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void Start() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); }
bool endline = false;
bool endlineA = false;
bool space = true;
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& i : v) {
in >> i;
}
return in;
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& v) {
for (auto i : v) {
out << i;
if (!endline) {
if (space) out << ' ';
} else {
out << '\n';
}
}
if (!endline && endlineA) {
out << '\n';
}
return out;
}
template <class T, class U>
istream& operator>>(istream& in, pair<T, U>& p) {
in >> p.first >> p.second;
return in;
}
template <class T, class U>
ostream& operator<<(ostream& out, const pair<T, U>& p) {
out << p.first << ' ' << p.second;
return out;
}
long long gettime() {
return chrono::high_resolution_clock::now().time_since_epoch().count() /
1000000;
}
mt19937_64 getrand(
chrono::high_resolution_clock::now().time_since_epoch().count());
long long randnum(long long l, long long r) {
return l + getrand() % (r - l + 1);
}
vector<vector<long long>> transform(vector<vector<long long>> v) {
vector<vector<long long>> res(v[0].size(), vector<long long>(v.size()));
for (long long i = 0; i < v.size(); i++) {
for (long long j = 0; j < v[0].size(); j++) {
res[j][i] = v[i][j];
}
}
return res;
}
long long get1(vector<vector<long long>> v) {
vector<long long> sum(v.size());
for (long long i = 0; i < v.size(); i++) {
for (auto j : v[i]) {
sum[i] += j;
}
}
sort(sum.rbegin(), sum.rend());
return sum[0] + sum[1] + sum[2] + sum[3];
}
long long get2(vector<vector<long long>> v) {
vector<long long> sum(v.size());
for (long long i = 0; i < v.size(); i++) {
for (auto j : v[i]) {
sum[i] += j;
}
}
long long res = 0;
for (long long i = 0; i < v[0].size(); i++) {
multiset<long long> l;
long long sum2 = 0;
for (long long j = 0; j < v.size(); j++) {
sum2 += v[j][i];
l.insert(sum[j] - v[j][i]);
if (l.size() > 3) {
l.erase(l.begin());
}
}
long long temp = 0;
for (auto i : l) temp += i;
res = max(res, sum2 + temp);
}
return res;
}
long long get3(vector<vector<long long>> v) {
vector<long long> sum(v.size());
for (long long i = 0; i < v.size(); i++) {
for (auto j : v[i]) {
sum[i] += j;
}
}
if (v[0].size() > v.size()) return 0;
long long res = 0;
for (long long i = 0; i < v[0].size(); i++) {
for (long long j = 0; j < i; j++) {
long long mx = -1, mxmx = -1;
long long sum2 = 0;
for (long long k = 0; k < v.size(); k++) {
sum2 += v[k][i] + v[k][j];
long long cur = sum[k] - v[k][i] - v[k][j];
if (mxmx < cur) {
swap(mx, mxmx);
mxmx = cur;
} else if (mx < cur) {
mx = cur;
}
}
long long temp = 0;
temp += mx;
temp += mxmx;
res = max(res, sum2 + temp);
}
}
return res;
}
signed main() {
Start();
long long n, m;
cin >> n >> m;
vector<vector<long long>> v(n, vector<long long>(m));
cin >> v;
if (min(n, m) <= 4) {
long long sum = 0;
for (auto i : v)
for (auto j : i) sum += j;
cout << sum;
return 0;
}
long long ans = 0;
ans = max(ans, get1(v));
ans = max(ans, get2(v));
ans = max(ans, get3(v));
v = transform(v);
ans = max(ans, get1(v));
ans = max(ans, get2(v));
ans = max(ans, get3(v));
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char in[10000], fir[10000], sec[10000];
struct widget {
long long x, y;
long long sp, bo;
int kind;
widget() {
x = -1;
y = -1;
sp = bo = 0;
}
vector<widget*> pack;
inline void calc() {
if (x != -1) return;
if (pack.size() == 0) {
x = 0;
y = 0;
return;
}
if (kind == 1) {
long long maxy = 0;
long long sumx = -sp;
for (int i = 0; i < pack.size(); i++) {
pack[i]->calc();
maxy = max(maxy, pack[i]->y);
sumx += pack[i]->x + sp;
}
x = sumx + 2ll * bo;
y = maxy + 2ll * bo;
} else {
long long maxx = 0;
long long sumy = -sp;
for (int i = 0; i < pack.size(); i++) {
pack[i]->calc();
maxx = max(maxx, pack[i]->x);
sumy += pack[i]->y + sp;
}
y = sumy + 2ll * bo;
x = maxx + 2ll * bo;
}
}
};
map<string, widget*> XD;
int main() {
int q, i;
gets(in);
q = atoi(in);
while (q--) {
gets(in);
int l = strlen(in);
for (i = 0; i < l; i++)
if (in[i] == ' ') break;
if (i < l) {
sscanf(in, "%s%s", fir, sec);
widget* w = new widget;
if (strcmp(fir, "Widget") == 0) {
string ss = sec;
string na = ss.substr(0, ss.find("("));
int x = atoi(ss.substr(ss.find("(") + 1).c_str());
int y = atoi(ss.substr(ss.find(",") + 1).c_str());
w->x = x;
w->y = y;
w->kind = 0;
XD[na] = w;
} else if (strcmp(fir, "HBox") == 0) {
w->kind = 1;
XD[sec] = w;
} else {
w->kind = 2;
XD[sec] = w;
}
} else {
string ss = in;
string na = ss.substr(0, ss.find("."));
string cmd = ss.substr(ss.find(".") + 1, ss.find("(") - ss.find(".") - 1);
string tar = ss.substr(ss.find("(") + 1, ss.find(")") - ss.find("(") - 1);
if (cmd == "pack") {
(XD[na]->pack).push_back(XD[tar]);
} else if (cmd == "set_border") {
XD[na]->bo = atoi(tar.c_str());
} else {
XD[na]->sp = atoi(tar.c_str());
}
}
}
for (map<string, widget*>::iterator it = XD.begin(); it != XD.end(); it++) {
it->second->calc();
printf("%s %I64d %I64d\n", (it->first).c_str(), it->second->x,
it->second->y);
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
int flag = 0, j = 0, sum = 0, n, i = 0;
scanf("%d", &n);
int arr[n];
for (; i < n; i++) {
scanf("%d", &arr[i]);
if (arr[i] == 1) {
flag = 1;
}
if (flag == 0 && arr[i] == 0) {
sum++;
j++;
}
}
i = n - 1;
for (; i > j; i--) {
if (arr[i] == 0) {
sum++;
} else {
break;
}
}
for (; i > j + 1; i--) {
if (arr[i] == 0) {
if (arr[i - 1] == 0) {
sum++;
}
i = i - 1;
while (arr[i] == 0) {
sum++;
i--;
}
}
}
printf("%d", n - sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m = 0, tmp, ans = 0;
cin >> n;
int arr[50];
for (int i = 1; i <= n; i++) {
cin >> tmp;
if (tmp == 1) {
arr[m] = i;
m++;
}
}
for (int i = 1; i < m; i++) {
ans += arr[i] - arr[i - 1] - 1;
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
int n, a[N];
bool in[N];
vector<int> all_sums(const vector<int>& b, int k) {
int m = b.size();
set<int> st;
vector<int> v;
for (int i = 0; i < k; i++) v.push_back(i);
while (true) {
int s = 0;
for (int i = 0; i < k; i++) s += b[v[i]];
st.insert(s);
int i = k - 1;
while (0 <= i && v[i] == m - k + i) i--;
if (i < 0) break;
v[i]++;
while (i + 1 < k) {
v[i + 1] = v[i] + 1;
i++;
}
}
return vector<int>(st.begin(), st.end());
}
vector<int> get_sum(const vector<int>& b, int k, int val) {
int m = b.size();
vector<int> v;
for (int i = 0; i < k; i++) v.push_back(i);
while (true) {
int s = 0;
for (int i = 0; i < k; i++) s += b[v[i]];
if (s == val) return v;
int i = k - 1;
while (0 <= i && v[i] == m - k + i) i--;
if (i < 0) break;
v[i]++;
while (i + 1 < k) {
v[i + 1] = v[i] + 1;
i++;
}
}
return v;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < 2 * n; i++) cin >> a[i];
sort(a, a + 2 * n);
int S = 0;
for (int i = 2; i < 2 * n; i++) S += a[i];
int opt = 1e7, k1, k2, val1, val2;
vector<int> b1, b2;
for (int i = 2; i < n + 1; i++) b1.push_back(a[i]);
for (int i = n + 1; i < 2 * n; i++) b2.push_back(a[i]);
for (int k = n / 2; k <= n - 1; k++) {
vector<int> v1 = all_sums(b1, k), v2 = all_sums(b2, n - 1 - k);
int j = (int)v2.size() - 1;
for (int i = 0; i < v1.size(); i++) {
while (0 <= j - 1 && v1[i] + v2[j - 1] >= (S + 1) / 2) j--;
for (int jj = max(j - 1, 0); jj <= j; jj++) {
if (abs(S - 2 * (v1[i] + v2[jj])) < opt) {
opt = abs(S - 2 * (v1[i] + v2[jj]));
k1 = k;
k2 = n - 1 - k;
val1 = v1[i];
val2 = v2[jj];
}
}
}
}
vector<int> v1 = get_sum(b1, k1, val1), v2 = get_sum(b2, k2, val2);
for (int i : v1) in[i + 2] = true;
for (int i : v2) in[n + 1 + i] = true;
cout << a[0];
for (int i = 2; i < 2 * n; i++)
if (in[i]) cout << " " << a[i];
cout << "\n";
for (int i = 2 * n - 1; 2 <= i; i--)
if (!in[i]) cout << a[i] << " ";
cout << a[1] << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
long long ans = 0;
for (long long i = 1; i < n - 1; i++) {
if (arr[i] == 1) continue;
if (!arr[i - 1] || !arr[i + 1]) continue;
arr[i + 1] = 0;
ans++;
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500800;
const int M = 1e5 + 100;
int n, q;
int num[M], now[M];
double f[M][110], C[N][10];
double res;
signed main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
now[i] = num[i];
f[i][num[i]] = 1;
res = res + f[i][0];
}
for (int i = 0; i <= N - 400; i++) C[i][0] = 1;
for (int i = 1; i <= N - 400; i++)
for (int j = 1; j <= min(i, 5); j++)
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
res -= f[u][0];
for (int j = 0; j <= num[u]; j++) {
double ans = 0;
for (int k = j; k <= min(j + w, now[u]); k++)
ans += f[u][k] * C[k][k - j] * C[now[u] - k][w - (k - j)];
f[u][j] = ans / C[now[u]][w];
}
res += f[u][0], now[u] -= w, now[v] += w;
printf("%.9lf\n", res);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int cnt[26] = {0};
int main() {
int x = 0;
int num;
string p;
cin >> num;
cin >> p;
int flag = 0;
if (p.length() > 26) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < p.length(); i++) {
cnt[p[i]] = cnt[p[i]] + 1;
if (cnt[p[i]] > 26) {
cout << "-1" << endl;
return 0;
}
if (cnt[p[i]] > 1) {
if (i > 25 && flag == 0) {
cout << "-1" << endl;
return 0;
}
x++;
flag = 1;
}
}
cout << x << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = (int)1e5 + 11;
int n, m, k, dp[2000][2000];
int C(int n, int k) {
if (n < 0 || k < 0 || k > n) return 0;
return dp[n][k];
}
int main() {
n = 2000;
for (int i = 0; i < n; i++) {
dp[i][0] = dp[i][i] = 1;
for (int j = 1; j < i; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % mod;
}
}
cin >> n >> m >> k;
int ans = C(n - 1, 2 * k);
ans = 1ll * ans * C(m - 1, 2 * k) % mod;
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, rev, cap, flow;
edge(int _v, int _rev, int _cap, int _flow) {
v = _v;
rev = _rev;
cap = _cap;
flow = _flow;
}
edge() {}
};
vector<pair<int, int> > path;
vector<vector<edge> > AdjList;
int f = 0;
void addEdge(int u, int v, int cap) {
int k = AdjList[v].size(), l = AdjList[u].size();
AdjList[u].push_back(edge(v, k, cap, 0));
AdjList[v].push_back(edge(u, l, 0, 0));
}
void augment(int s, int v, int min_edge) {
if (v == s) {
f = min_edge;
return;
}
int u = path[v].first, i = path[v].second;
if (u != -1) {
int res = AdjList[u][i].cap - AdjList[u][i].flow;
augment(s, u, min(res, min_edge));
AdjList[u][i].flow += f;
AdjList[v][AdjList[u][i].rev].flow -= f;
}
}
int maxFlow(int s, int t, int N) {
int maxflow = 0;
path.resize(N);
while (true) {
f = 0;
vector<int> dist(N, 1000000000);
vector<bool> visit(N, false);
path[t] = make_pair(-1, -1);
queue<int> cola;
cola.push(s);
visit[s] = true;
while (!cola.empty()) {
int u = cola.front();
cola.pop();
if (u == t) break;
for (int i = (0); i < ((int)AdjList[u].size()); ++i) {
edge e = AdjList[u][i];
if (!visit[e.v] and e.cap - e.flow > 0)
cola.push(e.v), visit[e.v] = true, path[e.v] = make_pair(u, i);
}
}
augment(s, t, 1000000000);
if (!f) break;
maxflow += f;
}
return maxflow;
}
char lab[15][15], caps[15][15];
int inf[15][15], dist[15][15];
int dX[] = {0, 1, 0, -1}, dY[] = {1, 0, -1, 0};
int main() {
int n, t;
scanf("%d %d", &n, &t);
for (int i = (0); i < (n); ++i) scanf("%s", lab[i]);
for (int i = (0); i < (n); ++i) scanf("%s", caps[i]);
memset(inf, -1, sizeof inf);
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j)
if (lab[i][j] == 'Z') {
queue<pair<pair<int, int>, int> > cola;
cola.push(make_pair(make_pair(i, j), 0));
inf[i][j] = 0;
while (!cola.empty()) {
int x = cola.front().first.first;
int y = cola.front().first.second;
int d = cola.front().second;
cola.pop();
for (int k = (0); k < (4); ++k) {
int nx = x + dX[k], ny = y + dY[k];
if (nx < 0 or ny < 0 or nx == n or ny == n or lab[nx][ny] == 'Y' or
inf[nx][ny] != -1)
continue;
inf[nx][ny] = d + 1;
cola.push(make_pair(make_pair(nx, ny), d + 1));
}
}
}
AdjList.assign(2 * n * n + 2, vector<edge>());
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j)
if (lab[i][j] - '0' > 0 and lab[i][j] - '0' <= 9)
addEdge(0, i * n + j + 1, lab[i][j] - '0');
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) {
if (lab[i][j] - '0' > 0 and lab[i][j] - '0' <= 9) {
memset(dist, -1, sizeof dist);
queue<pair<pair<int, int>, int> > cola;
cola.push(make_pair(make_pair(i, j), 0));
dist[i][j] = 0;
while (!cola.empty()) {
int x = cola.front().first.first;
int y = cola.front().first.second;
int d = cola.front().second;
cola.pop();
if (d <= t and (inf[x][y] == -1 or d <= inf[x][y]) and
(caps[x][y] - '0' > 0 and caps[x][y] - '0' <= 9))
addEdge(i * n + j + 1, x * n + y + 1 + n * n, 1000000000);
if (d == t or d == inf[x][y]) continue;
for (int k = (0); k < (4); ++k) {
int nx = x + dX[k], ny = y + dY[k];
if (nx < 0 or ny < 0 or nx == n or ny == n or lab[nx][ny] == 'Y' or
lab[nx][ny] == 'Z' or dist[nx][ny] != -1 or
(d + 1 > inf[nx][ny] and inf[nx][ny] != -1))
continue;
dist[nx][ny] = d + 1;
cola.push(make_pair(make_pair(nx, ny), d + 1));
}
}
}
if (caps[i][j] - '0' > 0 and caps[i][j] - '0' <= 9)
addEdge(i * n + j + 1 + n * n, 2 * n * n + 1, caps[i][j] - '0');
}
int maxflow = maxFlow(0, 2 * n * n + 1, 2 * n * n + 2);
printf("%d\n", maxflow);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2, s3;
int win(string s1, string s2) {
if (s1 == "rock") {
if (s2 == "rock") return 0;
if (s2 == "scissors") return 1;
if (s2 == "paper") return 2;
}
if (s1 == "paper") {
if (s2 == "rock") return 1;
if (s2 == "scissors") return 2;
if (s2 == "paper") return 0;
}
if (s1 == "scissors") {
if (s2 == "rock") return 2;
if (s2 == "scissors") return 0;
if (s2 == "paper") return 1;
}
}
int main() {
cin >> s1 >> s2 >> s3;
if (win(s1, s2) == 1 && win(s1, s3) == 1) {
cout << "F";
return 0;
}
if (win(s2, s1) == 1 && win(s2, s3) == 1) {
cout << "M";
return 0;
}
if (win(s3, s1) == 1 && win(s3, s2) == 1) {
cout << "S";
return 0;
}
cout << "?";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool finishes(int n, int k, int q) {
while (q != 0 && n > 0) {
n -= q;
q /= k;
}
return n <= 0;
}
int main() {
int n, v, k;
cin >> n >> k;
int min = 1, max = n;
while (min < max) {
int mid = (min + max) / 2;
if (!finishes(n, k, mid)) {
min = mid + 1;
} else {
max = mid - 1;
}
}
cout << (finishes(n, k, max) ? max : max + 1) << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 100000000000000;
const long double eps = 1e-8;
struct edge {
int to;
long long cap;
int rev;
};
vector<edge> G[100000];
bool used[100000];
void add_edge(int from, int to, long long cap) {
G[from].push_back(edge{to, cap, (int)G[to].size()});
G[to].push_back(edge{from, 0, (int)G[from].size() - 1});
}
long long dfs(int v, int t, long long f) {
if (v == t) return f;
used[v] = true;
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
long long max_flow(int s, int t) {
long long flow = 0;
for (;;) {
memset(used, 0, sizeof(used));
long long f = dfs(s, t, INF);
if (f == 0) return flow;
flow += f;
}
}
int distr[101][101];
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
distr[i][j] = 0;
else
distr[i][j] = mod;
}
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
distr[a][b] = distr[b][a] = 1;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
distr[i][j] = min(distr[i][j], distr[i][k] + distr[k][j]);
}
}
}
int nl, nr, nrel;
cin >> nl >> nr >> nrel;
vector<int> xl(nl), a(nl), f(nl), p(nl);
vector<int> xr(nr), b(nr), g(nr);
for (int i = 0; i < nl; i++) {
cin >> xl[i] >> a[i] >> f[i] >> p[i];
xl[i]--;
}
for (int i = 0; i < nr; i++) {
cin >> xr[i] >> b[i] >> g[i];
xr[i]--;
}
vector<pair<int, int>> rel(nrel);
for (int i = 0; i < nrel; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
rel[i] = {u, v};
}
vector<vector<pair<int, int>>> vb(n);
for (int i = 0; i < nr; i++) {
vb[xr[i]].push_back({b[i], g[i]});
}
vector<vector<int>> bb(n), hg(n);
for (int i = 0; i < n; i++) {
sort(vb[i].begin(), vb[i].end());
bb[i].resize(vb[i].size());
hg[i].resize(vb[i].size() + 1);
int ma = -2 * mod;
for (int j = 0; j < (int)vb[i].size(); j++) {
bb[i][j] = vb[i][j].first;
hg[i][j] = ma;
ma = max(ma, vb[i][j].second);
}
hg[i][vb[i].size()] = ma;
}
vector<bool> cant(nl, false);
vector<long long> val(nl);
for (int i = 0; i < nl; i++) {
int maval = -2 * mod;
for (int j = 0; j < n; j++) {
int d = distr[xl[i]][j];
if (d > f[i]) continue;
int id = upper_bound(bb[j].begin(), bb[j].end(), a[i]) - bb[j].begin();
maval = max(maval, hg[j][id]);
}
if (maval == -2 * mod) {
cant[i] = true;
}
val[i] = (long long)maval - (long long)p[i];
}
vector<bool> exi(nl, false);
for (int i = 0; i < nrel; i++) {
int u = rel[i].first, v = rel[i].second;
exi[u] = exi[v] = true;
}
vector<int> ids;
vector<int> trans(nl);
long long ans = 0;
for (int i = 0; i < nl; i++) {
if (!exi[i]) {
ans += max((long long)0, val[i]);
} else {
trans[i] = ids.size();
ids.push_back(i);
}
}
int s = ids.size();
int t = s + 1;
for (int i = 0; i < ids.size(); i++) {
int id = ids[i];
long long cost = val[id];
if (cost < 0) {
add_edge(s, i, -cost);
add_edge(i, t, 0);
} else {
add_edge(s, i, 0);
add_edge(i, t, cost);
}
if (cant[id]) {
add_edge(s, i, INF);
}
}
for (int i = 0; i < nrel; i++) {
int u = rel[i].first, v = rel[i].second;
u = trans[u], v = trans[v];
add_edge(v, u, INF);
}
long long sum = 0;
for (int i = 0; i < ids.size(); i++) {
if (val[ids[i]] >= 0) {
sum += val[ids[i]];
}
}
long long z = max_flow(s, t);
sum -= z;
ans += sum;
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
long long int n;
cin >> n;
long long int a = pow(4, n - 3);
long long int b = pow(4, max(n - 4, (long long int)0));
cout << 2 * 4 * 3 * a + 4 * (n - 3) * 3 * 3 * b;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> arr(n, 0);
int in;
for (int i = 0; i < n; i++) {
cin >> in;
arr[in - 1]++;
}
sort(arr.rbegin(), arr.rend());
int i = 0;
int chocs = arr[0];
long long int ans = 0;
while (i < n && arr[i] > 0 && chocs > 0) {
if (arr[i] >= chocs) {
ans += chocs;
} else {
chocs = arr[i];
ans += chocs;
}
chocs--;
i++;
}
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int t;
cin >> t;
while (t--) {
unsigned long long int a, b;
cin >> a >> b;
cout << (a ^ b) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const int INF = std::numeric_limits<int>::max();
mt19937 gen(static_cast<unsigned int>(time(NULL)));
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string s, t;
cin >> s >> t;
string summa;
bool overflow = false;
const uint32_t K = 26;
const uint32_t start = static_cast<uint32_t>('a');
for (int i = n - 1; i >= 0; --i) {
uint32_t a = static_cast<uint32_t>(s[i]) - start;
uint32_t b = static_cast<uint32_t>(t[i]) - start;
uint32_t tmp = a + b + (overflow ? 1 : 0);
overflow = tmp >= K;
summa += static_cast<char>(tmp - (tmp >= K ? K : 0) + start);
}
reverse((summa).begin(), (summa).end());
string res;
for (size_t i = 0; i < summa.size(); ++i) {
uint32_t a = static_cast<uint32_t>(summa[i]) - start + (overflow ? K : 0);
res += static_cast<char>(a / 2 + start);
overflow = a % 2 == 1;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct tp {
int dinh, v;
tp() {}
tp(int _dinh, int _v) { dinh = _dinh, v = _v; }
};
bool operator>(const tp& a, const tp& b) {
if (a.v > b.v) return true;
if (a.v == b.v)
if (a.dinh < b.dinh) return true;
return false;
}
int n, q;
int adjList[310][310];
long long d[310][310];
int dau[310];
int ret[310][310];
int cnt = 0;
void Dijsktra(int start, int endd) {
priority_queue<tp, vector<tp>, greater<tp> > open;
memset(dau, 0, sizeof(dau));
dau[start] = 1;
open.push(tp(start, 0));
while (!open.empty()) {
tp cur = open.top();
open.pop();
if (cur.dinh == endd) return;
int i;
for (i = 0; i < n; i++) {
if (i != cur.dinh) {
int moi = i;
if (!dau[moi]) {
dau[moi] = 1;
d[start][moi] = d[start][cur.dinh] + adjList[cur.dinh][i];
d[moi][start] = d[start][moi];
open.push(tp(moi, d[start][moi]));
} else if (dau[moi] &&
d[start][moi] > d[start][cur.dinh] + adjList[cur.dinh][i]) {
dau[moi] = 1;
d[start][moi] = d[start][cur.dinh] + adjList[cur.dinh][i];
d[moi][start] = d[start][moi];
open.push(tp(moi, d[start][moi]));
}
}
}
}
}
void Solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> d[i][j];
scanf("%d", &q);
long long sum = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) sum += d[i][j];
for (int i = 0; i < q; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
sum = 0;
for (int j = 0; j < n; j++) {
for (int k = j + 1; k < n; k++) {
long long v1 = d[j][a - 1] + d[b - 1][k] + (long long)c;
long long v2 = d[j][b - 1] + d[a - 1][k] + (long long)c;
v1 = min(v1, v2);
if (v1 < d[j][k]) {
d[j][k] = d[k][j] = v1;
sum += d[j][k];
} else
sum += d[j][k];
}
}
cout << sum << " ";
}
printf("\n");
}
int main() {
Solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mod = (int)1e9 + 7;
int R, G;
int dp[200003];
int main() {
cin >> R >> G;
int H;
for (int i = 1; i <= 1000; ++i) {
if ((i * (i + 1)) / 2 > R + G) {
H = i - 1;
break;
}
}
if (R > G) swap(R, G);
dp[0] = dp[1] = 1;
for (int h = 2; h <= H; ++h) {
int cur = (h * (h + 1)) / 2;
for (int r = R; r >= 0; --r) {
int tmp = 0;
if (r - h >= 0) tmp = (tmp + dp[r - h]) % mod;
if (cur - r - h >= 0) tmp = (tmp + dp[r]) % mod;
dp[r] = tmp;
}
}
int ans = 0, tow = (H * (H + 1)) / 2;
for (int r = R; r >= 0 && tow - r <= G; --r) {
ans = (ans + dp[r]) % mod;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
static constexpr int inf = std::numeric_limits<int>::max();
const int M = 500;
int parent[M], degree[M];
vector<pair<int, int> > edge;
int f(int u) { return parent[u] = parent[u] == u ? u : f(parent[u]); }
bool connect(int x, int y) {
int u = f(x), v = f(y);
if (u == v) return false;
parent[u] = v;
return true;
}
int main() {
int i, j, k, n, m;
for (i = 0; i < M; i++) parent[i] = i;
memset((degree), (0), sizeof(degree));
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &i, &j);
degree[i]++;
degree[j]++;
if (degree[i] > 2 || degree[j] > 2) {
printf("NO\n");
return 0;
};
connect(i, j);
}
while (true) {
for (i = 1; i <= n; i++)
if (degree[i] < 2) break;
if (i > n) break;
for (j = 1; j <= n; j++) {
if (degree[j] < 2)
if (connect(i, j)) break;
}
if (j > n) {
for (j = 1; j <= n; j++)
if (i != j && degree[j] < 2) {
edge.push_back(make_pair(i, j));
break;
}
if (j > n) edge.push_back(make_pair(i, i));
break;
}
edge.push_back(make_pair(i, j));
degree[i]++;
degree[j]++;
}
for (i = 1; i <= n; i++)
if (f(i) != f(1)) {
printf("NO\n");
return 0;
};
puts("YES");
printf("%d\n", edge.size());
for (i = 0; i < edge.size(); i++)
printf("%d %d\n", edge[i].first, edge[i].second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long c(int n, int m) {
long long res = 1;
for (int i = 1; i <= m; i++) res *= n - i + 1, res /= i;
return res;
}
int main(int argc, char *argv[]) {
int n;
cin >> n;
cout << c(n, 5) + c(n, 6) + c(n, 7) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
namespace fastio {
char rbuf[1 << 23], *p1 = rbuf, *p2 = rbuf, wbuf[1 << 23], *p3 = wbuf;
inline char getc() {
return p1 == p2 &&
(p2 = (p1 = rbuf) + fread(rbuf, 1, 1 << 23, stdin), p1 == p2)
? -1
: *p1++;
}
inline void putc(char x) { (*p3++ = x); }
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
T neg = 0;
while (!isdigit(c)) neg |= !(c ^ '-'), c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (neg) x = (~x) + 1;
}
template <typename T>
void recursive_print(T x) {
return (!x) ? void() : (recursive_print(x / 10), putc(x % 10 ^ 48), void());
}
template <typename T>
void print(T x) {
(!x) && (putc('0'), 0);
(x < 0) && (putc('-'), x = ~x + 1);
recursive_print(x);
}
template <typename T>
void print(T x, char c) {
(!x) && (putc('0'), 0);
(x < 0) && (putc('-'), x = ~x + 1);
recursive_print(x);
putc(c);
}
void print_final() { fwrite(wbuf, 1, p3 - wbuf, stdout); }
} // namespace fastio
const int MAXN = 40;
int n, k, c[MAXN + 5];
long long tot[MAXN + 5];
int c_new[MAXN + 5];
long long pre[MAXN + 5][MAXN + 5], msk[MAXN + 5];
bool dfs(int x, long long S) {
if (x == k) {
long long ought_S =
((1ll << n) - 1) & (~((1ll << n - __builtin_popcountll(S)) - 1));
long long dif = ought_S ^ S;
return (dif & msk[x]) == dif;
}
int mn = __builtin_popcountll(S & msk[x]);
S |= msk[x];
for (int i = mn; i <= mn + c_new[x]; i++)
if (!dfs(x + 1, S & pre[x][i])) return 0;
return 1;
}
int main() {
scanf("%d%d", &n, &k);
if (n == 1) return puts("ACCEPTED"), 0;
for (int i = 1; i <= k; i++) {
scanf("%d", &c[i]);
pre[i][c[i]] = (1ll << n) - 1;
for (int j = 1, x; j <= c[i]; j++) {
scanf("%d", &x);
msk[i] |= (1ll << x - 1);
pre[i][c[i] - j] = ~msk[i] & ((1ll << n) - 1);
}
c_new[i] = __builtin_popcountll(msk[i] & (~tot[i]));
tot[i + 1] = msk[i] | tot[i];
}
if (tot[k + 1] != (1ll << n) - 1) return puts("REJECTED"), 0;
printf("%s\n", dfs(1, 0) ? "ACCEPTED" : "REJECTED");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
template <typename T>
struct edge {
int from, to;
T w;
edge(int from, int to, T w) : from(from), to(to), w(w) {}
edge() {}
};
template <class T, class C>
void show(C a) {
for (T x : a) cout << x << " ";
cout << endl;
}
const long long M = 1e9 + 7;
const int N = 1e6 + 9;
long long n, k;
inline long long get(long long l, long long r) {
l = max(l, (1LL));
if (l > r) return 0;
--l;
long long a = (r - l) % M;
long long b = (r * (r + 1) - l * (l + 1)) / 2;
b %= M;
b = (b * (k - 1));
return (a + b) % M;
}
inline long long get(long long l, long long r, long long d) {
l = max(l, (1LL));
if (l > r) return 0;
--l;
long long a = (d * (r - l)) % M;
long long b = (r * (r + 1) - l * (l + 1)) / 2;
b %= M;
b = (b * (k - 1));
return (b - a + M) % M;
}
int parent[N];
int sz[N];
int lf[N], rf[N];
bool is[N];
inline bool is_set(int v) { return v >= 0 && v < n && is[v]; }
inline void make_set(int v) {
is[v] = true;
parent[v] = v;
sz[v] = 1;
lf[v] = rf[v] = v;
}
int find_set(int v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
inline void union_sets(int u, int v) {
u = find_set(u);
v = find_set(v);
if (u == v) return;
if (sz[u] < sz[v]) swap(v, u);
lf[u] = min(lf[u], (lf[v]));
rf[u] = max(rf[u], (rf[v]));
sz[u] += sz[v];
parent[v] = u;
}
vector<long long> a;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
a.resize(n);
vector<pair<long long, long long> > kek(n);
for (int i = 0; i < int(n); ++i) {
cin >> a[i];
kek[i] = make_pair(a[i], i);
}
sort(kek.begin(), kek.end());
long long all = 0;
for (auto x : kek) {
make_set(x.second);
if (is_set(x.second - 1)) union_sets(x.second, x.second - 1);
if (is_set(x.second + 1)) union_sets(x.second, x.second + 1);
int ind = x.second;
int v = find_set(ind);
int l = lf[v];
int r = rf[v];
int d1 = abs(ind - l) + 1, d2 = abs(r - ind) + 1;
if (d1 > d2) swap(d1, d2);
int f0 = 1;
int f1 = (d1 - 1) / (k - 1);
int f2 = (d2 - 1) / (k - 1);
int f3 = (d2 + d1 - 2) / (k - 1);
long long ans = 0;
ans = ((ans) + (get(f0, f3)) >= M ? (ans) + (get(f0, f3)) - M
: (ans) + (get(f0, f3)));
ans = ((ans) - (get(f1 + 1, f3, d1 - 1)) < 0
? (ans) - (get(f1 + 1, f3, d1 - 1)) + M
: (ans) - (get(f1 + 1, f3, d1 - 1)));
ans = ((ans) - (get(f2 + 1, f3, d2 - 1)) < 0
? (ans) - (get(f2 + 1, f3, d2 - 1)) + M
: (ans) - (get(f2 + 1, f3, d2 - 1)));
ans = (ans * x.first) % M;
all = ((all) + (ans) >= M ? (all) + (ans)-M : (all) + (ans));
}
cout << all;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void bla() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int main() {
bla();
int n;
cin >> n;
int x[n + 1], y[n + 1];
for (int i = 0; i < n; ++i) cin >> x[i] >> y[i];
int c = 0;
for (int i = 0; i < n; ++i) {
int a = 0, b = 0, d = 0, t = 0;
for (int j = 0; j < n; ++j) {
if (x[j] > x[i] && y[j] == y[i])
a++;
else if (x[j] < x[i] && y[j] == y[i])
b++;
else if (x[j] == x[i] && y[j] < y[i])
d++;
else if (x[j] == x[i] && y[j] > y[i])
t++;
if (a && b && d && t) {
if (a + b + d + t >= 4) {
c++;
break;
}
}
}
}
cout << c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, i, j, sum = 0, k = 0, b = 0, th;
long int a[200001];
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
sum = a[i] + sum;
}
th = sum / 2;
if (sum % 2 != 0) {
++th;
}
for (i = 0; i < n; i++) {
b = a[i] + b;
if (b >= th) {
k = i + 1;
break;
}
}
cout << k << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100010;
const int MAX_C = 1000010;
const long long INF = 1LL << 62;
class fenwickTree {
public:
int n;
vector<long long> tree;
fenwickTree(int n = 0) {
this->n = n;
tree = vector<long long>(n + 1, 0);
}
void update(int idx, long long val) {
while (idx <= n) {
tree[idx] += val;
idx += idx & -idx;
}
}
long long query(int r) {
long long res = 0;
while (r > 0) {
res += tree[r];
r -= r & -r;
}
return res;
}
long long query(int l, int r) { return query(r) - query(l - 1); }
};
long long cookies[MAX_N];
long long timeEat[MAX_N];
vector<pair<int, long long>> adj[MAX_N];
fenwickTree costs;
fenwickTree counts;
long long calcNumCookies(long long len, long long T) {
T -= 2 * len;
long long lo = 0, hi = costs.n;
while (hi - lo > 1) {
long long mid = (lo + hi) / 2;
if (costs.query(mid) <= T) {
lo = mid;
} else {
hi = mid;
}
}
if (lo + 1 < costs.n && costs.query(lo + 1) <= T) {
lo++;
}
long long res = counts.query(lo);
T -= costs.query(lo);
if (lo + 1 < costs.n) {
long long cookieCnt = counts.query(lo + 1, lo + 1);
long long price = costs.query(lo + 1, lo + 1);
if (cookieCnt > 0) {
price /= cookieCnt;
lo = 0;
hi = cookieCnt + 1;
while (hi - lo > 1) {
long long mid = (lo + hi) / 2;
if (mid * price <= T) {
lo = mid;
} else {
hi = mid;
}
}
if (lo + 1 <= cookieCnt && (lo + 1) * price <= T) {
lo++;
}
res += lo;
}
}
return res;
}
long long getRes(int v, long long len, long long T) {
counts.update(timeEat[v], cookies[v]);
costs.update(timeEat[v], timeEat[v] * cookies[v]);
long long res = calcNumCookies(len, T);
if (adj[v].size() > 0) {
multiset<long long, greater<long long>> childrenTimes;
vector<long long> times;
for (auto e : adj[v]) {
int w = e.first;
times.push_back(getRes(w, e.second + len, T));
childrenTimes.insert(times[times.size() - 1]);
}
long long childrenBest = INF;
if (v == 1) {
childrenBest = *childrenTimes.begin();
} else {
for (auto ct : times) {
childrenTimes.erase(childrenTimes.find(ct));
long long nextBest =
childrenTimes.size() > 0 ? *childrenTimes.begin() : 0;
childrenBest = min(childrenBest, nextBest);
childrenTimes.insert(ct);
}
}
res = max(res, childrenBest);
}
counts.update(timeEat[v], -cookies[v]);
costs.update(timeEat[v], -timeEat[v] * cookies[v]);
return res;
}
int main() {
ios::sync_with_stdio(false);
int n;
long long T;
cin >> n >> T;
for (int i = 1; i <= n; ++i) {
cin >> cookies[i];
}
for (int i = 1; i <= n; ++i) {
cin >> timeEat[i];
}
for (int i = 2; i <= n; ++i) {
int p;
long long len;
cin >> p >> len;
adj[p].push_back(make_pair(i, len));
}
costs = fenwickTree(MAX_C);
counts = fenwickTree(MAX_C);
long long res = getRes(1, 0, T);
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int solve(int i, string s) {
int n = s.size();
char c, c1;
int s1 = 0;
if (i == 0) c = '0', c1 = '0';
if (i == 1) c = '2', c1 = '5';
if (i == 2) c = '5', c1 = '0';
if (i == 3) c = '7', c1 = '5';
int pos;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == c1) {
pos = i;
break;
}
}
for (int i = pos; i < n - 1; i++) swap(s[i], s[i + 1]), s1++;
for (int i = s.size() - 2; i >= 0; i--) {
if (s[i] == c) {
pos = i;
break;
}
}
for (int i = pos; i < n - 2; i++) swap(s[i], s[i + 1]), s1++;
int c2 = 0;
if (s[0] == '0') {
for (int i = 0; i < n; i++) {
if (s[i] != '0') {
c2 = i;
break;
}
}
}
return s1 + c2;
}
int main() {
string s;
cin >> s;
int cnt[10] = {0};
vector<int> pos[10];
for (auto x : s) {
cnt[x - '0']++;
}
int minn = 1e9;
for (int i = 0; i < s.size(); i++) pos[s[i] - '0'].push_back(i);
bool a[4] = {false};
if (cnt[0] >= 2) a[0] = true;
if (cnt[2] >= 1 && cnt[5] >= 1) a[1] = true;
if (cnt[5] >= 1 && cnt[0] >= 1) a[2] = true;
if (cnt[7] >= 1 && cnt[5] >= 1) a[3] = true;
int r = -1;
int r1 = -1;
int n = s.size();
vector<int> res;
;
for (int i = 0; i < 4; i++) {
if (a[i] == true) {
r = 0;
r1 = solve(i, s);
res.push_back(r1);
}
}
if (r == -1)
cout << -1;
else {
sort(res.begin(), res.end());
cout << res[0];
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int A[200200];
deque<int> DQ;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
int N;
cin >> N;
for (int I = 0; I < N; I++) {
cin >> A[I];
}
if (N & 1) {
DQ.push_front(A[N / 2]);
}
for (int I = N / 2 - 1; I >= 0; I--) {
if (I & 1) {
DQ.push_front(A[I]);
DQ.push_back(A[N - I - 1]);
} else {
DQ.push_back(A[I]);
DQ.push_front(A[N - I - 1]);
}
}
for (int I = 0; I < N; I++) {
cout << DQ[I] << ' ';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int judge(int x) {
int sum = 0, temp = x;
while (temp > 0 && sum <= 10) sum += temp % 10, temp /= 10;
return sum;
}
int main() {
int n, ans;
scanf("%d", &n);
for (int i = 0; n; i++) {
if (judge(i) == 10) ans = i, n--;
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000000 + 7;
int one;
int n;
int a[2000000];
void input() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
if (a[i]) one = i;
}
if (a[n]) {
puts("NO");
exit(0);
}
if (n == 1) {
puts("YES");
puts("0");
exit(0);
}
if (n == 2) {
if (!one) {
puts("NO");
exit(0);
}
puts("YES");
puts("1->0");
exit(0);
}
if (n == one + 2) {
for (one = 1; one <= n; one++)
if (!a[one]) break;
if (one == n - 1) {
puts("NO");
exit(0);
}
one = n - 2;
}
puts("YES");
}
int st, en;
char s[2000000];
void solve() {
st = 1000000;
en = st - 1;
for (int i = n - 2; i >= 1; i--) {
if (i == n - 2) {
s[++en] = a[n - 2] + '0';
s[++en] = '-';
s[++en] = '>';
s[++en] = a[n - 1] + '0';
} else {
s[--st] = '>';
s[--st] = '-';
s[--st] = a[i] + '0';
}
s[--st] = '(';
s[++en] = ')';
}
s[++en] = '-';
s[++en] = '>';
s[++en] = '0';
s[++en] = 0;
puts(s + st);
}
int main() {
input();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
const int mod = 1e9 + 7;
const int B = sqrt(N);
int n, l, x, y;
int kh;
int a[N];
map<int, int> m, m1, m2;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> l >> x >> y;
for (int i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (m[a[i] + y]) {
m1[a[i] + y] = 1;
kh = 1;
}
}
int gh = 0;
for (int i = 1; i <= n; i++) {
if (m[a[i] + x]) gh = 1;
if (m[a[i] + x] && kh) {
cout << 0;
return 0;
}
m2[a[i] + x] = 1;
}
for (int i = 1; i <= n; i++) {
int r = a[i] + x;
int r1 = a[i] + y;
if (r <= l) {
if (m[r + y] || m[r - y] || kh) {
cout << 1 << "\n";
cout << r;
return 0;
}
}
if (r1 <= l) {
if (m[r1 - x] || m[r1 + x] || gh) {
cout << 1 << "\n";
cout << r1;
return 0;
}
}
r = a[i] - x;
r1 = a[i] - y;
if (r >= 0) {
if (m[r + y] || m[r - y] || kh) {
cout << 1 << "\n";
cout << r;
return 0;
}
}
if (r1 >= 0) {
if (m[r1 - x] || m[r1 + x] || gh) {
cout << 1 << "\n";
cout << r1;
return 0;
}
}
}
cout << 2 << "\n";
cout << x << " " << y;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], v[maxn], cnt;
void getprime() {
for (int i = 2; i <= maxn; i++) {
if (!v[i]) a[++cnt] = i;
for (int j = 1; j <= cnt && 1ll * i * a[j] < maxn; j++) {
v[i * a[j]] = 1;
if (!(i % a[j])) break;
}
}
}
int main() {
getprime();
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
map<int, int> mp;
vector<int> prime;
vector<int> div;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
div.push_back(i);
if (n / i != i) div.push_back(n / i);
}
}
div.push_back(n);
sort(div.begin(), div.end());
int tmp = n;
for (int i = 1; i <= cnt; i++) {
if (a[i] > tmp) break;
if (!(tmp % a[i])) {
prime.push_back(a[i]);
while (!(tmp % a[i])) tmp /= a[i];
}
}
if (tmp > 1) prime.push_back(tmp);
sort(prime.begin(), prime.end());
if (prime.size() == 1) {
for (int i = 0; i < div.size(); i++) printf("%d ", div[i]);
puts("\n0");
} else if (prime.size() == 2 && div.size() == 3) {
for (int i = 0; i < div.size(); i++) printf("%d ", div[i]);
puts("\n1");
} else {
vector<int> now;
for (int i = 0; i < prime.size(); i++) {
int d1 = prime[i], d2 = prime[(i + 1) % prime.size()];
for (int j = 0; j < div.size(); j++) {
if (!mp[div[j]] && div[j] % d1 == 0 && div[j] % d2 == 0) {
now.push_back(div[j]);
mp[div[j]] = 1;
break;
}
}
}
for (int i = 0; i < prime.size(); i++) {
for (int j = 0; j < div.size(); j++) {
if (!mp[div[j]] && div[j] % prime[i] == 0) {
printf("%d ", div[j]);
mp[div[j]] = 1;
}
}
printf("%d ", now[i]);
}
puts("\n0");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 9.2e18;
const int maxn = 1e5 + 70;
const int INF = 2.1e9;
const int maxm = 1e6 + 70;
const int MOD = 1e9 + 7;
const double eps = 1e-7;
const double PI = acos(-1.0);
int n, m, k;
int a[maxn];
multiset<int> S;
long long dp[maxn];
int main() {
while (cin >> n >> k) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long ans;
if (k > n) {
ans = 0;
for (int i = 1; i <= n; i++) ans += a[i];
} else {
dp[0] = 0;
S.clear();
long long sum = 0;
for (int i = 1; i < k; i++) {
sum += a[i];
dp[i] = sum;
S.insert(a[i]);
}
for (int i = k; i <= n; i++) {
dp[i] = dp[i - 1] + a[i];
sum += a[i];
S.insert(a[i]);
if (i > k) {
sum -= a[i - k];
auto it = S.lower_bound(a[i - k]);
S.erase(it);
}
dp[i] = min(dp[i], dp[i - k] + sum - *S.begin());
}
ans = dp[n];
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T &a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T &a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream &out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << endl;
}
template <class T>
void output(T x, ostream &out = cerr) {
output(x.begin(), x.end(), out);
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
vector<int> get_zero(int *a, int n) {
int lst = 0;
vector<int> res;
for (int i = 0; i <= n; ++i) {
if (i == n || a[i] == 1) {
if (lst) {
res.push_back(lst);
lst = 0;
}
}
if (i < n && a[i] == 0) {
lst++;
}
}
return res;
}
const long long MOD = 998244353;
const int mx = 3610;
int H, W, chips, used1[mx], used2[mx];
vector<int> v1, v2;
void read_and_parse() {
cin >> H >> W >> chips;
for (int i = 0; i < chips; ++i) {
int x1, Y1, x2, y2;
cin >> x1 >> Y1 >> x2 >> y2;
x1--;
Y1--;
x2--;
y2--;
used1[x1] = 1;
used1[x2] = 1;
used2[Y1] = 1;
used2[y2] = 1;
}
v1 = get_zero(used1, H);
v2 = get_zero(used2, W);
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
}
long long C[mx][mx];
void calc_C() {
for (int i = 0; i < mx; ++i) {
for (int j = 0; j < mx; ++j) {
if (j == 0) {
C[i][j] = 1;
continue;
}
if (i == 0) {
C[i][j] = 0;
continue;
}
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
}
}
long long get_C(int n, int k) {
if (n < k) {
return 0;
}
return C[n][k];
}
long long dp[mx][mx];
void calc_dp() {
for (int i = 0; i < mx; ++i) {
for (int j = 0; j < mx; ++j) {
if (j == 0) {
dp[i][j] = 1;
continue;
}
if (i == 0) {
dp[i][j] = 0;
continue;
}
dp[i][j] = dp[i - 1][j];
if (i >= 2) {
dp[i][j] = (dp[i][j] + dp[i - 2][j - 1]) % MOD;
}
}
}
}
vector<long long> get_dp(vector<int> &a, int l, int r, int sum) {
if (l > r) {
return {1};
}
if (l == r) {
return vector<long long>(dp[a[l]], dp[a[l]] + a[l] / 2 + 1);
}
int lsum = 0;
for (int i = l; i < r; ++i) {
lsum += a[i];
if (2 * lsum >= sum || i == r - 1) {
vector<long long> res_l = get_dp(a, l, i, lsum);
vector<long long> res_r = get_dp(a, i + 1, r, sum - lsum);
vector<long long> res((int)res_l.size() + (int)res_r.size() - 1);
for (int x = 0; x < res_l.size(); ++x) {
for (int y = 0; y < res_r.size(); ++y) {
res[x + y] = (res[x + y] + res_l[x] * res_r[y]) % MOD;
}
}
return res;
}
}
assert(0);
}
long long fact[mx];
signed main() {
fast_io();
fact[0] = 1;
for (int i = 1; i < mx; ++i) {
fact[i] = (fact[i - 1] * (long long)i) % MOD;
}
read_and_parse();
calc_C();
calc_dp();
int n = 0, m = 0;
for (auto x : v1) {
n += x;
}
for (auto x : v2) {
m += x;
}
vector<long long> dp1 = get_dp(v1, 0, (int)v1.size() - 1, n);
vector<long long> dp2 = get_dp(v2, 0, (int)v2.size() - 1, m);
long long ans = 0;
for (int k1 = 0; k1 < dp1.size(); ++k1) {
for (int k2 = 0; k2 < dp2.size(); ++k2) {
long long cnt1 = (dp1[k1] * get_C(n - 2 * k1, k2)) % MOD;
long long cnt2 = (dp2[k2] * get_C(m - 2 * k2, k1)) % MOD;
long long F = (fact[k1] * fact[k2]) % MOD;
ans = (ans + cnt1 * cnt2 % MOD * F % MOD) % MOD;
}
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops")
using namespace std;
const long long inf = (1ll << 60);
const long long iinf = 2147483647;
const long long mod = 1e9 + 7;
const long long maxn = 8000;
const double PI = acos(-1);
long long pw(long long x, long long p) {
long long ret = 1;
while (p > 0) {
if (p & 1) {
ret *= x;
ret %= mod;
}
x *= x;
x %= mod;
p >>= 1;
}
return ret;
}
long long inv(long long a) { return pw(a, mod - 2); }
long long cp[5005][5005];
bool leq[5005][5005];
long long dp[5005];
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string second;
cin >> second;
for (long long i = (0); i < (n + 2); i++)
for (long long j = (0); j < (n + 2); j++) cp[i][j] = 0, leq[i][j] = 1;
for (long long i = n - 1; i >= 0; --i) {
for (long long j = n - 1; j >= 0; --j) {
if (second[i] == second[j]) {
cp[i][j] = cp[i + 1][j + 1] + 1;
leq[i][j] = leq[i + 1][j + 1];
} else {
cp[i][j] = 0;
leq[i][j] = second[i] < second[j];
}
}
};
;
long long ret = 0;
for (long long i = 1; i <= n; ++i) {
dp[i] = 0;
for (long long j = 0; j < i; ++j) {
if (j == 0 || leq[j - 1][i - 1])
dp[i] =
max(dp[i], n - i + 1 + dp[j] - (j == 0 ? 0 : cp[i - 1][j - 1]));
}
ret = max(ret, dp[i]);
;
;
}
cout << ret << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const double pi = acos(-1.0);
const int maxn = (int)1e5 + 1;
struct dsu {
int pa[maxn];
int cnt[maxn];
int totalcnt;
int findpa(int id) {
if (pa[id] != id) pa[id] = findpa(pa[id]);
return pa[id];
}
void merge(int x, int y) {
int xpa = findpa(x), ypa = findpa(y);
if (xpa != ypa) {
pa[xpa] = ypa;
--totalcnt;
cnt[ypa] += cnt[xpa];
cnt[xpa] = 0;
}
}
void init(int n) {
totalcnt = n;
for (int(i) = (1); (i) <= (n); ++(i)) {
pa[i] = i;
cnt[i] = 1;
}
}
};
dsu solver;
inline bool lucky(const string& str) {
for (int(i) = (0); (i) < (str.length()); ++(i))
if (str[i] != '4' && str[i] != '7') return false;
return true;
}
int main() {
int n;
cin >> n;
solver.init(n);
for (int(i) = (0); (i) < (n - 1); ++(i)) {
int u, v;
string len;
cin >> u >> v >> len;
if (!lucky(len)) solver.merge(u, v);
}
long long ans = (long long)n * (n - 1) * (n - 2);
for (int(i) = (1); (i) <= (n); ++(i)) {
if (solver.cnt[i] > 1) {
long long m = solver.cnt[i];
ans -= (long long)m * (m - 1) * 2 * (n - m) + m * (m - 1) * (m - 2);
}
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long x1, x2, x3, y1, y2, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
cout << 3 << "\n";
cout << x1 + (x2 - x3) << " " << y1 + (y2 - y3) << "\n";
cout << x2 + (x3 - x1) << " " << y2 + (y3 - y1) << "\n";
cout << x3 + (x1 - x2) << " " << y3 + (y1 - y2) << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[5010], c[5010], sum[5010][5010];
int main() {
scanf("%d", &n);
int i, j, ans(0), num(0);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 1; i <= n; ++i) ++a[i];
for (i = 1; i <= n; ++i) {
memcpy(sum[i], sum[i - 1], sizeof(sum[i - 1]));
for (j = 1; j < i; ++j) {
int cnt =
((sum[i][a[i]] - sum[j][a[i]]) - (sum[i][a[j]] - sum[j][a[j]])) * 2;
if (a[i] < a[j]) cnt--;
if (cnt < ans) {
ans = cnt;
num = 1;
} else if (cnt == ans)
++num;
}
for (j = a[i]; j <= n; ++j) sum[i][j]++;
}
for (i = 1; i <= n; ++i) ans += i - sum[i][a[i]];
printf("%d %d\n", ans, num);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ll = long long;
template <class T>
struct Data {
inline const static T DEFAULT = numeric_limits<T>::max() / -2;
T sum, pref, suff, ans;
Data(T h = DEFAULT, T d = 0) {
ans = DEFAULT;
pref = h + d;
suff = h;
sum = d;
}
};
template <class T>
struct Combine {
Data<T> operator()(Data<T> l, Data<T> r) {
Data<T> res;
res.sum = l.sum + r.sum;
res.pref = max(l.pref + r.sum, r.pref);
res.suff = max(r.suff + l.sum, l.suff);
res.ans = max(max(l.ans, r.ans), l.pref + r.suff);
return res;
}
};
template <class T, class OP>
struct SegmentTree {
int n;
vector<T> t;
OP op;
SegmentTree(int n) : n(n), t(n << 1) {}
template <class U>
void Set(int i, U h, U d) {
t[i + n] = T(h, d);
}
void Build() {
for (int i = n - 1; i > 0; --i) t[i] = op(t[i << 1], t[i << 1 | 1]);
}
void Update(int p, T value) {
for (t[p += n] += value; p > 1; p >>= 1) t[p >> 1] = op(t[p], t[p ^ 1]);
}
T Query(int l, int r) {
T resl, resr;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) resl = op(resl, t[l++]);
if (r & 1) resr = op(t[--r], resr);
}
return op(resl, resr);
}
};
template <class T>
struct MX {
T operator()(T a, T b) { return max<T>(a, b); }
};
int main() {
cin.tie(0)->sync_with_stdio(0);
int n, q;
cin >> n >> q;
SegmentTree<Data<ll>, Combine<ll>> seg(2 * n);
vector<ll> d(n), h(n);
for (int i = 0; i < n; i++) cin >> d[i];
for (int i = 0; i < n; i++) cin >> h[i];
for (int i = 0; i < n; i++) {
seg.Set(i, 2 * h[i], d[i]);
seg.Set(i + n, 2 * h[i], d[i]);
}
seg.Build();
for (int i = 0; i < q; i++) {
int xl, xr;
cin >> xl >> xr;
xl--;
xr--;
if (xl <= xr) {
cout << seg.Query(xr + 1, xl + n).ans << '\n';
} else {
cout << seg.Query(xr + 1, xl).ans << '\n';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
char str[105];
scanf("%s", str);
int l = 0, r = 0, u = 0, d = 0;
for (int i = 0; i < n; i++)
if (str[i] == 'L')
l++;
else if (str[i] == 'R')
r++;
else if (str[i] == 'U')
u++;
else if (str[i] == 'D')
d++;
printf("%d\n", min(l, r) * 2 + min(u, d) * 2);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[212121];
vector<pair<long long, long long>> edge[212121];
long long ans = 0, mod = 1e9 + 7;
long long is_cent[212121];
long long S[212121], cent;
void mk_s(long long w, long long bef) {
S[w] = 1;
for (auto [nxt, ncol] : edge[w]) {
if (is_cent[nxt]) continue;
if (nxt == bef) continue;
mk_s(nxt, w);
S[w] += S[nxt];
}
}
long long get_cent(long long w, long long bef, long long all) {
for (auto [nxt, ncol] : edge[w]) {
if (is_cent[nxt]) continue;
if (nxt == bef) continue;
if (S[nxt] > all / 2) return get_cent(nxt, w, all);
}
return w;
}
vector<pair<long long, long long>> G[212121];
vector<long long> cnt[212121], SUM[212121];
void mk_G(long long w, long long bef, long long bef_col, long long sum,
long long trans, long long rep) {
G[rep].push_back({sum, trans});
for (auto [nxt, ncol] : edge[w]) {
if (is_cent[nxt]) continue;
if (nxt == bef) continue;
mk_G(nxt, w, ncol, (sum + a[nxt]) % mod, trans + (ncol != bef_col), rep);
}
}
void decomp(long long w) {
mk_s(w, -1);
long long cent = get_cent(w, -1, S[w]);
is_cent[cent] = 1;
vector<long long> ALLcnt[2], ALLS[2];
ALLcnt[0].resize(S[w], 0);
ALLS[0].resize(S[w], 0);
ALLcnt[1].resize(S[w], 0);
ALLS[1].resize(S[w], 0);
for (auto [nxt, ncol] : edge[cent]) {
if (is_cent[nxt]) continue;
G[nxt].clear();
mk_G(nxt, cent, ncol, a[nxt], 0, nxt);
long long mxt = 0;
for (auto [sum, trans] : G[nxt]) {
ALLcnt[ncol][trans]++;
mxt = max(mxt, trans);
}
cnt[nxt].clear();
cnt[nxt].resize(mxt + 1, 0);
SUM[nxt].clear();
SUM[nxt].resize(mxt + 1, 0);
for (auto [sum, trans] : G[nxt]) cnt[nxt][trans]++;
for (long long i = 0; i <= mxt; i++) {
SUM[nxt][i] += cnt[nxt][i];
if (i > 0) SUM[nxt][i] += SUM[nxt][i - 1];
}
}
for (long long i = 0; i < ALLcnt[0].size(); i++) {
ALLS[0][i] = ALLcnt[0][i] + (i > 0 ? ALLS[0][i - 1] : 0);
ALLS[1][i] = ALLcnt[1][i] + (i > 0 ? ALLS[1][i - 1] : 0);
}
long long allcount = 0;
for (auto [nxt, ncol] : edge[cent]) {
if (is_cent[nxt]) continue;
for (auto [sum, trans] : G[nxt]) {
if (k - trans >= 0) {
long long SnxtIdx = k - trans;
long long ncolIdx = k - trans;
if (SnxtIdx >= SUM[nxt].size()) SnxtIdx = SUM[nxt].size() - 1;
if (ncolIdx >= ALLS[ncol].size()) ncolIdx = ALLS[ncol].size() - 1;
long long gaesu = ALLS[ncol][ncolIdx] - SUM[nxt][SnxtIdx];
allcount += gaesu;
ans += sum * (gaesu % mod) % mod;
ans %= mod;
}
if (k - trans - 1 >= 0) {
long long ncolIdx = k - trans - 1;
if (ncolIdx >= ALLS[ncol].size()) ncolIdx = ALLS[ncol].size() - 1;
long long gaesu = ALLS[!ncol][ncolIdx];
allcount += gaesu;
ans += sum * (gaesu % mod) % mod;
ans %= mod;
}
}
}
allcount /= 2;
allcount %= mod;
allcount++;
for (auto [nxt, ncol] : edge[cent]) {
if (is_cent[nxt]) continue;
for (auto [sum, trans] : G[nxt]) {
if (trans <= k) {
ans = (ans + sum) % mod;
allcount++;
}
}
}
ans += allcount * a[cent];
ans %= mod;
for (auto [nxt, ncol] : edge[cent]) {
if (is_cent[nxt]) continue;
decomp(nxt);
}
}
int main() {
long long i, j;
scanf("%lld%lld", &n, &k);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (i = 0; i < n - 1; i++) {
long long s, e, col;
scanf("%lld%lld%lld", &s, &e, &col);
edge[s].push_back({e, col});
edge[e].push_back({s, col});
}
decomp(1);
printf("%lld\n", ans % mod);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long c(long long x) { return x * x * x; }
long long m[19 + 1];
int main(int argc, char *argv[]) {
long long M;
cin >> M;
long long cur = 1;
long long i = 0;
while (m[i] <= M && i < 19) {
while (m[i] + c(cur) >= c(cur + 1)) cur++;
m[i + 1] = m[i] + c(cur);
i++;
}
--i;
long long ans1 = i;
cur = 100000;
long long ans2 = 0;
while (cur && i) {
long long cc = c(cur);
if (cc > M) {
--cur;
continue;
}
if (M - cc >= m[i - 1]) {
ans2 += cc;
M -= cc;
--i;
} else {
M = cc - 1;
--cur;
}
}
cout << ans1 << " " << ans2 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int* a = new int[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int time = 0, c = 0;
for (int i = 0; i < n; i++) {
if (time <= a[i]) {
c++;
time += a[i];
}
}
printf("%d", c);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
char poster[101];
char* move[3] = {"PRINT", "LEFT\n", "RIGHT\n"};
scanf("%d%d", &n, &k);
scanf("%s", poster);
int left = k - 1, right = n - k;
if (left <= right)
for (int i = 0; i < left; i++) printf(move[1]);
else
for (int i = 0; i < right; i++) printf(move[2]);
int d1 = left <= right ? 2 : 1;
int d2 = d1 == 1 ? -1 : 1;
for (int i = d1 == 2 ? 0 : n - 1; i >= 0 && i < n; i += d2) {
printf("%s %c\n", move[0], poster[i]);
if (d2 == 1 && i != n - 1)
printf(move[d1]);
else if (d2 == -1 && i != 0)
printf(move[d1]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ans2;
void calc(int &a1, int &a2, int &a3, int &b1, int &b2, int &b3, int type) {
int d1, d2, d3;
if (type == 1) {
d1 = min(a1, b1);
a1 -= d1, b1 -= d1;
}
if (type == 2) {
d2 = min(a2, b2);
a2 -= d2, b2 -= d2;
}
if (type == 3) {
d3 = min(a3, b3);
a3 -= d3, b3 -= d3;
}
if (type == 4) {
d1 = min(b1, a2);
b1 -= d1, a2 -= d1;
}
if (type == 5) {
d2 = min(b2, a3);
b2 -= d2, a3 -= d2;
}
if (type == 6) {
d3 = min(b3, a1);
b3 -= d3, a1 -= d3;
}
ans2 = min(ans2, min(a1, b2) + min(a2, b3) + min(a3, b1));
}
void help(vector<int> order, int a1, int a2, int a3, int b1, int b2, int b3) {
if (order.size() == 6) {
for (int i : order) calc(a1, a2, a3, b1, b2, b3, i);
return;
}
for (int i = 1; i <= 6; i++) {
order.push_back(i);
help(order, a1, a2, a3, b1, b2, b3);
order.pop_back();
}
}
void solve() {
int n;
cin >> n;
int a1, a2, a3, b1, b2, b3;
cin >> a1 >> a2 >> a3 >> b1 >> b2 >> b3;
int ans1 = min(a1, b2) + min(a2, b3) + min(a3, b1);
ans2 = n;
help({}, a1, a2, a3, b1, b2, b3);
cout << ans2 << ' ' << ans1 << endl;
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
int n, s1, s2, a[N];
bool check(int x) {
int l = a[n] - x, r = a[n] + x;
for (int i = n - 1; i >= 1; i--) {
if (l <= a[i] && a[i] <= r)
l = a[i] - x, r = a[i] + x;
else {
l = max(a[i] - x, l);
r = min(a[i] + x, r);
if (l > r) return 0;
}
}
return (l <= s1 && s1 <= r) || (l <= s2 && s2 <= r);
}
int main() {
scanf("%d%d%d", &n, &s1, &s2);
if (s1 < s2) swap(s1, s2);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
int l = s1 - s2, r = (int)1e9, ans;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d[107][107], s, b, k;
struct spaceship {
int x, a, f, p;
} sp[100007];
struct base {
int x, d, g;
} ba[100007];
vector<int> v[107];
bool cmp(int x, int y) { return ba[x].d < ba[y].d; }
vector<pair<int, int> > u[107];
long long val[100007];
int e, head[100007], nxt[1000007], to[1000007], op[1000007];
long long cap[1000007];
void add_edge(int x, int y, long long c) {
nxt[++e] = head[x], to[head[x] = e] = y;
cap[e] = c, op[e] = e + 1;
nxt[++e] = head[y], to[head[y] = e] = x;
cap[e] = 0, op[e] = e - 1;
}
int S, T, nodes, dis[100007], cnt[100007];
long long sap(int x, long long delta) {
if (x == T) return delta;
long long sum = 0;
int mindis = nodes;
for (int i = head[x]; i; i = nxt[i]) {
if (cap[i] && dis[x] == dis[to[i]] + 1) {
long long save = sap(to[i], min(cap[i], delta - sum));
sum += save, cap[i] -= save, cap[op[i]] += save;
if (dis[S] >= nodes || sum == delta) return sum;
}
if (cap[i]) mindis = min(mindis, dis[to[i]]);
}
if (!sum)
if (!--cnt[dis[x]])
dis[S] = nodes;
else
++cnt[dis[x] = mindis + 1];
return sum;
}
long long max_flow() {
long long res = 0;
while (dis[S] < nodes) res += sap(S, 100000000000007LL);
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) d[i][j] = 107;
for (int i = 1, x, y; i <= m; ++i) {
scanf("%d%d", &x, &y);
if (x == y) continue;
d[x][y] = d[y][x] = 1;
}
for (int t = 1; t <= n; ++t)
for (int i = 1; i <= n; ++i)
if (i != t)
for (int j = 1; j <= n; ++j)
if (j != t && j != i) d[i][j] = min(d[i][j], d[i][t] + d[t][j]);
scanf("%d%d%d", &s, &b, &k);
for (int i = 1; i <= s; ++i)
scanf("%d%d%d%d", &sp[i].x, &sp[i].a, &sp[i].f, &sp[i].p);
for (int i = 1; i <= b; ++i) {
scanf("%d%d%d", &ba[i].x, &ba[i].d, &ba[i].g);
v[ba[i].x].push_back(i);
}
for (int i = 1; i <= n; ++i) {
sort(v[i].begin(), v[i].end(), cmp);
int mx = 0;
for (int j : v[i]) {
mx = max(mx, ba[j].g);
u[i].push_back(make_pair(ba[j].d, mx));
}
}
for (int i = 1; i <= s; ++i) {
val[i] = -100000000000007LL;
for (int j = 1; j <= n; ++j)
if (d[sp[i].x][j] < 107 && d[sp[i].x][j] <= sp[i].f) {
int t = -1, l = 0, r = u[j].size() - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (u[j][mid].first <= sp[i].a)
t = mid, l = mid + 1;
else
r = mid - 1;
}
if (t != -1) val[i] = max(val[i], 1LL * u[j][t].second - sp[i].p);
}
}
S = 0, T = s + 1, nodes = s + 2;
long long ans = 0;
for (int i = 1; i <= s; ++i)
if (val[i] > 0)
ans += val[i], add_edge(S, i, val[i]);
else if (val[i] < 0)
add_edge(i, T, -val[i]);
for (int i = 1, x, y; i <= k; ++i)
scanf("%d%d", &x, &y), add_edge(x, y, 100000000000007LL);
ans -= max_flow();
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
int n, k = 1;
long long ans = 0, gs;
cin >> n;
for (long long i = 3; i <= n; i += 2) {
gs = k * (4 * i - 4);
ans = ans + gs;
k++;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int MaxCap = 0, cap = 0;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
cap = cap - a;
cap = cap + b;
MaxCap = max(MaxCap, cap);
}
cout << MaxCap << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
vector<int> pos(n);
vector<double> speed(n);
for (int i = 0; i < n; ++i) cin >> pos[i];
for (int i = 0; i < n; ++i) {
double a;
cin >> a;
speed[i] = a;
}
double ret = INT_MAX, beg = 0, end = 1000000001;
while (end - beg > 1e-6) {
double mid = (beg + end) / 2.0;
bool ok = false;
vector<pair<double, int>> v;
for (int i = 0; i < n; ++i) {
v.emplace_back(pos[i] - speed[i] * mid, 1);
v.emplace_back(pos[i] + speed[i] * mid, -1);
}
sort(v.begin(), v.end());
int maxi = 0;
for (auto& i : v) {
maxi += i.second;
if (maxi == n) {
ok = true;
ret = min(ret, mid);
break;
}
}
if (ok)
end = mid;
else
beg = mid;
}
cout << ret;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using std::memset;
char s[510][510];
int f[2][510][510], ans, n, m;
const int P = 1e9 + 7;
inline bool pd(int x, int y, int xx, int yy) {
if (x == xx && y == yy) return 1;
if (x == xx && y + 1 == yy) return 1;
if (x + 1 == xx && y == yy) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (register int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
if (s[1][1] == s[n][m])
f[1][1][n] = 1;
else {
puts("0");
return 0;
}
for (register int i = 1; i <= n; i++) {
for (register int j = 1; 2 * (i + j) <= m + n + 2; j++)
for (register int k = n; k >= i; k--)
if (s[i][j] == s[k][n + m - k - i - j + 2]) {
f[i & 1][j][k] = (f[i & 1][j][k] + f[i & 1][j - 1][k]) % P;
f[i & 1][j][k] = (f[i & 1][j][k] + f[(i + 1) & 1][j][k]) % P;
f[i & 1][j][k] = (f[i & 1][j][k] + f[i & 1][j - 1][k + 1]) % P;
f[i & 1][j][k] = (f[i & 1][j][k] + f[(i + 1) & 1][j][k + 1]) % P;
if (pd(i, j, k, n + m - k - i - j + 2))
ans = (ans + f[i & 1][j][k]) % P;
}
memset(f[(i + 1) & 1], 0, sizeof(f[(i + 1) & 1]));
}
printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:128777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 1000007;
const int MAX2 = 200000;
const int BASE = 1000000007;
const int MOD = 1000000007;
const int CNT = 1000;
vector<int> l[MAX];
vector<int> r[MAX];
char s[10];
vector<int> res;
bool ok = 1;
void solve(int L, int R) {
if (L > R) return;
if (l[L].size() == 0) {
res.push_back(L);
solve(L + 1, R);
return;
}
if (r[L].size() == 0) {
solve(L + 1, R);
res.push_back(L);
return;
}
int rr = L;
int ll = R;
for (int i = (0); i < (l[L].size()); ++i) {
rr = max(rr, l[L][i] + 1);
}
for (int i = (0); i < (r[L].size()); ++i) {
ll = min(ll, r[L][i]);
}
int pos = L + 1;
while (pos != rr && rr <= ll) {
for (int i = (0); i < (l[pos].size()); ++i) {
rr = max(rr, l[pos][i] + 1);
}
for (int i = (0); i < (r[pos].size()); ++i) {
rr = max(rr, r[pos][i] + 1);
}
++pos;
}
if (rr > ll) {
ok = 0;
return;
}
solve(L + 1, rr - 1);
res.push_back(L);
solve(rr, R);
}
int main() {
int n, c;
cin >> n >> c;
for (int i = (0); i < (c); ++i) {
int a, b;
scanf("%d%d%s", &a, &b, &s);
--a;
--b;
if (s[0] == 'L') {
l[a].push_back(b);
}
if (s[0] == 'R') {
r[a].push_back(b);
}
if (a >= b) {
printf("IMPOSSIBLE\n");
return 0;
}
}
solve(0, n - 1);
if (!ok) {
printf("IMPOSSIBLE\n");
return 0;
}
for (int i = (0); i < (res.size()); ++i) {
printf("%d ", res[i] + 1);
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long sumOf(long long x) { return (x * (x + 1)) / 2; }
int main(void) {
long long x, k;
long long ans;
scanf("%lld %lld", &x, &k);
if (x == 1) {
printf("0");
return 0;
}
if (k >= (x / 2)) {
printf("%lld\n", sumOf(x - 1));
return 0;
} else {
ans = 2 * k * x - sumOf(2 * k);
printf("%lld\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[30], b[30], k[30], p[30];
int n, u, r;
long long ans = -1000000000000000000;
void go(int x, int pmask, int c[]) {
if (x > u || (u - x) & 1) {
long long sum = 0;
for (int i = 0; i < n; i++) sum += c[i] * k[i];
ans = max(ans, sum);
if (x > u) return;
}
int d[30];
for (int j = 0; j < n; j++)
if (pmask)
d[j] = c[p[j] - 1] + r;
else
d[j] = c[j] ^ b[j];
if (pmask) go(x + 1, 0, d);
go(x + 1, 1, d);
}
int main() {
cin >> n >> u >> r;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++) cin >> k[i];
for (int i = 0; i < n; i++) cin >> p[i];
go(1, 0, a);
go(1, 1, a);
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long mulmod(long long a, long long b) {
long long res = 0;
a = a % mod;
while (b > 0) {
if (b % 2 == 1) res = (res + a) % mod;
a = (a * 2) % mod;
b /= 2;
}
return res % mod;
}
long long power(long long x, long long y) {
long long res = 1;
x = (x % mod);
while (y > 0) {
if (y & 1) {
res = mulmod(res, x);
}
y = y >> 1;
x = mulmod(x, x);
}
return res;
}
long long binCoefficient(long long n, long long r) {
long long num = 1;
long long den = 1;
for (long long i = 0; i < r; i++) {
num = mulmod(num, n - i);
den = mulmod(den, i + 1);
}
return (((num % mod) * (power(den, mod - 2))) % mod);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long getCeil(long long a, long long b) {
if (a % b == 0)
return (a / b);
else
return ((a / b) + 1);
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long a[n], i, j, cost = 0;
for (i = 0; i < n; i++) cin >> a[i];
vector<pair<long long, long long>> v;
for (i = 1; i <= 100; i++) {
cost = 0;
for (j = 0; j < n; j++) {
if (a[j] > i)
cost += a[j] - i - 1;
else if (a[j] < i)
cost += i - 1 - a[j];
}
v.push_back(make_pair(cost, i));
}
sort(v.begin(), v.end());
cout << v[0].second << " " << v[0].first << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * (1e9);
const int mod = 1e9 + 7;
class TheCardShufflingDivTwo {
public:
int shuffle(int n, int m) {}
};
int main() {
int n, a, b;
string s;
cin >> n >> a >> b >> s;
int ok = -1;
int cntr = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '.') {
if (ok == 1) {
if (a > 0) {
a--;
cntr++;
}
ok = 0;
} else if (ok == 0) {
if (b > 0) {
b--;
cntr++;
}
ok = 1;
} else {
if (a > b && a > 0) {
a--;
cntr++;
ok = 0;
} else if (b > 0) {
b--;
cntr++;
ok = 1;
}
}
} else {
ok = -1;
}
}
cout << cntr << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, pt[205], blen = 1000000000;
long long a[205];
string ba, bb;
int main() {
scanf("%d", &N);
int tN = N;
for (int R = 3; R <= 9; R++) {
N = tN;
for (int i = 0; i < 200; i++) a[i] = 1;
for (int i = 0; i < R; i++) {
for (int j = 1; j < 200; j++) a[j] += a[j - 1];
}
memset(pt, 0, sizeof(pt));
int mx = 0;
while (N > 0) {
int pos = upper_bound(a, a + 200, N) - a - 1;
mx = max(mx, pos);
N -= a[pos];
pt[pos]++;
}
string a, b;
int len = 0;
for (int i = 0; i <= mx; i++) {
for (int j = 0; j < R; j++) a += (char)('a' + j);
for (int j = 0; j < pt[i]; j++) a += (char)('a' + R);
len += R + pt[i];
}
for (int j = 0; j <= R; j++) b += (char)('a' + j);
if (len < blen) {
blen = len;
ba = a;
bb = b;
}
}
printf("%s %s\n", ba.c_str(), bb.c_str());
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
int cost = 0;
if (e > f) {
cost += min(a, d) * e;
d -= min(a, d);
cost += min(b, min(c, d)) * f;
} else {
cost += min(b, min(c, d)) * f;
d -= min(b, min(c, d));
cost += min(a, d) * e;
}
cout << cost;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
int a[1000006], n, k;
int vis[2006], ans[2006], val[2006];
int main() {
while (~scanf("%d%d", &k, &n)) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
n = unique(a, a + n) - a;
for (int i = 0; i < n; i++) a[i] -= k;
memset(vis, 0, sizeof(vis));
memset(ans, 0, sizeof(ans));
if (a[0] * a[n - 1] > 0) {
printf("-1\n");
continue;
}
int top = 1, last = 1;
for (int i = 0; i < n; i++) {
val[top++] = a[i];
vis[a[i] + 1000] = 1;
ans[a[i] + 1000] = 1;
}
while (last != top && !vis[1000]) {
for (int i = 0; i < n; i++) {
if (abs(val[last] + a[i]) <= 1000 && !vis[val[last] + a[i] + 1000]) {
val[top++] = val[last] + a[i];
vis[val[last] + a[i] + 1000] = 1;
ans[val[last] + a[i] + 1000] = ans[val[last] + 1000] + 1;
}
}
last++;
}
printf("%d\n", vis[1000] ? ans[1000] : -1);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 999999999;
const int MAXN = 610;
int w[MAXN];
int countt[2 * MAXN];
int m, t, r;
int ans = 0;
bool lighted[2 * MAXN];
void light(int i) {
++ans;
lighted[i] = true;
for (int j = i; j <= i + t - 1; j++) countt[j]++;
}
int main() {
scanf("%d%d%d", &m, &t, &r);
if (r > t) {
puts("-1");
return 0;
}
for (int i = 0; i < m; i++) {
scanf("%d", w + i);
w[i] += 600;
}
sort(w, w + m);
for (int i = w[0] - r + 1; i <= w[0]; i++) light(i);
for (int i = 1; i < m; i++) {
int req = r - countt[w[i]];
int j = w[i];
while (!lighted[j] && req > 0) {
light(j);
j--;
req--;
}
if (req > 0) {
puts("-1");
return 0;
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
scanf("%d", &k);
if (k & 1) {
k /= 2;
if (k <= 17) {
printf("4");
for (int i = 0; i < k; ++i) printf("8");
} else
puts("-1");
} else {
k /= 2;
if (k <= 18) {
for (int i = 0; i < k; ++i) printf("8");
} else
puts("-1");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int p[100005], q[100005], k[100005];
void solve(int x) {
if (x == 0) return;
int i, l, t = 1;
while (t * 2 <= x) t <<= 1;
l = 2 * t - 1 - x;
for (i = l; i <= x; i++) p[i] = x + l - i;
solve(l - 1);
}
int main() {
int i, j, n, t, pos, cnt;
cin >> n;
if (n & 1)
puts("NO");
else {
solve(n);
puts("YES");
for (i = 1; i <= n; i++) cout << p[i] << " ";
puts("");
}
t = 1;
while (t * 2 <= n) t = t * 2;
if (t == n)
puts("NO");
else {
if (n <= 5) puts("NO");
if (n == 6) {
puts("YES");
puts("3 6 1 5 4 2");
}
if (n >= 7) {
q[1] = 7;
q[2] = 3;
q[3] = 2;
q[4] = 5;
q[5] = 6;
q[6] = 4;
q[7] = 1;
pos = 8;
while (pos <= n) {
cnt = 0;
for (i = pos; i <= min(pos + pos - 1, n); i++) k[++cnt] = i;
for (j = pos; j < min(pos + pos - 1, n); j++) q[j] = k[j - pos + 2];
q[min(pos + pos - 1, n)] = k[1];
pos = min(pos + pos - 1, n) + 1;
}
puts("YES");
for (i = 1; i <= n; i++) cout << q[i] << " ";
puts("");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char s[n + 2];
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
for (int j = 1; j <= i / 2; j++) {
swap(s[j], s[i - j + 1]);
}
}
}
for (int i = 1; i <= n; i++) cout << s[i];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, L[200000], R[200000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> L[i] >> R[i];
}
sort(L, L + N);
sort(R, R + N);
int ret = 0;
cin >> M;
for (int i = 0; i < M; i++) {
int A, B;
cin >> A >> B;
ret = max(ret, A - R[0]);
ret = max(ret, L[N - 1] - B);
}
cout << ret << endl;
}
| 1 |
/***Farhan132***/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dd;
typedef vector<ll> vll;
typedef pair<ll , ll> ii;
typedef vector< ii > vii;
typedef pair < pair < ll , ll > , pair < ll , ll > > cm;
#define ff first
#define ss second
#define pb push_back
#define in insert
#define f0(b) for(int i=0;i<(b);i++)
#define f00(b) for(int j=0;j<(b);j++)
#define f1(b) for(int i=1;i<=(b);i++)
#define f11(b) for(int j=1;j<=(b);j++)
#define f2(a,b) for(int i=(a);i<=(b);i++)
#define f22(a,b) for(int j=(a);j<=(b);j++)
#define sf(a) scanf("%lld",&a)
#define sff(a,b) scanf("%lld %lld", &a , &b)
#define pf(a) printf("%lld\n",a)
#define pff(a,b) printf("%lld %lld\n", a , b)
#define PI 3.14159265359
#define bug printf("**!\n")
#define mem(a , b) memset(a, b ,sizeof(a))
#define front_zero(n) __builtin_clzll(n)
#define back_zero(n) __builtin_ctzll(n)
#define total_one(n) __builtin_popcountll(n)
#define clean fflush(stdout)
const ll mod = (ll)1e9 + 7;
const ll maxn = (ll)1e5 + 5;
const int nnn = 1048590;
const int inf = numeric_limits<int>::max()-1;
//const ll INF = numeric_limits<ll>::max()-1;
const ll INF = 1e18;
ll dx[]={0,1,0,-1};
ll dy[]={1,0,-1,0};
ll dxx[]={0,1,0,-1,1,1,-1,-1};
ll dyy[]={1,0,-1,0,1,-1,1,-1};
map < string , ll > mp;
string s[maxn];
vector < string > g;
vector < char > make;
ll n , m , k;
vector < ll > v[maxn];
void go(string &s, ll pos = 0){
if(pos == 0){
g.clear();
}
if(pos == k){
string S = "";
for(auto u : make) S += u;
g.pb(S);
return;
}
make.pb(s[pos]);
go(s, pos+1);
make.pop_back();
make.pb('_');
go(s, pos+1);
make.pop_back();
return;
}
ll out[maxn];
void solve(){
cin >> n >> m >> k;
f1(n){
cin >> s[i];
mp[s[i]] = i;
out[i] = 0;
}
ll cnt =0 ;
for(ll i = 1; i <= m; i++){
string S;
ll pos;
cin >> S >> pos;
go(S);
bool ok = 0;
for(auto u : g){
if(s[pos] == u) ok = 1;
}
if(!ok){
cout << "NO\n";
return;
}
for(auto u : g){
if(mp[u] == 0 || s[pos] == u) continue;
v[pos].pb(mp[u]);
out[mp[u]]++;
}
}
queue < ll > q;
for(ll i = 1; i <= n; i++){
if(out[i] == 0) q.push(i);
}
vector < ll > ans;
while(q.size()){
ll node = q.front();
q.pop();
ans.pb(node);
for(auto u : v[node]){
out[u]--;
if(!out[u])q.push(u);
}
}
if(ans.size() != n){
cout << "NO\n";
return;
}
cout << "YES\n";
for(auto u : ans) cout << u << ' ';
return;
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#else
// freopen("cbarn2.in", "r", stdin);
// freopen("cbarn2.out", "w", stdout);
ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL);
#endif
//cout << fixed << setprecision(10);
// work();
// mem(b,0);
ll T;
T=1;
//cin >> T;
//scanf("%lld",&T);
// ll CT = 0;
//work();
while(T--){
//cout << "Case " << ++CT <<": " ;
//printf("Case %lld: ",++CT);
solve();
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3000, M = 1000000, inf = 0x3f3f3f3f;
struct node {
int to, nxt, flow;
} edge[M];
int head[N], cur[N], dep[N], a[N][N], cnt, n, S, T, h, m, tot, ans;
void pre() {
memset(head, -1, sizeof(head));
cnt = -1;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return x * f;
}
void add(int u, int v, int w) {
edge[++cnt] = (node){v, head[u], w};
head[u] = cnt;
edge[++cnt] = (node){u, head[v], 0};
head[v] = cnt;
}
bool bfs() {
memset(dep, 0, sizeof(dep));
dep[S] = 1;
queue<int> q;
q.push(S);
memcpy(cur, head, sizeof(head));
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; ~i; i = edge[i].nxt) {
int v = edge[i].to, f = edge[i].flow;
if (f && !dep[v]) dep[v] = dep[u] + 1, q.push(v);
}
}
return dep[T];
}
int dfs(int u, int lim) {
if (!lim || u == T) return lim;
int addflow = 0, flow;
for (int i = cur[u]; ~i; i = edge[i].nxt) {
cur[u] = i;
int v = edge[i].to, f = edge[i].flow;
if (dep[v] == dep[u] + 1 && (flow = dfs(v, min(lim, f)))) {
addflow += flow;
lim -= flow;
edge[i].flow -= flow;
edge[i ^ 1].flow += flow;
if (!lim) break;
}
}
return addflow;
}
int Dinic() {
int maxflow = 0;
while (bfs()) maxflow += dfs(S, inf);
return maxflow;
}
int main() {
pre();
n = read();
h = read();
m = read();
tot = 0;
ans = n * h * h;
S = n * (h + 1) + m + 1;
T = S + 1;
for (register int i = (1); i <= (n); ++i)
for (register int j = (0); j <= (h); ++j) a[i][j] = ++tot;
for (register int i = (1); i <= (n); ++i) add(S, a[i][0], inf);
for (register int i = (1); i <= (n); ++i)
for (register int j = (1); j <= (h); ++j)
add(a[i][j - 1], a[i][j], h * h - (j - 1) * (j - 1));
while (m--) {
int l = read(), r = read(), x = read(), c = read();
if (x == h) continue;
tot++;
x++;
for (register int i = (l); i <= (r); ++i) add(a[i][x], tot, inf);
add(tot, T, c);
}
printf("%d\n", ans - Dinic());
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(const T &a) {
return a * a;
}
int k, x, n, m;
long long a[200], b[200], c[200], d[200], e[200];
int main() {
scanf("%d%d%d%d", &k, &x, &n, &m);
b[1] = b[2] = 1;
c[1] = c[2] = 1;
d[1] = 0, d[2] = 1;
e[1] = 1, e[2] = 2;
for (int i = 3; i < 60; i++)
b[i] = b[i - 1] + b[i - 2], c[i] = c[i - 1] + c[i - 2] + (i % 2),
d[i] = d[i - 1] + d[i - 2] + (1 - i % 2), e[i] = e[i - 1] + e[i - 2] + 1;
for (int i = 0; i < n / 2 + 1; i++)
for (int j = 0; j < m / 2 + 1; j++) {
a[0] = i, a[1] = j;
for (int l = 2; l < k; l++) a[l] = a[l - 1] + a[l - 2];
if (a[k - 1] == x) {
for (int l = 0; l < i; l++) printf("AC");
for (int l = 0; l < n - 2 * i; l++) printf("X");
puts("");
for (int l = 0; l < j; l++) printf("AC");
for (int l = 0; l < m - 2 * j; l++) printf("X");
return 0;
}
if (a[k - 1] == x - c[k - 3] && 2 * i + 1 <= n && 2 * j + 1 <= m) {
printf("C");
for (int l = 0; l < i; l++) printf("AC");
for (int l = 0; l < n - 2 * i - 1; l++) printf("X");
puts("");
for (int l = 0; l < j; l++) printf("AC");
for (int l = 0; l < m - 2 * j; l++) printf("A");
return 0;
}
if (a[k - 1] == x - b[k - 2] && 2 * i != n && 2 * j != m) {
for (int l = 0; l < i; l++) printf("AC");
for (int l = 0; l < n - 2 * i - 1; l++) printf("X");
printf("A");
puts("");
printf("C");
for (int l = 0; l < j; l++) printf("AC");
for (int l = 0; l < m - 2 * j - 1; l++) printf("X");
return 0;
}
if (a[k - 1] == x - c[k - 4] && 2 * j + 2 <= m) {
for (int l = 0; l < i; l++) printf("AC");
for (int l = 0; l < n - 2 * i; l++) printf("X");
puts("");
printf("C");
for (int l = 0; l < j; l++) printf("AC");
for (int l = 0; l < m - 2 * j - 2; l++) printf("X");
printf("A");
return 0;
}
if (a[k - 1] == x - c[k - 2] && 2 * i + 1 <= n && 2 * j + 2 <= m) {
for (int l = 0; l < i; l++) printf("AC");
for (int l = 0; l < n - 2 * i - 1; l++) printf("X");
printf("A");
puts("");
printf("C");
for (int l = 0; l < j; l++) printf("AC");
for (int l = 0; l < m - 2 * j - 2; l++) printf("X");
printf("A");
return 0;
}
if (a[k - 1] == x - d[k - 2] && 2 * i + 2 <= n && 2 * j + 1 <= m) {
printf("C");
for (int l = 0; l < i; l++) printf("AC");
for (int l = 0; l < n - 2 * i - 2; l++) printf("X");
printf("A");
puts("");
for (int l = 0; l < j; l++) printf("AC");
for (int l = 0; l < m - 2 * j - 1; l++) printf("X");
printf("A");
return 0;
}
if (a[k - 1] == x - e[k - 2] && 2 * i + 2 <= n && 2 * j + 2 <= m) {
printf("C");
for (int l = 0; l < i; l++) printf("AC");
for (int l = 0; l < n - 2 * i - 2; l++) printf("X");
printf("A");
puts("");
printf("C");
for (int l = 0; l < j; l++) printf("AC");
for (int l = 0; l < m - 2 * j - 2; l++) printf("X");
printf("A");
return 0;
}
}
puts("Happy new year!");
}
| 6 |
#include <bits/stdc++.h>
int64_t solve(int64_t n) {
if (n == 0) {
return 0;
}
int64_t count = 0;
int64_t base = 0;
int64_t tmp = n;
int64_t last = 0;
while (tmp != 0) {
count += 1;
base = base * 10 + 1;
last = tmp;
tmp /= 10;
}
int64_t ten = base - base / 10;
int64_t last2 = 0;
tmp = base * 10 + 1 - n;
while (tmp != 0) {
last2 = tmp;
tmp /= 10;
}
int64_t result =
std::min(last * count + solve(std::abs(last * base - n)),
count + 1 + last2 * count +
solve(std::abs(base * 10 + 1 - n - last2 * base)));
if (n - (last - 1) * base < ten) {
result = std::min(
result, (last - 1) * count + solve(std::abs((last - 1) * base - n)));
}
return result;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int64_t n;
std::cin >> n;
std::cout << solve(n) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200005];
int main() {
scanf("%d", &n);
int bz = (int)sqrt(n), bs = (n + bz - 1) / bz, tim = 0;
for (int j = 1; j <= bz; ++j)
for (int i = bs - 1; i != -1; --i)
if (i * bz + j <= n) a[i * bz + j] = ++tim;
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int arr[200001];
int width[200001];
int k;
int solve(int ret, int segments) {
sort(width, width + segments);
for (int i = 0; i < segments && k >= 0; i++)
if (k - width[i] > -1)
ret -= 2, k -= width[i];
else
break;
return ret;
}
int main() {
bool flag = false;
int n, windays = 0, segments = 0, count = 0;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
if (arr[i] < 0) {
if (arr[i - 1] > -1 && i > 0 && windays) width[segments++] = count;
count = 0, windays++;
} else if (windays)
if (i == n - 1)
width[segments++] = ++count, flag = true;
else
count++;
}
if (windays > k)
printf("-1\n");
else if (!windays)
printf("0\n");
else {
int ret = (segments)*2;
k -= windays;
if (flag) {
ret = solve(ret, segments - 1);
if (k - width[segments - 1] > -1) ret--;
} else
ret = solve(ret, segments) + 1;
printf("%d\n", ret);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long A[8][3];
long long sqr(long long x) { return x * x; }
long long dist(int x, int y) {
long long res = 0;
for (int i = 0; i < 3; i++) {
res += sqr(A[x][i] - A[y][i]);
}
return res;
}
int need[4] = {0, 12, 12, 4};
vector<long long> v;
bool eval() {
long long mn = *min_element((v).begin(), (v).end());
if (mn == 0) {
return false;
}
int a[4] = {0, 0, 0, 0};
for (long long x : v) {
if (x % mn) {
return false;
}
x /= mn;
if (1 <= x && x <= 3) {
if (++a[x] > need[x]) {
return false;
}
} else {
return false;
}
}
return true;
}
void go(int x) {
if (x == 8) {
if (eval()) {
puts("YES");
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 3; j++) {
printf("%lld ", A[i][j]);
}
puts("");
}
exit(0);
}
return;
}
do {
for (int i = 0; i < x; i++) {
v.push_back(dist(i, x));
}
go(x + 1);
v.erase(v.end() - x, v.end());
} while (next_permutation(A[x], A[x] + 3));
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 3; j++) {
scanf("%lld", &A[i][j]);
}
sort(A[i], A[i] + 3);
}
go(0);
puts("NO");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, s;
cin >> n >> s;
long long a = n;
long long sum = 0;
long long ans = 0;
long long d = 0;
while (a > 0) {
a = a / 10;
d++;
}
for (long long i = 0; i < d; i++) {
sum = 0;
long long aa = n;
while (aa > 0) {
sum += aa % 10;
aa = aa / 10;
}
if (sum > s) {
long long di = n % 10;
n = n / 10;
if (di > 0) {
sum = sum - di;
n++;
long long z = 1;
for (long long j = 0; j < i; j++) {
z = z * 10;
}
ans += z * (10 - di);
}
}
}
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 10;
int n, m, k, mxlvl, ans;
int a[maxn];
vector<pair<int, int> > e[maxn];
bool vis[maxn];
int q[maxn];
int dis[maxn];
vector<int> pre[maxn];
vector<int> level[maxn];
int fa[maxn];
char s[maxn];
void print(int a[], int n, int st = 0) {
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", a[i + st]);
}
printf("\n");
}
void init() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(make_pair(v, i));
e[v].push_back(make_pair(u, i));
}
}
void bfs(int root) {
int st = 0, ed = 0;
for (int i = 1; i <= n; i++) dis[i] = 1e8;
q[st] = root;
dis[root] = 0;
vis[root] = true;
mxlvl = 0;
while (st <= ed) {
int u = q[st++], d = dis[u];
level[d].push_back(u);
mxlvl = max(mxlvl, d);
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first;
if (!vis[v]) {
vis[v] = true;
q[++ed] = v;
dis[v] = d + 1;
}
if (dis[v] >= d + 1) pre[v].push_back(u);
}
}
}
void output() {
for (int i = 0; i < m; i++) s[i] = '0';
s[m] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 0; j < e[i].size(); j++) {
if (e[i][j].first == fa[i]) s[e[i][j].second] = '1';
}
}
printf("%s\n", s);
}
void dfs_by_level(int lvl, int id) {
if (lvl > mxlvl) {
ans++;
if (ans > k) exit(0);
output();
return;
}
int u = level[lvl][id];
for (auto pa : pre[u]) {
fa[u] = pa;
if (id < level[lvl].size() - 1)
dfs_by_level(lvl, id + 1);
else
dfs_by_level(lvl + 1, 0);
}
}
void doit() {
bfs(1);
long long tot = 1;
for (int i = 2; i <= n; i++) {
tot *= pre[i].size();
if (tot >= k) break;
}
if (tot >= k)
printf("%d\n", k);
else
printf("%lld\n", tot);
ans = 0;
dfs_by_level(1, 0);
}
int main() {
init();
doit();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
double sqr(double a) { return a * a; }
struct Point {
double x, y;
Point(const double &x = 0, const double &y = 0) : x(x), y(y) {}
Point operator+(const Point &B) const { return Point(x + B.x, y + B.y); }
Point operator-(const Point &B) const { return Point(x - B.x, y - B.y); }
double operator*(const Point &B) const { return x * B.y - y * B.x; }
double Dis(const Point &B) const { return sqr(x - B.x) + sqr(y - B.y); }
} P[205];
int c[205], cnt_l, sz[205];
struct mat {
double a[205][205];
mat(int d = 0) {
memset(a, 0, sizeof a);
for (int i = (1), LIM = (n); i <= LIM; i++) a[i][i] = d;
}
mat operator*(const mat &B) const {
mat r;
for (int i = (1), LIM = (n); i <= LIM; i++)
for (int j = (1), LIM = (n); j <= LIM; j++)
for (int k = (1), LIM = (n); k <= LIM; k++)
r.a[i][k] += a[i][j] * B.a[j][k];
return r;
}
} A[14];
double ar[205];
vector<vector<int> > qL;
int main() {
scanf("%d", &n);
for (int i = (1), LIM = (n); i <= LIM; i++) scanf("%lf%lf", &P[i].x, &P[i].y);
for (int i = (1), LIM = (n); i <= LIM; i++) {
memset(c, 0, sizeof c);
memset(sz, 0, sizeof sz);
cnt_l = 0;
for (int j = (1), LIM = (n); j <= LIM; j++)
if (j ^ i && !c[j]) {
++cnt_l;
c[j] = cnt_l, sz[cnt_l] = 2;
for (int k = (1), LIM = (n); k <= LIM; k++)
if (k ^ i && !c[k] && fabs((P[k] - P[i]) * (P[j] - P[i])) < 1e-8)
c[k] = cnt_l, sz[cnt_l]++;
}
for (int j = (1), LIM = (n); j <= LIM; j++)
if (j ^ i) A[0].a[j][i] += 1.0 / cnt_l / sz[c[j]];
for (int j = (1), LIM = (cnt_l); j <= LIM; j++)
A[0].a[i][i] += 1.0 / cnt_l / sz[j];
}
for (int i = (1), LIM = (13); i <= LIM; i++) A[i] = A[i - 1] * A[i - 1];
int q;
scanf("%d", &q);
for (int i = (1), LIM = (n); i <= LIM; i++)
for (int j = (i + 1), LIM = (n); j <= LIM; j++) {
bool ER = 0;
for (int k = (1), LIM = (j - 1); k <= LIM; k++)
if (k != i && k != j && fabs((P[k] - P[i]) * (P[j] - P[i])) < 1e-8) {
ER = 1;
break;
}
if (!ER) {
vector<int> r;
r.push_back(i), r.push_back(j);
for (int k = (j + 1), LIM = (n); k <= LIM; k++)
if (fabs((P[k] - P[i]) * (P[j] - P[i])) < 1e-8) r.push_back(k);
qL.push_back(r);
}
}
for (; q--;) {
int t, m;
scanf("%d%d", &t, &m);
m--;
for (int i = (1), LIM = (n); i <= LIM; i++) ar[i] = (i == t);
for (int i = 13; i >= 0; i--)
if (m >> i & 1) {
static double p[205];
for (int j = (1), LIM = (n); j <= LIM; j++) {
p[j] = 0;
for (int k = (1), LIM = (n); k <= LIM; k++)
p[j] += ar[k] * A[i].a[k][j];
}
for (int j = (1), LIM = (n); j <= LIM; j++) ar[j] = p[j];
}
double ans = 0;
for (auto r : qL) {
double sm = 0;
for (auto u : r) sm += ar[u];
ans = max(ans, sm / r.size());
}
printf("%.10lf\n", ans);
}
}
| 9 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL);
#define pll pair<ll,ll>
#define MP make_pair
#define ff first
#define ss second
#define PB push_back
#define mod 1000000007
#define lp(i,start,end) for(ll i=start;i<=end;i++)
#define deb1(a) cout<<#a<<" = "<<(a)<<endl;
#define deb2(a,b) cout<<#a<<" = "<<(a)<<", "<<#b<<" = "<<(b)<<endl;
#define deb3(a,b,c) cout<<#a<<" = "<<(a)<<", "<<#b<<" = "<<(b)<<", "<<#c<<" = "<<(c)<<endl;
ll modu(ll a, ll b)
{
ll ans =1;
a=a%mod;
while(b>0)
{
if(b&1)
ans = (ans*a)%mod;
b/=2;
a = (a*a)%mod;
}
return ans;
}
int main()
{
fastio
ll t;
cin>>t;
while(t--){
ll n,k;
cin>>n>>k;
ll p=0;
for(ll i=0; i<n; i++){
ll q=p^i;
cout<<q<<endl;
p=p^q;
ll v;
cin>>v;
if(v)
break;
}
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int ar[200010], us[200010], used[200010];
int t[10][1000000], a, b;
void iz(int to, int tv, int tl, int tr, int l, int r, int el) {
if (l > r) return;
if (tl == l && tr == r) {
t[to][tv] = t[to][tv] + el;
if (to == 1) t[to][tv] = min(t[to][tv], b);
if (to == 2) t[to][tv] = min(t[to][tv], a);
return;
}
int tm = (tl + tr) / 2;
iz(to, tv * 2, tl, tm, l, min(r, tm), el);
iz(to, tv * 2 + 1, tm + 1, tr, max(l, tm + 1), r, el);
t[to][tv] = t[to][tv * 2] + t[to][tv * 2 + 1];
}
int ans(int to, int tv, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return t[to][tv];
int tm = (tl + tr) / 2;
return ans(to, tv * 2, tl, tm, l, min(r, tm)) +
ans(to, tv * 2 + 1, tm + 1, tr, max(tm + 1, l), r);
}
int main() {
int n, k, t, l, x, y, i, kol = 0;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &t);
for (i = 1; i <= t; i++) {
scanf("%d", &l);
if (l == 1) {
scanf("%d%d", &x, &y);
iz(1, 1, 1, n, x, x, y);
iz(2, 1, 1, n, x, x, y);
} else {
scanf("%d", &x);
printf("%d\n", ans(1, 1, 1, n, 1, x - 1) + ans(2, 1, 1, n, x + k, n));
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int INF = 1e8 + 7;
const int MOD = 1e9 + 7;
const long long LINF = 1e17 + 7;
const double Pi = acos(-1.);
const double EPS = 1e-8;
vector<int> b[N];
int n, m, s, e, a[N], f[N][301];
int calc(int pos, int val) {
int nxt = upper_bound(b[val].begin(), b[val].end(), pos) - b[val].begin();
return nxt == ((int)(b[val].size())) ? INF : b[val][nxt];
}
int main() {
scanf("%d%d%d%d", &n, &m, &s, &e);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= m; ++i) {
int x;
scanf("%d", &x);
b[x].push_back(i);
}
int MJ = s / e;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= MJ; ++j) f[i][j] = INF;
f[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= min(i, MJ); ++j)
if (f[i][j] < m) {
f[i + 1][j] = min(f[i + 1][j], f[i][j]);
f[i + 1][j + 1] = min(f[i + 1][j + 1], calc(f[i][j], a[i + 1]));
}
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= min(i, MJ); ++j)
if (i + f[i][j] + j * e <= s) {
ans = max(ans, j);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200010];
int C[400020];
void jl(int x) {
for (int i = x; i < 400020; i += i & -i) C[i]++;
}
long long s(int x) {
long long sum = 0;
for (int i = x; i > 0; i -= i & -i) sum += C[i];
return sum;
}
long long cj(int k) {
memset(C, 0, sizeof(C));
jl(n + 1);
int ct = 0;
long long sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] <= k)
ct -= 1;
else
ct += 1;
sum += s(ct + n);
jl(ct + n + 1);
}
return sum;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
cout << cj(m - 1) - cj(m) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, u;
cin >> n >> u;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int p1 = n - 1;
int p2 = n - 3;
bool bobol = false;
double ans = -1;
while (p1 > 0 && p2 >= 0) {
while (p1 - p2 < 2) p2--;
while (p2 >= 0 && a[p1] - a[p2] <= u) {
double test = (a[p1] - a[p2 + 1]) * 1.0 / (a[p1] - a[p2]);
if (test > ans) {
bobol = true;
ans = test;
}
if (p2)
p2--;
else
break;
}
p1--;
}
if (!bobol) {
cout << "-1\n";
return 0;
}
cout << fixed;
cout << setprecision(10) << ans;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.