solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
string s;
cin >> n >> s;
vector<int> index;
for (int i = 0; i < n - 1; ++i) {
if (s[i] == s[i + 1] && (i + 1 + count) % 2) {
++count;
index.push_back(i);
}
}
if ((s.size() - count) % 2) {
++count;
index.push_back(n - 1);
}
cout << count << endl;
int j = 0;
for (int i = 0; i < n; ++i) {
if (j < index.size() && i == index[j]) {
++j;
continue;
} else
cout << s[i];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k, i, j;
cin >> n >> k;
string s;
cin >> s;
char c[k];
for (i = 0; i < k; i++) {
cin >> c[i];
}
vector<long long int> v;
for (i = 0; i < n; i++) {
long long int tmp = 0;
for (j = 0; j < k; j++) {
if (s[i] == c[j]) {
tmp = 1;
break;
}
}
if (tmp == 0) {
v.push_back(i);
}
}
long long int siz = v.size();
if (siz == 0) {
cout << (n * (n + 1)) / 2;
} else {
long long int te = 0, ans = 0;
for (i = 0; i < siz; i++) {
if (i == 0) {
long long int te1 = v[i] - te;
ans += ((te1 * (te1 + 1)) / 2);
te = v[i];
} else {
long long int te1 = v[i] - (te + 1);
ans += ((te1 * (te1 + 1)) / 2);
te = v[i];
}
}
i--;
long long int te1 = n - (v[i] + 1);
ans += ((te1 * (te1 + 1)) / 2);
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
string st;
long long int i;
long long int pop = (n - k) / 2;
for (i = 0; i < s.size(); i++) {
if (pop and s[i] == ')') {
pop--;
st.pop_back();
continue;
}
st.push_back(s[i]);
}
cout << st;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans;
long long MD = 998244353LL;
vector<long long> v;
const long long N = 2000;
long long f[N + 10], c[2010][2010];
long long fastpow(long long a, long long b) {
if (b == 0) return 1;
long long x = 1, y = a % MD;
while (b) {
if (b & 1LL) x = (x * y) % MD;
y = (y * y) % MD;
b >>= 1LL;
}
return x;
}
long long inv(long long x) { return fastpow(x, MD - 2); }
long long C(long long n, long long r) {
long long dv = inv(f[r] * f[n - r]);
return (f[n] * dv) % MD;
}
int main() {
f[0] = 1;
for (long long i = 1; i <= N; ++i) {
f[i] = (f[i - 1] * i) % MD;
}
scanf("%lld %lld", &n, &k);
ans = 1;
for (long long i = 0; i < n; ++i) {
long long x;
scanf("%lld", &x);
if (v.empty() || v.back() != x) {
v.push_back(x);
}
}
if (v.size() > 1 && v[0] == v.back()) {
v.pop_back();
}
long long m = v.size();
if (k == 1 || m == 1) {
puts("0");
return 0;
}
ans *= fastpow(k, n - m);
long long sm = 0;
for (long long i = 0; i + i + 1 <= m; ++i) {
long long cc = C(m, i);
for (long long j = i + 1; i + j <= m; ++j) {
long long tmp = (cc * C(m - i, j)) % MD;
tmp = (tmp * fastpow(k - 2, m - i - j)) % MD;
sm = (sm + tmp) % MD;
}
}
ans = (ans * sm) % MD;
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void printV(vector<T>& v) {
for (const T& t : v) cout << t << " ";
cout << endl;
}
struct Edge {
int from;
bool type;
};
int n, m;
int main() {
cin >> n >> m;
vector<vector<Edge>> graph(n);
for (int i = (0); i < (m); i++) {
int from, to;
bool type;
cin >> from >> to >> type;
from--;
to--;
graph[to].push_back({from, type});
}
vector<bool> visited(n, false);
vector<bool> queued(n, false);
vector<int> dist(n, -1);
vector<int> type(n, -1);
queue<int> next;
next.push(n - 1);
dist[n - 1] = 0;
while (!visited[0] && !next.empty()) {
int cur = next.front();
next.pop();
if (visited[cur]) continue;
visited[cur] = true;
for (Edge& e : graph[cur]) {
if (visited[e.from] || queued[e.from]) continue;
if (type[e.from] == -1) {
type[e.from] = !e.type;
} else if (type[e.from] == e.type) {
queued[e.from] = true;
next.push(e.from);
dist[e.from] = dist[cur] + 1;
}
}
}
cout << dist[0] << endl;
for (int i = (0); i < (n); i++) {
if (type[i] == -1)
cout << 1;
else
cout << type[i];
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 5;
const int MAX = (int)1e5;
int n;
int a[N], cnt[N], cost[N], d[N];
inline void add(int u, int v, queue<int> &q, vector<int> &used) {
d[v] = d[u] + 1;
q.push(v);
used.push_back(v);
}
void bfs(int src) {
vector<int> used;
queue<int> q;
q.push(src);
used.push_back(src);
d[src] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
int v = u * 2;
if (v <= MAX && d[u] + 1 < d[v]) add(u, v, q, used);
v = u / 2;
if (v > 0 && d[u] + 1 < d[v]) add(u, v, q, used);
}
for (int i = 0; i < used.size(); i++) {
cnt[used[i]]++;
cost[used[i]] += d[used[i]];
d[used[i]] = 1 << 30;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
fill(d, d + MAX + 1, 1 << 30);
for (int i = 0; i < n; i++) bfs(a[i]);
int ret = 1 << 30;
for (int i = 1; i <= MAX; i++)
if (cnt[i] == n) ret = min(ret, cost[i]);
cout << ret << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300005;
const long long MOD = 998244353LL;
vector<vector<int> > adj(MAX_N);
long long A[MAX_N], B[MAX_N];
long long C[MAX_N];
bool visited[MAX_N];
long long MULT(long long a, long long b) {
a %= MOD;
b %= MOD;
long long res = a * b;
res %= MOD;
return res;
}
void dfs(int v) {
visited[v] = true;
long long ans = 0;
int count = 0;
A[v] = 1;
B[v] = 1;
C[v] = 1;
long long subtract = 1;
for (auto &u : adj[v]) {
if (!visited[u]) {
dfs(u);
count++;
A[v] = MULT(A[v], B[u] + C[u] + C[u]);
B[v] = MULT(B[v], B[u] + C[u] + C[u]);
subtract = MULT(subtract, B[u] + C[u]);
long long sum = A[u] + B[u] + (C[u] * 2);
C[v] = MULT(C[v], sum);
}
}
B[v] -= subtract;
B[v] %= MOD;
B[v] += MOD;
B[v] %= MOD;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0);
long long ans = B[0] + C[0] - 1;
ans %= MOD;
ans += MOD;
ans %= MOD;
return cout << ans << '\n', 0;
;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 18) + 5;
int a[maxn], vis[maxn];
struct Node {
int x;
bool operator<(const Node &rhs) const { return x > rhs.x; }
};
priority_queue<Node> q;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int x = 1;
while (x <= n) {
vis[x] = 1;
x <<= 1;
}
long long ans = 0;
for (int i = n; i >= 1; i--) {
if (a[i] == -1) break;
q.push(Node{a[i]});
if (vis[i]) {
ans += q.top().x;
q.pop();
}
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long double TIME;
void _main();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed;
TIME = clock();
_main();
}
void _main() {
long long n, x, y;
cin >> n >> x >> y;
vector<long long> a(n);
for (long long i = 0; i < a.size(); ++i) cin >> a[i];
;
for (long long i = 0; i < n; ++i) {
long long mx = (long long)(1e18), my = (long long)(1e18);
for (long long j = ((i - x) > (0) ? (i - x) : (0)); j < i; ++j)
mx = ((mx) < (a[j]) ? (mx) : (a[j]));
for (long long j = i + 1; j < ((i + y + 1) < (n) ? (i + y + 1) : (n)); ++j)
my = ((my) < (a[j]) ? (my) : (a[j]));
if (a[i] < mx && a[i] < my) return void(cout << i + 1);
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC target("avx")
const long long MOD = 1000000007;
const long double PI = 3.1415926535898;
const long long LIM = 100005;
using namespace std;
long long fpow(long long x, long long y) {
long long temp;
if (y == 0) return 1;
temp = fpow(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void sieve(long long n) {
bool prime[5 * LIM];
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= n; p++)
if (prime[p] == true)
for (long long i = p * p; i <= n; i += p) prime[i] = false;
prime[1] = 0;
}
inline long long read() {
long long p = 1, ans = 0;
char ch = getchar();
while (ch < 48 || ch > 57) {
if (ch == '-') p = -1;
ch = getchar();
}
while (ch >= 48 && ch <= 57) {
ans = (ans << 3) + (ans << 1) + ch - 48;
ch = getchar();
}
return ans * p;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
for (long long tt = 1; tt <= t; ++tt) {
long long n;
cin >> n;
if (n < 4) {
cout << -1 << endl;
continue;
}
long long ele = 0;
if (n % 2 == 0)
ele = n - 1;
else
ele = n;
while (ele >= 1) {
cout << ele << " ";
ele -= 2;
}
cout << 4 << " " << 2 << " ";
ele = 6;
while (ele <= n) {
cout << ele << " ";
ele += 2;
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(const T &val) {
return (val < 0) ? -val : val;
}
struct IndexNum {
long long value;
int index;
IndexNum(long long v, int i) {
value = v;
index = i;
}
bool operator<(const IndexNum &rhs) const {
if (abs(value) < abs(rhs.value)) {
return true;
} else if (abs(value) > abs(rhs.value)) {
return false;
} else {
return index < rhs.index;
}
}
};
int main() {
std::ios::sync_with_stdio(false);
int N, K, X;
cin >> N >> K >> X;
int neg = 0;
set<IndexNum> s;
for (int i = 0; i < N; i++) {
long long A;
cin >> A;
if (A < 0) {
neg++;
}
s.insert(IndexNum(A, i));
}
for (int i = 0; i < K; i++) {
auto sm = s.begin();
s.erase(sm);
IndexNum curr = *sm;
if (neg % 2 == 0) {
if (curr.value < 0) {
if (curr.value >= -X) {
neg--;
}
curr.value += X;
} else {
if (curr.value < X) {
neg++;
}
curr.value -= X;
}
} else {
if (curr.value < 0) {
curr.value -= X;
} else {
curr.value += X;
}
}
s.insert(curr);
}
long long B[N];
for (auto &it : s) {
B[it.index] = it.value;
}
for (auto &val : B) {
cout << val << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vii = vector<vi>;
using pii = pair<int, int>;
using ll = long long;
using ld = long double;
const int MAX = 1e9, MIN = -MAX, MOD = 1e9 + 7;
const ll MAX_LL = 1e18, MIN_LL = -MAX_LL;
int main() {
int n, m;
cin >> n >> m;
char a[n + 5], b[m + 5];
scanf("%s%s", &a[1], &b[1]);
int dp[n + 1][m + 1], ans = 0;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (a[i] == b[j])
dp[i][j] = dp[i - 1][j - 1] + 2;
else
dp[i][j] = max(dp[i][j], max(dp[i - 1][j] - 1, dp[i][j - 1] - 1));
ans = max(ans, dp[i][j]);
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) { return b != 0 ? GCD(b, a % b) : a; }
long long LCM(long long a, long long b) { return a * (b / GCD(a, b)); }
long long Pow(long long n, long long e) {
if (e == 0) return 1;
if (e == 1)
return n;
else if (e & 1) {
long long t = Pow(n, e / 2);
return n * t * t;
} else {
long long t = Pow(n, e / 2);
return t * t;
}
}
int h[5005];
int dp[5005][5005];
int main() {
int N;
scanf("%d", &N);
for (int i = (1), max_ = (N + 1); i < max_; ++i) scanf("%d", &h[i]);
for (int i = 0, max_ = (N + 1); i < max_; ++i)
for (int j = 0, max_ = (N + 1); j < max_; ++j) dp[i][j] = 100000000;
dp[0][0] = 0;
for (int i = 0, max_ = (N + 1); i < max_; ++i) {
int k = -1, sum = 0;
for (int j = (i + 1), max_ = (N + 1); j < max_; ++j) {
sum += h[j];
while (k + 1 < N && dp[i][k + 1] <= sum) ++k;
if (k >= 0) {
dp[j][k + 1] = min(dp[j][k + 1], sum);
}
}
for (int k = (N)-1; k >= 0; --k)
dp[i + 1][k] = min(dp[i + 1][k], dp[i + 1][k + 1]);
}
int maxK = 0;
for (int k = 0, max_ = (N + 1); k < max_; ++k)
if (dp[N][k] < 100000000) maxK = k;
printf("%d\n", N - maxK);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int i;
int j;
int n;
scanf("%d", &n);
char a[n];
scanf("%s", a);
int toplam = 0;
int Isayisi = 0;
int Fsayisi = 0;
int Asayisi = 0;
for (i = 0; i < n; i++) {
switch (a[i]) {
case 'A':
Asayisi++;
break;
case 'F':
Fsayisi++;
break;
case 'I':
Isayisi++;
break;
}
}
if (Isayisi == 1)
printf("1");
else if (Isayisi > 1)
printf("0");
else
printf("%d", Asayisi);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
long long GetMaxSum(int n, int len, int k) {
long long mxsum = -(~0ULL >> 1);
long long ans = 0;
multiset<int> Saki;
multiset<int> Nodoka;
for (int i = 0; i < n; i++) {
if (i >= len) {
if (Saki.find(a[i - len]) != Saki.end()) {
Saki.erase(Saki.find(a[i - len]));
ans += a[i - len];
if (!Nodoka.empty()) {
Saki.insert(*Nodoka.begin());
ans -= *Nodoka.begin() * 2;
Nodoka.erase(Nodoka.begin());
}
} else {
ans -= a[i - len];
if (Nodoka.find(a[i - len]) != Nodoka.end()) {
Nodoka.erase(Nodoka.find(a[i - len]));
}
}
}
if (a[i] < 0) {
if (Saki.size() < k) {
Saki.insert(a[i]);
ans -= a[i];
} else if (!Saki.empty() && a[i] <= *Saki.rbegin()) {
Nodoka.insert(*Saki.rbegin());
ans += *Saki.rbegin() * 2;
Saki.erase(--Saki.end());
Saki.insert(a[i]);
ans -= a[i];
} else {
Nodoka.insert(a[i]);
ans += a[i];
}
} else
ans += a[i];
if (i >= len - 1) mxsum = max(mxsum, ans);
}
return mxsum;
}
int main(void) {
int n = 0;
int len = 0;
scanf("%d %d", &n, &len);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int k = 0;
scanf("%d", &k);
long long ans = GetMaxSum(n, len, k);
for (int i = 0; i < n; i++) a[i] = -a[i];
ans = max(ans, GetMaxSum(n, len, k));
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long ans1, ans2, a[N], n, b[N], now = 1, p = 1;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (a[i] < 0) p *= -1;
b[i] = p;
if (p > 0)
ans1++;
else
ans2++;
}
int z = ans1, f = ans2;
for (int i = 1; i < n; i++) {
if (now * b[i] > 0)
z--;
else
f--;
if (a[i] < 0) swap(z, f), now *= -1;
ans1 += z;
ans2 += f;
}
cout << ans2 << " " << ans1 << endl;
}
| 3 |
#include <iostream>
#include <cstdio>
using namespace std;
int main() {
int T;
cin >> T;
while(T--)
{
int n,m;
cin >> n >> m;
int *a=new int[n+1];
double ans=1;
for(int i=1;i<=n;i++)
cin >> a[i];
int pos=n;
while(pos&&a[pos]==pos) --pos;
if(!pos)
{
for(int i=1;i<=m;i++)
{
int x;
double y;
cin >> x >> y;
}
puts("1.000000");
continue;
}
for(int i=1;i<=m;i++)
{
int x;
double y;
cin >> x >> y;
if(x>=pos) ans*=1-y;
}
printf("%.10lf\n",1-ans);
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int LIM_N = 1.5e5 + 5;
vector<int> adj[LIM_N];
bool hasMark[LIM_N];
int rawCst[LIM_N];
pair<int, int> maxDep[LIM_N][2];
pair<int, int> ans = {1e9, -1};
void explDfs(const int pos, const int prev = -1) {
maxDep[pos][0] = maxDep[pos][1] = {-1, -1};
rawCst[pos] = 0;
if (hasMark[pos]) maxDep[pos][0] = {0, pos};
for (const int nxt : adj[pos]) {
if (nxt == prev) continue;
explDfs(nxt, pos);
if (maxDep[nxt][0].second == -1) continue;
maxDep[pos][1] = max(maxDep[pos][1], {maxDep[nxt][0].first + 1, nxt});
if (maxDep[pos][0] < maxDep[pos][1]) swap(maxDep[pos][0], maxDep[pos][1]);
rawCst[pos] += 2 + rawCst[nxt];
}
}
void finDfs(const int pos, const int prev = -1, const int upDep = -1,
const int upRaw = 0) {
ans = min(ans, {rawCst[pos] + upRaw - max(maxDep[pos][0].first, upDep), pos});
for (const int nxt : adj[pos]) {
if (nxt == prev) continue;
if (maxDep[nxt][0].second == -1) continue;
int newUD = max(upDep, nxt != maxDep[pos][0].second ? maxDep[pos][0].first
: maxDep[pos][1].first);
if (newUD != -1) newUD++;
finDfs(nxt, pos, newUD,
upRaw + rawCst[pos] - rawCst[nxt] - (newUD == -1 ? 2 : 0));
}
}
int main() {
int N, K;
scanf("%d%d", &N, &K);
for (int i = 1, a, b; i < N; i++) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 0, a; i < K; i++) {
scanf("%d", &a);
hasMark[a] = true;
}
explDfs(1);
finDfs(1);
printf("%d\n%d\n", ans.second, ans.first);
}
| 7 |
#include <bits/stdc++.h>
int N, M;
int **sol;
int max_sol = 0;
int *level, *cost, *income;
int kInvalid = -10000000;
int **alloc_memory() {
sol = (int **)malloc(sizeof(int *) * (N + M + 1));
for (int i = 0; i <= N + M; ++i) {
sol[i] = (int *)malloc(sizeof(int) * (N + 1));
for (int j = 0; j <= N; ++j) {
sol[i][j] = kInvalid;
}
}
level = (int *)malloc(sizeof(int) * (N));
cost = (int *)malloc(sizeof(int) * (N));
income = (int *)malloc(sizeof(int) * (N + M + 1));
return sol;
}
void free_memory() {
for (int i = 0; i <= N + M; ++i) {
free(sol[i]);
}
free(sol);
free(level);
free(cost);
free(income);
}
void update(int k, int i, int value) {
if (value > sol[k][i]) {
sol[k][i] = value;
if (i == 1 && value > max_sol) {
max_sol = value;
}
}
}
void fight(int n, int cnt) {
int l = level[n];
update(l, cnt + 1, sol[l][cnt] + income[l] - cost[n]);
int x = cnt + 1;
int up = l;
while (x > 1) {
int y = x / 2;
update(up + 1, y, sol[up][x] + y * income[up + 1]);
x = y;
++up;
}
}
int main() {
scanf("%d%d", &N, &M);
alloc_memory();
for (int n = 0; n < N; ++n) {
scanf("%d", level + (N - 1 - n));
}
for (int n = 0; n < N; ++n) {
scanf("%d", cost + (N - 1 - n));
}
for (int l = 1; l <= N + M; ++l) {
scanf("%d", income + l);
}
update(0, 0, 0);
update(level[0], 1, income[level[0]] - cost[0]);
for (int n = 1; n < N; ++n) {
for (int j = n; j >= 0; --j) {
if (sol[level[n]][j] > kInvalid) {
fight(n, j);
}
}
update(level[n], 1, income[level[n]] - cost[n]);
for (int i = 1; i < level[n]; ++i) {
update(level[n], 1, sol[i][1] + income[level[n]] - cost[n]);
}
}
printf("%d\n", max_sol);
free_memory();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> razliciti[100005];
int a[100005];
int b[100005];
bool mark[100005];
int n, m;
int p, q;
int indeks;
int pronadji(int x) {
for (int i = 1; i <= n; i++) {
if (i != x) {
if (!mark[i]) return i;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
a[i] = i;
b[i] = i;
}
for (int i = 1; i <= m; i++) {
cin >> p >> q;
razliciti[p].push_back(q);
razliciti[q].push_back(p);
}
indeks = -1;
for (int i = 1; i <= n && indeks == -1; i++) {
if (razliciti[i].size() < n - 1) {
indeks = i;
}
}
if (indeks == -1) {
cout << "NO";
} else {
for (int i : razliciti[indeks]) mark[i] = true;
int prvi = pronadji(indeks);
b[prvi] = indeks;
cout << "YES"
<< "\n";
int cnt = 3;
for (int i = 1; i <= n; i++) {
if (i == indeks)
cout << "1 ";
else if (i == prvi)
cout << "2 ";
else
cout << cnt++ << " ";
}
cout << "\n";
cnt = 3;
for (int i = 1; i <= n; i++) {
if (i == indeks)
cout << "1 ";
else if (i == prvi)
cout << "1 ";
else
cout << cnt++ << " ";
}
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(0)
using namespace std;
inline int read(void) {
int n = 0;
bool b = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') b = 0;
c = getchar();
}
while (c >= '0' && c <= '9') n = (n << 3) + (n << 1) + c - 48, c = getchar();
return b ? n : -n;
}
int x, k, ans;
double p, f[210][210];
int main() {
x = read();
k = read();
p = read();
p /= 100.0;
for (int i = 0; i <= k; ++i) {
for (int j = x + i; !(j & 1); j >>= 1) {
++f[0][i];
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j <= k; ++j) {
if (j) f[i + 1][j - 1] += (1 - p) * f[i][j];
if ((j << 1) <= k) f[i + 1][j << 1] += p * (f[i][j] + 1);
}
}
printf("%.15lf", f[k][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n;
n = pow(2.0, n);
cin >> m;
cout << m % n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
int t;
cin >> t;
while (t--) {
long long ans = 0;
long long p, q;
cin >> p >> q;
if (p < q) {
cout << p << endl;
continue;
} else {
for (int i = 1; i * i <= q; i++) {
if (q % i) continue;
if (i != 1) {
long long t = p;
while (!(t % q)) t /= i;
ans = max(ans, t);
}
long long t = p;
while (!(t % q)) t /= q / i;
ans = max(ans, t);
}
cout << ans << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
#define ll long long
#define ld long double
using namespace std;
const int N = 2e5 + 5;
#define eps 1e-8
ld v, ans;
void solve(int idx, ld c, ld m, ld p, ld prob){
ans += (prob * p * idx);
if(c > eps){
if(m > eps) solve(idx + 1, c - v, m + min(c, v) / 2, p + min(c, v) / 2, prob * c);
else solve(idx + 1, c - v, m, p + min(c, v), prob * c);
}
if(m > eps){
if(c > eps) solve(idx + 1, c + min(m, v) / 2, m - v, p + min(m, v) / 2, prob * m);
else solve(idx + 1, c, m - v, p + min(m, v), prob * m);
}
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int tt;
cin >> tt;
while(tt--){
ld c, m, p;
cin >> c >> m >> p >> v;
ans = 0;
solve(1, c, m, p, 1);
cout << fixed << setprecision(8) << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int INF = 2147483647;
int inf = -2147483648;
const double PI = acos(-1.0);
int main() {
long long n;
long long ans = 0;
map<long long, long long> p;
map<long long, long long> q;
map<pair<long long, long long>, long long> pq;
cin >> n;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
ans += p[a]++;
ans += q[b]++;
ans -= pq[make_pair(a, b)]++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ini[n];
long long i;
for (i = 0; i < n; i++) cin >> ini[i];
long long k;
cin >> k;
long long fin[k];
long long coun[k], maxx[k];
for (i = 0; i < k; i++) cin >> fin[i];
long long coun1 = 0, coun2 = 0;
long long j, sumi = 0;
long long tems1 = 0, tems2 = 0;
for (i = 0; i < k; i++) tems1 += fin[i];
for (i = 0; i < n; i++) tems2 += ini[i];
if (tems1 != tems2) {
cout << "NO";
return 0;
}
for (i = 0; i < k; i++) {
sumi = 0;
long long ck = 0, ma = 0;
for (i == 0 ? j = 0 : j = coun[i - 1]; j < n; j++) {
sumi += ini[j];
if (i == 0 ? j != 0 : j != coun[i - 1]) {
if (ini[j] != ini[j - 1]) ck = 1;
ma = max(ma, ini[j]);
};
if (sumi == fin[i]) {
coun[i] = j + 1;
maxx[i] = ma;
if (ck == 0 && (i == 0 ? coun[i] != 1 : (coun[i] - coun[i - 1]) != 1)) {
cout << "NO";
return 0;
}
break;
} else if (sumi > fin[i]) {
cout << "NO";
return 0;
};
}
}
vector<long long> li[k];
cout << "YES" << endl;
for (i = 0; i < k; i++) {
long long upto = coun[i];
long long j = 0;
int maxxx = 0;
for ((i == 0) ? j = 0 : j = coun[i - 1]; j < upto; j++) {
li[i].push_back(ini[j]);
if (ini[j] > maxxx) maxxx = ini[j];
}
maxx[i] = maxxx;
}
for (i = 0; i < k; i++) {
j = 0;
long long maxi = 0;
if (li[i].size() == 1) continue;
while (j < coun[i]) {
if (li[i][j] == maxx[i]) {
if (j < li[i].size() - 1)
if (li[i][j + 1] != li[i][j]) {
maxi = j;
break;
};
if (j > 0)
if (li[i][j - 1] != li[i][j]) {
maxi = j;
break;
};
}
j++;
}
while (li[i].size() != 1) {
if (maxi < li[i].size() - 1) {
if (li[i][maxi] != li[i][maxi + 1]) {
li[i][maxi] += li[i][maxi + 1];
cout << i + maxi + 1 << ' ' << 'R' << endl;
li[i].erase(li[i].begin() + maxi + 1, li[i].begin() + maxi + 2);
continue;
}
};
if (maxi > 0) {
if (li[i][maxi] != li[i][maxi - 1]) {
li[i][maxi] += li[i][maxi - 1];
cout << i + maxi + 1 << ' ' << 'L' << endl;
li[i].erase(li[i].begin() + maxi - 1, li[i].begin() + maxi);
maxi--;
continue;
}
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
long long data[N], t, n;
vector<long long> d;
int main() {
scanf("%d", &t);
while (t--) {
bool f = true;
d.clear();
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &data[i]);
sort(data + 1, data + 1 + n);
long long x = data[1] * data[n];
for (int i = 2; 1LL * i * i <= x; i++) {
if (x % i == 0) {
d.push_back(i);
if (i != x / i) d.push_back(x / i);
}
if (d.size() > n) {
f = false;
break;
}
}
if (!f || d.size() != n) {
printf("%d\n", -1);
continue;
}
sort(d.begin(), d.end());
for (int i = 1; i <= n; i++)
if (data[i] != d[i - 1]) {
f = false;
break;
}
printf("%I64d\n", f ? x : -1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline int minimize(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int maximize(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
mt19937 RNG(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int myrand() { return abs((int)RNG()); }
const int MAXN = 5e5 + 100;
const int MOD = 1e9 + 7;
const long long MAXV = 5000000;
const double eps = 1e-12;
const int INF = 2e9 + 100;
const long long INF_LL = 1e16;
inline string toStr(long long x) {
string tmp = "";
do tmp = char(x % 10 + '0') + tmp;
while (x /= 10);
return tmp;
}
inline long long toInt(string s) {
long long res = 0;
for (auto x : s) res = res * 10 + x - '0';
return res;
}
inline string toBinStr(long long x) {
string res = "";
do res = (x % 2 ? "1" : "0") + res;
while (x >>= 1LL);
return res;
}
long long rnd(int k) {
if (!k) return myrand() % MAXV + 1;
long long t = myrand() % MAXV + 1;
return (myrand() % t) + (MAXV - t);
}
long long random_gen(int sign) {
long long x = rnd(myrand() % 2);
long long s = myrand() % 2;
s = !s ? 1 : -1;
return sign == 1 ? x : sign == -1 ? -x : s * x;
}
int divisor[MAXV + 1];
void Sieve() {
divisor[0] = divisor[1] = 0;
for (int i = 2; i <= MAXV; ++i)
if (divisor[i] == 0) {
divisor[i] = 1;
for (int j = 2; i * j <= MAXV; ++j) {
int count = 0;
int val = i * j;
while (val % i == 0) {
val /= i;
++count;
}
divisor[i * j] += count;
}
}
}
int Ares_KN() {
Sieve();
for (int i = (2), _b = (MAXV); i <= _b; i++) divisor[i] += divisor[i - 1];
int nTest;
cin >> nTest;
while (nTest--) {
int a, b;
cin >> a >> b;
if (a == b) {
puts("0");
continue;
}
printf("%d\n", divisor[a] - divisor[b]);
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
Ares_KN();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 128;
int dp[128][256];
int pic[128];
int depth[256];
int main() {
int t;
cin >> t;
while (t--) {
int n, k, l;
cin >> n >> k >> l;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
cin >> pic[i];
}
for (int i = 1; i <= k; i++) depth[i] = i;
for (int i = k + 1; i <= 2 * k; i++) depth[i] = k - (i - k);
for (int i = 0; i < 2 * k; i++) dp[0][i] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2 * k; j++) {
if (dp[i][j]) {
if (pic[i + 1] + depth[(j + 1) % (2 * k)] <= l)
dp[i + 1][(j + 1) % (2 * k)] = 1;
if (i == 0) continue;
if (pic[i] + depth[(j + 1) % (2 * k)] <= l) {
int tem = dp[i][(j + 1) % (2 * k)];
dp[i][(j + 1) % (2 * k)] = 1;
if ((j + 1) % (2 * k) < j && tem != 1) j = -1;
}
}
}
}
int flag = 0;
for (int i = 0; i < 2 * k; i++)
if (dp[n][i] == 1) {
flag = 1;
cout << "Yes" << endl;
break;
}
if (!flag) cout << "No" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pi = pair<int, int>;
using pll = pair<ll, ll>;
void fail() {
cout << "NO" << endl;
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < int(n); i++) cin >> a[i];
vector<bool> res(n);
vector<int> incr, decr;
for (int i = 0; i < int(n); i++) {
int x = a[i];
bool incr_ok = incr.empty() || x > incr.back();
bool decr_ok = decr.empty() || x < decr.back();
if (incr_ok && decr_ok) {
if (i + 1 < n && x < a[i + 1]) {
incr.push_back(x);
} else {
decr.push_back(x);
res[i] = 1;
}
} else if (incr_ok) {
incr.push_back(x);
} else if (decr_ok) {
decr.push_back(x);
res[i] = 1;
} else {
fail();
}
}
cout << "YES" << endl;
for (int r : res) cout << r << " ";
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("avx2")
using namespace std;
int n;
vector<int> val;
int Find_small(int value, vector<int> &x) {
int min_i = -1, max_i = (int)x.size() - 1;
while (min_i < max_i) {
int mid_i = (min_i + max_i + 1) / 2;
if (val[x[mid_i] % n] * 2 < value) {
min_i = mid_i;
} else {
max_i = mid_i - 1;
}
}
return min_i;
}
int Find_big(int value, vector<int> &x) {
int min_i = 0, max_i = (int)x.size() - 1;
while (min_i < max_i) {
int mid_i = (min_i + max_i + 1) / 2;
if (val[x[mid_i] % n] >= value) {
min_i = mid_i;
} else {
max_i = mid_i - 1;
}
}
return min_i;
}
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
val.resize(n);
int max_i = 0;
for (int i = 0; i < (n); i++) {
cin >> val[i];
}
reverse(val.begin(), val.end());
for (int i = 0; i < (n); i++) {
if (val[max_i] < val[i]) {
max_i = i;
}
}
vector<int> find_small, find_big, ans(n);
find_small.push_back(max_i);
find_big.push_back(max_i);
ans[max_i] = 1;
for (int i = (max_i - 1 + n) % n; i != max_i; i = (i - 1 + n) % n) {
if (val[i] * 2 < val[max_i]) {
break;
}
ans[max_i]++;
}
if (ans[max_i] >= n) {
for (int i = 0; i < (n); i++) {
cout << -1 << ' ';
}
cout << endl;
return 0;
}
for (int i = max_i + 1; i % n != max_i; i++) {
int big_i = Find_big(val[i % n], find_big),
small_i = Find_small(val[i % n], find_small);
if (small_i == -1 || find_small[small_i] < find_big[big_i]) {
ans[i % n] = i - find_big[big_i] + ans[find_big[big_i] % n];
} else {
ans[i % n] = i - find_small[small_i];
}
while (!find_big.empty() && val[find_big.back() % n] <= val[i % n]) {
find_big.pop_back();
}
find_big.push_back(i);
while (!find_small.empty() && val[find_small.back() % n] >= val[i % n]) {
find_small.pop_back();
}
find_small.push_back(i);
}
reverse(ans.begin(), ans.end());
for (int a : ans) {
cout << a << ' ';
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
const int ninf = -1000000;
const int inf = 1000000;
int dp[100005];
int binSearch(int value) {
int L = 0, R = n, M;
while (R - L > 1) {
M = (L + R) / 2;
if (dp[M] > value)
R = M;
else
L = M;
}
if (dp[L] > value)
return L;
else
return R;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
dp[0] = ninf;
for (int i = 1; i <= n; i++) dp[i] = inf;
for (int i = 0; i < n; i++) {
dp[binSearch(a[i])] = a[i];
}
int result;
for (int i = n; i >= 0; i--) {
if (dp[i] != inf) {
result = i;
break;
}
}
cout << result;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
unordered_map<string, int> compress;
struct DSU {
int parent[N];
int opposite[N];
DSU() {
for (int i = 0; i < N; ++i) {
parent[i] = i;
opposite[i] = -1;
}
}
int GetRoot(int x) {
if (parent[x] == x) {
return x;
}
return parent[x] = GetRoot(parent[x]);
}
int GetOpp(int x) { return opposite[GetRoot(x)]; }
void SetOpp(int x, int opp) { opposite[GetRoot(x)] = opp; }
void Join(int x, int y) {
x = GetRoot(x);
y = GetRoot(y);
parent[x] = y;
if (opposite[y] == -1) {
opposite[y] = opposite[x];
}
}
bool AreSame(int x, int y) {
if (x == -1 || y == -1) return false;
return GetRoot(x) == GetRoot(y);
}
bool AreOpp(int x, int y) {
return AreSame(x, GetOpp(y)) || AreSame(y, GetOpp(x));
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
compress[s] = i + 1;
}
DSU dsu;
while (m--) {
int t;
string a, b;
cin >> t >> a >> b;
int x = compress[a];
int y = compress[b];
int opp_x = dsu.GetOpp(x);
int opp_y = dsu.GetOpp(y);
if (t == 1) {
if (dsu.AreSame(x, opp_y) || dsu.AreSame(opp_x, y)) {
cout << "NO\n";
continue;
}
dsu.Join(x, y);
if (opp_x != -1 && opp_y != -1) {
dsu.Join(opp_x, opp_y);
}
} else {
if (dsu.AreSame(x, y) || dsu.AreSame(opp_x, opp_y)) {
cout << "NO\n";
continue;
}
if (opp_x != -1) {
dsu.Join(opp_x, y);
}
if (opp_y != -1) {
dsu.Join(x, opp_y);
}
dsu.SetOpp(x, y);
dsu.SetOpp(y, x);
}
cout << "YES\n";
}
while (q--) {
string a, b;
cin >> a >> b;
int x = compress[a];
int y = compress[b];
if (dsu.AreSame(x, y)) {
cout << "1\n";
} else if (dsu.AreOpp(x, y)) {
cout << "2\n";
} else {
cout << "3\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
long long n, m, ans = 0, cnt = 0;
scanf("%lld%lld", &n, &m);
ans = ((n % mod) * (m % mod)) % mod;
for (long long i = 1; i <= m; ++i) {
if (n / i == 0) break;
long long p = min(n / (n / i), m);
if ((p - i + 1) % 2) {
ans -=
((((p + i) / 2) % mod) * ((p - i + 1) % mod)) % mod * (n / i) % mod;
} else
ans -=
(((p + i) % mod) * (((p - i + 1) / 2) % mod)) % mod * (n / i) % mod;
if (ans < 0) ans += mod;
i = (n / (n / i));
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100, K = 5, M = 120;
int n, k, last[M], a[N], par[M], go[M][M];
long long ans;
vector<vector<int>> all;
vector<int> vec;
int g_par(int v) { return (v == par[v] ? v : par[v] = g_par(par[v])); }
bool merge(int u, int v) {
if (g_par(u) == g_par(v)) return false;
par[par[u]] = par[v];
return true;
}
void pre_pro() {
vector<int> vec;
for (int i = 0; i < k; i++) vec.push_back(i);
do {
all.push_back(vec);
} while (next_permutation(vec.begin(), vec.end()));
}
int read() {
vector<int> vec;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
vec.push_back(--x);
}
return lower_bound(all.begin(), all.end(), vec) - all.begin();
}
int f(int a, int b) {
vector<int> vec;
for (int i = 0; i < k; i++) vec.push_back(all[a][all[b][i]]);
return lower_bound(all.begin(), all.end(), vec) - all.begin();
}
void input_ready() {
cin >> n >> k;
pre_pro();
for (int i = 0; i < n; i++) a[i] = read();
for (int i = 0; i < all.size(); i++)
for (int j = 0; j < all.size(); j++) go[i][j] = f(i, j);
}
void act(int dex) {
if (last[a[dex]] == -1)
vec.push_back(last[a[dex]] = dex);
else {
vector<int> help;
for (int x : vec)
if (a[x] != a[dex]) help.push_back(x);
help.push_back(last[a[dex]] = dex);
vec = help;
}
}
int cnt;
void run(int x) {
for (int i = 0; i < all.size(); i++) cnt -= merge(i, go[i][x]);
}
void calc(int dex) {
int last = dex;
cnt = all.size();
iota(par, par + all.size(), 0);
for (int i = vec.size() - 1; ~i; i--) {
ans += (last - vec[i]) * (all.size() / cnt);
last = vec[i];
if (g_par(0) == g_par(a[vec[i]]))
continue;
else
run(a[vec[i]]);
}
ans += (last + 1) * (all.size() / cnt);
}
void solve() {
fill(last, last + all.size(), -1);
for (int i = 0; i < n; i++) {
act(i);
calc(i);
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
input_ready();
solve();
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 2005;
long long dp[N][N];
int a[N][N];
void pre() {
memset(dp, 0, sizeof(dp));
dp[1][0] = 1;
for (int n = 2; n < N; n++) {
dp[n][0] = dp[n - 1][0] * n % mod;
dp[n][1] = dp[n - 1][0] * (n - 1) % mod;
for (int r = 2; r <= n; r++) {
dp[n][r] =
((r - 1) * dp[n - 1][r - 2] + (n - r) * dp[n - 1][r - 1]) % mod;
}
}
}
inline long long modPow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) (ret *= a) %= mod;
(a *= a) %= mod;
b >>= 1;
}
return ret;
}
inline void update(int i, int x, int n, vector<int> &f) {
while (i <= n) {
f[i] += x;
i += i & (-i);
}
}
inline int query(int i, vector<int> &f) {
int ret = 0;
while (i) {
ret += f[i];
i &= (i - 1);
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(32);
pre();
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int cnt = a[1][i] - 1;
for (int j = 1; j < i; j++) {
if (a[1][j] < a[1][i]) cnt--;
}
ans += cnt * dp[n - i][0] % mod;
if (ans >= mod) ans -= mod;
}
(ans *= modPow(dp[n][n], n - 1)) %= mod;
for (int i = 2; i <= n; i++) {
long long cnt = 0;
vector<int> f1(n + 1), f2(n + 1), c(n + 1, 2);
for (int j = 1; j <= n; j++) {
update(j, 1, n, f1);
update(j, 1, n, f2);
}
for (int j = 1; j <= n; j++) {
if (c[a[i - 1][j]] == 2) {
update(a[i - 1][j], -1, n, f1);
}
int r = query(n, f1);
c[a[i - 1][j]]--;
if (a[i][j] < a[i - 1][j] || c[a[i - 1][j]] == 0) {
int x = query(a[i][j] - 1, f1);
int y = query(a[i][j] - 1, f2);
if (r > 0) cnt += x * dp[n - j][r - 1];
cnt += (y - x) * dp[n - j][r];
cnt %= mod;
} else {
int x = query(a[i][j] - 1, f1);
int y = query(a[i][j] - 1, f2) - 1;
if (r > 0) cnt += x * dp[n - j][r - 1];
cnt += (y - x) * dp[n - j][r];
cnt %= mod;
}
if (c[a[i][j]] == 2) {
update(a[i][j], -1, n, f1);
}
update(a[i][j], -1, n, f2);
c[a[i][j]]--;
}
(cnt *= modPow(dp[n][n], n - i)) %= mod;
ans += cnt;
if (ans >= mod) ans -= mod;
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long T, n, k;
cin >> T;
while (T--) {
cin >> n >> k;
long long ans = 0;
while (n) {
if (n % k != 0)
ans += n % k, n -= n % k;
else
ans++, n /= k;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct line {
long long x, y, dx, dy, s;
} a[25000];
struct point {
int i;
bool f;
long double x;
} b[50000], c[25000];
bool comp(point a, point b) {
if (a.x == b.x) {
if (a.f == b.f) return (a.i < b.i);
return (a.f < b.f);
}
return (a.x < b.x);
}
long double x;
bool operator<(point y, point z) {
long double y1, y2, dy, dx, ix, iy;
dy = a[y.i].dy;
dx = a[y.i].dx;
ix = a[y.i].x;
iy = a[y.i].y;
y1 = iy + (x - ix) * (dy / dx);
dy = a[z.i].dy;
dx = a[z.i].dx;
ix = a[z.i].x;
iy = a[z.i].y;
y2 = iy + (x - ix) * (dy / dx);
if (y1 == y2) return (y.i < z.i);
return (y1 < y2);
}
long double compute(line a, long long xn, long long xd, long long yn,
long long yd) {
long double x = xn;
x = x / xd;
x = (a.x - x) * (a.x - x);
long double y = yn;
y = y / yd;
y = (a.y - y) * (a.y - y);
long double ans = x + y;
ans = sqrt(ans);
ans = ans / a.s;
return ans;
}
bool check(int i, int j, long double t) {
long long xn, xd, yn, yd;
long double t1 = -1, t2 = -1;
if (a[i].dx * a[j].dy != a[j].dx * a[i].dy) {
xn = a[i].dx * a[j].dy * a[j].x - a[j].dx * a[i].dy * a[i].x +
a[j].dx * a[i].dx * (a[i].y - a[j].y);
xd = a[i].dx * a[j].dy - a[j].dx * a[i].dy;
yn = a[i].dy * a[j].dy * (a[j].x - a[i].x) + a[j].dy * a[i].dx * a[i].y -
a[i].dy * a[j].dx * a[j].y;
yd = a[i].dx * a[j].dy - a[j].dx * a[i].dy;
if (xd < 0) {
xn *= -1;
xd *= -1;
}
if (yd < 0) {
yn *= -1;
yd *= -1;
}
if (((a[i].dx > 0 && (xn - xd * a[i].x) >= 0) ||
(a[i].dx < 0 && (xn - xd * a[i].x) <= 0)) &&
((a[i].dy > 0 && (yn - yd * a[i].y) >= 0) ||
(a[i].dy < 0 && (yn - yd * a[i].y) <= 0)))
t1 = compute(a[i], xn, xd, yn, yd);
if (((a[j].dx > 0 && (xn - xd * a[j].x) >= 0) ||
(a[j].dx < 0 && (xn - xd * a[j].x) <= 0)) &&
((a[j].dy > 0 && (yn - yd * a[j].y) >= 0) ||
(a[j].dy < 0 && (yn - yd * a[j].y) <= 0)))
t2 = compute(a[j], xn, xd, yn, yd);
} else if ((a[i].dx * (a[j].y - a[i].y)) == (a[i].dy * (a[j].x - a[i].x))) {
bool f1 = false;
xn = a[j].x;
xd = 1;
yn = a[j].y;
yd = 1;
if (((a[i].dx > 0 && (xn - xd * a[i].x) >= 0) ||
(a[i].dx < 0 && (xn - xd * a[i].x) <= 0)) &&
((a[i].dy > 0 && (yn - yd * a[i].y) >= 0) ||
(a[i].dy < 0 && (yn - yd * a[i].y) <= 0)))
f1 = true;
bool f2 = false;
xn = a[i].x;
xd = 1;
yn = a[i].y;
yd = 1;
if (((a[j].dx > 0 && (xn - xd * a[j].x) >= 0) ||
(a[j].dx < 0 && (xn - xd * a[j].x) <= 0)) &&
((a[j].dy > 0 && (yn - yd * a[j].y) >= 0) ||
(a[j].dy < 0 && (yn - yd * a[j].y) <= 0)))
f2 = true;
if (f1 && f2) {
xn = a[i].x * a[j].s + a[j].x * a[i].s;
xd = a[i].s + a[j].s;
yn = a[i].y * a[j].s + a[j].y * a[i].s;
yd = a[i].s + a[j].s;
t1 = compute(a[i], xn, xd, yn, yd);
t2 = compute(a[j], xn, xd, yn, yd);
} else if (f1) {
xn = a[j].x;
xd = 1;
yn = a[j].y;
yd = 1;
t1 = compute(a[i], xn, xd, yn, yd);
t2 = 0;
} else if (f2) {
xn = a[i].x;
xd = 1;
yn = a[i].y;
yd = 1;
t1 = 0;
t2 = compute(a[j], xn, xd, yn, yd);
}
}
if (t1 >= 0 && t2 >= 0 && max(t1, t2) <= t) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
bool flag = false;
int n, i, j, z;
cin >> n;
for (i = 0; i < n; i++)
cin >> a[i].x >> a[i].y >> a[i].dx >> a[i].dy >> a[i].s;
long double l = 0, h = 1e13, m, dx, dy, s;
set<point> t;
set<point>::iterator it, it1, it2;
for (z = 0; z < 70; z++) {
m = (l + h) / 2;
for (i = 0; i < n; i++) {
b[2 * i].i = b[2 * i + 1].i = i;
b[2 * i].x = a[i].x;
dx = a[i].dx;
dy = a[i].dy;
s = a[i].s;
b[2 * i + 1].x = b[2 * i].x + ((dx * s * m) / sqrt(dx * dx + dy * dy));
if (b[2 * i].x < b[2 * i + 1].x) {
b[2 * i].f = 0;
b[2 * i + 1].f = 1;
} else {
b[2 * i].f = 1;
b[2 * i + 1].f = 0;
}
}
j = 2 * n;
sort(b, b + j, comp);
for (i = 0; i < j; i++) {
if (b[i].f) {
x = b[i].x;
it = t.lower_bound(c[b[i].i]);
it1 = it;
it1++;
if (it != t.begin() && it1 != t.end()) {
it2 = it;
it2--;
if (check(it1->i, it2->i, m)) break;
}
t.erase(it);
} else {
x = b[i].x;
t.insert(b[i]);
it = t.lower_bound(b[i]);
it1 = it;
it1++;
if (it1 != t.end() && check(it->i, it1->i, m)) break;
if (it != t.begin()) {
it1 = it;
it1--;
if (check(it->i, it1->i, m)) break;
}
c[b[i].i] = b[i];
}
}
if (i < j) {
flag = true;
h = m;
} else
l = m;
t.clear();
}
if (!flag)
cout << "No show :(";
else {
cout << fixed;
cout << setprecision(15);
cout << l;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
cin >> t;
while (t--) {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int pen = ceil((double)a / c);
int pencil = ceil((double)b / d);
int res = pen + pencil;
if (res <= k)
cout << pen << " " << pencil << endl;
else
cout << -1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 1000;
int n;
int target[MAXN];
char g[MAXN][MAXN + 1];
int targetedby[MAXN];
bool done[MAXN];
int solve() {
for (int x = (0); x < (n); ++x) {
for (int y = (0); y < (n); ++y) g[x][y] = '.';
g[x][n] = '\0';
}
bool identity = true;
for (int i = (0); i < (n); ++i)
if (target[i] != i) identity = false;
if (identity) return n;
for (int i = (0); i < (n); ++i) targetedby[target[i]] = i;
int last = n - 1;
while (last >= 0 && target[last] == last) --last;
assert(last >= 0);
int row = n - 1;
for (int i = (0); i < (n); ++i) done[i] = target[i] == i;
{
int to = targetedby[last];
done[to] = true;
while (!done[targetedby[to]]) {
int from = targetedby[to];
if (from < to)
g[row][from] = g[row][to] = '/';
else if (from > to)
g[row][from] = g[row][to] = '\\';
else
assert(false);
done[from] = true, to = from, --row;
}
}
for (int i = n - 1; i >= 0; --i)
if (!done[i]) {
int to = i;
while (!done[targetedby[to]]) {
int from = targetedby[to];
int realfrom = from != i ? from : last;
if (realfrom < to)
g[row][realfrom] = g[row][to] = '/';
else if (realfrom > to)
g[row][realfrom] = g[row][to] = '\\';
else
assert(false);
if (to == i) {
assert(from < to);
g[row][last] = '/';
}
done[from] = true, to = from, --row;
}
}
return n - 1;
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", &target[i]), --target[i];
printf("%d\n", solve());
for (int x = (0); x < (n); ++x) printf("%s\n", g[x]);
}
const int DX[] = {-1, 0, +1, 0}, DY[] = {0, -1, 0, +1};
int walk(int x, int y, int k) {
while (true) {
x += DX[k], y += DY[k];
if (x < 0 || x >= n || y < 0 || y >= n) break;
if (g[x][y] == '\\')
k ^= 1;
else if (g[x][y] == '/')
k = 3 - k;
}
return x == -1 ? y : -1;
}
void stress() {
for (int rep = (0); rep < (10000); ++rep) {
n = MAXN;
for (int i = (0); i < (n); ++i) target[i] = i;
for (int i = (0); i < (n); ++i) {
int idx = rand() % (i + 1);
swap(target[i], target[idx]);
}
int have = solve();
int cnt = 0;
for (int i = (0); i < (n); ++i)
if (walk(n, i, 0) == target[i]) ++cnt;
if (have == cnt) {
printf(".");
continue;
}
printf("err\n");
for (int i = (0); i < (n); ++i) {
if (i != 0) printf(" ");
printf("%d", target[i]);
}
puts("");
printf("have=%d cnt=%d\n", have, cnt);
for (int x = (0); x < (n); ++x) printf("%s\n", g[x]);
exit(0);
}
}
int main() {
run();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[5][5];
int n = 5;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) cin >> a[i][j];
vector<int> v;
for (int i = 0; i < n; i++) v.push_back(i);
long long ans = 0;
do {
long long cur = 0;
for (int i = 0; i < n; i += 2)
if (i + 1 < n) {
int x = v[i];
int y = v[i + 1];
cur += (a[x][y] + a[y][x]);
}
for (int i = 1; i < n; i += 2)
if (i + 1 < n) {
int x = v[i];
int y = v[i + 1];
cur += (a[x][y] + a[y][x]);
}
for (int i = 2; i < n; i += 2)
if (i + 1 < n) {
int x = v[i];
int y = v[i + 1];
cur += (a[x][y] + a[y][x]);
}
for (int i = 3; i < n; i += 2)
if (i + 1 < n) {
int x = v[i];
int y = v[i + 1];
cur += (a[x][y] + a[y][x]);
}
ans = max(ans, cur);
} while (next_permutation(v.begin(), v.end()));
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> f, s;
int main() {
int n;
cin >> n;
int lst;
long long sumf = 0, sums = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a < 0) {
s.push_back(a * -1);
sums += a;
lst = 2;
} else {
f.push_back(a);
sumf += a;
lst = 1;
}
}
sums *= -1;
if (sumf > sums) {
cout << "first\n";
return 0;
} else if (sumf < sums) {
cout << "second\n";
return 0;
}
for (int i = 0; i < min(s.size(), f.size()); i++) {
if (s[i] > f[i]) {
cout << "second\n";
return 0;
}
if (s[i] < f[i]) {
cout << "first\n";
return 0;
}
}
if (s.size() > f.size()) {
cout << "second\n";
return 0;
} else if (f.size() > s.size()) {
cout << "first\n";
return 0;
}
if (lst == 1)
cout << "first\n";
else
cout << "second\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 5;
const int mod = 1e9 + 7;
int cnt[105], a[105];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> a[i], cnt[a[i]]++;
int i = (m / n);
for (; i > 0; i--) {
int sum = 0;
for (int j = 1; j <= 100; j++) sum += (cnt[j] / i);
if (sum >= n) {
cout << i << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int inf = INT_MAX;
const int nmax = 1e5 + 5;
const int mod = 1e9 + 7;
using namespace std;
int n, cnt[nmax], a, i, j, v, x;
vector<int> pos[nmax * 10];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n >> a;
for (i = 1; i <= n; i++) {
cin >> x;
cnt[i] = cnt[i - 1];
if (x == a)
cnt[i]++;
else
pos[x].push_back(i);
}
for (i = 1; i <= 1e6; i++)
if (i != a && pos[i].size() >= cnt[n]) {
v = 1;
for (j = 0; j < pos[i].size(); j++)
if (cnt[pos[i][j]] > j) {
v = 0;
break;
}
if (v) return cout << i << endl, 0;
}
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[200010], b[200010];
pair<int, int> c[200010], d[200010];
int ans[200010];
int main() {
int m, i;
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &a[i]);
c[i] = pair<int, int>(a[i], i);
}
for (i = 1; i <= m; i++) {
scanf("%d", &b[i]);
d[i] = pair<int, int>(b[i], i);
}
sort(c + 1, c + m + 1);
sort(d + 1, d + m + 1);
for (i = 1; i <= m; i++) ans[d[i].second] = c[m - i + 1].first;
for (i = 1; i <= m; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e6;
long long cnt[MAXN], pcnt[MAXN], pmx[MAXN];
void upd(long long &mx1, long long &mx2) {
if (mx2 > mx1) {
swap(mx1, mx2);
}
}
long long getPref(long long l, long long r) {
r = min(MAXN - 1, r);
return pcnt[r] - pcnt[l - 1];
}
long long checkOne(long long y, long long k, long long all) {
long long maxs = 0;
long long maxOst = 0;
k--;
while (k > 0) {
long long R = y * (k + 1) - 1;
if (pmx[R] >= k * y) {
maxOst = max(maxOst, pmx[R] % y);
}
long long x = (k * y + maxOst) / 2;
x = min(x, all - k);
maxs = max(maxs, x * y);
k--;
}
return maxs;
}
long long checkTwo(long long y, long long k, long long all) {
long long mx1 = 0, mx2 = 0;
long long maxs = 0;
k--;
while (k >= 0) {
long long R = y * (k + 1) - 1;
long long f = pmx[R];
long long s = f;
if (cnt[f] == 1) {
s = pmx[f - 1];
}
if (f % y > mx2 && f >= y * k) {
mx2 = f % y;
upd(mx1, mx2);
}
if (s % y > mx2 && s >= y * k) {
mx2 = s % y;
upd(mx1, mx2);
}
long long x1 = k * y + mx1;
long long x2 = k * y + mx2;
if (getPref(x1, MAXN) < 2) {
x1 = 0;
}
if (getPref(x2, MAXN) < 2) {
x2 = 0;
}
x1 = min(x1, all - 2 * k - 1);
x2 = min(x2, all - 2 * k);
if (x1 > 1) {
maxs = max(maxs, x1 * y);
}
if (x2 > 1) {
maxs = max(maxs, x2 * y);
}
k--;
}
return maxs;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, maxa = 0;
cin >> n;
vector<long long> arr(n);
for (long long i = 0; i < n; i++) {
cin >> arr[i];
maxa = max(maxa, arr[i]);
cnt[arr[i]]++;
}
sort(arr.begin(), arr.end());
for (long long i = 1; i < MAXN; i++) {
pcnt[i] = pcnt[i - 1];
pcnt[i] += cnt[i];
pmx[i] = pmx[i - 1];
if (cnt[i] > 0) {
pmx[i] = i;
}
}
long long answer = 0;
for (long long i = 2; i <= maxa; i++) {
long long all = 0;
long long k = 1;
while (i * k <= maxa) {
k++;
all += getPref(i * (k - 1), i * k - 1) * (k - 1);
}
answer = max(answer, checkOne(i, k, all));
answer = max(answer, checkTwo(i, k, all));
}
cout << answer << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
cout << (n + 1) / 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, x;
long long ans;
unordered_map<int, int> cnt;
string st;
char ss[1000005];
int main() {
scanf("%d", &n);
while (n--) {
scanf(" %s", ss);
st = ss;
x = 0;
for (i = 0; i < st.length(); i++) x ^= (1 << (st[i] - 'a'));
for (i = 0; i < 26; i++) ans += cnt[x ^ (1 << i)];
ans += cnt[x];
cnt[x]++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
string s;
cin >> s;
int n = (int)s.size();
vector<vector<bool>> dp(n, vector<bool>(2));
dp[n - 1][0] = (n >= 7);
dp[n - 1][1] = (n >= 8);
for (int i = n - 3; i >= 6; --i) {
string sub2 = s.substr(i - 1, 2);
string sub3 = s.substr(i - 2, 3);
if (i <= n - 3) {
string psub2 = s.substr(i + 1, 2);
if (psub2 != sub2 && dp[i + 2][0]) dp[i][0] = 1;
}
if (i <= n - 4) {
if (dp[i + 3][1]) dp[i][0] = 1;
}
if (i >= 7) {
if (i <= n - 3) {
if (dp[i + 2][0]) dp[i][1] = 1;
}
if (i <= n - 4) {
string psub3 = s.substr(i + 1, 3);
if (psub3 != sub3 && dp[i + 3][1]) dp[i][1] = 1;
}
}
}
set<string> ans;
for (int i = 6; i < n; ++i) {
if (dp[i][0]) ans.insert(s.substr(i - 1, 2));
if (dp[i][1]) ans.insert(s.substr(i - 2, 3));
}
cout << ans.size() << "\n";
for (auto i : ans) cout << i << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
scanf("%d %d %d", &a, &b, &c);
if (a > b) swap(a, b);
if (c < a)
swap(a, c), swap(c, b);
else if (c < b)
swap(b, c);
printf("%d", min(a + b + c, a + a + b + b));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long base = 1e9 + 7;
const long long MAX_N = 2e6 + 1;
string getWinner(int i) {
if (i % 2) return "Bob";
return "Alice";
}
void Solves() {
long long n;
cin >> n;
long long a[n + 2];
for (int i = 1; i <= n; i++) cin >> a[i];
vector<long long> left;
vector<long long> right;
for (int i = 1; i <= n; i++) {
if (i == 1 || a[i] > a[i - 1])
left.push_back(a[i]);
else
break;
}
for (int i = n; i >= 1; i--) {
if (i == n || a[i] > a[i + 1])
right.push_back(a[i]);
else
break;
}
reverse(left.begin(), left.end());
reverse(right.begin(), right.end());
long long ans = 0;
while (1) {
long long l = left.back();
long long r = right.back();
if (l > r) {
if (left.size() % 2 == 1) {
cout << getWinner(ans);
break;
}
right.pop_back();
ans++;
ans %= 2;
}
if (r > l) {
if (right.size() % 2 == 1) {
cout << getWinner(ans);
break;
}
left.pop_back();
ans++;
ans %= 2;
}
if (l == r) {
if (left.size() % 2 == 1 || right.size() % 2 == 1) {
cout << getWinner(ans);
} else {
cout << getWinner((ans + 1) % 2);
}
break;
}
}
}
int main() { Solves(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1e9;
long long powm(long long a, long long p, long long m) {
long long r = 1 % m;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
int n, q;
vector<int> lst[300001];
int ans[300001];
set<pair<int, int> > s[300001];
int dfs(int p) {
int cnt = 1;
for (int i = 0; i < lst[p].size(); ++i) {
cnt += dfs(lst[p][i]);
if (s[p].size() < s[lst[p][i]].size()) swap(s[p], s[lst[p][i]]);
s[p].insert(s[lst[p][i]].begin(), s[lst[p][i]].end());
}
s[p].insert(make_pair(cnt, p));
ans[p] = s[p].lower_bound(make_pair((cnt + 1) / 2, 0))->second;
return cnt;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 2, p; i <= n; ++i) {
scanf("%d", &p);
lst[p].push_back(i);
}
dfs(1);
for (int i = 0, v; i < q; ++i) {
scanf("%d", &v);
printf("%d\n", ans[v]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e6;
long long c0[maxn + 1];
long long c1[maxn + 1];
long long c3[maxn + 1];
long long ans[maxn + 1];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
c0[1] = 1;
c1[1] = 0;
c3[1] = 0;
for (long long i = 2; i <= maxn; i++) {
c3[i] = (c1[i - 1] + c3[i - 1]) % 1000000007;
c1[i] = (c0[i - 1]) % 1000000007;
c0[i] = (2 * c1[i - 1] + c0[i - 1]) % 1000000007;
}
ans[1] = 0;
ans[2] = 0;
ans[3] = 1;
for (long long i = 4; i <= maxn; i++) {
ans[i] = (c1[i - 1] + ans[i - 3]) % 1000000007;
}
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
continue;
}
if (n == 2) {
cout << 0 << endl;
continue;
}
cout << (ans[n] * 4) % 1000000007 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, m;
cin >> n >> m;
vector<int> v;
for (int i = 0; i < m; i++) cin >> a[i];
for (int i = 1; i <= n; i++) v.push_back(i);
int lea = 0;
for (int i = 0; i < m; i++) {
lea = (lea + a[i]) % v.size();
cout << v[lea] << " ";
v.erase(v.begin() + lea);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int Mod = 998244353;
const int G = 3;
inline int qPow(int b, int e) {
int a = 1;
for (e < 0 ? e += Mod - 1 : 0; e; b = (long long)b * b % Mod, e >>= 1)
if (e & 1) a = (long long)a * b % Mod;
return a;
}
inline int chkto(int x) { return x >= Mod ? x - Mod : x; }
inline int chkuo(int x) { return x < 0 ? x + Mod : x; }
int A[1 << 21 | 1], B[1 << 21 | 1], R[1 << 21 | 1];
void NTT(int *A, int Sz, int t) {
for (int i = 0; i < Sz; ++i)
if (R[i] < i) std::swap(A[R[i]], A[i]);
for (int j = 1; j < Sz; j <<= 1) {
int j2 = j << 1;
int gn = qPow(G, t * (Mod - 1) / j2);
for (int i = 0; i < Sz; i += j2) {
int g = 1;
for (int k = 0; k < j; ++k, g = (long long)g * gn % Mod) {
int X = A[i + k], Y = (long long)g * A[i + j + k] % Mod;
A[i + k] = chkto(X + Y);
A[i + j + k] = chkuo(X - Y);
}
}
}
if (t == -1)
for (int i = 0, InvSz = qPow(Sz, Mod - 2); i < Sz; ++i)
A[i] = (long long)A[i] * InvSz % Mod;
}
int main() {
int N, K, Sz, Bt;
scanf("%d%d", &N, &K);
for (int i = 1, x; i <= K; ++i) scanf("%d", &x), A[x] = 1;
int Len = 9 * N / 2 + 1;
for (Sz = 1, Bt = 0; Sz < Len; Sz <<= 1, ++Bt)
;
for (int i = 0; i < Sz; ++i) R[i] = R[i >> 1] >> 1 | (i & 1) << (Bt - 1);
NTT(A, Sz, 1);
for (int i = 0; i < Sz; ++i) A[i] = qPow(A[i], N / 2);
NTT(A, Sz, -1);
int Ans = 0;
for (int i = 0; i < Len; ++i) Ans = (Ans + (long long)A[i] * A[i]) % Mod;
printf("%d\n", Ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
std::uniform_int_distribution<std::mt19937::result_type> udist(0, 1);
std::mt19937 rng;
using namespace std;
FILE *in, *out;
int ri() {
int a;
fscanf(in, "%d", &a);
return a;
}
double rf() {
double a;
fscanf(in, "%lf", &a);
return a;
}
char sbuf[100005];
string rstr() {
char c;
char *b = sbuf;
while (c = fgetc(in)) {
if (c == '\n' || c == 255) break;
*b++ = c;
}
*b = 0;
return sbuf;
}
long long nod(long long a, long long b) {
if (a == 1 || b == 1) return 1;
if (a == 0) return b;
if (b == 0) return a;
return nod(b % a, a);
}
vector<int> primes;
void calculatePrimes() {
primes.push_back(2);
for (int i = 3; i < 1000000; i += 2) {
bool bFound = false;
int m = (int)sqrt((float)i);
for (int j = 1; j < primes.size() && !bFound && primes[j] <= m; j++)
bFound = ((i % primes[j]) == 0);
if (!bFound) primes.push_back(i);
}
}
bool isPrime(long long p) {
for (int i : primes)
if (p != i && (p % i) == 0) return false;
return true;
}
void egcd(long long a, long long b, long long &g, long long &x, long long &y) {
if (a == 0) {
g = b;
x = 0;
y = 1;
return;
}
egcd(b % a, a, g, y, x);
x = x - (b / a) * y;
}
long long modinv(long long a, long long m) {
long long g = 0, x = 0, y = 0;
egcd(a, m, g, x, y);
return (x + m) % m;
}
long long modpow(int a, long long n, int p) {
long long res = 1;
long long curp = (a % p);
while (n) {
if (n & 1) {
res = (res * curp) % p;
}
curp = (curp * curp) % p;
n /= 2;
}
return res;
}
long long nf(int n) {
if (n <= 1) return 1;
return (n * nf(n - 1)) % 998244353;
}
long long intpowmod(long long base, long long exp) {
if (exp == 0) return 1;
if (exp == 1) return base;
if ((exp & 1) != 0)
return (base * intpowmod((base * base) % 998244353, exp / 2)) % 998244353;
return intpowmod((base * base) % 998244353, exp / 2);
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int co = n - k - 1;
long long res = m;
res = (res * intpowmod(m - 1, k)) % 998244353;
res = (res * nf(co + k)) % 998244353;
res = (res * modinv(nf(co), 998244353)) % 998244353;
res = (res * modinv(nf(k), 998244353)) % 998244353;
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, rem;
cin >> a >> b;
long long int count = 0;
a = max(a, b);
b = min(a, b);
while (a != b && b != 0) {
count += a / b;
rem = a % b;
a = b;
b = rem;
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXLEN = 701;
const int MOD = 1000000007;
const int INV9 = 111111112;
char s[MAXLEN + 1];
int n;
int ones[MAXLEN + 1];
int dp[MAXLEN + 1][MAXLEN + 1][2];
void inc(int &a, long long b) { a = (a + b) % MOD; }
void run() {
scanf("%s", s);
n = strlen(s);
ones[0] = 0;
for (int i = (1); i <= (n); ++i)
ones[i] = ((long long)10 * ones[i - 1] + 1) % MOD;
int ret = 0;
for (int k = (1); k <= (9); ++k) {
memset(dp, 0, sizeof(dp));
dp[0][0][1] = 1;
for (int i = (0); i < (n); ++i)
for (int j = (0); j <= (i); ++j) {
inc(dp[i + 1][j][0], (long long)k * dp[i][j][0]);
inc(dp[i + 1][j + 1][0], (long long)(10 - k) * dp[i][j][0]);
inc(dp[i + 1][j][0], (long long)min(k, s[i] - '0') * dp[i][j][1]);
inc(dp[i + 1][j + 1][0],
(long long)max(0, s[i] - '0' - k) * dp[i][j][1]);
inc(dp[i + 1][j + (s[i] - '0' >= k ? 1 : 0)][1], dp[i][j][1]);
}
for (int j = (0); j <= (n); ++j)
for (int eq = (0); eq < (2); ++eq)
inc(ret, (long long)dp[n][j][eq] * ones[j]);
}
printf("%d\n", ret);
}
int main() {
run();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
const int maxn = 1e5 + 7;
int m, n, u, v, minn = oo, p[maxn];
vector<int> a[maxn], A, B;
bool flag = true;
void nhap() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> u >> v;
minn = min(min(minn, u), v);
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = 1; i <= n; ++i) p[i] = -1;
}
void dfs(int u, int c) {
if (!flag) return;
if (p[u] != -1) {
if (p[u] != c) {
flag = false;
return;
} else
return;
}
p[u] = c;
if (c == 1)
A.push_back(u);
else
B.push_back(u);
if (a[u].size()) {
for (int i = 0; i <= a[u].size() - 1; ++i) {
if (c == 1)
dfs(a[u][i], 2);
else
dfs(a[u][i], 1);
}
}
}
void solve() {
for (int i = 1; i <= n; ++i)
if (a[i].size() && p[i] == -1) dfs(i, 1);
if (!flag) {
cout << -1;
return;
}
cout << A.size() << endl;
for (int i = 0; i <= A.size() - 1; ++i) cout << A[i] << ' ';
cout << endl;
cout << B.size() << endl;
for (int i = 0; i <= B.size() - 1; ++i) cout << B[i] << ' ';
}
void print() {}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
nhap();
solve();
print();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, k, n;
cin >> y >> k >> n;
int i;
int from = ceil((double)y / k);
if (k * from - y == 0 && y != n) from++;
int to = n / k;
if (from > to)
cout << -1;
else if (from == to) {
if (k * from - y > 0)
cout << k * from - y;
else
cout << -1;
} else
for (int i = from; i <= to; i++) {
cout << k * i - y << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long b, an;
long long a[9];
long long d[100009];
long long f[100009];
int main() {
for (int i = 0; i < 6; i++) scanf("%I64d", &a[i]);
scanf("%I64d", &b);
for (int i = 1; i <= b; i++) {
scanf("%I64d", &d[i]);
f[i] = d[i];
}
for (int i = 0; i < 3; i++) {
long long k = 0, c = 0;
while (c <= b) {
c += a[i];
for (int j = min(c, b); j > c - a[i]; j--) {
if (j - a[i] >= 1)
d[j] = max(d[j], d[j - a[i]]) + a[i + 3];
else
d[j] += a[i + 3];
}
}
}
for (int i = 1; i <= b; i++) an = max(an, d[i] - f[i]);
printf("%I64d", an);
getchar();
getchar();
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("trapv")
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
#pragma GCC target("avx2")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long MOD = 1000000007;
const long long MOD2 = 998244353;
const long long BIG = 1197423052705914509LL;
mt19937 rng(
(long long)std::chrono::steady_clock::now().time_since_epoch().count());
const long long MAXN = 610;
const long long is_query = -BIG;
struct line {
long long m, b;
mutable function<const line*()> succ;
bool operator<(const line& rhs) const {
if (rhs.b != is_query) return m < rhs.m;
const line* s = succ();
if (!s) return 0;
long long x = rhs.m;
return b - s->b < (s->m - m) * x;
}
};
struct dynamic_hull : public multiset<line> {
const long long inf = BIG;
bool bad(iterator y) {
auto z = next(y);
if (y == begin()) {
if (z == end()) return 0;
return y->m == z->m && y->b <= z->b;
}
auto x = prev(y);
if (z == end()) return y->m == x->m && y->b <= x->b;
long long v1 = (x->b - y->b);
if (y->m == x->m)
v1 = x->b > y->b ? inf : -inf;
else
v1 /= (y->m - x->m);
long long v2 = (y->b - z->b);
if (z->m == y->m)
v2 = y->b > z->b ? inf : -inf;
else
v2 /= (z->m - y->m);
return v1 >= v2;
}
void insert_line(long long m, long long b) {
auto y = insert({m, b});
y->succ = [=] { return next(y) == end() ? 0 : &*next(y); };
if (bad(y)) {
erase(y);
return;
}
while (next(y) != end() && bad(next(y))) erase(next(y));
while (y != begin() && bad(prev(y))) erase(prev(y));
}
long long eval(long long x) {
auto l = *lower_bound((line){x, is_query});
return l.m * x + l.b;
}
};
struct auxiliary_tree {
long long n;
vector<long long> ori[MAXN];
vector<long long> storelatest;
long long tin[MAXN], tout[MAXN], dep[MAXN], cor[MAXN];
bool imp[MAXN];
long long run = 0;
vector<long long> euler;
vector<vector<pair<long long, long long> > > lca_table;
long long lef[MAXN], rig[MAXN];
void dfs(long long node, long long prev, long long de) {
dep[node] = de;
tin[node] = ++run;
cor[tin[node]] = node;
euler.push_back(node);
for (long long i = 0; i < ori[node].size(); i++) {
if (ori[node][i] != prev) {
dfs(ori[node][i], node, de + 1);
euler.push_back(node);
}
}
tout[node] = ++run;
}
void find_all_lcas() {
long long k = log2(2 * n - 1);
lca_table.resize(k + 1);
for (long long i = 0; i < k + 1; i++) {
lca_table[i].resize(2 * n - 1);
}
for (long long i = 0; i < 2 * n - 1; i++) {
lca_table[0][i] = make_pair(dep[euler[i]], euler[i]);
}
for (long long i = 1; i <= k; i++) {
for (long long j = 0; j < 2 * n - 1; j++) {
if (j + (1 << (i - 1)) >= 2 * n - 1) continue;
if (lca_table[i - 1][j].first <
lca_table[i - 1][j + (1 << (i - 1))].first) {
lca_table[i][j].first = lca_table[i - 1][j].first;
lca_table[i][j].second = lca_table[i - 1][j].second;
} else {
lca_table[i][j].first = lca_table[i - 1][j + (1 << (i - 1))].first;
lca_table[i][j].second = lca_table[i - 1][j + (1 << (i - 1))].second;
}
}
}
for (long long i = 0; i < MAXN; i++) lef[i] = -1;
for (long long i = 0; i < 2 * n - 1; i++) {
if (lef[euler[i]] == -1) {
lef[euler[i]] = i;
}
rig[euler[i]] = i;
}
}
bool isParent(long long u, long long v) {
return tin[u] < tin[v] && tout[v] < tout[u];
}
public:
vector<long long> adj[MAXN];
long long root;
long long lcadep(long long x, long long y) {
if (lef[x] > rig[y]) {
swap(x, y);
}
long long k = log2(rig[y] - lef[x] + 1);
return min(lca_table[k][lef[x]].first,
lca_table[k][rig[y] - (1 << k) + 1].first);
}
long long lcaidx(long long x, long long y) {
if (lef[x] > rig[y]) {
swap(x, y);
}
long long k = log2(rig[y] - lef[x] + 1);
if (lca_table[k][lef[x]].first <
lca_table[k][rig[y] - (1 << k) + 1].first) {
return lca_table[k][lef[x]].second;
} else {
return lca_table[k][rig[y] - (1 << k) + 1].second;
}
}
void base(long long x, long long rt, vector<long long> y[]) {
n = x;
for (long long i = 1; i <= n; i++) {
ori[i] = y[i];
}
dfs(rt, -1, 0);
find_all_lcas();
}
void build(vector<long long> g) {
for (long long i = 0; i < g.size(); i++) {
g[i] = tin[g[i]];
}
sort(g.begin(), g.end());
for (long long i = 0; i < g.size(); i++) {
g[i] = cor[g[i]];
}
long long k = g.size();
for (long long i = 0; i < k - 1; i++) {
g.push_back(lcaidx(g[i], g[i + 1]));
}
for (long long i = 0; i < g.size(); i++) {
g[i] = tin[g[i]];
}
sort(g.begin(), g.end());
for (long long i = 0; i < g.size(); i++) {
g[i] = cor[g[i]];
}
g.erase(unique(g.begin(), g.end()), g.end());
for (long long i = 0; i < g.size(); i++) {
imp[g[i]] = 1;
storelatest.push_back(g[i]);
}
stack<long long> vert;
vert.push(g[0]);
for (long long i = 1; i < g.size(); i++) {
long long u = g[i];
while (vert.size() > 1 && isParent(vert.top(), u) == 0) {
long long sto = vert.top();
vert.pop();
adj[vert.top()].push_back(sto);
}
vert.push(u);
}
while (vert.size() > 1) {
long long sto = vert.top();
vert.pop();
adj[vert.top()].push_back(sto);
}
root = vert.top();
}
void clear() {
for (long long i = 0; i < storelatest.size(); i++) {
imp[storelatest[i]] = 0;
adj[storelatest[i]].clear();
}
storelatest.clear();
}
};
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t a) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(a + FIXED_RANDOM);
}
template <class T>
size_t operator()(T a) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
hash<T> x;
return splitmix64(x(a) + FIXED_RANDOM);
}
template <class T, class H>
size_t operator()(pair<T, H> a) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
hash<T> x;
hash<H> y;
return splitmix64(x(a.f) * 37 + y(a.s) + FIXED_RANDOM);
}
};
template <class T, class H>
using umap = unordered_map<T, H, custom_hash>;
map<pair<long long, long long>, long long> money;
void solve(long long test_case) {
long long n, a, b, k, f;
cin >> n >> a >> b >> k >> f;
unordered_map<string, long long> make_pair;
long long From[n + 1], To[n + 1];
long long next = 1;
for (long long i = 1; i <= n; i++) {
string x, y;
cin >> x >> y;
if (make_pair[x] == 0) {
make_pair[x] = next;
next++;
}
From[i] = make_pair[x];
if (make_pair[y] == 0) {
make_pair[y] = next;
next++;
}
To[i] = make_pair[y];
long long m1 = min(From[i], To[i]);
long long m2 = max(From[i], To[i]);
if (i == 1 || From[i] != To[i - 1])
money[{m1, m2}] += a;
else
money[{m1, m2}] += b;
}
priority_queue<pair<long long, pair<long long, long long> > > pq;
for (long long i = 1; i < next; i++) {
for (long long j = i + 1; j < next; j++) {
if (money[{i, j}] > f) {
pq.push({money[{i, j}] - f, {i, j}});
}
}
}
map<pair<long long, long long>, long long> card;
k = min(k, (long long)pq.size());
long long ans = 0;
while (k--) {
card[{pq.top().second.first, pq.top().second.second}] = 1;
ans += f;
pq.pop();
}
for (long long i = 1; i < next; i++) {
for (long long j = i + 1; j < next; j++) {
if (card[{i, j}]) continue;
ans += money[{i, j}];
}
}
cout << ans << "\n";
}
int32_t main() {
time_t t = clock();
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
long long T = 1;
long long test_case = 1;
while (T--) {
solve(test_case);
test_case++;
}
cerr << "Program terminated successfully\n";
t = clock() - t;
cerr << "Time used: " << fixed << setprecision(3)
<< (long double)(t * 1.0 / CLOCKS_PER_SEC) << " seconds\n";
}
| 5 |
#include <bits/stdc++.h>
char s1[200005], s2[200005];
int a[200005] = {0}, b[200005] = {0};
int len1, len2, mid;
int work(int x) {
int i, j, k, l;
for (i = 1; i <= len1; i++) b[i] = 0;
for (i = 1; i <= x; i++) b[a[i]] = 1;
j = 1;
for (i = 1; i <= len1; i++) {
if ((s1[i] == s2[j]) && (b[i] == 0)) {
j++;
if (j > len2) {
return 1;
}
}
}
return 0;
}
int main() {
int i, j, k, l, r, n;
scanf("%s", s1 + 1);
scanf("%s", s2 + 1);
len1 = strlen(s1 + 1);
len2 = strlen(s2 + 1);
for (i = 1; i <= len1; i++) scanf("%d", &a[i]);
l = 0;
r = len1 - 1;
while (l < r) {
mid = (l + r + 1) / 2;
if (work(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void io() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
long long tab[(1 << 22)];
long long sz[(1 << 22)];
long long hDeb, hFin;
vector<long long> moves;
void f(long long i) {
if (tab[2 * i] == 0 && tab[2 * i + 1] == 0) {
tab[i] = 0;
} else {
if (tab[2 * i] > tab[2 * i + 1]) {
tab[i] = tab[2 * i];
f(2 * i);
} else {
tab[i] = tab[2 * i + 1];
f(2 * i + 1);
}
}
}
bool canDo(long long i, long long prof) {
if (tab[2 * i] == 0 && tab[2 * i + 1] == 0) {
return prof >= hFin;
} else {
if (tab[2 * i] > tab[2 * i + 1]) {
return canDo(2 * i, prof + 1);
} else {
return canDo(2 * i + 1, prof + 1);
}
}
}
void clear(long long i, long long prof) {
if (prof >= hFin) return;
while (canDo(i, prof)) {
f(i);
moves.push_back(i);
}
clear(2 * i, prof + 1);
clear(2 * i + 1, prof + 1);
}
signed main() {
io();
long long nbTests;
cin >> nbTests;
for (long long iTest = 0; iTest < nbTests; iTest++) {
cin >> hDeb >> hFin;
for (long long i = 1; i < (1 << hDeb); i++) {
cin >> tab[i];
}
for (long long i = (1 << hDeb); i < 2 * (1 << hDeb); i++) {
tab[i] = 0;
}
clear(1, 0);
long long sum = 0;
for (long long i = 1; i < (1 << hFin); i++) {
sum += tab[i];
}
cout << sum << endl;
for (long long move : moves) {
cout << move << " ";
}
cout << endl;
moves.clear();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 3e5 + 10;
const int mod = 1e9 + 7;
long long a[maxn];
int main() {
long long n, m;
scanf("%I64d%I64d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
int now = 0;
for (int i = 0; i < n; i++) {
printf("%I64d%c", (a[i] + now) / m, " \n"[i == n - 1]);
now = (a[i] + now) % m;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const long long int LINF = 1LL * INF * INF;
const int MAXN = 2e5 + 10;
const int MAXM = 5e3 + 10;
priority_queue<int> pq;
vector<vector<int> > graph;
queue<int> que;
int A[MAXN];
char S[MAXN];
int main() {
int n, m, k, a, b, x, y;
int sum = 0;
int cnt = 0;
int mx = 0;
int mn = INF;
int cur = 0, idx = -1;
char c;
cin >> n >> a >> b;
x = a;
y = b;
for (int i = 1; i <= n; i++) {
cin >> c;
if (c == '.') A[i] = 1;
}
for (int i = 1; i <= n; i++) {
if (!A[i]) {
if (sum % 2) cnt++;
a -= sum / 2;
b -= sum / 2;
sum = 0;
} else {
sum++;
}
}
if (sum % 2) cnt++;
a -= sum / 2;
b -= sum / 2;
a = max(0, a);
b = max(0, b);
int res = max(a + b - cnt, 0);
cout << (x + y) - res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long cross(pair<long long, long long> o, pair<long long, long long> a,
pair<long long, long long> b) {
return (a.first - o.first) * (b.second - o.second) -
(a.second - o.second) * (b.first - o.first);
}
inline std::ostream &operator<<(std::ostream &o, pair<long long, long long> a) {
o << "(" << a.first << "," << a.second << ")";
return o;
}
inline std::istream &operator>>(std::istream &i,
pair<long long, long long> &a) {
i >> a.first >> a.second;
return i;
}
long long count(vector<pair<long long, long long> > &p,
pair<long long, long long> q) {
long long ret = 0;
int i = 0, j = 1, n = int((p).size());
while (i < n) {
while (cross(p[i], p[(j + 1) % n], q) > 0) j = (j + 1) % n;
int t = max(0, (j - i + n) % n - 1);
ret += 1ll * t * (t + 1) / 2;
i++;
}
return 1ll * n * (n - 1) * (n - 2) / 6 - ret;
}
int main() {
std::ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<long long, long long> > p(n);
for (int i = 0; i < int(n); i++) cin >> p[i];
reverse((p).begin(), (p).end());
int t;
cin >> t;
for (int i = 0; i < int(t); i++) {
pair<long long, long long> q;
cin >> q;
for (int i = 0; i < int(n); i++)
if (cross(p[i], p[(i + 1) % n], q) < 0) {
cout << "0\n";
goto hell;
}
cout << count(p, q) << "\n";
hell:;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool cand[100100], first[100100];
char op[100100];
int num[100100];
void check(set<int>& pos, set<int>& neg) {
if (pos.size() == 0) {
return;
}
set<int>::iterator it;
for (it = neg.begin(); it != neg.end(); ++it) {
cand[*it] = false;
}
neg.clear();
}
int main() {
memset(cand, -1, sizeof(cand));
memset(first, -1, sizeof(first));
int n, m, i;
set<int> pos, neg;
vector<int> ans;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf(" %c%d", &op[i], &num[i]);
if (first[num[i]]) {
first[num[i]] = false;
if (op[i] == '-')
pos.insert(num[i]);
else
neg.insert(num[i]);
}
}
check(pos, neg);
for (i = 0; i < m; i++) {
if (op[i] == '+') {
pos.insert(num[i]);
if (neg.count(num[i])) neg.erase(num[i]);
} else {
neg.insert(num[i]);
if (pos.count(num[i])) pos.erase(num[i]);
}
check(pos, neg);
}
for (i = 1; i <= n; i++) {
if (cand[i]) ans.push_back(i);
}
printf("%d\n", ans.size());
for (i = 0; i < ans.size(); i++) {
if (i) putchar(' ');
printf("%d", ans[i]);
}
if (ans.size()) putchar('\n');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r;
long long ans1 = 1, ans2 = 1;
cin >> n >> l >> r;
int mid = 1;
for (int i = 1; i < l; i++) {
mid *= 2;
ans1 += mid;
}
ans1 += n - l;
mid = 1;
for (int i = 1; i < r; i++) {
mid *= 2;
ans2 += mid;
}
for (int i = 0; i < n - r; i++) ans2 += mid;
cout << ans1 << " " << ans2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1000000007;
long long exp(long long a, long long b) {
if (b == 0) return 1;
long long tmp = exp(a, b / 2);
if (b % 2 == 0)
return (tmp * tmp) % N;
else
return (((a * tmp) % N) * tmp) % N;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k == 1) {
cout << exp(m, n) << endl;
} else if (k < n && k % 2 == 1) {
cout << exp(m, 2) << endl;
} else if (k < n && k % 2 == 0) {
cout << m << endl;
} else if (k == n) {
cout << exp(m, (k + 1) / 2) << endl;
} else {
cout << exp(m, n) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int64_t x1, x2, x3, y1, y2, y3;
cin >> x1 >> x2 >> x3;
cin >> y1 >> y2 >> y3;
if (x1 != y1 && x2 != y2 && x3 != y3)
cout << "NO";
else
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long s;
long long p;
int n;
long long a[100001];
int main() {
cin >> n >> p;
long long s1 = 0;
long long s2 = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
s1 = a[1];
for (int i = 2; i <= n; i++) s2 += a[i];
s = max(s, s1 % p + s2 % p);
for (int i = 2; i < n; i++) {
s1 += a[i];
s2 -= a[i];
s = max(s, s1 % p + s2 % p);
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
int main() {
long long n, m, tc, num, t = 1;
scanf("%lld %lld", &num, &m);
vector<long long> v1, v2;
for (long long i = 0; i < num; ++i) {
scanf("%lld", &n);
v1.push_back(n);
}
for (long long i = 0; i < num; ++i) {
scanf("%lld", &n);
v2.push_back(n);
}
sort(v2.begin(), v2.end());
long long ans = INT_MAX;
for (long long i = 0; i < num; ++i) {
vector<long long> temp;
long long avgmod = (m + v2[i] - v1[0]) % m;
for (long long j = 0; j < num; ++j) {
temp.push_back((v1[j] + avgmod) % m);
}
sort(temp.begin(), temp.end());
if (v2 == temp) {
ans = min(ans, avgmod);
}
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool dp[1002][2001];
string s;
void solve(int ind, int cur) {
if (ind == n) {
if (abs(cur) == k) {
cout << s << endl;
exit(0);
}
return;
}
if (dp[ind][cur + 1000]) return;
dp[ind][cur + 1000] = 1;
if (abs(cur) == k) return;
if (s[ind] == 'W')
solve(ind + 1, cur + 1);
else if (s[ind] == 'L')
solve(ind + 1, cur - 1);
else if (s[ind] == 'D')
solve(ind + 1, cur);
else {
s[ind] = 'W';
solve(ind + 1, cur + 1);
s[ind] = 'L';
solve(ind + 1, cur - 1);
s[ind] = 'D';
solve(ind + 1, cur);
s[ind] = '?';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> s;
solve(0, 0);
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = (int)1e6 + 10;
const int INF = (int)1e9 + 7;
const long long LINF = (long long)1e18;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1.0);
int n;
bool b[101][201][201];
int sum1, sum2;
pair<int, int> a[222];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i].first, &a[i].second);
sum1 += a[i].first;
sum2 += a[i].second;
}
b[0][0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= sum1; ++j) {
for (int k = 0; k <= sum1; ++k) {
if (j - a[i].first >= 0) b[i][j][k] |= b[i - 1][j - a[i].first][k];
if (k - a[i].second >= 0) b[i][j][k] |= b[i - 1][j][k - a[i].second];
}
}
}
for (int i = 1; i <= sum1; ++i) {
for (int j = 0; j <= i; ++j) {
if (b[n][i][j]) {
printf("%d", i);
return 0;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> ve;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
ve.push_back(x);
}
for (int i = 0; i < n - 1; i++) ve[i] += ve[i + 1];
for (auto x : ve) printf("%d ", x);
puts("");
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long mod = (long long)1e9 + 7;
const long long inf = (long long)1e18;
const long double e = 2.718281828459;
const long double pi = 3.141592653;
using namespace std;
template <class T>
istream &operator>>(istream &in, vector<T> &arr) {
for (T &cnt : arr) {
in >> cnt;
}
return in;
}
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> p(n * 2);
cin >> p;
vector<int> immediate_pairs(2 * n, -1);
set<pair<long long, pair<int, int>>> s;
set<pair<long long, int>> not_pairs;
for (int i = 0; i < n * 2; i++) {
not_pairs.insert({-p[i], i});
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
immediate_pairs[a] = b;
immediate_pairs[b] = a;
if (p[a] > p[b]) {
s.insert({-p[a], {a, b}});
} else {
s.insert({-p[b], {b, a}});
}
not_pairs.erase({-p[a], a});
not_pairs.erase({-p[b], b});
}
int t;
cin >> t;
if (t == 1) {
for (int i = 0; i < n; i++) {
long long x;
if (!s.empty()) {
auto mx = *s.begin();
s.erase(s.begin());
cout << mx.second.first + 1 << endl;
} else {
auto mx = *not_pairs.begin();
not_pairs.erase(not_pairs.begin());
cout << mx.second + 1 << endl;
}
cin >> x;
x--;
not_pairs.erase({-p[x], x});
}
} else {
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
x--;
not_pairs.erase({-p[x], x});
if (immediate_pairs[x] != -1) {
cout << immediate_pairs[x] + 1 << endl;
if (p[x] > p[immediate_pairs[x]]) {
s.erase({-p[x], {x, immediate_pairs[x]}});
} else {
s.erase({-p[immediate_pairs[x]], {immediate_pairs[x], x}});
}
} else {
if (!s.empty()) {
auto mx = *s.begin();
s.erase(s.begin());
cout << mx.second.first + 1 << endl;
immediate_pairs[mx.second.first] = -1;
immediate_pairs[mx.second.second] = -1;
} else {
auto mx = *not_pairs.begin();
not_pairs.erase(not_pairs.begin());
cout << mx.second + 1 << endl;
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(30);
srand(time(0));
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[300][300];
int l[300][300];
int lf[300][300];
int w[300][300];
int wf[300][300];
int main() {
int n, m, t;
scanf("%d%d%d", &n, &m, &t);
int p, u, d;
scanf("%d%d%d", &p, &u, &d);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < n; i++) {
for (int j = 1; j < m; j++) {
if (a[i][j] > a[i][j - 1])
w[i][j] = w[i][j - 1] + u;
else if (a[i][j] < a[i][j - 1])
w[i][j] = w[i][j - 1] + d;
else
w[i][j] = w[i][j - 1] + p;
}
for (int j = m - 2; j >= 0; j--) {
if (a[i][j] > a[i][j + 1])
wf[i][j] = wf[i][j + 1] + u;
else if (a[i][j] < a[i][j + 1])
wf[i][j] = wf[i][j + 1] + d;
else
wf[i][j] = wf[i][j + 1] + p;
}
}
for (int j = 0; j < m; j++) {
for (int i = 1; i < n; i++) {
if (a[i][j] > a[i - 1][j])
l[i][j] = l[i - 1][j] + u;
else if (a[i][j] < a[i - 1][j])
l[i][j] = l[i - 1][j] + d;
else
l[i][j] = l[i - 1][j] + p;
}
for (int i = n - 2; i >= 0; i--) {
if (a[i][j] > a[i + 1][j])
lf[i][j] = lf[i + 1][j] + u;
else if (a[i][j] < a[i + 1][j])
lf[i][j] = lf[i + 1][j] + d;
else
lf[i][j] = lf[i + 1][j] + p;
}
}
int ax, ay, bx, by;
int tx, ty, px, py;
int ans = 1999999999;
for (ax = 0; ax < n; ax++) {
for (ay = 0; ay < m; ay++) {
for (bx = ax + 2; bx < n; bx++) {
for (by = ay + 2; by < m; by++) {
int s = w[ax][by] - w[ax][ay] + wf[bx][ay] - wf[bx][by] + l[bx][by] -
l[ax][by] + lf[ax][ay] - lf[bx][ay];
s = abs(s - t);
if (ans > s) {
ans = s;
tx = ax;
ty = ay;
px = bx;
py = by;
}
}
}
}
}
printf("%d %d %d %d\n", tx + 1, ty + 1, px + 1, py + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int fact(int n) {
if (n == 1 || n == 0) return 1;
return n * fact(n - 1);
}
void cal(string s1, int pres, int in, double *count, int tot) {
if (in >= s1.size()) {
if (pres == tot) *count = *count + 1;
return;
}
if (s1[in] == '+') {
pres += 1;
cal(s1, pres, in + 1, count, tot);
} else if (s1[in] == '-') {
pres -= 1;
cal(s1, pres, in + 1, count, tot);
} else {
cal(s1, pres + 1, in + 1, count, tot);
cal(s1, pres - 1, in + 1, count, tot);
}
}
int main() {
ios_base::sync_with_stdio(false);
string s1, s2;
double tot, dem, loc = 0, num = 0;
double res;
cin >> s1;
cin >> s2;
tot = count(s2.begin(), s2.end(), '?');
dem = pow(2, tot);
int i;
for (i = 0; i < s1.size(); i++) {
if (s1[i] == '+') {
loc++;
} else {
loc--;
}
}
cal(s2, 0, 0, &num, loc);
res = num / dem;
cout.precision(12);
cout << fixed << res << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec[100005], vec3[100005];
vector<long long> vec2[105];
queue<pair<long long, long long> > q;
long long n, m, s, k;
bool goods[105][100005] = {0};
long long ans[100005] = {0};
long long item[100005];
void bfs(long long pos) {
long long si = vec2[pos].size();
if (si > 0) {
for (long long i = 0; i <= si - 1; i++) {
long long city = vec2[pos][i];
q.push({city, 0});
goods[pos][city] = 1;
}
}
while (!q.empty()) {
long long f = q.front().first;
long long w = q.front().second;
q.pop();
long long si2 = vec[f].size();
if (si2 > 0) {
for (long long i = 0; i <= si2 - 1; i++) {
long long p = vec[f][i];
if (!goods[pos][p]) {
q.push({p, w + 1});
goods[pos][p] = 1;
vec3[p].push_back(w + 1);
}
}
}
}
return;
}
int main() {
cin >> n >> m >> k >> s;
for (long long i = 1; i <= n; i++) {
cin >> item[i];
vec2[item[i]].push_back(i);
}
long long x, y;
for (long long i = 1; i <= m; i++) {
cin >> x >> y;
vec[x].push_back(y);
vec[y].push_back(x);
}
if (s == 1) {
for (long long i = 1; i <= n; i++) cout << 0 << " ";
cout << endl;
goto C;
}
for (long long i = 1; i <= k; i++) {
bfs(i);
}
for (long long i = 1; i <= n; i++) {
long long sii = vec3[i].size();
if (sii > 0) sort(vec3[i].begin(), vec3[i].begin() + sii);
for (long long j = 0; j <= s - 2; j++) {
ans[i] += vec3[i][j];
}
}
for (long long i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
C:
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int h, m, s;
double x[3];
int get(double t) {
int X = -1;
for (int i = 0; i < 3; i++) {
int j = (i == 2 ? 0 : i + 1);
if (x[i] < x[j]) {
if (t >= x[i] && t < x[j]) X = i;
} else {
if ((t >= x[i] && t <= 360.0) || (t >= 0 && t <= x[j])) X = i;
}
}
return X;
}
double t1, t2;
int main() {
cin >> h >> m >> s >> t1 >> t2;
double ht, mt, st;
st = s * 6.0;
mt = m * 6.0 + st / 60.0;
ht = h * 30.0 + mt / 12.0;
t1 *= 30.0;
t2 *= 30.0;
x[0] = st;
x[1] = mt;
x[2] = ht;
for (int i = 0; i < 3; i++)
if (x[i] > 360.0) x[i] -= 360.0;
sort(x, x + 3);
if (get(t1) == get(t2)) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, qq;
cin >> n >> qq;
set<int> app[n + 1];
int total = 0;
int t_max = 0;
queue<pair<int, int>> q;
for (int i = 0; i < qq; i++) {
int type;
cin >> type;
if (type == 1) {
int x;
cin >> x;
app[x].insert(i);
total++;
q.push({i, x});
cout << total << endl;
}
if (type == 2) {
int x;
cin >> x;
total -= app[x].size();
app[x].clear();
cout << total << endl;
}
if (type == 3) {
int t;
cin >> t;
int temp = t;
t -= t_max;
if (t_max < temp) t_max = temp;
for (int i = 0; i < t; i++) {
if (q.empty()) break;
auto u = q.front();
q.pop();
int a = u.first;
int b = u.second;
if (app[b].find(a) != app[b].end()) {
total--;
app[b].erase(a);
}
}
cout << total << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct FenwickTree {
vector<int> bit;
int n;
FenwickTree(int n) {
this->n = n;
bit.assign(n, 0);
}
FenwickTree(vector<int> a) {
this->n = a.size();
bit.assign(a.size(), 0);
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
int sum(int r) {
int ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
int sum(int l, int r) { return sum(r) - sum(l - 1); }
void add(int idx, int delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
void solve() {
int n, q;
cin >> n >> q;
vector<int> x(n + 1);
for (int i = 0; i < n; i++) {
int y;
cin >> y;
x[y] += 1;
}
FenwickTree ft(x);
while (q--) {
int y;
cin >> y;
if (y > 0) {
ft.add(y, 1);
} else {
y = -y;
int l = 1;
int r = n;
int ans = 1e7;
while (l <= r) {
int mid = (l + r) / 2;
int g = ft.sum(mid);
if (g >= y) {
ans = min(ans, mid);
r = mid - 1;
} else {
l = mid + 1;
}
}
ft.add(ans, -1);
}
}
for (int i = 1; i <= n; i++) {
if (ft.sum(i) > 0) {
cout << i << endl;
return;
}
}
cout << 0 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
int t = 1;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1e16;
long long int mod = 1e9 + 7;
char en = '\n';
long long int abs1(long long int x) {
if (x < 0) return -x;
return x;
}
long long int power(long long int x, long long int n, long long int mod) {
long long int res = 1;
x %= mod;
while (n) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
long long int dp[55][55][55][55];
long long int arr[55];
long long int pow2[55];
vector<long long int> choices[55];
long long int myPow(long long int a, long long int n, long long int flag) {
if (n < 0) {
return flag;
}
return pow2[n];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, 0, sizeof(dp));
pow2[0] = 1;
for (long long int i = 1; i < 55; i++) {
pow2[i] = (pow2[i - 1] * 2) % mod;
}
long long int n;
long long int p;
cin >> n >> p;
for (long long int i = 1; i <= n; i++) {
cin >> arr[i];
if (arr[i] != -1)
choices[i].push_back(arr[i]);
else {
choices[i].push_back(0);
choices[i].push_back(1);
}
}
dp[0][0][0][0] = 1;
for (long long int i = 1; i <= n; i++) {
for (long long int bo = 0; bo <= i; bo++) {
for (long long int be = 0; be <= i - bo; be++) {
for (long long int wo = 0; wo <= i - bo - be; wo++) {
long long int we = i - bo - be - wo;
for (long long int type : choices[i]) {
if (type == 1) {
if ((wo - 1) >= 0) {
dp[i][bo][be][wo] += pow2[be + wo + we - 1] *
dp[i - 1][bo][be][wo - 1] % mod *
myPow(2, bo - 1, 1) % mod;
if (dp[i][bo][be][wo] >= mod) dp[i][bo][be][wo] -= mod;
}
if ((we - 1) >= 0) {
dp[i][bo][be][wo] += pow2[be + wo + we - 1] *
dp[i - 1][bo][be][wo] % mod *
myPow(2, bo - 1, 0) % mod;
if (dp[i][bo][be][wo] >= mod) dp[i][bo][be][wo] -= mod;
}
} else {
if ((bo - 1) >= 0) {
dp[i][bo][be][wo] += pow2[we + bo + be - 1] *
dp[i - 1][bo - 1][be][wo] % mod *
myPow(2, wo - 1, 1) % mod;
if (dp[i][bo][be][wo] >= mod) dp[i][bo][be][wo] -= mod;
}
if ((be - 1) >= 0) {
dp[i][bo][be][wo] += pow2[we + bo + be - 1] *
dp[i - 1][bo][be - 1][wo] % mod *
myPow(2, wo - 1, 0) % mod;
if (dp[i][bo][be][wo] >= mod) dp[i][bo][be][wo] -= mod;
}
}
}
}
}
}
}
long long int res = 0;
for (long long int bo = 0; bo <= n; bo++) {
for (long long int be = 0; be <= n - bo; be++) {
for (long long int wo = 0; wo <= n - bo - be; wo++) {
long long int we = n - bo - be - wo;
long long int parity = (bo & 1) ^ (wo & 1);
if (parity == p) res += dp[n][bo][be][wo];
if (res >= mod) res -= mod;
}
}
}
cout << res << en;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, H, T, a, b;
scanf(" %d %d %d %d", &N, &M, &H, &T);
int x = min(H, T);
vector<vector<int> > adjL(N);
for (int i = 0; i < M; i++) {
scanf(" %d %d", &a, &b);
adjL[--a].push_back(--b);
adjL[b].push_back(a);
}
vector<bool> X(N, false);
a = b = -1;
for (int i = 0; i < N; i++)
if (adjL[i].size() > x && a == -1) {
for (auto it = adjL[i].begin(); it != adjL[i].end(); it++) X[*it] = true;
for (auto it = adjL[i].begin(); it != adjL[i].end(); it++) {
if (adjL[*it].size() <= x) continue;
if (max(adjL[i].size(), adjL[*it].size()) <= max(H, T)) continue;
if (adjL[*it].size() > H + T || adjL[i].size() > H + T) {
a = i, b = *it;
break;
}
int c = 0;
for (auto jt = adjL[*it].begin(); jt != adjL[*it].end(); jt++)
if (X[*jt]) c++;
if (adjL[i].size() + adjL[*it].size() - c - 2 < H + T) continue;
a = i, b = *it;
break;
}
for (auto it = adjL[i].begin(); it != adjL[i].end(); it++) X[*it] = false;
}
if (a == -1) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
if ((adjL[a].size() < adjL[b].size()) ^ (H < T)) swap(a, b);
cout << a + 1 << " " << b + 1 << "\n";
for (auto it = adjL[a].begin(); it != adjL[a].end(); it++) X[*it] = true;
vector<int> C;
for (auto it = adjL[b].begin(); it != adjL[b].end(); it++) {
if (X[*it]) C.push_back(*it);
X[*it] = false;
}
X[b] = false;
bool zac = false;
for (int i = 0; i < N; i++)
if (X[i]) {
if (zac)
cout << " ";
else
zac = true;
cout << i + 1;
H--;
if (H == 0) break;
}
for (int i = 0; i < N; i++) X[i] = false;
for (auto it = adjL[b].begin(); it != adjL[b].end(); it++) X[*it] = true;
X[a] = false;
for (auto it = adjL[a].begin(); it != adjL[a].end(); it++) X[*it] = false;
for (int i = 0; i < H; i++) {
if (zac)
cout << " ";
else
zac = true;
cout << C[i] + 1;
}
cout << "\n";
zac = false;
for (int i = 0; i < N; i++)
if (X[i]) {
if (zac)
cout << " ";
else
zac = true;
cout << i + 1;
T--;
if (T == 0) break;
}
for (int i = H; i < min(H + T, (int)C.size()); i++) {
if (zac)
cout << " ";
else
zac = true;
cout << C[i] + 1;
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 5;
vector<int> ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
double n, k;
cin >> n >> k;
int fi;
fi = (n) / k - (1 + k) / 2;
int left = n - (1 + k + 2 * fi) * k / 2;
if ((1 + k) * k / 2 > n) {
cout << "NO";
return 0;
} else {
int accu = 0;
for (int i = 1; i <= (int)(k); ++i) {
int h = fi + i + accu;
if (2 * (h - 1) > h) {
if (left >= k - i + 1) {
if (left <= (h - 2) * (k - i + 1)) {
accu += left / int(k - i + 1);
left %= left / int(k - i + 1);
} else {
accu += h - 2;
left -= (h - 2) * (k - i + 1);
}
}
}
ans.push_back(fi + i + accu);
}
}
if (left)
cout << "NO";
else {
cout << "YES" << '\n';
for (auto e : ans) cout << e << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, on = 0, en = 0, om = 0, em = 0;
cin >> n;
cin >> m;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1)
on++;
else
en++;
}
int b[m];
for (i = 0; i < m; i++) {
cin >> b[i];
if (b[i] % 2 == 1)
om++;
else
em++;
}
m = min(on, em) + min(en, om);
cout << m;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 5;
char a[MAXN];
char minn[MAXN];
stack<char> s;
int main() {
scanf("%s", a);
int m = 1000;
int len = strlen(a);
for (int i = len - 1; i >= 0; i--) {
if (m > a[i]) {
m = a[i];
}
minn[i] = m;
}
string ans;
for (int i = 0; i < len; i++) {
if (minn[i] == a[i]) {
ans += a[i];
while (!s.empty()) {
if (s.top() <= minn[i + 1]) {
ans += s.top();
s.pop();
} else
break;
}
} else {
s.push(a[i]);
}
}
while (!s.empty()) {
ans += s.top();
s.pop();
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace baseFastio {
template <typename Int>
inline Int read() {
Int flag = 1;
char c = getchar();
while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline Int read(char& c) {
Int flag = 1;
c = getchar();
while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline void write(Int x) {
if (x < 0) putchar('-'), x = ~x + 1;
if (x > 9) write(x / 10);
putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch) {
write(x);
putchar(nextch);
}
} // namespace baseFastio
namespace Fastio {
enum io_flags { ignore_int = 1 << 0 };
struct Reader {
char endch;
Reader() { endch = '\0'; }
template <typename Int>
Int operator()() {
return baseFastio::read<Int>(endch);
;
}
Reader& operator>>(io_flags f) {
if (f == ignore_int) baseFastio::read<int>();
return *this;
}
template <typename Int>
Reader& operator>>(Int& i) {
i = baseFastio::read<Int>(endch);
return *this;
}
template <typename Int>
inline Int get_int() {
return baseFastio::read<Int>();
}
inline char get_nxt() { return endch; }
} read;
struct Writer {
Writer& operator<<(const char* ch) {
while (*ch) putchar(*(ch++));
return *this;
}
Writer& operator<<(const char ch) {
putchar(ch);
return *this;
}
template <typename Int>
Writer& operator<<(const Int i) {
baseFastio::write(i);
return *this;
}
} write;
} // namespace Fastio
using namespace Fastio;
const int N = 3e5 + 7;
namespace against_cpp11 {
int n;
vector<int> G[N];
int f[N][2], ans;
void dp(int u, int fa) {
f[u][1] = 1;
f[u][0] = 0;
for (size_t i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v != fa) {
dp(v, u);
ans = max(ans, f[u][0] + max(f[v][0], f[v][1]));
ans = max(ans, f[u][1] + f[v][0]);
f[u][0] = max(f[u][0], (int)(max(f[v][0], f[v][1]) + G[u].size() - 2));
f[u][1] = max(f[u][1], f[v][0] + 1);
}
}
ans = max(ans, max(f[u][0], f[u][1]));
}
signed main() {
read >> n;
for (int i = 1, u, v; i < n; i++) {
read >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dp(1, 0);
write << ans << '\n';
return 0;
}
} // namespace against_cpp11
signed main() { return against_cpp11::main(); }
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int a[2002], b[2002], mk[2002];
int x[N], y[N];
int ans = 0;
int t = 0;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int j = 1; j <= n; j++) cin >> b[j], mk[b[j]] = j;
for (int i = 1; i <= n; i++) {
int val = b[i];
int h;
for (int j = 1; j <= n; j++)
if (a[j] == val) h = j;
int p = h;
for (int j = h - 1; j >= i; j--)
if (mk[a[j]] >= p) {
ans += p - j;
t++;
x[t] = j;
y[t] = p;
swap(a[j], a[p]);
p = j;
}
}
cout << ans << endl;
cout << t << endl;
for (int i = 1; i <= t; i++) printf("%d %d\n", x[i], y[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, ti, wi;
long long a, b, c, d, e, f, g, h;
long long myTi, myWi, lowerVal, higherVal, midVal;
struct team {
long long ti, wi, gap;
team() {}
team(long long ti, long long wi) {
this->ti = ti;
this->wi = wi;
gap = wi - ti;
}
const bool operator<(team B) const {
if (gap == B.gap) {
return ti < B.ti;
}
return gap < B.gap;
}
};
vector<team> vecTeam;
bool cmp(const team A, const team B) {
if (A.ti == B.ti) {
return A.wi < B.wi;
}
return A.ti < B.ti;
}
long long ifPossible(long long pos, vector<team> givenTeams) {
long long a, b, c, d, e, f, g, h, balloonLeft = myTi;
long long copMyTi = myTi;
multiset<team> mulSetTeam;
multiset<team>::iterator mulSetTeamIt;
for (a = givenTeams.size() - 1; a >= 0; a--) {
if (givenTeams[a].ti <= myTi) {
break;
}
mulSetTeam.insert(givenTeams[a]);
givenTeams.pop_back();
}
while (mulSetTeam.size() + 1 > pos) {
mulSetTeamIt = mulSetTeam.begin();
if ((mulSetTeamIt->gap + 1) > balloonLeft) {
return 0;
}
balloonLeft -= (mulSetTeamIt->gap + 1);
copMyTi -= (mulSetTeamIt->gap + 1);
mulSetTeam.erase(mulSetTeamIt);
while (givenTeams.size() &&
givenTeams[givenTeams.size() - 1].ti > copMyTi) {
mulSetTeam.insert(givenTeams[givenTeams.size() - 1]);
givenTeams.pop_back();
}
}
return 1;
}
long long bestPossible(vector<team> givenTeams) {
long long a, b, c, d, e, f, g, h, balloonLeft = myTi;
long long copMyTi = myTi, ans = INT_MAX;
multiset<team> mulSetTeam;
multiset<team>::iterator mulSetTeamIt;
for (a = givenTeams.size() - 1; a >= 0; a--) {
if (givenTeams[a].ti <= myTi) {
break;
}
mulSetTeam.insert(givenTeams[a]);
givenTeams.pop_back();
}
while (mulSetTeam.size()) {
ans = min(ans, (long long)(mulSetTeam.size() + 1));
mulSetTeamIt = mulSetTeam.begin();
if ((mulSetTeamIt->gap + 1) > balloonLeft) {
return ans;
}
balloonLeft -= (mulSetTeamIt->gap + 1);
copMyTi -= (mulSetTeamIt->gap + 1);
mulSetTeam.erase(mulSetTeamIt);
while (givenTeams.size() &&
givenTeams[givenTeams.size() - 1].ti > copMyTi) {
mulSetTeam.insert(givenTeams[givenTeams.size() - 1]);
givenTeams.pop_back();
}
}
return 1;
}
int main() {
cin >> n;
cin >> myTi >> myWi;
for (a = 2; a <= n; a++) {
scanf("%lld %lld", &ti, &wi);
vecTeam.push_back(team(ti, wi));
}
sort(vecTeam.begin(), vecTeam.end(), cmp);
cout << bestPossible(vecTeam);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
const double eps = 1e-9;
using namespace std;
struct Node {
double x, y;
} node[100100];
int n;
double p;
bool judge(double mid) {
double ans = 0;
for (int i = 0; i < n; i++) {
if (mid * node[i].x < node[i].y) continue;
double tp = (mid * node[i].x - node[i].y) / p;
ans += tp;
if (ans > mid) return false;
}
return true;
}
int main() {
scanf("%d%lf", &n, &p);
bool ok = false;
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &node[i].x, &node[i].y);
}
double mid;
double low = 0, high = 1.0 * 1e20;
for (int i = 0; i < 2000; i++) {
mid = (low + high) / 2;
if (judge(mid))
low = mid;
else
high = mid;
}
if (mid > 1e12)
puts("-1");
else
printf("%.10f\n", mid);
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
using namespace chrono;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int advceil(long long int num, long long int den) {
return (num % den == 0 ? num / den : num / den + 1);
}
long long int lstbt(long long int val) {
long long int msk = val & (val - 1);
return log2(val ^ msk);
}
long long int modmul(long long int a, long long int b) {
return (a * b) % 998244353;
}
long long int modexpo(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = modmul(res, a);
a = modmul(a, a);
b /= 2;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return a == 0 ? b : gcd(b % a, a);
}
vector<long long int> CALCfactor(long long int n) {
vector<long long int> factor(n + 2, 0);
for (long long int i = 4; i <= n; i += 2) factor[i] = 2;
for (long long int j = 3; j <= n; j += 2) {
if (factor[j]) continue;
for (long long int i = 2 * j; i <= n; i += j) factor[i] = j;
}
return factor;
}
vector<long long int> CALCprimeNUM(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> primeNUM;
primeNUM.reserve(n + 2);
for (long long int i = 2; i <= n; i++)
if (!factor[i]) primeNUM.push_back(i);
return primeNUM;
}
vector<long long int> CALCprimeFACTOR(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> ans;
while (factor[n] != 0) {
ans.push_back(factor[n]);
n /= factor[n];
}
if (n > 1) ans.push_back(n);
return ans;
}
vector<long long int> unique(vector<long long int> x) {
sort(x.begin(), x.end());
set<long long int> s;
vector<long long int> ans;
ans.reserve(x.size());
for (auto elem : x) s.insert(elem);
for (auto elem : s) ans.push_back(elem);
return ans;
}
pair<vector<long long int>, vector<long long int> > getFact(long long int n) {
vector<long long int> fact(n + 1, 1), invfact(n + 1, 1);
for (long long int i = 1; i <= n; i++)
fact[i] = (i * (fact[i - 1])) % 998244353;
for (long long int i = 1; i <= n; i++)
invfact[i] = (modexpo(i, 998244353 - 2) * invfact[i - 1]) % 998244353;
return {fact, invfact};
}
void compress(vector<long long int>& arr, long long int n) {
map<long long int, vector<long long int> > pos;
for (long long int i = 1; i <= n; i++) pos[arr[i]].push_back(i);
long long int cnt = 1;
for (auto itr : pos) {
for (auto elem : itr.second) arr[elem] = cnt;
cnt++;
}
}
void solve() {
long long int n;
cin >> n;
vector<long long int> arr(2 * n);
for (long long int i = 0; i < 2 * n; i++) cin >> arr[i];
;
sort(arr.begin(), arr.end());
pair<vector<long long int>, vector<long long int> > EF = getFact(2 * n + 2);
long long int res =
((EF.first[2 * n] * EF.second[n]) % 998244353 * EF.second[n]) % 998244353;
long long int ans = 0;
for (long long int i = 0; i < n; i++)
ans += abs(arr[i] - arr[2 * n - i - 1]), ans %= 998244353;
cout << (ans * res) % 998244353 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans[100001];
int main() {
long long n, k;
cin >> n >> k;
long long mini = (k + 1) * k / 2;
if (n < mini) {
puts("NO");
return 0;
}
n -= mini;
long long temp = n / k;
for (int i = 1; i <= k; ++i) {
ans[i] = i + temp;
}
n %= k;
for (int i = k; i >= 1 && n; --i) {
temp = min(n, ans[i - 1] * 2 - ans[i]);
if (temp < 0) temp = 0;
ans[i] += temp;
n -= temp;
}
if (n > 0) {
puts("NO");
} else {
puts("YES");
for (int i = 1; i <= k; ++i) {
printf("%d ", ans[i]);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxk = 36;
long long n, k, i, j, f, w, curk, s, m, curi, maxik;
pair<int, pair<long long, long long> > otv[100010][maxk], cur1, cur2;
long long inf = 1000000007;
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
int main() {
scanf("%I64d %I64d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%I64d", &f);
otv[i][0].first = f;
}
for (i = 0; i < n; i++) {
scanf("%I64d", &w);
otv[i][0].second = make_pair((w), (w));
}
maxik = 0;
curk = k;
while (curk > 0) {
maxik++;
curk = curk >> 1;
}
maxik = maxik + 1;
for (j = 1; j < maxik; j++)
for (i = 0; i < n; i++) {
cur1 = otv[i][j - 1];
cur2 = otv[cur1.first][j - 1];
otv[i][j].second.first = cur1.second.first + cur2.second.first;
otv[i][j].second.second = min(cur1.second.second, cur2.second.second);
otv[i][j].first = cur2.first;
}
for (i = 0; i < n; i++) {
curi = i;
curk = k;
s = 0;
m = inf;
for (j = maxik - 1; j >= 0; j--) {
if (curk <= 0) break;
if (curk < (1ll << j)) continue;
s += otv[curi][j].second.first;
m = min(m, otv[curi][j].second.second);
curi = otv[curi][j].first;
curk = (curk - (1ll << j));
}
printf("%I64d %I64d\n", s, m);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], de[50];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int x = a[i];
for (int j = 0; j < 32; j++)
if ((x >> j) & 1) de[j]++;
}
int mx = 0, pos = 1;
for (int i = 1; i <= n; i++) {
int x = a[i];
for (int j = 0; j < 32; j++)
if ((x >> j) & 1) de[j]--;
int now = 0;
for (int j = 0; j < 32; j++)
if (de[j]) now |= 1 << j;
now = a[i] - (a[i] & now);
if (mx <= now) {
pos = i;
mx = now;
}
for (int j = 0; j < 32; j++)
if ((x >> j) & 1) de[j]++;
}
printf("%d", a[pos]);
for (int i = 1; i <= n; i++)
if (i != pos) printf(" %d", a[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int warriors, pairse;
vector<vector<int> > adjacent;
vector<int> connected;
vector<pair<int, int> > pairs;
int main() {
cin >> warriors >> pairse;
adjacent.resize(warriors + 1);
for (int i = 1; i < warriors + 1; i++) adjacent[i].resize(warriors + 1);
connected.resize(warriors + 1);
for (int i = 0; i < pairse; i++) {
int a, b;
cin >> a >> b;
adjacent[a][b] = 1;
adjacent[b][a] = 1;
connected[a]++;
connected[b]++;
pair<int, int> foo = make_pair(a, b);
pairs.push_back(foo);
}
int mini = 1600000;
for (pair<int, int> p : pairs) {
int soFar = connected[p.first] + connected[p.second] - 4;
for (int i = 1; i < warriors + 1; i++) {
if (adjacent[p.first][i] && adjacent[p.second][i])
if (mini > soFar + connected[i] - 2) mini = soFar + connected[i] - 2;
}
}
if (mini != 1600000)
cout << mini << endl;
else
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
int arr[MAXN], tmp[MAXN];
vector<int> ve[MAXN];
map<pair<int, int>, vector<int> > mapa;
int ind[MAXN];
vector<int> out[MAXN];
int sol = 0;
vector<int> t1, t2;
vector<int> comp;
map<int, int> aaa;
void tour(int x, int i) {
while (ind[x] < ve[x].size()) {
int y = ve[x][ind[x]++];
int ind = mapa[{x, y}].back();
mapa[{x, y}].pop_back();
tour(y, ind);
}
out[sol].push_back(i);
return;
}
int main() {
ios_base::sync_with_stdio(false);
int n, s;
cin >> n >> s;
for (int i = (0); i < (n); i++) {
cin >> arr[i];
comp.push_back(arr[i]);
}
sort(comp.begin(), comp.end());
comp.resize(unique(comp.begin(), comp.end()) - comp.begin());
for (int i = (0); i < (comp.size()); i++) {
aaa[comp[i]] = i;
}
for (int i = (0); i < (n); i++) {
arr[i] = aaa[arr[i]];
tmp[i] = arr[i];
}
sort(tmp, tmp + n);
for (int i = (0); i < (n); i++) {
if (arr[i] != tmp[i]) {
mapa[{tmp[i], arr[i]}].push_back(i);
ve[tmp[i]].push_back(arr[i]);
}
}
int uk = 0;
for (int i = (0); i < (n); i++) {
tour(tmp[i], i);
out[sol].pop_back();
if (out[sol].size()) {
reverse(out[sol].begin(), out[sol].end());
uk += out[sol].size();
sol++;
}
}
if (uk > s) {
cout << "-1\n";
return 0;
}
int m = min(sol, s - uk);
for (int i = (0); i < (m); i++) {
sol--;
for (int x : out[sol]) t1.push_back(x);
t2.push_back(out[sol][0]);
}
if (m == 1) sol++;
if (m <= 1) {
cout << sol << endl;
for (int i = (0); i < (sol); i++) {
cout << out[i].size() << "\n";
for (int x : out[i]) cout << x + 1 << " ";
cout << "\n";
}
} else {
reverse(t2.begin(), t2.end());
cout << sol + 2 << endl;
cout << t1.size() << endl;
for (int x : t1) cout << x + 1 << " ";
cout << endl;
cout << t2.size() << endl;
for (int x : t2) cout << x + 1 << " ";
cout << endl;
for (int i = (0); i < (sol); i++) {
cout << out[i].size() << "\n";
for (int x : out[i]) cout << x + 1 << " ";
cout << "\n";
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 5;
const double EPS = 1e-6;
int prm[N], plm[N];
void prime() {
for (int i = 2; i <= int(sqrt(N)); i++)
if (!prm[i])
for (int j = i + i; j < N; j += i) prm[j] = 1;
for (int i = 2; i < N; i++) prm[i] = prm[i - 1] + 1 - prm[i];
}
void palindromic() {
for (int i = 1; i < N; i++) {
int x = i, y = 0;
for (; x; x /= 10) y = y * 10 + x % 10;
plm[i] = plm[i - 1] + (y == i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
double p, q;
cin >> p >> q;
prime(), palindromic();
for (int i = N - 1; i; i--)
if (p / q * double(plm[i]) >= double(prm[i])) {
cout << i << '\n';
return 0;
}
cout << "Palindromic tree is better than splay tree\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
template <class T>
inline T bigMod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T modInverse(T a, T M) {
return bigMod(a, M - 2, M);
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / gcd(a, b)) * b;
}
template <class T>
inline string int2String(T a) {
ostringstream str;
str << a;
return str.str();
}
template <class T>
inline T string2int(string a) {
stringstream str(a);
T b;
str >> b;
return b;
}
template <class T>
inline void read(T& r) {
r = 0;
int f = 1;
char ch = getchar();
while (ch < '0' or ch > '9') {
f = (ch == '-' ? -1 : 1), ch = getchar();
}
while (ch >= '0' and ch <= '9') {
r = r * 10 + ch - '0', ch = getchar();
}
r *= f;
}
const int dr[] = {0, 1, 0, -1, -1, 1, 1, -1, -2, -2, 2, 2, -1, -1, 1, 1};
const int dc[] = {1, 0, -1, 0, 1, 1, -1, -1, -1, 1, -1, 1, -2, 2, -2, 2};
int n;
string str;
long long dp[105][3005];
long long solve(int pos, int sum) {
if (sum < 0) return 0LL;
if (pos < 0) return 0LL;
if (pos <= 0) {
return (sum == 0);
}
long long& res = dp[pos][sum];
if (res != -1) return res;
res = 0;
for (int i = int(0); i < int(min(sum, 25) + 1); i++) {
res = (res + solve(pos - 1, sum - i)) % 1000000007;
}
return res;
}
int main() {
cin >> n;
memset(dp, -1, sizeof(dp));
while (n--) {
cin >> str;
int sum = 0;
for (int i = int(0); i < int(int(str.size())); i++) sum += str[i] - 'a';
long long ans =
(solve(int(str.size()), sum) - 1LL + 1000000007) % 1000000007;
cout << ans << endl;
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.