solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2) {
cout << 9 + n << " " << 9 << endl;
} else {
cout << 8 + n << " " << 8 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long d[111111];
long long sum[111111];
int q[111111];
long long cat[111111];
long long dp[101][100001];
long long getDP(int i, int j, int k) {
return (long long)j * cat[j] + dp[i - 1][k] - j * cat[k];
}
long long getUP(int i, int j, int k) {
return (long long)dp[i - 1][j] - dp[i - 1][k];
}
long long getDOWN(int j, int k) { return (long long)cat[j] - cat[k]; }
int main() {
int i, j, k, n, m, p, h;
cin >> n >> m >> p;
for (i = 2; i <= n; i++) {
cin >> d[i];
d[i] += d[i - 1];
}
for (i = 1; i <= m; i++) {
cin >> h >> cat[i];
cat[i] -= d[h];
}
sort(cat + 1, cat + 1 + m);
for (i = 1; i <= m; i++) sum[i] = sum[i - 1] + cat[i];
for (i = 1; i <= p; i++)
for (j = 1; j <= m; j++) dp[i][j] = 999999999999999;
dp[1][m] = (long long)m * cat[m] - sum[m];
for (i = 2; i <= p; i++) {
int head, tail;
head = tail = 0;
q[tail++] = m;
for (j = m; j >= 1; j--) {
while (head + 1 < tail && (getUP(i, q[head + 1], q[head]) <=
j * getDOWN(q[head + 1], q[head])))
head++;
dp[i][j] = min(dp[i][j], getDP(i, j, q[head]));
while (head + 1 < tail &&
getUP(i, j, q[tail - 1]) * getDOWN(q[tail - 1], q[tail - 2]) >
getUP(i, q[tail - 1], q[tail - 2]) * getDOWN(j, q[tail - 1]))
tail--;
q[tail++] = j;
}
}
long long ans = dp[p][1];
for (i = 1; i <= m; i++) ans = min(ans, dp[p][i]);
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MOD2 = 1e9 + 9;
const long long MOD3 = 1e9 + 21;
const long long INF = 5e18;
const long double pi = acos(-1.0);
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long exp(long long a, long long b, long long M) {
long long result = 1;
while (b > 0) {
if (b & 1) result = mod(result * a, M);
b >>= 1;
a = mod(a * a, M);
}
return result;
}
void solve() {
long long n, m;
cin >> n >> m;
char adj[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> adj[i][j];
}
}
long long ans = 1;
for (long long i = 0; i < m; i++) {
set<char> s;
for (long long j = 0; j < n; j++) {
s.insert(adj[j][i]);
}
ans *= s.size();
ans = mod(ans, MOD);
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
const int INF = 2000000005;
const long long BIG_INF = 2000000000000000005;
const int mod = 1000000007;
const int P = 31;
using namespace std;
vector<pair<int, int> > dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
bool valid(int x, int y, int n, int m) {
return x >= 0 && y >= 0 && x < n && y < m;
}
mt19937 rng(1999999973);
signed main() {
int t;
cin >> t;
while (t--) {
int ans = 0, n;
cin >> n;
for (int i = 0; i <= 8; i++) {
vector<int> a, b;
for (int j = 1; j <= n; j++) {
if ((j >> i) & 1)
a.push_back(j);
else
b.push_back(j);
}
if (a.size() == 0 || b.size() == 0) continue;
cout << a.size() << " " << b.size() << " ";
for (int i = 0; i < a.size(); i++) cout << a[i] << " ";
for (int i = 0; i < b.size(); i++) cout << b[i] << " ";
cout << '\n';
int c;
cin >> c;
ans = max(ans, c);
}
cout << "-1 " << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int counter = 0, n;
long long x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
if (x % i == 0 && x / i <= n) counter++;
}
cout << counter << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10, MOD = 1e9 + 7;
int n, m, ans, sp[20][20], dist[20][20], dp[1 << 15];
vector<vector<int> > g(20);
vector<pair<pair<int, int>, int> > edges;
bool vis[20], cyc[20][20], men[20];
void DFS(int u) {
vis[u] = true;
int sz = g[u].size();
for (int i = 0; i < sz; i++)
if (!vis[g[u][i]]) DFS(g[u][i]);
}
int calc(int mask) {
if (dp[mask] != -1) return dp[mask];
int ans = 1e9;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if ((g[i].size() & 1) && (g[j].size() & 1)) {
if ((mask & (1 << i)) || (mask & (1 << j)))
continue;
else
ans = min(ans, sp[i][j] + calc((mask | (1 << i)) | (1 << j)));
}
if (ans == 1e9) return 0;
return dp[mask] = ans;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d%d", &n, &m);
if (m == 0) return printf("0"), 0;
for (int i = 0; i < 20; i++)
for (int j = 0; j < 20; j++) sp[i][j] = 1e9;
for (int i = 0; i < 20; i++) sp[i][i] = 0;
while (m--) {
int l, r, c;
scanf("%d%d%d", &l, &r, &c);
l--, r--;
ans += c;
men[l] = men[r] = 1;
g[l].push_back(r);
g[r].push_back(l);
sp[l][r] = min(sp[l][r], c);
sp[r][l] = min(sp[r][l], c);
}
DFS(0);
for (int i = 0; i < n; i++)
if (!vis[i] && men[i]) return printf("-1"), 0;
for (int m = 0; m < n; m++)
for (int j = 0; j < n; j++)
for (int i = 0; i < n; i++) sp[j][i] = min(sp[j][i], sp[j][m] + sp[m][i]);
cout << ans + calc(0);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 0x3f3f3f3f, N = 2e5 + 5;
inline int read() {
int sum = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum * f;
}
int head[N], cnt, n, m, pre[N], nxt[N];
bool in[N], vis[N];
vector<int> scc[N];
struct node {
int to, next;
} e[N << 1];
inline void add(int u, int v) {
e[++cnt].next = head[u];
e[cnt].to = v;
head[u] = cnt;
}
inline void del(int x) {
nxt[pre[x]] = nxt[x];
pre[nxt[x]] = pre[x];
}
int bfs() {
queue<int> q;
int tot = 0;
while (nxt[0]) {
int now = nxt[0];
del(now);
q.push(now);
++tot;
in[now] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
vis[v] = 1;
}
for (int i = nxt[0]; i; i = nxt[i]) {
if (!in[i] && !vis[i]) {
q.push(i);
in[i] = 1;
del(i);
scc[tot].push_back(i);
}
}
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
vis[v] = 0;
}
}
}
return tot;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
for (int i = 1; i <= n + 1; i++) pre[i] = i - 1;
for (int i = 0; i < n; i++) nxt[i] = i + 1;
nxt[n] = 0;
int ans = bfs();
printf("%d\n", ans - 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int sx, sy, tx, ty, n;
int xx[] = {1, 0, 0, -1}, yy[] = {0, 1, -1, 0};
char c[] = {'R', 'U', 'D', 'L'};
struct data {
int x, y;
} a[405], P[4], L, R, U, D, q[100005];
int dir[100005], from[100005];
vector<int> p;
bool vis[305][305], mp[305][305];
bool bfs() {
int head = 0, tail = 1;
q[0] = (data){sx, sy};
vis[sx][sy] = 1;
while (head != tail) {
int x = q[head].x, y = q[head].y;
for (int k = 0; k < 4; k++) {
int nx = x + xx[k], ny = y + yy[k];
if ((0 <= nx && nx <= 300 && 0 <= ny && ny <= 300) && !vis[nx][ny]) {
q[tail] = (data){nx, ny};
vis[nx][ny] = 1;
dir[tail] = k;
from[tail] = head;
if (nx == tx && ny == ty) {
p.clear();
for (; tail; tail = from[tail]) p.push_back(dir[tail]);
reverse(p.begin(), p.end());
return 1;
}
tail++;
}
}
head++;
}
return 0;
}
bool move(int k) {
sx += xx[k];
sy += yy[k];
tx += xx[k];
ty += yy[k];
putchar(c[k]);
if ((0 <= tx && tx <= 300 && 0 <= ty && ty <= 300) && mp[tx][ty]) {
tx -= xx[k];
ty -= yy[k];
return 0;
}
return 1;
}
void pre() {
while ((0 <= sx && sx <= 300) || (0 <= tx && tx <= 300)) move(0);
while ((0 <= sy && sy <= 300) || (0 <= ty && ty <= 300)) move(1);
}
void ud(int d) {
pre();
while ((d == 2 && 0 <= ty) || (d == 1 && ty <= 300)) move(d);
while (tx != P[d].x) move(tx < P[d].x ? 0 : 3);
while (sy != ty) move(3 - d);
}
void lr(int d) {
pre();
while ((d == 3 && 0 <= tx) || (d == 0 && tx <= 300)) move(d);
while (ty != P[d].y) move(ty < P[d].y ? 1 : 2);
while (sx != tx) move(3 - d);
}
void solve() {
if (!n || !bfs()) {
puts("-1");
return;
}
for (int i = 0; i < p.size(); i++) {
if (move(p[i])) p.push_back(p[i]);
if (sx == tx && sy == ty) return;
if (!(0 <= sx && sx <= 300 && 0 <= sy && sy <= 300)) break;
}
if (sy < ty) ud(2);
if (sy > ty) ud(1);
if (sx < tx) lr(3);
if (sx > tx) lr(0);
}
int main() {
sx = read();
sy = read();
tx = read();
ty = read();
n = read();
sx += 150;
sy += 150;
tx += 150;
ty += 150;
int x, y;
L.x = D.y = 100000000;
R.x = U.y = -100000000;
for (int i = 1; i <= n; i++) {
x = read() + 150;
y = read() + 150;
if (x < L.x) L = (data){x, y};
if (x > R.x) R = (data){x, y};
if (y < D.y) D = (data){x, y};
if (y > U.y) U = (data){x, y};
mp[x][y] = vis[x][y] = 1;
}
P[0] = R;
P[1] = U;
P[2] = D;
P[3] = L;
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
const int K = 51;
const int INF = 1e9 + 7;
int a[N], b[N];
int aa[N], bb[N];
int n, p, k, r, s;
short dp[N][N][K][2];
int oo[N][N];
short calc(int idx, int canp, int cnt1, int cnt2) {
int who = (cnt1 > 0 ? 0 : 1);
auto &res = dp[idx][canp][cnt1 + cnt2][who];
if (res != -1) return res;
if (idx >= n) return res = 0;
assert(cnt1 == 0 || cnt2 == 0);
res = (cnt1 > 0 ? a[idx] : 0) + (cnt2 > 0 ? b[idx] : 0) +
calc(idx + 1, canp, cnt1 > 0 ? cnt1 - 1 : 0, cnt2 > 0 ? cnt2 - 1 : 0);
if (canp >= 1) {
if (cnt1 > 0) {
assert(cnt2 == 0);
int nr = min(n, idx + cnt1);
int ncost2 = oo[idx][nr - 1];
int ncnt22 = k - (nr - idx);
res = max(res, (short)(ncost2 + calc(nr, canp - 1, 0, ncnt22)));
}
if (cnt2 > 0) {
int nr = min(n, idx + cnt2);
int ncost1 = oo[idx][nr - 1];
int ncnt11 = k - (nr - idx);
res = max(res, (short)(ncost1 + calc(nr, canp - 1, ncnt11, 0)));
}
if (cnt1 == 0 && cnt2 == 0) {
res = max(res, (short)(a[idx] + calc(idx + 1, canp - 1, k - 1, 0)));
res = max(res, (short)(b[idx] + calc(idx + 1, canp - 1, 0, k - 1)));
}
}
if (canp >= 2) {
int nidx = min(n, idx + k);
res = max(res, (short)(oo[idx][nidx - 1] + calc(nidx, canp - 2, 0, 0)));
}
return res;
}
int main() {
cin >> n >> p >> k;
cin >> r;
for (int i = 0; i < r; i++) {
int x;
cin >> x;
x--;
a[x]++;
}
cin >> s;
for (int i = 0; i < s; i++) {
int x;
cin >> x;
x--;
b[x]++;
}
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
oo[i][j] = a[j] | b[j];
if (j > i) oo[i][j] += oo[i][j - 1];
}
}
memset(dp, -1, sizeof dp);
int ans = calc(0, p, 0, 0);
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
char s[maxn];
int solve(int l, int r, char m) {
if (l == r) {
if (s[l] == m)
return 0;
else
return 1;
}
int mid = (l + r) >> 1, left = 0, right = 0, len = r - l + 1;
for (int i = l; i <= mid; i++)
if (s[i] == m) left++;
for (int i = mid + 1; i <= r; i++)
if (s[i] == m) right++;
int ans = min(len / 2 - left + solve(mid + 1, r, m + 1),
len / 2 - right + solve(l, mid, m + 1));
return ans;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
int ans = solve(1, n, 'a');
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 1, s1 = 0, cnt;
cin >> n;
int a[1010], b[1010];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (b[i] != 0) {
s += b[i] - 1;
s1 += a[i];
a[i] = 0;
++cnt;
}
}
sort(a, a + n);
reverse(a, a + n);
for (int i = 0; i < s && i < n - cnt; i++) s1 += a[i];
cout << s1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vii = vector<ii>;
using vvii = vector<vii>;
const int INF = 2000000000;
const ll LLINF = 9000000000000000000;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
ll S, X;
cin >> S >> X;
S -= X;
if ((S & 1) || S < 0) {
cout << 0 << endl;
return 0;
}
cerr << S << ' ' << X << endl;
S /= 2LL;
int exp = __builtin_popcountll(X & ~S);
ll ans = 1LL << exp;
if (S == 0) ans -= 2LL;
if (ans < 0LL || ((X & S) != 0LL)) ans *= 0LL;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <class T>
inline T gcd(T a, T b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
template <class T>
inline T pow(T a, T b, T c) {
T re = 1;
while (b) {
if (b & 1) re = (re * a) % c;
a = (a * a) % c;
b >>= 1;
}
return re;
}
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
using namespace std;
int main() {
double l, p, q, x, t, x1;
cin >> l >> p >> q;
x = p + q;
t = l / x;
x1 = p * t;
printf("%.4lf\n", x1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
std::mt19937 rnd(
std::chrono::high_resolution_clock::now().time_since_epoch().count());
const double PI = atan2(0.0, -1.0);
const int INF = 0x3f3f3f3f;
const ll LINF = (ll)2e18;
const int N = 1100;
const int C = 32;
std::unordered_map<std::bitset<N>, int> q;
std::bitset<N> a[C];
int ans;
void precalc(int it, int depth, const std::bitset<N>& cur, int cnt) {
if (it == depth) {
auto iter = q.find(cur);
if (iter == q.end()) {
q[cur] = cnt;
} else if (iter->second > cnt) {
q[cur] = cnt;
}
return;
}
precalc(it + 1, depth, cur, cnt);
precalc(it + 1, depth, cur ^ a[it], cnt + 1);
}
void solve(int it, int depth, const std::bitset<N>& cur, int cnt) {
if (it == depth) {
auto iter = q.find(cur);
if (iter != q.end()) {
ans = std::min(ans, iter->second + cnt);
}
return;
}
solve(it + 1, depth, cur, cnt);
solve(it + 1, depth, cur ^ a[it], cnt + 1);
}
void run() {
int n, s, d;
scanf("%d%d%d", &n, &s, &d);
for (int i = 0; i < s; ++i) {
int sz;
scanf("%d", &sz);
while (sz--) {
int cur;
scanf("%d", &cur);
a[i][cur - 1] = true;
}
}
precalc(0, s - s / 3, std::bitset<N>(), 0);
while (d--) {
int sz;
scanf("%d", &sz);
std::bitset<N> need;
while (sz--) {
int cur;
scanf("%d", &cur);
need[cur - 1] = true;
}
ans = INF;
solve(s - s / 3, s, need, 0);
if (ans == INF) {
printf("-1\n");
} else {
printf("%d\n", ans);
}
}
}
int main(void) {
auto start = std::chrono::high_resolution_clock::now();
run();
auto end = std::chrono::high_resolution_clock::now();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m;
int pre[N], sz[N];
int find_set(int x) {
if (x == pre[x]) return x;
return pre[x] = find_set(pre[x]);
}
struct node {
int u, v, w;
} p[N];
pair<int, int> q[N];
bool cmp(node a, node b) { return a.w < b.w; }
long long ans[N];
int main() {
cin >> n >> m;
for (int i = (1); i < (n); i++) {
cin >> p[i].u >> p[i].v >> p[i].w;
}
for (int i = (1); i < (m + 1); i++) {
cin >> q[i].first;
q[i].second = i;
}
for (int i = (1); i < (n + 1); i++) pre[i] = i, sz[i] = 1;
sort(q + 1, q + m + 1);
sort(p + 1, p + n, cmp);
long long cnt = 0, cur = 1;
for (int i = 1; i <= m; ++i) {
while (cur < n && p[cur].w <= q[i].first) {
int fx = find_set(p[cur].u);
int fy = find_set(p[cur].v);
cnt += (long long)sz[fx] * sz[fy];
pre[fx] = fy;
sz[fy] += sz[fx];
cur++;
}
ans[q[i].second] = cnt;
}
for (int i = 1; i <= m; ++i) cout << ans[i] << " ";
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define IOS ios_base::sync_with_stdio(false); cin.tie(NULL);
int main()
{
IOS;
int tt;
cin>>tt;
while(tt--)
{
ll red,blue,diff;
cin>>red>>blue>>diff;
if(red>blue)
{
ll prob=(diff+1)*blue;
if(prob>=red)
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
}
}
else if(red<blue)
{
ll prob=(diff+1)*red;
if(prob>=blue)
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
}
}
else
{
cout<<"YES"<<endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
const int N = 1e6 + 10;
vector<vector<int>> G;
int n, m, cat[N], instack[N], stk[N], top, low[N], ti;
int tarjan(int x) {
int now = ++ti;
low[x] = now;
instack[x] = 1;
stk[top++] = x;
for (auto i : G[x]) {
if (!instack[i]) {
int ret = tarjan(i);
if (ret) return ret;
}
low[x] = min(low[x], low[i]);
}
if (low[x] == now) {
cat[x] = x;
while (stk[--top] != x) cat[stk[top]] = x;
return x;
} else
return 0;
}
void solve() {
int x = tarjan(1);
int sz = ti - low[x] + 1;
if (sz == n)
printf("No\n");
else {
printf("Yes\n%d %d\n", n - sz, sz);
for (int i = 1; i <= n; ++i)
if (cat[i] != x) printf("%d ", i);
printf("\n");
for (int i = 1; i <= n; ++i)
if (cat[i] == x) printf("%d ", i);
printf("\n");
}
}
void clear() {
G.clear();
G.resize(n + 1);
ti = top = 0;
memset(instack, 0, sizeof(int) * (n + 1));
memset(cat, 0, sizeof(int) * (n + 1));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
G.reserve(N);
int T;
cin >> T;
while (T--) {
cin >> n >> m;
clear();
for (int i = 0, a, b; i < m; ++i) {
cin >> a >> b;
if (a != b) G[b].push_back(a);
}
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a;
cin >> n >> m;
if (n <= m) {
cout << m + n - 1 << '\n';
for (int i = 1; i <= m; i++) cout << "1 " << i << '\n';
for (int i = 2; i <= n; i++) cout << i << " 1\n";
} else {
vector<pair<int, int> > v;
cout << n + m - 1 << '\n';
for (int i = 1; i <= n; i++) v.push_back({i, 1});
for (int i = 2; i <= m; i++) v.push_back({1, i});
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[200005];
int dist[200005];
int main() {
int n, m, i, j;
cin >> n >> m;
for (i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (i = 1; i <= n; i++) {
for (j = 0; j < graph[i].size(); j++) {
int v = graph[i][j];
if (v > i) {
if (dist[i] + 1 > dist[v]) {
dist[v] = dist[i] + 1;
}
}
}
}
long long maxm = 0;
for (i = 1; i <= n; i++) {
long long sz = graph[i].size();
long long d = dist[i] + 1;
if ((sz * d) > maxm) maxm = sz * d;
}
cout << maxm;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ara;
int main() {
long long n;
scanf("%lld", &n);
for (long long i = 0; i < n; i++) {
long long a;
scanf("%lld", &a);
ara.push_back(a);
}
sort(ara.begin(), ara.end());
long long ans = 1000000000000000010;
long long cur = 1;
while (powl(cur, n - 1) < 1e12) {
long long sum = 0;
for (long long i = 0; i < n; i++) {
sum += abs(ara[i] - powl(cur, i));
}
ans = min(ans, sum);
cur++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> res;
set<string> ss;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
string d;
cin >> d;
int z = d.size();
string s1 = "";
for (int j = 0; j < z; j++) {
if (d[j] == 'u') {
s1.push_back('o');
s1.push_back('o');
continue;
}
s1.push_back(d[j]);
}
d = s1;
z = d.size();
int kk = 1;
string s = "";
for (int j = 0; j < z; j++) {
if (d[j] != 'k') {
s.push_back(d[j]);
continue;
}
int k = 0;
string o = "";
while (j < z && d[j] == 'k') {
o.push_back(d[j]);
j++;
k++;
}
if (d[j] != 'h') {
j--;
for (int l = 0; l < k; l++) {
s.push_back(o[l]);
}
continue;
} else if (d[j] == 'h') {
j--;
continue;
}
}
res.push_back(s);
}
for (int i = 0; i < n; i++) {
ss.insert(res[i]);
}
cout << ss.size() << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2 * 100 + 10], pos[2 * 100 + 10];
int sum[100 + 10];
int vis[100 + 10];
int main() {
cin >> n;
for (int i = 1; i <= 2 * n; ++i) {
scanf("%d", a + i);
sum[a[i]]++;
}
int v = 0;
int cnt[2] = {0, 0};
for (int i = 10; i <= 99; ++i) {
if (sum[i] == 1) {
cnt[v]++;
v ^= 1;
} else if (sum[i] > 1) {
cnt[1]++;
cnt[0]++;
}
}
int ans = cnt[0] * cnt[1];
v = 0;
for (int i = 1; i <= 2 * n; ++i) {
if (sum[a[i]] == 1) {
pos[i] = v + 1;
v ^= 1;
} else if (sum[a[i]] > 1) {
vis[a[i]]++;
if (vis[a[i]] <= 2) {
if (vis[a[i]] == 1)
pos[i] = 1;
else
pos[i] = 2;
}
}
}
for (int i = 1; i <= 2 * n; ++i)
if (!pos[i]) {
pos[i] = v + 1;
v ^= 1;
}
printf("%d\n", ans);
cout << pos[1];
for (int i = 2; i <= 2 * n; ++i) printf(" %d", pos[i]);
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
uint64_t gcd(uint64_t a, uint64_t b) {
if (b == 0) return a;
return gcd(b, a % b);
}
uint64_t lcm(uint64_t a, uint64_t b) { return (a * b) / gcd(a, b); }
uint64_t modpow(uint64_t x, uint64_t n, uint64_t m) {
if (n == 0) return 1 % m;
uint64_t u = modpow(x, n / 2, m);
u = (u * u) % m;
if (n % 2 == 1) u = (u * x) % m;
return u;
}
int main(int argc, char *argv[]) {
int64_t q;
cin >> q;
for (uint64_t i = 0; i < q; ++i) {
int64_t n, m, st;
cin >> n >> m >> st;
int64_t diag = min(n, m);
int64_t straight = max(n, m) - diag;
int64_t minst = diag + straight;
if (st >= minst) {
int64_t ret;
ret = diag;
st -= diag;
int64_t mst = st % 2;
int64_t mstr = straight % 2;
if (!mstr && !mst) {
ret += st;
} else if (!mstr && mst) {
ret += (st - 2);
} else if (mstr) {
ret += (st - 1);
}
cout << ret << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int pre[100010];
int last[100010];
bool ini[100010];
int n = 1;
struct node {
node *lc, *rc;
int cnt;
};
node* init(int l, int r) {
node* p = new node;
if (l == r) {
return new (node){NULL, NULL, ini[l]};
} else {
int mid = (l + r) >> 1;
node* p = new (node){init(l, mid), init(mid + 1, r), 0};
p->cnt = p->lc->cnt + p->rc->cnt;
return p;
}
}
node* add(node* u, int l, int r, int v) {
if (l == r) {
return new (node){NULL, NULL, 1};
} else {
int mid = (l + r) >> 1;
node* p = new (node);
if (v <= mid)
p->lc = add(u->lc, l, mid, v), p->rc = u->rc;
else
p->lc = u->lc, p->rc = add(u->rc, mid + 1, r, v);
p->cnt = p->lc->cnt + p->rc->cnt;
return p;
}
}
int query(node* u, int l, int r, int k) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (u->lc->cnt >= k)
return query(u->lc, l, mid, k);
else
return query(u->rc, mid + 1, r, k - u->lc->cnt);
}
node* root[100010];
vector<int> g[100010];
int main() {
int sz;
scanf("%d", &sz);
for (int i = 0; i < (sz); ++i) {
scanf("%d", &a[n]);
if (n == 1 || a[n] != a[n - 1]) {
n++;
}
}
--n;
for (int i = 1; i <= n; ++i) {
pre[i] = last[a[i]];
if (pre[i] == 0) {
ini[i] = true;
} else {
g[pre[i]].push_back(i);
}
last[a[i]] = i;
}
root[0] = init(1, n + 1);
for (int i = 1; i < n; ++i) {
node* p = root[i - 1];
for (auto v : g[i]) p = add(p, 1, n + 1, v);
root[i] = p;
}
printf("%d", n);
for (int gap = 2; gap <= n; ++gap) {
int cur = 0, ans = 0;
while (cur < n) {
cur = query(root[cur], 1, n + 1, cur + gap + 1) - 1;
ans += 1;
}
printf(" %d", ans);
}
for (int i = n + 1; i <= sz; ++i) {
printf(" 1");
}
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string vow = "aeiou";
long long month[] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const long long dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const long long dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const long long dx4[] = {-1, 0, 1, 0};
const long long dy4[] = {0, 1, 0, -1};
const long long dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
const long long dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
const long double pie = 3.1415926535897932384626;
const long long special_prime = 982451653l;
const long long mod = 1e9 + 7;
void __print(long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <class T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &i : a) cin >> i;
return in;
}
template <class T>
ostream &operator<<(ostream &out, const vector<T> &a) {
for (auto &i : a) cout << i << " ";
return out;
}
template <class T, class U>
ostream &operator<<(ostream &out, const map<T, U> &a) {
for (auto &i : a) cout << "(" << i.first << ", " << i.second << ")\n";
return out;
}
template <class T, class U>
ostream &operator<<(ostream &out, const unordered_map<T, U> &a) {
for (auto &i : a) cout << "(" << i.first << ", " << i.second << ")\n";
return out;
}
bool comp(long long a, long long b) { return a > b; }
void a_b_c() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
cin >> a;
vector<long long> m(n);
long long mini = INT_MAX;
for (long long i = n - 1; i >= 0; i--) {
mini = min(a[i], mini);
m[i] = mini;
}
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if ((i + 1) < n) {
if (a[i] > m[i]) cnt++;
}
}
cout << cnt << "\n";
}
int32_t main() {
a_b_c();
long long t = 1;
cin >> t;
for (long long i = 1; i <= t; i++) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 100;
struct person {
int res, age, num, start, end, gs;
vector<pair<int, int> > v;
} p[maxn];
struct qq {
int F, S, num;
} w[maxn];
int t[maxn], mmax[maxn * 3], sum[maxn * 3], g[maxn], nb[maxn];
int n, q, k, c;
bool cmd1(person i, person j) { return (i.age < j.age); }
bool cmd2(person i, person j) { return (i.res < j.res); }
bool cmd3(qq i, qq j) {
return (max(p[i.F].res, p[i.S].res) > max(p[j.F].res, p[j.S].res));
}
void update1(int x, int l, int r, int xx) {
if (xx > r || xx < l) return;
if (xx == l && xx == r) {
sum[x]++;
return;
}
int mid = (l + r) / 2;
sum[x]++;
update1(2 * x, l, mid, xx);
update1(2 * x + 1, mid + 1, r, xx);
}
int query1(int x, int l, int r, int xx, int yy) {
if (xx > r || yy < l)
return 0;
else if (l >= xx && r <= yy)
return sum[x];
int mid = (l + r) / 2;
return query1(2 * x, l, mid, xx, yy) + query1(2 * x + 1, mid + 1, r, xx, yy);
}
void update2(int x, int l, int r, int xx, int yy) {
if (xx > r || xx < l) return;
if (xx == l && xx == r) {
mmax[x] = max(mmax[x], yy);
return;
}
int mid = (l + r) / 2;
mmax[x] = max(mmax[x], yy);
update2(2 * x, l, mid, xx, yy);
update2(2 * x + 1, mid + 1, r, xx, yy);
}
int query2(int x, int l, int r, int xx, int yy) {
if (xx > r || yy < l)
return 0;
else if (l >= xx && r <= yy)
return mmax[x];
int mid = (l + r) / 2;
return max(query2(2 * x, l, mid, xx, yy),
query2(2 * x + 1, mid + 1, r, xx, yy));
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> p[i].res;
for (int i = 0; i < n; i++) cin >> p[i].age;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> w[i].F >> w[i].S;
w[i].num = i;
w[i].F--;
w[i].S--;
p[w[i].F].v.push_back(make_pair(i, 0));
p[w[i].S].v.push_back(make_pair(i, 1));
}
sort(p, p + n, cmd1);
for (int i = 0; i < n; i++) {
t[i] = p[i].age;
p[i].num = i;
for (int j = 0; j < p[i].v.size(); j++) {
if (p[i].v[j].second == 0)
w[p[i].v[j].first].F = i;
else
w[p[i].v[j].first].S = i;
}
}
for (int i = 0; i < q; i++)
if (w[i].F > w[i].S) swap(w[i].F, w[i].S);
for (int i = 0; i < n; i++) {
p[i].start = lower_bound(t, t + n, t[i] - k) - t;
p[i].end = upper_bound(t, t + n, t[i] + k) - t - 1;
}
sort(w, w + q, cmd3);
sort(p, p + n, cmd2);
for (int i = 0; i < n; i++) {
update1(1, 0, n - 1, p[i].num);
p[i].gs = query1(1, 0, n - 1, p[i].start, p[i].end);
}
c = n - 1;
for (int i = 0; i < n; i++) g[p[i].num] = i;
for (int i = 0; i < q; i++) {
while (p[c].res >= max(p[g[w[i].F]].res, p[g[w[i].S]].res) && c >= 0) {
update2(1, 0, n - 1, p[c].num, p[c].gs);
c--;
}
int d = -1;
if (p[g[w[i].S]].start <= p[g[w[i].F]].end)
d = query2(1, 0, n - 1, p[g[w[i].S]].start, p[g[w[i].F]].end);
if (d <= 0)
nb[w[i].num] = -1;
else
nb[w[i].num] = d;
}
for (int i = 0; i < q; i++) cout << nb[i] << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long int n = s.size();
cout << 3 << "\n";
cout << 'L' << " " << n - 1 << "\n";
cout << "R " << n - 1 << "\n";
cout << "R " << 2 * n - 1 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 10005;
const long long int mod = 119 << 23 | 1;
long long int n, m;
map<long long int, vector<long long int>> mp;
long long int c[N];
vector<long long int> v;
long long int extra[N];
long long int power(long long int a, long long int b, long long int c) {
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % c;
a = (a * a) % c;
b = b >> 1;
}
return ans;
}
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int a, b;
cin >> a >> b;
if (b > a)
mp[a].push_back(b);
else
mp[a].push_back(n + b);
c[a]++;
}
for (long long int i = 1; i <= n; i++) {
sort(mp[i].begin(), mp[i].end());
}
long long int temp = 0;
for (long long int i = 1; i <= n; i++) {
temp = max(temp, c[i]);
}
long long int ans = (temp - 1) * n;
for (long long int i = 1; i <= n; i++) {
if (temp == c[i]) {
extra[i] = mp[i][0] - i;
}
}
for (long long int i = 1; i <= n; i++) {
long long int lol = 0;
for (long long int j = i; j <= n; j++) {
if (temp == c[j])
lol = max(extra[j] + (j - i), lol);
else if (c[j] > 0 and temp == c[j] + 1 and
(mp[j][0] % n > i and mp[j][0] % n < j)) {
lol = max(lol, (mp[j][0] - i + n) % n);
}
}
for (long long int j = 1; j < i; j++) {
if (temp == c[j])
lol = max(extra[j] + (j - i + n), lol);
else if (c[j] > 0 and temp == c[j] + 1 and
(mp[j][0] % n > i or mp[j][0] % n < j)) {
lol = max(lol, (mp[j][0] - i + n) % n);
}
}
cout << ans + lol << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int inf = 1e9;
int main() {
int n, i;
scanf("%d", &n);
if (n < 4)
printf("NO\n");
else {
printf("YES\n");
printf("2 * 4 = 8\n");
if (n & 1) {
printf("3 - 1 = 2\n");
printf("5 - 2 = 3\n");
printf("3 * 8 = 24\n");
for (i = 6; i <= n; i += 2) {
printf("%d - %d = 1\n", i + 1, i);
printf("24 * 1 = 24\n");
}
} else {
printf("3 * 1 = 3\n");
printf("8 * 3 = 24\n");
for (i = 5; i <= n; i += 2) {
printf("%d - %d = 1\n", i + 1, i);
printf("24 * 1 = 24\n");
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long Min(long long a, long long b) { return (a < b) ? a : b; }
long long Max(long long a, long long b) { return (a < b) ? b : a; }
long long gcd(long long m, long long n) {
if (n == 0) return m;
return gcd(n, m % n);
}
long long lcm(long long m, long long n) { return m * n / gcd(m, n); }
long long mod = 1e9 + 7;
long long add(long long x, long long y) { return (x + y) % mod; }
long long mul(long long x, long long y) { return (x * y) % mod; }
long long d[500005][4][4];
long long th[500005] = {
1,
};
void solve() {
long long n, cnt = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '?') cnt++;
}
for (int i = 1; i <= n; i++) {
th[i] = mul(th[i - 1], 3);
}
d[0][0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
if (d[i][j][k] == 0) continue;
d[i + 1][j][k] = add(d[i][j][k], d[i + 1][j][k]);
if (s[i] == '?') {
if (j + 1 < 4) {
d[i + 1][j + 1][k + 1] = add(d[i + 1][j + 1][k + 1], d[i][j][k]);
}
} else if (s[i] - 'a' == j) {
if (j + 1 < 4) {
d[i + 1][j + 1][k] = add(d[i][j][k], d[i + 1][j + 1][k]);
}
}
}
}
}
long long ans = 0;
for (int i = 0; i <= 3; i++) {
if (cnt - i >= 0) ans = add(ans, mul(d[n][3][i], th[cnt - i]));
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long tc = 1;
while (tc--) solve();
exit(0);
}
| 6 |
#include <bits/stdc++.h>
template <int MOD>
struct Integral {
int v_ = 0;
Integral() {}
Integral(long long v) {
if (v >= MOD) v -= MOD;
if (v < 0) v += MOD;
if (v >= MOD || v < 0) v = (v % MOD + MOD) % MOD;
v_ = v;
}
~Integral() = default;
int val() const { return v_; }
Integral operator+(const Integral& rhs) const {
return Integral(val() + rhs.val());
}
Integral operator-(const Integral& rhs) const {
return Integral(val() - rhs.val());
}
Integral operator*(const Integral& rhs) const {
return Integral(val() * 1LL * rhs.val());
}
Integral operator/(const Integral& rhs) const { return *this * rhs.inv(); }
Integral operator-() const { return Integral(-val()); }
Integral operator+=(const Integral& rhs) {
*this = *this + rhs;
return *this;
}
Integral operator-=(const Integral& rhs) {
*this = *this - rhs;
return *this;
}
Integral operator*=(const Integral& rhs) {
*this = *this * rhs;
return *this;
}
Integral operator/=(const Integral& rhs) {
*this = *this / rhs;
return *this;
}
bool operator==(const Integral& rhs) { return val() == rhs.val(); }
bool operator!=(const Integral& rhs) { return !(*this == rhs); }
Integral power(long long b) const {
long long ret = 1 % MOD, a = v_;
for (; b; b >>= 1, a = a * a % MOD)
if (b & 1) ret = ret * a % MOD;
return ret;
}
Integral inv() const { return power(MOD - 2); }
};
template <typename T>
using Polynomial = std::vector<T>;
template <typename T>
void norm(Polynomial<T>& p) {
while (p.size() > 1 && p.back() == T(0)) p.pop_back();
}
template <typename T>
Polynomial<T> operator+(const Polynomial<T>& lhs, const Polynomial<T>& rhs) {
Polynomial<T> ret = lhs;
ret.resize(std::max(lhs.size(), rhs.size()), T(0));
for (int i = 0; i < rhs.size(); ++i) ret[i] += rhs[i];
norm(ret);
return ret;
}
template <typename T>
Polynomial<T> operator*(const Polynomial<T>& lhs, const Polynomial<T>& rhs) {
(lhs.size() + rhs.size() > 0);
Polynomial<T> ret(lhs.size() + rhs.size() - 1, T(0));
for (int i = 0; i < lhs.size(); ++i)
for (int j = 0; j < rhs.size(); ++j) ret[i + j] += lhs[i] * rhs[j];
return ret;
}
template <typename T>
Polynomial<T> lagrange_polynomial(const std::vector<T>& x,
const std::vector<T>& y) {
(x.size() > 0);
int degree = x.size() - 1;
std::vector<std::vector<T>> f(degree + 1);
f[0] = y;
for (int i = 1; i <= degree; ++i)
for (int j = 0; j <= degree - 1; ++j)
f[i].emplace_back((f[i - 1][j + 1] - f[i - 1][j]) / (x[i + j] - x[j]));
Polynomial<T> cur(1, T(1));
Polynomial<T> ret;
for (int i = 0; i <= degree; ++i) {
ret = ret + cur * Polynomial<T>(1, f[i][0]);
cur = cur * Polynomial<T>{T(-x[i]), T(1)};
}
return ret;
}
template <typename T>
T eval(const Polynomial<T>& a, const T& x) {
T ret(0);
for (int i = (int)a.size() - 1; i >= 0; --i) ret = ret * x + a[i];
return ret;
}
const int MOD = 998244353;
using Int = Integral<MOD>;
using Poly = Polynomial<Int>;
Poly sum_from_l(const Poly& a, int l, int n) {
std::vector<Int> x;
for (int i = 0; i <= n; ++i) x.emplace_back(l + i);
std::vector<Int> y;
Int cur(0);
for (int i = 0; i <= n; ++i) {
cur += eval(a, x[i]);
y.emplace_back(cur);
}
return lagrange_polynomial(x, y);
}
Int sum_over_segment(const Poly& a, int l, int r) {
return eval(sum_from_l(a, l, a.size()), Int(r - 1));
}
int main() {
int n;
scanf("%d", &n);
std::vector<int> l(n), r(n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &l[i], &r[i]);
++r[i];
}
std::reverse(l.begin(), l.end());
std::reverse(r.begin(), r.end());
std::vector<int> coord{0, MOD - 1};
for (int i = 0; i < n; ++i) {
coord.emplace_back(l[i]);
coord.emplace_back(r[i]);
}
std::sort(coord.begin(), coord.end());
coord.erase(std::unique(coord.begin(), coord.end()), coord.end());
std::vector<Poly> cur(coord.size() - 1);
for (int i = 0; i + 1 < coord.size(); ++i) {
if (coord[i] >= l[0] && coord[i + 1] <= r[0]) {
cur[i] = Poly(1, Int(r[0] - l[0]).inv());
}
}
for (int i = 1; i < n; ++i) {
std::vector<Poly> next(coord.size() - 1);
Int sum(0);
for (int j = 0; j + 1 < coord.size(); ++j) {
next[j] = sum_from_l(cur[j], coord[j], i) + Poly(1, sum);
sum += sum_over_segment(cur[j], coord[j], coord[j + 1]);
}
for (int j = 0; j + 1 < coord.size(); ++j) {
if (coord[j] >= l[i] && coord[j + 1] <= r[i])
next[j] = next[j] * Poly(1, Int(r[i] - l[i]).inv());
else
next[j] = Poly(1, 0);
}
cur = next;
}
Int result(0);
for (int i = 0; i + 1 < coord.size(); ++i)
result += sum_over_segment(cur[i], coord[i], coord[i + 1]);
printf("%d\n", result.val());
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector
#define pb push_back
#define pub pull_back
#define be begin
#define p pair<ll,ll>
#define f first
#define se second
#define um unordered_map
#define om map
#define us unordered_set
#define tr pair<ll,pair<long long int,long long int>>
#define Q queue
#define cp(v1,x,i,n) for(i=0;i<n;i++){v1[i]=x;}
#define lp(i,a,b) for(i=a;i<b;i++)
#define MAXN 1000000
#define pq priority_queue
void update(ll i,ll j,ll d,ll n,v<v<ll>> &v3)
{
while(i>0)
{
ll k=j;
while(k>0)
{
v3[i][k]+=d;
k-=k&(-k);
}
i-=i&(-i);
}
}
ll getsum(ll i,ll j,ll n,v<v<ll>> &v3)
{
ll sum=0;
while(i<=n)
{
ll k=j;
while(k<=n)
{
sum+=v3[i][k];
k+=k&(-k);
}
i+=i&(-i);
}
return sum;
}
bool cmp(tr a,tr b)
{
if(a.f==b.f)
return a.se.se<b.se.se;
return a.f>b.f;
}
int main()
{
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
ll t=1,pp=0;
cin>>t;
while(t--)
{
ll n,j=0,b=0,sum1=0,sum2=0,mina=INT_MAX,maxa=0,e=0,h=0,g=0,x2=-1,y1,y2=-1,a,l=0,r,l1=0,r1=0,x1=0;
ll sum=0,i=0,y=0,c=0;
ll d=0;
ll k=0,k1=0,k2=0,k3=0,k4=0;
ll m;
// set<ll> s;
cin>>n;
string s1;
v<ll> v1(n);
lp(i,0,n)
cin>>v1[i];
sum=2*n-1;
for(i=2;i<n;i++)
{
if(v1[i-1]<v1[i]&&v1[i-1]<v1[i-2])
{
sum++;
}
else if(v1[i-1]>v1[i]&&v1[i-1]>v1[i-2])
sum++;
if(i!=2)
{
if(v1[i-1]<v1[i]&&v1[i-1]<v1[i-2])
{
if(v1[i-2]>v1[i-3]&&v1[i-1]<v1[i-3]&&v1[i-2]>v1[i])
{sum++;
}
}
else if(v1[i-1]>v1[i]&&v1[i-1]>v1[i-2])
{
if(v1[i-2]<v1[i-3]&&v1[i-1]>v1[i-3]&&v1[i-2]<v1[i])
{ sum++;
}
}
}
}
cout<<sum<<"\n";
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> st(k);
for (int &t : st) cin >> t;
int c2 = 2 * n, c4 = n, c1 = 0;
sort(st.begin(), st.end());
reverse(st.begin(), st.end());
for (int t : st) {
while (t >= 4 && c4) c4--, t -= 4;
while (t >= 2 && c2) c2--, t -= 2;
if (t == 3) {
if (c4)
c4--, t = 0;
else if (c1 >= 3)
c1 -= 3, t = 0;
} else if (t == 2) {
if (c4) c4--, c1++, t = 0;
}
while (t && c1) c1--, t--;
if (t == 1) {
if (c4)
c4--, c2++, t = 0;
else if (c2)
c2--, t = 0;
}
if (t > 0) {
puts("NO");
return 0;
}
}
puts("YES");
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void find(long long x) {
long long base = 1, cur = 9, f = 1;
while (x - cur * base > 0) {
x -= cur * base;
base++;
cur *= 10;
f *= 10;
}
long long numb = f + (x + base - 1) / base - 1, digit = (x - 1) % base;
string ans = to_string(numb);
cout << ans[digit] << endl;
}
void solve() {
long long k = 0;
cin >> k;
long long curlen = 1, toadd = 1, cur = 1, need = 10;
while (k - curlen > 0) {
k -= curlen;
cur++;
if (cur == need) {
toadd++;
need *= 10;
}
curlen += toadd;
}
find(k);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 0;
cin >> q;
while (q--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 1e6 + 7, SM = 1e3 + 5, logN = 20;
const long long MOD = 1e9 + 7, INF = 1e18 + 9;
const int dx[] = {1, 0, 0, -1, -1, 1, -1, 1};
const int dy[] = {0, 1, -1, 0, -1, 1, 1, -1};
void debug() { cerr << "\n"; }
template <typename Head, typename... Tail>
void debug(Head a, Tail... b) {
cerr << a << " ";
debug(b...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n + 1), b(k + 1);
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= k; i++) {
cin >> b[i];
}
sort(a.begin() + 1, a.end());
sort(b.rbegin(), b.rend() - 1);
vector<long long> prefA(n + 1), prefB(k + 1);
for (long long i = 1; i <= n; i++) {
prefA[i] = prefA[i - 1] + a[i];
}
for (long long i = 1; i <= k; i++) {
prefB[i] = prefB[i - 1] + b[i];
}
auto solve = [&](long long val) {
long long l = 1, r = n, st = 0;
while (l <= r) {
long long m = l + (r - l) / 2;
if (a[m] <= val) {
l = m + 1;
st = m;
} else {
r = m - 1;
}
}
if (val < a[1])
st = 0;
else
st = st * val - prefA[st];
long long nd = 0;
l = 1, r = k;
while (l <= r) {
long long m = l + (r - l) / 2;
if (b[m] >= val) {
l = m + 1;
nd = m;
} else {
r = m - 1;
}
}
if (val >= b[1])
nd = 0;
else
nd = prefB[nd] - nd * val;
return st + nd;
};
long long low = 1, high = MOD, ans = INF;
while (low <= high) {
long long mid = low + (high - low) / 2, x = solve(mid), y = solve(mid + 1);
if (x <= y) {
high = mid - 1;
} else {
low = mid + 1;
}
ans = min({ans, x, y});
}
cout << ans;
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, m, i, ind = 0;
char pixel[2];
scanf("%d%d", &n, &m);
for (; n > 0; n--) {
for (i = 0; i < m; i++) {
scanf("%s", pixel);
if (pixel[0] != 'B' && pixel[0] != 'W' && pixel[0] != 'G') {
ind = 1;
}
}
}
if (ind == 1) {
printf("#Color");
} else {
printf("#Black&White");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100050], num[100050], oc[100050];
inline void read(int &x) {
x = 0;
register char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
int main() {
read(n);
for (register int i = 1; i <= n; i++) {
read(a[i]);
num[a[i]]++;
}
int tot = 0;
for (register int i = 1; i <= n; i++) {
if (num[i] & 1) tot++;
}
if ((n % 2 == 0 && tot) || (n % 2 && tot > 1)) {
cout << 0 << endl;
return 0;
}
int len = 0;
for (register int i = 1; i <= (n >> 1); i++) {
if (a[i] != a[n - i + 1]) {
len = i;
break;
}
num[a[i]] -= 2;
}
if (len == 0) {
cout << (long long)n * (n + 1) / 2 << endl;
return 0;
}
int le = 0, ri = 0;
for (register int i = len; i <= n; i++) {
oc[a[i]]++;
if (oc[a[i]] * 2 > num[a[i]]) {
if (a[i] != a[n - i + 1]) break;
if (i < n - i + 1) break;
if (num[a[i]] % 2 == 0 && i == n - i + 1) break;
}
le++;
}
memset(oc, 0, sizeof(oc));
for (register int i = n - len + 1; i >= 1; i--) {
oc[a[i]]++;
if (oc[a[i]] * 2 > num[a[i]]) {
if (a[i] != a[n - i + 1]) break;
if (i > n - i + 1) break;
if (num[a[i]] % 2 == 0 && i == n - i + 1) break;
}
ri++;
}
cout << (long long)len * (len + le + ri) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[2000];
int main() {
int n, k, all, x, ans = 0, mx = 0;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> x;
a[x]++;
mx = max(mx, a[x]);
}
all = mx / k + (mx % k != 0);
for (int i = 0; i < 110; i++)
if (a[i]) ans += all * k - a[i];
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
struct S {
int l, r, p;
} s[205];
int f[205][205], n, a, b, m, r;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &a, &b), s[++m] = {a - b, a, i}, s[++m] = {a, a + b, i};
std::sort(s + 1, s + m + 1, [&](S a, S b) { return a.r < b.r; });
for (int i = 1; i <= m; i++) f[0][i] = s[i].r - s[i].l;
for (int i = 0; i <= m; i++)
for (int j = i + 1; j <= m; j++) {
for (int k = j + 1; k <= m; k++)
if ((!i || s[k].l > s[i].r) && s[k].p != s[j].p)
f[i][j] + s[k].r - std::max(s[k].l, s[j].r) > f[j][k]
? f[j][k] = f[i][j] + s[k].r - std::max(s[k].l, s[j].r)
: 0;
f[i][j] > r ? r = f[i][j] : 0;
}
printf("%d", r);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long m, t, M[110];
long long id = 1;
void alc(long long n) {
for (long long i = 1; i <= m - n + 1; i++) {
long long j;
for (j = i; j < i + n; j++)
if (M[j]) break;
if (j < i + n) continue;
for (j = i; j < i + n; j++) M[j] = id;
cout << id++ << '\n';
return;
}
cout << "NULL\n";
}
void ers(long long n) {
long long cnt = 0;
for (long long i = 1; i <= 100; i++)
if (M[i] == n && M[i] >= 1 && M[i] <= 100) M[i] = 0, cnt++;
if (!cnt) cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
void frg() {
vector<long long> v;
for (long long i = 1; i <= 100; i++)
if (M[i]) v.push_back(M[i]);
memset(M, 0, sizeof(M));
long long L = v.size();
for (long long i = 1; i <= L; i++) M[i] = v[i - 1];
}
int main() {
cin >> t >> m;
while (t--) {
string s;
cin >> s;
if (s == "alloc") {
long long x;
cin >> x;
alc(x);
}
if (s == "erase") {
long long x;
cin >> x;
ers(x);
}
if (s == "defragment") {
frg();
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, k;
long long c[maxn];
int vis[maxn];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%I64d", &c[i]);
for (int i = 0; i < k; ++i) {
int x;
scanf("%d", &x);
vis[x] = 1;
}
long long sum1 = 0, sum2 = 0;
for (int i = 1; i <= n; ++i) {
if (vis[i]) {
sum1 += c[i];
}
sum2 += c[i];
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
if (vis[i]) {
ans += (sum2 - c[i]) * c[i];
} else {
int x = i - 1;
int x1 = (x - 1 + n) % n + 1, x2 = (x + 1) % n + 1;
long long tmp = c[x1] + c[x2];
if (vis[x1]) tmp -= c[x1];
if (vis[x2]) tmp -= c[x2];
tmp += sum1;
ans += c[i] * tmp;
}
}
printf("%I64d\n", ans / 2);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100020];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
scanf("%d", &a[i]);
}
bool same = true;
for (int i = 0; i <= n; i++) {
if (a[i] > 1 && a[i + 1] > 1) {
same = false;
}
}
if (same) {
printf("perfect\n");
} else {
printf("ambiguous\n");
int cur = 1, p = 1;
printf("0");
for (int i = 1; i <= n; i++) {
for (int j = 0; j < a[i]; j++) {
printf(" %d", p);
if (p < cur) {
p++;
}
}
p = cur + 1;
cur += a[i];
}
printf("\n");
cur = 1;
p = 1;
printf("0");
for (int i = 1; i <= n; i++) {
for (int j = 0; j < a[i]; j++) {
printf(" %d", p);
}
p = cur + 1;
cur += a[i];
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int n, c, add[1000005];
vector<int> word[500005];
void out(int x) {
printf("%d\n", x);
exit(0);
}
int upd(int l, int r) {
add[l]++;
add[r]--;
}
int main() {
int u;
scanf("%d %d", &n, &c);
for (int i = 1; i <= n; i++) {
scanf("%d", &u);
word[i].assign(u, 0);
for (int j = 0; j < u; j++) scanf("%d", &word[i][j]);
}
for (int i = 1; i < n; i++) {
int id = 1;
while (id <= word[i].size() && id <= word[i + 1].size() &&
word[i][id - 1] == word[i + 1][id - 1])
id++;
if (id == word[i].size() + 1) {
upd(0, c);
continue;
}
if (id == word[i + 1].size() + 1) out(-1);
int a = word[i][id - 1], b = word[i + 1][id - 1];
if (a < b) {
upd(0, c - b + 1);
upd(c - a + 1, c);
} else
upd(c - a + 1, c - b + 1);
}
for (int i = 0; i < c; i++) {
if (i) add[i] += add[i - 1];
if (add[i] == n - 1) out(i);
}
out(-1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long minTime(string s, int k) {
int lastH = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'H') {
lastH = i;
}
}
for (int i = 0; i < s.length(); i++) {
if (k > 0 && s[i] == 'H') {
s[i] = '.';
k--;
}
}
int H = 0;
vector<int> pos;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'H') {
lastH = i;
if (H == 0) {
pos.push_back(i);
}
H++;
} else if (s[i] == 'S') {
H--;
if (H == 0) {
pos.push_back(i);
}
}
}
if (H > 0) {
return 2e9;
}
if (pos.size() != 0) lastH = max(lastH, pos[pos.size() - 1]);
pos.push_back(lastH);
pos.push_back(lastH);
int res = 2e9;
int used = 0;
for (int i = 0; i < pos.size(); i += 2) {
if (i == 0) {
used += pos[i] + 1;
} else {
used += pos[i] - pos[i - 2];
}
res = min(res, used + (lastH - pos[i]) * 2);
used += (pos[i + 1] - pos[i]) * 2;
}
return res;
}
int main() {
for (int i = 0; i < 1000; i++) {
minTime("...HHHSSS...S..H", i);
}
long long n, t;
cin >> n >> t;
string s;
cin >> s;
long long l = -1, r = 1e8;
while (l + 1 != r) {
long long mid = (l + r) / 2;
if (minTime(s, mid) <= t) {
r = mid;
} else {
l = mid;
}
}
if (minTime(s, r) > t || r > 1e7) {
cout << -1 << endl;
} else
cout << r << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int n, s, x;
pair<int, int> Ask(int i) {
if (i == -1) return make_pair(inf, -1);
printf("? %i\n", i);
fflush(stdout);
pair<int, int> p;
scanf("%i %i", &p.first, &p.second);
return p;
}
void Ans(int i) {
if (i == inf)
printf("! -1\n");
else
printf("! %i\n", i);
fflush(stdout);
exit(0);
}
int main() {
srand(time(0));
scanf("%i %i %i", &n, &s, &x);
int mx = 0, fir = s;
for (int t = 1000; t--;) {
int i = (rand() * rand() ^ rand()) % n + 1;
pair<int, int> tmp = Ask(i);
if (tmp.first < x) {
if (mx < tmp.first) mx = tmp.first, fir = i;
}
if (tmp.first == x) Ans(x);
}
int val = 0;
do {
pair<int, int> tmp = Ask(fir);
val = tmp.first;
fir = tmp.second;
} while (val < x);
Ans(val);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int visited[550000];
int arr[550000];
int cnt;
int stop;
struct graph {
int v;
struct graph *next;
} * gr[550000], *remem[550000];
void insert(int x, int x1) {
struct graph *temp = (struct graph *)malloc(sizeof(struct graph));
temp->v = x1;
temp->next = NULL;
if (!gr[x]) {
gr[x] = temp;
remem[x] = temp;
return;
}
remem[x]->next = temp;
remem[x] = temp;
}
void solve(int x, int par) {
if (visited[x]) return;
visited[x] = 1;
if (x != 1 && !stop) {
arr[x] = arr[x] == -1 ? 1 : -1;
if (arr[x] == 1)
cnt--;
else
cnt++;
if (cnt <= 0) {
printf("%d", x);
stop = 1;
}
}
if (!stop) printf("%d ", x);
struct graph *sweep = gr[x];
while (sweep) {
if (sweep->v != par) solve(sweep->v, x);
if (sweep->v != par && !stop) {
printf("%d ", x);
arr[x] = arr[x] == 1 ? -1 : 1;
if (arr[x] == -1)
cnt++;
else
cnt--;
if (cnt <= 0) stop = 1;
if (arr[sweep->v] == -1 && !stop) {
printf("%d ", sweep->v);
arr[sweep->v] = 1;
cnt--;
if (cnt <= 0) stop = 1;
if (cnt && !stop) {
printf("%d ", x);
arr[x] = arr[x] == 1 ? -1 : 1;
if (arr[x] == 1)
cnt--;
else
cnt++;
if (cnt <= 0) stop = 1;
}
}
}
sweep = sweep->next;
}
}
int main() {
int a, b, c, d, e;
int flag = 1;
scanf("%d", &a);
for (int i = 1; i <= a; i++) {
scanf("%d", arr + i);
if (arr[i] == -1) {
flag = 0;
cnt++;
}
}
for (int i = 0; i < a - 1; i++) {
int foo[2];
scanf("%d%d", foo, foo + 1);
insert(foo[0], foo[1]);
insert(foo[1], foo[0]);
}
if (flag) {
printf("1");
return 0;
}
solve(1, 0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> grid;
vector<vector<int>> flag;
int n, m, k;
int findFlag(int r, int c) {
if (flag[r][c] == r || flag[r][c] == n) return flag[r][c];
flag[r][c] = findFlag(flag[r][c], c);
return flag[r][c];
}
int main() {
cin >> n >> m >> k;
grid = vector<vector<int>>(n, vector<int>(m, 0));
flag = vector<vector<int>>(n, vector<int>(m, 0));
vector<int> ball(k, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
flag[i][j] = i;
}
}
for (int i = 0; i < k; i++) {
cin >> ball[i];
ball[i]--;
}
for (int i = 0; i < k; i++) {
int rCur = 0;
int cCur = ball[i];
while (rCur != n) {
if (grid[rCur][cCur] == 1) {
grid[rCur][cCur] = 2;
cCur++;
} else if (grid[rCur][cCur] == 3) {
grid[rCur][cCur] = 2;
cCur--;
} else {
int rNew = findFlag(rCur, cCur);
if (rCur == rNew) {
flag[rCur][cCur] = rCur + 1;
rCur++;
} else
rCur = rNew;
}
}
cCur++;
cout << cCur << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int r, b, g, ans;
int main() {
scanf("%d %d %d", &r, &g, &b);
ans = 29;
while (r + g + b > 0) {
if (r >= 2)
r -= 2;
else if (r)
r = 0;
ans++;
if (r + g + b > 0)
;
else
break;
if (g >= 2)
g -= 2;
else if (g)
g = 0;
ans++;
if (r + g + b > 0)
;
else
break;
if (b >= 2)
b -= 2;
else if (b)
b = 0;
ans++;
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, a[100001], pos, menor = 0x3f3f3f3f, cont = 0;
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) scanf("%d", &a[i]);
for (int i = 0; i + 1 < n; i++)
if (a[i] > a[i + 1]) cont++, pos = i + 1;
if (cont == 1 and a[n - 1] > a[0]) cont = 2;
if (cont > 1)
puts("-1");
else if (cont < 1)
puts("0");
else
printf("%d\n", (n - pos));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[200005];
struct ppp {
int l, r, tag, sum;
} tree[1000005];
int tin[200005], tout[200005], a[200005], tot = 0;
void dfs(int u) {
tin[u] = ++tot;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
dfs(v);
}
tout[u] = tot;
}
void push(long long i) {
if (!tree[i].tag) return;
tree[i * 2].tag ^= 1;
tree[i * 2 + 1].tag ^= 1;
tree[i * 2].sum = (tree[i * 2].r - tree[i * 2].l + 1) - tree[i * 2].sum;
tree[i * 2 + 1].sum =
(tree[i * 2 + 1].r - tree[i * 2 + 1].l + 1) - tree[i * 2 + 1].sum;
tree[i].tag = 0;
}
void buildtree(int i, int l, int r) {
tree[i].l = l;
tree[i].r = r;
tree[i].tag = 0;
if (l == r) {
tree[i].sum = 0;
return;
}
buildtree(i * 2, l, (l + r) / 2);
buildtree(i * 2 + 1, (r + l) / 2 + 1, r);
tree[i].sum = tree[i * 2].sum + tree[i * 2 + 1].sum;
}
void update(long long i, long long l, long long r) {
if (tree[i].l >= l && tree[i].r <= r) {
tree[i].tag ^= 1;
tree[i].sum = (tree[i].r - tree[i].l + 1) - tree[i].sum;
return;
}
push(i);
long long m = (tree[i].l + tree[i].r) / 2;
if (l <= m) update(i * 2, l, r);
if (r > m) update(i * 2 + 1, l, r);
tree[i].sum = tree[i * 2].sum + tree[i * 2 + 1].sum;
}
long long query(long long i, long long l, long long r) {
if (tree[i].l >= l && tree[i].r <= r) {
return tree[i].sum;
}
push(i);
long long m = (tree[i].r + tree[i].l) / 2, ans = 0;
if (l <= m) ans += query(i * 2, l, r);
if (r > m) ans += query(i * 2 + 1, l, r);
return ans;
}
int main() {
int n, q;
cin >> n;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
edge[x].push_back(i);
}
dfs(1);
buildtree(1, 1, n);
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x) update(1, tin[i], tin[i]);
}
cin >> q;
while (q--) {
string op;
cin >> op;
if (op == "pow") {
int x;
cin >> x;
update(1, tin[x], tout[x]);
} else {
int x;
cin >> x;
cout << query(1, tin[x], tout[x]) << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool vis[1000000];
int coun = 1;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x, y;
cin >> n >> x >> y;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (x > y) {
cout << n;
return 0;
}
int x1 = 0;
for (int i = 0; i < n; i++)
if (a[i] <= x) x1++;
cout << ceil((double)x1 / 2);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long h, w;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
cin >> s[i];
}
vector<vector<long long> > sd(h + 1, vector<long long>(w + 1, 0));
vector<vector<long long> > sr(h + 1, vector<long long>(w + 1, 0));
for (int i = h - 1; i >= 0; i--) {
for (int j = w - 1; j >= 0; j--) {
sd[i][j] = sd[i + 1][j] + (s[i][j] == 'R');
sd[i][j] %= 1000000007;
sr[i][j] = sr[i][j + 1] + (s[i][j] == 'R');
sr[i][j] %= 1000000007;
}
}
vector<vector<long long> > dpd(h + 5, vector<long long>(w + 5, 0));
vector<vector<long long> > dpr(h + 5, vector<long long>(w + 5, 0));
for (int i = h - 1; i >= 0; i--) {
for (int j = w - 1; j >= 0; j--) {
if (i == h - 1 && j == w - 1) {
continue;
}
dpr[i][j] = dpr[i][j + 1] + dpd[i][j + 1];
dpr[i][j] %= 1000000007;
dpd[i][j] = dpd[i + 1][j] + dpr[i + 1][j];
dpd[i][j] %= 1000000007;
if (i < h - 1 && s[i + 1][j] == 'R') {
dpd[i][j] -= dpr[h - sd[i + 1][j]][j];
dpd[i][j] = (dpd[i][j] + 1000000007) % 1000000007;
}
if (j < w - 1 && s[i][j + 1] == 'R') {
dpr[i][j] -= (dpd[i][w - sr[i][j + 1]]);
dpr[i][j] = (dpr[i][j] + 1000000007) % 1000000007;
}
if (i == h - 1) {
dpr[i][j] = (sr[i][j + 1] == 0 ? 1 : 0);
dpr[i][j] = (dpr[i][j] + 1000000007) % 1000000007;
}
if (j == w - 1) {
dpd[i][j] = (sd[i + 1][j] == 0 ? 1 : 0);
dpd[i][j] = (dpd[i][j] + 1000000007) % 1000000007;
}
}
}
long long ans = dpd[0][0] + dpr[0][0];
ans %= 1000000007;
if (h == 1 && w == 1 && s[0][0] == '.') {
ans = 1;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
int a[MAXN][MAXN], n, m, row[MAXN], col[MAXN];
inline void init(void) {
scanf("%d%d", &n, &m);
char ch;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> ch, a[i][j] = (ch == '#');
}
inline bool check1(void) {
int flag = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] == 1) flag = 0;
if (flag == 1) return true;
return false;
}
inline int id(int x, int y) { return (x - 1) * m + y; }
int fa[MAXN * MAXN];
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
inline void merge(int u, int v) {
int fu = get(u), fv = get(v);
if (fu != fv) fa[fv] = fu;
}
int head1[MAXN], head2[MAXN];
inline void dsuinit(void) {
for (int i = 1; i <= n * m; ++i) fa[i] = i;
}
inline bool checkrow(void) {
dsuinit();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (!a[i][j]) continue;
if (!head1[i])
head1[i] = id(i, j);
else
merge(id(i, j - 1), id(i, j));
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (!a[i][j]) continue;
if (get(id(i, j)) != head1[i]) return false;
}
}
return true;
}
inline bool checkcol(void) {
dsuinit();
for (int j = 1; j <= m; ++j) {
for (int i = 1; i <= n; ++i) {
if (!a[i][j]) continue;
if (!head2[j])
head2[j] = id(i, j);
else
merge(id(i - 1, j), id(i, j));
}
}
for (int j = 1; j <= m; ++j) {
for (int i = 1; i <= n; ++i) {
if (!a[i][j]) continue;
if (get(id(i, j)) != head2[j]) return false;
}
}
return true;
}
inline bool check3(void) {
bool flag1 = 1, flag2 = 1;
for (int i = 1; i <= n; ++i)
if (!head1[i]) flag1 = 0;
for (int j = 1; j <= m; ++j)
if (!head2[j]) flag2 = 0;
if ((!flag1) && flag2) return false;
if (flag1 && (!flag2)) return false;
return true;
}
const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int vis[MAXN][MAXN];
void dfs(int x, int y) {
vis[x][y] = 1;
for (int i = 0; i < 4; ++i) {
int dx = x + fx[i][0], dy = y + fx[i][1];
if ((dx >= 1 && dx <= n && dy >= 1 && dy <= m) && a[dx][dy] == 1 &&
!vis[dx][dy])
dfs(dx, dy);
}
}
int solve(void) {
int ret = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 1 && vis[i][j] == 0) {
ret++;
dfs(i, j);
}
}
}
return ret;
}
inline void work(void) {
if (check1()) {
printf("0");
return;
}
if (checkrow() && checkcol() && check3())
printf("%d", solve());
else
printf("-1");
}
int main() {
init();
work();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long c;
long long p[10010], s[10010];
long long f[10010], ans;
int main() {
scanf("%d%I64d", &n, &c);
for (int i = 1; i <= n; i++) scanf("%I64d", &p[i]);
for (int i = 1; i <= n; i++) scanf("%I64d", &s[i]);
for (int i = 1; i <= n; i++) {
f[i] = 1e18;
for (int j = i; j >= 1; j--)
f[j] = min(f[j] + j * c + p[i], f[j - 1] + s[i]);
f[0] += p[i];
}
ans = 1e18;
for (int i = 0; i <= n; i++) ans = min(ans, f[i]);
printf("%I64d", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, cntb, suf[N];
char str[N];
bool f[N];
inline bool check(int lim) {
memset(f, 0, sizeof(bool) * (n + 5));
f[0] = 1;
for (int i = 1; i <= n; i++) {
if (!f[i - 1]) continue;
if (str[i] == '.')
f[i] = 1;
else if (str[i] == 'P')
f[min(i + lim, min(suf[i] - 1, n))] = f[i] = 1;
else {
if (suf[i] - i <= lim) {
f[suf[i]] = 1;
if (suf[suf[i]] - i <= lim)
f[min(suf[i] + lim, min(suf[suf[suf[i]]] - 1, n))] = 1;
}
}
}
return f[n];
}
void work() {
int l = 0, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%d %d\n", cntb, l);
}
int main() {
scanf("%d%s", &n, str + 1);
int le = 1, ri = n;
while (str[le] != 'P' && le <= n) le++;
while (str[ri] != 'P' && ri >= 1) ri--;
if (le == ri) {
int cnt1 = 0, cnt2 = 0, last1 = le, last2 = le;
for (int i = le + 1; i <= n; i++) {
if (str[i] == '*') cnt1++, last1 = max(last1, i);
}
for (int i = le - 1; i >= 1; i--) {
if (str[i] == '*') cnt2++, last2 = min(last2, i);
}
if (cnt1 > cnt2)
printf("%d %d\n", cnt1, last1 - le);
else if (cnt1 < cnt2)
printf("%d %d\n", cnt2, le - last2);
else
printf("%d %d\n", cnt1, min(le - last2, last1 - le));
return 0;
}
suf[n + 1] = 1e9 + 7;
for (int i = n; i >= 1; i--) {
if (str[i + 1] == 'P')
suf[i] = i + 1;
else
suf[i] = suf[i + 1];
if (str[i] == '*') cntb++;
}
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int t, a, b, i;
long long q;
long double p, res, pom, h, w;
int main() {
cin >> t;
for (i = 0; i < t; ++i) {
cin >> a >> b;
if (b == 0) {
cout << "1" << endl;
continue;
}
if (a == 0) {
cout << "0.5" << endl;
continue;
}
q = (long long)a * b;
p = q;
w = (double)a / 4;
if (w > b)
pom = (long long)a * b - (long long)b * b * 2;
else
pom = w * a / 2;
p += pom;
res = p / q;
cout << res / 2 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int rd() {
char ch = getchar();
while (ch < 'A' || ch > 'Z') ch = getchar();
return (int)ch - 64;
}
int n, m, mp[21][21], u, v;
struct pt {
int h[21][21];
} f, g;
void prtf(pt as, int op) {
if (op == 0) printf("\n");
if (op == 0) printf("Print Map='F'\n");
if (op == 1) printf("Print Map='G'\n");
for (int i = 1; i <= u; i++) {
for (int j = 1; j <= v; j++) printf("%d ", as.h[i][j]);
printf("\n");
}
return;
}
bool equ() {
bool flg = true;
for (int i = 1; i <= u; i++)
for (int j = 1; j <= v; j++)
if (f.h[i][j] != g.h[i][j]) {
flg = false;
break;
}
if (flg) return true;
flg = true;
for (int i = 1; i <= u; i++)
for (int j = 1; j <= v; j++)
if (f.h[u - i + 1][v - j + 1] != g.h[i][j]) {
flg = false;
break;
}
if (flg) return true;
if (u != v) return false;
flg = true;
for (int i = 1; i <= u; i++)
for (int j = 1; j <= v; j++)
if (f.h[j][u - i + 1] != g.h[i][j]) {
flg = false;
break;
}
if (flg) return true;
flg = true;
for (int i = 1; i <= u; i++)
for (int j = 1; j <= v; j++)
if (g.h[j][u - i + 1] != f.h[i][j]) {
flg = false;
break;
}
if (flg) return true;
return false;
}
bool chck(int x, int y) {
int tx = n / x, ty = m / y;
u = x;
v = y;
for (int a = 0; a < tx; a++)
for (int b = 0; b < ty; b++)
for (int c = 0; c < tx; c++)
for (int d = 0; d < ty; d++)
if (a != c || b != d) {
for (int sx = 1; sx <= x; sx++)
for (int sy = 1; sy <= y; sy++)
f.h[sx][sy] = mp[a * x + sx][b * y + sy];
for (int sx = 1; sx <= x; sx++)
for (int sy = 1; sy <= y; sy++)
g.h[sx][sy] = mp[c * x + sx][d * y + sy];
bool rc = equ();
if (rc) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) mp[i][j] = rd();
int tt = 0, tx = n, ty = m;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (n % x == 0 && m % y == 0) {
if (chck(x, y)) {
tt++;
if (x * y < tx * ty) {
tx = x;
ty = y;
}
}
}
printf("%d\n%d %d\n", tt, tx, ty);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int N = 3e5, M = N;
vector<int> g[N];
int a[N];
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m, t, t1, i;
cin >> n >> m;
if (n % m == 0) {
for (i = 0; i < m; i++) cout << (n / m) << " ";
} else {
t = m - (n % m);
t1 = n % m;
while (t--) {
cout << floor((float)n / (float)m) << " ";
}
while (t1--) {
cout << ceil((float)n / (float)m) << " ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353, g = 3, G = (mod + 1) / 3;
int n, k0, t0, t = 1, k, bk[300005], p[2400005];
long long a[2400005], b0[10], b[2400005], q[2400005], res[2400005];
int read() {
int x = 0, fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * fl;
}
long long qpow(long long base, long long pw) {
long long s = 1;
while (pw) {
if (pw & 1) s = s * base % mod;
base = base * base % mod;
pw >>= 1;
}
return s;
}
void g_l(int x) {
while (t <= x) t <<= 1, k++;
for (int i = 0; i < t; i++) p[i] = (p[i >> 1] >> 1) | ((i & 1) << (k - 1));
return;
}
void NTT(long long *a, int o) {
for (int i = 0; i < t; i++)
if (i < p[i]) swap(a[i], a[p[i]]);
for (int i = 1; i < t; i <<= 1) {
long long wn = qpow(o == 1 ? g : G, (mod - 1) / (i << 1));
for (int j = 0; j < t; j += (i << 1)) {
long long w = 1;
for (int k = 0; k < i; k++, w = w * wn % mod) {
long long p = a[j + k], q = a[j + k + i] * w % mod;
a[j + k] = (p + q) % mod, a[j + k + i] = (p - q + mod) % mod;
}
}
}
if (o == -1) {
long long div = qpow(t, mod - 2);
for (int i = 0; i < t; i++) a[i] = a[i] * div % mod;
}
return;
}
void calc(long long x) {
int t1 = 0, t2 = 0;
for (int i = 1; i <= x - 1; i++)
t1 += (bk[i] == 1), t2 += ((bk[i] >= 2) << 1);
a[0] = b[0] = 1;
for (int i = 1; i <= t1; i++)
a[i] = a[i - 1] * 2ll % mod * (long long)(t1 + 1 - i) % mod *
qpow(i, mod - 2) % mod;
for (int i = 1; i <= t2; i++)
b[i] = b[i - 1] * (long long)(t2 + 1 - i) % mod * qpow(i, mod - 2) % mod;
g_l(t1 + t2);
for (int i = t1 + 1; i < t; i++) a[i] = 0;
for (int i = t2 + 1; i < t; i++) b[i] = 0;
NTT(a, 1), NTT(b, 1);
for (int i = 0; i < t; i++) a[i] = a[i] * b[i] % mod;
NTT(a, -1);
for (int i = 1; i <= t0; i++)
if ((q[i] >> 1) - 1 >= x) res[i] = (res[i] + a[(q[i] >> 1) - 1 - x]) % mod;
return;
}
int main() {
n = read(), k0 = read();
for (int i = 1; i <= n; i++) {
int x = read();
bk[x]++;
}
for (int i = 1; i <= k0; i++) b0[i] = read();
t0 = read();
for (int i = 1; i <= t0; i++) q[i] = read();
for (int i = 1; i <= k0; i++) calc(b0[i]);
for (int i = 1; i <= t0; i++) printf("%lld\n", res[i]);
return 0;
}
| 8 |
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;
#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());
typedef long long ll;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 1000000;
int n; ll wlim;
ll w[MAXN - 2];
ll ans[MAXN];
struct State {
ll offset; int dir;
set<pair<ll, ll>> ranges;
void init(ll x) { offset = 0; dir = +1; ranges.clear(); ranges.insert(MP(0LL, x)); }
bool has(ll x) {
ll y = offset + dir * x;
auto it = ranges.upper_bound(MP(y, LLONG_MAX));
if (it == ranges.begin()) return false;
it = prev(it);
return it->first <= y && y <= it->second;
}
bool empty() {
return SZ(ranges) == 0;
}
void reduce(ll x) {
ll y = offset + dir * x;
if (dir == +1) {
auto it = ranges.upper_bound(MP(y, LLONG_MAX));
while (it != ranges.end()) ranges.erase(it++);
if (it == ranges.begin()) return;
it = prev(it);
if (it->second <= y) return;
ll from = it->first;
ranges.erase(it);
ranges.insert(MP(from, y));
} else {
auto it = ranges.lower_bound(MP(y, LLONG_MIN));
if (it == ranges.begin()) return;
it = prev(it);
ll to = it->second;
while (it != ranges.begin()) ranges.erase(it--);
ranges.erase(it);
if (to >= y) ranges.insert(MP(y, to));
}
}
void flip(ll x) { offset += dir * x; dir = -dir; }
void add(ll x) {
if (has(x)) return;
ll y = offset + dir * x;
ranges.insert(MP(y, y));
}
ll smallest() {
assert(!empty());
if (dir == +1) {
return ranges.begin()->first - offset;
} else {
return offset - ranges.rbegin()->second;
}
}
};
bool solve() {
assert(n >= 3);
State state;
state.init(w[0]);
vector<bool> onleft(n - 2, false);
vector<ll> smallest(n - 2);
onleft[0] = true;
smallest[0] = state.smallest();
FOR(i, 1, n - 2) {
if (state.has(w[i])) {
onleft[i] = true;
state.init(w[i]);
} else {
state.reduce(w[i]);
if (state.empty()) return false;
state.flip(w[i]);
state.add(w[i]);
}
smallest[i] = state.smallest();
//printf("\t%d:", i); FORE(k, -50, +50) if (state.has(k)) printf(" %d", k); puts("");
}
//printf("onleft: "); REP(i, n - 2) printf("%c", onleft[i] ? 'V' : '.'); puts("");
//printf("smallest:"); REP(i, n - 2) printf(" %lld", smallest[i]); puts("");
vector<ll> d(n - 1);
d[n - 2] = smallest[n - 3];
int sgn = +1;
for (int i = n - 3; i >= 0; --i) {
if (onleft[i]) {
sgn = -sgn;
d[i] = sgn * w[i];
} else {
ll nxt = abs(d[i + 1]);
if (nxt == w[i]) {
sgn = -sgn;
d[i] = sgn * smallest[i - 1];
} else {
d[i] = sgn * (w[i] - nxt);
}
}
}
//printf("d:"); REP(i, n - 1) printf(" %lld", d[i]); puts("");
ans[0] = 0; REP(i, n - 1) ans[i + 1] = ans[i] + d[i];
ll mn = ans[0]; FOR(i, 1, n) mn = min(mn, ans[i]);
REP(i, n) ans[i] -= mn;
return true;
}
void run() {
scanf("%d%lld", &n, &wlim);
REP(i, n - 2) scanf("%lld", &w[i]);
if (!solve()) { printf("NO\n"); return; }
printf("YES\n");
REP(i, n) { if (i != 0) printf(" "); printf("%lld", ans[i]); } puts("");
}
void stress() {
int mxn = 20, mxlim = 200;
REP(rep, 10000) {
n = rnd() % (mxn - 3 + 1) + 3; wlim = rnd() % mxlim;
REP(i, n - 2) w[i] = rnd() % (wlim + 1);
if (solve()) {
vector<ll> have(n - 2);
REP(i, n - 2) { ll a = ans[i], b = ans[i + 1], c = ans[i + 2]; have[i] = max({ a, b, c }) - min({ a, b, c }); }
bool ok = true; REP(i, n - 2) if (have[i] != w[i]) ok = false;
if (ok) { printf("."); continue; }
printf("err\n");
printf("%d %lld\n", n, wlim);
REP(i, n - 2) { if (i != 0) printf(" "); printf("%lld", w[i]); } puts("");
printf("ans:"); REP(i, n) printf(" %lld", ans[i]); puts("");
printf("have:"); REP(i, n - 2) printf(" %lld", have[i]); puts("");
break;
}
}
}
int main() {
run();
//stress();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, xi, yi, nAct = 0, aux = 0;
vector<pair<long, pair<long, long>>> arr;
string ans = "";
scanf("%ld", &n);
while (n--) {
scanf("%ld %ld", &xi, &yi);
arr.push_back(make_pair(abs(xi) + abs(yi), make_pair(xi, yi)));
if (xi == 0 && yi == 0)
nAct += 2;
else if (xi == 0 || yi == 0)
nAct += 4;
else
nAct += 6;
}
sort(arr.begin(), arr.end());
bool flag, flagI;
printf("%ld \n", nAct);
for (int i = 0; i < arr.size(); i++) {
flag = true;
flagI = true;
if (arr[i].second.first > 0) printf("1 %ld R \n", arr[i].second.first);
if (arr[i].second.first < 0) {
flag = false;
printf("1 %ld L \n", -1 * arr[i].second.first);
}
if (arr[i].second.second > 0) printf("1 %ld U \n", arr[i].second.second);
if (arr[i].second.second < 0) {
flagI = false;
printf("1 %ld D \n", -1 * arr[i].second.second);
}
printf("2 \n");
if (flag && arr[i].second.first != 0)
printf("1 %ld L \n", arr[i].second.first);
else if (arr[i].second.first != 0)
printf("1 %ld R \n", -1 * arr[i].second.first);
if (flagI && arr[i].second.second != 0)
printf("1 %ld D \n", arr[i].second.second);
else if (arr[i].second.second != 0)
printf("1 %ld U \n", -1 * arr[i].second.second);
printf("3 \n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100005];
bool vis[100005];
int n;
double ans;
void DFS(int u, double p, int d) {
int cnt = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (vis[v] == 1) continue;
cnt++;
}
if (cnt == 0)
ans += d * p;
else {
double pp = 1.0 / cnt;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (vis[v] == 1) continue;
vis[v] = 1;
DFS(v, p * pp, d + 1);
vis[v] = 0;
}
}
}
int main() {
int u, v;
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
vis[1] = 1;
DFS(1, 1, 0);
printf("%.15f\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T1, class T2, class T3, class T4>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
gn(x1, x2, x3), gn(x4);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
gn(x1, x2, x3, x4), gn(x5);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5) {
printsp(x1), printsp(x2), printsp(x3), printsp(x4), println(x5);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int dp[5000000];
int p[3100];
int main() {
int n;
gn(n);
for (int i = 1; i <= n; i++) gn(p[i]);
int val = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
if (p[i] > p[j]) val++;
}
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= val; i++) {
dp[i] = dp[i - 2] + 4;
}
println(dp[val]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[3], b[3];
bool valid() {
int m[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (b[2] % 4 == 0) m[1]++;
return (b[1] >= 1 && b[1] <= 12 && b[0] >= 1 && b[0] <= m[b[1] - 1]);
}
int main() {
int i, j, k;
scanf("%d.%d.%d", &a[0], &a[1], &a[2]);
scanf("%d.%d.%d", &b[0], &b[1], &b[2]);
sort(b, b + 3);
do {
if (valid()) {
if (a[2] - b[2] > 18 ||
a[2] - b[2] == 18 && (a[1] > b[1] || a[1] == b[1] && a[0] >= b[0])) {
puts("YES");
return 0;
}
}
} while (next_permutation(b, b + 3));
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e3 + 3;
long long n, mod = 1e9 + 7, dp[N][N][2];
long long f(long long idx, long long diff, long long stat) {
long long &ret = dp[idx][diff][stat];
if (ret != -1) return ret;
if (idx == n) {
ret = 0;
return ret;
}
ret = 0;
if (stat == 0) {
if (n - idx - 1 >= diff + 1) {
ret =
(f(idx + 1, diff + 1, 0) + (diff > 0 ? f(idx + 1, diff - 1, 0) : 0)) %
mod;
ret = max(ret, (f(idx + 1, diff + 1, 1) + 1 +
(diff > 0 ? f(idx + 1, diff - 1, 0) : 0)) %
mod);
ret = max(ret, (f(idx + 1, diff + 1, 0) +
(diff > 0 ? 1 + f(idx + 1, diff - 1, 1) : 0)) %
mod);
} else {
if (diff > 0)
ret = max(f(idx + 1, diff - 1, 0), 1 + f(idx + 1, diff - 1, 1));
else
ret = 0;
}
} else {
if (n - idx - 1 >= diff + 1) {
ret =
(f(idx + 1, diff + 1, 0) + (diff > 0 ? f(idx + 1, diff - 1, 0) : 0)) %
mod;
} else {
if (diff > 0)
ret = f(idx + 1, diff - 1, 0);
else
ret = 0;
}
}
return ret;
}
int main() {
cin >> n;
n *= 2;
for (long long i = 0; i <= n; i++)
for (long long ii = 0; ii <= n; ii++)
for (long long iii = 0; iii < 2; iii++) dp[i][ii][iii] = -1;
cout << f(0, 0, 0) << "\n";
return 0;
}
| 6 |
/*
ALLAH IS ALMIGHTY ******BISMILLAHIR RAHMANIR RAHIM.****** ALLAH IS ALMIGHTY
```````````````````````````````
AUTHOR: ANISUR RAHAMAN
BSMRSTU(SHIICT)
ID:017
............LET's START OUR JOURNEY.............
*/
#include<bits/stdc++.h>
#define I_O ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define ll long long int
#define lls int64_t
#define ld long double
#define db double
#define ull unsigned long long int
//~~~~~~~~~~~~~~Pair~~~~~~~~~~~~~~~~~~//
#define pi pair<int,int>
#define pl pair<ll,ll>
#define pd pair<db,db>
#define psi pair<string,int>
#define vi vector<int>
#define vl vector<ll>
#define vd vector<db>
#define vb vector<bool>
#define vpi vector<pi>
#define vpl vector<pl>
#define vpd vector<pd>
#define vpsi vector<psi>
//~~~~~~~~~~~~~~Vector~~~~~~~~~~~~~~~~~//
#define pb push_back
#define pf push_front
#define MP make_pair
#define in insert
#define ff first
#define ss second
#define al(v) v.begin(),v.end()
#define alr(v) v.rbegin(), v.rend()
#define min(a, b) (((a) <= (b)) ? (a) : (b))
#define max(a, b) (((a) >= (b)) ? (a) : (b))
#define srt(v) sort(al(v))
#define sz(x) ((ll)(x).size())
#define rev(v) reverse(al(v))
#define acl(v, n) accumulate(al(v), n)
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define tpu(str) transform(al(str), str.begin(), ::toupper)
#define tpl(str) transform(al(str), str.begin(), ::tolower)
#define mxv(v) *max_element(al(v))
#define mnv(v) *min_element(al(v))
const int MOD = 1e9 + 7;
const ll INF = 2e18;
const int mxn = 2e9 + 9;
const int mxd = 2e5 + 5;
//~~~~~~~~~~~~~~~Loops and Short~~~~~~~~~~~~~~~~//
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*b)/gcd(a,b)
#define PI acos(-1)
#define C continue
#define B break
#define off return 0
#define N '\n'
#define rep(i, n) for(lls i = 0; i < n; i++)
#define repn(i, a, b) for(lls i = (lls)(a); i < (lls)(b); i++)
#define repr(i, a, b) for(lls i = (lls)(a) - 1; i >= (lls)(b); i--)
#define test_case() int T; cin >> T; while(T--)
using namespace std;
void SoLuTioN()
{
int n, k;
cin >> n >> k;
vi v(n), va(n);
rep(i, n) cin >> v[i] >> va[i];
rep(i, n){
int f = 0;
rep(j, n){
if(abs(v[i] - v[j]) + abs(va[i] - va[j]) > k){
f = 1;B;
}
}
if(f == 0){
cout << "1" << N;
return;
}
}
cout << "-1" << N;
}
int main()
{
I_O
test_case()
{
SoLuTioN();
}
off;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int a[maxn + 5], L[maxn + 5], prime[maxn + 5], numPrime, X[maxn * 5 + 5],
Y[maxn * 5 + 5], n, num;
bool vis[maxn * 10];
void inti() {
int m = (int)sqrt(maxn + 0.5);
memset(vis, false, sizeof(vis));
vis[1] = true;
for (int i = 2; i <= m; ++i)
if (vis[i] == false)
for (int j = i * i; j <= maxn + 100; j += i) vis[j] = true;
}
void look(int &a, int &b, int G) {
int t1;
t1 = G / 2;
while (true) {
if (vis[t1] == 0 && vis[G - t1] == 0) break;
t1--;
}
a = t1;
b = G - t1;
}
void jud(int a, int b) {
if (a < b) {
X[num] = a;
Y[num] = b;
} else {
X[num] = b;
Y[num] = a;
}
num++;
}
int main() {
inti();
while (scanf("%d", &n) == 1) {
num = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
L[a[i]] = i;
}
for (int i = 1; i <= n; ++i) {
if (L[i] == i) continue;
int L1 = L[i];
int L2 = i;
L[a[i]] = L[i];
L[L2] = L2;
int tt = a[i];
a[i] = i;
a[L1] = tt;
if (vis[L1 - L2 + 1] == 0) {
jud(L2, L1);
continue;
}
if ((L1 - L2) & 1) {
int aa, bb;
look(aa, bb, L1 - L2 + 1);
int L3 = L2 + 1;
int L4 = L3 - 1 + aa;
jud(L2, L3);
jud(L3, L4);
jud(L4, L1);
jud(L3, L4);
jud(L2, L3);
} else {
int aa, bb;
look(aa, bb, L1 - L2 + 2);
int L3 = L2 + aa - 1;
jud(L2, L3);
jud(L3, L1);
jud(L2, L3);
}
}
printf("%d\n", num);
for (int i = 0; i < num; ++i) printf("%d %d\n", X[i], Y[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int i, c = 0, a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n; i++) {
if (c < a[i]) c++;
}
cout << c + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ll c;
cin >> c;
for (ll i = 0; i < c; i++) {
ll n, m, t;
cin >> n >> m >> t;
vector<ll> in(n);
for (ll j = 0; j < n; j++) {
cin >> in[j];
}
auto f = [&](ll x) {
ll res = 0;
ll timeSpend = 0;
ll curDone = 0;
ll curTime = 0;
for (ll i = 0; i < n && timeSpend <= t; i++) {
if (in[i] <= x) {
if (timeSpend + in[i] > t) break;
timeSpend += in[i];
curTime += in[i];
curDone++;
res++;
if (curDone == m) {
timeSpend += curTime;
curDone = 0;
curTime = 0;
}
}
}
return res;
};
auto c = [&](ll x) {
ll res = 0;
for (ll y : in) {
if (y <= x) {
res++;
}
}
return res;
};
ll l = 1;
ll r = t + 1;
while (l + 1 < r) {
ll mid = (l + r) / 2;
if (f(mid) < c(mid)) {
r = mid;
} else {
l = mid;
}
}
if (f(l) >= f(r)) r = l;
cout << f(r) << " " << r << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int p[100005], n, m, color[100005], lab[100005], n_lab;
vector<pair<int, int> > e;
vector<int> G[100005];
bool has_odd_circle(int u) {
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i];
if (color[v] == 0) {
color[v] = -color[u];
if (has_odd_circle(v)) return true;
} else if (color[v] == color[u]) {
return true;
}
}
return false;
}
int root_of(int u) { return p[u] = (u == p[u] ? u : root_of(p[u])); }
void join(int u, int v) {
int s = root_of(u), r = root_of(v);
if (r != s) p[s] = r, n--;
}
int main() {
scanf("%d%d", &n, &m);
for (int u = 1; u <= n; u++) p[u] = u;
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
if (w == 1)
join(u, v);
else
e.push_back(pair<int, int>(u, v));
}
for (int i = 0; i < (int)e.size(); i++) {
int u = root_of(e[i].first), v = root_of(e[i].second);
if (lab[u] == 0) lab[u] = ++n_lab;
if (lab[v] == 0) lab[v] = ++n_lab;
u = lab[u], v = lab[v];
G[u].push_back(v);
G[v].push_back(u);
}
int n_comp = 0;
for (int u = 1; u <= n; u++) {
if (color[u] != 0) continue;
color[u] = 1;
if (has_odd_circle(u)) {
puts("0");
return 0;
}
n_comp++;
}
long long ans = 1;
for (n_comp--; n_comp > 0; n_comp--) {
ans = (ans * 2) % 1000000007;
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int niz[n];
for (int i = 0; i < n; i++) {
cin >> niz[i];
}
int b = sizeof(niz) / sizeof(niz[0]);
sort(niz, niz + b, greater<int>());
cout << niz[k - 1];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long in[101000];
int msb[101000];
int main() {
int n, i, j;
msb[1] = 1;
for (i = 2; i < 101000; i++) msb[i] = msb[i / 2] << 1;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", &in[i]);
long long ans = 0;
for (i = 1; i < n; i++) {
ans += in[i];
in[i + msb[n - i]] += in[i];
printf("%I64d\n", ans);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int t;
double r, v, f, s;
int check(double t) {
double dis = v * t;
double len = fmod(dis, 2 * pi * r);
double k = len / r / 2.0;
double dis2 = 2.0 * abs(sin(k)) * r;
if (dis + dis2 > f - s) return 1;
return 0;
}
int main() {
scanf("%d", &t);
cin >> r >> v;
while (t--) {
scanf("%lf%lf", &s, &f);
double l = 0.0, r = 1999999999.0;
for (int i = 0; i < 100; i++) {
double mid = (l + r) / 2.0;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.15f\n", l);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
struct st {
int n;
vector<int> t;
st(int sz) {
n = sz;
t = vector<int>(2 * n, -1);
}
void upd(int pos, int val) {
for (t[pos += n] = val; pos > 1; pos >>= 1) {
t[pos >> 1] = min(t[pos], t[pos ^ 1]);
}
}
int qry(int l, int r) {
int res = n;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (r & 1) res = min(res, t[--r]);
}
return res;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n];
bool all_one = true;
vector<vector<int>> at(n, vector<int>(1, -1));
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
if (a[i] > 0) all_one = false;
at[a[i]].push_back(i);
}
if (all_one) {
cout << 1 << '\n';
return 0;
}
vector<pair<int, int>> qry;
for (int i = 0; i < n; i++) {
at[i].push_back(n);
if (at[i].size() == 2) continue;
for (int j = 1; j < at[i].size(); j++) {
qry.push_back({at[i][j - 1], at[i][j]});
}
}
sort(qry.begin(), qry.end(), cmp);
vector<bool> vis(n + 2);
vis[0] = 1;
st rmq(n);
for (int q = 0; q < qry.size(); q++) {
int l = qry[q].first;
int r = qry[q].second;
int cur;
if (0 <= l && l < n) cur = a[l];
if (0 <= r && r < n) cur = a[r];
if (cur) {
int small = rmq.qry(0, cur);
if (l < small) vis[cur] = 1;
}
if (r < n) rmq.upd(a[r], r);
}
vector<bool> avail(n + 1);
for (int i = 0; i < n; i++) avail[a[i]] = 1;
for (int i = 0; i <= n; i++) {
if (!avail[i]) {
vis[i] = 1;
break;
}
}
for (int i = 0; i < n + 2; i++) {
if (!vis[i]) {
cout << i + 1 << '\n';
break;
}
}
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:640000000")
using namespace std;
int Set(int n, int pos) { return n = n | (1 << pos); }
int reset(int n, int pos) { return n = n & ~(1 << pos); }
bool check(int n, int pos) { return (bool)(n & (1 << pos)); }
long long int power(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0) {
long long int y = power(x, n / 2);
return y * y;
} else
return x * power(x, n - 1);
}
int strTOint(string s) {
stringstream second;
int x;
second << s;
second >> x;
return x;
}
double geo_dist(int a, int b, int c, int d) {
double dd = (double)(a - c) * (a - c) + (b - d) * (b - d);
double r = sqrt(dd) + 1e-9;
return r;
}
long long int bigmod(long long int a, long long int p, long long int m) {
if (p == 0) return 1 % m;
if (p % 2 == 0) {
long long int y = bigmod(a, p / 2, m);
return (y * y) % m;
} else {
return (a * bigmod(a, p - 1, m)) % m;
}
}
long long int euclid_x, euclid_y, euclid_d, euclid_g;
void ext_gcd(long long int a, long long int b) {
if (b == 0) {
euclid_x = 1;
euclid_y = 0;
euclid_d = a;
return;
}
ext_gcd(b, a % b);
long long int x1 = euclid_y;
long long int y1 = euclid_x - (a / b) * euclid_y;
euclid_x = x1;
euclid_y = y1;
}
long long int modInv(long long int a, long long int m) {
ext_gcd(a, m);
euclid_x %= m;
if (euclid_x < 0) euclid_x += m;
return euclid_x;
}
vector<int> num;
void input(string s) {
istringstream second(s);
int n;
while (second >> n) {
num.push_back(n);
}
}
int fx[] = {0, 0, -1, 1, -1, 1, 1, -1};
int fy[] = {1, -1, 0, 0, 1, 1, -1, -1};
map<string, int> mp;
vector<long long int> v, usb, ps2, both;
int main() {
long long int a, b, c;
cin >> a >> b >> c;
long long int m;
cin >> m;
for (long long int i = 0; i < m; i++) {
long long int x;
string y;
cin >> x >> y;
if (y == "USB")
usb.push_back(x);
else
ps2.push_back(x);
}
sort(usb.begin(), usb.end());
sort(ps2.begin(), ps2.end());
long long int ans = 0, cost = 0;
for (int i = 0; i < usb.size(); i++) {
if (a == 0) {
both.push_back(usb[i]);
continue;
}
ans++;
cost += usb[i];
a--;
}
for (int i = 0; i < ps2.size(); i++) {
if (b == 0) {
both.push_back(ps2[i]);
continue;
}
ans++;
cost += ps2[i];
b--;
}
sort(both.begin(), both.end());
for (int i = 0; i < both.size(); i++) {
if (c == 0) {
break;
}
ans++;
cost += both[i];
c--;
}
cout << ans << " " << cost << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long null = 0;
struct segment;
struct line;
struct point;
struct vec;
struct ray;
struct point {
long double x, y;
point() {}
point(long double x1, long double y1) {
x = x1;
y = y1;
}
long double dist_to_point(point p) {
return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
}
bool operator<(point p) { return (x < p.x) || ((x == p.x) && (y < p.y)); }
};
struct vec {
long double x, y;
vec(long double x1, long double y1) {
x = x1;
y = y1;
}
vec(point a, point b) {
x = b.x - a.x;
y = b.y - a.y;
}
vec normal() {
vec ans;
ans.x = y;
ans.y = -x;
return ans;
}
vec opposite() {
vec ans;
ans.x = -x;
ans.y = -y;
return ans;
}
vec sum(vec b) {
vec ans;
ans.x = x + b.x;
ans.y = y + b.y;
return ans;
}
long double cross_product(vec v) { return x * v.y - v.x * y; }
long double dot_product(vec v) { return x * v.x + y * v.y; }
vec resize(long double size) {
vec ans;
ans.x = (x * size) / len();
ans.y = (y * size) / len();
return ans;
}
vec() {}
long double len() { return sqrt(x * x + y * y); }
};
struct line {
long double a, b, c;
line(point a1, point b1) {
a = a1.y - b1.y;
b = b1.x - a1.x;
c = -a1.x * a - a1.y * b;
}
line(long double a1, long double b1, long double c1) {
a = a1;
b = b1;
c = c1;
}
line() {}
vec normal_vec() {
vec ans;
ans.x = a;
ans.y = b;
return ans;
}
line normal_line(point p) {
line ans;
ans.a = -b;
ans.b = a;
ans.c = -ans.a * p.x - ans.b * p.y;
return ans;
}
long double get_x(long double y1) {
if (a == 0) return 0;
return (-c - b * y1) / a;
}
long double get_y(long double x1) {
if (b == 0) return 0;
return (-c - a * x1) / b;
}
point intersection(line l) {
point ans;
ans.x = (-c * l.b + l.c * b) / (a * l.b - l.a * b);
ans.y = (-a * l.c + l.a * c) / (a * l.b - l.a * b);
return ans;
}
bool parallels(line l) { return a * l.b - l.a * b == 0; }
long double dist_to_point(point p) {
return abs((a * p.x + b * p.y + c) / (sqrt(a * a + b * b)));
}
long long is_inside(point p) {
long double k = a * p.x + b * p.y + c;
if (k < 0)
return -1;
else if (k == 0)
return 0;
return 1;
}
};
struct segment {
point a, b;
segment() {}
segment(point a1, point b1) {
a = a1;
b = b1;
}
long double len() {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool is_inside(point p) {
line l(a, b);
if (l.is_inside(p) != 0) return false;
vec v(p, a), v1(p, b);
if (v.dot_product(v1) > 0) return false;
return true;
}
long double dist_to_point(point p) {
vec v(a, p), v1(a, b), v2(b, p), v3(b, a);
if (v.dot_product(v1) < 0) return p.dist_to_point(a);
if (v2.dot_product(v3) < 0) return p.dist_to_point(b);
line l(a, b);
return l.dist_to_point(p);
}
point get_center() {
point ans;
ans.x = (a.x + b.x) / 2;
ans.y = (a.y + b.y) / 2;
return ans;
}
};
struct ray {
point a, b;
ray(point p, point p1) {
a = p;
b = p1;
}
ray() {}
long double dist_to_point(point p) {
vec v(a, p), v1(a, b);
if (v.dot_product(v1) < 0) return a.dist_to_point(p);
line l(a, b);
return l.dist_to_point(p);
}
bool is_inside(point p) {
line l(a, b);
if (l.is_inside(p) != 0) return false;
vec v(a, p), v1(a, b);
if (v.dot_product(v1) < 0) return false;
return true;
}
};
struct angle {
point a, b, c;
angle(){};
angle(point a1, point b1, point c1) {
a = a1;
b = b1;
c = c1;
}
long double get_angle() {
vec v(b, a), v1(b, c);
return acos(v.dot_product(v1) / (v.len() * v1.len()));
}
long double get_grad_angle() {
vec v(b, a), v1(b, c);
return 180 * acos(v.dot_product(v1) / (v.len() * v1.len())) /
3.141592653589793238462643;
}
};
struct polygon {
long long n;
vector<point> points;
long double get_area() {
point a(0, 0);
vec v(a, points[0]);
long double ans = 0;
for (long long i = 1; i < n; ++i) {
vec v1(a, points[i]);
ans = ans + v.cross_product(v1);
v = v1;
}
vec v2(a, points[0]);
vec v1(a, points[n - 1]);
return abs(ans + v1.cross_product(v2)) / 2;
}
};
struct triangle {
point a, b, c;
triangle() {}
triangle(point a1, point b1, point c1) {
a = a1;
b = b1;
c = c1;
}
long double get_area() {
point d(0, 0);
vec v(a, d), v1(b, d), v2(c, d);
return (v.cross_product(v1) + v1.cross_product(v2) + v2.cross_product(v)) /
2;
}
point get_center() {
segment s(a, b), s1(a, c);
point p = s.get_center(), p1 = s1.get_center();
line l(a, b), l1(a, c), l2(b, c);
l = l.normal_line(p);
l1 = l1.normal_line(p1);
return l.intersection(l1);
}
long double get_R() {
triangle t(a, b, c);
point p = t.get_center();
return p.dist_to_point(a);
}
};
long long power(long long a, long long b) {
if (b == 0)
return 1;
else if (b == 1)
return a;
else {
long long k = power(a, b / 2);
return k * k * power(a, b % 2);
}
}
long long power_mod(long long a, long long b, long long MOD) {
if (b == 0)
return 1;
else if (b == 1)
return a % MOD;
else {
long long k = power_mod(a, b / 2, MOD);
return ((k * k) % MOD * power_mod(a, b % 2, MOD)) % MOD;
}
}
long long sum_mod(long long a, long long b, long long MOD) {
return (a + b) % MOD;
}
long long mul_mod(long long a, long long b, long long MOD) {
return (a * b) % MOD;
}
long long ord(char a) { return a; }
char chr(long long a) { return a; }
long long strtoint(string s) {
long long ans = 0;
for (long long i = 0; i < s.size(); ++i) {
ans *= 10;
ans += ord(s[i]) - 48;
}
return ans;
}
string rev_string(string s) {
string ans = "";
for (long long i = s.size(); i >= 0; --i) {
ans += s[i];
}
return ans;
}
string inttostr(long long a) {
string ans = "", ans1 = "";
while (a > 0) {
ans += chr(a % 10 + 48);
a /= 10;
}
for (long long i = ans.size() - 1; i >= 0; --i) {
ans1 += ans[i];
}
return ans1;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long nok(long long a, long long b) { return a * b / gcd(a, b); }
vector<pair<long long, long long> > ar;
long long ans[200000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; ++i) {
long long a;
cin >> a;
ar.push_back(make_pair(a, i));
}
sort(ar.begin(), ar.end());
long long k = 0;
for (long long i = 0; i < n; ++i) {
ans[ar[i].second] = k % 2;
++k;
}
for (long long i = 0; i < n; ++i) {
cout << ans[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
vector<pair<int, int> > a;
cin >> n;
cin >> x;
a.push_back(make_pair(x, 1));
for (int i = (2); i <= (n); ++i) {
cin >> x;
if (x != a.back().first) a.push_back(make_pair(x, i));
}
n = (int)(a).size();
for (int i = (1); i <= (n - 2); ++i)
if ((a[i - 1].first < a[i].first) != (a[i].first < a[i + 1].first)) {
printf("3\n%d %d %d\n", a[i - 1].second, a[i].second, a[i + 1].second);
return 0;
}
printf("0\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
using namespace std;
int n;
cin >> n;
int *a = new int[n];
int *b = new int[n];
for (int i = 0; i < n; ++i) cin >> a[i];
b[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; --i) b[i] = a[i] + a[i + 1];
for (int i = 0; i < n; ++i) cout << b[i] << ' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
vector<int> p, ne, ze;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] > 0) p.push_back(i);
if (a[i] == 0) ze.push_back(i);
if (a[i] < 0) ne.push_back(i);
}
for (int i = 0; p.size() > 1 && i < p.size() - 1; ++i) {
cout << 1 << ' ';
cout << p[i] << ' ' << p.back() << endl;
}
int maxn = 0, pos;
if (ne.size() & 1) {
for (int i = 0; i < ne.size(); ++i) {
if (!i || a[ne[i]] > maxn) {
maxn = a[ne[i]];
pos = ne[i];
}
}
ne.erase(find(ne.begin(), ne.end(), pos));
ze.push_back(pos);
sort(ze.begin(), ze.end());
}
for (int i = 0; ne.size() > 1 && i < ne.size() - 1; ++i) {
cout << 1 << ' ';
cout << ne[i] << ' ' << ne.back() << endl;
}
for (int i = 0; ze.size() > 1 && i < ze.size() - 1; ++i) {
cout << 1 << ' ';
cout << ze[i] << ' ' << ze.back() << endl;
}
if (ne.size() && p.size()) {
cout << 1 << ' ';
cout << min(p.back(), ne.back()) << ' ' << max(p.back(), ne.back()) << endl;
}
if ((p.size() || ne.size()) && ze.size()) {
cout << 2 << ' ' << ze.back() << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<pair<long long, long long>, long long> arr[1004];
vector<pair<long long, long long> > v[1004];
long long n, m, w, a, b, sumb[1004], sumw[1004], dp[1004][1004];
long long froot(long long a) {
long long i = a;
while (arr[i].second != i) {
i = arr[i].second;
}
return i;
}
bool find(long long a, long long b) {
long long roota = froot(a);
long long rootb = froot(b);
if (roota == rootb) return true;
return false;
}
void _union(long long a, long long b) {
long long roota = froot(a);
long long rootb = froot(b);
arr[roota].second = rootb;
}
long long solve(long long idx, long long wgt) {
if (wgt > w) return INT_MIN;
if (idx == 1001) return 0;
if (dp[idx][wgt] != -1) return dp[idx][wgt];
long long res = INT_MIN;
for (long long i = 0; i < v[idx].size(); i++)
res = max(res, v[idx][i].second + solve(idx + 1, wgt + v[idx][i].first));
res = max(res, sumb[idx] + solve(idx + 1, wgt + sumw[idx]));
return dp[idx][wgt] = max(res, solve(idx + 1, wgt));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof(dp));
cin >> n >> m >> w;
for (long long i = 0; i < n; i++) cin >> arr[i].first.first;
for (long long i = 0; i < n; i++)
cin >> arr[i].first.second, arr[i].second = i;
for (long long i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
_union(a, b);
}
long long k;
for (long long i = 0; i < n; i++) {
k = froot(arr[i].second);
v[k].push_back(make_pair(arr[i].first.first, arr[i].first.second));
sumw[k] += arr[i].first.first;
sumb[k] += arr[i].first.second;
}
cout << solve(0, 0);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> p(n);
for (int i = 0; i < m; ++i) {
int pos;
cin >> pos;
p[pos - 1] = 1;
}
while (true) {
bool flag = false;
for (int i = 0; i < n; i++) {
if (p[i] && a[i] > a[i + 1]) {
flag = true;
swap(a[i], a[i + 1]);
}
}
if (!flag) break;
}
bool possible = true;
for (int i = 0; i < n - 1; i++) {
possible &= (a[i] <= a[i + 1]);
}
if (possible)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int sum[4010], dp[30000010], n;
inline int read() {
int s = 0, w = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') w = -1;
for (; isdigit(c); c = getchar()) s = (s << 1) + (s << 3) + (c ^ 48);
return s * w;
}
int Hash(int a, int b, int c, int d) {
return ((((a * 4000ll) + b) * 100 + c) * 2 + d) % 29999999;
}
int dfs(int l, int r, int x, int k) {
if (r - l + 1 < x) return 0;
if (r - l + 1 == x) return (sum[r] - sum[l - 1]) * (k ? -1 : 1);
int sta = Hash(l, r, x, k);
if (~dp[sta]) return dp[sta];
int ans = 0;
if (k) {
ans = dfs(l, r - x, x, 0) - (sum[r] - sum[r - x + 1 - 1]);
if (l <= r - x)
ans = min(ans, dfs(l, r - x - 1, x + 1, 0) - (sum[r] - sum[r - x - 1]));
return dp[sta] = ans;
} else {
ans = dfs(l + x, r, x, 1) + (sum[l + x - 1] - sum[l - 1]);
if (l + x <= r)
ans = max(ans, dfs(l + x + 1, r, x + 1, 1) + (sum[l + x] - sum[l - 1]));
return dp[sta] = ans;
}
}
int main() {
n = read();
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; ++i) sum[i] = read(), sum[i] += sum[i - 1];
printf("%d\n", dfs(1, n, 1, 0));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef struct xx {
long long val;
long long op;
struct xx *right, *left;
} node;
node* nnode() {
node* temp = (node*)malloc(sizeof(node));
temp->val = -1;
temp->op = -1;
temp->left = NULL;
temp->right = NULL;
return temp;
}
long long dfs(node* root, long long depth) {
if (depth == 0) {
long long x;
cin >> x;
root->val = x;
return x;
}
root->left = nnode();
root->left->op = root->op ^ 1;
root->right = nnode();
root->right->op = root->op ^ 1;
long long a = dfs(root->left, depth - 1);
long long b = dfs(root->right, depth - 1);
if (root->op == 1)
root->val = a | b;
else
root->val = a ^ b;
return root->val;
}
long long hi;
long long update(node* root, long long x, long long y, long long temp) {
if (temp == 0) {
root->val = y;
return y;
}
if (x > temp) {
long long a = update(root->right, x - temp, y, temp / 2);
if (root->op == 1)
root->val = (root->left->val) | a;
else
root->val = (root->left->val) ^ a;
return root->val;
} else {
long long a = update(root->left, x, y, temp / 2);
if (root->op == 1)
root->val = (root->right->val) | a;
else
root->val = (root->right->val) ^ a;
return root->val;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
hi = 1 << n;
node* root = nnode();
if (n % 2 == 1)
root->op = 1;
else
root->op = 0;
long long temp = dfs(root, n);
while (m--) {
long long x, y;
cin >> x >> y;
cout << update(root, x, y, hi / 2) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <int mod> struct ModInt {
#if __cplusplus >= 201402L
#define MDCONST constexpr
#else
#define MDCONST
#endif
using lint = long long;
MDCONST static int get_mod() { return mod; }
static int get_primitive_root() {
static int primitive_root = 0;
if (!primitive_root) {
primitive_root = [&]() {
std::set<int> fac;
int v = mod - 1;
for (lint i = 2; i * i <= v; i++)
while (v % i == 0) fac.insert(i), v /= i;
if (v > 1) fac.insert(v);
for (int g = 1; g < mod; g++) {
bool ok = true;
for (auto i : fac)
if (ModInt(g).pow((mod - 1) / i) == 1) {
ok = false;
break;
}
if (ok) return g;
}
return -1;
}();
}
return primitive_root;
}
int val;
MDCONST ModInt() : val(0) {}
MDCONST ModInt &_setval(lint v) { return val = (v >= mod ? v - mod : v), *this; }
MDCONST ModInt(lint v) { _setval(v % mod + mod); }
MDCONST explicit operator bool() const { return val != 0; }
MDCONST ModInt operator+(const ModInt &x) const { return ModInt()._setval((lint)val + x.val); }
MDCONST ModInt operator-(const ModInt &x) const { return ModInt()._setval((lint)val - x.val + mod); }
MDCONST ModInt operator*(const ModInt &x) const { return ModInt()._setval((lint)val * x.val % mod); }
MDCONST ModInt operator/(const ModInt &x) const { return ModInt()._setval((lint)val * x.inv() % mod); }
MDCONST ModInt operator-() const { return ModInt()._setval(mod - val); }
MDCONST ModInt &operator+=(const ModInt &x) { return *this = *this + x; }
MDCONST ModInt &operator-=(const ModInt &x) { return *this = *this - x; }
MDCONST ModInt &operator*=(const ModInt &x) { return *this = *this * x; }
MDCONST ModInt &operator/=(const ModInt &x) { return *this = *this / x; }
friend MDCONST ModInt operator+(lint a, const ModInt &x) { return ModInt()._setval(a % mod + x.val); }
friend MDCONST ModInt operator-(lint a, const ModInt &x) { return ModInt()._setval(a % mod - x.val + mod); }
friend MDCONST ModInt operator*(lint a, const ModInt &x) { return ModInt()._setval(a % mod * x.val % mod); }
friend MDCONST ModInt operator/(lint a, const ModInt &x) { return ModInt()._setval(a % mod * x.inv() % mod); }
MDCONST bool operator==(const ModInt &x) const { return val == x.val; }
MDCONST bool operator!=(const ModInt &x) const { return val != x.val; }
MDCONST bool operator<(const ModInt &x) const { return val < x.val; } // To use std::map<ModInt, T>
friend std::istream &operator>>(std::istream &is, ModInt &x) {
lint t;
return is >> t, x = ModInt(t), is;
}
MDCONST friend std::ostream &operator<<(std::ostream &os, const ModInt &x) { return os << x.val; }
MDCONST ModInt pow(lint n) const {
lint ans = 1, tmp = this->val;
while (n) {
if (n & 1) ans = ans * tmp % mod;
tmp = tmp * tmp % mod, n /= 2;
}
return ans;
}
static std::vector<long long> facs, invs;
MDCONST static void _precalculation(int N) {
int l0 = facs.size();
if (N <= l0) return;
facs.resize(N), invs.resize(N);
for (int i = l0; i < N; i++) facs[i] = facs[i - 1] * i % mod;
long long facinv = ModInt(facs.back()).pow(mod - 2).val;
for (int i = N - 1; i >= l0; i--) {
invs[i] = facinv * facs[i - 1] % mod;
facinv = facinv * i % mod;
}
}
MDCONST lint inv() const {
if (this->val < 1 << 20) {
while (this->val >= int(facs.size())) _precalculation(facs.size() * 2);
return invs[this->val];
} else {
return this->pow(mod - 2).val;
}
}
MDCONST ModInt fac() const {
while (this->val >= int(facs.size())) _precalculation(facs.size() * 2);
return facs[this->val];
}
MDCONST ModInt doublefac() const {
lint k = (this->val + 1) / 2;
return (this->val & 1) ? ModInt(k * 2).fac() / (ModInt(2).pow(k) * ModInt(k).fac()) : ModInt(k).fac() * ModInt(2).pow(k);
}
MDCONST ModInt nCr(const ModInt &r) const { return (this->val < r.val) ? 0 : this->fac() / ((*this - r).fac() * r.fac()); }
ModInt sqrt() const {
if (val == 0) return 0;
if (mod == 2) return val;
if (pow((mod - 1) / 2) != 1) return 0;
ModInt b = 1;
while (b.pow((mod - 1) / 2) == 1) b += 1;
int e = 0, m = mod - 1;
while (m % 2 == 0) m >>= 1, e++;
ModInt x = pow((m - 1) / 2), y = (*this) * x * x;
x *= (*this);
ModInt z = b.pow(m);
while (y != 1) {
int j = 0;
ModInt t = y;
while (t != 1) j++, t *= t;
z = z.pow(1LL << (e - j - 1));
x *= z, z *= z, y *= z;
e = j;
}
return ModInt(std::min(x.val, mod - x.val));
}
};
template <int mod> std::vector<long long> ModInt<mod>::facs = {1};
template <int mod> std::vector<long long> ModInt<mod>::invs = {0};
// Integer convolution for arbitrary mod
// with NTT (and Garner's algorithm) for ModInt / ModIntRuntime class.
// We skip Garner's algorithm if `skip_garner` is true or mod is in `nttprimes`.
// input: a (size: n), b (size: m)
// return: vector (size: n + m - 1)
template <typename MODINT> std::vector<MODINT> nttconv(std::vector<MODINT> a, std::vector<MODINT> b, bool skip_garner = false);
constexpr int nttprimes[3] = {998244353, 167772161, 469762049};
// Integer FFT (Fast Fourier Transform) for ModInt class
// (Also known as Number Theoretic Transform, NTT)
// is_inverse: inverse transform
// ** Input size must be 2^n **
template <typename MODINT> void ntt(std::vector<MODINT> &a, bool is_inverse = false) {
int n = a.size();
if (n == 1) return;
static const int mod = MODINT::get_mod();
static const MODINT root = MODINT::get_primitive_root();
assert(__builtin_popcount(n) == 1 and (mod - 1) % n == 0);
static std::vector<MODINT> w{1}, iw{1};
for (int m = w.size(); m < n / 2; m *= 2) {
MODINT dw = root.pow((mod - 1) / (4 * m)), dwinv = 1 / dw;
w.resize(m * 2), iw.resize(m * 2);
for (int i = 0; i < m; i++) w[m + i] = w[i] * dw, iw[m + i] = iw[i] * dwinv;
}
if (!is_inverse) {
for (int m = n; m >>= 1;) {
for (int s = 0, k = 0; s < n; s += 2 * m, k++) {
for (int i = s; i < s + m; i++) {
MODINT x = a[i], y = a[i + m] * w[k];
a[i] = x + y, a[i + m] = x - y;
}
}
}
} else {
for (int m = 1; m < n; m *= 2) {
for (int s = 0, k = 0; s < n; s += 2 * m, k++) {
for (int i = s; i < s + m; i++) {
MODINT x = a[i], y = a[i + m];
a[i] = x + y, a[i + m] = (x - y) * iw[k];
}
}
}
int n_inv = MODINT(n).inv();
for (auto &v : a) v *= n_inv;
}
}
template <int MOD> std::vector<ModInt<MOD>> nttconv_(const std::vector<int> &a, const std::vector<int> &b) {
int sz = a.size();
assert(a.size() == b.size() and __builtin_popcount(sz) == 1);
std::vector<ModInt<MOD>> ap(sz), bp(sz);
for (int i = 0; i < sz; i++) ap[i] = a[i], bp[i] = b[i];
ntt(ap, false);
if (a == b)
bp = ap;
else
ntt(bp, false);
for (int i = 0; i < sz; i++) ap[i] *= bp[i];
ntt(ap, true);
return ap;
}
long long garner_ntt_(int r0, int r1, int r2, int mod) {
using mint2 = ModInt<nttprimes[2]>;
static const long long m01 = 1LL * nttprimes[0] * nttprimes[1];
static const long long m0_inv_m1 = ModInt<nttprimes[1]>(nttprimes[0]).inv();
static const long long m01_inv_m2 = mint2(m01).inv();
int v1 = (m0_inv_m1 * (r1 + nttprimes[1] - r0)) % nttprimes[1];
auto v2 = (mint2(r2) - r0 - mint2(nttprimes[0]) * v1) * m01_inv_m2;
return (r0 + 1LL * nttprimes[0] * v1 + m01 % mod * v2.val) % mod;
}
template <typename MODINT> std::vector<MODINT> nttconv(std::vector<MODINT> a, std::vector<MODINT> b, bool skip_garner) {
int sz = 1, n = a.size(), m = b.size();
while (sz < n + m) sz <<= 1;
if (sz <= 16) {
std::vector<MODINT> ret(n + m - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) ret[i + j] += a[i] * b[j];
}
return ret;
}
int mod = MODINT::get_mod();
if (skip_garner or std::find(std::begin(nttprimes), std::end(nttprimes), mod) != std::end(nttprimes)) {
a.resize(sz), b.resize(sz);
if (a == b) {
ntt(a, false);
b = a;
} else
ntt(a, false), ntt(b, false);
for (int i = 0; i < sz; i++) a[i] *= b[i];
ntt(a, true);
a.resize(n + m - 1);
} else {
std::vector<int> ai(sz), bi(sz);
for (int i = 0; i < n; i++) ai[i] = a[i].val;
for (int i = 0; i < m; i++) bi[i] = b[i].val;
auto ntt0 = nttconv_<nttprimes[0]>(ai, bi);
auto ntt1 = nttconv_<nttprimes[1]>(ai, bi);
auto ntt2 = nttconv_<nttprimes[2]>(ai, bi);
a.resize(n + m - 1);
for (int i = 0; i < n + m - 1; i++) { a[i] = garner_ntt_(ntt0[i].val, ntt1[i].val, ntt2[i].val, mod); }
}
return a;
}
//////////////////////// TEMPLATE ENDS ////////////////////////
using mint = ModInt<998244353>;
int main() {
int N, K;
cin >> N >> K;
vector<int> L(N);
for (auto &l : L) cin >> l;
const mint lsum = accumulate(L.begin(), L.end(), mint(0));
using P = pair<int, vector<vector<mint>>>;
priority_queue<P, vector<P>, greater<P>> pque;
for (auto Li : L) {
vector<vector<mint>> tmp{{1}, {0}};
for (int pi = 1; pi * K < Li; pi++) {
mint b = mint(Li - K * pi);
tmp[0].push_back(b.pow(pi) / mint(pi).fac());
tmp[1].push_back(b.pow(pi - 1) / mint(pi - 1).fac());
}
pque.emplace(tmp.size() * tmp[0].size(), tmp);
}
// 2D convolution
while (pque.size() > 1) {
auto [d1_, f1] = pque.top();
pque.pop();
auto [d2_, f2] = pque.top();
pque.pop();
int D = int(f1[0].size() + f2[0].size()) - 1;
vector<vector<mint>> f(f1.size() + f2.size() - 1, vector<mint>(D));
for (int d1 = 0; d1 < int(f1.size()); d1++) {
for (int d2 = 0; d2 < int(f2.size()); d2++) {
auto v = nttconv(f1[d1], f2[d2]);
for (int i = 0; i < D; i++) f[d1 + d2][i] += v[i];
}
}
pque.emplace(f.size() * f[0].size(), f);
}
const auto v = pque.top().second;
mint ret = 0;
for (int q = 1; q < int(v[0].size()); q++) {
for (int d = 0; d < min(q + 1, int(v.size())); d++) {
ret -= mint(-1).pow(q) * lsum / mint(K * q).pow(q + 1 - d) * mint(q - d).fac() * v[d][q];
}
}
cout << ret << '\n';
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l, r;
cin >> l >> r;
if (2 * l > r)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char buff[200100];
int main() {
long long n;
cin >> n >> buff;
map<char, char> o;
set<char> in;
o['U'] = 'D';
o['D'] = 'U';
o['L'] = 'R';
o['R'] = 'L';
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (in.find(o[buff[i]]) != in.end()) {
ans++;
in.clear();
}
in.insert(buff[i]);
}
if (in.size() > 0) ans++;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, z, p = 0LL, i, a, c = 0;
cin >> x;
while (x % 10 == 0) {
x = x / 10;
}
y = x;
a = x;
while (a != 0) {
c++;
a /= 10;
}
i = c - 1;
while (y != 0) {
z = y % 10;
p = p + (long long)z * (long long)pow(10, i);
y /= 10;
i--;
}
if (p == x)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t[100][100] = {0};
int n;
scanf(" %d", &n);
for (int i = 0; i < n; ++i) {
int x1, y1, x2, y2;
scanf(" %d %d %d %d", &x1, &y1, &x2, &y2);
x1--;
y1--;
x2--;
y2--;
for (int j = x1; j <= x2; ++j) {
for (int k = y1; k <= y2; ++k) {
t[j][k]++;
}
}
}
int ans = 0;
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 100; ++j) {
ans += t[i][j];
}
}
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 12, L = 1e6 + 2;
const long double eps = 0.2, eps2 = 0.0001;
const int INF = (int)1e9 + 7, MOD = INF;
const long long LINF = 1e18;
const double PI = acos(-1.0);
int n, k, v;
int a[N];
int d[N][N];
pair<int, int> ops[N];
bool rucksack() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
d[i][j] = -1;
}
}
d[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
if (d[i][j] != -1) {
d[i + 1][j] = 0;
}
int prev = (k + j - (a[i] % k)) % k;
if (d[i][prev] != -1) {
d[i + 1][j] = 1;
}
}
}
return d[n][v % k] != -1;
}
int main() {
scanf("%d%d%d", &n, &k, &v);
long long s = 0;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
s += a[i];
}
if (s < v || !rucksack()) {
printf("NO");
return 0;
}
vector<int> used;
printf("YES\n");
int vol = v % k;
int fst = 0;
for (int i = n; i > 0; i--) {
if (d[i][vol] > 0) {
used.push_back(i - 1);
vol = ((k - a[i - 1] % k) + vol) % k;
}
}
long long inFirst = 0;
if (!used.empty()) {
fst = used[0];
inFirst = a[fst];
for (int i = 1; i < used.size(); i++) {
ops[used[i]].first = used[0];
ops[used[i]].second = (a[used[i]] + k - 1) / k;
inFirst += a[used[i]];
a[used[i]] = 0;
}
if (inFirst > v) {
int to = (used[0] & 1) ^ 1;
ops[used[0]].first = to;
ops[used[0]].second = (inFirst - v) / k;
}
} else {
printf("%d 1 2\n", (a[0] + k - 1) / k);
a[1] += a[0];
a[0] = 0;
}
int snd = -1;
long long inSecond = 0;
if (inFirst < v) {
for (int i = 0; i < n; i++) {
if (a[i] == 0 || i == fst) {
continue;
}
if (snd == -1) {
snd = i;
inSecond = a[i];
continue;
}
ops[i].first = snd;
ops[i].second += (a[i] + k - 1) / k;
inSecond += a[i];
}
ops[snd].first = fst;
ops[snd].second = (v - inFirst) / k;
}
for (int i = 0; i < n; i++) {
if (i != fst && ops[i].second > 0 && i != snd) {
printf("%d %d %d\n", ops[i].second, i + 1, ops[i].first + 1);
}
}
if (ops[fst].second > 0) {
printf("%d %d %d", ops[fst].second, fst + 1, ops[fst].first + 1);
}
if (snd > -1) {
printf("%d %d %d", ops[snd].second, snd + 1, ops[snd].first + 1);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
int a1;
cin >> a1;
for (int TT = 0; TT < a1; TT++) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int i = n - 1;
long long int ans = 0;
int mi = INT_MAX;
while (i >= 0) {
mi = min(mi, a[i]);
if (i > 0 && a[i] < a[i - 1]) {
int j = i - 1;
while (j > 0 && a[j] < a[j - 1]) j--;
ans += (a[j] - mi);
mi = a[j];
i = j;
}
i--;
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
struct node {
int u1, v1, u2, v2, id;
} a[N * 4];
int n, m, k, q, sum[N * 4];
bool ans[N];
vector<int> h[N], l[N];
bool cmp(node a, node b) { return a.u2 < b.u2; }
bool cmp1(node a, node b) { return a.v2 < b.v2; }
void update(int p, int l, int r, int y, int z) {
if (l == r) {
sum[p] = z;
return;
}
int mid = (l + r) >> 1;
if (y <= mid)
update(p * 2, l, mid, y, z);
else
update(p * 2 + 1, mid + 1, r, y, z);
sum[p] = min(sum[p * 2], sum[p * 2 + 1]);
}
int query(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return sum[p];
int mid = (l + r) >> 1, res = 1e9;
if (L <= mid) res = min(res, query(p * 2, l, mid, L, R));
if (R > mid) res = min(res, query(p * 2 + 1, mid + 1, r, L, R));
return res;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
h[x].push_back(y);
l[y].push_back(x);
}
for (int i = 1; i <= q; i++) {
scanf("%d%d%d%d", &a[i].u1, &a[i].v1, &a[i].u2, &a[i].v2);
a[i].id = i;
}
sort(a + 1, a + q + 1, cmp);
int x = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < h[i].size(); j++) {
int k = h[i][j];
update(1, 1, max(n, m), k, i);
}
while (x <= q && a[x].u2 == i) {
int res = query(1, 1, max(n, m), a[x].v1, a[x].v2);
if (res >= a[x].u1) ans[a[x].id] = 1;
x++;
}
}
memset(sum, 0, sizeof(sum));
sort(a + 1, a + q + 1, cmp1);
x = 1;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < l[i].size(); j++) {
int k = l[i][j];
update(1, 1, max(n, m), k, i);
}
while (x <= q && a[x].v2 == i) {
int res = query(1, 1, max(n, m), a[x].u1, a[x].u2);
if (res >= a[x].v1) ans[a[x].id] = 1;
x++;
}
}
for (int i = 1; i <= q; i++) {
if (ans[i])
puts("YES");
else
puts("NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (const auto &x : v) os << x << " ";
return os << endl;
}
ll ceil_div(ll a, ll b) { return (a + b - 1) / b; }
constexpr ll MOD = 1e9 + 7;
ll fact(int n) {
ll ans = 1;
for (int i = 1; i <= n; i++) ans = (ans * i) % MOD;
return ans;
}
void solve() {
int n, x, pos;
cin >> n >> x >> pos;
int lo = 0, hi = n;
int left = 0, right = 0;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (pos < mid) {
hi = mid;
right++;
} else {
lo = mid + 1;
left += (pos > mid);
}
}
ll ans = 1;
for (int i = 1; i <= left; ++i) ans = (ans * (x - i)) % MOD;
for (int i = 1; i <= right; ++i) ans = (ans * (n - x - i + 1)) % MOD;
int r = n - left - right - 1;
ans = (ans * fact(r)) % MOD;
cout << ans << endl;
}
int main(int argc, char const *argv[]) {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100005;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<int> > v(n + 1);
v[0] = {1}, v[1] = {0, 1};
for (int i = (int)(1); i < (int)(n); ++i) {
v[i + 1].resize(i + 2);
for (int j = 0; j < (int)(i + 1); ++j) {
v[i + 1][j + 1] = v[i][j];
}
for (int j = 0; j < (int)(i); ++j) {
v[i + 1][j] += v[i - 1][j];
}
bool flag = false;
for (int j = 0; j < (int)(i + 2); ++j) {
if (abs(v[i + 1][j]) > 1) {
flag = true;
}
}
if (!flag) {
continue;
}
for (int j = 0; j < (int)(i); ++j) {
v[i + 1][j] -= 2 * v[i - 1][j];
}
}
cout << n << "\n";
for (int i = 0; i < (int)(n + 1); ++i) {
cout << v[n][i] << " ";
}
cout << "\n";
cout << n - 1 << "\n";
for (int i = 0; i < (int)(n); ++i) {
cout << v[n - 1][i] << " ";
}
cout << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ss, n;
cin >> n;
ss = s.length();
int a[26] = {0};
int count = 0, r = 0, change = 0;
if (n > ss)
cout << "impossible";
else {
for (int i = 0; i < ss; i++) {
if (a[s[i] - 97] == 0)
count++;
else
r++;
a[s[i] - 97]++;
}
if (count >= n)
cout << "0";
else
cout << n - count;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
cout << 1 + (n - 1) / 2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod(long long a) {
return a >= 0 ? a % 1000000009 : (1000000009 + a % 1000000009) % 1000000009;
}
long long st[2 * 3000010];
long long lz[2][2 * 3000010];
long long fib[2][3000010];
long long fibSum[2][3000010];
long long getFib(int i, long long i0, long long i1) {
return mod(mod(fib[0][i] * i0) + mod(fib[1][i] * i1));
}
long long getFibSum(int i, long long i0, long long i1) {
return mod(mod(fibSum[0][i] * i0) + mod(fibSum[1][i] * i1));
}
long long getFibSumRange(int i, int j, int i0, int i1) {
if (i == 0) return getFibSum(j, i0, i1);
return mod(getFibSum(j, i0, i1) - getFibSum(i - 1, i0, i1));
}
void buildU(vector<int> &v, int i, int l, int r) {
if (l == r) {
st[i] = v[l];
return;
}
int m = (l + r) / 2;
buildU(v, i << 1, l, m);
buildU(v, i << 1 | 1, m + 1, r);
st[i] = mod(st[i << 1] + st[i << 1 | 1]);
}
void build(vector<int> &v) {
for (int i = 1; i < 2 * v.size(); i++) {
lz[0][i] = 0;
lz[1][i] = 0;
}
buildU(v, 1, 0, v.size() - 1);
}
const int add = 1;
bool lzEmpty(int i) { return lz[0][i] == 0 && lz[1][i] == 0; }
void lazyUpdate(int i, int l, int r) {
st[i] = mod(st[i] + getFibSum(r - l, lz[0][i], lz[1][i]));
if (l != r) {
lz[0][i << 1] = mod(lz[0][i << 1] + lz[0][i]);
lz[1][i << 1] = mod(lz[1][i << 1] + lz[1][i]);
int m = (l + r) / 2;
lz[0][i << 1 | 1] =
mod(lz[0][i << 1 | 1] + getFib(m + 1 - l, lz[0][i], lz[1][i]));
lz[1][i << 1 | 1] =
mod(lz[1][i << 1 | 1] + getFib(m + 2 - l, lz[0][i], lz[1][i]));
}
lz[0][i] = 0;
lz[1][i] = 0;
}
void changeU(int cl, int cr, int i, int l, int r) {
if (!lzEmpty(i)) lazyUpdate(i, l, r);
if (r < cl || cr < l) return;
if (cl <= l && r <= cr) {
st[i] = mod(st[i] + getFibSumRange(l - cl, r - cl, 1, 1));
if (l != r) {
lz[0][i << 1] = mod(lz[0][i << 1] + getFib(l - cl, 1, 1));
lz[1][i << 1] = mod(lz[1][i << 1] + getFib(l - cl + 1, 1, 1));
int m = (l + r) / 2;
lz[0][i << 1 | 1] = mod(lz[0][i << 1 | 1] + getFib(m + 1 - cl, 1, 1));
lz[1][i << 1 | 1] = mod(lz[1][i << 1 | 1] + getFib(m + 2 - cl, 1, 1));
}
return;
}
int m = (l + r) / 2;
changeU(cl, cr, i << 1, l, m);
changeU(cl, cr, i << 1 | 1, m + 1, r);
st[i] = mod(st[i << 1] + st[i << 1 | 1]);
}
void change(int n, int cl, int cr) { changeU(cl, cr, 1, 0, n - 1); }
int queryU(int ql, int qr, int i, int l, int r) {
if (!lzEmpty(i)) lazyUpdate(i, l, r);
if (r < ql || qr < l) return 0;
if (ql <= l && r <= qr) return st[i];
int m = (l + r) / 2;
int q1 = queryU(ql, qr, i << 1, l, m);
int q2 = queryU(ql, qr, i << 1 | 1, m + 1, r);
return mod(q1 + q2);
}
int query(int n, int ql, int qr) { return queryU(ql, qr, 1, 0, n - 1); }
void print(int n) {
cout << "st" << endl;
for (int i = 1; i < 2 * n; i++) {
cout << setw(4) << st[i] << " ";
}
cout << endl;
for (int j = 0; j < 2; j++) {
cout << "lz[" << j << "]" << endl;
for (int i = 1; i < 2 * n; i++) {
cout << setw(4) << lz[j][i] << " ";
}
cout << endl;
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
fib[0][0] = 1;
fib[0][1] = 0;
fib[1][0] = 0;
fib[1][1] = 1;
fibSum[0][0] = fib[0][0];
fibSum[1][0] = fib[1][0];
for (int j = 0; j < 2; j++) {
for (int i = 2; i < n; i++) {
fib[j][i] = (fib[j][i - 2] + fib[j][i - 1]) % 1000000009;
}
}
for (int j = 0; j < 2; j++) {
for (int i = 0; i < n; i++) {
fibSum[j][i] = (fibSum[j][i - 1] + fib[j][i]) % 1000000009;
}
}
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
build(v);
for (int i = 0; i < m; i++) {
int op, l, r;
cin >> op >> l >> r;
l--;
r--;
if (op == 1) {
change(n, l, r);
} else {
cout << query(n, l, r) << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
const ld eps = 1e-5;
template <class T>
struct pt {
T x, y;
pt operator+(const pt &p) const { return {x + p.x, y + p.y}; }
pt operator-(const pt &p) const { return {x - p.x, y - p.y}; }
pt operator*(T d) const { return {x * d, y * d}; }
pt operator/(T d) const { return {x / d, y / d}; }
bool operator<(const pt &p) const {
if (::abs(x - p.x) < eps) return ::abs(y - p.y) < eps ? false : y < p.y;
return x < p.x;
}
T sq() { return x * x + y * y; }
T abs() { return sqrt(sq()); }
pt rot(T a) {
T nx = x * cos(a) - y * sin(a);
T ny = x * sin(a) + y * cos(a);
return {nx, ny};
}
friend ostream &operator<<(ostream &out, pt p) {
out << '(' << p.x << ',' << p.y << ')';
return out;
}
};
using Pt = pt<long double>;
bool intersect(Pt c1, ld r1, Pt c2, ld r2, pair<Pt, Pt> &out) {
ld d = (c2 - c1).abs();
ld co = (d * d + r1 * r1 - r2 * r2) / (2 * d * r1);
if (abs(co) > 1) return false;
ld alpha = acos(co);
Pt rad = (c2 - c1) / d * r1;
out = {c1 + rad.rot(-alpha), c1 + rad.rot(alpha)};
return true;
}
int n, dsu[3];
ld r[3];
Pt cir[3];
bool seen[8];
bool join(int u, int v) {
while (dsu[u] != u) u = dsu[u];
while (dsu[v] != v) v = dsu[v];
if (u == v) return false;
dsu[u] = v;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> cir[i].x >> cir[i].y >> r[i];
dsu[i] = i;
}
set<Pt> vert;
int c = n;
int e = 0;
for (int i = 0; i < n; i++) {
set<Pt> ivert;
for (int j = 0; j < n; j++) {
if (i == j) continue;
pair<Pt, Pt> it;
if (intersect(cir[i], r[i], cir[j], r[j], it)) {
ivert.insert(it.first);
ivert.insert(it.second);
if (join(i, j)) c--;
}
}
e += ivert.size();
for (auto p : ivert) {
vert.insert(p);
}
}
int v = vert.size();
cout << e - v + c + 1 << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int kMax = 100007;
std::map<std::vector<int>, int> memory;
bool isPrime[kMax];
int prime[kMax], primeNum;
void GetPrime() {
memset(isPrime, true, sizeof(isPrime));
isPrime[0] = isPrime[1] = false;
for (int i = 2; i < kMax; ++i) {
if (isPrime[i]) prime[primeNum++] = i;
for (int j = 0; j < primeNum && (long long)prime[j] * i < kMax; ++j) {
isPrime[prime[j] * i] = false;
if (i % prime[j] == 0) break;
}
}
}
int factor[2][67], factorNum;
void GetFactor(int n) {
factorNum = 0;
for (int i = 0; (long long)prime[i] * prime[i] <= n; ++i) {
factor[1][factorNum] = 0;
if (n % prime[i] == 0) {
factor[0][factorNum] = prime[i];
while (n % prime[i] == 0) {
++factor[1][factorNum];
n /= prime[i];
}
++factorNum;
}
}
if (n != 1) {
factor[0][factorNum] = n;
factor[1][factorNum++] = 1;
}
}
int SG(const std::vector<int> &vec) {
auto it = memory.find(vec);
if (it != memory.end()) return it->second;
if (vec.empty()) return 0;
bool sg[2507];
memset(sg, false, sizeof(sg));
for (int i = 1; i <= vec[0]; ++i) {
std::vector<int> next;
for (int v : vec) {
if (v > i)
next.push_back(v - i);
else if (v < i)
next.push_back(v);
}
std::sort(next.begin(), next.end(), std::greater<int>());
sg[SG(next)] = true;
}
for (int i = 0; i < 2507; ++i)
if (sg[i] == false) return memory[vec] = i;
return -1;
}
int main() {
GetPrime();
std::unordered_map<int, std::vector<int>> factorMap;
int N, ans = 0;
scanf("%d", &N);
for (int i = 0, a; i < N; ++i) {
scanf("%d", &a);
GetFactor(a);
for (int j = 0; j < factorNum; ++j)
factorMap[factor[0][j]].push_back(factor[1][j]);
}
for (auto &p : factorMap) {
std::sort(p.second.begin(), p.second.end(), std::greater<int>());
ans ^= SG(p.second);
}
printf("%s\n", ans ? "Mojtaba" : "Arpa");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bitset<1002> vis;
const long long int oo = LLONG_MAX;
long long int dis[1002];
long long int n, m, k;
set<pair<long long int, long long int>> v[1002];
pair<long long int, long long int> arr[1002];
void dijkstra(int a) {
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int>>,
greater<pair<long long int, long long int>>>
pq;
for (int i = 1; i <= n; i++) dis[i] = oo, vis[i] = 0;
dis[a] = 0;
pq.push({0, a});
while (!pq.empty()) {
long long int u, du, w, node;
u = pq.top().second;
du = pq.top().first;
pq.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto i : v[u]) {
node = i.second;
w = i.first;
if (du + w < dis[node]) {
dis[node] = du + w;
pq.push({dis[node], node});
}
}
}
}
long long int fck[1002];
void init_distances() {
for (int i = 1; i <= k; i++) {
int node = arr[i].first;
dijkstra(node);
fck[i] = dis[arr[i].second];
}
}
pair<long long int, long long int> edges[1002];
long long int weight[1002];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
long long int a, b;
long long int w;
cin >> a >> b >> w;
weight[i] = w;
if (a > b) swap(a, b);
edges[i].first = a;
edges[i].second = b;
v[a].insert({w, b});
v[b].insert({w, a});
}
for (int i = 1; i <= k; i++) cin >> arr[i].first >> arr[i].second;
long long int temp[1002];
init_distances();
long long int fin = LLONG_MAX;
for (int i = 1; i <= m; i++) {
long long int a, b, w;
a = edges[i].first;
b = edges[i].second;
w = weight[i];
v[a].erase({w, b});
v[b].erase({w, a});
v[a].insert({0, b});
v[b].insert({0, a});
dijkstra(a);
for (int j = 1; j <= n; j++) temp[j] = dis[j];
dijkstra(b);
long long int ans = 0;
for (int j = 1; j <= k; j++) {
long long int val = temp[arr[j].first] + dis[arr[j].second];
long long int val1 = temp[arr[j].second] + dis[arr[j].first];
val = min(val, val1);
ans += min(val, fck[j]);
}
fin = min(fin, ans);
v[a].erase({0, b});
v[b].erase({0, a});
v[a].insert({w, b});
v[b].insert({w, a});
}
cout << fin << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> g[200005];
long long int n, a[200005];
vector<vector<long long int> > ans(200005, vector<long long int>(2));
vector<vector<bool> > vis(200005, vector<bool>(2, false));
long long int dfs(long long int s, long long int t) {
if (s == 0 || s == n + 1) return 0;
if (vis[s][t]) {
if (ans[s][t]) return ans[s][t];
return -1;
}
vis[s][t] = true;
ans[s][t] = dfs(g[s][t], 1 - t);
if (ans[s][t] == -1) return -1;
ans[s][t] += a[s - 2];
return ans[s][t];
}
void solve() {
cin >> n;
for (__typeof(n - 1) i = 0; i < n - 1; i++) cin >> a[i];
for (__typeof(n - 1) i = 0; i < n - 1; i++) {
g[i + 2].emplace_back(min(n + 1, i + a[i] + 2));
g[i + 2].emplace_back(max((long long int)0, i - a[i] + 2));
}
vis[1][0] = true;
for (__typeof(n + 1) i = 2; i < n + 1; i++)
if (!vis[i][0]) ans[i][0] = dfs(i, 0);
for (__typeof(n + 1) i = 2; i < n + 1; i++)
if (!vis[i][1]) ans[i][1] = dfs(i, 1);
for (__typeof(n) i = 1; i < n; i++) {
if (ans[1 + i][1] == -1)
cout << -1 << endl;
else
cout << ans[1 + i][1] + i << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.