solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
double dp[1 << 21];
const double pi = acos(-1);
struct node {
double x, y, a;
} s[25];
int n;
double l, r;
double get(double x, int p) {
x += l;
double a = s[p].a / 180 * pi, re = 0;
double y = s[p].y;
if (x <= s[p].x) {
double ll = sqrt(y * y + (s[p].x - x) * (s[p].x - x));
a -= acos(y / ll);
if (a >= pi / 2) return r - l;
re = tan(a) * y + sqrt(ll * ll - y * y);
} else {
x -= s[p].x;
a += atan(x / y);
if (a >= pi / 2) return r - l;
re = y * tan(a) - x;
}
return re;
}
int main() {
cin >> n >> l >> r;
for (int i = 0; i < n; i++) cin >> s[i].x >> s[i].y >> s[i].a;
int lim = 1 << n;
for (int i = 0; i < lim; i++) {
if (dp[i] == r - l) continue;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) continue;
dp[i + (1 << j)] = max(dp[i + (1 << j)], dp[i] + get(dp[i], j));
}
}
double ans = 0;
for (int i = 1; i < lim; i++) ans = max(ans, dp[i]);
printf("%.9lf\n", min(ans, r - l));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, cnt = 0;
cin >> a >> b;
while (a % b != 0) {
if (a >= b) {
cnt += a / b;
a -= a / b * b;
} else {
swap(a, b);
}
}
cnt += a / b;
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool f[(1000)][(1000)];
bool vis[(1000)];
int ans[(1000)], now[(1000)];
int n, sum, tot;
const int bound = 200;
int main() {
scanf("%d", &n);
if (n == 2) {
scanf("%d", &sum);
for (int i = 1; i <= sum; i++) scanf("%d", &now[i]);
printf("1 %d\n%d", now[1], sum - 1);
for (int i = 2; i <= sum; i++) printf(" %d", now[i]);
puts("");
return 0;
}
for (int i = 1; i <= (n - 1) * n / 2; i++) {
scanf("%d", &sum);
for (int k = 1; k <= sum; k++) scanf("%d", &now[k]);
for (int j = 1; j <= sum; j++) {
int k = now[j];
if (ans[k]) continue;
if (!vis[k]) {
vis[k] = true;
for (int a = 1; a <= sum; a++) f[k][now[a]] = true;
} else {
tot++;
for (int a = 1; a <= sum; a++)
if (f[k][now[a]]) ans[now[a]] = tot;
}
}
}
for (int i = 1; i <= tot; i++) {
int num = 0;
for (int j = 1; j <= bound; j++)
if (ans[j] == i) num++;
printf("%d", num);
for (int j = 1; j <= bound; j++)
if (ans[j] == i) printf(" %d", j);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target ("avx,avx2,fma")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#define X first
#define Y second
#define debug(x) cerr << #x << ": " << x << endl;
#define endl '\n'
#define pb push_back
#define rep(i,l,r) for (int i=l; i<r; i++)
#define repr(i,r,l) for (int i=r; i>=l; i--)
using namespace std;
typedef long long int ll;
typedef pair<int,int> pll;
const long long int N=5e2+30,mod = 1e9+7,inf=2e5;
const long double eps = 0.0001;
int a[N];
int main(){
int T;
cin >> T;
while (T--){
int n,x,j=-1;
bool f = 0;
cin >> n >> x;
rep(i,0,n){
cin >> a[i];
if (i && a[i] < a[i-1]) j = i-1;
}
int ans = 0;
rep(i,0,n){
if (!i){
if (j > 0 && a[i] > x){
swap(a[i],x);
ans++;
}
continue;
}
if ((a[i] < a[i-1] || i <= j) && a[i-1] > x){
swap(a[i-1],x);
ans++;
}
if (a[i] < a[i-1]){
f = 1;
break;
}
}
if (f){
cout << -1 << endl;
continue;
}
//if (n >= 2 && a[0] > a[1]) ans++;
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <typename T>
int sgn(T val) {
return (T(0) < val) - (val < T(0));
}
long long read() {
long long x = 0;
bool q = 0;
char c = getchar();
while (!isdigit(c)) q |= (c == '-'), c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + c - '0', c = getchar();
return q ? -x : x;
}
char buffer[22], len_b = 0;
void print(long long x, char q = '\n') {
if (x < 0) putchar('-'), x = -x;
if (x == 0) putchar('0');
buffer[len_b++] = q;
while (x > 0) buffer[len_b++] = x % 10 + '0', x /= 10;
while (len_b) putchar(buffer[--len_b]);
}
string read_s() {
string s;
char c = getchar();
while (c == ' ' || c == '\t' || c == '\n') c = getchar();
while (c != ' ' && c != '\t' && c != '\n') s += c, c = getchar();
return s;
}
void print_s(string s, char q = '\n') {
for (char c : s) putchar(c);
putchar(q);
}
const int MAX_N = 200002;
int a[MAX_N], ans[MAX_N];
bool used[MAX_N];
vector<pair<int, int> > adj[MAX_N];
int dfs(int x = 0) {
int e = a[x];
used[x] = 1;
int ptr = -1;
for (auto u : adj[x])
if (!used[u.first]) {
int f = dfs(u.first);
if (u.second > 0)
ans[u.second - 1] = f;
else
ans[-u.second - 1] = -f;
e += f;
}
return e;
}
int main() {
int n = read();
long long wv = 0;
for (int i = 0; i < n; i++) a[i] = read(), wv += a[i];
if (wv != 0)
puts("Impossible");
else {
puts("Possible");
int m = read();
for (int i = 1; i <= m; i++) {
int x = read() - 1, y = read() - 1;
adj[x].push_back({y, i});
adj[y].push_back({x, -i});
}
for (int i = 0; i < n; i++)
if (!used[i]) dfs(i);
for (int i = 0; i < m; i++) print(ans[i]);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char sc[1000005];
int dp[1000002][2];
int le, dix, dig;
int cost(int x, int g) {
if (g == 0) {
return sc[x] - '0';
} else {
return 1 - (sc[x] - '0');
}
}
int main() {
gets(sc);
le = strlen(sc);
dp[le][0] = 0;
dp[le][1] = 2123123123;
for (int i = le - 1; i >= 0; i--) {
dp[i][0] = min(cost(i, 0) + dp[i + 1][0], 1 + cost(i, 1) + dp[i + 1][1]);
dp[i][1] = min(cost(i, 1) + dp[i + 1][1], 1 + cost(i, 1) + dp[i + 1][0]);
}
printf("%d\n", dp[0][0]);
int x = 0;
int g = 0;
for (int i = 0; i < le; i++) {
if (g == 0) {
if (cost(i, 0) + dp[i + 1][0] < 1 + cost(i, 1) + dp[i + 1][1]) {
if (cost(i, 0)) printf("+2^%d\n", le - i - 1);
} else {
g = 1 - g;
printf("+2^%d\n", le - i);
}
} else {
if (cost(i, 1) + dp[i + 1][1] < 1 + cost(i, 1) + dp[i + 1][0]) {
if (cost(i, 1)) printf("-2^%d\n", le - i - 1);
} else {
g = 1 - g;
printf("-2^%d\n", le - i - 1);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a, C b) {
a = min(a, b);
}
template <class C>
void maxi(C& a, C b) {
a = max(a, b);
}
void a() {
int n, x, y;
cin >> n >> x >> y;
int res = 0;
while (n * y > (x + res) * 100) res++;
cout << res << '\n';
}
bool esAum(string a) {
int n = a.size();
for (int i = 0; i < n; i++) {
if (a[i] == '#') return true;
if (a[i] != ' ') return false;
}
return false;
}
string comprimir(string a) {
int n = a.size();
string res;
for (int i = 0; i < n; i++)
if (a[i] != ' ') res.push_back(a[i]);
return res;
}
void agregar(string& res, string a) {
int n = a.size();
for (int i = 0; i < n; i++)
if (a[i] != ' ') res.push_back(a[i]);
}
void b() {
vector<string> input;
string s;
while (getline(cin, s)) input.push_back(s);
vector<string> res;
for (int i = 0; i < input.size(); i++) {
if (esAum(input[i]))
res.push_back(input[i]);
else if (res.empty() or esAum(res.back()))
res.push_back(comprimir(input[i]));
else
agregar(res.back(), input[i]);
}
for (int i = 0; i < res.size(); i++) cout << res[i] << '\n';
}
void c() {
int n;
double a, d;
cin >> n >> a >> d;
double maximo = 0.0;
double t, v;
for (int i = 0; i < n; i++) {
cin >> t >> v;
double ti;
if (v * v / 2 / a > d)
ti = t + sqrt(2 * d / a);
else
ti = t + v / a + (d - v * v / 2 / a) / v;
maxi(maximo, ti);
cout << setprecision(9) << fixed << max(ti, maximo) << '\n';
}
}
void d() {
int n, l, k;
cin >> n >> l >> k;
vector<double> p(n);
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) p[i] /= 100.0;
for (int i = 0; i < n; i++) cin >> a[i];
vector<vector<double> > dp(n + 1, vector<double>(n + 1, 0.0));
dp[0][min(k, n)] = 1.0;
for (int i = 0; i < n; i++) {
if (a[i] == -1) continue;
for (int(pr) = n + 1 - 1; pr >= 0; pr--) {
dp[pr][n] *= 1.0 - p[i];
if (pr > 0)
for (int esp = max(0, n - a[i]); esp <= n; esp++)
dp[pr][n] += dp[pr - 1][esp] * p[i];
for (int(esp) = n - 1; esp >= 0; esp--) {
dp[pr][esp] *= 1.0 - p[i];
if (pr > 0 and esp - a[i] >= 0)
dp[pr][esp] += dp[pr - 1][esp - a[i]] * p[i];
}
}
}
for (int i = 0; i < n; i++) {
if (a[i] >= 1) continue;
for (int(pr) = n + 1 - 1; pr >= 0; pr--) {
for (int esp = 0; esp < n + 1; esp++) {
dp[pr][esp] *= 1.0 - p[i];
if (pr > 0 and esp < n) dp[pr][esp] += dp[pr - 1][esp + 1] * p[i];
}
}
}
double res = 0.0;
for (int pr = l; pr <= n; pr++)
for (int esp = 0; esp < n + 1; esp++) res += dp[pr][esp];
cout << setprecision(9) << fixed << res << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
d();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
int main() {
int n, k;
cin >> n >> k;
vector<unordered_map<long long, long long>> dp(n + 1);
vector<long long> arr(n);
for (int i = 0; i < n; ++i) cin >> arr[i];
unordered_map<long long, long long> current;
current[0] = 1;
for (int i = 0; i < n; ++i) {
long long here = arr[i];
long long nxt = arr[(i + 1) % n];
unordered_map<long long, long long> nxt_map;
if (here == nxt) {
for (auto [j, times] : current) {
nxt_map[j] += times * k;
nxt_map[j] %= mod;
}
} else {
for (auto [j, times] : current) {
nxt_map[j] += times * (k - 2);
nxt_map[j] %= mod;
}
for (auto [j, times] : current) {
nxt_map[j + 1] += times;
nxt_map[j - 1] += times;
nxt_map[j + 1] %= mod;
nxt_map[j - 1] %= mod;
}
}
current = nxt_map;
}
long long res = 0;
for (auto [i, j] : current) {
if (i > 0) res += j;
res %= mod;
}
cout << res << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[1000001];
int main() {
int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int mx = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mx = max(mx, arr[i]);
}
long long int mx1 = INT_MIN;
for (int i = 0; i < n; i++) {
arr[i] = mx - arr[i];
mx1 = max(mx1, arr[i]);
}
if (k % 2 == 1) {
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
} else {
for (int i = 0; i < n; i++) {
cout << mx1 - arr[i] << " ";
}
cout << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int BS(int num, vector<int>& a) {
int lo = 0;
int hi = a.size();
while (lo != hi) {
int mid = (lo + hi) / 2;
if (a[mid] <= num)
lo = mid + 1;
else
hi = mid;
}
return lo;
}
int main() {
int n;
cin >> n;
vector<int> Kango(n);
for (int i = 0; i < n; i++) scanf("%d", &Kango[i]);
sort(Kango.begin(), Kango.end());
int hid = 0;
int j = Kango.size() / 2;
for (int i = 0; i < Kango.size() / 2; i++) {
for (; j < Kango.size(); j++) {
if (Kango[i] * 2 <= Kango[j]) {
hid++;
j++;
break;
}
}
}
cout << Kango.size() - hid;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int N = 3e5 + 5;
int vis[N], n, m, s, id, a, b;
char mx[N], mn[N];
vector<pair<int, pair<int, int>>> adj[N];
void getMax() {
vis[s] = 1;
queue<int> q;
q.push(s);
fill(mx, mx + id, '?');
while (q.size()) {
int u = q.front();
q.pop();
for (auto e : adj[u]) {
int v = e.first;
int x = e.second.first;
int f = e.second.second;
if (x < N && mx[x] != '?') continue;
mx[x] = f ? '+' : '-';
if (vis[v]) continue;
vis[v] = 1;
q.push(v);
}
}
a = count(vis, vis + 1 + n, 1);
}
void getMin() {
vis[s] = 2;
queue<int> q;
q.push(s);
fill(mn, mn + id, '?');
while (q.size()) {
int u = q.front();
q.pop();
for (auto e : adj[u]) {
int v = e.first;
int x = e.second.first;
int f = e.second.second;
if (x < N && mn[x] == '?') {
mn[x] = f ? '-' : '+';
continue;
}
if (vis[v] == 2) continue;
vis[v] = 2;
q.push(v);
}
}
b = count(vis, vis + 1 + n, 2);
}
int main() {
scanf("%d %d %d", &n, &m, &s);
for (int i = 0; i < m; i++) {
int t, u, v;
scanf("%d %d %d", &t, &u, &v);
if (t == 1)
adj[u].push_back({v, {N, 0}});
else {
adj[u].push_back({v, {id, 1}});
adj[v].push_back({u, {id++, 0}});
}
}
getMax();
getMin();
for (int i = 0; i < id; i++) {
if (mx[i] == '?') mx[i] = '+';
if (mn[i] == '?') mn[i] = '+';
}
mn[id] = mx[id] = '\0';
printf("%d\n%s\n%d\n%s", a, mx, b, mn);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
const long long INF = 1LL << 60;
void go() {
long long n, m;
cin >> n >> m;
long long sum = 0;
vector<int> v;
long long s = 0, s2 = 0;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v.push_back(y);
sum += y;
s2 += 1LL * y * (x - 1) % n;
}
s = (1LL * (n - 1) * n / 2) % n;
s2 %= n;
sort(v.begin(), v.end());
if (sum < n) {
cout << 1 << '\n';
}
if (sum > n) {
cout << -1 << '\n';
}
if (sum == n) {
if (s == s2) {
cout << 1 << '\n';
} else {
cout << -1 << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int c = 0;
int t;
if (!c) {
t = 1;
} else {
cin >> t;
}
while (t--) {
go();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int nc, n, m, t;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
vector<vector<char>> grid;
vector<vector<int>> vis, cp, d0, d1;
vector<int> sz;
void flood(int x, int y, int c, int tr) {
cp[x][y] = c;
sz[c]++;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || grid[nx][ny] - '0' != tr ||
cp[nx][ny])
continue;
flood(nx, ny, c, tr);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> t;
grid.assign(n, vector<char>(m));
vis.assign(n, vector<int>(m, -1));
cp.assign(n, vector<int>(m));
d0.assign(n, vector<int>(m, INF));
d1.assign(n, vector<int>(m, INF));
sz.resize(n * m + 10);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!cp[i][j]) {
nc++;
flood(i, j, nc, grid[i][j] - '0');
}
}
}
queue<pair<int, int>> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '0' && sz[cp[i][j]] > 1) {
q.push({i, j});
d0[i][j] = 0;
}
}
}
while (q.size()) {
auto p = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = p.first + dx[i], ny = p.second + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || d0[nx][ny] != INF) continue;
q.push({nx, ny});
d0[nx][ny] = d0[p.first][p.second] + 1;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '1' && sz[cp[i][j]] > 1) {
q.push({i, j});
d1[i][j] = 0;
}
}
}
while (q.size()) {
auto p = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = p.first + dx[i], ny = p.second + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || d1[nx][ny] != INF) continue;
q.push({nx, ny});
d1[nx][ny] = d1[p.first][p.second] + 1;
}
}
while (t--) {
int r, c;
long long ti;
cin >> r >> c >> ti;
r--;
c--;
if (sz[cp[r][c]] == 1) {
int ch = min(d0[r][c], d1[r][c]);
if (ch != INF && ch <= ti)
cout << (((long long)(grid[r][c] - '0')) ^ ((ti - ch) & 1LL)) << '\n';
else
cout << grid[r][c] << '\n';
continue;
}
cout << (((long long)(grid[r][c] - '0')) ^ (ti & 1LL)) << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005;
int n, m, k, ans;
int main() {
scanf("%d %d %d", &n, &m, &k);
ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if ((i + j) & 1) continue;
int x = min(min(i, n - i - 1), min(j, m - j - 1)) + 1;
ans += x == k;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = (1e18);
const ll mod = 1000000007;
const ll mod2 = 998244353;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll c, ll d) { return c / gcd(c, d) * d; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<ll> p(n);
ll oddp = 0, evenp = 0;
for (int i = 0; i < n; i++) {
cin >> p[i];
if (p[i] % 2 == 1)
oddp++;
else
evenp++;
}
ll ans = 0;
int m;
cin >> m;
vector<ll> q(m);
for (int i = 0; i < m; i++) {
cin >> q[i];
if (q[i] % 2 == 1)
ans += oddp;
else
ans += evenp;
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long int i, j, w, h, ans = 0;
scanf("%I64d%I64d", &w, &h);
for (i = 2; i <= h; i += 2) {
for (j = 2; j <= w; j += 2) ans = (ans + (h - i + 1) * (w - j + 1));
}
printf("%I64d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int t;
long long n;
vector<int> v;
long long cnt[30];
long long pos[30];
long long fact[21];
void init() {
for (int i = 0; i < int(30); i++) cnt[i] = pos[i] = 0;
v.clear();
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
fact[0] = 1;
for (int i = 1; i <= 20; i++) fact[i] = fact[i - 1] * i;
cin >> t;
while (t--) {
init();
long long n;
cin >> n;
int cur = 2;
while (n) {
v.push_back(n % cur);
n /= cur;
cur++;
}
sort(v.begin(), v.end());
for (int i = 0; i < int(v.size()); i++) cnt[v[i]]++;
pos[1] = cnt[0];
for (int i = 2; i <= v.size() + 1; i++) pos[i] = pos[i - 1] + cnt[i - 1];
long long A = 1;
for (int i = 2; i <= v.size() + 1; i++) A *= (pos[i] - (i - 2));
long long B = 1;
if (cnt[0] == 0)
B = 0;
else {
B = cnt[0];
for (int i = 2; i <= v.size(); i++) B *= (pos[i] - (i - 1));
}
long long ans = A - B;
for (int i = 0; i < int(21); i++) ans /= fact[cnt[i]];
cout << ans - 1 << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int acnt[255];
int bcnt[255];
int ccnt[255];
string a, b, c;
bool can(int* cnt_arr) {
for (char ch = 'a'; ch <= 'z'; ch++) {
if (cnt_arr[ch] > acnt[ch]) return false;
}
return true;
}
void calc(const string& s, int* cnt_arr) {
for (int i = 0; i < s.length(); i++) {
cnt_arr[s[i]]++;
}
}
void write(const string& s) {
cout << s;
for (int i = 0; i < s.length(); i++) {
if (acnt[s[i]] <= 0) {
cout << "LOL";
cout << s << endl;
exit(0);
}
acnt[s[i]]--;
}
}
int main() {
cin >> a >> b >> c;
if (b.length() > c.length()) {
swap(b, c);
}
calc(a, acnt);
calc(b, bcnt);
calc(c, ccnt);
int mx = 0;
pair<int, int> ans;
int col = 0;
while (true) {
for (char ch = 'a'; ch <= 'z'; ch++) {
if (acnt[ch] < bcnt[ch] * col) goto end;
}
int mn = 1e9;
for (char ch = 'a'; ch <= 'z'; ch++) {
if (ccnt[ch] == 0) continue;
int cnt = acnt[ch] - bcnt[ch] * col;
mn = min(mn, cnt / ccnt[ch]);
}
if (col + mn > mx) {
mx = col + mn;
ans = make_pair(col, mn);
}
col++;
}
end:
for (int i = 0; i < ans.first; i++) write(b);
for (int i = 0; i < ans.second; i++) write(c);
for (char ch = 'a'; ch <= 'z'; ch++) {
for (int i = 0; i < acnt[ch]; i++) {
cout << ch;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize(1)
#pragma GCC optimize(2)
long long gcd(long long a, long long b) {
while (b ^= a ^= b ^= a %= b)
;
return a;
}
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 4e5 + 10;
const int maxn = 1e9;
int T, n, m;
int vis[N];
int k, x, y, z, v, h, l, rsum, ans, cnt;
string str;
struct ss {
char s;
int u;
} sss[N];
bool cmp(ss a, ss b) {
if (a.s == b.s) return a.u < b.u;
return a.s < b.s;
}
void cf() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> sss[i].s;
sss[i].u = i;
str += sss[i].s;
}
memset(vis, 0, sizeof(vis));
;
sort(sss + 1, sss + 1 + n, cmp);
for (int i = 1; i <= m; i++) {
vis[sss[i].u] = 1;
}
for (int i = 0; i < str.length(); i++) {
if (vis[i + 1] == 0) {
cout << str[i];
}
}
cout << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
T = 1;
while (T--) {
cf();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int adj[30][30];
int main() {
memset(adj, -1, sizeof(adj));
for (int i = 0; i < 26; i++) adj[i][i] = 0;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
string str;
cin >> str;
int len = (int)str.length();
int a = str[0] - 'a', b = str[len - 1] - 'a';
for (int j = 0; j < 26; j++) {
if (adj[j][a] == -1) continue;
adj[j][b] = max(adj[j][b], adj[j][a] + len);
}
}
int res = 0;
for (int i = 0; i < 26; i++) res = max(res, adj[i][i]);
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, p[200001], a[2000001], c[2000001][10], cn[2000001], d[200001],
num[2000001];
bool bo[2000001], BO;
int quickmi(int a, int b) {
int t = 1;
while (b) {
if (b & 1) t = 1ll * t * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return t;
}
int main() {
memset(bo, 1, sizeof(bo));
memset(cn, 0, sizeof(cn));
for (int i = 2; i <= 2000000; i++)
if (bo[i]) {
c[i][++cn[i]] = i;
for (int j = (i << 1); j <= 2000000; j += i) bo[j] = 0, c[j][++cn[j]] = i;
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
sort(p + 1, p + n + 1);
int ans = 1;
BO = 0;
memset(a, 0, sizeof(a));
memset(num, 0, sizeof(num));
for (int i = n; i; i--) {
int y;
bool boo = 0;
if ((i == 1 || p[i] != p[i - 1]) && (!a[p[i]]))
y = p[i];
else
y = p[i] - 1;
for (int j = 1; j <= cn[y]; j++) {
int x = y, cnt = 0;
while (x % c[y][j] == 0) x /= c[y][j], cnt++;
if (cnt > a[c[y][j]])
a[c[y][j]] = cnt, boo = 1, num[c[y][j]] = 1;
else if (cnt == a[c[y][j]])
num[c[y][j]]++;
}
d[i] = y;
}
for (int i = 1; i <= n; i++) {
bool boo = 0;
int y = d[i];
for (int j = 1; j <= cn[y]; j++) {
int x = y, cnt = 0;
while (x % c[y][j] == 0) x /= c[y][j], cnt++;
if (cnt == a[c[y][j]] && num[c[y][j]] == 1) boo = 1;
}
if (!boo) {
BO = 1;
break;
}
}
for (int i = 2; i <= 2000000; i++) ans = 1ll * ans * quickmi(i, a[i]) % mod;
if (BO) ans = (ans + 1) % mod;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int a[1000010];
int main() {
int n;
scanf("%d %d", &n, &a[0]);
int _min = a[0], _gcd = a[0];
for (int i = 1; i < n; i++) {
scanf("%d", &a[i]);
_min = min(a[i], _min);
_gcd = gcd(a[i], _gcd);
}
if (_gcd != _min) {
cout << "-1";
return 0;
}
cout << 2 * n << endl;
for (int i = 0; i < n; i++) cout << a[i] << " " << _min << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1, s2;
getline(cin, s);
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W' && (s.size() - 1 - i) >= 2) {
if (s[i + 1] == 'U' && s[i + 2] == 'B') {
i += 2;
if (!s1.empty()) {
s2 += s1 + ' ';
s1.clear();
}
} else
s1 += s[i];
} else {
s1 += s[i];
}
}
if (!s1.empty()) s2 += s1 + ' ';
cout << s2 << endl;
s2.clear();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long countZero(long long n) {
long long ans = 0, div = 5;
while (div <= n) {
ans += n / div;
div *= 5;
}
return ans;
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long n, k, a, b;
cin >> n >> k >> a >> b;
if (k == 1) {
cout << (1LL * n * a) - a << endl;
return 0;
}
long long x = n, ans = 0;
while (x != 1) {
if (x % k != 0) {
ans += (a * (x % k));
x -= (x % k);
} else {
ans += min(b, (x - (x / k)) * a);
x = x / k;
}
if (x == 0) {
ans -= a;
break;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int oo = 0x3f3f3f3f;
vector<int> get_primes(int v) {
vector<int> res;
for (int p = 2; p * p <= v; ++p) {
if (v % p == 0) {
res.push_back(p);
while (v % p == 0) v /= p;
}
}
if (v != 1) res.push_back(v);
return res;
}
int get_portion(int v, int p) {
int res = 1;
while (v % p == 0) {
v /= p;
res *= p;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int N;
cin >> N;
vector<int> a(N);
for (int i = (0); i < (N); i++) cin >> a[i];
auto p1 = get_primes(a[0]);
auto p2 = get_primes(a[1]);
unordered_set<int> pr((p1).begin(), (p1).end());
for (auto it : p2) pr.insert(it);
long long res = 1;
for (auto p : pr) {
long long f1 = get_portion(a[0], p);
long long f2 = get_portion(a[1], p);
;
;
if (f1 < f2) swap(f1, f2);
for (int i = (2); i < (N); i++) {
long long f = get_portion(a[i], p);
if (f < f1) {
f1 = f;
if (f1 < f2) swap(f1, f2);
};
;
}
res *= f1;
;
;
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
long long H[1 << 24], W;
struct SA {
long long *A, *S, *X, *M;
int N;
void ini(int n) {
N = 1 << (int(log2(n) - (1e-10)) + 1);
A = H + W, W += N * 2, S = H + W, W += N * 2;
X = H + W, W += N * 2, M = H + W, W += N * 2;
for (int i(0); i < N << 1; i++) A[i] = S[i] = X[i] = 0, M[i] = 1;
}
void gt(int u, long long &s, long long &x, long long &m, int b, int e) {
if (M[u] > X[u])
m = x = A[u], s = (e - b + 1) * A[u];
else
m = M[u] + A[u], x = X[u] + A[u], s = S[u] + A[u] * (e - b + 1);
}
void st(int b, int e, long long v = 0) { st(b, e, v, 1, 0, N - 1); }
void st(int b, int e, long long v, int u, int B, int E) {
if (B > e || E < b) return;
if (M[u] > X[u] && B ^ E)
M[u << 1 | 1] = M[u << 1] = 1, X[u << 1 | 1] = X[u << 1] = 0,
A[u << 1 | 1] = A[u << 1] = A[u], A[u] = 0;
if (b <= B && e >= E) {
M[u] = 1, X[u] = 0, A[u] = v;
return;
}
long long U, V, W;
if (A[u])
ad(B, E, A[u], u << 1, B, (B + E) >> 1),
ad(B, E, A[u], u << 1 | 1, (B + E) / 2 + 1, E), A[u] = 0;
st(b, e, v, u << 1, B, (B + E) >> 1),
st(b, e, v, u << 1 | 1, (B + E) / 2 + 1, E);
gt(u << 1, S[u], X[u], M[u], B, (B + E) >> 1),
gt(u << 1 | 1, U, V, W, (B + E) / 2 + 1, E);
S[u] += U, X[u] = max(X[u], V), M[u] = min(M[u], W);
}
void ad(int b, int e, long long v = 1) { ad(b, e, v, 1, 0, N - 1); }
void ad(int b, int e, long long v, int u, int B, int E) {
if (B > e || E < b) return;
if (M[u] > X[u] && B ^ E)
M[u << 1 | 1] = M[u << 1] = 1, X[u << 1 | 1] = X[u << 1] = 0,
A[u << 1 | 1] = A[u << 1] = A[u];
if (M[u] > X[u]) gt(u, S[u], X[u], M[u], B, E), A[u] = 0;
if (b <= B && e >= E) {
A[u] += v;
return;
}
long long U, V, W;
ad(b, e, v, u << 1, B, (B + E) >> 1),
ad(b, e, v, u << 1 | 1, (B + E) / 2 + 1, E);
gt(u << 1, S[u], X[u], M[u], B, (B + E) >> 1),
gt(u << 1 | 1, U, V, W, (B + E) / 2 + 1, E);
S[u] += U, X[u] = max(X[u], V), M[u] = min(M[u], W);
}
void gt(int b, int e, long long &s, long long &x, long long &m) {
s = 0, x = -1e18, m = 1e18;
gt(b, e, 1, 0, N - 1, s, x, m);
}
void gt(int b, int e, int u, int B, int E, long long &s, long long &x,
long long &m) {
if (B > e || E < b) return;
long long U = -1e18, V = 1e18, W;
if (X[u] < M[u] || (b <= B && e >= E))
gt(u, U, V, W, max(b, B), min(e, E)), s += U, x = max(x, V),
m = min(m, W);
else
gt(b, e, u << 1, B, (B + E) >> 1, s, U, V),
gt(b, e, u << 1 | 1, (B + E) / 2 + 1, E, s, U, V),
x = max(x, U + A[u]), m = min(m, V + A[u]),
s += A[u] * (1 + min(e, E) - max(b, B));
}
long long mx(int b, int e) {
long long u, v, w;
return gt(b, e, u, v, w), v;
}
long long mn(int b, int e) {
long long u, v, w;
return gt(b, e, u, v, w), w;
}
long long sm(int b, int e) {
long long u, v, w;
return gt(b, e, u, v, w), u;
}
} T, X;
int N, M, Q, A[222222], B[222222], a, b, c;
vector<pair<int, int> > g[222222];
int main(void) {
scanf("%d%d%d", &N, &M, &Q), T.ini(N + 5), X.ini(N + 5);
for (int i(0); i < N - 1; i++) scanf("%d%d", A + i, B + i + 1);
for (int i(0); i < N; i++) T.st(i, i, B[i]);
for (int i(0); i < M; i++)
scanf("%d%d%d", &a, &b, &c), g[--a].push_back({b, c});
for (int i(0); i < N; i++) X.st(i, i, A[i]);
for (int i(0); i < N; i++) {
for (auto &h : g[i]) T.ad(0, h.first - 1, h.second);
X.ad(i, i, T.mn(0, N - 1));
}
printf("%lld\n", X.mn(0, N - 1));
for (int i(0); i < Q; i++)
scanf("%d%d", &a, &b), --a, X.ad(a, a, -A[a]),
A[a] = b, X.ad(a, a, b), printf("%lld\n", X.mn(0, N - 1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int a[maxn], b[maxn];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", a + i);
int x, l = 0, p = 0, q = a[0];
for (int i = 0; i < m; i++) {
scanf("%d", &x);
q -= x;
while (q < 0) q += a[++l];
if (q == 0) p++;
}
printf("%d\n", p);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long visited[100001];
long long dep[100001];
long long dep1[100001];
vector<vector<long long> > v(100001);
void dfs(long long node) {
visited[node] = 1;
for (long long c : v[node]) {
if (visited[c] == 1) continue;
dep[c] = dep[node] + 1;
dfs(c);
}
}
void dfs1(long long node) {
visited[node] = 1;
for (long long c : v[node]) {
if (visited[c] == 1) continue;
dep1[c] = dep1[node] + 1;
dfs1(c);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, t, i, j, x, k, y;
cin >> t;
while (t--) {
long long a, b, da, db, y, ans = -1;
cin >> n >> a >> b >> da >> db;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++) visited[i] = 0;
dep[a] = 0;
dfs(a);
if (dep[b] <= da || db <= 2 * da) ans = 1;
if (ans != 1) {
k = 0, x = 1;
for (i = 1; i <= n; i++) {
if (dep[i] > k) {
k = dep[i];
x = i;
}
}
for (i = 1; i <= n; i++) visited[i] = 0;
dep[x] = 0;
dfs(x);
k = 0, x = 1;
for (i = 1; i <= n; i++) {
if (dep[i] > k) {
k = dep[i];
x = i;
}
}
for (i = 1; i <= n; i++) visited[i] = 0;
dep1[x] = 0;
dfs1(x);
for (i = 1; i <= n; i++)
if (max(dep[i], dep1[i]) <= da) ans = 1;
}
if (ans == -1)
cout << "Bob\n";
else
cout << "Alice\n";
for (i = 1; i <= n; i++) v[i].clear();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int spend[N][N] = {};
char g[N][N];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
for (int j = 1; j <= n; ++j) g[i][j] = s[j - 1];
}
for (int i = 0; i < N; ++i) spend[0][i] = spend[i][0] = 1e6;
spend[0][1] = spend[1][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
spend[i][j] = (g[i][j] != 'a') + min(spend[i - 1][j], spend[i][j - 1]);
}
}
vector<pair<int, int> > bests;
int best_len = 0;
for (int len = 1; len <= 2 * n - 1; ++len) {
bool found = false;
for (int i = max(1, len + 1 - n); i <= min(len, n); ++i) {
int j = len + 1 - i;
if (spend[i][j] <= k) found = true;
}
if (!found) break;
best_len = len;
}
set<pair<int, int> > locs;
for (int i = max(1, best_len + 1 - n); i <= min(best_len, n); ++i) {
int j = best_len + 1 - i;
if (spend[i][j] <= k) {
locs.emplace(i, j);
}
}
vector<char> str(best_len, 'a');
if (best_len == 0) {
locs.emplace(1, 1);
str.push_back(g[1][1]);
++best_len;
}
while ((int)str.size() < 2 * n - 1) {
best_len += 1;
char best = 'z';
set<pair<int, int> > new_locs;
for (int i = max(1, best_len + 1 - n); i <= min(best_len, n); ++i) {
int j = best_len + 1 - i;
if (g[i][j] > best) continue;
pair<int, int> p1(i - 1, j);
pair<int, int> p2(i, j - 1);
if (locs.count(p1) || locs.count(p2)) {
if (g[i][j] < best) {
new_locs.clear();
best = g[i][j];
}
new_locs.emplace(i, j);
}
}
str.push_back(best);
locs = new_locs;
}
for (char c : str) cout << c;
cout << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, i, sum1, sum2, k1, k2, x[1001], y[1001], o1, o2;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
sum1 += x[i];
sum2 += y[i];
}
if (sum1 % 2 == 0 && sum2 % 2 == 0)
cout << 0, exit(0);
else
for (i = 1; i <= n; i++)
if ((sum1 - x[i] + y[i]) % 2 == 0 && (sum2 - y[i] + x[i]) % 2 == 0)
cout << 1, exit(0);
cout << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, arr[1000], i, count = 0, out_arr[1000], j = 0;
scanf(" %d", &n);
for (i = 0; i < n; i++) {
scanf(" %d", &arr[i]);
}
if (n > 1) {
for (i = 0, j = 0; i < n - 1; i++) {
if (arr[i] >= arr[i + 1]) {
count++;
out_arr[j] = arr[i];
j++;
}
if (i + 1 == n - 1) {
count++;
out_arr[j] = arr[i + 1];
j++;
}
}
} else {
count = 1;
out_arr[0] = arr[0];
}
printf("%d\n", count);
for (i = 0; i < count; i++) {
printf("%d ", out_arr[i]);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, mx;
long long a[100000 + 10];
long long dp[100000 + 10];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (x > mx) mx = x;
a[x]++;
}
dp[1] = a[1];
dp[2] = max(a[1], 2 * a[2]);
for (int i = 3; i <= mx; i++)
dp[i] = max(dp[i - 2] + a[i] * i, dp[i - 3] + a[i - 1] * (i - 1));
cout << dp[mx];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
int n, cnt = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int p = a[0];
for (int i = 1; i < n; i++) {
if (a[i - 1] > a[i]) {
p -= a[i - 1] - a[i];
}
}
(p >= 0) ? cout << "YES" << endl : cout << "NO" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int main() {
int n;
cin >> n;
vector<int> a(n), o(n);
for (int i = 0; i < n; i++) cin >> a[i];
iota(o.begin(), o.end(), 0);
sort(o.begin(), o.end(),
[&](int p, int q) { return a[p] == a[q] ? p < q : a[p] < a[q]; });
vector<pair<int, int>> ans;
for (int t = 0; t < n; t++)
for (int i = 0; i < n - 1; i++)
if (o[i] > o[i + 1])
ans.push_back(make_pair(o[i + 1], o[i])), swap(o[i], o[i + 1]);
cout << int((ans).size()) << '\n';
for (auto p : ans) cout << p.first + 1 << ' ' << p.second + 1 << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int segment[] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int main() {
int a, b, i;
long long sum = 0;
cin >> a >> b;
for (i = a; i <= b; i++) {
int num = i;
while (num > 0) {
sum += segment[num % 10];
num = num / 10;
}
}
cout << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int T, N = 2000, M;
unsigned mat[2000][64];
char buf[999];
int main() {
scanf("%d", &M);
for (int i = 0; i < M; i++) {
scanf("%s", buf);
int n = strlen(buf);
reverse(buf, buf + n);
vector<long long> tmp((n - 1) / 8 + 1, 0);
for (int i = n; i--;) tmp[i / 8] = tmp[i / 8] * 10 + buf[i] - '0';
for (int j = 0; j < 250; j++) {
int v = tmp[0] & 255;
for (int k = 0; k < 8; k++)
if (v & (1 << k)) {
mat[j * 8 + k][i >> 5] ^= (1U << (i & 31));
}
for (int k = ((int)(tmp).size()) - 1; k > 0; k--) {
tmp[k - 1] += (tmp[k] & 255) * (long long)1e8;
tmp[k] >>= 8;
}
tmp[0] >>= 8;
}
}
vector<int> igen;
for (int i = 0; i < M; i++) {
int t = ((int)(igen).size());
bool sw = 0;
for (int j = t; j < N; j++) {
if ((bool)(mat[j][i >> 5] & (1U << (i & 31)))) {
if (t != j) {
for (int k = 0; k < 64; k++) swap(mat[t][k], mat[j][k]);
}
sw = 1;
break;
}
}
if (!sw) {
vector<int> arr;
for (int j = 0; j < t; j++)
if ((bool)(mat[j][i >> 5] & (1U << (i & 31)))) arr.push_back(igen[j]);
printf("%d", ((int)(arr).size()));
for (int t : arr) printf(" %d", t);
puts("");
continue;
}
igen.push_back(i);
puts("0");
for (int j = 0; j < N; j++)
if (t != j && (bool)(mat[j][i >> 5] & (1U << (i & 31)))) {
for (int k = 0; k < 64; k++) mat[j][k] ^= mat[t][k];
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, s, ans, i, j, k, a[300000];
long long ab(long long dd) {
if (dd < 0) return -dd;
return dd;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> s;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
ans += ab(s - a[n / 2 + 1]);
for (i = 1; i < n / 2 + 1; i++) {
if (a[i] > s) ans += ab(s - a[i]);
}
for (i = n / 2 + 2; i <= n; i++) {
if (a[i] < s) ans += ab(s - a[i]);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long BIT[200005];
void update(long long id, long long val) {
for (long long i = id; i <= 200000; i += i & -i) BIT[i] += val;
}
long long query(long long id) {
long long sum = 0;
for (long long i = id; i > 0; i -= i & -i) sum += BIT[i];
return sum;
}
int main() {
std::ios::sync_with_stdio(false);
string s;
long long k;
cin >> s;
cin >> k;
long long n = s.length();
if (s[0] == '0')
cout << "0" << endl;
else {
bool f = 0;
long long nz = 0, c = 0;
for (long long i = n - 1; i >= 1; i--) {
if (s[i] != '0')
nz++;
else
c++;
if (c == k) {
f = 1;
break;
}
}
if (f)
cout << nz << endl;
else {
cout << n - 1 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& n) {
char ch;
int sign = 1;
while (!isdigit(ch = getchar()))
if (ch == '-') sign = -1;
n = ch - '0';
while (isdigit(ch = getchar())) n = n * 10 + ch - '0';
n *= sign;
}
const int INF = 1e9 + 7;
const int N = 222222;
int n;
int a[N], vis[N];
int main() {
read(n);
for (int i = (1); i <= (n); ++i) read(a[i]);
int ans = 1;
for (int i = (1); i <= (n); ++i) {
if (!vis[a[i]])
vis[a[i]] = 1;
else
ans++;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int P = 1e9 + 7;
const int inf = 1e9;
const long long Inf = 1e15;
inline int IN() {
char ch = getchar();
int x = 0, f = 0;
while (ch < '0' || ch > '9') ch = getchar(), f = (ch == '-');
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - 48;
ch = getchar();
}
return f ? (-x) : x;
}
inline int Pow(int x, int y, int p) {
int an = 1;
for (; y; y >>= 1, x = (long long)x * x % p)
if (y & 1) an = (long long)an * x % p;
return an;
}
void renew(int &x, int y) {
x += y;
if (x < 0)
x += P;
else if (x >= P)
x -= P;
}
void setIO(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
template <typename T>
inline void chkmin(T &a, const T &b) {
if (a > b) a = b;
}
template <typename T>
inline void chkmax(T &a, const T &b) {
if (a < b) a = b;
}
int n, k;
int dp[1000005], g[1000005], fac[1000005], inv[1000005];
int main() {
scanf("%d%d", &n, &k);
fac[0] = 1;
for (int i = (int)1; i <= (int)n; i++) fac[i] = (long long)fac[i - 1] * i % P;
inv[0] = inv[1] = 1;
for (int i = (int)2; i <= (int)n; i++)
inv[i] = (long long)inv[P % i] * (P - P / i) % P;
for (int i = (int)2; i <= (int)n; i++)
inv[i] = (long long)inv[i - 1] * inv[i] % P;
dp[1] = dp[0] = 1;
for (int i = (int)2; i <= (int)k; i++) dp[i] = (long long)dp[i - 1] * i % P;
for (int i = (int)1; i <= (int)k; i++)
g[i] = (g[i - 1] + (long long)inv[i] * dp[i]) % P;
for (int i = (int)k + 1; i <= (int)n; i++) {
dp[i] = (g[i - 1] + P - g[i - k - 1]) % P;
dp[i] = (long long)dp[i] * fac[i - 1] % P;
g[i] = (g[i - 1] + (long long)inv[i] * dp[i]) % P;
}
int ans = 0;
for (int i = (int)0; i <= (int)n - 1; i++)
ans = (ans + (long long)dp[i] * fac[n - 1] % P * inv[i]) % P;
ans = (0LL + fac[n] - ans) % P;
ans = (ans + P) % P;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
namespace Patchouli {
const int K = 10;
struct node {
int min[K], max[K];
int size;
inline bool operator<(const node &b) const {
for (int i = 0; i < K; ++i)
if (max[i] > b.min[i]) return false;
return true;
}
node() {
memset(min, 0, sizeof(min));
memset(max, 0, sizeof(max));
}
};
inline node merge(const node a, const node b) {
node res;
res.size = a.size + b.size;
for (int i = 0; i < K; ++i)
res.min[i] = min(a.min[i], b.min[i]), res.max[i] = max(a.max[i], b.max[i]);
return res;
}
inline int read() {
int a = 1, b = 0;
char t;
do {
t = getchar();
if (t == '-') a = -1;
} while (t > '9' || t < '0');
do {
b = b * 10 - '0' + t;
t = getchar();
} while (t >= '0' && t <= '9');
return a * b;
}
int QAQ() {
int n = read(), k = read();
set<node> s;
node tmp;
for (int i = 1; i <= n; ++i) {
tmp.size = 1;
for (int j = 0; j < k; ++j) tmp.min[j] = tmp.max[j] = read();
set<node>::iterator it;
while ((it = s.find(tmp)) != s.end()) {
tmp = merge(tmp, *it);
s.erase(it);
}
s.insert(tmp);
printf("%d\n", s.rbegin()->size);
}
return false;
}
} // namespace Patchouli
int main() { return Patchouli::QAQ(); }
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct RTC {};
int main() {
int n, k;
cin >> n;
vector<int> v;
for (int i = 0; i < (n); i++) {
scanf("%d", &k);
v.push_back(k);
}
sort((v).begin(), (v).end());
for (int i = 0; i < (n); i++) {
if (i == 0) {
cout << v[n - 1];
cout << " ";
continue;
}
if (i == n - 1) {
cout << v[0];
cout << " ";
continue;
}
cout << v[i];
cout << " ";
}
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, neg = 0, pos = 0;
cin >> t;
for (int i = 0; i < t; i++) {
int input, ble;
cin >> input >> ble;
if (input < 0)
neg++;
else
pos++;
}
if (pos > 1 && neg > 1) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct unit {
int fa[2010][2010];
int find(int x, int y) {
return fa[x][y] == y ? y : fa[x][y] = find(x, fa[x][y]);
}
};
struct unit g1, g2;
int n, m, k, x2, y2, nq, d1, ansx, ansy;
int a[2010][2010];
int read() {
int ret = 0;
char ch = getchar();
while (ch < 48 || ch > 57) ch = getchar();
while (ch >= 48 && ch <= 57) {
ret = ret * 10 + ch - 48;
ch = getchar();
}
return ret;
}
void update(int x, int y) {
int d2;
d2 = (x > x2 ? x - x2 : x2 - x) + (y > y2 ? y - y2 : y2 - y);
if (d2 < d1 || (d2 == d1 && (x < ansx || (x == ansx && y < ansy)))) {
ansx = x;
ansy = y;
d1 = d2;
}
}
int main() {
int i, j, d, q, p;
n = read(), m = read(), nq = read();
for (i = 1; i <= n; i++)
for (j = 0; j <= m + 1; j++) {
g1.fa[i][j] = j;
g2.fa[i][j] = j;
}
for (q = 1; q <= nq; q++) {
x2 = read(), y2 = read();
ansx = 4001;
ansy = 4001;
d1 = 4001;
d = max(a[x2][y2], max(a[x2][y2 - 1] - 1,
max(a[x2][y2 + 1] - 1,
max(a[x2 - 1][y2] - 1, a[x2 + 1][y2] - 1))));
d = max(0, d - m);
k = (q / m) + (m + 1) / 2;
for (i = d; i <= k; i++) {
if (d1 < i) break;
if (x2 - i > 0) {
p = g1.find(x2 - i, y2);
if (p != 0) update(x2 - i, p);
p = g2.find(x2 - i, y2);
if (p != m + 1) update(x2 - i, p);
}
if (i != 0 && x2 + i <= n) {
p = g1.find(x2 + i, y2);
if (p != 0) update(x2 + i, p);
p = g2.find(x2 + i, y2);
if (p != m + 1) update(x2 + i, p);
}
}
g1.fa[ansx][ansy] = ansy - 1;
g2.fa[ansx][ansy] = ansy + 1;
a[x2][y2] = d1;
printf("%d %d\n", ansx, ansy);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool best[101];
int main() {
int n, m, kol = 0;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int j = m - 1; j >= 0; j--) {
int k_max = 0, max = -1;
vector<int> v;
for (int i = 0; i < n; i++) {
if (a[i][j] - '0' > max) {
max = a[i][j] - '0';
k_max = 0;
v.clear();
}
if (a[i][j] - '0' == max) {
k_max++;
v.push_back(i);
}
}
for (int i = 0; i < v.size(); i++) {
if (!best[v[i]]) {
kol++;
best[v[i]] = true;
}
}
}
cout << kol << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 0;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f ? x : -x;
}
priority_queue<int, vector<int>, greater<int> > Q;
int main() {
int n = read();
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int x = read();
if (!Q.empty() && Q.top() < x) {
ans += x - Q.top();
Q.pop();
Q.push(x);
}
Q.push(x);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653589793238462643383279502884;
int arr[8][8];
vector<long long int> v;
void solve(long long int x) {
if (x > 1e12) return;
v.push_back(x + 4), v.push_back(x + 7);
solve((x + 4) * 10);
solve((x + 7) * 10);
}
bool check(long long int x) {
int a4 = 0, a7 = 0;
while (x > 0) {
(x % 10 == 7) ? a7++ : a4++;
x /= 10;
}
return a7 == a4;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
solve(0);
sort(v.begin(), v.end());
vector<long long int> vec;
for (auto c : v)
if (check(c)) vec.push_back(c);
if (binary_search(vec.begin(), vec.end(), n))
cout << vec[(lower_bound(vec.begin(), vec.end(), n) - vec.begin())];
else
cout << vec[(upper_bound(vec.begin(), vec.end(), n) - vec.begin())];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
pair<string, string> a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
for (int i = 0; i < n; ++i) {
if (a[i].second == "rat") cout << a[i].first << endl;
}
for (int i = 0; i < n; ++i) {
if (a[i].second == "woman" || a[i].second == "child")
cout << a[i].first << endl;
}
for (int i = 0; i < n; ++i) {
if (a[i].second == "man") cout << a[i].first << endl;
}
for (int i = 0; i < n; ++i) {
if (a[i].second == "captain") cout << a[i].first << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)(1e9 + 7);
const double pi = 3.14159265359;
const int MAXN = 100100;
void boost() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void file() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
string s[MAXN];
map<string, long long> a;
int id[MAXN];
int main() {
boost();
int n, k, m;
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[s[i]] = x;
}
for (int i = 1; i <= k; i++) {
long long x, minn = inf;
cin >> x;
for (int j = 1; j <= x; j++) {
cin >> id[j];
minn = min(a[s[id[j]]], minn);
}
for (int j = 1; j <= x; j++) a[s[id[j]]] = min(a[s[id[j]]], minn);
}
long long ans = 0;
for (int i = 1; i <= m; i++) {
string s2;
cin >> s2;
ans += a[s2];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x;
int biggest[80][80][40];
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> x;
for (int cnt = m / 2 - 1; cnt >= 0; cnt--)
for (int mod = 0; mod < k; mod++)
biggest[i][(biggest[i][mod][cnt] + x) % k][cnt + 1] =
max(biggest[i][(biggest[i][mod][cnt] + x) % k][cnt + 1],
(biggest[i][mod][cnt] + x));
}
for (int cnt = 0; cnt <= m / 2; cnt++)
for (int mod = 0; mod < k; mod++)
biggest[i + 1][mod][0] =
max(biggest[i][mod][cnt], biggest[i + 1][mod][0]);
}
cout << biggest[n + 1][0][0] << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int main() {
s.clear();
int n, m, k;
cin >> n;
k = n;
while (cin >> m) {
if (m <= n) s.insert(m);
}
cout << k - s.size() << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
int n, m, w[100001], c[100001];
long long f[100001], ans;
int main() {
ans = INF;
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) {
scanf("%d %d", &w[i], &c[i]);
++w[i];
m = max(m, w[i]);
}
m += n;
for (register int i = 1; i <= m; ++i) {
f[i] = INF;
}
for (register int i = 1; i <= n; ++i) {
for (register int j = m; j >= w[i]; --j) {
f[j] = min(f[j], f[j - w[i]] + c[i]);
if (j >= n) {
ans = min(ans, f[j]);
}
}
}
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& num) {
num = 0;
bool f = true;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = false;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
num = num * 10 + ch - '0';
ch = getchar();
}
num = f ? num : -num;
}
int out[100];
template <class T>
inline void write(T x, char ch) {
if (x == 0) {
putchar('0');
putchar(ch);
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int num = 0;
while (x) {
out[num++] = (x % 10);
x = x / 10;
}
for (int i = (num - 1); i >= (0); i--) putchar(out[i] + '0');
putchar(ch);
}
const double eps = 1e-8;
bool in[105][105][1000];
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
struct Poi {
int x, y;
} p[10];
int s[105][105];
int dp[105][105][1000], pre[105][105][1000], a[105][105];
int sumsta, n, m, k;
bool vis[105][105];
queue<int> q;
int pack(int x, int y, int st) { return x * 10000000 + y * 10000 + st; }
bool judge(int x, int y) {
if (x <= 0 || y <= 0 || x > n || y > m) return false;
return true;
}
void spfa() {
while (!q.empty()) {
int tmp = q.front();
q.pop();
int x = tmp / 10000000, st = tmp % 10000, y = tmp / 10000 % 1000;
in[x][y][st] = false;
for (int i = (0); i <= (3); i++) {
int xx = x + dx[i], yy = y + dy[i], stt = st | s[xx][yy];
if (!judge(xx, yy)) continue;
if (dp[xx][yy][stt] > dp[x][y][st] + a[xx][yy]) {
dp[xx][yy][stt] = dp[x][y][st] + a[xx][yy];
pre[xx][yy][stt] = tmp;
if (!in[xx][yy][stt]) {
in[xx][yy][stt] = true;
q.push(pack(xx, yy, stt));
}
}
}
}
}
void init() {
read(n);
read(m);
read(k);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) read(a[i][j]);
sumsta = (1 << k);
for (int i = (0); i <= (sumsta - 1); i++)
for (int x = (1); x <= (n); x++)
for (int y = (1); y <= (m); y++) dp[x][y][i] = pre[x][y][i] = 1070000000;
for (int i = (1); i <= (k); i++) {
int x, y;
read(x);
read(y);
s[x][y] = 1 << (i - 1);
dp[x][y][s[x][y]] = a[x][y];
}
}
void check(int i) {
puts("statu is :");
write(i, '\n');
for (int x = (1); x <= (n); x++) {
for (int y = (1); y <= (m); y++) write(dp[x][y][i], ' ');
puts("");
}
puts("");
}
void getans(int x, int y, int st) {
vis[x][y] = true;
int tmp = pre[x][y][st];
if (tmp == 1070000000) return;
int xx = tmp / 10000000, _st = tmp % 10000, yy = tmp / 10000 % 1000;
getans(xx, yy, _st);
if (x == xx && y == yy) getans(xx, yy, (st - _st) | s[xx][yy]);
}
void work() {
for (int st = (1); st <= (sumsta - 1); st++) {
for (int x = (1); x <= (n); x++)
for (int y = (1); y <= (m); y++) {
for (int i = (st - 1) & st; i; i = (i - 1) & st) {
int d =
dp[x][y][i | s[x][y]] + dp[x][y][(st - i) | s[x][y]] - a[x][y];
if (d < dp[x][y][st]) {
dp[x][y][st] = d;
pre[x][y][st] = pack(x, y, i);
}
}
if (dp[x][y][st] < 1070000000)
q.push(pack(x, y, st)), in[x][y][st] = true;
}
spfa();
}
int ans = 1070000000, xx, yy;
for (int x = (1); x <= (n); x++)
for (int y = (1); y <= (m); y++) {
if (dp[x][y][sumsta - 1] < ans)
ans = min(ans, dp[x][y][sumsta - 1]), xx = x, yy = y;
}
write(ans, '\n');
getans(xx, yy, sumsta - 1);
for (int x = (1); x <= (n); x++) {
for (int y = (1); y <= (m); y++)
if (vis[x][y])
putchar('X');
else
putchar('.');
puts("");
}
}
int main() {
init();
work();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long dp[16][10][2];
long long n;
long long gap[16];
long long x[16];
int func(int pos, long long val) {
if (val < 0) val = -val;
if (pos == -1) return val;
long long xx = val / x[pos];
return min(func(pos - 1, val - xx * x[pos]) + xx * (pos + 1),
func(pos - 1, val - (xx + 1) * x[pos]) + (xx + 1) * (pos + 1));
}
int main() {
x[0] = 1;
for (int i = 1; i <= 15; i++) {
x[i] = x[i - 1] * 10;
}
for (int i = 1; i <= 15; i++) x[i] += x[i - 1];
memset(dp, -1, sizeof(dp));
scanf("%lld", &n);
printf("%d\n", func(15, n));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void bst() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
}
int main() {
bst();
int n;
cin >> n;
long long arr[(int)2e5 + 100];
long long s = 0;
long long pos = 0;
for (int i = 1; i <= n; i++) {
bool t;
cin >> t;
if (t) {
pos++;
} else {
s += pos;
}
}
cout << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100000;
const int maxk = 110000;
const long long Mod = 1e9 + 7;
int n, m, k;
struct segment {
long long c, flag;
} seg[maxn << 2];
void pushdown(const int x, const int l, const int r) {
if (seg[x].flag != -1) {
int mid = l + r >> 1, lc = x << 1, rc = lc | 1;
long long fl = seg[x].flag % Mod;
seg[x].flag = -1;
seg[lc].c = (long long)(mid - l + 1) * fl % Mod;
seg[lc].flag = fl;
seg[rc].c = (long long)(r - mid) * fl % Mod;
seg[rc].flag = fl;
}
}
void pushup(const int x) {
int lc = x << 1, rc = lc | 1;
seg[x].c = (seg[lc].c + seg[rc].c) % Mod;
}
int lx, rx;
long long v;
void upd(const int x, const int l, const int r) {
if (rx < l || r < lx) return;
if (lx <= l && r <= rx) {
seg[x].c = (long long)(r - l + 1) * v % Mod;
seg[x].flag = v;
return;
}
pushdown(x, l, r);
int mid = l + r >> 1, lc = x << 1, rc = lc | 1;
upd(lc, l, mid);
upd(rc, mid + 1, r);
pushup(x);
}
void add(const int x, const int l, const int r) {
if (l == r) {
seg[x].c += v;
return;
}
int mid = l + r >> 1, lc = x << 1, rc = lc | 1;
pushdown(x, l, r);
if (lx <= mid)
add(lc, l, mid);
else
add(rc, mid + 1, r);
pushup(x);
}
void cal(const int x, const int l, const int r) {
if (rx < l || r < lx) return;
if (lx <= l && r <= rx) {
v += seg[x].c;
return;
}
int mid = l + r >> 1, lc = x << 1, rc = lc | 1;
pushdown(x, l, r);
cal(lc, l, mid);
cal(rc, mid + 1, r);
}
struct D {
int pos, x1, x2, i;
D() {}
D(const int _pos, const int _x1, const int _x2, const int _i) {
pos = _pos;
x1 = _x1;
x2 = _x2;
i = _i;
}
} a[maxk << 1];
int cnt;
inline bool cmp(const D x, const D y) {
if (x.pos == y.pos) return x.i == y.i ? x.x1 > y.x1 : x.i > y.i;
return x.pos < y.pos;
}
multiset<int> S;
multiset<int>::iterator it;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
a[++cnt] = D(x1, y1, y2, 1);
a[++cnt] = D(x2 + 1, y1, y2, -1);
}
sort(a + 1, a + cnt + 1, cmp);
lx = rx = 1;
v = 1ll;
upd(1, 1, m);
int pos = 1;
S.insert(0);
S.insert(m + 1);
while (pos <= cnt && a[pos].pos == 1) {
S.insert(a[pos].x1);
S.insert(a[pos].x2);
pos++;
}
for (int i = 2; i <= n; i++) {
while (pos <= cnt && a[pos].pos == i) {
if (a[pos].i == 1) {
it = S.upper_bound(a[pos].x2);
it--;
lx = (*it) + 1, rx = a[pos].x2;
v = 0ll;
if (lx <= rx) cal(1, 1, m);
v %= Mod;
it = S.upper_bound(a[pos].x2);
if ((*it) != a[pos].x2 + 1) lx = rx = a[pos].x2 + 1, add(1, 1, m);
lx = a[pos].x1, rx = a[pos].x2, v = 0ll, upd(1, 1, m);
S.insert(a[pos].x1);
S.insert(a[pos].x2);
} else {
it = S.find(a[pos].x1);
S.erase(it);
it = S.find(a[pos].x2);
S.erase(it);
}
pos++;
}
}
it = S.lower_bound(m);
it--;
lx = (*it) + 1, rx = m, v = 0;
if (lx <= rx) cal(1, 1, m);
printf("%I64d\n", v % Mod);
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return {i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
using ld = long double;
using ll = long long;
constexpr int mod = 998244353;
constexpr int odw2 = (mod + 1) / 2;
void OdejmijOd(int& a, int b) {
a -= b;
if (a < 0) a += mod;
}
int Odejmij(int a, int b) {
OdejmijOd(a, b);
return a;
}
void DodajDo(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int Dodaj(int a, int b) {
DodajDo(a, b);
return a;
}
int Mnoz(int a, int b) { return (ll)a * b % mod; }
void MnozDo(int& a, int b) { a = Mnoz(a, b); }
int Pot(int a, int b) {
int res = 1;
while (b) {
if (b % 2 == 1) MnozDo(res, a);
a = Mnoz(a, a);
b /= 2;
}
return res;
}
int Odw(int a) { return Pot(a, mod - 2); }
void PodzielDo(int& a, int b) { MnozDo(a, Odw(b)); }
int Podziel(int a, int b) { return Mnoz(a, Odw(b)); }
int Moduluj(ll x) {
x %= mod;
if (x < 0) x += mod;
return x;
}
template <typename T>
T Maxi(T& a, T b) {
return a = max(a, b);
}
template <typename T>
T Mini(T& a, T b) {
return a = min(a, b);
}
constexpr int K = 76;
constexpr int nax = 4005;
int n;
int dp[K];
vector<int> graf[nax];
map<pair<int, int>, array<int, K>> memo;
const array<int, K>& Licz(int w, int o);
array<int, K> Prefiks(const array<int, K>& tab) {
array<int, K> licz;
licz[0] = 1;
for (int i = 1; i < K; i++) {
licz[i] = 0;
for (int j = 1; j <= i; j++) {
DodajDo(licz[i], Mnoz(licz[i - j], tab[j]));
}
}
return licz;
}
array<int, K> Oblicz(int w, int o) {
array<int, K> licz;
for (int i = 0; i < K; i++) licz[i] = 0;
for (int x : graf[w]) {
if (x == o) continue;
const array<int, K>& tab = Licz(x, w);
for (int i = 0; i + 2 < K; i++) {
DodajDo(licz[i + 2], tab[i]);
}
}
return Prefiks(licz);
}
const array<int, K>& Licz(int w, int o) {
auto it = memo.find(make_pair(w, o));
if (it == memo.end()) {
return memo[make_pair(w, o)] = Oblicz(w, o);
}
return it->second;
}
void Licz(int n_) {
n = n_;
for (int i = 0; i < K; i++) {
dp[i] = 0;
}
for (int i = 1; i <= n; i++) {
graf[i].clear();
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
graf[a].push_back(b);
graf[b].push_back(a);
}
memo.clear();
for (int i = 1; i <= n; i++) {
const array<int, K>& tab = Licz(i, -1);
for (int j = 0; j < K; j++) {
DodajDo(dp[j], tab[j]);
}
}
}
int C[K][K];
int main() {
for (int i = 0; i < K; i++) {
C[i][i] = C[i][0] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = Dodaj(C[i - 1][j - 1], C[i - 1][j]);
}
}
ios_base::sync_with_stdio(0);
cin.tie(0);
int nx[2], k;
cin >> nx[0] >> nx[1] >> k;
array<int, K> tab[2];
for (int i = 0; i < 2; i++) {
Licz(nx[i]);
for (int j = 0; j <= k; j++) {
tab[i][j] = dp[j];
debug() << "tab[" << i << "][" << j << "] = " << tab[i][j];
}
}
int wynik = 0;
for (int a = 0; a <= k; a++) {
const int b = k - a;
DodajDo(wynik, Mnoz(Mnoz(tab[0][a], tab[1][b]), C[k][a]));
}
cout << wynik << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int a[100005];
long long int dp[100005];
int main() {
int i, j, k, t, go;
long long int an;
cin >> t >> go;
a[0] = 1;
dp[0] = 1;
long long int mod = 1e9 + 7;
for (i = 1; i <= 100000; i++) {
a[i] = a[i - 1];
if (i - go >= 0) a[i] += a[i - go];
a[i] %= mod;
dp[i] = (dp[i - 1] + a[i]) % mod;
}
while (t) {
t--;
cin >> j >> k;
an = dp[k] - dp[j - 1];
if (an < 0) an += mod;
cout << an << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int INFI = 1000 * 1000 * 1000;
const long double eps = (1e-12);
const long long INFL = (long long)INFI * (long long)(INFI);
using namespace std;
int n, a[100001], b[100001], sz, ans, x, y;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
cin >> x >> y;
sort(a + 1, a + n + 1);
b[++sz] = a[1];
for (int i = 2; i <= n; ++i)
if (a[i] != a[i - 1]) b[++sz] = a[i];
while (x != y) {
int mx = 1;
for (int i = 1; i <= sz; ++i)
if (x - (x % b[i]) >= y && x % b[i] > mx) mx = x % b[i];
x -= mx;
while (sz && x - (x % b[sz]) < y) sz--;
ans++;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, n;
cin >> t;
while (t--) {
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
long long int b[n];
long long int cnt1 = 0, cnt2 = 0;
for (long long int i = 0; i < n; i++) {
cin >> b[i];
if (b[i] == 0)
cnt1++;
else
cnt2++;
}
long long int flag = 0;
for (long long int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
flag = 1;
break;
}
}
if (flag == 0) {
cout << "Yes" << endl;
continue;
}
if (cnt1 != 0 && cnt2 != 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long Find(long long x) {
for (long long i = 1;; i++)
if (i * (i - 1) == x)
return i;
else if (i * (i - 1) > x)
return -1;
}
int main() {
long long a, b, c, d;
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
long long sum = a + b + c + d;
if (sum == 0) return puts("0"), 0;
long long x = Find(a * 2);
long long y = Find(d * 2);
long long n = x + y;
if (x == -1 || y == -1) return puts("Impossible"), 0;
if (a + b + c == 0) {
while (y--) putchar('1');
return 0;
}
if (b + c + d == 0) {
while (x--) putchar('0');
return 0;
}
if (n * (n - 1) != sum * 2) return puts("Impossible"), 0;
long long num = (n * (n - 1) / 2 - a - d - b) / x;
while (num--) putchar('1'), --y;
num = (n * (n - 1) / 2 - a - d - b) % x;
for (long long i = 1, sz = x - num; i <= sz; i++) putchar('0'), --x;
if (y) putchar('1'), --y;
while (x--) putchar('0');
while (y--) putchar('1');
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
vector<int> g[N];
vector<int> t;
bool u[N];
int col[N];
void dfs(int v) {
col[v] = 1;
for (auto to : g[v]) {
if (col[to] == 0) {
dfs(to);
} else if (col[to] == 1) {
puts("-1");
exit(0);
}
}
col[v] = 2;
t.push_back(v);
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<int> cur(k);
for (int i = 0; i < k; i++) {
scanf("%d", &cur[i]);
}
for (int i = 1; i <= n; i++) {
int j;
scanf("%d", &j);
while (j--) {
int k;
scanf("%d", &k);
g[i].push_back(k);
}
}
for (int i : cur) {
if (!col[i]) {
dfs(i);
}
}
printf("%d\n", (int)t.size());
for (int i : t) {
printf("%d ", i);
}
puts("");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 10, inf = 0x3f3f3f3f, llinf = 0x3f3f3f3f3f3f3f3f;
const int M = 2e7 + 5;
long long n, m, k;
long long a, b;
void solve() {
cin >> a >> b;
long long x1 = (a + b + 1) / 2;
long long x2 = (a + b) / 2;
vector<long long> vec;
for (int x = 0; x <= x2; ++x) {
int y = x - a + x1;
if (y <= x1 && y >= 0 && x >= 0) {
vec.push_back(x + y);
}
}
swap(x1, x2);
for (int x = 0; x <= x2; ++x) {
int y = x - a + x1;
if (y <= x1 && y >= 0 && x >= 0) {
vec.push_back(x + y);
}
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
cout << vec.size() << '\n';
for (long long v : vec) {
cout << v << " ";
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
int tt = 1;
cin >> tt;
while (tt--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long A[205];
long long C2[205];
long long C5[205];
long long dp[205][10005];
long long solve = 0, c5 = 0, c2 = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> A[i];
long long v2 = 0, v5 = 0;
long long x = A[i];
while (x % 2ll == 0) x /= 2ll, v2++;
x = A[i];
while (x % 5ll == 0) x /= 5ll, v5++;
C2[i] = v2, C5[i] = v5;
c5 += v5;
c2 += v2;
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (long long i = 1; i <= n; i++)
for (long long l = k; l >= 1; l--)
for (long long j = c5; j >= C5[i]; j--) {
if (dp[l - 1][j - C5[i]] == -1) continue;
dp[l][j] = max(dp[l][j], dp[l - 1][j - C5[i]] + C2[i]);
solve = max(solve, min(j, dp[l][j]));
}
cout << solve << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int kmax = 5e3 + 10;
const int mod = 1e9 + 7;
int n, k;
int dp[kmax][kmax];
int sum(int a, int b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
int mul(int a, int b) {
long long c = 1LL * a * b;
if (c >= mod) c %= mod;
return c;
}
int lgpow(int a, int b) {
int res = 1;
for (int i = 0; (1 << i) <= b; ++i) {
if (b & (1 << i)) res = mul(res, a);
a = mul(a, a);
}
return res;
}
int get_dp(int a, int b, int c) {
if (a == 0) dp[a][b] = lgpow(2, c);
if (dp[a][b] >= 0) return dp[a][b];
int F = (b == 0) ? 0 : mul(b, get_dp(a - 1, b, c));
int S = (c == 0) ? 0 : mul(c, get_dp(a - 1, b + 1, c - 1));
dp[a][b] = sum(F, S);
return dp[a][b];
}
int main() {
ios_base ::sync_with_stdio(false);
for (int i = 0; i < kmax; ++i)
for (int j = 0; j < kmax; ++j) dp[i][j] = -1;
cin >> n >> k;
cout << get_dp(k, 0, n) << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << max((int)(n != m), min(n - m, m));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace Base {
const int inf = 0x3f3f3f3f, INF = 0x7fffffff;
const long long infll = 0x3f3f3f3f3f3f3f3fll, INFll = 0x7fffffffffffffffll;
template <typename T>
void read(T &x) {
x = 0;
int fh = 1;
double num = 1.0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') fh = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
if (ch == '.') {
ch = getchar();
while (isdigit(ch)) {
num /= 10;
x = x + num * (ch - '0');
ch = getchar();
}
}
x = x * fh;
}
template <typename T>
void chmax(T &x, T y) {
x = x < y ? y : x;
}
template <typename T>
void chmin(T &x, T y) {
x = x > y ? y : x;
}
} // namespace Base
using namespace Base;
const int N = 200010;
struct Node {
long long c;
int v;
} p[N], d[N];
bool cmp(Node x, Node y) { return ((x.v < y.v) || (x.v == y.v && x.c < y.c)); }
int n;
long long dl[N], dr[N];
long long s;
int main() {
read(n);
read(s);
for (int i = 1; i <= n; i++) {
read(p[i].v);
read(p[i].c);
}
sort(p + 1, p + n + 1, cmp);
int cnt = 1;
for (int i = 2; i <= n; i++)
if (p[i].v != p[cnt].v) p[++cnt] = p[i];
n = cnt;
for (int i = n - 1; i >= 1; i--)
if (p[i].c < p[cnt].c) p[--cnt] = p[i];
for (int i = cnt; i <= n; i++) p[i - cnt + 1] = p[i];
assert(p[1].c == 0);
n = n - cnt + 1;
cnt = 1;
d[1].c = 0;
d[1].v = p[1].v;
dl[1] = 1;
dr[1] = infll;
for (int i = 2; i <= n; i++) {
int l = 1, r = cnt, q;
while (l <= r) {
int mid = (l + r) / 2;
if (dr[mid] == infll || p[i].c <= d[mid].c + d[mid].v * dr[mid])
q = mid, r = mid - 1;
else
l = mid + 1;
}
long long dat;
if (d[q].c >= p[i].c)
dat = 0;
else
dat = (p[i].c - d[q].c - 1) / d[q].v + 1;
Node now = (Node){d[q].c + d[q].v * dat - p[i].c - p[i].v * dat, p[i].v};
l = 1, r = cnt;
while (l <= r) {
int mid = (l + r) / 2;
if (dr[mid] == infll ||
now.c + now.v * dr[mid] >= d[mid].c + d[mid].v * dr[mid])
q = mid, r = mid - 1;
else
l = mid + 1;
}
long long ti = (d[q].c - now.c - 1) / (now.v - d[q].v) + 1;
if (ti <= dl[q])
cnt = q - 1, ti = dl[q];
else
cnt = q;
d[++cnt] = now;
dl[cnt] = ti, dr[cnt] = infll;
dr[cnt - 1] = dl[cnt] - 1;
}
long long ans = 0;
for (int i = 1; i <= cnt; i++)
if (dr[i] == infll || d[i].c + d[i].v * dr[i] >= s) {
ans = (s - d[i].c - 1) / d[i].v + 1;
break;
}
for (int i = 1; i < cnt; i++) {
assert(d[i].c + dr[i] * d[i].v > d[i + 1].c + dr[i] * d[i + 1].v);
assert(d[i].c + (dr[i] + 1) * d[i].v <=
d[i + 1].c + (dr[i] + 1) * d[i + 1].v);
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long minRes[2][20][1005];
void buildQuery(long long ind) {
long long cnt = 0;
for (int i = 1; i <= n; i++) {
if ((1LL << ind) & i) {
cnt++;
}
}
cout << cnt << endl;
for (int i = 1; i <= n; i++) {
if ((1LL << ind) & i) {
cout << i << " ";
}
}
cout << endl;
cnt = 0;
for (int i = 1; i <= n; i++) {
if (!((1LL << ind) & i)) {
cnt++;
}
}
cout << cnt << endl;
for (int i = 1; i <= n; i++) {
if (!((1LL << ind) & i)) {
cout << i << " ";
}
}
cout << endl;
}
int main() {
cin >> n;
for (long long i = 0; 1LL << i <= n; i++) {
buildQuery(i);
for (int j = 1; j <= n; j++) {
cin >> minRes[1][i][j];
}
for (int j = 1; j <= n; j++) {
cin >> minRes[0][i][j];
}
}
cout << -1 << endl;
vector<long long> res;
for (long long i = 1; i <= n; i++) {
long long s = 2e9;
for (long long j = 0; (1LL << j) <= n; j++) {
bool bit = !(i & (1LL << j));
s = min(s, minRes[bit][j][i]);
}
res.push_back(s);
}
for (int i = 0; i < res.size(); i++) {
if (i) cout << " ";
cout << res[i];
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k;
string s, t;
cin >> n >> k;
if (k > n || (n > 1 && k == 1)) {
cout << "-1" << endl;
return 0;
}
if (n == 1 && k == 1) {
cout << "a" << endl;
return 0;
}
t = "a";
for (i = 0; i < n - k + 2; i++) {
s += t;
if (t == "a")
t = "b";
else
t = "a";
}
t = "c";
for (i = n - k + 2; i < n; i++) {
s += t;
t[0]++;
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int out = 1;
long long int n;
cin >> n;
n *= 2;
vector<long long int> v;
for (long long int i = 1; i <= (100005); i++) {
v.push_back(i * (i + 1));
}
for (long long int i = 0; i < (100000); i++) {
if (v[i] > n) break;
if (binary_search(v.begin(), v.end(), n - v[i])) {
cout << "YES" << endl;
return;
}
}
cout << "NO" << endl;
}
int main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char buf[0xff];
const int inf = 1e9;
int bitcount(int x) {
int c = 0;
for (; x; c++) x &= x - 1;
return c;
}
int bit(int x, int i) {
if (i < 0) return 0;
return x >> i & 1;
}
int solve(int n, int m) {
if (m > n) swap(n, m);
int maxmask = 1 << m;
int dp[n + 1][maxmask][maxmask];
for (int i = 0; i < (int)(n + 1); i++)
for (int j = 0; j < (int)(maxmask); j++)
for (int k = 0; k < (int)(maxmask); k++) dp[i][j][k] = inf;
for (int i = 0; i < (int)(maxmask); i++) dp[0][0][i] = bitcount(i);
for (int i = 1; i <= n; i++)
for (int b = 0; b < (int)(maxmask); b++)
for (int c = 0; c < (int)(maxmask); c++)
for (int a = 0; a < (int)(maxmask); a++) {
bool nospider = false;
for (int j = 0; j < (int)(m); j++)
if (!(bit(a, j) || bit(c, j) || bit(b, j - 1) || bit(b, j) ||
bit(b, j + 1))) {
nospider = true;
break;
}
if (nospider) continue;
dp[i][b][c] = min(dp[i][b][c], dp[i - 1][a][b] + bitcount(c));
}
int res = inf;
for (int b = 0; b < (int)(maxmask); b++) res = min(res, dp[n][b][0]);
return n * m - res;
}
int main() {
int n, m;
while (cin >> n >> m) cout << solve(n, m) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using f64 = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = double;
namespace io {
const int BUFSIZE = 1 << 20;
int isize, osize;
char ibuf[BUFSIZE + 10], obuf[BUFSIZE + 10];
char *is, *it, *os = obuf, *ot = obuf + BUFSIZE;
char getchar() {
if (is == it) {
is = ibuf;
it = ibuf + fread(ibuf, 1, BUFSIZE, stdin);
if (is == it) return EOF;
}
return *is++;
}
char getalpha() {
char c = getchar();
while (!isalpha(c)) c = getchar();
return c;
}
void putchar(char c) {
*os++ = c;
if (os == ot) {
fwrite(obuf, 1, BUFSIZE, stdout);
os = obuf;
}
}
int inp() {
int x = 0, f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF) return -1;
if (ch == '-') f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return f ? -x : x;
}
ll inp_ll() {
ll x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return f ? -x : x;
}
template <class T>
bool read(T& x) {
x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF) return 0;
if (ch == '-') f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
if (f) x = -x;
return 1;
}
bool read(char* s) {
char* t = s;
char ch = getchar();
for (; ch == ' ' || ch == '\n'; ch = getchar())
;
for (; ch != ' ' && ch != '\n' && ch != EOF; ch = getchar()) *t++ = ch;
*t = 0;
return s != t;
}
template <class T, class... Args>
bool read(T& x, Args&... args) {
return read(x) && read(args...);
}
template <class T>
bool readln(T& x) {
x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF) return 0;
if (ch == '-') f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
if (f) x = -x;
for (; ch != '\n' && ch != EOF; ch = getchar())
;
return 1;
}
bool readln(char* s) {
char* t = s;
while (1) {
char ch = getchar();
if (ch == '\n' || ch == EOF) break;
*t++ = ch;
}
*t = 0;
return s != t;
}
template <class T, class... Args>
bool readln(T& x, Args&... args) {
return read(x) && readln(args...);
}
template <class T>
void write(T x) {
static char s[22];
static char* it = s + 20;
static char* end = s + 20;
if (x < 0) {
putchar('-');
x = -x;
}
do {
*--it = x % 10 + '0';
x /= 10;
} while (x);
for (; it < end; ++it) putchar(*it);
}
void write(const char* s) {
for (; *s; ++s) putchar(*s);
}
template <>
void write(char* s) {
write((const char*)s);
}
template <>
void write(char c) {
putchar(c);
}
template <class T, class... Args>
void write(T x, Args... args) {
write(x);
write(args...);
}
void writeln() { putchar('\n'); }
template <class T, class... Args>
void writeln(T x, Args... args) {
write(x);
writeln(args...);
}
template <class Iterator>
bool input(Iterator st, Iterator ed) {
for (; st != ed; ++st) {
if (!read(*st)) return false;
}
return true;
}
template <class T>
bool input(T& a) {
return input(a.begin(), a.end());
}
template <class Iterator>
void print(Iterator st, Iterator ed, const char* c = " ") {
int flag = 0;
for (; st != ed; ++st) {
if (flag) write(c);
flag = 1;
write(*st);
}
writeln();
}
template <class T>
void print(const T& a, const char* c = " ") {
print(a.begin(), a.end(), c);
}
struct ender {
~ender() {
if (os != obuf) fwrite(obuf, 1, os - obuf, stdout);
}
} __ender;
} // namespace io
int64_t power(int64_t a, int64_t b, int64_t p) {
if (!b) return 1;
int64_t t = power(a, b >> 1, p);
t = t * t % p;
if (b & 1) t = t * a % p;
return t;
}
pll exgcd(ll a, ll b) {
if (b == 0) return {1, 0};
auto e = exgcd(b, a % b);
ll x = e.first;
ll y = e.second;
return {y, x - a / b * y};
}
mt19937 rd(1);
using namespace io;
template <class T>
inline void freshmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
inline void freshmax(T& a, const T& b) {
if (a < b) a = b;
}
int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
template <class T>
T det(T x1, T y1, T x2, T y2, T x3, T y3) {
return x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3;
}
template <class T>
T dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
const int INF = 1000000000;
void solve() {
int n;
read(n);
vector<vector<int>> v(n);
for (int i = 1; i < n; ++i) {
int x, y;
read(x, y);
x -= 1;
y -= 1;
v[x].push_back(y);
v[y].push_back(x);
}
vector<int> sz(n);
int root = -1, best = n;
function<void(int, int)> dfs = [&](int x, int pre) {
sz[x] = 1;
int largest = 0;
for (auto y : v[x]) {
if (y == pre) continue;
dfs(y, x);
sz[x] += sz[y];
freshmax(largest, sz[y]);
}
freshmax(largest, n - sz[x]);
if (largest < best) {
best = largest;
root = x;
}
};
dfs(0, -1);
vector<int> dis(n);
vector<int> w;
function<void(int, int)> dfs2 = [&](int x, int pre) {
w.push_back(x);
for (auto y : v[x]) {
if (y == pre) continue;
dis[y] = dis[x] + 1;
dfs2(y, x);
}
};
dfs2(root, -1);
int step = n / 2;
ll ans = 0;
vector<int> res(n);
for (int i = 0; i < n; ++i) {
res[w[i]] = w[(i + step) % n];
ans += dis[w[i]] + dis[res[w[i]]];
}
writeln(ans);
for (auto& x : res) x += 1;
print(res);
}
int main() {
int T = 1;
for (int test = 1; test <= T; ++test) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int(i) = 0; (i) < (((int)((t).size()))); ++(i)) s << t[i] << " ";
return s;
}
int a[3006], b[3006];
int main() {
int(n), (m);
scanf("%d %d", &(n), &(m));
for (int(i) = 0; (i) < (n); ++(i)) scanf("%d", a + i);
for (int(j) = 0; (j) < (m); ++(j)) scanf("%d", b + j);
int j = m - 1, res = 0;
for (int(i) = (n - 1); (i) >= (0); --i) {
if (j == -1) {
++res;
} else if (b[j] >= a[i]) {
--j;
} else {
++res;
}
}
pisz(res);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int getNextX(int& x) { return x = (x * 37LL + 10007) % 1000000007; }
void initAB(vector<int>& a, vector<int>& b, int n, int d, int x) {
for (int i = (0); i < ((n)); ++i) a[i] = i + 1;
for (int i = (0); i < ((n)); ++i) swap(a[i], a[getNextX(x) % (i + 1)]);
for (int i = (0); i < ((n)); ++i) {
if (i < d)
b[i] = 1;
else
b[i] = 0;
}
for (int i = (0); i < ((n)); ++i) swap(b[i], b[getNextX(x) % (i + 1)]);
}
int main() {
ios_base::sync_with_stdio(false);
int n, d, x;
cin >> n >> d >> x;
vector<int> a(n), b(n);
initAB(a, b, n, d, x);
vector<int> p(n + 1);
for (int i = (0); i < ((n)); ++i) p[a[i]] = i;
vector<int> ones;
for (int i = (0); i < ((n)); ++i) {
if (b[i]) ones.push_back(i);
}
int const s = 30;
for (int i = (0); i < ((n)); ++i) {
int res = -1;
for (int j = (0); j < ((s)); ++j) {
int const target = n - j;
if (p[target] <= i && b[i - p[target]]) {
res = target;
break;
}
}
if (res == -1) {
res = 0;
for (int j = (0); j < (((int)ones.size())); ++j) {
if (ones[j] > i) break;
res = max(res, a[i - ones[j]]);
}
}
cout << res << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, now, ans;
int v1[505], id2[505], v2[505], kans[505];
int main() {
scanf("%d%d", &n, &m);
for (register int i = 1; i <= n; ++i) {
scanf("%d", &v1[i]), v2[i] = -1;
for (register int j = 2; j <= m; ++j) {
int x;
scanf("%d", &x);
if (x != v1[i]) v2[i] = x, id2[i] = j;
}
if (v2[i] == -1) now ^= v1[i];
}
for (register int i = 1; i <= n; ++i) {
if (v2[i] == -1)
kans[i] = 1;
else {
if ((now ^ v1[i]) == 0)
now ^= v2[i], kans[i] = id2[i];
else
now ^= v1[i], kans[i] = 1;
}
}
if (now == 0)
puts("NIE");
else {
puts("TAK");
for (register int i = 1; i <= n; ++i) printf("%d ", kans[i]);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::deque;
using std::endl;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::queue;
using std::sort;
using std::string;
using std::vector;
int main() {
int n;
cin >> n;
int data[100] = {
0,
};
for (int i = 0; i < n; i++) {
cin >> data[i];
}
if (n == 1) {
if (data[0] == 0) {
cout << "UP";
} else if (data[0] == 15) {
cout << "DOWN";
} else {
cout << -1;
}
return 0;
}
if (data[n - 1] > data[n - 2]) {
if (data[n - 1] == 15) {
cout << "DOWN";
} else {
cout << "UP";
}
}
if (data[n - 1] < data[n - 2]) {
if (data[n - 1] == 0) {
cout << "UP";
} else {
cout << "DOWN";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("popcnt")
#pragma GCC target("avx2")
using namespace std;
template <typename T1, typename T2>
inline void mine(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void maxe(T1 &x, T2 y) {
if (x < y) x = y;
}
ostream &operator<<(ostream &a, const vector<int> &b) {
for (auto k : b) cout << k << ' ';
return a;
}
const int INF = 1000000050;
const long long BIG = (long long)2e18 + 50;
const int MX = 201000;
const double EPS = 1e-9;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int a[MX];
int b[MX];
int w[MX];
int p[MX];
int used[MX];
int done = 5e7;
int it = INF;
bool ahah(int v) {
if (used[v]) return false;
--done;
--it;
used[v] = 1;
if (p[a[v]] == -1) {
p[a[v]] = v;
used[v] = 0;
return 1;
}
if (p[b[v]] == -1) {
p[b[v]] = v;
used[v] = 0;
return 1;
}
if (it < 0) return false;
if (ahah(p[a[v]])) {
p[a[v]] = v;
used[v] = 0;
return 1;
}
if (ahah(p[b[v]])) {
p[b[v]] = v;
used[v] = 0;
return 1;
}
return false;
}
bool cmp(int a, int b) { return w[a] > w[b]; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> w[i];
}
vector<int> mda(m);
for (int i = 0; i < m; i++) mda[i] = i;
sort(mda.begin(), mda.end(), cmp);
int l = 0;
while (l < m) {
int r = l;
while (r < m && w[mda[r]] == w[mda[l]]) ++r;
shuffle(mda.begin() + l, mda.begin() + r, rng);
l = r;
}
int ans = 0;
memset(p, -1, sizeof(p));
for (auto &v : mda) {
if (done < 0) it = 100;
if (ahah(v)) {
ans += w[v];
}
}
cout << ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000 + 10;
int main() {
int pl, pr, vl, vr, k;
cin >> pl >> pr >> vl >> vr >> k;
vector<int> candidate;
for (int d = 1; d <= 9; d++) {
for (int i = 0; i < (1 << d); i++) {
int num = 0;
for (int r = 0; r < d; r++) {
if ((i >> r) & 1) {
num = num * 10 + 7;
} else {
num = num * 10 + 4;
}
}
candidate.push_back(num);
}
}
sort(candidate.begin(), candidate.end());
long long int ans = 0;
for (int i = 0; i < candidate.size(); i++) {
int leftborder1 = i >= 1 ? candidate[i - 1] + 1 : 1;
int rightborder1 = candidate[i];
int leftborder2 = -1;
int rightborder2 = -1;
if (i + k - 1 < candidate.size()) {
leftborder2 = candidate[i + k - 1];
rightborder2 = i + k < candidate.size() ? candidate[i + k] - 1 : 1E+9;
long long int num1left =
min(pr, rightborder1) - max(pl, leftborder1) >= 0
? min(pr, rightborder1) - max(pl, leftborder1) + 1
: 0;
long long int num2right =
min(vr, rightborder2) - max(vl, leftborder2) >= 0
? min(vr, rightborder2) - max(vl, leftborder2) + 1
: 0;
ans = ans + num1left * num2right;
long long int num1right =
min(pr, rightborder2) - max(pl, leftborder2) >= 0
? min(pr, rightborder2) - max(pl, leftborder2) + 1
: 0;
long long int num2left =
min(vr, rightborder1) - max(vl, leftborder1) >= 0
? min(vr, rightborder1) - max(vl, leftborder1) + 1
: 0;
ans = ans + num1right * num2left;
if (k == 1) {
if (min(pr, candidate[i]) - max(pl, candidate[i]) >= 0 &&
min(vr, candidate[i]) - max(vl, candidate[i]) >= 0) {
ans--;
}
}
}
}
printf("%.15f\n", 1.0 * ans / (pr - pl + 1) / (vr - vl + 1));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Mx = 1 << 16;
int N;
int Deg[Mx], D[Mx];
vector<int> L;
vector<pair<int, int> > ans;
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d%d", Deg + i, D + i);
}
for (int i = 0; i < N; i++)
if (Deg[i] == 1) L.push_back(i);
while (!L.empty()) {
int p = L.back();
L.pop_back();
if (Deg[p] != 1) continue;
Deg[p] = 0;
int q = D[p];
ans.push_back(pair<int, int>(p, q));
Deg[q]--;
D[q] ^= p;
if (Deg[q] == 1) L.push_back(q);
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
const ll MOD = 1e9 + 7, N = 1e5 + 10;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
ll n, k;
cin >> n >> k;
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
cin >> a[i];
}
map<ll, ll> cnt;
deque<ll> dq;
ll ii = 0;
while (ii < n) {
if (cnt[a[ii]] == 0) {
cnt[a[ii]] = 1;
dq.push_front(a[ii]);
}
if (dq.size() > k) {
ll tp = dq.back();
cnt[tp] = 0;
dq.pop_back();
}
ii++;
}
cout << (ll)dq.size() << '\n';
while (!dq.empty()) {
cout << dq.front() << ' ';
dq.pop_front();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 605, INF = 1e9;
int w[N][N], a[N], b[N];
bool used[N];
vector<int> v[N], t[N];
int g = 0;
bool dfs(int node) {
if (used[node]) return false;
used[node] = 1;
for (int to : t[node]) {
if (b[to] == -1 || dfs(b[to])) {
b[to] = node;
a[node] = to;
return true;
}
}
return false;
}
int main() {
int n, m, k, d;
scanf("%d%d%d%d", &n, &m, &k, &d);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
w[i][j] = INF;
}
w[i][i] = 0;
}
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
x--;
v[x].push_back(g++);
}
for (int i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
x--, y--;
w[x][y] = min(w[x][y], z);
w[y][x] = min(w[y][x], z);
}
for (int y = 0; y < n; y++) {
for (int x = 0; x < n; x++) {
for (int z = 0; z < n; z++) {
w[x][z] = min(w[x][z], w[x][y] + w[y][z]);
}
}
}
int l = -1, r = INF;
while (r - l > 1) {
int p = (l + r) >> 1;
for (int i = 0; i < k; i++) {
t[i].clear();
}
fill(a, a + k, -1);
fill(b, b + n, -1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (w[i][j] <= p) {
for (int x : v[i]) {
t[x].push_back(j);
}
}
}
}
bool work = true;
int ct = 0;
while (work) {
work = false;
fill(used, used + k, 0);
for (int i = 0; i < k; i++) {
if (a[i] == -1 && dfs(i)) {
work = true;
ct++;
}
}
}
if (ct >= d)
r = p;
else
l = p;
}
printf("%d", r == INF ? -1 : r);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int a, b, l, r;
cin >> a >> b >> l >> r;
bool loops_around = (l - 1) % (a + b) >= a && (r - 1) % (a + b) < a;
vector<string> first_four(4);
for (int i = 0; i < a; ++i) {
first_four[0].push_back('a' + i);
}
for (int i = 0; i < b; ++i) {
if (a > b && loops_around) {
first_four[1].push_back(first_four[0][b]);
} else {
first_four[1].push_back(first_four[0].back());
}
}
if (a <= b) {
for (int i = 0; i < a - 1; ++i) {
first_four[2].push_back('a' + i);
}
first_four[2].push_back(first_four[1].back() + 1);
} else {
for (int i = 0; i < b; ++i) {
first_four[2].push_back('a' + i);
}
for (int i = 0; i < a - b; ++i) {
first_four[2].push_back(first_four[1].back() + i + 1);
}
}
for (int i = 0; i < b; ++i) {
if (a > b && loops_around) {
first_four[3].push_back(first_four[2][b]);
} else {
first_four[3].push_back(first_four[2].back());
}
}
string ans = first_four[0] + first_four[1] + first_four[2] + first_four[3];
unordered_set<char> seen;
for (int i = l; i <= min(r, l + (int)ans.size() - 1); ++i) {
int pos = (i - 1) % ans.size();
seen.insert(ans[pos]);
}
cout << seen.size() << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0, lim - 1);
return uid(rang);
}
int mod = 1e9 + 7;
bool isprime(long long int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
void binarySearch(long long arr[], long long l, long long r, long long x) {
while (l <= r) {
long long m = l + (r - l) / 2;
if (arr[m] == x) {
arr[m] = -1;
return;
}
if (arr[m] < x)
l = m + 1;
else
r = m - 1;
}
}
int tree[100001];
void buildTree(int *a, int *tree, int start, int end, int treeNode) {
if (start == end) {
tree[treeNode] = a[start];
return;
}
int mid = (start + end) / 2;
buildTree(a, tree, start, mid, 2 * treeNode);
buildTree(a, tree, mid + 1, end, 2 * treeNode + 1);
tree[treeNode] = tree[2 * treeNode] + tree[2 * treeNode + 1];
}
void updateTree(int *a, int *tree, int start, int end, int treeNode, int idx,
int val) {
if (start == end) {
tree[treeNode] = val;
a[start] = val;
return;
}
int mid = (start + end) / 2;
if (idx > mid) {
updateTree(a, tree, mid + 1, end, 2 * treeNode + 1, idx, val);
} else {
updateTree(a, tree, start, mid, 2 * treeNode, idx, val);
}
tree[treeNode] = tree[2 * treeNode] + tree[2 * treeNode + 1];
}
int lcs(string s1, string s2) {
int m = s1.length(), n = s2.length();
int dp[m + 1][n + 1];
for (int i = 0; i <= m; i++) dp[i][0] = 0;
for (int j = 0; j <= n; j++) dp[0][j] = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (s1[i - 1] == s2[j - 1])
dp[i][j] = 1 + dp[i - 1][j - 1];
else
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
return dp[m][n];
}
int leftIndex(int tail[], int l, int r, int x) {
while (r > l) {
int m = l + (r - l) / 2;
if (tail[m] >= x)
r = m;
else
l = m + 1;
}
return r;
}
int longestSubsequence(int n, int a[]) {
int len = 1;
int tail[n];
tail[0] = a[0];
int i;
for (i = 1; i < n; i++) {
if (a[i] > tail[len - 1]) {
tail[len] = a[i];
len++;
} else {
int c = leftIndex(tail, 0, len - 1, a[i]);
tail[c] = a[i];
}
}
return len;
}
int query(int *a, int *tree, int start, int end, int treeNode, int left,
int right) {
if (start > right || end < left) {
return 0;
}
if (start >= left && end <= right) {
return tree[treeNode];
}
int mid = (start + end) / 2;
int ans1 = query(a, tree, start, mid, 2 * treeNode, left, right);
int ans2 = query(a, tree, mid + 1, end, 2 * treeNode + 1, left, right);
return ans1 + ans2;
}
void Dfs(vector<int> adj[], int src, vector<bool> &visited) {
visited[src] = true;
cout << src << " ";
for (auto itr : adj[src]) {
if (visited[itr] == false) {
Dfs(adj, itr, visited);
}
}
return;
}
vector<string> generate(long long n) {
vector<string> v;
queue<string> q;
for (long long i = 0; i < 26; i++) {
char word = i + 'a';
string worde = "";
worde += word;
q.push(worde);
}
while (n--) {
string ahead = q.front();
v.push_back(ahead);
q.pop();
for (long long i = 0; i < 26; i++) {
char word = i + 'a';
string s1 = ahead;
s1 += word;
q.push(s1);
}
}
return v;
}
long long binpow(long long a, long long b) {
long long ans = 1;
a %= mod;
while (b) {
if (b & 1) ans = (ans * a);
b /= 2;
a = (a * a);
ans %= mod;
a %= mod;
}
return ans;
}
bool isPerfectSquare(long double x) {
if (x >= 0) {
long long sr = sqrt(x);
return (sr * sr == x);
}
return false;
}
vector<long long> read(long long n) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
void write(vector<long long> v, long long n) {
for (long long i = 0; i < n; i++) cout << v[i] << " ";
cout << endl;
}
long long sum(long long n) {
long long sum = 0;
while (n > 0) {
long long rem = n % 10;
sum += rem;
n = n / 10;
}
return sum;
}
void solve() {
long long n, m;
cin >> n >> m;
long long dp[n + 1];
dp[1] = 1;
long long sum = 1;
for (int i = 2; i <= n; i++) {
dp[i] = sum;
for (int j = 1; j * j <= i; j++) {
long long repeat = ((i / j) - i / (j + 1));
long long calc_floor = ((dp[j] % m) * (repeat) % m);
dp[i] = dp[i] + calc_floor;
if (j != i / j && j > 1) dp[i] = dp[i] + dp[i / j];
dp[i] = dp[i] % m;
}
sum += dp[i];
sum = sum % m;
}
cout << dp[n] << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int arr[26] = {0};
int firstPosition[26] = {0};
for (int i = 0; i < 26; i++) firstPosition[i] = INT_MAX;
for (int i = 0; i < s.length(); i++) {
arr[s[i] - 'a']++;
if (firstPosition[s[i] - 'a'] == INT_MAX) {
firstPosition[s[i] - 'a'] = i + 1;
}
}
int in = -1, flag = 1;
for (int i = 0; i < 26; i++) {
if (arr[i] == 0) {
in = i;
break;
}
}
if (in != -1) {
for (int i = in + 1; i < 26; i++) {
if (arr[i] > 0) flag = 0;
}
}
for (int i = 1; i < 26; i++) {
if (firstPosition[i] < firstPosition[i - 1]) {
flag = 0;
}
}
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
string s;
long long a{0}, b{0}, c{0};
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A')
a++;
else if (s[i] == 'B')
b++;
else
c++;
}
if ((a + c) == b)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ll = long long;
vi in, out, p, d;
vector<vi> childs;
vector<char> chars;
int dfs_count = 0;
int max_depth = 1;
void dfs(int u) {
in[u] = ++dfs_count;
if (u != 0) d[u] = 1 + d[p[u]], max_depth = max(max_depth, d[u]);
for (auto& v : childs[u]) dfs(v);
out[u] = ++dfs_count;
}
struct X {
int in;
unsigned int xor_prefix;
bool operator<(const X& r) const { return in < r.in; }
};
vector<vector<X>> bfs_order;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int N, Q;
cin >> N >> Q;
in.resize(N), out.resize(N);
p.assign(N, -1);
d.assign(N, -1);
childs.assign(N, vi());
chars.resize(N);
for (int i = 1; i < N; i++) cin >> p[i], p[i]--, childs[p[i]].push_back(i);
cin >> ws;
for (auto i = decltype(N)(0); i < (N); i++) cin >> chars[i], chars[i] -= 'a';
d[0] = 1;
dfs(0);
bfs_order.assign(max_depth + 1, vector<X>{{-1, 0}});
queue<int> q;
q.push(0);
while (!q.empty()) {
auto u = q.front();
q.pop();
auto xor_prefix = (1 << chars[u]) ^ bfs_order[d[u]].back().xor_prefix;
bfs_order[d[u]].push_back({in[u], xor_prefix});
for (auto& v : childs[u]) q.push(v);
}
for (auto i = decltype(Q)(0); i < (Q); i++) {
int u, depth;
cin >> u >> depth;
u--;
if (depth > max_depth) {
cout << "Yes\n";
continue;
}
auto first = lower_bound(begin(bfs_order[depth]), end(bfs_order[depth]),
X{in[u], 0});
first = prev(first);
auto last = lower_bound(begin(bfs_order[depth]), end(bfs_order[depth]),
X{out[u], 0});
last = prev(last);
auto xor_range = last->xor_prefix ^ first->xor_prefix;
cout << (__builtin_popcount(xor_range) <= 1 ? "Yes" : "No") << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2e5;
struct Query {
int op, u, v;
};
int N, Q;
Query q[Maxn + 5];
set<pair<int, int> > g1, g2;
int fa[Maxn + 5], siz[Maxn + 5];
stack<pair<int, int> > stk;
void check(int u, int v) {
if (u > v) swap(u, v);
pair<int, int> p = make_pair(u, v);
if (g1.find(p) != g1.end()) g1.erase(p), g2.insert(p);
}
void update(int u, int v) {
if (u > v) swap(u, v);
pair<int, int> p = make_pair(u, v);
if (g2.find(p) != g2.end())
g2.erase(p);
else
g2.insert(p);
}
int find(int x) {
if (fa[x] == x) return x;
return find(fa[x]);
}
void unite(int u, int v) {
int fu = find(u), fv = find(v);
if (fu == fv) return;
if (siz[fu] < siz[fv]) swap(fu, fv);
stk.push(make_pair(fu, fv));
siz[fu] += siz[fv], fa[fv] = fu;
}
void rebuild() {
while (!stk.empty()) {
int u = stk.top().first, v = stk.top().second;
fa[v] = v, siz[u] -= siz[v];
stk.pop();
}
for (set<pair<int, int> >::iterator it = g2.begin(); it != g2.end(); it++)
unite((*it).first, (*it).second);
}
int main() {
scanf("%d %d", &N, &Q);
for (int i = 1; i <= Q; i++) scanf("%d %d %d", &q[i].op, &q[i].u, &q[i].v);
int block_size = sqrt(Q);
int ans = 0;
for (int i = 1; i <= Q; i += block_size) {
int k = min(Q, i + block_size - 1);
g2.clear();
for (int j = i; j <= k; j++)
if (q[j].op == 1) {
check(q[j].u, q[j].v);
check(q[j].u % N + 1, q[j].v % N + 1);
}
for (int j = 1; j <= N; j++) fa[j] = j, siz[j] = 1;
for (set<pair<int, int> >::iterator it = g1.begin(); it != g1.end(); it++)
unite((*it).first, (*it).second);
while (!stk.empty()) stk.pop();
for (int j = i; j <= k; j++) {
q[j].u = (q[j].u + ans - 1) % N + 1;
q[j].v = (q[j].v + ans - 1) % N + 1;
if (q[j].op == 1)
update(q[j].u, q[j].v);
else {
rebuild();
printf("%d", ans = (find(q[j].u) == find(q[j].v)));
}
}
for (set<pair<int, int> >::iterator it = g2.begin(); it != g2.end(); it++)
g1.insert((*it));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
int a[2010][2010];
int Max[4][10];
int ans[10][10];
int main() {
int n, m, k, s, x, y;
scanf("%d%d%d%d", &n, &m, &k, &s);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
x = a[i][j];
Max[0][x] = max(i + j, Max[0][x]);
Max[1][x] = max(i + n - j, Max[1][x]);
Max[2][x] = max(n - i + j, Max[2][x]);
Max[3][x] = max(n - i + n - j, Max[3][x]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
x = a[i][j];
for (int k = 1; k <= 9; k++) {
ans[x][k] = max(Max[0][k] - (i + j), ans[x][k]);
ans[x][k] = max(Max[1][k] - (i + n - j), ans[x][k]);
ans[x][k] = max(Max[2][k] - (n - i + j), ans[x][k]);
ans[x][k] = max(Max[3][k] - (n - i + n - j), ans[x][k]);
}
}
}
int t = 0;
scanf("%d", &x);
for (int i = 1; i < s; i++) {
scanf("%d", &y);
t = max(ans[x][y], t);
x = y;
}
printf("%d\n", t);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long mod = 1000000007;
using namespace std;
void yn(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long mx = max(a, max(b, c)), mn = min(a, min(b, c)),
md = a + b + c - mx - mn;
cout << max(0LL, md + d - mx) + max(0LL, mn - (md - d));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int i, j, k, l, m, n, p, q, r, t;
cin >> t;
while (t--) {
cin >> n >> p;
k = 2 * n + p;
vector<vector<int> > adj;
vector<int> *temp;
for (i = 0; i <= n - 1; i++) {
temp = new vector<int>;
adj.push_back(*temp);
}
for (i = 0; i <= n - 1; i++) {
adj[i].push_back(i + 1);
adj[i].push_back(i + 2);
}
q = p / n;
for (i = 0; i <= n - 1; i++) {
for (j = 0; j <= q - 1; j++) adj[i].push_back(j);
}
r = p % n;
for (i = 0; i <= r - 1; i++) {
adj[i].push_back(0);
}
for (i = 0; i <= n - 1; i++) {
j = adj[i].size();
k = i + 1;
for (l = i + 2; j != 0 && l <= n; l++) {
cout << k << " " << l << endl;
j--;
}
for (l = 1; l <= n && j != 0; l++) {
cout << k << " " << l << endl;
j--;
}
}
adj.clear();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, n1, n2;
cin >> n >> n1 >> n2;
int A[n], i;
for (i = 0; i < n; ++i) cin >> A[i];
sort(A, A + n, std::greater<int>());
int a, b;
if (n1 < n2) {
a = n1;
b = n2;
} else {
a = n2;
b = n1;
}
double ans1 = 0, ans2 = 0;
for (i = 0; i < a; ++i) ans1 += A[i];
ans1 = ans1 / (double)a;
for (; i < a + b; ++i) ans2 += A[i];
ans2 = ans2 / (double)b;
printf("%.8lf\n", ans1 + ans2);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 3e5 + 5;
const long long INF = 1e14;
vector<long long> adj[33];
int dirx[] = {-1, 1, 0, 0};
int diry[] = {0, 0, -1, 1};
long long ans[33][2];
void dfs(int u, int p, int dir, long long dist) {
int d = 0;
for (long long i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p) continue;
if (dir == d) d++;
ans[v][0] = ans[u][0] + dist * dirx[d];
ans[v][1] = ans[u][1] + dist * diry[d];
dfs(v, u, d ^ 1, (dist >> 1));
d++;
}
}
int main() {
ios::sync_with_stdio(false);
int n;
int a, b;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (long long i = 0; i < n; i++)
if (adj[i].size() > 4) {
cout << "NO\n";
return 0;
}
ans[0][0] = 0;
ans[0][1] = 0;
dfs(0, -1, -1, (1 << 30));
cout << "YES\n";
for (long long i = 0; i < n; i++)
cout << ans[i][0] << " " << ans[i][1] << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, a, b;
cin >> n >> k >> a >> b;
pair<long long int, long long int> cn[n];
for (long long int i = 0; i < n; i++) cin >> cn[i].first >> cn[i].second;
for (long long int i = 0; i < n; i++) {
cn[i].first = cn[i].first * a + cn[i].second * b;
cn[i].second = i;
}
sort(cn, cn + n);
vector<long long int> res;
for (long long int i = 0; i < n; i++) {
if (cn[i].first <= k) {
res.push_back(cn[i].second + 1);
k -= cn[i].first;
}
}
cout << res.size() << endl;
for (auto x : res) cout << x << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m[1005][1005];
int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
int n, ax, ay, bx, by, cx, cy;
struct node {
int x, y;
};
queue<node> q;
int check(int x, int y) {
if (x < 1 || x > n || y < 1 || y > n || m[x][y] == 1) return 0;
if (x == bx || y == by) return 0;
if (x + y == bx + by) return 0;
if (x - y == bx - by) return 0;
return 1;
}
int bfs() {
node now, next;
while (!q.empty()) {
now = q.front();
q.pop();
if (now.x == cx && now.y == cy) return 1;
for (int i = 0; i < 8; i++) {
next.x = now.x + dx[i];
next.y = now.y + dy[i];
if (check(next.x, next.y)) {
m[next.x][next.y] = 1;
q.push(next);
}
}
}
return 0;
}
int main() {
memset(m, 0, sizeof(m));
scanf("%d", &n);
scanf("%d %d", &bx, &by);
scanf("%d %d", &ax, &ay);
scanf("%d %d", &cx, &cy);
ax = n - ax + 1;
bx = n - bx + 1;
cx = n - cx + 1;
swap(ax, ay);
swap(bx, by);
swap(cx, cy);
node s;
s.x = ax;
s.y = ay;
q.push(s);
m[ax][ay] = 1;
if (bfs())
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, g_n;
int prime[N], tot;
int g_prime[N], cnt;
bool flag[N];
vector<pair<int, int> > g;
int L[N], R[N], id[N];
inline int min(int a, int b) { return a > b ? b : a; }
inline void pre() {
for (register int i = 2; i <= n; ++i) {
if (!flag[i]) {
prime[++tot] = i;
}
for (register int j = 1; j <= tot; ++j) {
if (i * prime[j] > n) break;
flag[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
inline void get_pig(int pos) {
for (register int i = L[pos]; i <= R[pos]; ++i) {
int tot;
cout << "A " << g_prime[i] << endl;
cin >> tot;
if (tot) {
g.push_back(make_pair(g_prime[i], 1));
return;
}
}
}
int main() {
scanf("%d", &n);
if (n == 1) {
puts("C 1");
fflush(stdout);
return 0;
}
pre();
g_n = sqrt(n);
for (register int i = 1; i <= tot; ++i) {
if (prime[i] <= g_n)
g_prime[++cnt] = prime[i];
else
break;
}
for (register int i = 1; i <= cnt; ++i) {
int x = g_prime[i];
cout << "B " << x << endl;
int cnt;
cin >> cnt;
cout << "A " << x << endl;
cin >> cnt;
int k = 0, res = x;
if (cnt) {
while (cnt) {
++k;
res *= x;
if (res > n) break;
cout << "A " << res << endl;
cin >> cnt;
}
g.push_back(make_pair(x, k));
}
}
for (register int i = cnt + 1; i <= tot; ++i) {
g_prime[++prime[0]] = prime[i];
}
cnt = prime[0];
int size = sqrt(cnt);
int sum_g = 0;
if (cnt % size)
sum_g = cnt / size + 1;
else
sum_g = cnt / size;
for (register int i = 1; i <= sum_g; ++i) {
L[i] = (i - 1) * size + 1;
R[i] = min(i * size, cnt);
}
for (register int i = 1; i <= sum_g; ++i)
for (register int j = L[i]; j <= R[i]; ++j) id[j] = i;
cout << "A 1" << endl;
cin >> cnt;
for (register int k = 1; k <= sum_g; ++k) {
int expect = 0;
for (register int i = L[k]; i <= R[k]; ++i) {
int x;
cout << "B " << g_prime[i] << endl;
cin >> x;
expect += x;
}
int tot;
cout << "A 1" << endl;
cin >> tot;
if (cnt - tot != expect) {
get_pig(k);
break;
}
cnt = tot;
}
int ans = 1;
int sx = g.size();
for (register int k = 0; k < sx; ++k) {
int x = g[k].first, p = g[k].second;
while (p) {
ans *= x;
--p;
}
}
cout << "C " << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[6];
int i;
for (i = 0; i < 6; ++i) {
cin >> a[i];
}
long long ans = (a[0] + a[5] + a[1]) * (a[0] + a[5] + a[1]) - a[1] * a[1] -
a[5] * a[5] - a[3] * a[3];
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
;
const long long int maxx = 3 * 1e5, limit = 1e17, MOD = 1e9 + 7;
string binary(long long int n) {
bitset<32> b(n);
string p = b.to_string();
return p;
}
long long int decimal(string s) {
long long int res = 0;
for (long long int i = 0; i < s.size(); i++) {
if (s[i] == '1') res = res + pow(2, s.size() - i - 1);
}
return res;
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int pow(long long int x, long long int n, long long int mod) {
if (n == 0) return 1;
long long int res = pow(x, n / 2, mod);
res = (res * res) % mod;
if (n % 2) res = (res * x) % mod;
return res;
}
long long int calcInverse(long long int a, long long int n = MOD) {
long long int t = 0, newt = 1;
long long int r = n, newr = a;
while (newr != 0) {
auto quotient = r / newr;
tie(t, newt) = make_tuple(newt, t - quotient * newt);
tie(r, newr) = make_tuple(newr, r - quotient * newr);
}
if (r > 1) throw runtime_error("a is not invertible");
if (t < 0) t += n;
t = t % n;
return t;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n, k;
cin >> n >> k;
long long int min1 = k / n;
k = k - min1 * n;
if (k == 0) {
cout << min1 << endl;
return 0;
} else {
cout << min1 + 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size(), count = 1, ans = 0;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1])
count++;
else {
ans += count / 5;
if (count % 5) ans++;
count = 1;
}
}
ans += count / 5;
if (count % 5) ans++;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l = 0, r = 0, u = 0, d = 0;
string s;
int q;
scanf("%d", &q);
while (q--) {
l = 0, r = 0, u = 0, d = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'L')
l++;
else if (s[i] == 'R')
r++;
else if (s[i] == 'D')
d++;
else if (s[i] == 'U')
u++;
}
l = min(l, r);
d = min(u, d);
if (l == 0 && d == 0) {
cout << 0 << endl;
} else if (l == 0) {
cout << '2' << endl;
cout << "UD" << endl;
} else if (d == 0) {
cout << "2" << endl;
cout << "LR" << endl;
} else {
cout << (l + d) * 2 << endl;
for (int i = 1; i <= l; i++) {
cout << 'L';
}
for (int i = 1; i <= d; i++) {
cout << "D";
}
for (int i = 1; i <= l; i++) {
cout << "R";
}
for (int i = 1; i <= d; i++) {
cout << "U";
}
cout << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
struct book {
int T, W;
};
int main() {
int n;
while (scanf("%d", &n) == 1) {
struct book B[100];
bool one = false;
int DP[2001];
int SumT, ans;
SumT = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &B[i].T, &B[i].W);
SumT += B[i].T;
if (B[i].T == 1) one = true;
}
for (int i = 0; i <= SumT; i++) DP[i] = 0;
for (int i = 0; i < n; i++) {
for (int j = SumT; j - B[i].T >= 0; j--) {
if (DP[j - B[i].T] + B[i].W > DP[j]) DP[j] = DP[j - B[i].T] + B[i].W;
}
}
for (ans = one ? 1 : 2; ans <= SumT; ans += one ? 1 : 2) {
if (ans >= DP[SumT] - DP[ans]) break;
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.