solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 998244353;
int n, a[N];
int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
int mul(int x, int y) { return 1ll * x * y % mod; }
struct node {
int sum, l, r, tagp, tagm;
} tr[N << 5];
int cnt, Rt;
void pushup(int k) { tr[k].sum = add(tr[tr[k].l].sum, tr[tr[k].r].sum); }
void change(int &k, int l, int r, int vp, int vm) {
if (!k) k = ++cnt, tr[k].tagm = 1;
tr[k].sum = mul(tr[k].sum, vm);
tr[k].sum = add(tr[k].sum, mul(r - l + 1, vp));
tr[k].tagp = mul(tr[k].tagp, vm);
tr[k].tagp = add(tr[k].tagp, vp);
tr[k].tagm = mul(tr[k].tagm, vm);
}
void pushdown(int k, int l, int r) {
change(tr[k].l, l, (l + r) / 2, tr[k].tagp, tr[k].tagm);
change(tr[k].r, (l + r) / 2 + 1, r, tr[k].tagp, tr[k].tagm);
tr[k].tagp = 0;
tr[k].tagm = 1;
}
void add(int &k, int l, int r, int ql, int qr, int v) {
if (ql > qr || qr < l || ql > r) return;
if (!k) k = ++cnt, tr[k].tagm = 1;
if (ql <= l && qr >= r) {
change(k, l, r, v, 1);
return;
}
pushdown(k, l, r);
add(tr[k].l, l, (l + r) / 2, ql, qr, v);
add(tr[k].r, (l + r) / 2 + 1, r, ql, qr, v);
pushup(k);
}
void multi(int &k, int l, int r, int ql, int qr, int v) {
if (ql > qr || qr < l || ql > r) return;
if (!k) k = ++cnt, tr[k].tagm = 1;
if (ql <= l && qr >= r) {
change(k, l, r, 0, v);
return;
}
pushdown(k, l, r);
multi(tr[k].l, l, (l + r) / 2, ql, qr, v);
multi(tr[k].r, (l + r) / 2 + 1, r, ql, qr, v);
pushup(k);
}
int query(int k, int l, int r, int ql, int qr) {
if (ql > qr || qr < l || ql > r || !k) return 0;
if (ql <= l && qr >= r) return tr[k].sum;
pushdown(k, l, r);
return add(query(tr[k].l, l, (l + r) / 2, ql, qr),
query(tr[k].r, (l + r) / 2 + 1, r, ql, qr));
}
int main() {
scanf("%d", &n);
int maxx = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), maxx = max(maxx, a[i]);
add(Rt, 1, maxx, 1, a[1], 1);
for (int i = 2; i <= n; i++) {
int tmp = query(Rt, 1, maxx, 1, a[i - 1]);
multi(Rt, 1, maxx, 1, min(a[i], a[i - 1]), mod - 1);
multi(Rt, 1, maxx, a[i] + 1, maxx, 0);
add(Rt, 1, maxx, 1, a[i], tmp);
}
printf("%d\n", query(Rt, 1, maxx, 1, a[n]));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 251;
const int inf = 0x3f3f3f3f;
class Solution {
public:
long long diamonds(int n, long long m, long long k, vector<int> a) {
long long ans = 0;
if (n == 1) {
ans = a[0];
if ((long long)m * k < ans) ans = min(ans, m * k);
return ans;
}
if ((n & 1) == 0) return 0;
long long d = (n + 1) >> 1;
if (m < d) return 0;
long long out = (long long)(m / d) * k;
ans = a[0];
for (int i = 0; i < n; i += 2) ans = min(ans, (long long)a[i]);
ans = min(ans, (out));
return ans;
}
};
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> a;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
a.push_back(t);
}
Solution tester;
cout << tester.diamonds(n, m, k, a);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
int mox[8] = {1, 0, 0, -1, 1, -1, 1, -1};
int moy[8] = {0, -1, 1, 0, -1, -1, 1, 1};
char mover[4] = {'D', 'L', 'R', 'U'};
const long long INF = 1LL << 61;
const int inf = 2e9;
const long double PI = acos(-1.0);
const long double EPS = 1e-9;
bool debug;
using namespace std;
void solve();
int main() {
debug = 0;
cout.precision(30);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand((unsigned)time(NULL));
solve();
if (debug)
cout << '\n'
<< '\n'
<< "time: " << clock() * 1.0 / CLOCKS_PER_SEC * 1000 << " ms" << '\n';
}
const int N = 100005;
const int MAGIC = 420;
double la[N];
int all[N], n, h, a, w, b;
vector<pair<double, double> > q;
bool check(int len, int a, int b) {
double needH = log(a / h + (a % h != 0));
double needW = log(b / w + (b % w != 0));
int n1 = len / 2;
int n2 = len - n1;
q.clear();
for (int mask = 0; mask < (1 << n1); mask++) {
double H = 0, W = 0;
for (int j = 0; j < n1; j++) {
if (mask & (1 << j))
H += la[j];
else
W += la[j];
}
q.push_back({H, W});
}
sort(q.begin(), q.end());
for (int i = (int)q.size() - 2; i >= 0; i--)
q[i].second = max(q[i].second, q[i + 1].second);
for (int mask = 0; mask < (1 << n2); mask++) {
double H = 0, W = 0;
for (int j = 0; j < n2; j++) {
if (mask & (1 << j))
H += la[j + n1];
else
W += la[j + n1];
}
double ostH = needH - H;
double ostW = needW - W;
pair<double, double> tmp = {ostH - EPS, -1.0};
auto it = lower_bound(q.begin(), q.end(), tmp);
if (it != q.end() && it->second >= ostW - EPS) return 1;
}
return 0;
}
void solve() {
scanf("%d%d%d%d%d", &a, &b, &h, &w, &n);
for (int i = 0; i < n; i++) {
scanf("%d", &all[i]);
}
sort(all, all + n);
reverse(all, all + n);
n = min(n, 40);
for (int i = 0; i < n; i++) la[i] = log(all[i]);
if (h >= a && w >= b) return void(cout << 0 << '\n');
if (h >= b && w >= a) return void(cout << 0 << '\n');
for (int i = 0; i <= 1; i++) {
if (h >= a && w * all[0] >= b) return void(cout << 1 << '\n');
if (h * all[0] >= a && w >= b) return void(cout << 1 << '\n');
swap(a, b);
}
int le = 1, ri = n;
if (!check(n, a, b) && !check(n, b, a)) return void(cout << -1 << '\n');
while (ri - le > 1) {
int mid = (le + ri) >> 1;
if (!check(mid, a, b) && !check(mid, b, a))
le = mid;
else
ri = mid;
}
cout << ri << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300005;
int n;
char s[MAX_N];
bool f(int l, int r) {
for (int x = l; x <= r; x++)
for (int k = 1; x + 2 * k <= r; k++)
if (s[x] == s[x + k] && s[x] == s[x + 2 * k]) return true;
return false;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
long long ans = 0;
for (int l = 1; l <= n; l++) {
ans += max(0, n - (l + 8) + 1);
for (int r = l + 2; r <= n && r - l + 1 < 9; r++)
if (f(l, r)) ans++;
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m[500005], pos, ans;
long long dp[500005], dp1[500005], mx;
stack<pair<int, int> > s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &m[i]);
while (!s.empty() and s.top().first > m[i]) s.pop();
if (s.empty())
pos = 0;
else
pos = s.top().second;
dp[i] = dp[pos] + 1ll * (i - pos) * m[i];
s.push({m[i], i});
}
while (!s.empty()) s.pop();
for (int i = n; i >= 1; i--) {
while (!s.empty() and s.top().first > m[i]) s.pop();
if (s.empty())
pos = n + 1;
else
pos = s.top().second;
dp1[i] = dp1[pos] + 1ll * (pos - i) * m[i];
s.push({m[i], i});
if (dp[i] + dp1[i] - m[i] > mx) {
mx = dp[i] + dp1[i] - m[i];
ans = i;
}
}
for (int i = ans - 1; i >= 1; i--) m[i] = min(m[i], m[i + 1]);
for (int i = ans + 1; i <= n; i++) m[i] = min(m[i - 1], m[i]);
for (int i = 1; i <= n; i++) printf("%d ", m[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int val[15][4];
int main() {
int n, m, k, s;
scanf("%d %d %d %d", &n, &m, &k, &s);
for (int i = 0; i < 10; i++)
for (int j = 0; j < 4; j++) val[i][j] = -100000;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int tem;
scanf("%d", &tem);
val[tem][0] = max(val[tem][0], i + j);
val[tem][1] = max(val[tem][1], -i + j);
val[tem][2] = max(val[tem][2], i - j);
val[tem][3] = max(val[tem][3], -i - j);
}
int ans = 0, last = -1;
for (int i = 0; i < s; i++) {
int tem;
scanf("%d", &tem);
if (last == -1) {
last = tem;
continue;
}
ans = max(ans, val[tem][0] + val[last][3]);
ans = max(ans, val[tem][1] + val[last][2]);
ans = max(ans, val[tem][2] + val[last][1]);
ans = max(ans, val[tem][3] + val[last][0]);
last = tem;
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime[1200000];
int cntPrime[1200000];
int cntHuiwen[1200000];
FILE *out1 = fopen("out1.txt", "w");
FILE *out2 = fopen("out2.txt", "w");
bool ishuiwen(int n) {
int t = 0;
int a = n;
while (n) {
t = t * 10 + n % 10;
n /= 10;
}
return t == a;
}
void init() {
int i, j;
memset(isPrime, true, sizeof(isPrime));
isPrime[0] = isPrime[1] = false;
for (int i = 2; i < 1200000; i++) {
if (isPrime[i]) {
for (int j = 2; i * j < 1200000; j++) {
isPrime[i * j] = false;
}
}
}
cntPrime[0] = 0;
for (int i = 1; i < 1200000; i++) {
cntPrime[i] = cntPrime[i - 1];
if (isPrime[i]) cntPrime[i]++;
}
}
void init2() {
cntHuiwen[0] = 0;
for (int i = 1; i < 1200000; i++) {
cntHuiwen[i] = cntHuiwen[i - 1];
if (ishuiwen(i)) cntHuiwen[i]++;
}
}
int main() {
init();
init2();
int q, p;
while (cin >> p >> q) {
int s = 1;
int e = 1200000 - 1;
while (s <= e) {
int m = (s + e) / 2;
if (cntPrime[m] * q > cntHuiwen[m] * p)
e = m - 1;
else
s = m + 1;
}
s = s - 1;
int ans = s;
int len = 20;
for (int i = 1; i <= 8888; i++) {
if (cntPrime[s + i] * q <= cntHuiwen[s + i] * p) ans = s + i;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int x = n;
vector<int> dels2;
vector<int> dels;
map<int, int> arr;
for (int i = 2; i <= sqrt((long double)n); ++i) {
while (x % i == 0) {
dels.push_back(i);
x /= i;
}
}
if (x != 1) {
dels.push_back(x);
}
int minPos = 1e9;
for (int i = (n / dels[dels.size() - 1] - 1) * dels[dels.size() - 1] + 1;
i <= n; ++i) {
int z = i;
int count = 0;
for (int k = 2; k <= sqrt((long double)z); ++k) {
while (z % k == 0) {
z /= k;
count++;
if (((i / k) - 1) * k < minPos) minPos = ((i / k) - 1) * k;
}
}
if (z != 1 && count > 0) {
if ((i / z - 1) * z < minPos) minPos = (i / z - 1) * z;
}
}
cout << minPos + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(9);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int m;
int up = 3000000, down = 0, mid = 200000;
int a[19], s;
int main() {
cin >> m;
a[0] = 1;
for (int i = 1; i <= 10; i++) {
a[i] = a[i - 1] * 5;
}
while (mid != down) {
s = 0;
for (int i = 1; i <= 10; i++) {
s = s + (mid / a[i]);
}
if (s <= m) {
down = mid;
mid = (mid + up) / 2;
} else {
up = mid;
mid = (mid + down) / 2;
}
}
s = 0;
for (int i = 1; i <= 10; i++) {
s = s + (mid / a[i]);
}
if (s == m) {
cout << 5 << endl;
mid = (mid / 5) * 5;
for (int i = 0; i < 5; i++) {
cout << mid + i << ' ';
}
} else {
cout << 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double esp = 1e-7;
const double pi = acos(-1.0);
const int maxx = 1101000;
const int mod = int(1e9 + 7);
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[100000], *p1 = buf + 100000, *pend = buf + 100000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 100000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(int &x) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
}
inline void readll(long long int &x) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
}
inline void reads(char *s) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
s[0] = ch;
for (int i = 1; (!blank(ch = nc())); ++i) {
s[i] = ch;
}
}
}; // namespace fastIO
int a[110];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
int cnt = 0;
int minn = a[0];
int maxn = a[n - 1];
bool yes = false;
for (int i = 0; i < 101; ++i) {
int ye = true;
for (int j = 0; j < n; ++j) {
if (a[j] == a[0] || a[j] - i == a[0] + i || a[j] == a[0] + i) {
continue;
} else {
ye = false;
break;
}
}
if (ye) {
yes = true;
cnt = i;
break;
}
}
if (!yes)
cout << -1 << endl;
else
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int par[3001][3001];
long long sub[3001][3001];
long long dp[3001][3001];
int n;
vector<int> vertices[3001];
void dfs(int x, int f, int root) {
par[root][x] = f;
sub[root][x] = 1;
for (auto i : vertices[x]) {
if (i == f) continue;
dfs(i, x, root);
sub[root][x] += sub[root][i];
}
}
long long solve(int u, int v) {
if (u == v) return 0;
if (~dp[u][v]) return dp[u][v];
return dp[u][v] = sub[u][v] * sub[v][u] +
max(solve(u, par[u][v]), solve(v, par[v][u]));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
vertices[u].push_back(v);
vertices[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
dfs(i, i, i);
}
long long ans = 0;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
ans = max(ans, solve(i, j));
}
printf("%lld", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 100000000;
struct coord {
short x, y, color;
coord(int _x, int _y, int _color) {
x = _x;
y = _y;
color = _color;
}
coord() {
x = 0;
y = 0;
}
};
vector<string> g;
vector<vector<vector<int>>> d;
coord first, second, third;
int n, m;
bool check(coord v) {
if (v.x >= 1 && v.x <= n && v.y >= 1 && v.y <= m && g[v.x][v.y] != '#')
return true;
else
return false;
}
void run_edge(coord v, int dir_x, int dir_y, deque<coord>& q) {
coord to = v;
to.x += dir_x;
to.y += dir_y;
if (check(to)) {
if (g[to.x][to.y] >= '1' && g[to.x][to.y] <= '3') {
if (d[to.x][to.y][to.color] > d[v.x][v.y][v.color]) {
d[to.x][to.y][to.color] = d[v.x][v.y][v.color];
q.push_front(to);
}
} else {
if (d[to.x][to.y][to.color] > d[v.x][v.y][v.color] + 1) {
d[to.x][to.y][to.color] = d[v.x][v.y][v.color] + 1;
q.push_back(to);
}
}
}
}
void solve() {
d.assign(n + 1, vector<vector<int>>(m + 1, vector<int>(4, INF)));
deque<coord> q;
q.push_back(first);
q.push_back(second);
q.push_back(third);
d[first.x][first.y][1] = 0;
d[second.x][second.y][2] = 0;
d[third.x][third.y][3] = 0;
while (!q.empty()) {
coord v = q.front();
q.pop_front();
run_edge(v, 0, 1, q);
run_edge(v, 1, 0, q);
run_edge(v, 0, -1, q);
run_edge(v, -1, 0, q);
}
int ans = INF;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (ans > d[i][j][1] + d[i][j][2] + d[i][j][3] - (g[i][j] == '.') * 2) {
ans = d[i][j][1] + d[i][j][2] + d[i][j][3] - (g[i][j] == '.') * 2;
}
}
}
if (ans >= INF)
cout << -1;
else
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
g.assign(n + 1, string(m + 1, ' '));
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
for (int j = 1; j <= m; ++j) {
g[i][j] = s[j - 1];
if (g[i][j] == '1') {
first.x = i;
first.y = j;
first.color = 1;
}
if (g[i][j] == '2') {
second.x = i;
second.y = j;
second.color = 2;
}
if (g[i][j] == '3') {
third.x = i;
third.y = j;
third.color = 3;
}
}
}
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, m1, h2, m2;
scanf("%d:%d", &h1, &m1);
scanf("%d:%d", &h2, &m2);
int u = h1 * 60 + m1;
int v = h2 * 60 + m2;
int w = (u + v) / 2;
printf("%02d:%02d\n", w / 60, w % 60);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long m = 1000000007) {
if (b == 0) return 1;
if (b == 1) return a;
long long res = power(a, b / 2, m);
res = (res * res) % m;
if (b & 1) res = (res * a) % m;
return res;
}
long long modinv(long long a, long long m = 1000000007) {
return power(a, m - 2, m);
}
long long add(long long a, long long b, long long m = 1000000007) {
long long c = (a % m + b % m);
if (c >= m) c -= m;
return c;
}
long long sub(long long a, long long b, long long m = 1000000007) {
long long c = (a % m - b % m);
if (c < 0) c += m;
return c;
}
long long mul(long long a, long long b, long long m = 1000000007) {
return (a * b) % m;
}
long long odd(long long x) {
if (x % 2 == 0) x--;
return x;
}
long long even(long long x) {
if (x % 2) x--;
return x;
}
void solve() {
long long n, ans = 0, i;
cin >> n;
vector<long long> a(n, 0), l(n, 0), le(n, 0), ri(n, 0), r(n, 0);
for (i = 1; i < n; i++) cin >> a[i];
for (i = 1; i < n; i++) {
l[i] = max(le[i - 1], l[i - 1]) + odd(a[i]);
le[i] = le[i - 1] + even(a[i]);
if (a[i] == 1) le[i] = 0;
}
for (i = n - 2; i > 0; i--) {
r[i] = max(ri[i + 1], r[i + 1]) + odd(a[i + 1]);
ri[i] = ri[i + 1] + even(a[i + 1]);
if (a[i + 1] == 1) ri[i] = 0;
}
for (i = 1; i < n; i++) ans = max({ans, ri[i] + l[i], le[i] + r[i]});
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
for (long long i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T Bitcnt(T a) {
int sum = 0;
while (a) {
if (a & 1) sum++;
a /= 2;
}
return sum;
}
template <class T>
T Max3(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
T Lcm(T a, T b) {
T tmp = __gcd(a, b);
return (a / tmp) * b;
}
template <class T>
T Pow(T a, T b) {
T ans = 1;
T base = a;
while (b) {
if (b & 1) ans = (ans * base);
base = (base * base);
b /= 2;
}
return ans;
}
long long Bigmod(long long a, long long b) {
long long res = 1;
long long pw = a % 1000000007LL;
while (b > 0) {
if (b & 1) res = (res * pw) % 1000000007LL;
pw = (pw * pw) % 1000000007LL;
b /= 2;
}
return res;
}
int a_x[] = {1, -1, 0, 0};
int a_y[] = {0, 0, 1, -1};
long long X, Y;
void extend_euclid(long long a, long long b) {
if (b == 0) {
X = 1;
Y = 0;
return;
}
extend_euclid(b, a % b);
long long x, y;
x = Y;
y = X - (a / b) * Y;
X = x;
Y = y;
}
long long inverse_modulo(long long a, long long b) {
extend_euclid(a, b);
return (X + 1000000007LL) % 1000000007LL;
}
int main() {
int n;
cin >> n;
if (n == 1)
cout << -1;
else
cout << n << " " << (n + 1) << " " << n * (n + 1) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c = 1023, n, num;
char x;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> num;
if (x == '|') a |= num, b -= b & num, c -= (c & num);
if (x == '^') b ^= num;
if (x == '&') a &= num, b &= num, c &= num;
}
cout << 3 << endl << "& " << c << " | " << a << " ^ " << b;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007LL;
const int SIZE = 35010;
int n, k;
int a[SIZE], cnt_pref[SIZE], pred[SIZE];
int prev_exist[SIZE];
int t[SIZE * 4], add[SIZE * 4];
struct segment_tree {
int n;
void build(int v, int vl, int vr, vector<int>& a) {
if (vl == vr) {
t[v] = a[vl];
return;
}
int vm = (vl + vr) / 2;
build(2 * v + 1, vl, vm, a);
build(2 * v + 2, vm + 1, vr, a);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}
segment_tree(vector<int>& a) {
n = a.size();
memset(t, 0, 4 * n * 4);
memset(add, 0, 4 * n * 4);
build(0, 0, n - 1, a);
}
void push(int v, int vl, int vr) {
if (add[v]) {
t[v] += add[v];
if (vl != vr) {
add[2 * v + 1] += add[v];
add[2 * v + 2] += add[v];
}
add[v] = 0;
}
}
int query(int v, int vl, int vr, int l, int r) {
push(v, vl, vr);
if (r < vl || vr < l) {
return -INF;
}
if (l <= vl && vr <= r) {
return t[v];
}
int vm = (vl + vr) / 2;
int ql = query(2 * v + 1, vl, vm, l, r);
int qr = query(2 * v + 2, vm + 1, vr, l, r);
return max(ql, qr);
}
void modify(int v, int vl, int vr, int l, int r, int val) {
push(v, vl, vr);
if (r < vl || vr < l) {
return;
}
if (l <= vl && vr <= r) {
add[v] = val;
push(v, vl, vr);
return;
}
int vm = (vl + vr) / 2;
modify(2 * v + 1, vl, vm, l, r, val);
modify(2 * v + 2, vm + 1, vr, l, r, val);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
vector<vector<int> > d(k + 1, vector<int>(n + 1, -INF));
int count_uniqie = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (prev_exist[a[i]] == 0) {
pred[i] = -1;
++count_uniqie;
} else
pred[i] = prev_exist[a[i]];
prev_exist[a[i]] = i;
cnt_pref[i] = count_uniqie;
}
for (int i = 1; i <= n; ++i) {
d[1][i] = cnt_pref[i];
}
for (int box = 2; box <= k; ++box) {
vector<int> a = d[box - 1];
for (int i = 1; i < box - 1; ++i) {
a[i] = -INF;
d[box][i] = -INF;
}
a[box - 1] = d[box - 1][box - 1];
d[box][box - 1] = -INF;
for (int i = box; i <= n; ++i) {
a[i] = d[box - 1][i];
}
segment_tree sgt(a);
for (int i = box; i <= n; ++i) {
int r = i;
int l = (pred[i] == -1 ? 1 : pred[i]);
sgt.modify(0, 0, sgt.n - 1, l, r - 1, 1);
d[box][i] = sgt.query(0, 0, sgt.n - 1, 1, r - 1);
}
}
cout << d[k][n];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 993244853;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {-1, -2, 1, -2, 2, -1, 2, 1}, ddy[] = {-2, -1, -2, 1, -1, 2, 1, 2};
vector<pair<int, int> > v[1005];
bitset<1005> L[1005];
int parent[1005], depth[1005], t[1005];
int LCA[1005][1005];
int lca(int x, int y) {
if (x == y) return x;
int &ret = LCA[x][y];
if (~ret) return ret;
if (depth[x] > depth[y]) return ret = lca(parent[x], y);
return ret = lca(x, parent[y]);
}
void dfs(int N, int p = -1) {
parent[N] = p;
if (v[N].size() == 1) {
L[N][N] = 1;
return;
}
for (auto P : v[N]) {
if (P.first == p) continue;
depth[P.first] = depth[N] + 1;
t[P.first] = P.second;
dfs(P.first, N);
L[N] |= L[P.first];
}
}
void upd(int x, int y, int c) {
int u = lca(x, y);
int tt = x;
while (tt != u) {
t[tt] -= c;
tt = parent[tt];
}
tt = y;
while (tt != u) {
t[tt] -= c;
tt = parent[tt];
}
}
int main() {
memset((LCA), -1, sizeof(LCA));
;
int n;
scanf("%d", &n);
for (int(i) = (1); (i) <= (n - 1); (i) += (1)) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
v[x].push_back(make_pair(y, z));
v[y].push_back(make_pair(x, z));
}
int R = -1;
for (int(i) = (1); (i) <= (n); (i) += (1)) {
if (v[i].size() == 2) {
if (v[i][0].second != v[i][1].second) return !printf("NO");
}
if (v[i].size() > 2) R = i;
}
if (R == -1) {
puts("YES");
puts("1");
int x = -1, y = -1;
for (int(i) = (1); (i) <= (n); (i) += (1))
if (v[i].size() == 1) {
y = x, x = i;
}
return !printf("%d %d %d\n", x, y, v[1][0].second);
}
dfs(R);
vector<int> vv;
for (int(i) = (1); (i) <= (n); (i) += (1)) {
if (v[i].size() == 1 && t[i] & 1) vv.push_back(i);
}
if (vv.size() & 1) return !printf("NO");
for (int(i) = (0); (i) <= ((int)vv.size() - 2); (i) += (2)) {
upd(vv[i], vv[i + 1], 1);
}
for (int(i) = (1); (i) <= (n); (i) += (1)) {
if (i == R) continue;
if (t[i] & 1) return !printf("NO");
}
puts("YES");
vector<tuple<long long, long long, long long> > ans;
for (int(i) = (0); (i) <= ((int)vv.size() - 2); (i) += (2))
ans.push_back(tuple<int, int, int>(vv[i], vv[i + 1], 1));
vector<int> leaf;
for (int(i) = (1); (i) <= (n); (i) += (1)) {
if (v[i].size() == 1) leaf.push_back(i);
}
for (int(i) = (1); (i) <= ((int)leaf.size() - 1); (i) += (1)) {
int x = leaf[0], y = leaf[i];
int c = t[y];
upd(x, y, c);
ans.push_back(tuple<int, int, int>(x, y, c));
}
if (t[leaf[0]] != 0) {
int w = leaf[0], x = leaf[1], y = leaf[2];
int z = t[w] / 2;
upd(w, x, z);
upd(w, y, z);
upd(x, y, -z);
ans.push_back(tuple<int, int, int>(w, x, z));
ans.push_back(tuple<int, int, int>(w, y, z));
ans.push_back(tuple<int, int, int>(x, y, -z));
}
for (int(i) = (1); (i) <= (n); (i) += (1)) {
if (t[i] == 0 || v[i].size() == 2) continue;
int a = -1, b = -1, c = -1, d = -1;
int z = t[i] / 2;
for (pair<int, int> P : v[i]) {
if (P.first == parent[i]) continue;
for (int(j) = (1); (j) <= (n); (j) += (1)) {
if (L[P.first][j]) {
if (a == -1)
a = j;
else if (b == -1)
b = j;
break;
}
}
if (b != -1) break;
}
int last = i, now = parent[i];
while (1) {
for (pair<int, int> P : v[now]) {
if (P.first == last || P.first == parent[now]) continue;
for (int(j) = (1); (j) <= (n); (j) += (1)) {
if (L[P.first][j]) {
if (c == -1)
c = j;
else if (d == -1)
d = j;
break;
}
}
if (d != -1) break;
}
if (d != -1) break;
last = now;
now = parent[now];
}
ans.push_back(tuple<int, int, int>(a, c, z));
ans.push_back(tuple<int, int, int>(b, d, z));
ans.push_back(tuple<int, int, int>(a, b, -z));
ans.push_back(tuple<int, int, int>(c, d, -z));
}
printf("%d\n", ans.size());
for (auto I : ans) {
int x, y, z;
tie(x, y, z) = I;
printf("%d %d %d\n", x, y, z);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int dp[261][261][261];
char s[261];
int nxt[100010][26];
int pos[30];
int len[4];
vector<char> res[4];
int n, q;
int ok = 0;
int update(int i, int j, int k) {
dp[i][j][k] = n + 1;
if (i and dp[i - 1][j][k] != n + 1) {
int pos = dp[i - 1][j][k];
char ss = res[1][i - 1];
dp[i][j][k] = min(dp[i][j][k], nxt[pos][ss - 'a']);
}
if (j and dp[i][j - 1][k] != n + 1) {
int pos = dp[i][j - 1][k];
char ss = res[2][j - 1];
dp[i][j][k] = min(dp[i][j][k], nxt[pos][ss - 'a']);
}
if (k and dp[i][j][k - 1] != n + 1) {
int pos = dp[i][j][k - 1];
char ss = res[3][k - 1];
dp[i][j][k] = min(dp[i][j][k], nxt[pos][ss - 'a']);
}
}
int main() {
cin >> n >> q;
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) pos[i] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = pos[j];
if (i) pos[s[i] - 'a'] = i;
}
dp[0][0][0] = 0;
while (q--) {
char ss;
scanf(" %c", &ss);
if (ss == '-') {
int st;
scanf("%d", &st);
len[st]--;
res[st].pop_back();
} else {
int st;
scanf("%d %c", &st, &ss);
res[st].push_back(ss);
len[st]++;
if (st == 1) {
for (int i = 0; i <= len[2]; i++)
for (int j = 0; j <= len[3]; j++) {
update(len[1], i, j);
}
}
if (st == 2) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[3]; j++) {
update(i, len[2], j);
}
}
if (st == 3) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++) {
update(i, j, len[3]);
}
}
}
if (dp[len[1]][len[2]][len[3]] != n + 1)
puts("YES");
else
puts("NO");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3505;
int n, m, k;
int a[N], s[N];
void Push(int i, deque<int> &d) {
while (!d.empty() && s[i] <= s[d.back()]) d.pop_back();
d.push_back(i);
}
void Pop(int fr, deque<int> &d) {
while (d.front() < fr) d.pop_front();
}
int Result() {
for (int i = (int)1; i <= (int)m; i++) s[i] = max(a[i], a[n - m + i]);
deque<int> d;
int res = 0;
for (int i = (int)1; i <= (int)m - k - 1; i++) Push(i, d);
for (int i = (int)m - k; i <= (int)m; i++) {
Push(i, d);
Pop(i - (m - k) + 1, d);
res = max(res, s[d.front()]);
}
return res;
}
int main() {
int test;
cin >> test;
while (test--) {
cin >> n >> m >> k;
for (int i = (int)1; i <= (int)n; i++) cin >> a[i];
if (k >= m) k = m - 1;
cout << Result() << "\n";
int x = 1;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i;
long long a[50], s[51], sum = 0;
int main() {
cin >> n;
i = 1;
for (i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
s[n] = 0;
for (i = n - 1; i >= 0; i--) s[i] = abs(a[i] - s[i + 1]);
cout << (sum - s[0]) / 2 << " " << (sum + s[0]) / 2 << endl;
getchar();
getchar();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int dif;
cin >> dif;
dif += 2000;
cout << 2000 << '\n' << -1 << ' ';
for (int i = 0; i < 1999; ++i) {
cout << (dif / 1999) + (i < (dif % 1999)) << ' ';
}
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, m, l, o, p;
int a[350];
while (~scanf("%d %d %d", &n, &m, &l)) {
o = n;
p = m;
for (int i = 0; i <= l; i++) {
if (o > p) {
if (i % 2 == 0) {
a[i] = 0;
n--;
} else {
a[i] = 1;
m--;
}
} else {
if (i % 2 == 0) {
a[i] = 1;
m--;
} else {
a[i] = 0;
n--;
}
}
}
int w = m;
int e = n;
for (int i = 0; i <= l; i++) {
printf("%d", a[i]);
if (a[i] == 1 && m > 0) {
for (int j = 0; j < w; j++) {
printf("1");
m--;
}
}
if (a[i] == 0 && n > 0) {
for (int j = 0; j < e; j++) {
printf("0");
n--;
}
}
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
int a[200005];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int g = 1;
for (int i = 0; i < n; i++) {
if (a[i] >= g) {
ans++;
g++;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class Edge {
public:
long long from, to, rev;
long long cost, lim;
Edge(long long from, long long to, long long cost, long long lim = -1,
long long rev = -1)
: from(from), to(to), cost(cost), lim(lim), rev(rev) {}
};
class Graph {
public:
long long n;
long long m;
vector<vector<Edge>> edge;
Graph(long long n = 0) : n(n), m(0) { edge = vector<vector<Edge>>(n); }
void add_edge(long long from, long long to, long long cost = 1,
long long lim = -1) {
if (lim == -1) {
edge[from].push_back(Edge(from, to, cost));
return;
}
edge[from].push_back(Edge(from, to, cost, lim, edge[to].size()));
edge[to].push_back(Edge(to, from, -cost, 0, edge[from].size() - 1));
}
};
class Dinic {
public:
Graph *g;
vector<int> iter, level, come;
vector<int> color;
Dinic(){};
void bfs(int s) {
queue<int> q;
fill(level.begin(), level.end(), ((1 << 30) - 1));
level[s] = 0;
q.push(s);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto e : g->edge[x]) {
if (level[e.to] != ((1 << 30) - 1)) continue;
if (e.lim <= 0) continue;
level[e.to] = level[x] + 1;
q.push(e.to);
}
}
}
long long dfs(int s, int t, long long f) {
if (s == t) return f;
if (come[s]) return 0;
come[s] = true;
for (int &i = iter[s]; i < g->edge[s].size(); i++) {
Edge &e = g->edge[s][i];
if (e.lim <= 0) continue;
long long tmp = dfs(e.to, t, min(f, e.lim));
if (tmp == 0) continue;
e.lim -= tmp;
g->edge[e.to][e.rev].lim += tmp;
return tmp;
}
return 0;
}
long long max_flow(Graph &_g, int s, int t) {
g = &_g;
iter = vector<int>(g->n);
color = vector<int>(g->n);
level = vector<int>(g->n);
come = vector<int>(g->n, 0);
long long res = 0;
while (true) {
bfs(s);
if (level[t] == ((1 << 30) - 1)) break;
fill(iter.begin(), iter.end(), 0);
while (true) {
fill(come.begin(), come.end(), false);
long long tmp = dfs(s, t, ((1 << 30) - 1));
if (tmp == 0)
break;
else
res += tmp;
}
}
return res;
}
void color_cut(int s) {
if (color[s]) return;
color[s] = 1;
for (auto e : g->edge[s]) {
if (e.lim > 0) color_cut(e.to);
}
}
};
class UnionFind {
public:
int n;
vector<int> u;
UnionFind(int _n = 0) {
n = _n;
u = vector<int>(n, -1);
}
int r(int x) {
if (u[x] < 0) return x;
return u[x] = r(u[x]);
}
void unite(int x, int y) {
x = r(x);
y = r(y);
if (x == y) return;
u[x] += u[y];
u[y] = x;
}
int size(int x) { return -u[r(x)]; }
};
class GomoryHu {
public:
vector<vector<int>> components;
vector<vector<pair<long long, long long>>> adj;
vector<int> group;
int n;
vector<vector<pair<long long, long long>>> tree;
GomoryHu(Graph g) : tree(g.n), n(g.n), components(1), adj(1), group(g.n) {
for (int i = 0; i < n; i++) {
components[0].push_back(i);
}
for (int i = 0; i < n - 1; i++) {
int nxt_comp = 0;
while (components[nxt_comp].size() == 1) nxt_comp++;
for (auto x : components[nxt_comp]) group[x] = x;
for (auto to : adj[nxt_comp]) dfs(to.first, nxt_comp, to.first + n);
int s = components[nxt_comp][0], t = components[nxt_comp][1];
Graph contract_g(n * 2);
for (int i = 0; i < n; i++) {
for (auto e : g.edge[i]) {
if (group[e.from] == group[e.to]) continue;
contract_g.add_edge(group[e.from], group[e.to], 1, e.cost);
}
}
Dinic dinic;
long long min_cut = dinic.max_flow(contract_g, s, t);
dinic.color_cut(s);
vector<int> s_comp, t_comp;
for (auto v : components[nxt_comp]) {
if (dinic.color[v])
s_comp.push_back(v);
else
t_comp.push_back(v);
}
vector<pair<long long, long long>> s_node, t_node;
for (auto p : adj[nxt_comp]) {
int to = p.first;
if (dinic.color[n + to]) {
s_node.push_back(p);
} else {
t_node.push_back(p);
for (int i = 0; i < adj[to].size(); i++)
if (adj[to][i].first == nxt_comp)
adj[to][i].first = components.size();
}
}
s_node.push_back(pair<long long, long long>(components.size(), min_cut));
t_node.push_back(pair<long long, long long>(nxt_comp, min_cut));
components[nxt_comp] = s_comp;
components.push_back(t_comp);
adj[nxt_comp] = s_node;
adj.push_back(t_node);
}
for (int i = 0; i < n; i++) {
int from = components[i][0];
for (auto p : adj[i]) {
int to = components[p.first][0];
int cost = p.second;
tree[from].push_back(pair<long long, long long>(to, cost));
}
}
}
void dfs(int x, int last, int comp) {
for (auto v : components[x]) group[v] = comp;
for (auto p : adj[x]) {
int to = p.first;
if (to == last) continue;
dfs(to, x, comp);
}
}
};
int main() {
int n, m, u, v, c;
cin >> n >> m;
Graph g(n);
for (int i = 0; i < m; i++) {
cin >> u >> v >> c;
u--, v--;
g.add_edge(u, v, c);
g.add_edge(v, u, c);
}
GomoryHu gh(g);
auto tree = gh.tree;
vector<pair<long long, pair<long long, long long>>> edges;
vector<vector<int>> comp(n);
for (int i = 0; i < n; i++) {
comp[i].push_back(i);
for (auto p : tree[i]) {
int to = p.first;
int cost = p.second;
if (i > to) continue;
edges.push_back(pair<long long, pair<long long, long long>>(
cost, pair<long long, long long>(i, to)));
}
}
sort(edges.rbegin(), edges.rend());
UnionFind uf(n);
long long cost_sum = 0;
for (auto e : edges) {
int cost = e.first;
int u = e.second.first, v = e.second.second;
cost_sum += cost;
u = uf.r(u);
v = uf.r(v);
for (auto x : comp[v]) comp[u].push_back(x);
comp[v].clear();
uf.unite(u, v);
}
cout << cost_sum << endl;
for (auto v : comp[uf.r(0)]) cout << v + 1 << " ";
cout << endl;
return 0;
}
| 10 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+10;
int s[N], ne[N], dp[N][20];
unordered_map<int, int> p;
int main() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
memset(ne, 0x7f, sizeof ne);
int n, m, x, y;
cin >> n >> m;
for(int i=1; i<=n; i++) {
cin >> s[i];
}
dp[n+1][0] = n+1;
for(int i=n; i>=1; i--) {
int tmp = s[i];
dp[i][0] = dp[i+1][0];
for(int j=2; 1ll*j*j<=tmp; j++) {
if(tmp % j == 0) {
if(p[j]) ne[i] = min(p[j], ne[i]);
p[j] = i;
while(tmp % j == 0) tmp /= j;
}
}
if(tmp > 1) {
if(p[tmp]) ne[i] = min(p[tmp], ne[i]);
p[tmp] = i;
}
if(ne[i] == 2139062143) ne[i] = n+1;
dp[i][0] = min(ne[i], dp[i][0]);
}
// for(int i=1; i<=n; i++) cout << dp[i][0] << endl;
for(int i=n+1; i>=1; i--) {
for(int j=1; j<=17; j++) {
dp[i][j] = dp[dp[i][j-1]][j-1];
// cout << dp[i][j] << ' ';
}
// cout << endl;
}
for(int i=1; i<=m; i++) {
cin >> x >> y;
int ans = 0;
for(int i=17; i>=0; i--) {
if(dp[x][i] <= y) {
ans += (1<<i);
x = dp[x][i];
}
}
cout << ans+1 << endl;
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long mod = 1e9 + 7;
long long fac[N];
long long ksm(long long a, long long k) {
long long re = 1;
while (k) {
if (k & 1) re = 1ll * re * a % mod;
a = 1ll * a * a % mod;
k >>= 1;
}
return re;
}
signed main() {
long long n;
scanf("%lld", &n);
for (long long i = fac[0] = 1; i <= 2 * n; i++)
fac[i] = 1ll * fac[i - 1] * i % mod;
printf("%lld", 2ll * fac[n * 2 - 1] % mod * ksm(fac[n], mod - 2) % mod *
ksm(fac[n - 1], mod - 2) % mod -
n);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
map<long long, int> ds;
vector<long long> getDivisor(long long x) {
vector<long long> res;
double sq = sqrt((double)x);
for (long long i = 2; i < sq; i++) {
if (x % i == 0) {
res.push_back(i);
res.push_back(x / i);
}
}
if ((long long)sq * (long long)sq == x) {
res.push_back((long long)sq);
}
sort(res.begin(), res.end());
return res;
}
int dfs(long long x, int depth) {
if (ds[x] == 0) {
int res = depth;
vector<long long> d = getDivisor(x);
int n = d.size();
for (int i = 0; i < n; i++) {
res = max(res, dfs(d[i], depth + 1));
}
if (d.empty()) {
ds[x] = -1;
} else {
ds[x] = res - depth;
}
return res;
} else if (ds[x] == -1) {
return depth;
} else {
return depth + ds[x];
}
}
int main() {
long long q;
cin >> q;
vector<long long> qd = getDivisor(q);
if (q == 1 || qd.empty()) {
cout << 1 << endl;
cout << 0 << endl;
return 0;
}
int n = qd.size(), maxdepth;
for (int i = 0; i < n; i++) {
maxdepth = dfs(qd[i], 1);
if (maxdepth % 2 == 0) {
cout << 1 << endl;
cout << qd[i] << endl;
return 0;
}
}
cout << 2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long int mod = 1000000007;
const int INF = 1000000000;
using namespace std;
unsigned long long int pow2(unsigned long long int s) {
if (s != 0 && (s & (s - 1)))
cout << "0";
else
cout << "1";
}
unsigned long long int powany(long long int a, long long int b) {
unsigned long long int res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
unsigned long long int prime(unsigned long long int n) {
if (n == 2 || n == 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (unsigned long long int i = 7; i * i < n; i += 6)
if (n % (i) == 0 || n % (i - 2) == 0) return 0;
return 1;
}
int main() {
int n, k, i, j, c = 1, cou = 0;
cin >> n >> k;
int a[n][n];
for (i = 0; i < n; ++i)
for (j = 0; j <= k - 2; ++j) a[i][j] = c++;
for (i = 0; i < n; ++i)
for (j = k - 1; j < n; ++j) a[i][j] = c++;
for (i = 0; i < n; ++i) cou += a[i][k - 1];
cout << cou << "\n";
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) cout << a[i][j] << " ";
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int f[N][3], f2[N], pos[N], pr[N], pr2[N];
int a[N], c[N], d[N];
pair<int, int> b[N];
unordered_map<int, int> mem, mem2, cnt;
unordered_map<int, int> prv, rev, endd;
set<int, greater<int>> s, s2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
if (fopen("GUARDS.INP", "r")) {
freopen("GUARDS.INP", "r", stdin);
freopen("GUARDS.OUT", "w", stdout);
}
int t;
cin >> t;
for (int q = 1; q <= t; q++) {
int n;
cin >> n;
mem.clear();
mem2.clear();
prv.clear();
s2.clear();
s.clear();
cnt.clear();
rev.clear();
endd.clear();
for (int i = 1; i <= n; i++) pr[i] = 0, pr2[i] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
pr[i] = prv[a[i]];
prv[a[i]] = i;
b[i].first = a[i];
b[i].second = i;
}
stable_sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++) {
if ((i > 1 && b[i].first == b[i - 1].first)) {
} else {
rev[b[i].second] = 1;
if (i > 0) endd[b[i - 1].second] = 1;
s2.clear();
for (auto j : s) s2.insert(j);
s.clear();
}
auto it = s2.lower_bound(b[i].second);
if (it != s2.end()) {
pr2[b[i].second] = *it;
}
s.insert(b[i].second);
}
endd[b[n].second] = 1;
int best = 0;
f[0][0] = 0;
f[0][1] = 0;
for (int i = 1; i <= n; i++) f[i][0] = 1, f[i][1] = 1, f[i][2] = 1;
for (int i = 1; i <= n; i++) {
if (pr[i] > 0) {
f[i][0] = max(f[i][0], f[pr[i]][0] + 1);
f[i][1] = max(f[i][1], f[pr[i]][1] + 1);
f[i][2] = max(f[i][2], f[pr[i]][2] + 1);
}
if (pr2[i] > 0) {
if (rev[i] == 1) {
f[i][1] = max(f[i][1], f[pr2[i]][0] + 1);
} else {
f[i][2] = max(f[i][2], f[pr2[i]][0] + 1);
if (endd[pr2[i]]) f[i][2] = max(f[i][2], f[pr2[i]][1] + 1);
}
if (endd[pr2[i]] == 1 && rev[i] == 1) {
f[i][1] = max(f[i][1], f[pr2[i]][1] + 1);
}
}
best = max(best, f[i][0]);
best = max(best, f[i][2]);
best = max(best, f[i][1]);
}
int ans = n - best;
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
const int W = 1 << N;
const int K = 555555;
const int inf = 1e9;
int n, w, m, k, a[K], b[K][N], c[W][N], f[W][N * N];
string s[N], t;
void cmin(int& x, int y) {
if (x > y) x = y;
}
int main() {
int T = 0, i, j, o, x, ans = inf, anss = 0;
cin >> n;
for (i = 0; i < n; i = i + 1) cin >> s[i];
w = (1 << n) - 1;
for (i = 0; i <= w; i = i + 1) {
for (j = n - 1; j >= 0; j = j - 1) {
c[i][j] = c[i][j + 1];
if (i & (1 << j)) c[i][j]++;
}
}
scanf("%d", &m);
while (m--) {
T++;
cin >> k;
for (i = 0; i <= k; i = i + 1) a[i] = -1;
for (i = 1; i <= k; i = i + 1) {
cin >> t;
for (j = 0; j < n; j = j + 1)
if (t == s[j]) a[i] = j;
}
memset(b, 0, sizeof(b));
for (i = k; i >= 0; i = i - 1) {
for (j = 0; j < n; j = j + 1) b[i][j] = b[i + 1][j];
if (a[i] >= 0) b[i][a[i]] = i;
}
for (i = 0; i <= w; i = i + 1)
for (j = 0; j < n * n; j = j + 1) f[i][j] = inf;
f[0][0] = 0;
for (i = 0; i <= w; i = i + 1)
for (j = 0; j < n * n; j = j + 1) {
x = f[i][j];
if (x >= inf) continue;
for (o = 0; o < n; o = o + 1) {
if (i & (1 << o)) continue;
if (b[x][o]) cmin(f[i | (1 << o)][j + c[i][o]], b[x][o]);
}
}
for (j = 0; j < n * n; j = j + 1)
if (f[w][j] <= k && j < ans) ans = j, anss = T;
}
if (ans >= inf) {
cout << "Brand new problem!";
return 0;
}
ans = n * (n - 1) / 2 - ans + 1;
cout << anss << endl;
cout << "[:";
while (ans--) {
cout << '|';
}
cout << ":]";
return 0;
}
| 9 |
#include <bits/stdc++.h>
void answer(unsigned r, unsigned b, unsigned y, unsigned g) {
std::cout << r << ' ' << b << ' ' << y << ' ' << g << '\n';
}
void solve(const std::string& s) {
const auto count = [&s](char c) {
const size_t n = s.length();
size_t i = 0;
while (i < n && s[i] != c) ++i;
unsigned k = 0;
for (size_t j = i % 4; j < n; j += 4) k += (s[j] == '!');
return k;
};
const unsigned r = count('R');
const unsigned b = count('B');
const unsigned y = count('Y');
const unsigned g = count('G');
answer(r, b, y, g);
}
int main() {
std::string s;
std::cin >> s;
solve(s);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class BIT {
int n;
vector<long long> data;
public:
BIT(int n) {
this->n = n;
data.assign(n + 1, 0);
}
void add(int k, long long x) {
++k;
while (k <= n) {
data[k] += x;
k += k & -k;
}
}
long long sum(int k) {
++k;
long long ret = 0;
while (k > 0) {
ret += data[k];
k -= k & -k;
}
return ret;
}
long long sum(int a, int b) { return sum(b) - sum(a - 1); }
};
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 1);
vector<int> index(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
index[a[i]] = i;
}
vector<pair<pair<int, int>, int> > q(m);
for (int i = 0; i < m; ++i) {
cin >> q[i].first.second >> q[i].first.first;
q[i].second = i;
}
sort(q.begin(), q.end());
BIT b(n + 1);
int k = 0;
vector<long long> ret(m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j * j <= a[i]; ++j) {
if (a[i] % j == 0) {
if (index[j] < i) b.add(index[j], 1);
if (j * j < a[i] && index[a[i] / j] < i) b.add(index[a[i] / j], 1);
}
}
for (int j = a[i]; j <= n; j += a[i]) {
if (index[j] <= i) b.add(index[j], 1);
}
while (k < m && q[k].first.first == i) {
ret[q[k].second] = b.sum(q[k].first.second, q[k].first.first);
++k;
}
}
for (int i = 0; i < m; ++i) cout << ret[i] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string i2s(T x) {
ostringstream o;
o << x;
return o.str();
}
template <class T>
vector<T> split(const string& s) {
vector<T> v;
istringstream is(s);
T t;
while (is >> t) v.push_back(t);
return v;
}
vector<string> splitStr(const string& s, const string& d = "",
bool keepEmpty = false) {
if (d.empty()) return split<string>(s);
vector<string> v;
string t;
for (int _n = ((int((s).size()))), i = 0; i < _n; ++i)
if (d.find(s[i]) != string::npos) {
if (keepEmpty || !t.empty()) {
v.push_back(t);
t = "";
}
} else
t += s[i];
if (!t.empty()) v.push_back(t);
return v;
}
int main() {
std::ios::sync_with_stdio(false);
int s, x1, x2, t1, t2, p, d;
cin >> s >> x1 >> x2 >> t1 >> t2 >> p >> d;
int walkTime = t2 * abs(x1 - x2);
int trainTime = 0;
if (p < x1) {
if (d == 1)
trainTime += t1 * (x1 - p);
else
trainTime += t1 * (p + x1), d = 1;
} else if (p == x1) {
} else {
if (d == 1)
trainTime += t1 * (s - p + s - x1), d = -1;
else
trainTime += t1 * (p - x1);
}
if (x1 <= x2) {
if (d == 1)
trainTime += t1 * (x2 - x1);
else
trainTime += t1 * (x1 + x2);
} else {
if (d == 1)
trainTime += t1 * (s - x1 + s - x2);
else
trainTime += t1 * (x1 - x2);
}
int ans = min(walkTime, trainTime);
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string w[100];
void solve() {
int n;
cin >> n;
for (int i = 2; i < n; i++) cin >> w[i - 2];
string s = w[0];
for (int i = 1; i < n - 2; i++) {
if (w[i][0] != w[i - 1][1]) s += w[i][0];
s += w[i][1];
}
if (s.size() == n - 1) s += 'a';
cout << s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
while (~scanf("%d %d", &a, &b)) {
int ans1 = (a < b ? a : b);
printf("%d %d\n", ans1, (a + b - ans1 - ans1) / 2);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
bool visited[2001];
long long compute(long long a, long long b) {
if (b == 0) return 1;
long long res = compute(a * a % MOD, b / 2);
if (b & 1) res = res * a % MOD;
return res;
}
void dfs(int x, int n, int k) {
if (!visited[x]) {
visited[x] = true;
for (int p = 0; p < k; p++) {
int b = x - p;
if (b >= 0 && b + k <= n) {
int q = k - p - 1;
int next = b + q;
dfs(next, n, k);
}
}
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
memset(visited, 0, sizeof(visited));
int comp = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
comp++;
dfs(i, n, k);
}
}
cout << compute((long long)m, (long long)comp) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
long long low = 1, high = n * m, ans = -1;
while (low <= high) {
long long mid = low + (high - low) / 2;
long long cnt = 0, equal = 0;
for (int i = 1; i <= n; i++) {
long long val = min(m, mid / i);
if (val * i == mid) {
equal++;
}
cnt += val;
}
if (cnt <= k - 1) {
low = mid + 1;
} else {
high = mid - 1;
}
}
cout << low;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p, i, j, k, l, opt, u, v;
int c[100005], Max[400005];
long long h, K, dist[10005], a[100005];
int q[100005], ll, rr;
bool use[100005], inq[100005];
void update(int x) {
if (Max[x << 1] == -1)
Max[x] = Max[x << 1 | 1];
else if (Max[x << 1 | 1] == -1)
Max[x] = Max[x << 1];
else {
if (c[Max[x << 1]] >= c[Max[x << 1 | 1]])
Max[x] = Max[x << 1];
else
Max[x] = Max[x << 1 | 1];
}
}
int main() {
scanf("%I64d%d%d%d", &h, &n, &m, &p);
for (l = 1; l < n; l *= 2)
;
for (i = l + l - 1; i; --i) Max[i] = -1;
for (i = 1; i < p; ++i) dist[i] = h + 1;
for (i = 1; i <= n; ++i) {
scanf("%I64d%d", &a[i], &c[i]);
--a[i];
if (a[i] % p == 0) {
use[i] = true;
Max[j = l + i - 1] = i;
for (j >>= 1; j; j >>= 1) update(j);
}
}
for (; m; --m) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%I64d", &K);
ll = rr = 0;
for (i = 0; i < p; ++i) q[++rr] = i, inq[i] = true;
while (ll != rr) {
++ll;
if (ll == 100000) ll = 1;
inq[q[ll]] = false;
if (dist[q[ll]] + K < dist[(q[ll] + K) % p]) {
dist[(q[ll] + K) % p] = dist[q[ll]] + K;
if (!inq[(q[ll] + K) % p]) {
++rr;
if (rr == 100000) rr = 1;
q[rr] = (q[ll] + K) % p;
inq[(q[ll] + K) % p] = true;
}
}
}
for (i = 1; i <= n; ++i)
if (!use[i] && dist[a[i] % p] <= a[i]) {
use[i] = true;
Max[j = l + i - 1] = i;
for (j >>= 1; j; j >>= 1) update(j);
}
}
if (opt == 2) {
scanf("%d%d", &u, &v);
c[u] -= v;
for (j = l + u - 1 >> 1; j; j >>= 1) update(j);
}
if (opt == 3) {
if (Max[1] == -1)
printf("0\n");
else {
printf("%d\n", c[Max[1]]);
c[Max[1]] = 0;
for (j = l + Max[1] - 1 >> 1; j; j >>= 1) update(j);
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
char v[111][111];
char best[111];
int main() {
int n = 0, m = 0, r = 0;
cin >> n >> m;
char v[111][111], mm[111];
for (int i = 0; i < n; i++) {
cin >> v[i];
for (int j = 0; j < m; j++) mm[j] = max(mm[j], v[i][j]);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (v[i][j] == mm[j]) {
r++;
break;
}
cout << r << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct sums {
long long sum = 0;
long long num = 0;
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans1 = 0, ans2 = 0;
vector<long long> v(n);
queue<long long> po;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] > 0) {
po.push(i);
} else {
if ((int)(po.size())) {
long long x = v[po.front()];
v[po.front()] = max((long long)0, v[po.front()] + v[i]);
v[i] = min((long long)0, v[i] + x);
if (v[po.front()] == 0) {
po.pop();
}
while ((int)(po.size()) && v[i] < 0) {
x = v[po.front()];
v[po.front()] = max((long long)0, v[po.front()] + v[i]);
v[i] = min((long long)0, v[i] + x);
if (v[po.front()] == 0) {
po.pop();
}
}
}
}
}
for (int i = 0; i < n; i++) {
if (v[i] > 0)
ans1 += v[i];
else
ans2 += abs(v[i]);
}
cout << min(ans1, ans2) + abs(ans1 - ans2) << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename A>
void _do(A x) {
cerr << x << '\n';
}
template <typename A, typename... B>
void _do(A x, B... y) {
cerr << x << ", ";
_do(y...);
}
long long n, d, m;
vector<long long> low, high;
signed main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> d >> m;
for (int i = 1, x; i <= n; i++) {
cin >> x;
if (x <= m)
low.emplace_back(x);
else
high.emplace_back(x);
}
sort((low).begin(), (low).end(), greater<long long>());
sort((high).begin(), (high).end(), greater<long long>());
if (high.size() == 0) {
long long ans = 0;
for (auto i : low) ans += i;
cout << ans << '\n';
return 0;
}
for (int i = 1; i < low.size(); i++) low[i] += low[i - 1];
long long ans = 0, val = 0;
for (int i = 0; i < high.size(); i++) {
val += high[i];
long long le = n - i * d - i - 1;
if (le < 0) break;
if (le > low.size()) le = low.size();
if (le == 0)
ans = max(ans, val);
else {
cerr << "le, val + low[le - 1]"
<< " = ";
_do(le, val + low[le - 1]);
;
ans = max(ans, val + low[le - 1]);
}
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
void Read(int& x) {
char c = nc();
for (; c < '0' || c > '9'; c = nc())
;
for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - 48, c = nc())
;
}
const int N = 300010;
const int M = 19;
int n, m, x, y;
int t[N << 1], nx[N << 1], h[N], num;
int f[N], c[N], dp[N][M];
int a[N], l, cur[N];
vector<pair<int, int> > g[N];
long long Res, Ans;
void Add(int x, int y) {
t[++num] = y;
nx[num] = h[x];
h[x] = num;
}
bool Cmp(int x, int y) { return x > y; }
void Dfs(int x, int y) {
dp[x][1] = n;
f[x] = y;
for (int i = h[x]; i; i = nx[i])
if (t[i] != y) Dfs(t[i], x), c[x] = max(c[x], c[t[i]]);
for (int j = 2; j < M; j++) {
l = 0;
for (int i = h[x]; i; i = nx[i])
if (t[i] != y && dp[t[i]][j - 1]) a[++l] = dp[t[i]][j - 1];
sort(a + 1, a + l + 1, Cmp);
for (int k = l; k > 1; k--)
if (a[k] >= k) {
dp[x][j] = k;
break;
}
if (dp[x][j]) g[dp[x][j]].push_back(pair<int, int>(x, j));
}
Ans += ++c[x];
}
void Update(int x, int y) {
while (x) {
if (cur[x] >= y) break;
Res += y - cur[x];
cur[x] = y;
x = f[x];
}
}
int main() {
Read(n);
for (int i = 1; i < n; i++) Read(x), Read(y), Add(x, y), Add(y, x);
Dfs(1, 1);
for (int i = 1; i <= n; i++) cur[i] = 1;
Res = n;
for (int k = n; k > 1; k--) {
for (int j = 0; j < g[k].size(); j++) Update(g[k][j].first, g[k][j].second);
Ans += Res;
}
cout << Ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, m, s, f;
scanf("%d%d%d%d", &n, &m, &s, &f);
int now = 0, pos = s, g;
g = s < f ? 1 : -1;
char go = s < f ? 'R' : 'L';
int arr = 0;
for (int i = 0; i < m; ++i) {
int t, l, r;
scanf("%d%d%d", &t, &l, &r);
for (int j = now; j < t - 1; ++j) {
pos += g;
printf("%c", go);
if (pos == f) return 0;
}
if ((l <= pos && r >= pos) || (pos + g >= l && pos + g <= r))
printf("%c", 'X');
else {
pos += g;
printf("%c", go);
if (pos == f) return 0;
}
now = t;
}
while (pos != f) {
pos += g;
printf("%c", go);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2 * (1e3 + 1);
const long long INF = 1e18 + 1;
const long long MOD = 1e18 + 7;
const long long BITS = 64;
const long long PRIME = 31;
const long double EPS = 1e-12;
const long double PI = acos(-1);
void bye() {
cout << "\n";
exit(0);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
sort((s).begin(), s.end());
cout << s;
bye();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
struct D {
int v, id, c;
bool q;
D() {}
D(int b, int c, int d, bool e) : v(b), id(c), c(d), q(e) {}
};
vector<D> al[200005];
char rs[200005];
bool bl[200005];
int n, m, sz[200005];
long long int sm[200005], cr[200005];
int main() {
int t, i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d%d", &j, &k, &t);
al[j].push_back(D(k, i, t, 0));
al[k].push_back(D(j, i, t, 1));
sz[j]++;
sz[k]++;
sm[j] += t;
sm[k] += t;
rs[i] = 3;
}
priority_queue<int> q;
q.push(-1);
bl[1] = 1;
while (!q.empty()) {
k = -q.top();
q.pop();
for (i = 0; i < sz[k]; i++) {
if (rs[al[k][i].id] != 3) continue;
cr[al[k][i].v] += al[k][i].c;
rs[al[k][i].id] = al[k][i].q;
if (cr[al[k][i].v] * 2 == sm[al[k][i].v]) {
bl[al[k][i].v] = 1;
q.push(-al[k][i].v);
}
}
}
for (i = 0; i < m; i++) {
printf("%d\n", rs[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char c;
int flag = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag *= -1;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= flag;
return;
}
inline void read(long long &x) {
char c;
int flag = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag *= -1;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= flag;
return;
}
inline void read(char &c) {
while (!isalpha(c = getchar())) c = getchar();
}
long long n, W, B, X, m;
long long dp[1005][10005];
long long c[1005], cost[1005];
int main() {
read(n);
read(W);
read(B);
read(X);
for (int i = 1; i <= n; i++) {
read(c[i]);
m += c[i];
}
for (int i = 1; i <= n; i++) cin >> cost[i];
memset(dp, -1, sizeof dp);
dp[0][0] = W;
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (long long j = 0; j <= m; j++) {
long long max_mana = W + j * B;
for (int k = 0; k <= min(j, c[i]); k++) {
if (dp[i - 1][j - k] == -1) continue;
if (min(W + (j - k) * B, dp[i - 1][j - k] + X) - cost[i] * k < 0)
continue;
dp[i][j] = max(
dp[i][j], min(max_mana, min(W + (j - k) * B, dp[i - 1][j - k] + X) -
cost[i] * k));
ans = max(ans, j);
max_mana += B;
}
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
const int N = 2e5 + 5;
long long fact[N], inv_fact[N];
long long powm(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
void pre_calculate() {
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv_fact[N - 1] = powm(fact[N - 1], mod - 2);
for (int i = N - 2; i >= 0; i--) {
inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
pre_calculate();
if (n == 2) {
cout << 0;
return 0;
}
long long ans = fact[m];
ans = (((ans * inv_fact[n - 1]) % mod) * inv_fact[m - n + 1]) % mod;
ans = (ans * (n - 2)) % mod;
ans = (ans * powm(2, n - 3)) % mod;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 1000010;
const int C = 262144;
const int INF = 1000000001;
int n, m, in[MXN], out[MXN];
vector<int> U[MXN];
void test() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= (m); i++) {
int a, b;
scanf("%d %d", &a, &b);
if (a < b) swap(a, b);
out[a]++;
in[b]++;
U[b].push_back(a);
}
long long int res = 0;
for (int i = (1); i <= (n); i++) res += (long long int)out[i] * in[i];
int q;
scanf("%d", &q);
printf("%I64d\n", res);
while (q--) {
int x;
scanf("%d", &x);
res -= (long long int)out[x] * in[x];
for (__typeof((U[x]).begin()) it = ((U[x]).begin()); it != (U[x]).end();
++it) {
res += out[*it] - 1;
res -= in[*it];
out[*it]--;
in[*it]++;
U[*it].push_back(x);
}
out[x] += in[x];
in[x] = 0;
U[x].clear();
printf("%I64d\n", res);
}
}
int main() {
int te = 1;
while (te--) test();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, q;
inline long long lowbit(long long x) { return x & -x; }
inline long long query(long long x) {
long long t = (n << 1) - x;
t /= lowbit(t);
long long k = (2 * n + 1 - t) / 2;
return k;
}
signed main() {
scanf("%lld%lld", &n, &q);
while (q--) {
long long x;
scanf("%lld", &x);
printf("%lld\n", query(x));
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
std::ios::sync_with_stdio(false);
int a, b, c, d;
cin >> a >> b;
cin >> c >> d;
map<int, int> my;
for (int i = 0; i < 100000; i++) my[b + a * i]++;
for (int i = 0; i < 100000; i++)
if (my[d + c * i]) {
cout << d + c * i << endl;
return 0;
}
cout << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int day, min, count = 0;
cin >> day >> min;
int arr[day];
for (int i = 0; i < day; i++) {
cin >> arr[i];
}
for (int i = 0; i < (day - 1); i++) {
if ((arr[i] + arr[i + 1]) < min) {
count += min - (arr[i] + arr[i + 1]);
arr[i + 1] = arr[i + 1] + (min - (arr[i] + arr[i + 1]));
}
}
cout << count << endl;
for (int i = 0; i < day; i++) {
cout << arr[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long x, n;
cin >> n >> x;
cout << 2 * x << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
string t = ".QAQ";
int n, f[101][4];
int main() {
cin >> s;
s = ' ' + s;
n = s.size() - 1;
for (int i = 0; i <= n; i++) f[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 3; j++) {
f[i][j] = f[i - 1][j];
if (s[i] == t[j]) f[i][j] += f[i - 1][j - 1];
}
if (n < 3)
cout << 0;
else
cout << f[n][3];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100011][2][2];
string a, b;
int len;
long long solve(int lengthDone, int addedA, int addedB) {
int idxA = lengthDone - addedA;
int idxB = lengthDone - addedB;
if (lengthDone == len)
return 1;
else if (dp[lengthDone][addedA][addedB] != -1)
return dp[lengthDone][addedA][addedB];
long long ret = 0;
if (a[idxA] == b[idxB])
ret += solve(lengthDone + 1, addedA, addedB);
else {
if (!addedA) ret += solve(lengthDone + 1, 1, addedB);
if (!addedB) ret += solve(lengthDone + 1, addedA, 1);
}
return (dp[lengthDone][addedA][addedB] = ret);
}
int main() {
scanf("%d", &len);
len += 1;
cin >> a >> b;
for (int i = 0; i <= 100010; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) dp[i][j][k] = -1;
cout << solve(0, 0, 0) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
#define db long double
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
using namespace std;
int a, b;
const int N = (1<<20);
const int INF = 1e9;
bool dp[N];
bool can[N];
bool from[N];
int n;
pair<int, int> left_index[N];
pair<int, int> right_index[N];
int tcnt[N];
bool good(int mask) {
int cnt = tcnt[mask];
int delta = right_index[mask].x - left_index[mask].x + 1;
return ((ll) cnt * b >= (ll) delta * a);
}
void solve(vector<pair<int, int> > v, vector<char> t, vector<int> cnt) {
if (t.size() == 1) {
cout << "1 " << t[0] << endl;
exit(0);
}
n = v.size();
left_index[0] = mp(INF, -1);
right_index[0] = mp(-INF, -1);
tcnt[0] = 0;
for (int i = 1; i < (1<<n); ++i) {
for (int j = 0; j < n; ++j) {
if (((1<<j)&i)) {
left_index[i] = min(left_index[i^(1<<j)], mp(v[j].x, j));
right_index[i] = max(right_index[i^(1<<j)], mp(v[j].y, j));
tcnt[i] = tcnt[i^(1<<j)] + cnt[j];
break;
}
}
}
for (int i = 0; i < n; ++i) {
if (good(1<<i)) {
dp[1<<i] = true;
from[1<<i] = true;
}
can[1<<i] = true;
}
for (int i = 1; i < (1<<n); ++i) {
bool T = good(i);
vector<pair<int, int> > lin, rin;
for (int j = 0; j < n; ++j) {
if (!((1<<j)&i)) continue;
lin.pb(mp(v[j].x, j));
rin.pb(mp(v[j].y, j));
}
sort(all(lin));
sort(all(rin));
for (int take = 0; take < lin.size(); ++take) {
int M = 0;
for (int take2 = take; take2 < lin.size(); ++take2) {
M ^= (1<<lin[take2].y);
if ((dp[i^M] && can[M]) || (dp[M] && can[i^M])) {
can[i] = true;
dp[i] = T;
from[i] = T;
}
if (from[M] && from[i^M]) from[i] = true;
}
if (can[i]) break;
}
for (int take = 0; take < rin.size(); ++take) {
int M = 0;
for (int take2 = take; take2 < rin.size(); ++take2) {
M ^= (1<<rin[take2].y);
if ((dp[i^M] && can[M]) || (dp[M] && can[i^M])) {
can[i] = true;
dp[i] = T;
from[i] = T;
}
if (from[M] && from[i^M]) from[i] = true;
}
if (can[i]) break;
}
}
vector<char> ans;
for (int i = 0; i < n; ++i) {
if (from[((1<<n) - 1) ^ (1<<i)]) ans.pb(t[i]);
}
sort(all(ans));
cout << ans.size() << " ";
for (auto x : ans) cout << x << " ";
}
int main(){
#ifdef LOCAL
freopen("G_input.txt", "r", stdin);
//freopen("G_output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n >> a >> b;
string s;
cin >> s;
vector<pair<int, int> > borders;
borders.assign(26, mp(INF, -INF));
vector<int> cnt(26, 0);
int u = 0;
for (auto x : s) {
borders[x - 'a'].x = min(borders[x - 'a'].x, u);
borders[x - 'a'].y = max(borders[x - 'a'].y, u++);
cnt[x - 'a']++;
}
vector<pair<int, int> > rb;
vector<char> symb;
vector<int> t;
u = 0;
for (auto el : borders) {
if (el.x != INF) {
rb.pb(el);
symb.pb((char) ('a' + u));
t.pb(cnt[u]);
}
u++;
}
solve(rb, symb, t);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 2e5 + 13, mod = 1e9 + 7;
long long r, g, odp[maxN], ans;
bool can(long long x) {
if (x * (x + 1) / 2 <= r + g) return 1;
return 0;
}
int32_t main() {
cin >> r >> g;
long long lf = 0, rg = max(r, g) + 1;
while (rg - lf > 1) {
long long mid = lf + rg >> 1;
if (can(mid))
lf = mid;
else
rg = mid;
}
long long h = lf;
odp[0] = 1;
for (long long j = 0; j <= h; j++) {
for (long long i = r; i >= 0; i--) {
if (!(i == 0 && j == 0))
odp[i] = (odp[i] + ((i >= j) ? odp[i - j] : 0)) % mod;
}
}
for (long long i = r; i + g >= h * (h + 1) / 2 && i >= 0; i--) {
ans = (ans + odp[i]) % mod;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int life[200001], N, a, i;
for (i = 0; i < 200001; i++) life[i] = 0;
scanf("%d", &N);
for (i = 0; i < N; i++) {
scanf("%d", &a);
if (a != 0) life[a + 100000] = 1;
}
int diff = 0;
for (i = 0; i < 200001; i++) diff += life[i];
printf("%d\n", diff);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 2], ans[n + 2];
for (int i = 2; i <= n; i++) {
cout << "? " << 1 << " " << i << endl;
cin >> a[i];
}
for (int i = 3; i <= n; i++) {
ans[i] = a[i] - a[i - 1];
}
cout << "? " << 2 << " " << 3 << endl;
int x;
cin >> x;
ans[1] = a[3] - x;
ans[2] = a[2] - ans[1];
cout << "! ";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100050;
char s[maxn], t[maxn];
int cnt1 = 0, cnt2 = 0;
int main() {
scanf("%s%s", s, t);
int len = strlen(s), cnt1 = 0, cnt2 = 0;
for (int i = 0; i < len; i++) {
if (s[i] != t[i]) {
if (s[i] == '7')
cnt1++;
else
cnt2++;
}
}
printf("%d\n", max(cnt1, cnt2));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
long long int n;
long long int a, b;
cin >> n >> a >> b;
string s;
cin >> s;
long long int bc = n * (a + b) + b;
bool ftram = true;
bool ztram = true;
long long int fzero = -1;
long long int nc = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == '0') {
if (!ztram) {
fzero = i;
ztram = true;
}
} else {
if (ztram) {
if (ftram) {
nc += a;
ftram = false;
} else {
nc += min(2 * a, (i - fzero - 1) * b);
}
ztram = false;
nc += b;
}
nc += b;
}
}
if (!ftram) nc += a;
cout << bc + nc << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 100;
const int mod = (int)998244353;
int n;
double ans;
vector<int> g[maxn];
void dfs(int v, int p = 0, int lvl = 1) {
ans += 1.0 / (lvl + .0);
for (int to : g[v])
if (to != p) dfs(to, v, lvl + 1);
}
int main() {
cin >> n;
for (int i = (1); i <= (n - 1); ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
cout << fixed << setprecision(9) << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int currMax = 0;
int maxInd = -1;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
if (arr[i] > currMax) {
currMax = arr[i];
maxInd = i;
}
}
for (int i = maxInd + 1; i < n; ++i) {
if (arr[i] > arr[i - 1]) {
cout << "NO\n";
return 0;
}
}
for (int i = maxInd - 1; i >= 0; --i) {
if (arr[i] > arr[i + 1]) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, pair<int, int> > t[4000500];
pair<int, pair<int, int> > combine(pair<int, pair<int, int> > x,
pair<int, pair<int, int> > y) {
int t = min(x.second.first, y.second.second);
return {x.first + y.first + t,
{x.second.first + y.second.first - t,
x.second.second + y.second.second - t}};
}
void build(string& a, int v, int tl, int tr) {
if (tl == tr)
if (a[tl] == '(')
t[v] = {0, {1, 0}};
else
t[v] = {0, {0, 1}};
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
pair<int, pair<int, int> > get_max(int v, int tl, int tr, int l, int r) {
if (l > r) return {0, {0, 0}};
if (l == tl && r == tr) return t[v];
int tm = (tl + tr) / 2;
return combine(get_max(v * 2, tl, tm, l, min(r, tm)),
get_max(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int main() {
string s;
cin >> s;
build(s, 1, 0, s.length() - 1);
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
cout << 2 * get_max(1, 0, s.length() - 1, l - 1, r - 1).first << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, a1, b1, a2, b2, a3, b3;
bool ans = false;
cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3;
if (a1 < b1) {
t = a1;
a1 = b1;
b1 = t;
}
if (a2 < b2) {
t = a2;
a2 = b2;
b2 = t;
}
if (a3 < b3) {
t = a3;
a3 = b3;
b3 = t;
}
if (a2 <= a1 && a3 <= a1 && b2 + b3 <= b1) ans = true;
if ((a2 <= b1 && a3 <= b1) && (b2 + b3 <= a1)) ans = true;
if ((a2 + b3 <= a1) && (b2 <= b1 && a3 <= b1)) ans = true;
if (a2 + a3 <= a1 && (b2 <= b1 && b3 <= b1)) ans = true;
if ((b2 <= a1 && b3 <= a1) && a2 + a3 <= b1) ans = true;
if ((b3 <= b1 && a2 <= b1) && b2 + a3 <= a1) ans = true;
if ((a3 <= a1 && b2 <= a1) && b3 + a2 <= b1) ans = true;
if ((a2 <= a1 && b3 <= a1) && b2 + a3 <= b1) ans = true;
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct p {
int st, en, d;
};
bool cmp(p a, p b) { return a.d < b.d; }
bool cmp1(p a, p b) { return a.st < b.st; }
p b[500005];
long long dp[5005], dp1[5005], dp2[5005];
int a[500005];
int main() {
for (int i = 0; i < 5005; i++)
dp[i] = 100000000000000LL, dp1[i] = 100000000000000LL;
int k, n;
cin >> k >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
b[i - 1].st = a[i - 1], b[i - 1].en = a[i], b[i - 1].d = a[i] - a[i - 1];
}
sort(b, b + n - 1, cmp);
sort(b, b + min(3 * k, n - 1), cmp1);
dp1[1] = b[0].d;
dp1[0] = 0, dp[0] = 0;
if (n == 2) {
cout << dp1[1] << endl;
return 0;
}
for (int i = 1; i < min(n - 1, 3 * k); i++) {
for (int cnt = 0; cnt <= k; cnt++) {
if (cnt == 0)
dp2[cnt] = 0;
else if (b[i].st == b[i - 1].en) {
dp2[cnt] = min(dp1[cnt], dp[cnt - 1] + b[i].d);
if (dp2[cnt] > 100000000000000LL) dp2[cnt] = 100000000000000LL;
} else {
dp2[cnt] = min(dp1[cnt], dp1[cnt - 1] + b[i].d);
if (dp2[cnt] > 100000000000000LL) dp2[cnt] = 100000000000000LL;
}
}
for (int cnt = 0; cnt <= k; cnt++) {
dp[cnt] = dp1[cnt];
dp1[cnt] = dp2[cnt];
}
}
cout << dp2[k] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100009;
int dp[1001][1001][12];
int n, m, k;
string s, t;
int solve(int i, int j, int cnt) {
if (i == n || j == m || cnt == 0) return 0;
int &ret = dp[i][j][cnt];
if (ret != -1) return ret;
ret = 0;
ret = max(ret, solve(i + 1, j, cnt));
ret = max(ret, solve(i, j + 1, cnt));
int x = i;
int y = j;
for (; x < n && y < m;) {
if (s[x] != t[y])
break;
else {
++x;
++y;
}
}
if (x > i) ret = max(ret, x - i + solve(x, y, cnt - 1));
return ret;
}
int main() {
cin >> n >> m >> k;
cin >> s >> t;
memset(dp, -1, sizeof dp);
cout << solve(0, 0, k);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int modInverse(long long int a, long long int m) {
long long int m0 = m;
long long int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long int q = a / m;
long long int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
void pairsort(int a[], int b[], int n) {
pair<int, int> pairt[n];
for (int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
void pairsortlli(long long int a[], long long int b[], long long int n) {
pair<long long int, long long int> pairt[n];
for (long long int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long int binomialCoeff(long long int n, long long int k) {
long long int C[k + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long int i = 1; i <= n; i++) {
for (long long int j = min(i, k); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % 1000000007;
}
return C[k];
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int bins(long long int arr[], long long int l, long long int r,
long long int x) {
if (r >= l) {
long long int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return bins(arr, l, mid - 1, x);
return bins(arr, mid + 1, r, x);
}
return -1;
}
void swap(long long int* a, long long int* b) {
long long int t;
t = *a;
*a = *b;
*b = t;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int y1, y2, yw, xb, yb, r;
cin >> y1 >> y2 >> yw >> xb >> yb >> r;
long long int p = yb + 2 * (yw - r - yb);
double m = ((p - y1 - r) * 1.0) / xb;
long long int q = y2 - y1 - r;
double a = 1 + m * m;
if ((q * q * 1.0) / a > r * r) {
cout << fixed << setprecision(20) << abs((yw - r - y1 - r) / m) << "\n";
} else {
cout << -1 << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
void solve(int n) {
if (n == 4)
printf("1 * 2 = 2\n2 * 3 = 6\n4 * 6 = 24\n");
else if (n == 5)
printf("3 - 1 = 2\n2 + 2 = 4\n4 * 5 = 20\n20 + 4 = 24\n");
else {
printf("%d - %d = 1\n1 * 1 = 1\n", n, n - 1);
solve(n - 2);
}
}
int main() {
int n;
scanf("%d", &n);
if (n <= 3)
printf("NO\n");
else {
printf("YES\n");
solve(n);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O2")
using namespace std;
const int maxn = 500100, mod = 1e9 + 7, maxa = 1005, maxs = 820, maxb = 33,
base = 737, base2 = 3079, mod3 = 1e7 + 19;
const long long inf = 2e14, infint = 1e9 + 11;
long long max(long long x, long long y) { return (x > y ? x : y); }
long long min(long long x, long long y) { return (x < y ? x : y); }
vector<int> v[maxn];
vector<pair<int, int> > mna[maxn];
vector<int> to[maxn];
vector<int> cmp;
int a[maxn];
int b[maxn];
int seg[4 * maxn];
int lazy[4 * maxn];
inline int ind(int x) {
return int(upper_bound(cmp.begin(), cmp.end(), x) - cmp.begin());
}
inline void ok(int x) {
sort(mna[x].begin(), mna[x].end());
while (mna[x].size() > 2) {
mna[x].pop_back();
}
}
inline void dfs(int x, int p) {
mna[x].push_back(make_pair(a[x], x));
ok(x);
to[mna[x][0].second].push_back(x);
for (auto u : v[x]) {
if (u != p) {
mna[u] = mna[x];
dfs(u, x);
}
}
}
inline void shift(int x) {
lazy[2 * x] += lazy[x];
lazy[2 * x + 1] += lazy[x];
seg[2 * x] += lazy[x];
seg[2 * x + 1] += lazy[x];
lazy[x] = 0;
}
inline void update(int x, int l, int r, int s, int t, int val) {
if (l >= s && r <= t) {
seg[x] += val;
lazy[x] += val;
return;
}
shift(x);
int mid = (l + r) / 2;
if (s < mid) {
update(2 * x, l, mid, s, min(mid, t), val);
}
if (t > mid) {
update(2 * x + 1, mid, r, max(mid, s), t, val);
}
seg[x] = min(seg[2 * x], seg[2 * x + 1]);
}
inline int get() { return seg[1]; }
inline void add(int in, int val) { update(1, 0, maxn, 0, ind(in), val); }
inline bool check(int x, int val) {
for (auto u : to[x]) {
int mn2 = mna[u][1].first;
add(mna[u][0].first, -1);
add(min(mn2, val), 1);
}
bool res = (get() >= 0);
for (auto u : to[x]) {
int mn2 = mna[u][1].first;
add(mna[u][0].first, 1);
add(min(val, mn2), -1);
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> b[i];
cmp.push_back(b[i]);
}
sort(cmp.begin(), cmp.end());
dfs(0, -1);
mna[0].push_back(make_pair(infint, -1));
for (int i = 0; i < k; i++) {
add(b[i], -1);
}
for (int i = 0; i < n; i++) {
add(mna[i][0].first, 1);
}
if (get() >= 0) {
cout << 0 << endl;
return 0;
}
long long ans = infint;
for (int i = 0; i < n; i++) {
int l = a[i], r = infint;
if (!check(i, r)) {
continue;
}
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(i, mid)) {
r = mid;
continue;
}
l = mid;
}
ans = min(ans, r - a[i]);
}
if (ans >= infint) {
cout << -1 << endl;
return 0;
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
const long long oo = 1e18;
const long long mod = 1e9 + 7;
int a[N], sum[2 * N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
int cur = n;
long long ans = 0;
sum[cur] = 1;
long long q = 0;
for (int i = 0; i < n; i++) {
if (a[i] < m) {
cur--;
q -= sum[cur];
} else {
q += sum[cur];
cur++;
}
ans += q;
sum[cur]++;
}
memset(sum, 0, sizeof(sum));
cur = n;
sum[cur] = 1;
q = 0;
for (int i = 0; i < n; i++) {
if (a[i] < m + 1) {
cur--;
q -= sum[cur];
} else {
q += sum[cur];
cur++;
}
ans -= q;
sum[cur]++;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
const double eps = 1e-9;
long long INF = 1e9 + 7;
struct compare {
bool operator()(const int& l, const int& r) { return l > r; }
};
void read(string str, int node) {
stringstream ss;
int number;
ss << str;
while (ss >> number) cout << number << endl;
}
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
long long fp(long long b, long long p) {
if (p == 0) return 1;
if (p % 2 == 0) return fp((b * b) % INF, p / 2);
return (fp(b, p - 1) * b) % INF;
}
long long read_binary(string s) {
unsigned long long x = 0, tmp = 1;
for (int i = s.size() - 1; i >= 0; i--) {
x = (x + tmp * (s[i] - '0')) % INF;
tmp = (tmp * 2) % INF;
}
return x;
}
int dp[5007][6];
string s;
int rec(int i, int opr) {
if (i >= s.size()) return 0;
if (dp[i][opr] != 0) return dp[i][opr];
int& ret = dp[i][opr];
ret = max(ret, rec(i + 1, opr));
if (opr == 0) {
if (s[i] == 'a') {
ret = max(ret, rec(i + 1, 0) + 1);
} else {
ret = max(ret, rec(i + 1, 1) + 1);
}
} else if (opr == 1) {
if (s[i] == 'b') {
ret = max(ret, rec(i + 1, 1) + 1);
} else {
ret = max(ret, rec(i + 1, 2) + 1);
}
}
if (opr == 2) {
if (s[i] == 'a') {
ret = max(ret, rec(i + 1, 2) + 1);
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
scanf("%d", &n);
string s;
int i = 0;
int rem = (n % 7);
while (i < n) {
s += "ROYGBIV";
i += 7;
}
i = 0;
string ss;
for (int i = 0; i < n - rem; i++) ss += s[i];
if (rem == 1) ss += 'G';
if (rem == 2) ss += "GB";
if (rem == 3) ss += "GBI";
if (rem == 4) ss += "YGBI";
if (rem == 5) ss += "OYGBI";
if (rem == 6) ss += "ROYGBI";
cout << ss << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 6;
int n;
int a[maxi];
string s;
vector<int> ans;
void check(int x) {
int m = x;
int sum = 0;
while (m > 0) {
sum += m % 10;
m /= 10;
}
if (x + sum == n) {
ans.push_back(x);
}
}
int main() {
cin >> n;
for (int i = max(n - 1000, 1); i <= n; i++) check(i);
printf("%d\n", ans.size());
for (int i : ans) printf("%d\n", i);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, idx = 0;
string s;
cin >> n >> s;
for (int i = 0, len = s.size(); i < len - 1; ++i, ++idx) {
if (s[i] > s[i + 1]) break;
}
for (int i = 0, len = s.size(); i < len; ++i) {
if (i != idx) cout << s[i];
}
cout << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1000] = {0};
bool ispf(int x) {
int s = sqrt(x);
return (s * s == x);
}
bool isFib(int n) { return ispf(5 * n * n + 4) || ispf(5 * n * n - 4); }
int main() {
int yy = 0;
if (yy == 0)
;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
if (isFib(i)) {
cout << "O";
} else
cout << "o";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt[6];
inline int score(int a, int b) {
if (a * 2 > b) return 500;
if (a * 4 > b) return 1000;
if (a * 8 > b) return 1500;
if (a * 16 > b) return 2000;
if (a * 32 > b) return 2500;
return 3000;
}
inline int calc(int a, int b) { return a - 1ll * b * a / 250; }
int a[130][6];
inline bool check(int v) {
int val1 = 0, val2 = 0;
for (int i = 1; i <= 5; i++) {
if (a[1][i] == a[2][i]) continue;
if (a[1][i] < a[2][i]) {
val1 += calc(score(cnt[i], n + v), a[1][i]);
val2 += calc(score(cnt[i], n + v), a[2][i]);
} else {
if (a[1][i] == 250) {
val1 += calc(score(cnt[i], n + v), 250);
val2 += calc(score(cnt[i], n + v), a[2][i]);
} else {
val1 += calc(score(cnt[i] + v, n + v), a[1][i]);
val2 += calc(score(cnt[i] + v, n + v), a[2][i]);
}
}
}
return val1 > val2;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 5; j++) {
scanf("%d", &a[i][j]);
if (a[i][j] != -1)
cnt[j]++;
else
a[i][j] = 250;
}
}
for (int i = 0; i <= 50000; i++) {
if (check(i)) {
printf("%d\n", i);
return 0;
}
}
puts("-1");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long sum[500005], mx[500005];
long long n, p, q, r;
long long ans;
struct note {
int a, b, c;
} a[500005];
bool cmp(note i, note j) { return i.c > j.c; }
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &p, &q, &r);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i].a, &a[i].b, &a[i].c);
for (int i = 1; i <= n; i++)
mx[a[i].a] = max(mx[a[i].a], (long long)a[i].b + 1);
for (int i = p; i >= 1; i--) mx[i] = max(mx[i + 1], mx[i]);
for (int i = 1; i <= p; i++) sum[i] = sum[i - 1] + (q - mx[i]) + 1;
long long ma = 1, mb = 1;
sort(a + 1, a + n + 1, cmp);
int wz = 1;
for (int i = r; i >= 1; i--) {
while (wz <= n && a[wz].c == i) {
ma = max(ma, a[wz].a + 1ll);
mb = max(mb, a[wz].b + 1ll);
wz++;
}
if (ma > p || mb > q) break;
int x = ma, y = p, ret = ma - 1;
while (x <= y) {
int mid = (x + y) >> 1;
if (mx[mid] >= mb) {
x = mid + 1;
ret = mid;
} else
y = mid - 1;
}
ans += sum[ret] - sum[ma - 1] + 1ll * (p - ret) * (q - mb + 1);
}
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, l, t;
long long dist(long long a, long long b) {
if (b > a) return b - a;
return b - a + l;
}
int get(vector<long long> &a, int i, int x) {
int izq = i + 1, der = i + n - 1;
int r = i;
while (izq <= der) {
int med = (izq + der) / 2;
if (dist(a[i], a[med]) <= x)
izq = med + 1, r = med;
else
der = med - 1;
69;
69;
69;
69;
}
return r;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> l >> t;
vector<long long> a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
}
long long vueltas = t / l;
long long falto = t % l;
long long res = 2 * vueltas * n * (n - 1);
a.insert(a.end(), a.begin(), a.end());
69;
for (int i = 0; i < n; i++) {
res += get(a, i, 2 * falto) - i;
res += get(a, i, 2 * falto - l) - i;
}
long double r = .25 * res;
cout.precision(30);
cout << r << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, sol, bl, r, sbl, sr;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
if (i % 2 == 1) {
r = sbl + 1;
sr = sr + r;
r = r % 1000000007;
sr = sr % 1000000007;
sol += r;
sol = sol % 1000000007;
} else {
bl = sr + 1;
bl = bl % 1000000007;
sbl = sbl + bl;
sbl %= 1000000007;
sol += bl;
sol = sol % 1000000007;
}
}
cout << sol % 1000000007;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 1;
const long double eps = 1e-9;
struct Point {
long double x, y;
Point() {}
Point(long double x, long double y) : x(x), y(y) {}
long double operator*(const Point &other) const {
return x * other.x + y * other.y;
}
long double operator^(const Point &other) const {
return x * other.y - y * other.x;
}
Point operator-(Point &other) { return Point(x - other.x, y - other.y); }
Point operator+(Point &other) { return Point(x + other.x, y + other.y); }
bool operator==(Point &other) { return x == other.x && y == other.y; }
friend ostream &operator<<(ostream &ouf, const Point &p) {
return ouf << p.x << ' ' << p.y;
}
};
Point maxpnt(Point a, Point b) {
if (a.x > b.x)
return a;
else if (abs(a.x - b.x) < eps && a.y > b.y)
return a;
return b;
}
struct Line {
long double a, b, c;
Line(const Point &n, const Point &m) {
a = m.y - n.y;
b = n.x - m.x;
c = -a * n.x - b * n.y;
}
friend ostream &operator<<(ostream &ouf, const Line &line) {
return ouf << line.a << ' ' << line.b << ' ' << line.c;
}
};
bool cmp(Point a, Point b) {
long long vect_prod = a ^ b;
long long lenA = a * a;
long long lenB = b * b;
return (vect_prod == 0) ? (lenA < lenB) : (vect_prod > 0);
}
long double dist(Point a, Point b) {
return sqrt((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y));
}
bool inSeg(Point a, Point two, Point three) {
long double len1 = dist(a, two);
long double len2 = dist(a, three);
long double len3 = dist(two, three);
Point vect1;
vect1.x = a.x - two.x;
vect1.y = a.y - two.y;
Point vect2;
vect2.x = a.x - three.x;
vect2.y = a.y - three.y;
long double sq = abs(vect1.x * vect2.y - vect2.x * vect1.y) / 2;
if (sq > eps || abs(len3 - len2 - len1) > eps) return 0;
return 1;
}
long double angle(Point a, Point one, Point two) {
Point vect1(a.x - one.x, a.y - one.y);
Point vect2(a.x - two.x, a.y - two.y);
return atan2(vect1 ^ vect2, vect1 * vect2);
}
int doIntersect(Line &one, Line &two) {
if (abs(one.a * two.b - one.b * two.a) < eps)
return abs(one.b * two.c - one.c * two.b) < eps &&
abs(one.a * two.c - one.c * two.a) < eps
? 2
: 0;
else
return 1;
}
Point intersection(Line &one, Line &two) {
double x = (double)(Point(one.c, two.c) ^ Point(one.b, two.b)) /
(double)(Point(one.b, two.b) ^ Point(one.a, two.a));
double y = (double)(Point(one.a, two.a) ^ (Point(one.c, two.c))) /
(double)(Point(one.b, two.b) ^ Point(one.a, two.a));
return Point(x, y);
}
int main() {
cout.precision(100);
int n, p, q;
cin >> n >> p >> q;
int max_p = -inf, max_q = -inf;
set<pair<int, int> > b;
vector<Point> a;
long double ans = 1e9;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
max_p = max(max_p, x);
max_q = max(max_q, y);
b.insert({x, y});
max_q = max(max_q, y);
long double t1 = (1.0 * p) / x;
long double t2 = (1.0 * q) / y;
ans = min(ans, max(t1, t2));
}
for (auto it : b) a.push_back(Point(it.first, it.second));
if (a.size() == 1) {
cout << fixed << setprecision(30);
cout << max((1.0 * p) / a[0].x, (1.0 * q) / a[0].y) << endl;
return 0;
}
a.push_back(Point(max_p, 0));
a.push_back(Point(0, max_q));
n = (int)a.size();
Point minp = a[0];
for (int i = 1; i < n; ++i) {
if (a[i].y < minp.y)
minp = a[i];
else if (a[i].y == minp.y && a[i].x < minp.x)
minp = a[i];
}
for (int i = 0; i < n; ++i) a[i] = a[i] - minp;
sort(a.begin(), a.end(), cmp);
vector<Point> st;
st.push_back(a[0]);
st.push_back(a[1]);
for (int i = 2; i < n; ++i) {
while (st.size() > 1 &&
((st.back() - st[st.size() - 2]) ^ (a[i] - st.back())) <= 0)
st.pop_back();
st.push_back(a[i]);
}
for (int i = 0; i < (int)st.size(); ++i) st[i] = st[i] + minp;
st.push_back(st[0]);
if (st.size() == 1) {
cout << max(p / st[0].x, q / st[0].y);
return 0;
}
Line work(Point(0, 0), Point(p, q));
long double res = 1e17;
for (int i = 0; i < (int)st.size() - 1; ++i) {
Line cur(st[i], st[i + 1]);
Point inter = intersection(cur, work);
if (abs(dist(st[i + 1], st[i]) - dist(st[i], inter) -
dist(st[i + 1], inter)) < eps)
res =
min(res, max(((long double)p) / inter.x, ((long double)q) / inter.y));
}
cout << fixed << setprecision(7) << res << endl;
;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int x[500], y[500], l[500];
int r[500], pr[500];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < m; i++) cin >> l[i];
memset(r, -1, sizeof(r));
memset(pr, -1, sizeof(pr));
int f = 1;
for (int i = 0; i < n; i += 2) {
int pi = (i + n - 1) % n;
int ni = (i + 1) % n;
int pd = abs(x[i] - x[pi]) + abs(y[i] - y[pi]);
int nd = abs(x[i] - x[ni]) + abs(y[i] - y[ni]);
for (int j = 0; j < m; j++)
if (l[j] == pd + nd && pr[j] == -1) {
r[i] = j;
pr[j] = i;
break;
}
if (r[i] == -1) {
f = 0;
break;
}
}
if (f) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (r[i] == -1) r[i]--;
cout << r[i] + 1 << ' ';
}
cout << endl;
} else {
memset(r, -1, sizeof(r));
memset(pr, -1, sizeof(pr));
for (int i = 1; i < n; i += 2) {
int pi = (i + n - 1) % n;
int ni = (i + 1) % n;
int pd = abs(x[i] - x[pi]) + abs(y[i] - y[pi]);
int nd = abs(x[i] - x[ni]) + abs(y[i] - y[ni]);
for (int j = 0; j < m; j++)
if (l[j] == pd + nd && pr[j] == -1) {
r[i] = j;
pr[j] = i;
break;
}
if (r[i] == -1) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (r[i] == -1) r[i]--;
cout << r[i] + 1 << ' ';
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n % 4 == 0)
cout << "YES";
else
cout << "NO";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B, typename C>
struct triple {
A X;
B Y;
C Z;
triple(A a = 0, B b = 0, C c = 0) : X(a), Y(b), Z(c) {}
};
template <typename A, typename B, typename C>
triple<A, B, C> make_triple(A a = 0, B b = 0, C c = 0) {
return triple<A, B, C>(a, b, c);
}
template <typename A, typename B, typename C>
bool operator<(const triple<A, B, C>& a, const triple<A, B, C>& b) {
if (a.X != b.X) return a.X < b.X;
if (a.Y != b.Y) return a.Y < b.Y;
return a.Z < b.Z;
}
template <typename T, typename SS>
ostream& operator<<(ostream& ofs, const pair<T, SS>& p) {
ofs << "( " << p.first << " , " << p.second << " )";
return ofs;
}
template <typename T>
void print(T a) {
for (auto i : a) cout << i << ' ';
cout << '\n';
}
template <typename T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <typename T>
T min(T a, T b, T c) {
return min(a, max(b, c));
}
vector<vector<long long> > g;
vector<long long> h;
vector<long long> p;
void dfs(long long v, long long hh = 0, long long pp = -1) {
h[v] = hh;
for (auto to : g[v])
if (to != pp) {
p[to] = v;
dfs(to, hh + 1, v);
}
}
signed main() {
srand(time(NULL));
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
g.resize(n);
p.resize(n);
h.resize(n);
for (long long _ = 0; _ < (n - 1); _++) {
long long x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(0);
set<pair<long long, long long> > need;
for (long long i = 0; i < n; i++)
if (h[i] > 2) need.insert(make_pair(-h[i], i));
long long ans = 0;
while (need.size()) {
long long x = need.begin()->second;
long long y = p[x];
if (need.count(make_pair(-h[y], y))) need.erase(make_pair(-h[y], y));
for (auto to : g[y])
if (need.count(make_pair(-h[to], to))) need.erase(make_pair(-h[to], to));
ans++;
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const unsigned int &first) { printf("%u", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const float &first) { printf("%.15f", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const string &first) { printf("%s", first.c_str()); }
void fast_print(const char v[]) { fast_print((string)v); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &first : v) {
fast_print(first);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template <class T, class... Args>
void _print(deque<string> names, T elem, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(elem);
names.pop_front();
_print(names, args...);
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace typedefs {}
namespace numbers_operation {
template <class T>
T floor_mod(T a, T b) {
if (a % b == 0) return 0;
if (a >= 0 && b >= 0) return a % b;
if (a <= 0 && b <= 0) return a % b;
return abs(b) - (abs(a) % abs(b));
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
int n, m, k;
vector<vector<int>> g;
vector<int> trap;
vector<int> ztraps;
int traps = 0;
vector<vector<double>> gauss(vector<vector<double>> M) {
for (int i = 0; i < (((int)M[0].size())); i++) {
int unz = 0;
for (int j = 0; j < (((int)M.size())); j++) {
if (abs(M[j][i]) > abs(M[unz][i])) {
unz = j;
}
}
if (M[unz][i] == 0) continue;
double cor = M[unz][i];
for (int j = 0; j < (((int)M[0].size())); j++) {
M[unz][j] /= cor;
}
for (int j = 0; j < (((int)M.size())); j++) {
double coef = M[j][i] / M[unz][i];
for (int k = 0; k < (((int)M[0].size())); k++) {
M[j][k] -= coef * M[unz][k];
}
}
}
return M;
}
vector<vector<double>> merge(vector<vector<double>> A,
vector<vector<double>> B) {
vector<vector<double>> C(traps, vector<double>(traps));
for (int st = 0; st < (traps); st++) {
for (int inter = 0; inter < (traps); inter++) {
for (int end = 0; end < (traps); end++) {
C[st][end] += A[st][inter] * B[inter][end];
}
}
}
return C;
}
vector<double> operator*(vector<double> v, double d) {
for (double &first : v) {
first *= d;
}
return v;
}
vector<double> operator+(vector<double> a, vector<double> b) {
assert(((int)a.size()) == ((int)b.size()));
for (int i = 0; i < (((int)b.size())); i++) {
a[i] += b[i];
}
return a;
}
vector<double> operator-(vector<double> a, vector<double> b) {
return a + (b * -1);
}
vector<vector<double>> get_first() {
vector<vector<double>> prob(n, vector<double>(n));
for (int i = 0; i < n; i++) {
if (trap[i]) {
prob[i][i] = 1;
} else {
for (int j : g[i]) {
prob[i][j] += 1.0 / ((int)g[i].size());
}
}
}
vector<vector<double>> R(n, vector<double>(n));
for (int i = 0; i < n; i++) {
prob[i][i] -= 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (trap[j]) {
R[i][j] = -prob[i][j];
prob[i][j] = 0;
}
}
}
for (int i = 0; i < n; i++) {
if (trap[i]) continue;
for (int j = i + 1; j < n; j++) {
if (abs(prob[j][i]) > abs(prob[i][i])) {
swap(prob[j], prob[i]);
swap(R[j], R[i]);
}
}
for (int j = i + 1; j < n; j++) {
double cor = prob[j][i] / prob[i][i];
for (int k = 0; k < n; k++) {
prob[j][k] -= cor * prob[i][k];
R[j][k] -= cor * R[i][k];
}
}
}
vector<vector<double>> final(n, vector<double>(n));
for (int i = n - 1; i > -1; i--) {
if (trap[i]) continue;
for (int j = 0; j < n; j++) {
R[i][j] /= prob[i][i];
}
prob[i][i] = 1;
for (int j = 0; j < i; j++) {
for (int k = 0; k < n; k++) {
R[j][k] -= prob[j][i] * R[i][k];
}
prob[j][i] = 0;
}
}
vector<vector<double>> next(n, vector<double>(n));
for (int i = 0; i < n; i++) {
if (trap[i]) {
R[i] = vector<double>(n, 0);
R[i][i] = 1;
}
double c = 1;
for (int j = 0; j < n; j++) {
c -= R[i][j];
}
}
return R;
}
vector<vector<double>> one;
vector<vector<double>> fast_pow(int k) {
if (k == 1) {
if (!one.empty()) return one;
vector<vector<double>> F = get_first();
vector<vector<double>> P(traps, vector<double>(traps));
for (int i = 0; i < (traps); i++) {
for (int j = 0; j < (traps); j++) {
for (int sub : g[ztraps[i]]) {
P[i][j] += F[sub][ztraps[j]];
}
P[i][j] /= ((int)g[ztraps[i]].size());
}
}
return one = P;
} else {
if (k % 2 == 0) {
vector<vector<double>> first = fast_pow(k / 2);
return merge(first, first);
} else {
vector<vector<double>> first = fast_pow(k - 1);
return merge(first, fast_pow(1));
}
}
}
signed main(signed argc, char *argv[]) {
cin, n, m, k;
trap.resize(n);
g.resize(n);
cin, trap;
for (int i = 0; i < (n); i++) {
traps += trap[i];
if (trap[i]) {
ztraps.push_back(i);
}
}
for (int i = 0; i < (m); i++) {
int a, b;
cin, a, b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
if (k == 2) {
vector<vector<double>> F = get_first();
smart_io::precall_print();
cout, F[0][n - 1];
} else {
vector<vector<double>> P = fast_pow(k - 2);
vector<vector<double>> F = get_first();
double rez = 0;
for (int i = 0; i < (traps); i++) {
rez += F[0][ztraps[i]] * P[i][traps - 1];
}
smart_io::precall_print();
cout, rez;
}
}
| 10 |
#include <bits/stdc++.h>
#define ll long long
#define pp push_back
#define ff first
#define ss second
using namespace std;
ll w,m,mm,h,r,l,ii,i1,jj,x[1000001],y[1000001],z,g,aa,bb,a,b,c,d,vis[1000001],k,kk,mod=1e9+7,q,inf=1e18;
ll T,i,j,n;
vector <pair <ll,ll> > v,vv;
pair <ll,ll> p[1000001];
map <ll,ll> mp,mpp,mppp;
multiset <ll> se,see;
multiset <ll> :: iterator it,itt,it1;
string s,s2,s1;
char cc;
int main()
{
ios::sync_with_stdio(0);
cin >> T;
while(T--)
{
cin >> n;
for(i=0;i<2*n;i++)
cin >> x[i];
sort(x,x+2*n);
a=0;
b=0;
j=0;
for(i=n*2-1;i>0;i-=2)
{
if(x[i]!=x[i-1] || (x[i]-a)%((n-j)*2)!=0 || x[i]-a<=0 || x[i]==x[i-2])
{
b=1;
break;
}
x[i]-=a;
a+=x[i]/((n-j));
j++;
}
if(b==0)
cout << "YES";
else
cout << "NO";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie();
iostream::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> res(n);
for (int i = 0; i < n; i++) {
cin >> res[i];
}
sort(res.begin(), res.end());
int count = 0;
for (int j = 1; j < n; j++) {
count += (int)(k - res[j]) / res[0];
}
cout << count << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101111;
int n, m, deg[maxn];
int main() {
cin >> n >> m;
m *= 2;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
deg[u]++;
deg[v]++;
}
int num = 0;
for (int i = 1; i <= n; i++) {
if (deg[i] == 1) {
num++;
}
}
cout << fixed << setprecision(18) << 1.0 * m / num << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long MOD = 1e+9 + 7;
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const long long MAXN = 4e+5 + 7;
void solve();
long long min(long long a, long long b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
while (T--) {
solve();
cout << "\n";
}
return 0;
}
void solve() {
int n;
cin >> n;
vector<int> a;
while (n > 0) {
string t = to_string(n);
bool flg = false;
for (long long i = 0; i < t.length(); i++) {
if (t[i] > '1') flg = true;
t[i] = '0' + (t[i] > '0');
}
if (!flg) {
a.push_back(n);
break;
}
stringstream lolnice(t);
int x = 0;
lolnice >> x;
n -= x;
a.push_back(x);
}
cout << a.size() << '\n';
for (long long i = 0; i < a.size(); i++) cout << a[i] << ' ';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int streak = 0;
vector<int> ls;
for (int i = 0; i < n; i++) {
if (s[i] == 'x')
streak++;
else {
if (streak > 2) {
ls.push_back(streak);
}
streak = 0;
}
}
if (streak > 2) {
ls.push_back(streak);
}
int ans = 0;
for (int i = 0; i < ls.size(); i++) {
ans += (ls[i] - 2);
}
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> cnt1, cnt2, cnt3;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
++cnt1[x];
}
for (int i = 1; i <= n - 1; ++i) {
int x;
scanf("%d", &x);
++cnt2[x];
}
for (int i = 1; i <= n - 2; ++i) {
int x;
scanf("%d", &x);
++cnt3[x];
}
for (map<int, int>::iterator it = cnt1.begin(); it != cnt1.end(); ++it)
if (it->second != cnt2[it->first]) {
printf("%d\n", it->first);
break;
}
for (map<int, int>::iterator it = cnt2.begin(); it != cnt2.end(); ++it)
if (it->second != cnt3[it->first]) {
printf("%d", it->first);
break;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int idx, pos, num, dir;
};
int chk[105][205][55][2];
int main() {
string s;
int n;
cin >> s;
cin >> n;
queue<Node> q;
Node node = {0, 100, n, 0};
q.push(node);
int res = 0;
while (!q.empty()) {
Node node = q.front();
q.pop();
int idx = node.idx, pos = node.pos, num = node.num, dir = node.dir;
if (idx == s.size()) {
if (num == 0) res = max(res, abs(100 - pos));
continue;
}
int dx = dir ? 1 : -1;
if (s[idx] == 'T') {
if (!chk[idx + 1][pos][num][!dir]) {
chk[idx + 1][pos][num][!dir] = 1;
Node temp = {idx + 1, pos, num, !dir};
q.push(temp);
}
bool tdir = dir;
for (int i = 1; i <= num; ++i) {
if (i % 2)
dx = dir ? 1 : -1;
else
dx = 0;
if (!chk[idx + 1][pos + dx][num - i][tdir]) {
chk[idx + 1][pos + dx][num - i][tdir] = 1;
Node temp = {idx + 1, pos + dx, num - i, tdir};
q.push(temp);
}
tdir = !tdir;
}
} else {
if (!chk[idx + 1][pos + dx][num][dir]) {
chk[idx + 1][pos + dx][num][dir] = 1;
Node temp = {idx + 1, pos + dx, num, dir};
q.push(temp);
}
int tdir = dir;
for (int i = 1; i <= num; ++i) {
if (i % 2 == 0)
dx = dir ? 1 : -1;
else
dx = 0;
if (!chk[idx + 1][pos + dx][num - i][!tdir]) {
chk[idx + 1][pos + dx][num - i][!tdir] = 1;
Node temp = {idx + 1, pos + dx, num - i, !tdir};
q.push(temp);
}
tdir = !tdir;
}
}
}
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const long double pi = acos(-1);
const int mod = 998244353;
const int mod1 = 1e9 + 7;
mt19937_64 rnd(time(0));
void faster() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
}
vector<long long> d1;
vector<long long> d2;
void calc(string &s) {
long long n = ((long long)(s).size());
long long l = 0, r = -1;
for (int i = 0; i < n; i++) {
long long k = 0;
if (i <= r) {
k = min(r - i, d1[r - i + l]);
}
while (i + k + 1 < n && i - k - 1 >= 0 && s[i + k + 1] == s[i - k - 1]) {
k++;
}
d1[i] = k;
if (i + k > r) {
l = i - k;
r = i + k;
}
}
l = 0;
r = -1;
for (int i = 0; i < n; i++) {
long long k = 0;
if (i <= r) {
k = min(r - i + 1, d2[r - i + l + 1]);
}
while (i + k < n && i - k - 1 >= 0 && s[i + k] == s[i - k - 1]) k++;
d2[i] = k;
if (i + k - 1 > r) {
l = i - k;
r = i + k - 1;
}
}
}
signed main() {
faster();
double start = clock();
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long n = ((long long)(s).size());
d1.assign(((long long)(s).size()), 0);
d2.assign(((long long)(s).size()), 0);
long long l = 0, r = n - 1, maxl = 0, minr = n - 1;
calc(s);
while (s[l] == s[r]) {
l++;
r--;
maxl = l;
minr = r;
if (l == n) break;
}
long long maxn = 0, id = -1, ok = 0, la = 0;
for (int i = 0; i < n; i++) {
long long t = d1[i];
if (maxl > i - t - 1 || minr < i + t + 1) {
long long a = min(maxl, max({0ll, min(i - t, n - i - t - 1)}));
if (a * 2 + t * 2 + 1 > maxn) {
maxn = a * 2 + t * 2 + 1;
ok = -1;
id = i;
la = a;
}
}
t = d2[i];
if (maxl > i - t - 1 || minr < i + t) {
long long a = min(maxl, max({0ll, min(i - t, n - i - t)}));
if (a * 2 + t * 2 > maxn) {
maxn = a * 2 + t * 2;
ok = 1;
id = i;
la = a;
}
}
}
if (ok == -1) {
long long t = d1[id];
cout << s.substr(0, la) << s.substr(id - t, t * 2 + 1)
<< s.substr(n - la);
} else {
long long t = d2[id];
cout << s.substr(0, la) << s.substr(id - t, t * 2) << s.substr(n - la);
}
cout << endl;
}
cerr << "Time " << (clock() - start) * 1.0 / CLOCKS_PER_SEC << "s\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3fLL;
const double err = 1e-9;
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
int pos[N];
int fq[N];
int lq[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int n, k;
cin >> n >> k;
ll ans = n * 3 - 2;
memset(lq, -1, sizeof lq);
memset(fq, -1, sizeof fq);
for (int(i) = (0); (i) < (k); (i)++) {
int x;
cin >> x;
x--;
if (fq[x] != -1) lq[x] = max(lq[x], i);
if (fq[x] == -1) fq[x] = i, lq[x] = i;
}
for (int(i) = (0); (i) < (n); (i)++) {
if (fq[i] != -1) {
ans--;
if (i != n - 1 and lq[i + 1] > fq[i]) ans--;
if (i != 0 and lq[i - 1] > fq[i]) ans--;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int kiemra(int n, string s, string ss) {
int i;
for (i = 0; i < n; i++) {
if (s[i] != '.' && s[i] != ss[i]) {
return 0;
}
}
return 1;
}
int main() {
string v = "vaporeon", j = "jolteon", f = "flareon", e = "espeon",
u = "umbreon", l = "leafeon", g = "glaceon", s = "sylveon";
string in;
int n;
cin >> n >> in;
if (n == 6) {
if (kiemra(n, in, e) == 1) cout << e;
} else if (n == 7) {
if (kiemra(n, in, j) == 1)
cout << j;
else if (kiemra(n, in, f) == 1)
cout << f;
else if (kiemra(n, in, u) == 1)
cout << u;
else if (kiemra(n, in, l) == 1)
cout << l;
else if (kiemra(n, in, g) == 1)
cout << g;
else if (kiemra(n, in, s) == 1)
cout << s;
} else {
if (kiemra(n, in, v) == 1) cout << v;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long pf[10000001];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void prime() {
memset(pf, 0, 10000001);
pf[0] = pf[1] = 1;
for (long long i = 2; i < 10000001; i++) {
if (pf[i] == 0) {
for (long long j = i * i; j < 10000001; j = j + i) pf[j] = 1;
}
}
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
int check_ps(long long n) {
double sqrt_n = sqrt(n);
if (sqrt_n == int(sqrt_n)) {
return 1;
} else {
return 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long x, y;
cin >> x >> y;
if (x == y)
cout << "YES";
else if (x == 1)
cout << "NO";
else if (x == 2 && y > 3)
cout << "NO";
else if (x == 3 && y > 3)
cout << "NO";
else
cout << "YES";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100, M = 3e5 + 7;
const long long MOD = 1e9 + 7;
vector<pair<int, int> > p[N];
long long dp[M], gou[M], dp1[M], gou1[M];
int f[N], par[N][20], dep[N], dis[N], u[N], v[N], w[N];
bool vis[N];
vector<int> vec[50];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void dfs(int x, int fa, int r) {
par[x][0] = fa;
dep[x] = dep[fa] + 1;
dis[x] = r;
for (pair<int, int> v : p[x])
if (v.first != fa) {
dfs(v.first, x, v.second);
}
}
void init(int n) {
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= n; j++) {
par[j][i] = par[par[j][i - 1]][i - 1];
}
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 19; i >= 0; i--)
if ((dep[u] - dep[v]) >> i & 1) u = par[u][i];
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
return par[u][0];
}
void fwt(long long a[], int n) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; j++) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) % MOD;
a[i + j + d] = (x - y + MOD) % MOD;
}
}
}
}
void ifwt(long long a[], int n) {
int inv2 = (MOD + 1) / 2;
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; j++) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) * inv2 % MOD;
a[i + j + d] = (x - y + MOD) * inv2 % MOD;
}
}
}
}
int main() {
int n, m, n1 = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) f[i] = i;
int x = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u[i], &v[i], &w[i]);
x ^= w[i];
if (find(u[i]) != find(v[i])) {
vis[i] = true;
p[u[i]].push_back({v[i], w[i]});
p[v[i]].push_back({u[i], w[i]});
f[find(u[i])] = find(v[i]);
n1++;
}
}
if (n1 != n - 1) {
printf("0 0");
return 0;
}
dfs(1, 0, 0);
init(n);
int cnt = 0;
for (int i = 1; i <= m; i++) {
if (!vis[i]) {
vec[++cnt].push_back(w[i]);
int now = u[i], lc = lca(u[i], v[i]);
while (now != lc) {
vec[cnt].push_back(dis[now]);
now = par[now][0];
}
now = v[i];
while (now != lc) {
vec[cnt].push_back(dis[now]);
now = par[now][0];
}
}
}
int t = 131072;
for (int i = 0; i < t; i++) dp[i] = 0;
dp[x] = 1;
fwt(dp, t);
for (int i = 0; i < t; i++) dp1[i] = dp[i];
for (int i = 1; i <= cnt; i++) {
for (int j = 0; j < t; j++) gou[j] = 0, gou1[j] = 0;
for (int j : vec[i]) gou[j]++, gou1[j] = 1;
fwt(gou, t);
fwt(gou1, t);
for (int j = 0; j < t; j++) {
dp[j] = dp[j] * gou[j] % MOD;
dp1[j] = dp1[j] * gou1[j] % MOD;
}
}
ifwt(dp, t);
ifwt(dp1, t);
for (int i = 0; i < t; i++) {
if (dp1[i]) {
printf("%d %lld\n", i, dp[i]);
return 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string str;
getline(cin, str);
getline(cin, str);
vector<int> free;
for (size_t i = 0; i < str.size(); ++i) {
if (str[i] == '0') free.push_back(int(i));
}
int left = 0;
int opt = 0;
int res = free[left + K] - free[left];
for (; left + K < int(free.size()); ++left) {
while (opt + 1 <= left + K &&
free[opt + 1] - free[left] < free[left + K] - free[opt + 1])
++opt;
res = min(res,
max(free[opt + 1] - free[left], free[left + K] - free[opt + 1]));
res = min(res, max(free[opt] - free[left], free[left + K] - free[opt]));
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int mem[10003][5003];
long long factorio[5003];
long long fact(int n) {
if (n < 2) return 1;
if (factorio[n] != 0)
return factorio[n];
else {
factorio[n] = ((fact(n - 1) * (long long)n) % 998244353);
return factorio[n];
}
}
int ncr(int n, int r) {
if (r == 0) return 1;
if (r == n) return 1;
if (mem[n][r] != 0)
return mem[n][r];
else {
mem[n][r] = (ncr(n - 1, r - 1) + ncr(n - 1, r)) % 998244353;
return mem[n][r];
}
}
int main() {
int a, b, c;
std::cin >> a >> b >> c;
int i;
long long as = 0, bs = 0, cs = 0, ans;
int mab = std::min(a, b), mbc = std::min(b, c), mca = std::min(c, a);
for (i = 0; i < mab + 1; i++) {
as += ((long long)ncr(a, i) * (long long)ncr(b, i)) % 998244353 * fact(i);
as %= 998244353;
}
for (i = 0; i < mbc + 1; i++) {
bs += ((long long)ncr(b, i) * (long long)ncr(c, i)) % 998244353 * fact(i);
bs %= 998244353;
}
for (i = 0; i < mca + 1; i++) {
cs += ((long long)ncr(c, i) * (long long)ncr(a, i)) % 998244353 * fact(i);
cs %= 998244353;
}
ans = ((as * bs) % 998244353 * cs) % 998244353;
std::cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int shower[6][6];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
cin >> shower[i][j];
}
}
int a[6], temp = 0, sol = -1;
for (int i = 0; i < 5; i++) {
a[i] = i;
}
do {
temp = shower[a[0]][a[1]] + shower[a[1]][a[0]];
temp += shower[a[2]][a[3]] + shower[a[3]][a[2]];
temp += shower[a[1]][a[2]] + shower[a[2]][a[1]];
temp += shower[a[3]][a[4]] + shower[a[4]][a[3]];
temp += shower[a[2]][a[3]] + shower[a[3]][a[2]];
temp += shower[a[4]][a[3]] + shower[a[3]][a[4]];
sol = max(sol, temp);
} while (next_permutation(a, a + 5));
cout << sol << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
const int N = 1e6 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int x;
cin >> x;
if (x % 4 == 1) {
cout << "0 A\n";
} else if (x % 4 == 3) {
cout << "2 A\n";
} else if (x % 4 == 2) {
cout << "1 B\n";
} else {
cout << "1 A\n";
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.