solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
const int dx[2][3] = {{1, -1, 1}, {1, -1, -1}},
dy[2][3] = {{0, 0, -1}, {0, 0, 1}};
int n, m, i, j, k, a[515][515], deg[515][515], ans;
int fa[300005];
queue<pair<int, int> > qx;
vector<pair<int, int> > v;
int id(int x, int y) { return (x - 1) * 510 + y; }
int fnd(int x) {
if (fa[x] == x) return x;
return fa[x] = fnd(fa[x]);
}
int main() {
for (((i)) = (1); ((i)) <= ((300000)); ((i))++) fa[i] = i;
read(n);
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
int x, y;
read(x);
read(y);
a[x + 4][y + 4] = 1;
qx.push(make_pair(x + 4, y + 4));
}
while (!qx.empty()) {
int x = qx.front().first, y = qx.front().second;
qx.pop();
ans += a[x][y];
if (a[x][y] == 2 && deg[x][y] == 3) v.push_back(make_pair(x, y));
for (((i)) = (0); ((i)) <= (((int)(3)) - 1); ((i))++) {
int xx = x + dx[x & 1][i], yy = y + dy[x & 1][i];
if (++deg[xx][yy] >= 2 && !a[xx][yy]) {
a[xx][yy] = 2;
qx.push(make_pair(xx, yy));
}
}
}
for (((i)) = (1); ((i)) <= ((510)); ((i))++)
for (((j)) = (1); ((j)) <= ((510)); ((j))++)
if (a[i][j]) {
for (((k)) = (0); ((k)) <= (((int)(3)) - 1); ((k))++) {
int xx = i + dx[i & 1][k], yy = j + dy[i & 1][k];
if (a[xx][yy] && (xx < i || (xx == i && yy < j))) {
int t1 = id(i, j), t2 = id(xx, yy);
if (fnd(t1) == fnd(t2)) {
puts("SICK");
return 0;
}
fa[fnd(t1)] = fnd(t2);
}
}
}
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
for (((k)) = (0); ((k)) <= (((int)(3)) - 1); ((k))++) {
int xx = it->first + dx[it->first & 1][k],
yy = it->second + dy[it->first & 1][k];
if (deg[xx][yy] >= 2) {
ans += 2;
break;
}
}
}
puts("RECOVERED");
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> adjl[200003];
long long a[200003], ans = 0;
bool b[200003], c[200003];
pair<long long, long long> extra[200003];
pair<long long, long long> dfs(int now, int prev) {
if (c[now] == 1 && b[now] == 0)
extra[now] = {1, 0};
else if (c[now] == 0 && b[now] == 1)
extra[now] = {0, 1};
else
extra[now] = {0, 0};
for (int next : adjl[now]) {
if (next == prev) continue;
a[next] = min(a[next], a[now]);
auto tmp = dfs(next, now);
extra[now].first += tmp.first;
extra[now].second += tmp.second;
}
long long use = min(extra[now].first, extra[now].second);
ans += 2 * use * a[now];
extra[now].first -= use;
extra[now].second -= use;
return extra[now];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adjl[u].push_back(v);
adjl[v].push_back(u);
}
dfs(1, 0);
if (extra[1].first + extra[1].second > 0 &&
extra[1].first != extra[1].second) {
cout << -1 << "\n";
return 0;
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
while (k--) {
if (n / 10) {
if (n % 10)
n--;
else
n /= 10;
} else
n--;
}
cout << n << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r;
while (cin >> n >> l >> r, n | l | r) {
int ans = 0;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int x = l; x <= r; x++) {
int f = 1;
for (int i = 0; i < n; i++) {
if (x % a[i] == 0) {
f = 0;
if (i % 2 == 0) ans++;
break;
}
}
if (f && n % 2 == 0) ans++;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long t;
cin >> t;
while (t--) {
long n;
cin >> n;
long arr[2 * n];
unordered_map<long, long> mp;
for (int i = 0; i < 2 * n; i++) {
cin >> arr[i];
mp[arr[i]]++;
if (mp[arr[i]] == 1) cout << arr[i] << " ";
}
cout << '\n';
}
}
| 2 |
#include <cstdio>
#include <algorithm>
void chmin(int &a, int b) {
a = std::min(a, b);
}
int p[50], t[50];
int dp[50][5];
const int INF = 1 << 30;
int main() {
int N;
while(1) {
scanf("%d", &N);
if(N == 0) return 0;
for(int i=0; i<N; i++) {
scanf("%d%d", &p[i+1], &t[i+1]);
}
for(int i=0; i<=N; i++) {
for(int k=0; k<=3; k++) {
dp[i][k] = INF;
}
}
dp[0][0] = 0;
for(int i=0; i<N; i++) {
bool ok = false;
for(int k=0; k<=3; k++) {
if(dp[i][k] == INF) continue;
int diff_p = abs(p[i+1] - p[i]);
int diff_t = t[i+1] - t[i];
// γγ‘γε΄’γ¨γγ²γη― γ»γγ‘γγ‘γγ΅γγ»γδ»°ιγγ?εγγγ€?
if(k < 3 && diff_p * (k+1) <= diff_t) {
chmin(dp[i+1][k+1], dp[i][k] + diff_p);
ok = true;
}
// γγγγ―γ?γ²γηγ²γγ»γγ§γγ«γγγ?γ©γγ»γγ―γγΌγγγγ€?
if(p[i+1] + p[i] * (k+1) <= diff_t) {
chmin(dp[i+1][1], dp[i][k] + p[i] + p[i+1]);
ok = true;
}
}
if(!ok) {
printf("NG %d\n", i+1);
break;
}
}
int ans = INF;
for(int i=0; i<=3; i++) chmin(ans, dp[N][i] + p[N]);
if(ans < INF) printf("OK %d\n", ans);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100006], gw[100006];
struct edge {
int u, v, w, idx;
};
bool cmp(edge a, edge b) { return a.w < b.w; }
int fa[100006];
int n, m, sum = 0;
edge edges[1000006];
int find(int n) { return (fa[n] == n ? n : (fa[n] = find(fa[n]))); }
bool book[1000006];
void kruskal() {
for (int i = 0; i < n + 1; ++i) fa[i] = i;
sort(edges, edges + m, cmp);
for (int i = 0; i < m; ++i) {
if (find(edges[i].u) != find(edges[i].v)) {
int u = edges[i].u, v = edges[i].v;
g[u].push_back(v), g[v].push_back(u);
gw[u].push_back(edges[i].w), gw[v].push_back(edges[i].w);
fa[find(edges[i].u)] = fa[find(edges[i].v)];
;
book[i] = true;
}
}
return;
}
int G[100006][20][2], h[100006];
bool done[100006];
void dfs(int u, int f) {
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i], w = gw[u][i];
if (v == f) continue;
h[v] = h[u] + 1;
G[v][0][0] = u, G[v][0][1] = w;
for (int j = 1; j < 20; ++j)
if (G[G[v][j - 1][0]][j - 1][0]) {
G[v][j][0] = G[G[v][j - 1][0]][j - 1][0],
G[v][j][1] = max(G[v][j - 1][1], G[G[v][j - 1][0]][j - 1][1]);
} else
break;
dfs(v, u);
}
}
int lca(int a, int b) {
int l = (h[a] > h[b] ? a : b), r = (h[a] > h[b] ? b : a);
int suml = 0, sumr = 0;
if (h[a] != h[b]) {
for (int i = 19; i >= 0; --i)
if (h[G[l][i][0]] >= h[r]) {
suml = max(suml, G[l][i][1]);
l = G[l][i][0];
}
}
if (l == r) return max(suml, sumr);
for (int i = 19; i >= 0; --i)
if (G[l][i][0] != G[r][i][0]) {
suml = max(suml, G[l][i][1]), sumr = max(G[r][i][1], sumr);
l = G[l][i][0], r = G[r][i][0];
}
suml = max(suml, G[l][0][1]), sumr = max(G[r][0][1], sumr);
return max(suml, sumr);
}
int res[1000006];
int main(void) {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
static int u, v, w;
cin >> u >> v >> w;
edges[i].u = u, edges[i].v = v, edges[i].w = w, edges[i].idx = i;
}
kruskal();
h[1] = 1;
dfs(1, 1);
int ans;
for (int i = 0; i < m; ++i)
if (!book[i]) {
ans = lca(edges[i].u, edges[i].v), res[edges[i].idx] = ans;
} else
res[edges[i].idx] = -1;
for (int i = 0; i < m; ++i)
if (~res[i]) printf("%d ", res[i]);
return 0;
}
| 5 |
//
// Created by Happig on 2021/3/6.
//
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
#define ENDL "\n"
#define lowbit(x) (x & (-x))
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double dinf = 1e300;
const ll INF = 1e18;
const int Mod = 1e9 + 7;
const int maxn = 2e5 + 10;
string A, B;
map<int, char> mp;
bool check() {
stack<char> s;
for (int i = 0; i < B.size(); i++) {
if (B[i] == '(') s.push(B[i]);
else {
if (s.empty()) return false;
else s.pop();
}
}
if (s.size()) return false;
return true;
}
int main() {
//freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
cin >> A;
bool ok = 0;
for (int i = 0; i < 8; i++) {
bitset<5> b(i);
mp.clear();
for (int j = 0; j < 3; j++) {
//cout << b[j];
if (b[j]) mp[j] = '(';
else mp[j] = ')';
//cout << (char) ('A' + j) << ": " << mp[j] << ",";
}
//cout << endl;
B = "";
for (int j = 0; j < A.size(); j++) {
B += mp[A[j] - 'A'];
}
//cout << B << endl;
if (check()) {
ok = 1;
break;
}
}
if (ok) cout << "YES" << ENDL;
else cout << "NO" << ENDL;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
template <typename T>
void read(T &qq) {
qq = 0;
char ch = getchar();
long long f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
qq = qq * 10 + ch - 48;
ch = getchar();
}
qq *= f;
}
int num[510][510];
int fps[510][510];
int main() {
int n;
for (int i = 1; i <= 504; i++)
for (int j = 1; j <= 504; j++) fps[i][j] = 999999;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i][i]);
fps[i][i] = 1;
}
for (int len = 2; len <= n; len++) {
for (int l = 1; l <= n - len + 1; l++) {
int r = l + len - 1;
for (int k = l; k < r; k++) {
fps[l][r] = min(fps[l][k] + fps[k + 1][r], fps[l][r]);
if (fps[l][k] == 1 && fps[k + 1][r] == 1 &&
num[l][k] == num[k + 1][r]) {
fps[l][r] = 1;
num[l][r] = num[l][k] + 1;
}
}
}
}
printf("%d\n", fps[1][n]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int A[300010], suf2[300010], suf[300010], ans[300010], tree[1200010];
void update(int low, int high, int ind, int value, int node) {
if (low == high) {
tree[node] = A[low];
return;
}
int mid = (low + high) / 2;
if (ind <= mid)
update(low, mid, ind, value, 2 * node);
else
update(mid + 1, high, ind, value, 2 * node + 1);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
}
int query(int low, int high, int begin, int end, int node) {
if (low > end || high < begin) return 1e9;
if (low >= begin && high <= end) return tree[node];
int mid = (low + high) / 2;
return min(query(low, mid, begin, end, 2 * node),
query(mid + 1, high, begin, end, 2 * node + 1));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = n; i < 3 * n; i++) A[i] = A[i - n];
for (int i = 0; i < 12 * n; i++) tree[i] = 1e9;
for (int i = 3 * n - 1; i >= 0; i--) {
int low = i, high = 3 * n;
while (low < high) {
int mid = (low + high) / 2;
if (query(0, 3 * n - 1, i, mid, 1) < (A[i] + 1) / 2)
high = mid;
else
low = mid + 1;
}
if (low == 3 * n)
ans[i] = 1e9;
else
ans[i] = low;
update(0, 3 * n - 1, i, A[i], 1);
}
suf2[3 * n - 1] = ans[3 * n - 1];
for (int i = 3 * n - 2; i >= 0; i--) {
suf2[i] = min(ans[i], suf2[i + 1]);
}
for (int i = 0; i < n; i++) {
if (suf2[i] > 1e7)
cout << -1 << " ";
else
cout << suf2[i] - i << " ";
}
cout << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int a[N];
int Min[N];
bool used[N];
struct node {
int u;
int c;
};
vector<node> f[N], f2[N];
int all;
int d[N];
int n;
struct node2 {
int loc;
int val;
bool operator<(const node2 it) const { return val > it.val; }
};
priority_queue<node2> Q[N];
void add(int u, int v, int c) {
node now;
now.u = v, now.c = c;
f[u].push_back(now);
}
void dfs(int u, int step) {
if (used[u]) return;
d[u] = step;
used[u] = true;
int size = f[u].size();
for (int i = 0; i < size; i++) {
node now = f[u][i];
node now2;
now2.u = u;
now2.c = now.c;
if (used[now.u]) continue;
f2[now.u].push_back(now2);
dfs(now.u, step + 1);
}
}
void solve() {
dfs(1, 1);
int i, j, k;
memset(Min, 0, sizeof(Min));
int w[N];
k = 0;
for (i = 2; i <= n; i++)
for (j = 1; j <= n; j++)
if (d[j] == i) w[k++] = j;
while (1) {
bool flag = 1;
for (j = 0; j < k; j++) {
i = w[j];
if (!Q[i].empty()) {
node now = f2[i][0];
int cnt = now.c;
int u = now.u;
while (cnt-- && (!Q[i].empty())) {
node2 next = Q[i].top();
Q[i].pop();
Min[next.loc]++;
Q[u].push(next);
}
priority_queue<node2> q;
while (!Q[i].empty()) {
node2 next = Q[i].top();
Min[next.loc]++;
q.push(next);
Q[i].pop();
}
while (!q.empty()) {
Q[i].push(q.top());
q.pop();
}
flag = 0;
}
}
if (flag) break;
}
for (i = 1; i <= n; i++) {
printf("%d", Min[i]);
if (i == n)
printf("\n");
else
printf(" ");
}
}
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
node2 now;
now.loc = i;
now.val = a[i];
Q[i].push(now);
}
for (i = 1; i < n; i++) {
int u, v, c;
scanf("%d %d %d", &u, &v, &c);
add(u, v, c);
add(v, u, c);
}
solve();
return 0;
}
| 3 |
#include <iostream>
int x, y, z;
int main() {
std::cin >> x >> y >> z;
std::cout << z << " " << x << " " << y;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int M = 250, N = 1e6;
int n, m;
int32_t x[M], y[M], ans[N + 1];
int64_t intersect(int i, int j) {
int64_t dx = x[j] - x[i], dy = y[j] - y[i];
if (dy == 0) return -1;
if (dx == 0) return x[i];
auto t = dy * x[i] - dx * y[i];
if (t % dy != 0) return -1;
return t / dy;
}
int count(int i, int j) {
int ans = 2;
int64_t dx = x[j] - x[i], dy = y[j] - y[i];
for (int k = 0; k < m; k++) {
if (k != i && k != j && dx * (y[k] - y[i]) == dy * (x[k] - x[i])) ans++;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> x[i] >> y[i];
fill(ans + 1, ans + n + 1, 1);
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
int64_t xx = intersect(i, j);
if (1 <= xx && xx <= n) {
ans[xx] = max(ans[xx], count(i, j));
}
}
}
int sum = 0;
for (int i = 1; i <= n; i++) sum += ans[i];
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MOD = 1000000007;
const long long MAXN = 100005;
const double eps = 1e-6;
long long n, m, a[1005][1005], dp1[1005][1005], dp2[1005][1005],
dp3[1005][1005], dp4[1005][1005];
int main() {
while (~scanf("%lld %lld", &n, &m)) {
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
scanf("%lld", &a[i][j]);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
dp1[i][j] = max(dp1[i - 1][j], dp1[i][j - 1]) + a[i][j];
}
}
for (long long i = n; i >= 1; i--) {
for (long long j = m; j >= 1; j--) {
dp2[i][j] = max(dp2[i + 1][j], dp2[i][j + 1]) + a[i][j];
}
}
for (long long i = n; i >= 1; i--) {
for (long long j = 1; j <= m; j++) {
dp3[i][j] = max(dp3[i][j - 1], dp3[i + 1][j]) + a[i][j];
}
}
for (long long j = m; j >= 1; j--) {
for (long long i = 1; i <= n; i++) {
dp4[i][j] = max(dp4[i - 1][j], dp4[i][j + 1]) + a[i][j];
}
}
long long ans = 0;
for (long long i = 2; i < n; i++) {
for (long long j = 2; j < m; j++) {
ans = max(
ans, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]);
ans = max(
ans, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]);
}
}
printf("%lld\n", ans);
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;cin>>s;
sort(s.begin(),s.end());
for(int i=0;i<s.size()-1;i++){
if(s[i]==s[i+1]){
cout<<"no"<<endl;
return 0;
}
}
cout<<"yes"<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int e1 = a * (b) + 2 * d;
int e2 = a * (c) + 2 * e;
if (e1 < e2) {
cout << "First";
} else if (e1 > e2) {
cout << "Second";
} else {
cout << "Friendship";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1001001001;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
vector<long long> res(3);
for (int i = 0; i < (3); ++i) cin >> res[i];
long long ans = 0;
for (int i = 0; i < (3); ++i) {
long long a = res[0], b = res[1];
long long div = res[2];
if (a >= b) {
long long p = a - b;
b += min(p, div);
div -= min(p, div);
div /= 2;
if (a == b) ans = max(ans, a + div);
} else {
long long p = b - a;
a += min(p, div);
div -= min(p, div);
div /= 2;
if (a == b) ans = max(ans, a + div);
}
rotate(res.begin(), res.begin() + 1, res.end());
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, counter = 0;
int add = 1;
bool first = true;
cin >> n;
string entry, edited = "";
cin >> entry;
while (entry[counter] != NULL) {
edited += entry[counter];
counter += add;
add++;
}
cout << edited;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++i)
#define per(i, a, b) for (int i = (a), i##end = (b); i >= i##end; --i)
mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
inline void chkmax(T &x, T y) { if (x < y) x = y; }
template <typename T>
inline void chkmin(T &x, T y) { if (x > y) x = y; }
inline int read() {
#define nc getchar()
int x = 0;
char c = nc;
while (c < 48) c = nc;
while (c > 47) x = x * 10 + (c ^ 48), c = nc;
return x;
#undef nc
}
typedef long long ll;
typedef vector <int> vi;
typedef pair <int, int> pii;
#define P 998244353
const int maxn = 3e5 + 10, MAXN = 3e5 + 10;
int Inc(int x, int y) {
return x + y < P ? x + y : x + y - P;
}
int Dec(int x, int y) {
return x < y ? x - y + P : x - y;
}
void Add(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
void Sub(int &x, int y) {
x -= y;
if (x < 0) x += P;
}
int qp(int a, int k) {
int res = 1;
for (; k; k >>= 1, a = 1ll * a * a % P) {
if (k & 1) res = 1ll * res * a % P;
}
return res;
}
int pw2[maxn], inv[maxn], fac[maxn], ifac[maxn];
int binom(int n, int m) {
return n < m ? 0 : 1ll * fac[n] * ifac[m] % P * ifac[n - m] % P;
}
void init() {
pw2[0] = 1, pw2[1] = 2;
fac[0] = ifac[0] = 1;
inv[1] = fac[1] = ifac[1] = 1;
rep(i, 2, maxn - 1) {
pw2[i] = Inc(pw2[i - 1], pw2[i - 1]);
inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
fac[i] = 1ll * i * fac[i - 1] % P;
ifac[i] = 1ll * inv[i] * ifac[i - 1] % P;
}
}
int Pow( int x , int a ) {
int ret = 1;
while( a ) {
if( a & 1 ) ret = ret * 1ll * x % P;
x = x * 1ll * x % P , a >>= 1;
}
return ret;
}
int Wn[2][MAXN];
void getwn( int len ) {
for( int mid = 1 ; mid < len ; mid <<= 1 ) {
int w0 = Pow( 3 , ( P - 1 ) / ( mid << 1 ) ) , w1 = Pow( 3 , P - 1 - ( P - 1 ) / ( mid << 1 ) );
Wn[0][mid] = Wn[1][mid] = 1;
for( int i = 1 ; i < mid ; ++ i )
Wn[0][mid + i] = Wn[0][mid + i - 1] * 1ll * w0 % P,
Wn[1][mid + i] = Wn[1][mid + i - 1] * 1ll * w1 % P;
}
}
int rev[MAXN];
void getr( int len ) {
int l = __builtin_ctz( len ) - 1;
for( int i = 1 ; i < len ; ++ i ) rev[i] = ( rev[i >> 1] >> 1 ) | ( ( i & 1 ) << l );
}
void NTT( vi& A , int len , int typ ) {
for( int i = 0 ; i < len ; ++ i ) if( i < rev[i] ) swap( A[i] , A[rev[i]] );
for( int mid = 1 ; mid < len ; mid <<= 1 )
for( int i = 0 ; i < len ; i += ( mid << 1 ) )
for( int j = i ; j < i + mid ; ++ j ) {
int t0 = A[j] , t1 = A[j + mid] * 1ll * Wn[typ][j - i + mid] % P;
A[j] = ( t0 + t1 > P ? t0 + t1 - P : t0 + t1 ) , A[j + mid] = ( t0 < t1 ? t0 - t1 + P : t0 - t1 );
}
if( typ ) for( int i = 0 , iv = Pow( len , P - 2 ) ; i < len ; ++ i ) A[i] = A[i] * 1ll * iv % P;
}
vi mul( vi a , vi b ) {
int l = a.size() + b.size() - 1 , len = 1;
if (l <= 100) {
vi as(l);
rep(i, 0, a.size() - 1) rep(j, 0, b.size() - 1) {
Add(as[i + j], 1ll * a[i] * b[j] % P);
}
return as;
}
while( len <= l ) len <<= 1;
getr( len );
a.resize( len ) , b.resize( len );
vi as( len );
NTT( a , len , 0 ) , NTT( b , len , 0 );
rep( i , 0 , len - 1 ) as[i] = a[i] * 1ll * b[i] % P;
NTT( as , len , 1 );
as.resize( l );
return as;
}
vi pol[MAXN];
vi divide(int l, int r) {
if (l == r) return pol[l];
int mid = r - 1, tmp = 0, cur = 0;
rep(i, l, r) tmp += pol[i].size();
rep(i, l, r - 1) if ((cur += pol[i].size()) * 2 >= tmp) {
mid = i; break;
}
return mul(divide(l, mid), divide(mid + 1, r));
}
int n, tot, A[maxn], h[maxn];
void discretize() {
static int data[maxn];
memcpy(data, h, sizeof data);
sort(data + 1, data + n + 1);
tot = unique(data + 1, data + n + 1) - data - 1;
rep(i, 1, n) A[h[i] = lower_bound(data + 1, data + tot + 1, h[i]) - data]++;
}
void solve() {
init();
cin >> n;
n *= 2;
rep(i, 1, n) h[i] = read();
discretize();
rep(i, 1, tot) {
// printf("#%d\n", A[i]);
pol[i].push_back(1);
rep(j, 1, A[i] / 2) {
int tmp = 1ll * binom(A[i], j + j) * fac[j + j] % P * qp(1ll * fac[j] * pw2[j] % P, P - 2) % P;
pol[i].push_back(tmp);
}
// for (int x : pol[i]) printf("%d ", x);
// puts("");
}
// puts("GG");
vi data = divide(1, tot);
int ans = 0;
rep(i, 0, data.size() - 1) {
// printf("!%d\n", data[i]);
int t = n - i * 2, tmp = 1ll * fac[t] * qp(1ll * fac[t / 2] * pw2[t / 2] % P, P - 2) % P;
ans = (ans + 1ll * (i & 1 ? -1 : 1) * data[i] * tmp % P + P) % P;
}
cout << ans << endl;
}
signed main() {
getwn( 1 << 17 );
// int T = read();
// while (T--) solve();
solve();
return 0;
}
| 0 |
#include <iostream>
#include <deque>
using namespace std;
int main()
{
long long n,q;
cin>>n>>q;
deque < deque<int> > a(n);
while(q--)
{
int b;
cin>>b;
if(b==0)
{
long long t,x;
cin>>t>>x;
a[t].push_back(x);
}
else if(b==1)
{
long long t;
cin>>t;
if(!a[t].empty())
{
cout<<a[t][0]<<endl;
}
}
else
{
long long t;
cin>>t;
if(!a[t].empty())
{
a[t].pop_front();
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
const ll N = 2e3 + 5;
ll n;
vector<vi> v(N);
ll cnt[N];
ll ans[N];
ll tree[N];
ll sz[N];
void upd(ll a, ll b) {
while (a <= n) {
tree[a] += b;
a += a & -a;
}
}
ll sum(ll a) {
ll s = 0;
while (a > 0) {
s += tree[a];
a -= a & -a;
}
return s;
}
ll src(ll a) {
ll l = 1, r = n, ans = -1;
while (l <= r) {
ll mid = (l + r) / 2;
if (sum(mid) >= a) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
return ans;
}
void dfs(ll a, ll b) {
ans[a] = src(cnt[a] + 1);
upd(ans[a], -1);
for (auto u : v[a]) {
if (u == b) continue;
dfs(u, a);
}
}
void findSz(ll a, ll b) {
sz[a] = 1;
for (auto u : v[a]) {
if (u == b) continue;
findSz(u, a);
sz[a] += sz[u];
}
if (sz[a] <= cnt[a]) sz[a] = (ll)1e9;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
ll root;
for (int i = 1; i <= n; i++) {
ll d;
cin >> d >> cnt[i];
if (d == 0) {
root = i;
continue;
}
v[i].push_back(d);
v[d].push_back(i);
}
for (int i = 1; i <= n; i++) upd(i, 1);
findSz(root, 0);
if (sz[root] >= (ll)1e9) {
cout << "NO\n";
return 0;
}
dfs(root, 0);
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 2 |
#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<algorithm>
#include<unordered_map>
#include<queue>
using namespace std;
int ruisekiwa[10000];
int S[10001];
signed main() {
int sum = 2;
ruisekiwa[1] = 2;
for (int i = 3; i < 10000; i++) {
bool a = true;
for (int j = 2; j*j <= i; j++) {
if (i%j == 0)a = false;
}
if (a) {
ruisekiwa[sum] = ruisekiwa[sum - 1] + i;
sum++;
}
}
for (int i = 0; i < sum; i++) {
for (int j = i + 1; j < sum; j++) {
int x = ruisekiwa[j] - ruisekiwa[i];
if (x <= 10000)S[x]++;
}
}
int a;
while (cin >> a, a) {
cout << S[a] << endl;
}
} | 0 |
#include<cstdio>
#include<vector>
#define pu push_back
#define po pop_back
const int mod=1000000007;
int N,p[200010][19],dep[200010];
int lca(int i,int j){
int k;
if(dep[i]>dep[j])k=i,i=j,j=k;
for(k=19;k--;)if(dep[i]-dep[j]>>k&1)j=p[j][k];
for(k=19;k--;)if(p[i][k]!=p[j][k])i=p[i][k],j=p[j][k];
if(i!=j)i=*p[i];
return i;
}
struct edge{int to;edge*next;}E[400010],*ne=E,*first[200010];
void link(int u,int v){*ne=(edge){v,first[u]};first[u]=ne++;}
struct item{
int id,f,g,pro;
void mer(const item&x){
f=(1ll*f*(x.g-x.f+mod)+1ll*x.f*pro)%mod;
g=1ll*g*x.g%mod;
pro=1ll*pro*(x.g-x.f+mod)%mod;
}
};
std::vector<item>S[200010];
void dfs(int i){
int d=dep[i],j=S[d].size()-1;
if(j<0)S[d].pu((item){i,1,2,1});
else{
int a=lca(i,S[d][j].id);
for(;j&&S[d][j-1].id>=a;j--)S[d][j-1].mer(S[d][j]),S[d].po();
if(S[d][j].id!=a){
S[d][j].pro=(S[d][j].g-S[d][j].f+mod)%mod;
}
S[d][j].id=a;
S[d].pu((item){i,1,2,1});
}
for(edge*e=first[i];e;e=e->next)dfs(e->to);
}
int dc[200010],pw2[200010];
int main(){
scanf("%d",&N);
for(int i=*dc=*pw2=1;i<=N;i++){
scanf("%d",p[i]);
for(int j=1;j<19;j++)p[i][j]=p[p[i][j-1]][j-1];
dep[i]=dep[*p[i]]+1;
link(*p[i],i);
dc[dep[i]]++;
pw2[i]=pw2[i-1]*2%mod;
}
dfs(0);
int ans=0;
for(int d=0;d<=N;d++)if(S[d].size()){
int j=S[d].size()-1;
for(;j;j--)S[d][j-1].mer(S[d][j]),S[d].po();
ans=(ans+1ll*S[d][0].f*pw2[N+1-dc[d]])%mod;
}
printf("%d\n",ans);
} | 0 |
#include<cstdio>
#include<algorithm>
#define N 100000
using namespace std;
long long A[N] = { 0 }, T[4 * N], lazy[4 * N] = { 0 };
void build(int l, int r, int k) {
if (l == r) {
T[k] = A[l];
return;
}
int mid = (l + r) / 2;
build(l, mid, k * 2);
build(mid + 1, r, k * 2 + 1);
T[k] = max(T[2 * k], T[2 * k + 1]);
}
void pushdown(int k) {
if (lazy[k]) {
lazy[2 * k] += lazy[k];
lazy[2 * k + 1] += lazy[k];
T[2 * k] += lazy[k];
T[2 * k + 1] += lazy[k];
lazy[k] = 0;
}
}
void updata(int L, int R, int l, int r, int k) {
if (L <= l && r <= R) {
T[k] += 1;
lazy[k] += 1;
return;
}
int mid = (l + r) / 2;
pushdown(k);
if (mid >= L) updata(L, R, l, mid, 2 * k);
if (mid < R) updata(L, R, mid + 1, r, 2 * k + 1);
T[k] = max(T[2 * k], T[2 * k + 1]);
}
long long find(int L, int R, int l, int r, int k) {
if (L <= l && r <= R) return T[k];
int mid = (l + r) / 2;
pushdown(k);
long long ans = 0;
if (mid >= L) ans = max(ans, find(L, R, l, mid, k * 2));
if (mid < R) ans = max(ans, find(L, R, mid + 1, r, k * 2 + 1));
return ans;
}
int main() {
int n, q;
scanf("%d%d", &q, &n);
build(0, n - 1, 1);
int com, s, t, x, y;
while (q--) {
scanf("%d%d", &s, &t);
updata(s, t-1, 0, n - 1, 1);
}
printf("%lld\n", T[1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[202][202][202];
int main() {
long long R, G, B;
cin >> R >> G >> B;
vector<long long> arrR = {LONG_LONG_MAX}, arrG = {LONG_LONG_MAX},
arrB = {LONG_LONG_MAX};
long long mx_val = 0;
for (long long i = 0; i < R; i++) {
long long val;
cin >> val;
arrR.push_back(val);
}
for (long long i = 0; i < G; i++) {
long long val;
cin >> val;
arrG.push_back(val);
}
for (long long i = 0; i < B; i++) {
long long val;
cin >> val;
arrB.push_back(val);
}
sort(arrR.rbegin(), arrR.rend());
sort(arrG.rbegin(), arrG.rend());
sort(arrB.rbegin(), arrB.rend());
for (long long i = 0; i <= R; i++) {
for (long long j = 0; j <= G; j++) {
for (long long k = 0; k <= B; k++) {
if (i >= 1 && j >= 1) {
dp[i][j][k] =
max(dp[i][j][k], dp[i - 1][j - 1][k] + (arrR[i] * arrG[j]));
}
if (i >= 1 && k >= 1) {
dp[i][j][k] =
max(dp[i][j][k], dp[i - 1][j][k - 1] + (arrR[i] * arrB[k]));
}
if (j >= 1 && k >= 1) {
dp[i][j][k] =
max(dp[i][j][k], dp[i][j - 1][k - 1] + (arrG[j] * arrB[k]));
}
if ((i + j + k) % 2 == 0) mx_val = max(mx_val, dp[i][j][k]);
}
}
}
cout << mx_val << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int MAXN = 2e5 + 10;
const int INF = 1e6;
int n, m;
map<pair<int, int>, bool> mp;
int a[5];
bool mark[MAXN];
bool check() {
int cnt = 0;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (mp[{a[i], a[j]}]) cnt++;
}
}
if (cnt == 10 || cnt == 0) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
mp[{u, v}] = true;
mp[{v, u}] = true;
}
for (int i = 1; i <= INF; i++) {
for (int j = 0; j < 5; j++) {
int x = rng() % n + 1;
while (mark[x]) {
x = rng() % n + 1;
}
a[j] = x;
mark[x] = true;
}
if (check()) {
for (int j = 0; j < 5; j++) {
cout << a[j] << ' ';
}
cout << '\n';
return 0;
}
for (int j = 0; j < 5; j++) {
mark[a[j]] = false;
}
}
cout << -1 << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<vector<int> > V(n, vector<int>(n, 0));
vector<int> lineas(n, 0);
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
V[a][b] = 1;
lineas[a]++;
}
int maxindice = 0;
vector<pair<int, pair<int, int> > > Vans;
for (int i = 0; i < n; i++) {
int miindice = i;
for (int j = i + 1; j < n; j++) {
if (lineas[j] < lineas[miindice]) {
miindice = j;
}
}
if (i != miindice) {
Vans.push_back(make_pair(1, make_pair(i, miindice)));
vector<int> A = V[i];
V[i] = V[miindice];
V[miindice] = A;
int a = lineas[i];
lineas[i] = lineas[miindice];
lineas[miindice] = a;
}
}
int pindice = 0;
for (int i = 1; i < n; i++) {
int k = pindice + 1;
for (; pindice < i; pindice++) {
if (V[i][pindice] == 0) {
bool J = false;
for (k = max(k, pindice + 1); k < n; k++) {
if (V[i][k] == 1) {
for (int l = 0; l < n; l++) {
int aux = V[l][k];
V[l][k] = V[l][pindice];
V[l][pindice] = aux;
J = true;
}
Vans.push_back(make_pair(2, make_pair(pindice, k)));
k++;
break;
}
}
if (!J) {
break;
}
}
}
}
cout << Vans.size() << "\n";
for (int i = 0; i < Vans.size(); i++) {
cout << Vans[i].first << " " << Vans[i].second.first + 1 << " "
<< Vans[i].second.second + 1 << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int s[41][41][41][41];
int r[41][41][41][41];
int b[41][41][41][41];
int a[41][41];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
bool flag = false;
int n, m, q;
cin >> n >> m >> q;
char ch;
getchar();
for (int i1 = 1; i1 <= 40; i1++)
for (int j1 = 1; j1 <= 40; j1++)
for (int i2 = 1; i2 <= 40; i2++)
for (int j2 = 1; j2 <= 40; j2++) {
b[i1][j1][i2][j2] = -1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ch = getchar();
a[i][j] = ch - '0';
}
getchar();
}
for (int i1 = 1; i1 <= n; i1++)
for (int j1 = 1; j1 <= m; j1++)
for (int i2 = 1; i2 <= n; i2++)
for (int j2 = 1; j2 <= m; j2++) {
if (i2 < i1 || j2 < j1) continue;
r[i1][j1][i2][j2] =
r[i1][j1][i2][j2 - 1] || r[i1][j1][i2 - 1][j2] || a[i2][j2];
}
for (int i1 = 1; i1 <= n; i1++)
for (int j1 = 1; j1 <= m; j1++)
for (int i2 = 1; i2 <= n; i2++)
for (int j2 = 1; j2 <= m; j2++) {
if (i2 < i1 || j2 < j1) continue;
s[i1][j1][i2][j2] = s[i1][j1][i2 - 1][j2] + s[i1][j1][i2][j2 - 1] -
s[i1][j1][i2 - 1][j2 - 1] - r[i1][j1][i2][j2] + 1;
}
int sum, x1, y1, x2, y2;
for (int i = 0; i < q; i++) {
cin >> x1 >> y1 >> x2 >> y2;
if (b[x1][y1][x2][y2] != -1) {
cout << b[x1][y1][x2][y2] << endl;
continue;
}
sum = 0;
for (int i = x1; i <= x2; i++)
for (int j = y1; j <= y2; j++) sum += s[i][j][x2][y2];
b[x1][y1][x2][y2] = sum;
cout << sum << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
constexpr long long mod = 1000000007;
const long long INF = mod * mod;
const long double eps = 1e-12;
const long double pi = acos(-1.0);
void chmin(int &a, int b) { a = min(a, b); }
void chmax(int &a, int b) { a = max(a, b); }
long long mod_pow(long long a, long long n, long long m = mod) {
a %= m;
long long res = 1;
while (n) {
if (n & 1) res = res * a % m;
a = a * a % m;
n >>= 1;
}
return res;
}
struct modint {
long long n;
modint() : n(0) { ; }
modint(long long m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
a.n += b.n;
if (a.n >= mod) a.n -= mod;
return a;
}
modint operator-=(modint &a, modint b) {
a.n -= b.n;
if (a.n < 0) a.n += mod;
return a;
}
modint operator*=(modint &a, modint b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0) return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
long long inv(long long a, long long p) {
return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 10001000;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
void solve() {
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
if (n % 2) {
if (a[n / 2] != b[n / 2]) {
cout << "No\n";
return;
}
}
vector<pair<int, int> > va, vb;
for (int i = 0; i < n / 2; i++) {
pair<int, int> pa = {a[i], a[n - 1 - i]};
pair<int, int> pb = {b[i], b[n - 1 - i]};
if (pa.first > pa.second) swap(pa.first, pa.second);
if (pb.first > pb.second) swap(pb.first, pb.second);
va.push_back(pa);
vb.push_back(pb);
}
sort((va).begin(), (va).end());
sort((vb).begin(), (vb).end());
if (va == vb) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) solve();
char nyaa;
cin >> nyaa;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
string a;
cin >> n >> k >> a;
int flag = 0;
for (int i = k; i < n; i++) {
if (a[i] > a[i - k])
flag = 1;
else if (a[i] < a[i - k])
break;
}
if (flag == 1) {
int pos = k - 1;
while (a[pos] == '9') {
a[pos--] = '0';
}
a[pos]++;
if (pos == -1) a[k - 1] = '1';
}
for (int i = k; i < n; i++) a[i] = a[i - k];
int pos = 0;
while (a[pos] == '0') pos++;
cout << n - pos << "\n";
while (pos < n) {
cout << a[pos];
pos++;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
template <class T>
ostream &operator<<(ostream &out, vector<T> &a) {
out << "{";
for (auto x : a) out << x << " ";
return out << "}";
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(12) << fixed;
smain();
}
long double dist(long double x1, long double y1, long double x2,
long double y2) {
return sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
}
void solve2() {
long long a, b, c;
cin >> a >> b >> c;
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (a == 0 || b == 0) {
cout << abs(x1 - x2) + abs(y1 - y2);
return;
}
long long lx = x1, rx = x2;
if (lx > rx) swap(lx, rx);
long long ly = y2, ry = y1;
if (ly > ry) swap(ly, ry);
long double f = (long double)(-a * x1 - c) / b;
long double s = (long double)(-b * y2 - c) / a;
long double ans = abs(x1 - x2) + abs(y1 - y2);
long double cur = abs(f - y1) + abs(x2 - s) + dist(x1, f, s, y2);
ans = min(ans, (cur));
s = (long double)(-a * x2 - c) / b;
cur = abs(f - y1) + abs(y2 - s) + dist(x1, f, x2, s);
ans = min(ans, (cur));
f = (long double)(-b * y1 - c) / a;
cur = abs(f - x1) + abs(y2 - s) + dist(f, y1, x2, s);
ans = min(ans, (cur));
s = (long double)(-b * y2 - c) / a;
cur = abs(f - x1) + abs(x2 - s) + dist(f, y1, s, y2);
ans = min(ans, (cur));
cout << ans;
}
void smain() { solve2(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> n >> a >> b;
int k = a;
if (b > 0) {
for (int i = 0; i < b; i++) {
k++;
if (k > n) {
k = 1;
}
}
} else if (b < 0) {
b = abs(b);
for (int i = 0; i < b; i++) {
k--;
if (k < 1) k = n;
}
} else
k = a;
cout << k << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
const int H = 10, W = 5;
int board[H][W];
int main(){
int h, score, inc;
while(cin >> h, h){
inc = 1;
score = 0;
for(int i = 0;i < h;++i){
for(int j = 0;j < W;++j){
cin >> board[i][j];
}
}
while(inc){
int c, k;
inc = 0;
for(int i = 0;i < h;++i){
for(int j = 0;j < W;++j){
c = 0;
for(int k = j;k < W && board[i][j] == board[i][k];++k){
++c;
}
if(c >= 3){
inc += board[i][j] * c;
for(int k = j;k < j + c;++k){
board[i][k] = 0;
}
}
j += (c - 1);
}
}
for(int i = 1;i < h;++i){
for(int j = 0;j < W;++j){
if(!board[i][j]){
for(int k = i - 1;0 <= k;--k){
board[k + 1][j] = board[k][j];
}
board[0][j] = 0;
}
}
}
score += inc;
}
cout << score << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, p1, p2, p3, t1, t2, ans, l[N], r[N];
int main() {
scanf("%d%d%d%d%d%d", &n, &p1, &p2, &p3, &t1, &t2);
scanf("%d%d", &l[1], &r[1]);
ans += (r[1] - l[1]) * p1;
for (int i = 2; i <= n; ++i) {
scanf("%d%d", &l[i], &r[i]);
ans += (r[i] - l[i]) * p1;
if (l[i] - r[i - 1] > t1 + t2)
ans += t1 * p1 + t2 * p2 + (l[i] - r[i - 1] - t1 - t2) * p3;
else if (l[i] - r[i - 1] > t1)
ans += t1 * p1 + (l[i] - r[i - 1] - t1) * p2;
else
ans += (l[i] - r[i - 1]) * p1;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, x, y, a[1001][1001];
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
while (q--) {
cin >> x >> y;
a[x][y] = 1 - a[x][y];
int ans = 0;
for (int i = 1; i <= n; i++) {
int c = 0;
for (int j = 1; j <= m; j++) {
if (a[i][j])
c++;
else
c = 0;
ans = max(ans, c);
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
int ans;
scanf("%d%d%d", &a, &b, &c);
ans = (a - b) * c;
if (!(ans % b))
ans /= b;
else {
ans /= b;
ans += 1;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int f[101][101];
int a[101], b[101];
int dp(int x, int y) {
if (x < 0 || y < 0) return 0;
if (f[x][y] >= 0) return f[x][y];
int tmp;
if (abs(a[x] - b[y]) <= 1) {
tmp = dp(x - 1, y - 1) + 1;
} else {
if (a[x] > b[y]) {
tmp = dp(x - 1, y);
} else {
tmp = dp(x, y - 1);
}
}
f[x][y] = tmp;
return f[x][y];
}
int main() {
int i, j, n, m;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
for (i = 0; i <= n; i++) {
for (j = 0; j <= m; j++) {
f[i][j] = -1;
}
}
cout << dp(n - 1, m - 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int j, t, n, i;
cin >> t;
for (j = 0; j < t; j++) {
cin >> n;
cout << n << '\n';
for (i = 0; i < n; i++) {
cout << i + 1 << ' ';
}
cout << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, q;
const int M = 200010;
int qzh[M], a[M], cf[M];
int main() {
int z = M, y = 0;
int l, r;
scanf("%d%d%d", &n, &k, &q);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l, &r);
cf[l]++;
cf[r + 1]--;
}
for (int i = 1; i < M; i++) a[i] = a[i - 1] + cf[i];
for (int i = 1; i < M; i++)
if (a[i] >= k)
a[i] = 1;
else
a[i] = 0;
for (int i = 1; i < M; i++) qzh[i] = qzh[i - 1] + a[i];
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
printf("%d\n", qzh[r] - qzh[l - 1]);
}
return 0;
}
| 2 |
#include <iostream>
#include <vector>
#include <utility>
#include <cstdio>
using namespace std;
#define rep(i, n) for(int i = 0;i < n;i++)
const int N = 10000001;
bool is_prime[N];
int main() {
rep(i, N) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
rep(i, N) {
if(!is_prime[i]) continue;
for(int j = i * 2; j < N;j += i) {
is_prime[j] = false;
}
}
while(1) {
int n;
cin >> n;
if(!n) break;
for(int i = n;i >= 0;i--) {
if(is_prime[i] && is_prime[i - 2] && is_prime[i - 6] && is_prime[i - 8]) {
cout << i << endl;
break;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<string, string> r;
for (int i = 0; i < m; i++) {
string x, y;
cin >> x >> y;
int l1 = x.length();
int l2 = y.length();
if (l2 < l1)
r[x] = y;
else
r[x] = x;
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
cout << r[s] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
double x[102], y[102], z[102];
double solx, soly, solz;
double dist(double _x, double _y, double _z) {
double distsol = 0, curr;
for (int i = 0; i < n; i++) {
curr = (_x - x[i]) * (_x - x[i]) + (_y - y[i]) * (_y - y[i]) +
(_z - z[i]) * (_z - z[i]);
if (distsol < curr) distsol = curr;
}
return distsol;
}
double ternary2(double _x, double _y) {
double l = -1e4, r = 1e4;
while (r - l > 0.00000001) {
double m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
if (dist(_x, _y, m1) > dist(_x, _y, m2))
l = m1;
else
r = m2;
}
return (l + r) / 2;
}
pair<double, double> ternary1(double _x) {
double l = -1e4, r = 1e4;
while (r - l > 0.00000001) {
double m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
double z1 = ternary2(_x, m1), z2 = ternary2(_x, m2);
if (dist(_x, m1, z1) > dist(_x, m2, z2))
l = m1;
else
r = m2;
}
return make_pair((l + r) / 2, ternary2(_x, (l + r) / 2));
}
void ternary() {
double l = -1e4, r = 1e4;
while (r - l > 0.00000001) {
double m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
pair<double, double> s1 = ternary1(m1), s2 = ternary1(m2);
if (dist(m1, s1.first, s1.second) > dist(m2, s2.first, s2.second))
l = m1;
else
r = m2;
}
solx = (l + r) / 2;
pair<double, double> sol = ternary1(solx);
soly = sol.first;
solz = sol.second;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf%lf%lf", x + i, y + i, z + i);
ternary();
printf("%.6lf %.6lf %.6lf", solx, soly, solz);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
long long int len = s.length();
string s1 = s;
sort(s1.begin(), s1.end());
stack<char> st;
char dp[len + 1];
dp[len] = 'z' + 3;
for (long long int i = len - 1; i >= 0; i--) {
dp[i] = min(dp[i + 1], s[i]);
}
string ans = "";
long long int i = 0, index = 0;
while (i != len) {
if (s[i] == s1[index]) {
ans += (s[i]);
char temp = dp[i + 1];
while (!st.empty() && st.top() <= temp) {
char x = st.top();
ans += (x);
st.pop();
}
index++;
while (s1[index] < dp[i + 1] && index < len) index++;
} else
st.push(s[i]);
i++;
}
while (!st.empty()) {
char x = st.top();
ans += x;
st.pop();
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1000111;
int n;
int dp[MN], father[MN], ln[MN], ln2[MN];
int main() {
ios ::sync_with_stdio(false);
cin >> n;
for (int i = (2), _b = (n + 1); i <= _b; i++) {
cin >> father[i];
dp[i] = 1;
int u = i;
while (u != 1) {
if (dp[u] > ln[father[u]])
ln2[father[u]] = ln[father[u]], ln[father[u]] = dp[u];
else
ln2[father[u]] = max(ln2[father[u]], dp[u]);
u = father[u];
int cur = max(ln[u], ln2[u] + 1);
if (cur == dp[u]) break;
dp[u] = cur;
}
printf("%d ", ln[1]);
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int N=305;
int n;
double dp[N][N][N];
double dfs(int a,int b,int c)
{
if(!a && !b && !c) return 0;
if(dp[a][b][c]) return dp[a][b][c];
if(a) dp[a][b][c]+=a/(a+b+c+0.0)*dfs(a-1,b,c);
if(b) dp[a][b][c]+=b/(a+b+c+0.0)*dfs(a+1,b-1,c);
if(c) dp[a][b][c]+=c/(a+b+c+0.0)*dfs(a,b+1,c-1);
dp[a][b][c]+=n/(a+b+c+0.0);
return dp[a][b][c];
}
int main()
{
scanf("%d",&n);
int a=0,b=0,c=0;
for(int i=1;i<=n;i++)
{
int x;
scanf("%d",&x);
if(x==1) a++;
if(x==2) b++;
if(x==3) c++;
}
printf("%.15f\n",dfs(a,b,c));
return 0;
} | 0 |
#include<iostream>
int main(){long long n,m;std::cin>>n>>m;std::cout<<(2*n<=m?n+(m-2*n)/4:m/2);} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s;
bool ok = false;
for (int i = 0; i < s.size(); i++) {
if (s.size() - i < 26) break;
int j = i;
vector<int> f(26);
int qq = 0;
while (j < s.size() && j - i + 1 <= 26) {
if (s[j] != '?')
f[s[j] - 'A']++;
else
qq++;
if (j - i + 1 == 26) break;
j++;
}
int have = 0;
queue<char> need;
for (int k = 0; k < 26; k++) {
if (f[k] > 0)
have++;
else
need.push(char(k + 'A'));
}
int want = 26 - have;
if (want == qq) {
ok = true;
for (int k = i; k <= j; k++)
if (s[k] == '?') {
s[k] = need.front();
need.pop();
}
}
}
if (!ok) {
puts("-1");
} else {
for (auto c : s) {
if (c == '?')
cout << 'A' << "";
else
cout << c << "";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const int modd = 1e9 + 7;
const int inf = 0x3f3f3f3f;
long long n, q, p, x, d;
long long a[maxn], b[maxn], c[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
cin >> q;
for (int i = 1; i <= q; ++i) {
cin >> d;
if (d == 1) {
cin >> p >> x;
a[p] = x;
b[p] = i;
} else if (d == 2) {
cin >> x;
c[i] = x;
}
}
for (int i = q; i >= 1; --i) {
c[i - 1] = max(c[i - 1], c[i]);
}
cout << max(a[1], c[b[1]]);
for (int i = 2; i <= n; i++) {
cout << " " << max(a[i], c[b[i]]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long calcsum(long long i, vector<long long> v) {
long long n = v.size();
long long sum = 0;
for (long long op = 0; op < n; ++op) {
sum += abs(i - v[op]);
}
return sum;
}
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long m;
cin >> m;
long long count = 0;
long long* arr = new long long[m];
char* arr1 = new char[m];
for (long long i = 0; i < m; ++i) {
cin >> arr[i];
if (arr[i] == 0) {
++count;
}
arr1[i] = '?';
}
long long n = s.size();
map<char, long long> m1;
for (long long i = 0; i < n; ++i) {
++m1[s[i]];
}
map<char, long long>::iterator it = m1.end();
--it;
while (true) {
if (it->second >= count) {
break;
}
--it;
}
long long left = m;
vector<long long> v;
char cur = it->first;
for (long long i = 0; i < m; ++i) {
if (arr[i] == 0) {
arr1[i] = cur;
v.push_back(i);
--left;
}
}
while (left > 0) {
--it;
vector<long long> aux;
for (long long i = 0; i < m; ++i) {
if (arr1[i] == '?') {
if (calcsum(i, v) == arr[i]) {
aux.push_back(i);
}
}
}
long long last = aux.size();
while (it->second < last) {
--it;
}
for (long long i = 0; i < last; ++i) {
v.push_back(aux[i]);
arr1[aux[i]] = it->first;
--left;
}
}
for (long long i = 0; i < m; ++i) {
cout << arr1[i];
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, c;
while (cin >> a >> c) {
long long count = 0;
long long sum = 0;
while (a != 0 || c != 0) {
int r1 = a % 3;
int r2 = c % 3;
if (r2 < r1) r2 += 3;
sum += (r2 - r1) % 3 * pow(3.0, (double)count);
count++;
a = a / 3;
c = c / 3;
}
cout << sum << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int x, long long int y) {
return y == 0 ? x : gcd(y, x % y);
}
bool isPalin(string x) {
long long int len = x.length();
for (int i = 0; i <= (len / 2) - 1; ++i) {
if (x[i] != x[len - 1 - i]) return false;
}
return true;
}
string tolowerStr(string x) {
string ret = "";
for (int i = 0; i <= (long long int)x.length() - 1; ++i) {
ret.push_back(tolower(x[i]));
}
return ret;
}
string toupperStr(string x) {
string ret = "";
for (int i = 0; i <= (long long int)x.length() - 1; ++i) {
ret.push_back(toupper(x[i]));
}
return ret;
}
long long int modulo(long long int a, long long int b, long long int c) {
long long int res = 1;
for (int i = 0; i < b; i++) {
res *= a;
res %= c;
}
return res % c;
}
bool double_equals(double a, double b, double epsilon = 0.1) {
return std::abs(a - b) < epsilon;
}
int main() {
ios_base::sync_with_stdio(false);
vector<pair<long long int, long long int> > v;
long long int n, a, ans, l1, l2, xlow, xhigh, ylow, yhigh, b, l;
cin >> n;
for (int i = 0; i <= n - 1; ++i) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
xlow = v[0].first;
xhigh = v[n - 1].first;
ylow = LONG_LONG_MAX;
yhigh = -LONG_LONG_MAX;
for (int i = 0; i <= v.size() - 1; ++i) {
if (v[i].second < ylow) ylow = v[i].second;
if (v[i].second > yhigh) yhigh = v[i].second;
}
l1 = ((xhigh - xlow) < 0 ? -(xhigh - xlow) : (xhigh - xlow));
l2 = ((yhigh - ylow) < 0 ? -(yhigh - ylow) : (yhigh - ylow));
l = ((l1) > (l2) ? (l1) : (l2));
ans = l * l;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e6;
int n, a[M], b[M], prv[M], rp[M];
int id[M], cnt;
vector<pair<int, int>> g[M];
int dis[M];
inline void add(int u, int v, int w = 0) { g[u].emplace_back(v, w); }
void build(int p, int l, int r) {
if (l == r) {
id[p] = l;
return;
}
id[p] = ++cnt;
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
add(id[p], id[p << 1]);
add(id[p], id[p << 1 | 1]);
}
void modify(int p, int l, int r, int ll, int rr, int u) {
if (l >= ll && r <= rr) {
add(u, id[p], 1);
return;
}
int mid = (l + r) >> 1;
if (mid >= ll) modify(p << 1, l, mid, ll, rr, u);
if (mid < rr) modify(p << 1 | 1, mid + 1, r, ll, rr, u);
}
int solve() {
priority_queue<pair<int, int>> pq;
memset(dis, 0x3f, sizeof dis);
dis[n] = 0;
pq.emplace(0, n);
while (!pq.empty()) {
auto p = pq.top();
pq.pop();
int u = p.second;
if (dis[u] + p.first != 0) continue;
for (auto it : g[u]) {
int v = it.first, w = it.second;
int tmp = v;
if (tmp <= n) v = b[v];
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
prv[v] = u;
if (tmp <= n) rp[v] = tmp;
pq.emplace(-dis[v], v);
}
}
}
return dis[0] >= 1e9 ? -1 : dis[0];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]), b[i] += i;
cnt = n;
build(1, 0, n);
for (int i = 1; i <= n; ++i)
if (a[i]) modify(1, 0, n, i - a[i], i - 1, i);
int ans = solve();
printf("%d\n", ans);
if (~ans) {
vector<int> nodes;
int cur = 0;
while (cur != n) {
if (cur <= n) nodes.emplace_back(rp[cur]);
cur = prv[cur];
}
reverse(nodes.begin(), nodes.end());
for (auto x : nodes) printf("%d ", x);
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
string s;
int ans,ansi;
int main(){
cin>>s;
for(int i=0;i<3;i++){
if(s[i]=='R')
ansi++;
if(ansi>=ans)
ans=ansi;
}
if(s=="RSR")
ans--;
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100100;
int sz[N];
bool del[N];
ll sum[N];
ll ans[N];
vector<pair<int, int>> g[N];
ll dfs(int u, int p) {
ll ansv = 0;
for (auto e : g[u]) {
if (e.first != p) {
ansv += (ans[e.second] * sz[e.first] + dfs(e.first, u));
}
}
return ansv;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].emplace_back(v, i);
g[v].emplace_back(u, i);
}
multiset<pair<ll, int>> ms;
for (int i = 1; i <= n; ++i) {
cin >> sum[i];
ms.emplace(sum[i], i);
sz[i] = 1;
}
for (int i = 1; i <= n - 2; ++i) {
int u = (--ms.end())->second;
ms.erase(--ms.end());
int v, id;
for (auto e : g[u]) {
if (!del[e.first]) {
tie(v, id) = e;
break;
}
}
del[u] = true;
sz[v] += sz[u];
ans[id] = (sum[u] - sum[v]) / (n - 2 * sz[u]);
}
int u = 0, v = 0;
for (int i = 1; i <= n; ++i) {
if (!del[i] && u) {
v = i;
} else if (!del[i]) {
u = i;
}
}
int id = 0;
for (auto e : g[u]) {
if (e.first == v) {
id = e.second;
}
}
ans[id] = (sum[u] - dfs(u, v) - dfs(v, u)) / sz[v];
for (int i = 1; i < n; ++i) {
cout << ans[i] << "\n";
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, c[maxn];
vector<int> e[maxn];
int fa[maxn], sz[maxn], son[maxn];
void dfs(int u, int f) {
fa[u] = f;
sz[u] = 1;
for (int i = 0; i < e[u].size(); ++i) {
int v = e[u][i];
if (v == f) continue;
dfs(v, u);
sz[u] += sz[v];
if (!son[u] || sz[son[u]] < sz[v]) son[u] = v;
}
}
int cnt[maxn], top;
long long sum[maxn], ans[maxn];
void Add(int u, int add) {
sum[cnt[c[u]]] -= 1ll * c[u];
cnt[c[u]] += add;
sum[cnt[c[u]]] += 1ll * c[u];
if (sum[top + 1]) top++;
if (!sum[top]) top--;
for (int i = 0; i < e[u].size(); ++i) {
int v = e[u][i];
if (v == fa[u]) continue;
Add(v, add);
}
}
void solve(int u, int keep) {
for (int i = 0; i < e[u].size(); ++i) {
int v = e[u][i];
if (v == fa[u] || v == son[u]) continue;
solve(v, 0);
}
if (son[u]) solve(son[u], 1);
for (int i = 0; i < e[u].size(); ++i) {
int v = e[u][i];
if (v == fa[u] || v == son[u]) continue;
Add(v, 1);
}
sum[cnt[c[u]]] -= 1ll * c[u];
cnt[c[u]]++;
sum[cnt[c[u]]] += 1ll * c[u];
if (sum[top + 1]) top++;
if (!sum[top]) top--;
ans[u] = sum[top];
if (!keep) Add(u, -1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
dfs(1, 0);
solve(1, 1);
for (int i = 1; i <= n; ++i) {
printf("%lld ", ans[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
string s;
vector<pair<char, long long int>> sor;
stack<char> t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
for (long long int i = 0; i < (long long int)s.size(); ++i)
sor.push_back(make_pair(s[i], i));
stable_sort(sor.begin(), sor.end());
long long int counter = 0;
auto iter = sor.begin();
while (iter != sor.end()) {
if (!t.empty() && t.top() <= iter->first) {
cout << t.top();
t.pop();
continue;
}
while (counter <= iter->second) {
t.push(s[counter]);
counter++;
}
if (counter - 1 == iter->second) {
cout << t.top();
t.pop();
}
iter++;
}
while (!t.empty()) {
cout << t.top();
t.pop();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 10;
const int Mod = 1000000007;
int state[maxn][maxn];
int n, m, k;
int map[maxn][maxn];
long long ans = 0;
int num[1 << 10], amont[15];
int two[1 << 10];
bool go[1 << 10][10];
long long dfs(int x, int y) {
if (y == m) {
if (x == n - 1) {
return 1;
}
return dfs(x + 1, 0);
}
state[x][y] = 0;
if (x > 0) state[x][y] |= state[x - 1][y];
if (y > 0) state[x][y] |= state[x][y - 1];
if (map[x][y]) {
if (go[state[x][y]][map[x][y] - 1]) return 0;
state[x][y] |= two[map[x][y] - 1];
return dfs(x, y + 1);
state[x][y] -= two[map[x][y] - 1];
} else {
if (num[state[x][y]] < n - 1 - x + m - 1 - y + 1) return 0;
int cnt = 0, flag = 0;
long long sum = 0, tt = 0;
for (int i = 0; i < k; i++) {
if (go[state[x][y]][i]) continue;
int temp = state[x][y];
state[x][y] |= two[i];
amont[i + 1]++;
if (amont[i + 1] == 1) {
cnt++;
if (flag == 0) {
flag = 1;
tt = dfs(x, y + 1);
}
} else
sum = (sum + dfs(x, y + 1)) % Mod;
state[x][y] = temp;
amont[i + 1]--;
}
sum = (sum + tt * cnt) % Mod;
return sum;
}
}
int main() {
two[0] = 1;
int i, j;
for (i = 1; i <= 10; i++) two[i] = two[i - 1] * 2;
scanf("%d%d%d", &n, &m, &k);
if (n + m - 1 > k) {
puts("0");
return 0;
}
if (m == 1000)
while (1)
;
memset(amont, 0, sizeof(amont));
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
scanf("%d", &map[i][j]);
if (map[i][j]) amont[map[i][j]]++;
}
memset(go, false, sizeof(go));
for (i = 0; i < (1 << k); i++) {
num[i] = 0;
for (j = 0; j < k; j++)
if ((i & (1 << j)) == 0)
num[i]++;
else
go[i][j] = true;
}
memset(state, 0, sizeof(state));
printf("%I64d\n", dfs(0, 0) % Mod);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int item[105];
int main() {
int n, k, sum = 0, day = 0;
bool check = 1;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &item[i]);
for (int i = 0; i < n; i++) {
if (item[i] > 8) {
if (i < n - 1) item[i + 1] += (item[i] - 8);
sum += 8;
} else
sum += item[i];
day++;
if (sum >= k) {
check = 0;
break;
}
}
if (check == 0)
printf("%d", day);
else
printf("-1");
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, T;
int main(void) {
scanf("%d%d", &N, &K);
if (K <= 1 || K >= 4 || N <= 3) {
cout << -1;
return 0;
}
if (K == 2) {
if (N == 4) {
cout << -1;
return 0;
} else {
printf("%d\n", N - 1);
for (int i = 1; i < N; i++) printf("%d %d\n", i, i + 1);
return 0;
}
}
if (K == 3) {
printf("%d\n", N - 1);
printf("1 2\n");
printf("2 3\n");
printf("3 4\n");
for (int i = 5; i <= N; i++) printf("%d %d\n", 2, i);
return 0;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h;
cin >> h >> w;
char c[200][200], d[200][200];
for (int i = 0; i < w; ++i)
for (int j = 0; j < h; ++j) cin >> c[i][j];
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
d[i][j] = c[j][i];
}
}
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
cout << d[i][j] << d[i][j];
}
cout << endl;
for (int j = 0; j < w; ++j) {
cout << d[i][j] << d[i][j];
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long n, m;
map<int, int> rt;
string t;
long ry = 0;
string p[] = {"1869", "6198", "1896", "9186", "9168", "6189", "8691"};
void df(int k) {
for (int i = 1; i <= rt[k]; ++i) {
ry = (ry * 10 + k) % 7;
cout << k;
}
}
int main() {
cin >> t;
for (int k = 0; k < t.size(); ++k) {
rt[t[k] - '0']++;
}
--rt[1];
--rt[6];
--rt[8];
--rt[9];
for (int k = 1; k <= 9; ++k) df(k);
cout << p[ry];
df(0);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int64_t mod = 1e9 + 7;
int64_t log2(int64_t x, int64_t base) { return log(x) / log(base); }
int64_t bin_pow(int64_t base, int64_t pow) {
if (pow == 0) {
return 1;
}
if (pow == 1) {
return base;
}
int64_t res = bin_pow(base, pow / 2);
res %= mod;
res *= res;
res %= mod;
if (pow % 2 != 0) {
res *= base;
res %= mod;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int64_t t;
cin >> t;
while (t--) {
int64_t n, k;
cin >> n >> k;
int64_t res = 0;
while (k > 0) {
int64_t n2p = log2(k, 2);
res += bin_pow(n, n2p);
res %= mod;
k -= pow(2, n2p);
}
cout << res << "\n";
}
}
| 2 |
#include "bits/stdc++.h"
#define in std::cin
#define out std::cout
#define rep(i,N) for(int i=0;i<N;++i)
typedef long long int LL;
const LL inf = 1123456789;
LL N, K, cou, ans;
int main()
{
in >> N >> K;
std::vector<LL>x(N), y(N);
rep(i, N) in >> x[i] >> y[i];
ans = 4123456789012345678;
rep(i, N)
{
rep(j, N)
{
rep(k, N)
{
rep(l, N)
{
LL minX = std::min({ x[i],x[j],x[k],x[l] });
LL maxX = std::max({ x[i],x[j],x[k],x[l] });
LL minY = std::min({ y[i],y[j],y[k],y[l] });
LL maxY = std::max({ y[i],y[j],y[k],y[l] });
cou = 0;
rep(m, N)
{
if (minX <= x[m] && x[m] <= maxX && minY <= y[m] && y[m] <= maxY) ++cou;
}
if (cou >= K) ans = std::min(ans, (maxX - minX)*(maxY - minY));
}
}
}
}
out << ans << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 105;
inline int gi()
{
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum;
}
int mod;
inline int add(int x, int y) {return x + y > mod ? x + y - mod : x + y;}
inline int sub(int x, int y) {return x < y ? x - y + mod : x - y;}
inline void inc(int &x, int y) {x += y; if (x >= mod) x -= mod;}
inline void dec(int &x, int y) {x -= y; if (x < 0) x += mod;}
int n, m, t;
int c[maxn][maxn], pw[maxn][maxn * maxn], f[2][maxn][maxn], tr[maxn][maxn];
void init()
{
for (int i = 0; i <= n; ++i)
for (int j = c[i][0] = 1; j <= i; ++j)
c[i][j] = add(c[i - 1][j - 1], c[i - 1][j]);
for (int i = 0; i <= t; ++i)
for (int j = pw[i][0] = 1; j <= n * m; ++j) pw[i][j] = (ll)pw[i][j - 1] * i % mod;
}
int main()
{
n = gi(); m = gi(); t = gi(); mod = gi();
if (n < m) swap(n, m);
init();
int cur = 0;
f[0][0][0] = 1;
for (int k = 1; k <= t; ++k) {
cur ^= 1; memset(f[cur], 0, sizeof(f[cur]));
for (int j = 0; j <= m; ++j)
for (int i = 0; i <= n; ++i) tr[j][i] = (ll)pw[k][i * (m - j)] * pw[t - k + 1][i * j] % mod;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j)
if (f[cur ^ 1][i][j]) {
for (int l = 0; l + i <= n; ++l)
f[cur][i + l][j] = (f[cur][i + l][j] + (ll)f[cur ^ 1][i][j] * c[i + l][i] % mod * tr[j][l]) % mod;
}
cur ^= 1; memset(f[cur], 0, sizeof(f[cur]));
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j) tr[i][j] = (ll)pw[k][j * (n - i)] * pw[t - k + 1][i * j] % mod;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j)
if (f[cur ^ 1][i][j]) {
for (int l = 0; l + j <= m; ++l)
f[cur][i][j + l] = (f[cur][i][j + l] + (ll)f[cur ^ 1][i][j] * c[j + l][j] % mod * tr[i][l]) % mod;
}
cur ^= 1; memset(f[cur], 0, sizeof(f[cur]));
for (int j = 0; j <= m; ++j)
for (int i = 0; i <= n; ++i) tr[j][i] = (ll)pw[k][i * (m - j)] * pw[t - k][i * j] % mod;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j)
if (f[cur ^ 1][i][j]) {
for (int l = 0; l + i <= n; ++l)
if (~l & 1) f[cur][i + l][j] = (f[cur][i + l][j] + (ll)f[cur ^ 1][i][j] * c[i + l][i] % mod * tr[j][l]) % mod;
else f[cur][i + l][j] = (f[cur][i + l][j] + (ll)(mod - f[cur ^ 1][i][j]) * c[i + l][i] % mod * tr[j][l]) % mod;
}
cur ^= 1; memset(f[cur], 0, sizeof(f[cur]));
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j) tr[i][j] = (ll)pw[k][j * (n - i)] * pw[t - k][i * j] % mod;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j)
if (f[cur ^ 1][i][j]) {
for (int l = 0; l + j <= m; ++l)
if (~l & 1) f[cur][i][j + l] = (f[cur][i][j + l] + (ll)f[cur ^ 1][i][j] * c[j + l][j] % mod * tr[i][l]) % mod;
else f[cur][i][j + l] = (f[cur][i][j + l] + (ll)(mod - f[cur ^ 1][i][j]) * c[j + l][j] % mod * tr[i][l]) % mod;
}
}
printf("%d\n", f[cur][n][m]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, p;
cin >> n >> m >> p;
long long t = 0;
bool took = false;
for (int i = 0; i < n; ++i) {
long long a;
cin >> a;
if (a % p && !took) {
t = i;
took = true;
}
}
took = false;
for (int i = 0; i < m; ++i) {
long long a;
cin >> a;
if (a % p && !took) {
t += i;
took = true;
}
}
cout << t << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int o, c, h;
scanf("%d %d", &c, &o);
if (o == 1 && c == 0) {
printf("YES");
return 0;
} else if (o > 1) {
h = o - 1;
if (c < h) {
printf("NO");
return 0;
} else {
if ((c - h) % 2 == 0) {
printf("YES");
return 0;
}
}
}
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
int main() {
int n, id = 0;
cin >> n;
vector<int> a(n + 1), b(n + 1);
for (int i = 1; i <= n; i++) {
string tmp;
cin >> tmp;
if (mp[tmp] == 0) mp[tmp] = ++id;
a[i] = mp[tmp];
b[i] = tmp.length() + b[i - 1];
}
int cnt = b.back() + n - 1, ans = cnt;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int len = 1 - (b[j] - b[i - 1]), ct = 0;
for (int k = j + 1; k + j - i <= n; k++) {
int flag = 1;
for (int p = 0; p < j - i + 1; p++) {
if (a[i + p] != a[k + p]) {
flag = 0;
break;
}
}
if (flag) {
ct++;
k = k + j - i;
}
}
if (ct) {
ans = min(ans, cnt + (ct + 1) * len);
}
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int n, m, bst, ci;
char z[5002][5002];
vector<int> st[5002], dr[5002], sus[5002], jos[5002];
void rid(int i, int j) {
if (dr[i][j] != m + 1) st[i][dr[i][j]] = st[i][j];
if (st[i][j] != 0) dr[i][st[i][j]] = dr[i][j];
if (sus[i][j] != 0) jos[sus[i][j]][j] = jos[i][j];
if (jos[i][j] != n + 1) sus[jos[i][j]][j] = sus[i][j];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> (z[i] + 1);
for (int i = 1; i <= n; ++i) {
st[i].resize(m + 2);
dr[i].resize(m + 2);
sus[i].resize(m + 2);
jos[i].resize(m + 2);
}
for (int a = 1; a <= n; ++a)
for (int b = 1; b <= m; ++b) {
if (z[a][b] == '.') continue;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
st[i][j] = j - 1;
dr[i][j] = j + 1;
sus[i][j] = i - 1;
jos[i][j] = i + 1;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (z[i][j] == '.') rid(i, j);
int x = a;
int y = b;
int nr = 0;
while (1 <= x && x <= n && 1 <= y && y <= m) {
rid(x, y);
if (z[x][y] == 'L')
y = st[x][y];
else if (z[x][y] == 'U')
x = sus[x][y];
else if (z[x][y] == 'R')
y = dr[x][y];
else
x = jos[x][y];
++nr;
}
if (nr > bst)
bst = nr, ci = 1;
else if (nr == bst)
++ci;
}
cout << bst << " " << ci << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long x = abs(a - b);
long long cnt = 0, inc = 0;
while (cnt + 5 <= x) {
long long d = x - cnt;
long long z = d / 5;
cnt += z * 5;
inc += z;
}
while (cnt + 2 <= x) {
long long d = x - cnt;
long long z = d / 2;
cnt += z * 2;
inc += z;
}
while (cnt + 1 <= x) {
long long d = x - cnt;
long long z = d;
cnt += z;
inc += z;
}
cout << inc << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int N = 1001;
const int oo = 1e9;
const double pi = acos(-1);
int main() {
int n;
cin >> n;
map<int, int> mp;
for (int i = 0; i < n * n; ++i) {
int x;
cin >> x;
++mp[x];
}
priority_queue<pair<int, int>> pr;
for (auto x : mp) pr.push({x.second, x.first});
vector<vector<int>> g(n, vector<int>(n));
int lmt = n / 2;
for (int i = 0; i < lmt; ++i) {
for (int j = 0; j < lmt; ++j) {
pair<int, int> top = pr.top();
pr.pop();
if (top.first < 4) {
puts("NO");
return 0;
}
g[i][j] = top.second;
g[n - i - 1][j] = top.second;
g[i][n - j - 1] = top.second;
g[n - i - 1][n - j - 1] = top.second;
top.first -= 4;
pr.push(top);
}
}
if (n % 2) {
for (int it = 0; it < 2; ++it) {
for (int j = 0; j < lmt; ++j) {
pair<int, int> top = pr.top();
pr.pop();
if (top.first < 2) {
puts("NO");
return 0;
}
if (it) {
g[lmt][j] = top.second;
g[lmt][n - j - 1] = top.second;
} else {
g[j][lmt] = top.second;
g[n - j - 1][lmt] = top.second;
}
top.first -= 2;
pr.push(top);
}
}
}
if (n % 2) g[n - lmt - 1][n - lmt - 1] = pr.top().second;
puts("YES");
for (auto v : g) {
for (auto x : v) cout << x << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 1e8;
const long long inf_ll = 1e16;
const double pi = 3.1415926535898;
bool debug = 0;
const int MAXN = 1e5 + 10;
const int LOG = 20;
const int mod = 1e9 + 7;
vector<int> g[MAXN];
int tin[MAXN];
int tout[MAXN];
int timer;
int up[MAXN][LOG];
int h[MAXN];
void dfs(int v, int p) {
tin[v] = ++timer;
up[v][0] = p;
for (int i = 1; i < LOG; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (int to : g[v]) {
if (to == p) continue;
h[to] = h[v] + 1;
dfs(to, v);
}
tout[v] = timer;
}
int lca(int a, int b) {
if (h[a] < h[b]) swap(a, b);
int dif = h[a] - h[b];
for (int i = 0; i < LOG; ++i) {
if (dif & (1 << i)) a = up[a][i];
}
assert(h[a] == h[b]);
if (a == b) return a;
for (int i = LOG - 1; i >= 0; --i) {
if (up[a][i] != up[b][i]) {
a = up[a][i];
b = up[b][i];
}
}
return up[a][0];
}
const int MX = 1e7 + 1;
int mn[MX];
void sieve() {
for (int i = 2; i < MX; ++i) {
if (!mn[i]) {
mn[i] = i;
if (1ll * i * i < MX) {
for (int e = i * i; e < MX; e = e + i) {
if (!mn[e]) mn[e] = i;
}
}
}
}
}
int a[MAXN];
int ans[MAXN];
pair<int, int> query[MAXN];
vector<pair<pair<int, int>, int>> add_ver;
vector<pair<pair<int, int>, int>> add_quer;
void process_ver(int v) {
int x = a[v];
while (x > 1) {
int cur = mn[x];
int cnt = 0;
while (mn[x] == cur) {
cnt++;
x /= cur;
}
add_ver.push_back({{cur, cnt}, v});
}
}
void process_quer(int val, int ind) {
int x = val;
while (x > 1) {
int cur = mn[x];
int cnt = 0;
while (mn[x] == cur) {
cnt++;
x /= cur;
}
add_quer.push_back({{cur, cnt}, ind});
}
}
vector<int> quer_ind[2][MAXN];
struct Fenwick_tree {
int t[MAXN];
Fenwick_tree() { memset(t, 0, sizeof t); }
inline void add(int pos, int val) {
for (; pos < MAXN; pos = pos + (pos & -pos)) {
t[pos] += val;
}
}
inline int get(int pos) {
int res = 0;
for (; pos > 0; pos = pos - (pos & -pos)) {
res += t[pos];
}
return res;
}
inline void add(int l, int r, int x) {
add(r + 1, -x);
add(l, x);
}
} tree;
inline int my_pow(long long a, int n) {
int res = 1;
while (n) {
if (n & 1) res = (res * a) % mod;
a = (a * a) % mod;
n >>= 1;
}
return res;
}
int was_added[MAXN];
void solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1, 1);
sieve();
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
process_ver(i);
}
int q;
cin >> q;
for (int i = 1; i <= q; ++i) {
int a, b, x;
scanf("%d %d %d", &a, &b, &x);
ans[i] = 1;
query[i] = {a, b};
process_quer(x, i);
}
sort(add_quer.begin(), add_quer.end());
sort(add_ver.begin(), add_ver.end());
for (int top_v = 0, top_q = 0;
top_v < (int(add_ver.size())) && top_q < (int(add_quer.size()));) {
int mx = max(add_quer[top_q].first.first, add_ver[top_v].first.first);
while (top_q < (int(add_quer.size())) && add_quer[top_q].first.first < mx)
++top_q;
while (top_v < (int(add_ver.size())) && add_ver[top_v].first.first < mx)
++top_v;
if (top_q == (int(add_quer.size())) || top_v == (int(add_ver.size())) ||
add_quer[top_q].first.first != add_ver[top_v].first.first)
continue;
int l = top_v, r = top_v;
while (r < (int(add_ver.size())) && add_ver[r].first.first == mx) ++r;
int mx_power = 0;
while (top_q < (int(add_quer.size())) &&
add_quer[top_q].first.first == mx) {
int cur_power = add_quer[top_q].first.second;
if (cur_power > mx_power) {
for (int i = l; i < r; ++i) {
if (add_ver[i].first.second > mx_power) {
int v = add_ver[i].second;
int temp = min(add_ver[i].first.second, cur_power) - mx_power;
tree.add(tin[v], tout[v], temp);
was_added[v] += temp;
}
}
mx_power = cur_power;
}
int id = add_quer[top_q].second;
int a, b;
tie(a, b) = query[id];
int lc = lca(a, b);
int res = tree.get(tin[a]) + tree.get(tin[b]) - tree.get(tin[lc]);
if (lc != 1) res = res - tree.get(tin[up[lc][0]]);
ans[id] = (1ll * my_pow(mx, res) * ans[id]) % mod;
++top_q;
}
for (int i = l; i < r; ++i) {
int v = add_ver[i].second;
tree.add(tin[v], tout[v], -was_added[v]);
was_added[v] = 0;
}
top_v = r;
}
for (int i = 1; i <= q; ++i) {
printf("%d\n", ans[i]);
}
}
signed main() {
int t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct seg_tree {
long long seg[4 * 200009];
pair<long long, long long> arr[200009];
void construct_segtree(int start, int end, int pos) {
if (end == start + 1)
seg[pos] = start;
else {
int mid = (start + end) / 2;
construct_segtree(start, mid, 2 * pos + 1);
construct_segtree(mid, end, 2 * pos + 2);
seg[pos] = arr[seg[2 * pos + 1]].first <= arr[seg[2 * pos + 2]].first
? seg[2 * pos + 1]
: seg[2 * pos + 2];
}
}
long long get_query(int ql, int qh, int low, int high, int pos) {
if (qh <= low || ql >= high) return -1;
if (low >= ql && high <= qh) return seg[pos];
int mid = (low + high) / 2;
long long v1 = get_query(ql, qh, low, mid, 2 * pos + 1);
long long v2 = get_query(ql, qh, mid, high, 2 * pos + 2);
if (v1 == -1)
return v2;
else if (v2 == -1)
return v1;
if (arr[v1].first <= arr[v2].first)
return v1;
else
return v2;
}
};
int comp(pair<long long, long long> x, pair<long long, long long> y);
long long get_nxt_best(long long x);
long long get_farrest(long long x);
long long fn();
seg_tree tree;
pair<long long, long long> arr[200009];
long long n, tank_size, last_point;
const long long inf = (1LL << 60);
int main() {
scanf("%lld %lld %lld", &last_point, &tank_size, &n);
for (int i = 0; i < n; i++) scanf("%lld %lld", &arr[i].second, &arr[i].first);
sort(arr, arr + n, comp);
for (int i = 0; i < n; i++) tree.arr[i] = arr[i];
tree.construct_segtree(0, n, 0);
long long ans = fn();
printf("%lld\n", ans == inf ? -1 : ans);
return 0;
}
long long fn() {
long long ret = 0, curr_station = 0;
long long feul = tank_size;
if (arr[0].second > tank_size) return inf;
curr_station = 0;
feul -= arr[0].second;
while (true) {
int c1 = (curr_station == n - 1 &&
last_point - arr[curr_station].second > tank_size);
int c2 =
(curr_station < n - 1 &&
arr[curr_station + 1].second - arr[curr_station].second > tank_size);
if (c1 + c2) return inf;
long long nxt_best = get_nxt_best(curr_station);
if (nxt_best == inf) {
if (arr[curr_station].second + tank_size >= last_point) {
long long dist = last_point - arr[curr_station].second;
if (feul < dist) ret += (dist - feul) * arr[curr_station].first;
break;
}
ret += (tank_size - feul) * arr[curr_station].first;
feul = tank_size;
long long farrest = get_farrest(curr_station);
if (farrest == -1) return inf;
long long to_go = tree.get_query(curr_station + 1, farrest + 1, 0, n, 0);
if (to_go == -1) return inf;
feul -= arr[to_go].second - arr[curr_station].second;
curr_station = to_go;
} else {
if (arr[nxt_best].second >= last_point) {
long long dist = last_point - arr[curr_station].second;
if (feul < dist) ret += (dist - feul) * arr[curr_station].first;
break;
}
long long dist = arr[nxt_best].second - arr[curr_station].second;
if (dist > feul)
ret += (dist - feul) * arr[curr_station].first, feul = dist;
feul -= arr[nxt_best].second - arr[curr_station].second;
curr_station = nxt_best;
}
}
return ret;
}
long long get_nxt_best(long long x) {
long long s = x + 1, b = n - 1, ret = inf;
while (b >= s) {
long long mid = (b + s) / 2;
long long c1;
if (x + 1 == mid + 1)
c1 = mid + 1;
else
c1 = tree.get_query(x + 1, mid + 1, 0, n, 0);
if (arr[c1].first <= arr[x].first)
b = mid - 1, ret = min(ret, mid);
else
s = mid + 1;
}
if (ret != inf) {
if (arr[ret].second - arr[x].second > tank_size) return inf;
}
return ret;
}
long long get_farrest(long long x) {
long long s = x + 1, b = n - 1, ret = -1;
while (b >= s) {
long long mid = (b + s) / 2;
if (arr[mid].second - arr[x].second <= tank_size) {
ret = max(ret, mid);
s = mid + 1;
} else
b = mid - 1;
}
return ret;
}
int comp(pair<long long, long long> x, pair<long long, long long> y) {
return x.second < y.second;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[1000], l, r;
int main() {
long long n, m;
cin >> n >> m;
l = 0, r = n - 1;
for (int i = 1; i <= n; ++i) {
int rem = n - i;
if (rem == 0) {
a[l] = i;
} else {
long long tmp = (1LL) << (rem - 1);
if (tmp >= m) {
a[l++] = i;
} else {
a[r--] = i;
m -= tmp;
}
}
}
for (int i = 0; i < n; ++i) printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 100 * 1000 + 16;
int n;
int a[128];
int b[110][1 << 17];
int dp[110][1 << 17];
int p[60];
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 2, k = 0; i < 60; ++i) {
if (p[i]) continue;
int b = 1 << k++;
for (int j = i; j < 60; j += i) p[j] |= b;
}
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
int msk = (1 << 17) - 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= msk; ++j) {
int v = dp[i - 1][j];
if (v < 0) continue;
for (int k = 1; k < 60; ++k) {
int m = p[k];
if (m & j) continue;
int x = v + abs(k - a[i]);
m |= j;
if (dp[i][m] == -1 || dp[i][m] > x) {
b[i][m] = k;
dp[i][m] = x;
}
}
}
}
vector<int> c;
int best = -1;
for (int i = 0; i < (1 << 17); ++i)
if (dp[n][i] != -1 && (best == -1 || dp[n][best] > dp[n][i])) best = i;
for (int i = n; i > 0; --i) {
int x = b[i][best];
a[i] = x;
best &= ~p[x];
}
for (int i = 1; i <= n; ++i) cout << a[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6, M = 25;
vector<int> v[M];
int s[N], cnt[N];
bool dp[N];
int main() {
int n, m, d;
cin >> n >> m >> d;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
for (int j = 0; j < t; j++) {
int a;
cin >> a;
s[a] = i;
}
}
for (int i = 1; i <= n; i++) {
cnt[s[i]]++;
if (i >= d) {
if (i > d) cnt[s[i - d]]--;
int val = 0;
for (int j = 0; j < m; j++) {
if (cnt[j] > 0) val += (1 << j);
}
dp[val] = true;
}
}
int ans = 0;
for (int i = 0; i < (1 << m); i++) {
int cnt = 0;
for (int j = 0; j < m; j++) {
if ((i & (1 << j)) && dp[i - (1 << j)]) dp[i] = true;
if (i & (1 << j)) cnt++;
}
if (!dp[i]) ans = max(ans, cnt);
}
cout << m - ans;
}
| 4 |
#include<cstdio>
int main()
{
long long a;
while(scanf("%lld",&a)==1)
{
if(a==0)break;
long long res=1ll;
for(long long i=2;i*i<=a;i++)
{
long long t=0;
if(a%i==0)
{
while(a%i==0)
{
a=a/i;
t++;
}
res=res*(2*t+1);
}
}
if(a!=1)
res=res*3;
printf("%lld\n",(res+1)/2);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18;
const long long int mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long int n, d, h, p, m, i, r;
cin >> n >> d >> h;
if (h > n - 1 || d < h || d - h > h)
cout << -1 << endl;
else if (n > 2 && d == 1)
cout << -1 << endl;
else {
for (i = 1; i <= h; i++) cout << i << " " << i + 1 << endl;
r = i - 1;
if (d > h) {
p = d - h;
cout << 1 << " " << i + 1 << endl;
i++;
p--;
while (p != 0) {
cout << i << " " << i + 1 << endl;
p--, i++;
}
}
while (i < n) {
cout << r << " " << i + 1 << endl;
i++;
}
}
}
| 2 |
#include <bits/stdc++.h>
inline int read() {
char c;
int x;
for (c = getchar(); !isdigit(c); c = getchar())
;
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return x;
}
const int mod = 1e9 + 7;
const int dx[8] = {1, 1, -1, -1, 2, 2, -2, -2};
const int dy[8] = {2, -2, 2, -2, 1, -1, 1, -1};
const int N = 105;
int nn, mm, f[N][N];
__int128_t solve1(__int128_t n, __int128_t m) {
if (n % 2 == 0) {
__int128_t res = solve1(n - 1, m);
m = std::min(n / 2, m);
__int128_t x = n / 2 % 2 ? n / 2 : n / 2 + 1;
__int128_t y = n / 2 % 2 ? n / 2 + 1 : n / 2;
res += x * ((m + 1) / 2) + y * (m / 2);
return res;
}
n /= 2;
__int128_t res = 0;
if (n <= m) {
res += n * (n + 1) * (n * 4 + 5) / 6;
} else {
res += m * (m + 1) * (m * 4 + 5) / 6;
res -= m * (m + 1) * (m + 1);
res += m * (n + 1) * (n + 1);
}
return res;
}
__int128_t solve2(__int128_t n, __int128_t m) {
__int128_t res = std::min((n - 1) / 2, m - 1);
res = res * (res + 1) / 2;
return res;
}
__int128_t solve3(__int128_t n, __int128_t m) {
__int128_t res;
n = std::min(n, m) - 1;
res = (4 + n * n * 3 + n * 9 + (n % 3 - (n - 1) % 3) * 2) / 18;
return res * 2;
}
__int128_t check(__int128_t n, __int128_t m) {
__int128_t res = 0;
for (__int128_t l = 1, r = 1e9, mid; l <= r;) {
mid = (l + r) / 2;
if (std::min(mid, m - mid - mid) > std::max((__int128_t)0, mid * 4 - n)) {
l = mid + 1;
res = mid;
} else {
r = mid - 1;
}
}
return res;
}
__int128_t solve4(__int128_t n, __int128_t m) {
__int128_t res = 0, p = check(n, m);
if (p == 0) {
return 0;
}
__int128_t pn = n / 4, pm = m / 3;
pn = std::min(pn, p);
pm = std::min(pm, p);
if (pn > pm) {
res += pm * (pm + 1) * (pm * 4 + 5) / 6;
res -= m * (pm + 1) * (pm + 1) - (pm * (pm + 1) * (pm * 4 + 5) / 6 * 2);
res += m * (pn + 1) * (pn + 1) - (pn * (pn + 1) * (pn * 4 + 5) / 6 * 2);
res -=
(m + n) * (pn + 1) * (pn + 1) - (pn * (pn + 1) * (pn * 4 + 5) / 6 * 6);
res += (m + n) * (p + 1) * (p + 1) - (p * (p + 1) * (p * 4 + 5) / 6 * 6);
} else {
res += pn * (pn + 1) * (pn * 4 + 5) / 6;
res -= n * (pn + 1) * (pn + 1) - (pn * (pn + 1) * (pn * 4 + 5) / 6 * 3);
res += n * (pm + 1) * (pm + 1) - (pm * (pm + 1) * (pm * 4 + 5) / 6 * 3);
res -=
(m + n) * (pm + 1) * (pm + 1) - (pm * (pm + 1) * (pm * 4 + 5) / 6 * 6);
res += (m + n) * (p + 1) * (p + 1) - (p * (p + 1) * (p * 4 + 5) / 6 * 6);
}
return res;
}
__int128_t solve5(__int128_t n, __int128_t m) {
n -= 2;
m -= 1;
if (n < 1 || m < 1) {
return 0;
}
__int128_t res = 0, p = check(n, m);
if (p == 0) {
return 0;
}
__int128_t pn = n / 4, pm = m / 3;
pn = std::min(pn, p);
pm = std::min(pm, p);
if (pn > pm) {
res += pm * (pm + 1) * (pm * 4 + 5) / 6;
res += pm * (pm + 1) / 2;
res -= m * (pm + 1) * (pm + 1) - (pm * (pm + 1) * (pm * 4 + 5) / 6 * 2);
res -= pm * m - pm * (pm + 1) / 2 * 2;
res += m * (pn + 1) * (pn + 1) - (pn * (pn + 1) * (pn * 4 + 5) / 6 * 2);
res += pn * m - pn * (pn + 1) / 2 * 2;
res -=
(m + n) * (pn + 1) * (pn + 1) - (pn * (pn + 1) * (pn * 4 + 5) / 6 * 6);
res -= pn * (n + m) - pn * (pn + 1) / 2 * 6;
res += (m + n) * (p + 1) * (p + 1) - (p * (p + 1) * (p * 4 + 5) / 6 * 6);
res += p * (n + m) - p * (p + 1) / 2 * 6;
} else {
res += pn * (pn + 1) * (pn * 4 + 5) / 6;
res += pn * (pn + 1) / 2;
res -= n * (pn + 1) * (pn + 1) - (pn * (pn + 1) * (pn * 4 + 5) / 6 * 3);
res -= pn * n - pn * (pn + 1) / 2 * 3;
res += n * (pm + 1) * (pm + 1) - (pm * (pm + 1) * (pm * 4 + 5) / 6 * 3);
res += pm * n - pm * (pm + 1) / 2 * 3;
res -=
(m + n) * (pm + 1) * (pm + 1) - (pm * (pm + 1) * (pm * 4 + 5) / 6 * 6);
res -= pm * (n + m) - pm * (pm + 1) / 2 * 6;
res += (m + n) * (p + 1) * (p + 1) - (p * (p + 1) * (p * 4 + 5) / 6 * 6);
res += p * (n + m) - p * (p + 1) / 2 * 6;
}
return res;
}
__int128_t solve(__int128_t n, __int128_t m) {
if (n == 0 || m == 0) {
return 0;
}
__int128_t res = 0;
res += solve1(n, m) + solve1(m, n);
res += solve2(n, m) + solve2(m, n);
res += solve3(n, m);
res += solve4(n, m) + solve4(m, n);
res += solve4(n - 1, m - 1) + solve4(m - 1, n - 1);
res += solve4(n - 2, m - 2) + solve4(m - 2, n - 2);
res += solve5(n, m) + solve5(m, n);
res += solve5(n - 1, m - 1) + solve5(m - 1, n - 1);
res += solve5(n - 2, m - 2) + solve5(m - 2, n - 2);
if (1 <= n && 2 <= m) {
res += 2;
}
if (2 <= n && 1 <= m) {
res += 2;
}
if (2 <= n && 2 <= m) {
res += 2;
}
if (3 <= n && 3 <= m) {
res += 2;
}
if (nn == 4 && n == 4) {
res += 2;
}
if (mm == 4 && m == 4) {
res += 2;
}
return res;
}
int main() {
for (int T = read(); T; T--) {
int r = read(), c = read(), n = read(), m = read();
nn = n;
mm = m;
if (n <= 50 && m <= 50) {
memset(f, 60, sizeof(f));
f[1][1] = 0;
for (int d = 0; d < 100; d++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 0; k < 8; k++) {
int x = i + dx[k], y = j + dy[k];
if (1 <= x && 1 <= y && x <= n && y <= m) {
f[i][j] = std::min(f[i][j], f[x][y] + 1);
}
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (f[i][j] > 1e9) {
f[i][j] = 0;
}
f[i][j] += f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1];
}
}
printf("%d\n", f[n][m] + f[r - 1][c - 1] - f[n][c - 1] - f[r - 1][m]);
} else {
printf("%d\n", (int)((solve(n, m) + solve(r - 1, c - 1) -
solve(n, c - 1) - solve(r - 1, m)) %
mod));
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s[1005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
bool flag = 0;
for (int i = 0; i < n; i++) {
if (s[i][0] == 'O' && s[i][1] == 'O') {
flag = 1;
s[i][0] = '+';
s[i][1] = '+';
break;
} else if (s[i][3] == 'O' && s[i][4] == 'O') {
flag = 1;
s[i][3] = '+';
s[i][4] = '+';
break;
}
}
if (flag == 1) {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << s[i] << "\n";
} else {
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long n, h, k, s;
scanf("%I64d", &n);
h = 0;
if ((n + 1) % 3 == 0) h++;
s = 7;
k = 5;
for (s = 7; s <= n; s = s + k) {
if ((n - s) % 3 == 0) h++;
k = k + 3;
}
printf("%I64d\n", h);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool vstd[150004] = {0};
vector<vector<int> > v;
int cnt = 0;
int DFS(int i) {
if (vstd[i]) return 0;
vstd[i] = true;
cnt++;
for (int j = 0; j < v[i].size(); j++) {
int q = v[i][j];
if (!vstd[q]) DFS(q);
}
return cnt;
}
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
v = vector<vector<int> >(n + 1);
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long ans = 0;
for (int i = 1; i < n + 1; i++) {
{
if (!vstd[i]) {
cnt = 0;
long long c = DFS(i);
c = (c * (c - 1)) / 2;
ans += c;
if (ans > m) break;
}
}
}
if (ans > m)
cout << "NO";
else {
cout << "YES";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
static const double PI = 3.141592653589793238462643383279;
int main() {
int rept;
scanf("%d", &rept);
static int ans[100010];
int n, i;
int a, o;
long long all, cnt;
for (int loopCount = 1; loopCount <= (rept); loopCount++) {
scanf("%d", &n);
all = 0;
vector<pair<pair<int, int>, int> > aoi;
aoi.reserve(2 * n);
for (i = 0; i < (2 * n - 1); i++) {
scanf("%d %d", &a, &o);
aoi.push_back(make_pair(make_pair(a, o), i + 1));
all += o;
}
sort(aoi.begin(), aoi.end(),
less<pair<pair<long long, long long>, int> >());
cnt = 0;
for (i = 0; i < (n); i++) {
cnt += aoi[2 * i].first.second;
}
printf("YES\n");
if (cnt >= ((all + 1) / 2)) {
for (i = 0; i < (n - 1); i++) ans[i] = aoi[2 * i].second;
} else {
for (i = 0; i < (n - 1); i++) ans[i] = aoi[2 * i + 1].second;
}
ans[n - 1] = aoi.rbegin()->second;
sort(ans, ans + n);
for (i = 0; i < (n); i++) {
printf("%d", ans[i]);
if (i == n - 1)
printf("\n");
else
printf(" ");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p[111111], h[111111], d[111111];
vector<vector<int>> g;
int f(int w, int x, int k) {
d[x] = k;
int m = -1;
for(int y : g[x]) {
if(y == w)
continue;
p[y] = x;
m = max(m, f(x, y, k + 1));
}
return h[x] = m + 1;
}
int main() {
int n, u, v;
cin >> n >> u >> v;
g.resize(n + 1);
for(int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
f(0, v, 0);
int l = (d[u] - 1) / 2;
while(l--)
u = p[u];
cout << h[u] + d[u] - 1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long a[100] = {1}, ans[100];
int main() {
int s, k, i = 0, cnt = 0;
scanf("%d%d", &s, &k);
long long d = 1, sum = 0;
while (a[i] < s) {
if (i < k) {
a[++i] = d;
d += a[i];
} else {
a[i + 1] = 2 * a[i] - a[i - k];
++i;
}
}
if (s == a[i]) {
printf("2\n%I64d 0\n", a[i]);
return 0;
}
--i;
while (sum < s) {
if (sum + a[i] <= s) {
sum += a[i];
ans[cnt++] = a[i];
}
--i;
}
printf("%d\n%I64d", cnt, ans[0]);
for (i = 1; i < cnt; ++i) printf(" %I64d", ans[i]);
puts("");
return 0;
}
| 2 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 1000005
char s[maxn],t[maxn];
int n,cnt,ans;
struct Vergil
{
int x,y;
}a[maxn],b[maxn];
bool comp(char *s,char *t)
{
for (int i=1;i<=n;i++)
if (s[i]!=t[i]) return 0;
return 1;
}
bool check(int x)
{
for (int i=1;i<=cnt-x;i++)
if (b[i+x].x-x<b[i].y) return 0;
return 1;
}
int main()
{
scanf("%d",&n);
scanf("%s%s",s+1,t+1);
if (comp(s,t)) {puts("0");return 0;}
for (int i=n,j=n;i>=1;i--)
{
j=min(j,i);
while (j>0&&s[j]!=t[i]) j--;
if (j==0) {puts("-1");return 0;}
a[i]=(Vergil){j,i};
}
b[1]=a[1];cnt=1;
for (int i=2;i<=n;i++)
if (a[i].x==a[i-1].x) b[cnt]=a[i];
else b[++cnt]=a[i];
int L=1,R=cnt;
while (L<=R)
{
int mid=(L+R)>>1;
if (check(mid)) {ans=mid;R=mid-1;}
else L=mid+1;
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1005][1005][2];
bool ban[1005][1005];
void solve() {
int n, m, q;
cin >> n >> m >> q;
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j][0] = dp[i - 1][j][1] + 1;
dp[i][j][1] = dp[i][j - 1][0] + 1;
ans += (dp[i][j][0] + dp[i][j][1]);
}
}
int open = n * m;
while (q--) {
int x, y;
cin >> x >> y;
if (!ban[x][y]) {
long long a = dp[x][y][0];
long long b = dp[x][y][1];
dp[x][y][0] = 0;
dp[x][y][1] = 0;
open--;
ans -= (a + b);
bool last = 1;
int tmp = x, tmp2 = y;
while (x <= n && y <= m && !ban[x][y]) {
if (!last) {
x++;
} else
y++;
if (x <= n && y <= m && !ban[x][y]) {
dp[x][y][last] -= a;
ans -= a;
}
last = !last;
}
x = tmp, y = tmp2;
last = 0;
while (x <= n && y <= m && !ban[x][y]) {
if (!last) {
x++;
} else
y++;
if (x <= n && y <= m && !ban[x][y]) {
dp[x][y][last] -= b;
ans -= b;
}
last = !last;
}
ban[tmp][tmp2] = 1;
} else {
long long a = dp[x - 1][y][1] + 1;
long long b = dp[x][y - 1][0] + 1;
dp[x][y][0] = a;
dp[x][y][1] = b;
open++;
ans += (a + b);
bool last = 1;
int tmp = x, tmp2 = y;
ban[x][y] = 0;
while (x <= n && y <= m && !ban[x][y]) {
if (!last) {
x++;
} else
y++;
if (x <= n && y <= m && !ban[x][y]) {
dp[x][y][last] += a;
ans += a;
}
last = !last;
}
x = tmp, y = tmp2;
last = 0;
while (x <= n && y <= m && !ban[x][y]) {
if (!last) {
x++;
} else
y++;
if (x <= n && y <= m && !ban[x][y]) {
dp[x][y][last] += b;
ans += b;
}
last = !last;
}
}
cout << ans - open << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
int n, k, t, x;
cin >> n >> k >> t;
for (x = 0; x <= n * k; ++x)
if (100 * x > n * k * t) {
x--;
break;
}
for (int i = 0; i < n; ++i) {
cout << " " << min(x, k);
x -= min(x, k);
}
cout << endl;
return EXIT_SUCCESS;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
int a[1001];
bool hasPred[1001] = {};
cin >> n >> x;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] != 0) {
hasPred[a[i]] = true;
}
}
int lengths[1000];
int size = 0;
for (int i = 1; i <= n; ++i) {
if (!hasPred[i] && i != x) {
lengths[size] = 0;
bool metX = false;
for (int j = i; j != 0; j = a[j]) {
++lengths[size];
metX |= j == x;
}
if (!metX) {
++size;
}
}
}
int pos = 0;
for (int i = x; i != 0; i = a[i]) {
++pos;
}
bool possible[1000] = {};
possible[0] = true;
for (int i = 0; i < size; ++i) {
for (int j = n - 1; j > 0; --j) {
if (j >= lengths[i]) {
possible[j] |= possible[j - lengths[i]];
}
}
}
for (int i = 0; i < n; ++i) {
if (possible[i]) {
cout << i + pos << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,a;
cin>>n;
for(int i=0;i<n;i++){
cin>>a;
if(a%2==0&&a%3&&a%5)cout<<"DENIED\n",exit(0);
}
cout<<"APPROVED\n";
}
| 0 |
#include <iostream>
#include <algorithm>
using namespace std;
#define N 100
int main()
{
int n;
cin >> n;
int p[N + 1], m[N + 1][N + 1];
for (int i = 0; i < n; i++) {
cin >> p[i] >> p[i + 1];
}
for (int i = 1; i <= n; i++) {
m[i][i] = 0;
}
for (int l = 2; l <= n; l++) {
for (int i = 1; i <= n - l + 1; i++) {
int j = i + l - 1;
m[i][j] = (1 << 21);
for (int k = i; k < j; k++) {
m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
}
}
}
cout << m[1][n] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int n, W; cin >> n >> W;
vector<long long> dp(1<<17, 1ll<<60);
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
int w, v; cin >> w >> v;
for (int j = (1<<17) - 1; j >= v; --j) {
dp[j] = min(dp[j], dp[j - v] + w);
}
}
for (int i = (1<<17) - 1; i >= 0; --i) if (dp[i] <= W) {
cout << i << '\n';
exit(0);
}
assert(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Team {
int id, univ, ac, pen;
Team(int id, int univ, int ac, int pen) : id(id), univ(univ), ac(ac), pen(pen){}
Team(){}
bool operator < (const Team x) const {
if (ac != x.ac) return (ac < x.ac);
if (pen != x.pen) return (pen > x.pen);
return (id > x.id);
}
};
int main()
{
int n;
while (scanf("%d", &n) && n){
Team teams[512];
for (int i = 0; i < n; i++){
scanf("%d %d %d %d", &teams[i].id, &teams[i].univ, &teams[i].ac, &teams[i].pen);
}
sort(teams, teams + n);
reverse(teams, teams + n);
int sel = 0;
int uCount[1024];
memset(uCount, 0, sizeof(uCount));
for (int i = 0; i < n; i++){
if (sel < 10 && uCount[teams[i].univ] < 3){
printf("%d\n", teams[i].id); uCount[teams[i].univ]++; sel++;
}
else if (sel < 20 && uCount[teams[i].univ] < 2){
printf("%d\n", teams[i].id); uCount[teams[i].univ]++; sel++;
}
else if (sel < 26 && uCount[teams[i].univ] < 1){
printf("%d\n", teams[i].id); uCount[teams[i].univ]++; sel++;
}
}
}
return (0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int lft[26];
char s[111111], t[111111];
int n, m;
int main() {
gets(s);
n = (int)strlen(s);
for (int i = 0; i < n; ++i) lft[s[i] - 'a']++;
gets(t);
m = (int)strlen(t);
for (int i = 0; i < n; ++i) {
bool fnd = 0;
for (int let = 0; let < 26; ++let) {
if (!lft[let]) continue;
s[i] = 'a' + let;
lft[let]--;
int pos = i + 1;
for (int j = 25; j >= 0; --j) {
for (int k = 0; k < lft[j]; ++k) s[pos++] = 'a' + j;
}
s[n] = 0;
if (strcmp(s, t) == 1) {
fnd = 1;
break;
}
lft[let]++;
}
if (!fnd) {
cout << "-1\n";
return 0;
}
}
puts(s);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, p;
cin >> a >> b >> c;
p = sqrt(a * b * c);
a = p / a;
b = p / b;
c = p / c;
cout << (4 * (a + b + c));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long getF(int numb) {
long long ans = 1;
for (int i = 2; i <= numb; i++) ans *= i;
return ans;
}
int main() {
string str;
cin >> str;
int cnt = 0;
set<char> st;
int pow10 = 0;
for (int i = 0; i < str.size(); i++) {
if (str[i] >= 'A' && str[i] <= 'J') st.insert(str[i]);
if (str[i] == '?') pow10++;
}
cnt = st.size();
long long ans = 1;
ans *= (getF(10) / getF(10 - cnt));
if (str[0] >= 'A' && str[0] <= 'J') ans -= ((getF(9) / getF(9 - cnt + 1)));
if (pow10) {
ans *= (str[0] == '?' ? 9 : 10);
pow10--;
}
cout << ans;
for (int i = 0; i < pow10; i++) cout << 0;
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> f[1000007];
int nivel[1000007];
void go(int curr, int l) {
nivel[l]++;
for (int i = 0; i < f[curr].size(); i++) {
go(f[curr][i], l + 1);
}
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x;
cin >> x;
x--;
f[x].push_back(i);
}
go(0, 0);
int ans = 0;
for (int i = 0; i < n; i++) {
ans += (nivel[i] % 2);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve(map<int, int>& m, int n) {
int mx = n / 2;
int cnt = 0, g = 0, s = 0, b = 0;
if (n < 6 || m.size() < 3)
cout << s << " " << b << " " << g << endl;
else {
auto itr = m.begin();
g = itr->second;
itr++;
s = itr->second;
itr++;
while (g + s + itr->second <= mx && itr != m.end()) {
s += itr->second;
itr++;
}
itr--;
s = s - itr->second;
b = itr->second;
while (g >= b && itr != m.begin()) {
itr--;
b += itr->second;
s -= itr->second;
}
if (g < b && g < s)
cout << g << " " << s << " " << b << endl;
else
cout << "0 0 0" << endl;
}
}
int main() {
int t;
cin >> t;
while (t--) {
int i, k, n;
cin >> n;
map<int, int> m;
for (i = 0; i < n; i++) {
cin >> k;
m[-k]++;
}
solve(m, n);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 1e9;
const long long INF = 1e18;
const double PI = acos(-1.0);
const double EPS = 1e-8;
const int MOD = 1000000007;
struct Point {
int x, y;
Point() {}
Point(int x, int y) : x(x), y(y) {}
};
struct Line {
int a, b, c;
Line() {}
Line(int a, int b, int c) : a(a), b(b), c(c) {}
int Orientation(Point p) {
long long int val = 1LL * a * p.x + 1LL * b * p.y + c;
if (val == 0) return 0;
if (val > 0)
return 1;
else
return -1;
}
} L;
vector<Line> V;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
Point a, b;
cin >> a.x >> a.y >> b.x >> b.y;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int a, b, c;
cin >> a >> b >> c;
V.push_back(Line(a, b, c));
}
int ans = 0;
for (auto x : V) {
int X = x.Orientation(a);
int Y = x.Orientation(b);
if (X != Y) ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
char s[100008];
long long int i, a[1000], b[100];
long long int sum;
int main() {
cin >> s;
n = strlen(s);
for (i = 0; i < n; i++)
if (s[i] >= 'a' && s[i] <= 'z') a[s[i] - 'a']++;
for (i = 0; i < n; i++)
if (s[i] >= '0' && s[i] <= '9') b[s[i] - '0']++;
for (i = 0; i < 26; i++)
if (a[i] > 0) sum += a[i] * a[i];
for (i = 0; i < 26; i++)
if (b[i] > 0) sum += b[i] * b[i];
cout << sum << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(void){
int a,b,g=100,h=0,j = 0;
for(int i = 0; i < 4; i++){
cin >>a;
g = min(g,a);
j = j + a;
}
j = j - g;
for(int i = 0; i < 2; i++){
cin >>b;
h = max(h,b);
}
cout<<j + h<<endl;
}
| 0 |
Subsets and Splits