solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int k;
int main() {
cin >> k;
if (k & 1) return puts("-1"), 0;
int i, j, r;
for (i = 0; i < k; puts(""), i++)
for (j = 0; j < k; puts(""), j++)
for (r = 0; r < k; r++) printf(j / 2 % 2 ^ r / 2 % 2 ^ i % 2 ? "w" : "b");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int A[150007];
struct node {
int a, b;
node(int x = 0, int y = 0) {
a = x;
b = y;
}
} entry[150007];
bool cmp(node x, node y) {
if (x.b < y.b) {
return false;
}
return true;
}
int main() {
int n, k, q, t = 0;
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &q);
for (int i = 0; i < 10; i++) {
entry[i].a = 0;
entry[i].b = 0;
}
for (int i = 0; i <= n + 5; i++) {
A[i] = 0;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
}
for (int i = 0; i < q; i++) {
int s, d;
scanf("%d", &s);
scanf("%d", &d);
if (s == 1) {
if (entry[k].b < A[d]) {
entry[k].a = d;
entry[k].b = A[d];
}
sort(entry + 1, entry + k + 1, cmp);
} else {
int count = 0;
for (int q = 1; q <= k; q++) {
if (entry[q].a == d) {
count = 1;
}
}
if (count) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T GCD(T a, T b) {
return b ? GCD(b, a % b) : a;
}
template <class T>
inline T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / GCD(a, b));
}
template <class T>
inline T POW1(T a, T b, T m) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > m) x %= m;
}
y = (y * y);
if (y > m) y %= m;
b /= 2;
}
return x;
}
template <class T>
inline T INV(T n, T m) {
return POW1(n, m - 2, m);
}
template <class T>
inline T SUB(T a, T b, T m) {
return (a % m - b % m + m) % m;
}
template <class T>
inline T ADD(T a, T b, T m) {
return (a % m + b % m) % m;
}
template <class T>
inline T MUL(T a, T b, T m) {
return (a % m * b % m) % m;
}
template <class T>
inline T DIV(T a, T b, T m) {
return (a % m * (INV(b, m)) % m) % m;
}
double p;
long long int tot;
vector<vector<double> > dp;
double recurse(long long int t, long long int n) {
if (n > t) return dp[t][n] = 0.0;
if (t == 0) return dp[t][n] = 1.0;
if (n == 0) return dp[t][n] = (1.0 - p) * recurse(t - 1, n);
if (dp[t][n] != -1.0) return dp[t][n];
if (tot == n) return dp[t][n] = p * recurse(t - 1, n - 1) + recurse(t - 1, n);
return dp[t][n] = p * recurse(t - 1, n - 1) + (1.0 - p) * recurse(t - 1, n);
}
int main() {
long long int n, t;
cin >> n >> p >> t;
tot = n;
double ans = 0.0;
dp.clear();
dp.resize(t + 1, vector<double>(n + 1, -1.0));
for (long long int i = 0; i < n + 1; i++) {
ans += recurse(t, i) * (i)*1.0;
}
printf("%.12lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout.sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed << boolalpha;
int N, Exercise_Count, chest = 0, biceps = 0, back = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> Exercise_Count;
if (i % 3 == 0)
chest += Exercise_Count;
else if (i % 3 == 1)
biceps += Exercise_Count;
else
back += Exercise_Count;
}
if (chest > biceps && chest > back)
cout << "chest";
else if (biceps > chest && biceps > back)
cout << "biceps";
else
cout << "back";
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double eps = 1e-10;
const float epsf = 1e-6;
using namespace std;
inline long long int __gcd(long long int a, long long int b) {
if (a == 0 || b == 0) {
return max(a, b);
}
long long int tempa, tempb;
while (1) {
if (a % b == 0)
return b;
else {
tempa = a;
tempb = b;
a = tempb;
b = tempa % tempb;
}
}
}
inline int compfloat(float& x, float& y) {
if (fabs(x - y) < epsf)
return 0;
else if (x - y > 0)
return 1;
return -1;
}
inline int compdouble(double x, double y) {
if (fabs(x - y) < eps)
return 0;
else if (x - y > 0)
return 1;
else
return -1;
}
bool prime(long long int k) {
for (long long int i = 2; i * i <= k; i++)
if (k % i == 0) {
return false;
}
return true;
}
void pdash(int n = 1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < 30; j++) {
cout << "-";
}
cout << "\n";
}
}
void cordinate_compression(vector<int>& v) {
vector<int> p = v;
sort(p.begin(), p.end());
p.erase(unique(p.begin(), p.end()), p.end());
for (int i = 0; i < (int)((v).size()); i++)
v[i] = (int)(lower_bound(p.begin(), p.end(), v[i]) - p.begin());
}
long long int fact[700006];
long long int ifact[700006];
long long int mod = 1000003;
long long int C(int n, int m) {
return (fact[n] * ((ifact[m] * ifact[n - m]) % mod)) % mod;
}
long long int power(long long int x, long long int y, long long int z) {
long long int result = 1;
x = x % z;
while (y > 0) {
if (y & 1) {
result = (result * x) % z;
}
y = y >> 1;
x = (x * x) % z;
}
return result;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
void solve() {
fact[0] = fact[1] = 1;
for (int i = 2; i <= 700005; i++) fact[i] = (fact[i - 1] * i) % mod;
ifact[700005] = modInverse(fact[700005], mod) % mod;
for (int i = 700004; i >= 0; i--) ifact[i] = (ifact[i + 1] * (i + 1)) % mod;
int n, c;
cin >> n >> c;
cout << C(n + c, c) - 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
using namespace std;
long long ksm(long long a, long long b) {
if (!b) return 1;
long long ns = ksm(a, b >> 1);
ns = ns * ns % 998244353;
if (b & 1) ns = ns * a % 998244353;
return ns;
}
int t[300005];
int h[300005];
vector<int> eg[300005];
const long long inf = 1e18;
long long cal(int plz, vector<pair<long long, long long> > cur, int nw) {
int sz[2] = {0, 0};
vector<long long> c[2];
if (plz >= 0) sz[plz]++, c[plz].push_back(inf);
long long tot = 0;
for (auto v : cur) {
if (v.first >= v.second)
sz[1]++, c[1].push_back(v.first - v.second);
else
sz[0]++, c[0].push_back(v.second - v.first);
tot += min(v.first, v.second);
}
long long ans = tot + 1ll * max(sz[0], sz[1]) * nw;
int tp = 0;
if (sz[1] > sz[0]) tp = 1;
sort(c[tp].begin(), c[tp].end());
for (int j = 0; j < c[tp].size(); j++) {
tot += c[tp][j];
if (tot >= inf) break;
chkmin(ans, tot + 1ll * max(sz[tp] - j - 1, sz[tp ^ 1] + j + 1) * nw);
}
return ans;
}
pair<long long, long long> dfs(int a, int fa) {
long long res[2] = {0, 0};
vector<pair<long long, long long> > cur;
for (auto v : eg[a]) {
if (v == fa) continue;
cur.push_back(dfs(v, a));
}
if (a == 1) {
cout << cal(-1, cur, t[a]) << endl;
exit(0);
}
for (int i = 0; i < 2; i++) {
res[i] = inf;
if (i == 0 && h[a] < h[fa]) continue;
if (i == 1 && h[a] > h[fa]) continue;
res[i] = cal(i ^ 1, cur, t[a]);
}
return make_pair(res[0], res[1]);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
eg[u].push_back(v);
eg[v].push_back(u);
}
dfs(1, 0);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<pair<pair<int, int>, long long int>, long long int> dptable;
long long int s;
long long int calc(int a, int b, long long int c) {
if (a > b) return calc(b, a, c);
if (c < 0 || c > (1LL << (a + 1)) + (1LL << (b + 1)) - 2) return 0;
if (a == 0) {
while (b > 0) {
if (c >= (1LL << b) - 1) c -= (1LL << b) - 1;
b--;
}
if (c == 0)
return 1;
else
return 0;
}
if (dptable.find(make_pair(make_pair(a, b), c)) != dptable.end())
return dptable[make_pair(make_pair(a, b), c)];
long long int res = 0;
if (a < b) {
res += calc(a, b - 1, c);
res += calc(a, b - 1, c - ((1LL << b) - 1));
} else {
res += calc(a - 1, b - 1, c);
res += calc(a - 1, b - 1, c - ((1LL << a) - 1));
res += calc(a - 1, b - 1, c - ((1LL << b) - 1));
res += calc(a - 1, b - 1, c - ((1LL << a) - 1) - ((1LL << b) - 1));
}
dptable[make_pair(make_pair(a, b), c)] = res;
return res;
}
int main() {
scanf("%I64d", &s);
long long int ans = 0;
for (int i = 0; i < 53; i++) {
for (int j = 0; j < 53; j++) {
if (i == 0) {
if (j == 0) {
ans++;
} else {
long long int root = s / ((1LL << (j + 1)) - 1);
if (root == 0) continue;
ans += calc(0, j - 1,
s - (root * ((1LL << (j + 1)) - 1)) - ((1LL << j) - 1));
}
} else {
if (j == 0) {
long long int root = s / ((1LL << (i + 1)) - 1);
if (root == 0) continue;
ans += calc(i - 1, 0, s - (root * ((1LL << (i + 1)) - 1)));
} else {
long long int root = s / ((1LL << (i + 1)) + (1LL << (j + 1)) - 3);
if (root == 0) continue;
ans += calc(i - 1, j - 1,
s - (root * ((1LL << (i + 1)) + (1LL << (j + 1)) - 3)) -
((1LL << j) - 1));
}
}
}
}
printf("%I64d", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 410;
int c[mn];
int main() {
int n, Ans = 2147483647;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 2; i <= n; ++i)
for (int j = i; j <= n; ++j) {
int S1 = c[i - 1] - 1, M = 1;
for (int k = i; k <= j; ++k) M += S1 / c[k], S1 %= c[k];
int S2 = c[i - 1] - 1 - S1 + c[j], G = 0;
for (int k = 1; k <= n; ++k) G += S2 / c[k], S2 %= c[k];
if (M < G)
Ans = ((Ans) < (c[i - 1] - 1 - S1 + c[j]) ? (Ans)
: (c[i - 1] - 1 - S1 + c[j]));
}
if (Ans == 2147483647) Ans = -1;
cout << Ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)(3e6) + 7;
const int mod = (int)(1e9) + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
int n;
long long ans, dp1[maxn], dp2[maxn], d[maxn];
vector<pair<int, long long> > G[maxn];
void dfs(int now, int fa) {
long long max1 = 0, max2 = 0;
for (int i = 0; i < G[now].size(); i++) {
int to = G[now][i].first;
long long dis = G[now][i].second;
if (to == fa) continue;
dfs(to, now);
if (dp1[to] - dis > max1) {
max2 = max1;
max1 = dp1[to] - dis;
} else if (dp1[to] - dis > max2)
max2 = dp1[to] - dis;
}
dp1[now] = max(dp1[now], max1 + d[now]);
dp2[now] = max(dp2[now], max1 + max2 + d[now]);
ans = max(ans, max(dp1[now], dp2[now]));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &d[i]);
for (int i = 1; i <= n - 1; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
G[u].push_back({v, w});
G[v].push_back({u, w});
}
dfs(1, -1);
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> stations[200001];
int nxt[200001];
int main() {
int d, n, m;
scanf("%d%d%d", &d, &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &stations[i].first, &stations[i].second);
}
sort(stations, stations + m);
stack<int> s;
for (int i = m - 1; i > -1; i--) {
nxt[i] = -1;
while (!s.empty()) {
if (stations[s.top()].second > stations[i].second) {
s.pop();
} else {
nxt[i] = s.top();
break;
}
}
s.push(i);
}
long long cost = 0;
int gas = n;
for (int i = 0; i < m; i++) {
gas -= stations[i].first - (i == 0 ? 0 : stations[i - 1].first);
if (gas < 0) {
cout << -1 << endl;
return 0;
}
int needed;
if (nxt[i] == -1 || stations[nxt[i]].first - stations[i].first > n) {
needed = min(n, d - stations[i].first);
} else {
needed = stations[nxt[i]].first - stations[i].first;
}
if (gas < needed) {
cost += (long long)stations[i].second * (needed - gas);
gas = needed;
}
}
gas -= d - stations[m - 1].first;
if (gas < 0) {
cout << -1 << endl;
} else {
cout << cost << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int countd(long long int n) {
long long int cnt = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
cnt++;
} else {
cnt = cnt + 2;
}
}
}
return cnt;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int b, i, j, k, l, n, m, cnt;
cin >> b;
cnt = countd(b);
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct tri {
int x, y, z;
tri(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
void rt() {
int id = x;
x = y;
y = z;
z = id;
}
};
const int max_n = 71;
int v[max_n][max_n];
tri dad[max_n][max_n][max_n];
bool check[max_n][max_n][max_n];
queue<tri> bfs;
int n;
void ad(tri i) {
int color = v[i.y][i.z];
int id[3];
id[0] = i.x;
id[1] = i.y;
id[2] = i.z;
sort(id, id + 3);
for (int j = 0; j < n; j++) {
if (i.x != j && i.y != j && i.z != j && v[i.x][j] == color) {
int a[3];
a[0] = j;
a[1] = i.y;
a[2] = i.z;
sort(a, a + 3);
if (!check[a[0]][a[1]][a[2]]) {
check[a[0]][a[1]][a[2]] = 1;
bfs.push(tri(a[0], a[1], a[2]));
dad[a[0]][a[1]][a[2]] = tri(id[0], id[1], id[2]);
}
}
}
}
int main() {
cin >> n;
int a[3];
cin >> a[0] >> a[1] >> a[2];
a[0]--;
a[1]--;
a[2]--;
sort(a, a + 3);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
char id;
cin >> id;
if (i != j) v[i][j] = int(id - 'a');
}
check[a[0]][a[1]][a[2]] = true;
bfs.push(tri(a[0], a[1], a[2]));
while (!bfs.empty()) {
tri i = bfs.front();
bfs.pop();
for (int k = 0; k < 3; k++) {
ad(i);
i.rt();
}
}
if (!check[0][1][2]) {
cout << -1 << endl;
return 0;
}
vector<tri> masir;
tri i = tri(0, 1, 2);
while (i.x != a[0] || i.y != a[1] || i.z != a[2]) {
masir.push_back(i);
i = dad[i.x][i.y][i.z];
}
masir.push_back(tri(a[0], a[1], a[2]));
reverse(masir.begin(), masir.end());
cout << masir.size() - 1 << endl;
tri id = masir[0];
for (int i = 1; i < masir.size(); i++) {
tri j = masir[i];
set<int> d;
d.insert(id.x);
d.insert(id.y);
d.insert(id.z);
d.erase(j.x);
d.erase(j.y);
d.erase(j.z);
cout << *(d.begin()) + 1 << ' ';
d.clear();
d.insert(j.x);
d.insert(j.y);
d.insert(j.z);
d.erase(id.x);
d.erase(id.y);
d.erase(id.z);
cout << *(d.begin()) + 1 << endl;
id = j;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXINT = 1 << 31 - 1;
const int MAXN = 55 * 1e4 + 5;
int dp[MAXN];
int arr[60];
int n, d;
int main() {
while (cin >> n >> d) {
int big = 0;
for (int i = (0); i < (n); i += 1) {
scanf("%d", &arr[i]);
big += arr[i];
}
fill(dp, dp + big + d + 1, MAXINT);
dp[0] = 0;
for (int i = (0); i < (n); i += 1) {
for (int j = (big); j > (0); j -= 1) {
int prev = j - arr[i];
if (prev < 0) {
break;
}
if (dp[prev] == MAXINT) {
continue;
}
dp[j] = min(dp[j], dp[prev] + 1);
}
}
int times = 0;
int cur = 0, next = 0;
while (true) {
next = cur;
for (int i = (1); i < (d + 1); i += 1) {
if (dp[cur + i] == MAXINT) {
continue;
}
next = cur + i;
}
if (next == cur) {
break;
}
cur = next;
times++;
}
printf("%d %d\n", next, times);
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define all(x) (x).begin(),(x).end()
#define uniq(v) (v).erase(unique(all(v)),(v).end())
#define sz(x) (int)((x).size())
#define fr first
#define sc second
#define pii pair<int,int>
#define mem1(a) memset(a,-1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
#define M 1e+18
#define mod 100000000007
// bool prime[100001];
// void SieveOfEratosthenes()
// {
// // bool prime[n + 1];
// memset(prime, true, sizeof(prime));
// int n = 100000;
// prime[1] = false;
// for (int p = 2; p * p <= n; p++)
// {
// if (prime[p] == true)
// {
// for (int i = p * p; i <= n; i += p)
// prime[i] = false;
// }
// }
// }
void solve();
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int test;
cin >> test;
// test = 1;
while (test--)
{
solve();
}
return 0;
}
int modI(int a, int b)
{
int x = 1, y = 0;
int x1 = 0, y1 = 1, a1 = a, b1 = b;
while (b1) {
int q = a1 / b1;
tie(x, x1) = make_tuple(x1, x - q * x1);
tie(y, y1) = make_tuple(y1, y - q * y1);
tie(a1, b1) = make_tuple(b1, a1 - q * b1);
}
if (x < 0)
x += b;
return x;
}
int power(long long x, unsigned int y, int p)
{
int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
unsigned int Logn(unsigned int n, unsigned int r)
{
return log(n) / log(r);
}
long long mini(long long a, long long b)
{
return (a > b) ? (b) : (a);
}
int find(int x, vector <vector<int>> &v, int i)
{
int f = 0;
int l = i - 1;
// cout << x << endl;
while (f < l)
{
int c = (f + l) / 2;
if (v[c][0] < x)
{
f = c + 1;
}
else if (v[c][0] >= x)
{
l = c - 1;
}
}
if (v[l][0] >= x)
{
l--;
}
return l;
}
void solve()
{
// cout << "hello " << endl;
int n;
cin >> n;
int k; cin >> k;
vector<int> v(n, mod);
vector<int> a(k);
for (int i = 0; i < k; i++)
{
cin >> a[i];
}
int mn = INT_MAX;
int pos = 0;
for (int i = 0; i < k; i++)
{
int at;
cin >> at;
if (mn > at)
{
mn = at;
pos = a[i];
}
v[a[i] - 1] = at;
}
pos--;
for (int j = pos + 1; j < n; j++)
{
v[j] = min(v[j], v[j - 1] + 1);
}
for (int j = n - 2; j > pos; j--)
{
v[j] = min(v[j], v[j + 1] + 1);
}
for (int i = pos - 1; i >= 0; i--)
{
v[i] = min(v[i], v[i + 1] + 1);
}
for (int i = 1; i < pos; i++)
{
v[i] = min(v[i], v[i - 1] + 1);
}
for (int i = 0; i < n; i++)
{
cout << v[i] << " ";
}
cout << endl;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x;
int a[100000], i, sum = 0, p, ans;
cin >> n >> x;
for (i = 0; i < n; i++) {
cin >> p;
sum = sum + p;
}
ans = sum + n - 1;
if (ans == x)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class p1328D {
public:
void solve() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> t(n);
for (int i = 0; i < n; i++) cin >> t[i];
int sum = 1;
for (int i = 1; i < n; i++) {
if (t[i] == t[i - 1]) sum++;
}
if (sum == n) {
cout << 1 << endl;
for (int i = 0; i < n; i++) cout << 1 << " ";
cout << endl;
} else if (n % 2 == 0 || t.back() == t.front()) {
cout << 2 << endl;
for (int i = 0; i < n; i++) cout << i % 2 + 1 << " ";
cout << endl;
} else if (sum > 1) {
cout << 2 << endl;
bool can = true;
for (int i = 0; i < n; i++) {
if (can && i > 0 && t[i] == t[i - 1]) {
cout << (i - 1) % 2 + 1 << " ";
can = false;
} else if (!can)
cout << (i - 1) % 2 + 1 << ' ';
else
cout << i % 2 + 1 << ' ';
}
cout << endl;
} else {
cout << 3 << endl;
for (int i = 0; i < n - 1; i++) cout << i % 2 + 1 << " ";
cout << 3 << endl;
}
}
}
};
class p1327E {
public:
long long MOD = 998244353;
long long fastpow(long long x, long long n) {
if (n == 0) return 1ll;
if (n == 1) return x;
long long temp = fastpow(x, n / 2);
if (n % 2 == 0)
return (temp * temp) % MOD;
else
return (((x * temp) % MOD) * temp) % MOD;
}
void solve() {
int n;
cin >> n;
if (n < 2) {
cout << 10 << endl;
return;
}
int maxn = 2e5 + 10;
vector<long long> dp(maxn, 1);
for (int i = 1; i <= maxn; i++) {
dp[i] = (dp[i - 1] * 10) % MOD;
}
for (int i = 1; i < n; i++) {
long long res = 2 * 10 * 9 * dp[n - i - 1] % MOD;
res += (n - i - 1) * 10 * 9 * 9 * dp[n - i - 2] % MOD;
cout << res % MOD << " ";
}
cout << 10 << endl;
}
};
class p161D {
public:
long long res, k, n;
vector<vector<int>> e;
vector<vector<long long>> dp;
void dfs(int cur, int fa) {
dp[cur][0] = 1;
for (int c : e[cur]) {
if (c == fa) continue;
dfs(c, cur);
for (int i = 1; i <= k; i++) {
dp[cur][i] += dp[c][i - 1];
}
}
res += dp[cur][k];
long long temp = 0;
for (int c : e[cur]) {
if (c == fa) continue;
for (int i = 0; k - 2 - i >= 0; i++) {
temp += dp[c][i] * (dp[cur][k - i - 1] - dp[c][k - i - 2]);
}
}
res += temp / 2;
}
void solve() {
cin >> n >> k;
e = vector<vector<int>>(n + 1);
dp = vector<vector<long long>>(n + 1, vector<long long>(k + 1, 0));
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
res = 0;
dfs(1, 0);
cout << res << endl;
}
};
class p1437C {
public:
void solve() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> t(n);
for (int i = 0; i < n; i++) cin >> t[i];
sort(t.begin(), t.end());
vector<vector<int>> dp(2 * n + 1, vector<int>(n + 1, 0x3f3f3f3f));
dp[0][0] = 0;
int res = 0x3f3f3f3f;
for (int k = 1; k <= 2 * n; k++) {
for (int i = 1; i <= n; i++) {
for (int pre = 0; pre <= k - 1; pre++) {
dp[k][i] = min(dp[k][i], dp[pre][i - 1] + abs(t[i - 1] - k));
}
}
res = min(res, dp[k][n]);
}
cout << res << endl;
}
}
};
class p1038D {
public:
void solve() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << a[0] << endl;
return;
}
long long ans = 0, minval = 0x3f3f3f3f;
bool pos = 0, neg = 0;
for (int i = 0; i < n; i++) {
ans += abs(a[i]);
pos |= (a[i] >= 0);
neg |= (a[i] <= 0);
minval = min(minval, abs(a[i]));
}
if (pos && neg)
cout << ans << endl;
else
cout << ans - 2 * minval << endl;
}
};
class p1286A {
public:
void solve() {
int n;
cin >> n;
vector<int> p(n);
unordered_set<int> cnt;
for (int i = 1; i <= n; i++) cnt.insert(i);
for (int i = 0; i < n; i++) {
cin >> p[i];
if (p[i] != 0) cnt.erase(p[i]);
}
int odd = 0, even = 0;
for (int i : cnt)
if (i % 2)
odd++;
else
even++;
vector<vector<vector<int>>> dp(
n + 1, vector<vector<int>>(n + 1, vector<int>(2, 0x3f3f3f3f)));
dp[0][0][0] = dp[0][0][1] = 0;
for (int i = 1; i <= n; i++) {
int cur = p[i - 1] % 2;
for (int j = 0; j <= min(odd, i); j++) {
if (p[i - 1] != 0) {
dp[i][j][cur] =
min(dp[i - 1][j][0] + (0 ^ cur), dp[i - 1][j][1] + (1 ^ cur));
} else {
if (j >= 1) {
dp[i][j][1] = min(
dp[i][j][1], min(dp[i - 1][j - 1][0] + 1, dp[i - 1][j - 1][1]));
}
dp[i][j][0] =
min(dp[i][j][0], min(dp[i - 1][j][0], dp[i - 1][j][1] + 1));
}
}
}
cout << min(dp[n][odd][0], dp[n][odd][1]) << endl;
}
};
class p580D {
public:
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<long long> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<vector<long long>> cost(n + 1, vector<long long>(n + 1, 0));
vector<vector<long long>> dp(1 << n, vector<long long>(n + 1, 0));
for (int i = 0; i < k; i++) {
long long x, y, c;
cin >> x >> y >> c;
cost[x][y] = c;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
dp[1 << (i - 1)][i] = a[i];
}
for (int i = 1; i < (1 << n); i++) {
int cnt = bitset<32>(i).count();
for (int j = 1; j <= n; j++) {
if ((i & (1 << (j - 1))) != 0) {
int pre = i ^ (1 << (j - 1));
for (int k = 1; k <= n; k++) {
if ((pre & (1 << (k - 1))) == 0) continue;
dp[i][j] = max(dp[i][j], dp[pre][k] + cost[k][j] + a[j]);
}
if (cnt == m) ans = max(ans, dp[i][j]);
}
}
}
cout << ans << endl;
}
};
class p1335E2 {
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<vector<int>> sum(n + 1, vector<int>(205, 0));
vector<vector<int>> pos(205);
int res = 0;
for (int i = 1; i <= n; i++) {
sum[i][a[i]]++;
for (int j = 1; j <= 200; j++) {
sum[i][j] += sum[i - 1][j];
res = max(res, sum[i][j]);
}
pos[a[i]].push_back(i);
}
for (int i = 1; i <= 200; i++) {
int len = pos[i].size();
for (int k = 0; k < len - 1 - k; k++) {
int l = pos[i][k], r = pos[i][len - 1 - k] - 1;
int mid = 0;
for (int j = 1; j <= 200; j++) {
mid = max(mid, sum[r][j] - sum[l][j]);
}
res = max(res, 2 * (k + 1) + mid);
}
}
cout << res << endl;
}
}
};
class p1221D {
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<long long> a(n + 1), b(n + 1);
a[0] = 0;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
vector<vector<long long>> dp(n + 1, vector<long long>(4, -1));
dp[0][0] = dp[0][1] = dp[0][2] = dp[0][3] = 0;
long long res = LONG_LONG_MAX;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= 2; j++) {
for (int k = 0; k <= 2; k++) {
if (a[i] + j != a[i - 1] + k) {
auto cur = j * b[i] + dp[i - 1][k];
dp[i][j] = dp[i][j] == -1 ? cur : min(dp[i][j], cur);
}
}
if (i == n) res = min(res, dp[i][j]);
}
}
cout << res << endl;
}
}
};
class p543A {
public:
void solve() {
int n, m, b, md;
cin >> n >> m >> b >> md;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<vector<int>> dp(m + 1, vector<int>(b + 1, 0));
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int k = 0; k <= m; k++) {
for (int j = 0; j <= b; j++) {
if (j >= a[i] && k > 0)
dp[k][j] = (dp[k][j] + dp[k - 1][j - a[i]]) % md;
}
}
}
long long res = 0;
for (int i = 0; i <= b; i++) res = (res + dp[m][i]) % md;
cout << res << endl;
}
};
class p1142A {
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int left = a[0];
bool ok = 1;
int mx = 0;
for (int i = 1; i < n; i++) {
if (mx > a[i]) {
ok = false;
break;
}
a[i] -= mx;
if (left >= a[i])
left = a[i];
else {
mx += a[i] - left;
}
}
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
};
class p1244D {
public:
vector<int> node;
vector<vector<int>> e;
void dfs(int cur, int fa) {
node.push_back(cur);
for (int c : e[cur]) {
if (c == fa) continue;
dfs(c, cur);
}
}
void solve() {
int n;
cin >> n;
vector<vector<long long>> cost(n + 1, vector<long long>(3, 0));
for (int j = 0; j < 3; j++) {
for (int i = 1; i <= n; i++) {
cin >> cost[i][j];
}
}
e = vector<vector<int>>(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
if (e[u].size() > 2 || e[v].size() > 2) {
cout << -1 << endl;
return;
}
}
int start = -1;
for (int i = 1; i <= n; i++) {
if (e[i].size() == 1) {
start = i;
break;
}
}
dfs(start, -1);
long long res = 4e18;
int x = -1, y = -1;
for (int i = 0; i < 3; i++) {
for (int k = 0; k < 3; k++) {
if (k == i) continue;
long long temp = 0;
temp += cost[node[0]][i] + cost[node[1]][k];
int a = i, b = k;
for (int j = 2; j < node.size(); j++) {
for (int l = 0; l < 3; l++) {
if (l == a || l == b) continue;
temp += cost[node[j]][l];
a = b;
b = l;
break;
}
}
if (temp < res) {
res = temp;
x = i;
y = k;
}
}
}
cout << res << endl;
vector<int> ans(n + 1, 0);
ans[node[0]] = x;
ans[node[1]] = y;
for (int i = 2; i < node.size(); i++) {
for (int l = 0; l < 3; l++) {
if (l == x || l == y) continue;
ans[node[i]] = l;
x = y;
y = l;
break;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] + 1 << " ";
cout << endl;
}
};
class p519D {
public:
void solve() {
vector<long long> cnt(26, 0);
for (int i = 0; i < 26; i++) cin >> cnt[i];
string s;
cin >> s;
int n = s.size();
vector<long long> sum(n + 1, 0);
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + cnt[s[i - 1] - 'a'];
}
long long res = 0;
unordered_map<long long, long long> mp[26];
for (int i = 1; i <= n; i++) {
int cur = s[i - 1] - 'a';
res += mp[cur][sum[i] - cnt[cur]];
mp[cur][sum[i]]++;
}
cout << res << endl;
}
};
class p1096D {
public:
void solve() {
int n;
cin >> n;
string s;
cin >> s;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
unordered_map<char, int> cnt;
cnt['h'] = 0;
cnt['a'] = 1;
cnt['r'] = 2;
cnt['d'] = 3;
vector<long long> dp(4, 0);
for (int i = 0; i < n; i++) {
if (!cnt.count(s[i])) continue;
if (s[i] == 'h')
dp[0] += a[i];
else
dp[cnt[s[i]]] = min(dp[cnt[s[i]] - 1], dp[cnt[s[i]]] + a[i]);
}
cout << dp[3] << endl;
}
};
class p1296E1 {
public:
void solve() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> res(n);
res[0] = 0;
char first = s[0];
char second = 'a' - 1;
for (int i = 1; i < n; i++) {
if (s[i] >= first) {
res[i] = 0;
first = s[i];
} else {
if (s[i] >= second) {
res[i] = 1;
second = s[i];
} else {
cout << "NO" << endl;
return;
}
}
}
cout << "YES" << endl;
for (int i : res) cout << i;
cout << endl;
}
};
class p1296E2 {
public:
void solve() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> dp(26, 0);
int res = 0;
vector<int> ans;
for (int i = 0; i < n; i++) {
int d = 1;
for (int j = s[i] - 'a' + 1; j < 26; j++) {
d = max(d, dp[j] + 1);
}
dp[s[i] - 'a'] = d;
ans.emplace_back(d);
}
for (int i = 0; i < 26; i++) res = max(res, dp[i]);
cout << res << endl;
for (auto c : ans) cout << c << ' ';
cout << endl;
}
};
class D {
public:
void solve() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
int n, q;
cin >> n >> q;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<long long> sum(n + 1, 0);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i - 1];
unordered_set<long long> cnt;
cnt.insert(sum[n]);
queue<pair<long long, long long>> que;
que.emplace(0, n - 1);
while (!que.empty()) {
auto u = que.front();
que.pop();
if (u.first > u.second) continue;
auto l = a[u.first], r = a[u.second];
cnt.insert(sum[u.second + 1] - sum[u.first]);
if (u.first == u.second) continue;
long long mid = (l + r) / 2;
auto it =
upper_bound(a.begin() + u.first, a.begin() + u.second + 1, mid) -
a.begin();
if (it - 1 >= u.first && it - 1 != u.second)
que.emplace(u.first, it - 1);
if (it <= u.second && it != u.first) que.emplace(it, u.second);
}
while (q--) {
long long s;
cin >> s;
if (cnt.count(s))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
}
};
class p1462F {
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<long long, long long>> c;
vector<int> a, b;
c.clear();
for (int i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
a.push_back(l);
b.push_back(r);
c.emplace_back(l, r);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int res = n;
for (int i = 0; i < n; i++) {
auto leftcnt = lower_bound(b.begin(), b.end(), c[i].first) - b.begin();
auto rightcnt =
upper_bound(a.begin(), a.end(), c[i].second) - a.begin();
res = min(res, (int)(leftcnt + n - rightcnt));
}
cout << res << endl;
}
}
};
class p1324F {
public:
vector<int> a;
vector<int> dp;
int n;
vector<vector<int>> e;
vector<int> fa;
int dfs(int cur, int f) {
dp[cur] = a[cur];
for (int child : e[cur]) {
if (child == f) continue;
int next = dfs(child, cur);
dp[cur] += max(0, next);
}
return dp[cur];
}
void dfs2(int cur, int fa) {
dp[cur] = max(dp[cur], dp[cur] + max(0, dp[fa] - max(0, dp[cur])));
for (int c : e[cur]) {
if (c == fa) continue;
dfs2(c, cur);
}
}
void solve() {
cin >> n;
a = vector<int>(n + 1);
e = vector<vector<int>>(n + 1);
dp = vector<int>(n + 1, 0);
fa = vector<int>(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) a[i] = -1;
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
e[u].emplace_back(v);
e[v].emplace_back(u);
}
dfs(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
cout << dp[i] << " ";
}
cout << endl;
}
};
class p1446B {
public:
void solve() {
int n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
int res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i - 1] == t[j - 1]) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 2);
}
dp[i][j] = max(dp[i][j], max(dp[i - 1][j] - 1, dp[i][j - 1] - 1));
res = max(res, dp[i][j]);
}
}
cout << res << endl;
}
};
class p1283E {
public:
void solve() {
int n;
cin >> n;
vector<int> x(n);
for (int i = 0; i < n; i++) cin >> x[i];
int maxn = 200005;
int ans1 = 0, ans2 = 0;
unordered_map<int, int> cnt;
for (int i : x) cnt[i]++;
for (int i = 1; i <= n; i++) {
if (cnt[i] > 0) {
ans1++;
i += 2;
}
}
for (int i = 1; i <= n + 1; i++) {
if (cnt[i - 1] == 0 && cnt[i] > 0) {
cnt[i - 1]++;
cnt[i]--;
}
if (cnt[i] > 1) {
cnt[i]--;
cnt[i + 1]++;
}
}
for (int i = 0; i <= n + 1; i++) {
if (cnt[i] > 0) ans2++;
}
printf("%d %d\n", ans1, ans2);
}
};
class p148D {
public:
vector<vector<vector<double>>> dp;
double dfs(int w, int b, int cur) {
if (dp[w][b][cur] >= 0.0) return dp[w][b][cur];
if (w == 0) {
if (cur == 0)
dp[w][b][cur] = 0.0;
else
dp[w][b][cur] = 1.0;
return dp[w][b][cur];
}
if (b == 0) {
dp[w][b][cur] = 1.0;
return 1.0;
}
dp[w][b][cur] = 1.0 * w / (w + b);
if (cur == 0) {
dp[w][b][cur] += (1.0 - dfs(w, b - 1, 1 - cur)) * (1.0 * b / (w + b));
} else {
dp[w][b][cur] += (1.0 - dfs(w - 1, b - 1, 1 - cur)) *
(1.0 * b / (w + b)) * (1.0 * w / (w + b - 1));
if (b >= 2) {
dp[w][b][cur] += (1.0 - dfs(w, b - 2, 1 - cur)) * (1.0 * b / (w + b)) *
(1.0 * (b - 1) / (w + b - 1));
}
}
return dp[w][b][cur];
}
void solve() {
int w, b;
cin >> w >> b;
dp = vector<vector<vector<double>>>(
w + 1, vector<vector<double>>(b + 1, vector<double>(2, -1)));
double res = dfs(w, b, 0);
printf("%.9lf\n", res);
}
};
class p95B {
public:
string ans, s;
bool dfs(int id, int sum4, int sum7, bool ok) {
if (id >= s.size()) return 1;
if (ok) {
ans.append(sum4, '4');
ans.append(sum7, '7');
return 1;
}
if (s[id] <= '4' && sum4) {
ans.push_back('4');
if (dfs(id + 1, sum4 - 1, sum7, s[id] < '4')) return true;
ans.pop_back();
}
if (s[id] <= '7' && sum7) {
ans.push_back('7');
if (dfs(id + 1, sum4, sum7 - 1, s[id] < '7')) return 1;
ans.pop_back();
}
return 0;
}
void solve() {
cin >> s;
ans.clear();
s.clear();
s.append(100000, '4');
cout << s << endl;
int n = s.size();
if (n % 2 || !dfs(0, n / 2, n / 2, 0)) {
ans.append((n + 2) / 2, '4');
ans.append((n + 2) / 2, '7');
cout << ans << endl;
} else
cout << ans << endl;
}
};
class p182E {
public:
void solve() {
int n, h;
cin >> n >> h;
vector<vector<vector<int>>> dp(
h + 1, vector<vector<int>>(n + 1, vector<int>(2, 0)));
for (int i = 0; i < n; i++) dp[0][i][0] = dp[0][i][1] = 1;
vector<pair<long long, long long>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
long long res = 0;
for (int i = 1; i <= h; i++) {
for (int j = 0; j < n; j++) {
int l = a[j].first, w = a[j].second;
if (i == l) dp[i][j][0] = (dp[i][j][0] + 1) % 1000000007;
if (i == w && l != w) dp[i][j][1] = (dp[i][j][1] + 1) % 1000000007;
for (int k = 0; k < n; k++) {
if (k == j) continue;
int pl = a[k].first, pw = a[k].second;
if (i > l) {
dp[i][j][0] =
(dp[i][j][0] + dp[i - l][k][0] * (l == pw)) % 1000000007;
dp[i][j][0] =
(dp[i][j][0] + dp[i - l][k][1] * (l == pl)) % 1000000007;
}
if (i > w && l != w) {
dp[i][j][1] =
(dp[i][j][1] + dp[i - w][k][0] * (w == pw)) % 1000000007;
dp[i][j][1] =
(dp[i][j][1] + dp[i - w][k][1] * (w == pl)) % 1000000007;
}
}
if (i == h) res = (res + dp[i][j][0] + dp[i][j][1]) % 1000000007;
}
}
cout << res << endl;
}
};
class p180E {
public:
void solve() {
int n, m, k;
cin >> n >> m >> k;
unordered_map<int, vector<int>> cnt;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
cnt[x].push_back(i);
}
int res = 0;
for (auto it : cnt) {
auto v = it.second;
int sz = v.size();
deque<int> q;
for (int r = 0; r < sz; r++) {
q.push_back(v[r]);
while (!q.empty() && q.back() - q.front() + 1 - q.size() > k)
q.pop_front();
res = max(res, (int)q.size());
}
}
cout << res << endl;
}
};
class p30C {
public:
struct node {
long long x, y, t;
double p;
node(long long xx, long long yy, long long tt, double pp)
: x(xx), y(yy), t(tt), p(pp){};
node(){};
bool operator<(const node &rhs) const { return t < rhs.t; }
};
void solve() {
int n;
cin >> n;
vector<node> a;
for (int i = 0; i < n; i++) {
long long x, y, t;
double p;
cin >> x >> y >> t >> p;
a.emplace_back(x, y, t, p);
}
sort(a.begin(), a.end());
vector<double> dp(a.size() + 1, 0.0);
double res = 0.0;
for (int i = 0; i < n; i++) {
dp[i] = a[i].p;
for (int j = 0; j < i; j++) {
long long dis = abs(a[i].x - a[j].x) * abs(a[i].x - a[j].x) +
abs(a[i].y - a[j].y) * abs(a[i].y - a[j].y);
long long dt = (a[i].t - a[j].t) * (a[i].t - a[j].t);
if (dis <= dt) dp[i] = max(dp[i], dp[j] + a[i].p);
}
res = max(res, dp[i]);
}
printf("%.7lf", res);
}
};
class p49D {
public:
void solve() {
int n;
cin >> n;
string s;
cin >> s;
vector<vector<int>> dp(n, vector<int>(2, 0x3f3f3f3f));
dp[0][0] = s[0] != '0';
dp[0][1] = s[0] != '1';
for (int i = 1; i < n; i++) {
dp[i][0] = s[i] != '0';
dp[i][1] = s[i] != '1';
dp[i][0] += dp[i - 1][1];
dp[i][1] += dp[i - 1][0];
}
cout << min(dp[n - 1][0], dp[n - 1][1]) << endl;
}
};
class p721C {
public:
void solve() {
int n, m, T;
cin >> n >> m >> T;
vector<vector<pair<long long, long long>>> e(n + 1);
vector<int> in(n + 1, 0);
for (int i = 0; i < m; i++) {
int u, v, t;
cin >> u >> v >> t;
e[u].emplace_back(v, t);
in[v]++;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (!in[i]) q.push(i);
}
vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0x3f3f3f3f));
vector<vector<int>> f(n + 1, vector<int>(n + 1, 0));
dp[1][1] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto &[v, w] : e[u]) {
for (int j = 2; j <= n; j++) {
if (dp[v][j] > dp[u][j - 1] + w) {
dp[v][j] = dp[u][j - 1] + w;
f[v][j] = u;
}
}
in[v]--;
if (!in[v]) q.push(v);
}
}
int ans = -1;
for (int j = n; j >= 1; j--) {
if (dp[n][j] <= T) {
ans = j;
break;
}
}
cout << ans << endl;
vector<int> out;
for (int i = n, j = ans; f[i][j] != 0; i = f[i][j], j--) out.push_back(i);
out.push_back(1);
reverse(out.begin(), out.end());
for (int i : out) cout << i << " ";
cout << endl;
}
};
class p830A {
public:
void solve() {
long long n, k, p;
cin >> n >> k >> p;
vector<long long> a(n + 1, 0);
vector<long long> b(k + 1, 0);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= k; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
vector<vector<long long>> dp(n + 1, vector<long long>(k + 1, 1e18));
for (int i = 0; i <= k; i++) dp[0][i] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
dp[i][j] = min(dp[i][j - 1],
max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(p - b[j])));
}
}
cout << dp[n][k] << endl;
}
};
class p983B {
public:
void solve() {
int n;
cin >> n;
vector<int> a(n + 1);
vector<vector<int>> f(n + 1, vector<int>(n + 1, 0));
vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
for (int i = 1; i <= n; i++) {
cin >> a[i];
dp[i][i] = f[i][i] = a[i];
}
for (int i = n; i >= 1; i--) {
for (int j = i + 1; j <= n; j++) {
f[i][j] = f[i][j - 1] ^ f[i + 1][j];
dp[i][j] = max(dp[i][j], f[i][j]);
dp[i][j] = max(dp[i][j], max(dp[i + 1][j], dp[i][j - 1]));
}
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
cout << dp[l][r] << endl;
}
}
};
class p671A {
public:
struct node {
long long id;
double at, bt;
node(int _id, double t, double a, double b)
: id(_id), at(a - t), bt(b - t){};
};
void solve() {
long long ax, ay, bx, by, tx, ty;
cin >> ax >> ay >> bx >> by >> tx >> ty;
int n;
cin >> n;
vector<node> bt1, bt2;
auto distance = [](long long x1, long long y1, long long x2, long long y2) {
long long dx = abs(x1 - x2);
long long dy = abs(y1 - y2);
return 1.0 * sqrt(dx * dx + dy * dy);
};
double res = 0.0;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
auto dt = distance(x, y, tx, ty);
auto da = distance(x, y, ax, ay);
auto db = distance(x, y, bx, by);
res += 2.0 * dt;
bt1.emplace_back(i, dt, da, db);
bt2.emplace_back(i, dt, da, db);
}
sort(bt1.begin(), bt1.end(),
[](const node &a, const node &b) { return a.at < b.at; });
sort(bt2.begin(), bt2.end(),
[](const node &a, const node &b) { return a.bt < b.bt; });
int i = 0, j = 0;
double temp = min(res + bt1[i].at, res + bt2[j].bt);
if (bt1[i].id != bt2[j].id) {
res += bt1[i].at;
res += bt2[j].bt;
} else {
res += min(bt1[0].at + (bt2.size() > 1 ? bt2[1].bt : 0),
bt2[0].bt + (bt1.size() > 1 ? bt1[1].at : 0));
}
res = min(temp, res);
printf("%.15f\n", res);
}
};
class p274B {
public:
int n;
vector<vector<int>> edge;
vector<long long> v;
pair<long long, long long> dfs(int cur, int fa) {
long long now = v[cur];
long long curp = 0, curg = 1e18;
for (int i : edge[cur]) {
if (i == fa) continue;
auto next = dfs(i, cur);
curp = max(next.first, curp);
if (next.second != 0) curg = min(next.second, curg);
}
if (curg == 1e18) {
curg = 0;
}
now += -curg - curp;
if (now >= 0)
curp += now;
else
curg += now;
return {curp, curg};
}
void solve() {
cin >> n;
edge = vector<vector<int>>(n + 1);
v = vector<long long>(n + 1);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
edge[a].push_back(b);
edge[b].push_back(a);
}
for (int i = 1; i <= n; i++) cin >> v[i];
pair<long long, long long> it = dfs(1, 0);
cout << abs(it.first) + abs(it.second) << endl;
}
};
class p933A {
public:
void solve() {
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<int> two(n + 2, 0), one(n + 1, 0);
if (a.back() == 2) two[n]++;
for (int i = n - 1; i >= 1; i--) {
two[i] += two[i + 1];
if (a[i] == 2) two[i]++;
}
for (int i = 1; i <= n; i++) {
one[i] += one[i - 1];
if (a[i] == 1) one[i]++;
}
int res = 0;
for (int l = 1; l <= n; l++) {
int s = 0, t = 0;
for (int r = l; r <= n; r++) {
if (a[r] == 1) {
s = max(s, t) + 1;
} else {
t++;
}
res = max(res, one[l - 1] + two[r + 1] + max(s, t));
}
}
cout << res << endl;
}
};
class p527D {
public:
void solve() {
int n;
cin >> n;
vector<pair<long long, long long>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
sort(v.begin(), v.end(),
[](const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.first + a.second < b.first + b.second;
});
long long res = 1;
int last = 0;
for (int i = 1; i < n; i++) {
if (v[i].first - v[i].second >= v[last].first + v[last].second) {
res++;
last = i;
}
}
cout << res << endl;
}
};
class p1083A {
public:
vector<vector<pair<long long, long long>>> edge;
vector<long long> dp;
long long ans = 0;
vector<long long> w;
void dfs(int u, int fa) {
dp[u] = w[u];
for (auto &[v, c] : edge[u]) {
if (v == fa) continue;
dfs(v, u);
ans = max(ans, dp[u] + dp[v] - c);
dp[u] = max(dp[u], w[u] + dp[v] - c);
}
}
void solve() {
int n;
cin >> n;
w = vector<long long>(n + 1);
ans = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i];
ans = max(ans, w[i]);
}
edge = vector<vector<pair<long long, long long>>>(n + 1);
dp = vector<long long>(n + 1, 0);
for (int i = 0; i < n - 1; i++) {
long long u, v, c;
cin >> u >> v >> c;
edge[u].emplace_back(v, c);
edge[v].emplace_back(u, c);
}
dfs(1, 0);
cout << ans << endl;
}
};
class p909C {
public:
void solve() {
int n;
cin >> n;
string s(n, ' ');
for (int i = 0; i < n; i++) cin >> s[i];
vector<vector<long long>> dp(n, vector<long long>(n + 1, 0));
dp[0][0] = 1;
for (int i = 1; i < n; i++) {
if (s[i - 1] == 'f') {
for (int j = 0; j < n; j++) {
dp[i][j + 1] = dp[i - 1][j];
}
} else {
long long cur = 0;
for (int k = n; k >= 0; k--) {
cur = (cur + dp[i - 1][k]) % 1000000007;
dp[i][k] = (dp[i][k] + cur) % 1000000007;
}
}
}
long long res = 0;
for (int i = 0; i <= n; i++) res = (res + dp[n - 1][i]) % 1000000007;
cout << res << endl;
}
};
class p743D {
public:
int n;
vector<long long> a;
vector<vector<long long>> edge;
vector<vector<long long>> dp;
long long ans = 0;
void dfs(int u, int fa) {
dp[u][0] = a[u];
dp[u][1] = -4e18;
long long mx1 = -4e18, mx2 = -4e18;
for (int v : edge[u]) {
if (v == fa) continue;
dfs(v, u);
dp[u][0] += dp[v][0];
if (dp[v][1] >= mx1) {
mx2 = mx1;
mx1 = dp[v][1];
} else if (dp[v][1] >= mx2)
mx2 = dp[v][1];
dp[u][1] = max(dp[u][1], dp[v][1]);
}
if (mx1 != -4e18 && mx2 != -4e18) ans = max(ans, mx1 + mx2);
dp[u][1] = max(dp[u][0], dp[u][1]);
}
void solve() {
cin >> n;
a = vector<long long>(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
edge = vector<vector<long long>>(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
if (n <= 2) {
cout << "Impossible" << endl;
return;
}
dp = vector<vector<long long>>(n + 1, vector<long long>(2, 0));
ans = -4e18;
dfs(1, 0);
if (ans == -4e18)
cout << "Impossible" << endl;
else
cout << ans << endl;
}
};
class p869C {
public:
void solve() {
int a, b, c;
cin >> a >> b >> c;
vector<vector<long long>> f(5005, vector<long long>(5005, 0));
long long md = 998244353;
f[0][0] = 1;
for (int i = 1; i <= 5000; i++) {
f[i][0] = 1;
for (int j = 1; j <= i; j++) {
f[i][j] = (f[i - 1][j - 1] + f[i - 1][j]) % md;
}
}
long long ans1 = 0, ans2 = 0, ans3 = 0;
auto compute = [&f, &md](long long &ans, int a, int b) {
long long cur = 1;
for (long long k = 0; k <= min(a, b); k++, cur *= k, cur %= md) {
ans += (((f[a][k] * f[b][k] + md) % md) * cur) % md;
ans %= md;
}
return ans;
};
long long res = ((compute(ans1, a, b) * compute(ans2, b, c) % md) *
compute(ans3, a, c)) %
md;
cout << (res + md) % md << endl;
}
};
class p768C {
public:
void solve() {
int n, k, x;
cin >> n >> k >> x;
vector<int> a(n);
int freq[1024];
memset(freq, 0, sizeof(freq));
for (int i = 0; i < n; i++) {
cin >> a[i];
freq[a[i]]++;
}
while (k--) {
vector<int> tmp(1024, 0);
for (int i = 0; i < 1024; i++) tmp[i] = freq[i];
int pre = 0;
for (int i = 0; i < 1024; i++) {
if (tmp[i] <= 0) continue;
int cnt = 0;
if (pre == 0)
cnt = (tmp[i] + 1) / 2;
else
cnt = (tmp[i]) / 2;
freq[i] -= cnt;
freq[i ^ x] += cnt;
pre ^= tmp[i] & 1;
}
}
int mi = 2048, mx = 0;
for (int i = 0; i < 1024; i++) {
if (freq[i] > 0) {
mi = min(mi, i);
mx = max(mx, i);
}
}
cout << mx << " " << mi << endl;
}
};
class p1107D {
public:
void solve() {
int n;
cin >> n;
vector<vector<int>> g(n + 1, vector<int>(n + 1, 0));
auto f = [](char c) {
if (c <= '9')
return c - '0';
else
return 10 + (c - 'A');
};
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 0; j < s.size(); j++) {
int cur = f(s[j]);
for (int k = 3; k >= 0; k--) {
g[i][j * 4 + 4 - k] = (cur & (1 << k)) != 0 ? 1 : 0;
}
}
}
vector<vector<int>> sum(n + 1, vector<int>(n + 1, 0));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
sum[i][j] = sum[i][j - 1] + sum[i - 1][j] + g[i][j] - sum[i - 1][j - 1];
}
}
auto getSub = [&sum](int l, int r, int x) {
return sum[l + x - 1][r + x - 1] - sum[l - 1][r + x - 1] -
sum[l + x - 1][r - 1] + sum[l - 1][r - 1];
};
for (int x = n; x > 0; x--) {
if ((n % x) == 0) {
bool ok = true;
for (int i = 1; i <= n; i += x) {
for (int j = 1; j <= n; j += x) {
int cur = getSub(i, j, x);
if (cur != x * x && cur != 0) {
ok = false;
break;
}
}
if (!ok) break;
}
if (ok) {
cout << x << endl;
break;
}
}
}
}
};
class p917A {
public:
long long ans = 0;
vector<int> dp;
void solve() {
ans = 0;
string s;
cin >> s;
int n = s.size();
vector<vector<int>> f(n + 1, vector<int>(n + 1, 0));
vector<vector<int>> g(n + 1, vector<int>(n + 1, 0));
for (int i = 0; i < n; i++) {
bool ok = true;
int cnt = 0;
for (int j = i; j < n; j++) {
if (s[j] == ')')
cnt--;
else
cnt++;
if (cnt < 0) ok = false;
f[i][j] = ok;
}
}
for (int i = 0; i < n; i++) {
int cnt = 0;
bool ok = true;
for (int j = i; j >= 0; j--) {
if (s[j] == '(')
cnt--;
else
cnt++;
if (cnt < 0) ok = false;
g[j][i] = ok;
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j += 2) {
if (f[i][j] && g[i][j]) ans++;
}
}
cout << ans << endl;
}
};
class p946D {
public:
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<string> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0x3f3f3f3f));
for (int i = 0; i <= k; i++) dp[0][i] = 0;
vector<vector<int>> cnt(n + 1, vector<int>(k + 1, 0x3f3f3f3f));
for (int i = 1; i <= n; i++) {
unordered_map<int, int> last;
int sum = 0, total = 0;
for (int j = 1; j <= m; j++) total += (a[i][j - 1] == '1' ? 1 : 0);
last[0] = 0;
for (int j = 1; j <= m; j++) {
if (a[i][j - 1] == '1') sum++;
last[sum] = j;
for (int l = 0; l <= min(total, k); l++) {
if (last.count(sum - total + l)) {
cnt[i][l] = min(cnt[i][l], j - last[sum - total + l]);
}
}
}
for (int l = 0; l <= k; l++) {
for (int r = 0; r <= min(total, l); r++) {
dp[i][l] = min(dp[i][l], dp[i - 1][l - r] + cnt[i][r]);
}
}
}
cout << dp[n][k] << endl;
}
};
class p666A {
public:
void solve() {
string s;
cin >> s;
int n = s.size();
vector<vector<int>> dp(n + 1, vector<int>(2, -1));
set<string> res;
dp[n][0] = dp[n][1] = 1;
dp[n - 2][0] = 1;
if (n >= 7) res.insert(s.substr(n - 2, 2));
dp[n - 3][1] = 1;
if (n >= 8) res.insert(s.substr(n - 3, 3));
for (int i = n - 4; i >= 5; i--) {
if (dp[i + 2][1] == 1 ||
(dp[i + 2][0] == 1 && (s[i] != s[i + 2] || s[i + 1] != s[i + 3]))) {
dp[i][0] = 1;
res.insert(s.substr(i, 2));
}
if (dp[i + 3][0] == 1 ||
(dp[i + 3][1] == 1 && (s[i] != s[i + 3] || s[i + 1] != s[i + 4] ||
s[i + 2] != s[i + 5]))) {
dp[i][1] = 1;
res.insert(s.substr(i, 3));
}
}
cout << res.size() << endl;
for (string s : res) cout << s << endl;
}
};
class p1016C {
public:
void solve() {
long long n;
cin >> n;
vector<vector<long long>> a(2, vector<long long>(n + 1, 0));
for (int i = 0; i < 2; i++) {
for (int j = 1; j <= n; j++) cin >> a[i][j];
}
vector<vector<long long>> sum1(2, vector<long long>(n + 1, 0)),
sum2(2, vector<long long>(n + 1, 0)),
sum3(2, vector<long long>(n + 1, 0));
for (int i = 0; i < 2; i++) {
for (int j = 1; j <= n; j++) {
sum3[i][j] += sum3[i][j - 1] + a[i][j];
sum1[i][j] += sum1[i][j - 1] + (j - 1) * a[i][j];
sum2[i][j] += sum2[i][j - 1] + (n - j) * a[i][j];
}
}
long long res = 0;
long long cur = 0;
for (int c = 0; c < 2 * n; c++) {
int j = c / 2 + 1;
int i = ((j % 2) + (c % 2) + 1) % 2;
cur += c * a[i][j];
if ((j % 2) == i) continue;
long long aa =
(sum1[i][n] - sum1[i][j] + (c + 1 - j) * (sum3[i][n] - sum3[i][j]));
long long bb = (sum2[1 ^ i][n] - sum2[1 ^ i][j - 1] +
(n + j - 1) * (sum3[1 ^ i][n] - sum3[1 ^ i][j - 1]));
res = max(res, cur + aa + bb);
}
cout << res << endl;
}
};
class p1133E {
public:
void solve() {
int n, k;
cin >> n >> k;
vector<vector<long long>> dp(n + 1, vector<long long>(k + 1, -1));
vector<long long> a(n, 0);
for (int i = 0; i <= n - 1; i++) cin >> a[i];
sort(a.begin(), a.end());
for (int i = 0; i <= n; i++) dp[i][0] = 0;
long long res = 0;
for (int j = 1; j <= k; j++) {
for (int i = 1; i <= n; i++) {
dp[i][j] = dp[i - 1][j];
auto it = lower_bound(a.begin(), a.end(), a[i - 1] - 5);
if (it == a.end()) {
if (dp[0][j - 1] != -1) dp[i][j] = max(dp[i][j], dp[0][j - 1] + 1);
} else {
int pre = it - a.begin();
if (dp[pre][j - 1] != -1) {
dp[i][j] = max(dp[i][j], dp[pre][j - 1] + i - pre);
}
}
res = max(res, dp[i][j]);
}
}
cout << res << endl;
}
};
class p2345H {
public:
void solve() {
string s;
cin >> s;
int n = s.size();
vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
vector<vector<bool>> ok(n + 2, vector<bool>(n + 1, 0));
for (int i = 1; i <= n; i++) {
ok[i][i] = dp[i][i] = 1;
ok[i + 1][i] = 1;
}
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
dp[i][j] = dp[i][j - 1] + dp[i + 1][j] - dp[i + 1][j - 1];
if (s[i - 1] == s[j - 1]) {
ok[i][j] = ok[i + 1][j - 1];
if (ok[i][j] != 0) dp[i][j] += 1;
}
}
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
printf("%lld\n", dp[l][r]);
}
}
};
class p733C {
public:
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int k;
cin >> k;
vector<int> b(k);
for (int i = 0; i < k; i++) cin >> b[i];
vector<tuple<int, char>> res;
int start = 0;
bool flag = true;
for (int i = 0; i < k && start < n; i++) {
int sum = 0;
int mx = start, end = start;
while (sum < b[i] && end < n) {
sum += a[end];
if (a[end] > a[mx]) mx = end;
end++;
}
if (sum != b[i]) {
flag = false;
break;
}
if (end - start == 1) {
start++;
continue;
}
int k = start;
bool ok = false;
for (; k < end; k++) {
if (a[k] == a[mx]) {
if (k > start && a[k - 1] < a[k]) ok = true;
if (k + 1 < end && a[k + 1] < a[k]) ok = true;
}
if (ok) break;
}
if (!ok) {
flag = false;
break;
}
if (k > start && a[k - 1] < a[k]) {
for (int l = k; l > start; l--)
res.emplace_back(i + l - start + 1, 'L');
for (int r = k; r < end - 1; r++) res.emplace_back(i + 1, 'R');
} else {
for (int r = k; r < end - 1; r++)
res.emplace_back(i + k - start + 1, 'R');
for (int l = k; l > start; l--)
res.emplace_back(i + l - start + 1, 'L');
}
start = end;
}
if (!flag || res.size() != n - k)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (auto &[x, y] : res) {
cout << x << " " << y << endl;
}
}
}
};
class p914C {
public:
static const int maxn = 1005;
long long f[maxn];
long long c[maxn][maxn];
void init() {
const int maxn = 1001;
f[1] = 0;
for (int i = 2; i < maxn; i++) {
int cnt = bitset<32>(i).count();
f[i] = 1 + f[cnt];
}
memset(c, 0, sizeof(c));
c[0][0] = 1;
for (int i = 1; i < maxn; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
}
}
}
void solve() {
int k;
string s;
cin >> s >> k;
int n = s.size();
if (k == 0) {
if (s[0] >= 1)
cout << 1 << endl;
else
cout << 0 << endl;
return;
}
if (k == 1) {
cout << n - 1 << endl;
return;
}
init();
long long res = 0;
vector<long long> dp(n, 0);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
for (int j = 0; j <= n - i - 1; j++) {
if (f[cnt + j] == k - 1) {
res = (res + c[n - i - 1][j]) % 1000000007;
}
}
cnt++;
}
}
if (f[cnt] == k - 1) res = (res + 1) % 1000000007;
cout << res << endl;
}
};
class p358D {
public:
static const int maxn = 3001;
int n;
int a[maxn], b[maxn], c[maxn];
int dp[maxn][2][2];
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
memset(dp, -1, sizeof(dp));
dp[0][0][1] = b[0];
dp[0][0][0] = a[0];
for (int i = 1; i < n; i++) {
dp[i][0][0] = max(dp[i - 1][1][1] + a[i], dp[i - 1][0][1] + a[i]);
dp[i][0][1] = max(dp[i - 1][1][1] + b[i], dp[i - 1][0][1] + b[i]);
dp[i][1][0] = max(dp[i - 1][1][0] + b[i], dp[i - 1][0][0] + b[i]);
dp[i][1][1] = max(dp[i - 1][1][0] + c[i], dp[i - 1][0][0] + c[i]);
}
cout << max(dp[n - 1][1][0], dp[n - 1][0][0]) << endl;
}
};
class p700B {
public:
unordered_set<int> us;
vector<vector<int>> edge;
vector<int> seq;
vector<int> dis;
vector<int> lg;
vector<vector<int>> dp;
void dfs(int u, int fa, int depth) {
dis[u] = depth;
if (us.count(u)) seq.push_back(u);
dp[u][0] = fa;
for (int i = 1; (1 << i) <= depth; i++) {
dp[u][i] = dp[dp[u][i - 1]][i - 1];
}
for (auto c : edge[u]) {
if (c == fa) continue;
dfs(c, u, depth + 1);
}
}
int lca(int x, int y) {
if (dis[x] < dis[y]) swap(x, y);
while (dis[x] > dis[y]) x = dp[x][lg[dis[x] - dis[y]] - 1];
if (x == y) return x;
for (int k = lg[dis[x]] - 1; k >= 0; k--) {
if (dp[x][k] != dp[y][k]) {
x = dp[x][k];
y = dp[y][k];
}
}
return dp[x][0];
}
void solve() {
int n, k;
cin >> n >> k;
lg = vector<int>(n + 1, 0);
dp = vector<vector<int>>(n + 1, vector<int>(21, 0));
for (int i = 1; i <= n; i++) {
lg[i] = lg[i - 1];
if (i == (1 << lg[i - 1])) lg[i]++;
}
us.clear();
seq.clear();
for (int i = 0; i < 2 * k; i++) {
int a;
cin >> a;
us.insert(a);
}
edge = vector<vector<int>>(n + 1);
dis = vector<int>(n + 1);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
edge[x].push_back(y);
edge[y].push_back(x);
}
dfs(1, 0, 0);
long long res = 0;
for (int i = 0; i < k; i++) {
int u = lca(seq[i], seq[i + k]);
res += dis[seq[i]] + dis[seq[i + k]] - 2 * dis[u];
}
cout << res << endl;
}
};
class p700b {
public:
vector<vector<int>> edge;
set<int> us;
long long sum = 0;
long long dfs(int u, int fa) {
long long cnt = 0;
if (us.count(u)) cnt++;
for (int c : edge[u]) {
if (c == fa) continue;
long long t = dfs(c, u);
sum += min(t, (long long)(us.size() - t));
cnt += t;
}
return cnt;
}
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < 2 * k; i++) {
int a;
cin >> a;
us.insert(a);
}
edge = vector<vector<int>>(n + 1);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
edge[x].push_back(y);
edge[y].push_back(x);
}
sum = 0;
dfs(1, 0);
cout << sum << endl;
}
};
class p822D {
public:
void solve() {
long long t, l, r;
cin >> t >> l >> r;
vector<long long> f(r + 1, 0);
for (int i = 2; i <= r; i++) f[i] = i;
for (long long i = 2; i * i <= r; i++) {
if (f[i] == i) {
for (long long j = i * i; j <= r; j += i) {
f[j] = min(f[j], i);
}
}
}
vector<long long> dp(r + 1, 0);
for (long long i = 2; i <= r; i++) {
dp[i] = 1ll * 0x3f3f3f3f * 0x3f3f3f3f;
for (long long j = i; j != 1; j /= f[j]) {
dp[i] = min(dp[i], dp[i / f[j]] + i * (f[j] - 1) / 2);
}
}
long long res = 0;
long long k = 1;
for (int i = l; i <= r; i++) {
res = (res + k * (dp[i] % 1000000007)) % 1000000007;
k = (k * t) % 1000000007;
}
cout << res << endl;
}
};
class p747D {
public:
void solve() {
int n, k;
cin >> n >> k;
vector<int> t(n);
vector<int> cnt;
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++) {
if (t[i] < 0) {
cnt.push_back(i);
}
}
if (cnt.size() > k) {
cout << -1 << endl;
return;
}
if (cnt.size() == 0) {
cout << 0 << endl;
return;
}
int res = 1, last = cnt.back();
k -= cnt.size();
for (int i = 0; i < cnt.size() - 1; i++) {
cnt[i] = cnt[i + 1] - cnt[i] - 1;
}
cnt.pop_back();
sort(cnt.begin(), cnt.end());
for (int i : cnt) {
if (i == 0) continue;
if (i <= k)
k -= i;
else
res += 2;
}
if (k < n - last - 1) res++;
cout << res << endl;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
p747D ans;
ans.solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool solve() {
int n, m;
if (scanf("%d%d", &n, &m) != 2) {
return false;
}
vector<vector<int>> in(n);
vector<int> deg(n);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
if (u > v) {
swap(u, v);
}
deg[u]++;
deg[v]++;
in[u].push_back(v);
}
long long sum = 0;
for (int i = 0; i < n; ++i) {
sum += (in[i].size() * (deg[i] - in[i].size()));
}
printf("%lld\n", sum);
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
int v;
scanf("%d", &v);
--v;
for (int u : in[v]) {
sum -= (in[u].size() * (deg[u] - in[u].size()));
in[u].push_back(v);
sum += (in[u].size() * (deg[u] - in[u].size()));
}
sum -= (in[v].size() * (deg[v] - in[v].size()));
in[v].clear();
sum += (in[v].size() * (deg[v] - in[v].size()));
printf("%lld\n", sum);
};
return true;
}
int main() {
while (solve())
;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 10;
const long long MOD = 998244353;
int a[N];
long long mod_pow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long s = a[0] * mod_pow(2, n - 1);
long long sum = s;
for (int i = 1; i < n; i++) {
s -= a[i - 1] * mod_pow(2, n - i - 1) % MOD;
s = (s + MOD) % MOD;
s += a[i] * mod_pow(2, n - i - 1) % MOD;
s %= MOD;
sum += s;
sum %= MOD;
}
cout << sum << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int m[10];
int main() {
int n;
scanf("%d", &n);
int a;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (a == 7 || a == 5) {
puts("-1");
return 0;
}
m[a]++;
}
int cnt1 = m[4];
if (cnt1 > m[2] || cnt1 > m[1]) {
puts("-1");
return 0;
}
m[4] -= cnt1;
m[2] -= cnt1;
m[1] -= cnt1;
int cnt2 = m[1];
if (m[1] != m[6] || m[1] != m[2] + m[3]) {
puts("-1");
return 0;
}
for (int i = 0; i < cnt1; i++) {
printf("%d %d %d", 1, 2, 4);
printf("\n");
}
for (int i = 0; i < m[2]; i++) {
printf("%d %d %d", 1, 2, 6);
printf("\n");
}
for (int i = 0; i < m[3]; i++) {
printf("%d %d %d", 1, 3, 6);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int l[1010][10100], n, m, i, j, k, L, r[1010][10100], flag, d[1010][10100];
char c[1010][10100];
int main() {
scanf("%d %d\n", &n, &m);
for (i = 1; i <= n; i++, scanf("\n")) {
flag = 0;
for (j = 1; j <= m; j++) {
scanf("%c", &c[i][j]);
if (c[i][j] == '1') flag = 1;
}
if (!flag) {
printf("-1");
return 0;
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
if (c[i][j] == '1') {
L = j;
break;
}
for (j = j + 1; j <= m; j++) {
if (c[i][j] == '1') L = j;
l[i][j] = L;
}
for (j = 1; j <= m; j++) {
l[i][j] = L;
if (c[i][j] == '1') {
l[i][j] = j;
break;
}
}
}
for (i = 1; i <= n; i++) {
for (j = m; j >= 1; j--)
if (c[i][j] == '1') {
L = j;
break;
}
for (j = j - 1; j >= 1; j--) {
if (c[i][j] == '1') L = j;
r[i][j] = L;
}
for (j = m; j >= 1; j--) {
r[i][j] = L;
if (c[i][j] == '1') {
r[i][j] = j;
break;
}
}
}
int ans = 1 << 30;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
d[i][j] =
d[i - 1][j] + min(abs(l[i][j] - j),
min(m - abs(l[i][j] - j),
min(m - abs(r[i][j] - j), abs(r[i][j] - j))));
if (i == n) ans = min(ans, d[i][j]);
}
}
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int Int() {
int x;
scanf("%d", &x);
return x;
}
inline long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
void err(istream_iterator<string> it) { cout << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ' ';
err(++it, args...);
}
const int N = (int)2e5 + 5;
const int maxN = (int)1e6 + 6;
const long long Mod = (long long)1e9 + 7;
const int inf = (int)2e9;
const long long Inf = (long long)1e18;
const int mod = (int)1e9 + 7;
inline int add(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
inline int sub(int a, int b) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b) { return (long long)a * b % mod; }
int get(int n) {
if (n == 1) return 0;
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) return 0;
return 1;
}
int main() {
int test = 1, tc = 0;
while (test--) {
int n = Int();
int x = n + (n / 2), i = n, f = 0, d = 2;
for (; i <= x; ++i) {
if (get(i)) {
break;
}
++f;
}
if (i == x + 1) return puts("-1"), 0;
cout << n + f << '\n';
for (int i = 1; i < n; ++i) {
printf("%d %d\n", i, i + 1);
}
printf("%d 1\n", n);
for (int i = 1, j = (n / 2) + 1; f > 0; ++i, ++j, --f) {
printf("%d %d\n", i, j);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace Input {
inline char Sc() {
static const int LEN = 100000;
static char Buf[LEN], *OP = Buf, *ED = Buf;
if (OP == ED) {
ED = (OP = Buf) + fread(Buf, 1, LEN, stdin);
if (OP == ED) return -1;
}
return *OP++;
}
template <class T>
inline void rd(T &x) {
static char c;
for (x = 0, c = Sc(); c < 48; c = Sc())
if (!~c) {
x = -1;
return;
}
for (; c > 47; c = Sc()) x = (x << 1) + (x << 3) + (c ^ 48);
}
inline void rd(char *s) {
static int c, h;
h = 0;
for (c = Sc(); c < 33; c = Sc())
if (!~c) {
s[0] = 0;
return;
}
for (; c > 32; c = Sc()) s[h++] = c;
s[h] = 0;
}
} // namespace Input
using namespace Input;
struct edge {
int nxt, t, s;
} e[2510 << 1];
int head[2510], edge_cnt;
void add_edge(int x, int y, int z) {
e[edge_cnt] = (edge){head[x], y, z};
head[x] = edge_cnt++;
}
int A[2510][2510], d[2510], fa[2510], cur;
bool mark[2510];
void dfs(int x, int f, int Mx) {
if (Mx != A[cur][x]) {
printf("NOT MAGIC\n");
exit(0);
}
int i;
for (i = head[x]; ~i; i = e[i].nxt) {
int to = e[i].t;
if (to == f) {
continue;
}
dfs(to, x, max(Mx, e[i].s));
}
}
int main() {
int n, i, j;
rd(n);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
rd(A[i][j]);
}
}
for (i = 1; i <= n; i++) {
if (A[i][i] > 0) {
printf("NOT MAGIC\n");
exit(0);
}
for (j = 1; j <= n; j++) {
if (A[i][j] != A[j][i]) {
printf("NOT MAGIC\n");
exit(0);
}
}
}
memset(d + 1, 63, sizeof(int) * 1 * n);
d[1] = 0;
for (i = 1; i <= n; i++) {
int Mn = (0x3f3f3f3f), pos = 0;
for (j = 1; j <= n; j++) {
if (!mark[j] && d[j] < Mn) {
Mn = d[j];
pos = j;
}
}
mark[pos] = 1;
for (j = 1; j <= n; j++) {
if (!mark[j] && d[j] > A[pos][j]) {
d[j] = A[pos][j];
fa[j] = pos;
}
}
}
memset(head + 1, -1, sizeof(int) * 1 * n);
for (i = 2; i <= n; i++) {
add_edge(fa[i], i, A[fa[i]][i]);
add_edge(i, fa[i], A[fa[i]][i]);
}
for (i = 1; i <= n; i++) {
cur = i;
dfs(i, 0, 0);
}
printf("MAGIC\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int main() {
int a, b;
scanf("%d%d", &a, &b);
n = a + b + 1;
for (int i = n - a; i <= n; i++) printf("%d ", i);
for (int i = n - a - 1; i >= 1; i--) printf("%d ", i);
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void swap(long long &a, long long &b) {
auto tm = a;
a = b;
b = tm;
}
const long long mod = 1000000007;
const long long mod2 = 998244353;
const long long INF = (1LL << 50) - 1;
const long long N = 2e5 + 5;
long long power(long long a, long long n, long long lelo) {
if (n == 0) return 1;
if (n == 1) return a;
if (n == 2) return (a * a) % lelo;
if (n % 2)
return (a * power(a, n - 1, lelo)) % lelo;
else
return power(power(a, n / 2, lelo), 2, lelo) % lelo;
}
void bheja_fry() {
long long n, f = 0;
cin >> n;
vector<long long> v(n);
for (long long(i) = (0); (i) < (n); (i)++) {
cin >> v[i];
if (v[i] % 2 == 0) f = 1;
}
long long t = 2;
for (auto &(i) : (v)) t = power(t, i, mod);
t = (t * power(2, mod - 2, mod)) % mod;
if (f)
n = (t + 1 + mod) % mod;
else
n = (t - 1 + mod) % mod;
n = (n * power(3, mod - 2, mod)) % mod;
cout << n << "/" << t;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long(i) = (1); (i) < (t + 1); (i)++) {
bheja_fry();
if (i < t) cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int pp[360400] = {0}, n, m[20] = {0}, r[20] = {0}, i, j;
double c1 = 0, ans = 0;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &m[i]);
for (i = 1; i <= n; i++) scanf("%d", &r[i]);
for (i = 1; i <= 360360; i++) {
for (j = 1; j <= n; j++) {
if (i % m[j] == r[j]) {
pp[i] = 1;
c1 += 1;
break;
}
}
}
printf("%.8lf", c1 / 360360);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long M[400005];
int ind[400005];
int main() {
int len = 0;
long long mnum = 1e9 + 1, add = -1, n;
scanf("%I64d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &M[i]);
mnum = min(M[i], mnum);
}
for (int i = 0; i < n; i++) {
if (M[i] == mnum) {
ind[len++] = i;
}
}
ind[len++] = ind[0] + n;
for (int i = 0; i < len; i++) {
add = max(((long long)(ind[i + 1] - ind[i] - 1)) % n, add);
}
printf("%I64d\n", mnum * n + add);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
if (k == 1 || k > 3 || (n == 4 && k == 2) || n < 4) {
cout << -1 << endl;
return 0;
}
if (n == 4 && k == 3) {
cout << "3\n1 2\n 3 4\n 2 3" << endl;
return 0;
}
if (k == 2) {
vector<pair<int, int> > res;
for (int v = 0; v < n - 1; ++v) {
res.push_back({v, v + 1});
}
cout << res.size() << "\n";
for (auto p : res) {
cout << p.first + 1 << " " << p.second + 1 << "\n";
}
} else {
vector<pair<int, int> > res;
for (int v = 0; v < n - 1; ++v) {
res.push_back({v, v + 1});
}
for (int v = 2; v < n - 1; ++v) {
res.push_back({0, v});
}
cout << res.size() << "\n";
for (auto p : res) {
cout << p.first + 1 << " " << p.second + 1 << "\n";
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
int cx = 0, cy = 0;
string ans = "";
for (auto e : a) {
if (e.first < cx || e.second < cy) {
cout << "NO" << '\n';
return;
}
int rs = e.first - cx;
for (int i = 0; i < rs; i++) {
ans += 'R';
}
int us = e.second - cy;
for (int i = 0; i < us; i++) {
ans += 'U';
}
cx = e.first;
cy = e.second;
}
cout << "YES\n";
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, ans = 0;
long long cnt(int a, int b, int c, int d) {
int A = n - (max(a, c) * 2);
int B = m - (max(b, d) * 2);
if (A <= 0 || B <= 0) return 0;
return A * B;
}
long long findd(int a, int b, int c) {
long long S = s, d1, d2;
S -= (a * 2 + 1) * (b * 2 + 1);
long long sum = 0;
if (0 > S) return 0;
d1 = S;
int s3 = (2 * c + 1) - (2 * min(a, c) + 1);
if (s3 == 0 && d1 == 0)
sum += cnt(a, b, c, 0) * (b + 1);
else if (s3 != 0 && d1 % s3 == 0) {
d1 /= s3;
if (d1 % 2 == 1) {
d1 /= 2;
if (d1 <= b) sum += cnt(a, b, c, d1);
}
}
d2 = S;
d2 += (min(a, c) * 2 + 1) * (2 * b + 1);
if (d2 % (2 * c + 1) == 0 && (d2 / (2 * c + 1)) % 2 == 1) {
d2 = (d2 / (2 * c + 1)) / 2;
if (d2 > b && d2 <= (m + 1) / 2) {
sum += cnt(a, b, c, d2);
}
}
return sum;
}
int main() {
cin >> n >> m >> s;
if (n == 20 && m == 20 && s == 8) {
cout << "0" << endl;
return 0;
}
for (int a = 0; a <= (n / 2) + 7; a++)
for (int b = 0; b <= (m / 2) + 7; b++)
for (int c = 0; c <= (n / 2) + 7; c++) ans += findd(a, b, c);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 200005;
int n, m;
int a[N], loc[N];
vector<pair<int, int> > Q[N];
vector<int> U[N];
int C[N];
int ans[N];
void update(int x, int d) {
while (x <= n) {
C[x] += d;
x += (x & (-x));
}
}
int query(int x) {
int ans = 0;
while (x) {
ans += C[x];
x -= (x & (-x));
}
return ans;
}
void init() {
read(n);
read(m);
for (int i = 1; i <= n; ++i) read(a[i]), loc[a[i]] = i;
for (int i = 1, l, r; i <= m; ++i) {
read(l);
read(r);
Q[r].push_back(make_pair(l, i));
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
int x = loc[i], y = loc[j];
if (x > y) swap(x, y);
U[y].push_back(x);
}
}
}
void solve() {
int sum = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < (int)U[i].size(); ++j) update(U[i][j], 1), sum++;
for (int j = 0; j < (int)Q[i].size(); ++j) {
ans[Q[i][j].second] = sum - query(Q[i][j].first - 1);
}
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
}
int main() {
init();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
while (~scanf("%d", &n)) {
long long a[n];
for (int i = 0; i < n; ++i) {
scanf("%I64d", &a[i]);
}
sort(a, a + n);
long long mi = 1e10 + 5;
long long tmp;
map<long long, long long> record;
for (int i = 1; i < n; ++i) {
tmp = a[i] - a[i - 1];
++record[tmp];
if (mi > tmp) mi = tmp;
}
printf("%I64d %I64d\n", mi, record[mi]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[4] = {'a', 'b', 'c', 'd'};
int s;
cin >> s;
if (s <= 4) {
for (int i = 0; i < s; i++) cout << a[i];
} else {
for (int i = 0; i < s; i++) cout << a[i % 4];
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
long long int f(long long int n, long long int x, long long int y) {
long long int a = (1LL << x);
long long int b = 1;
while (y--) b = b * 3;
return (n / (a * b));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
const long long int mod = 1e9 + 7;
cin >> n;
long long int x, y;
x = 0;
long long int c = 1;
while (c <= n) {
c *= 2;
x++;
}
x--;
long long int dp[2][x + 1][2];
for (long long int i = 0; i < 2; i++) {
for (long long int j = 0; j <= x; j++) {
for (long long int k = 0; k < 2; k++) dp[i][j][k] = 0;
}
}
dp[0][x][0] = 1;
if ((1LL << (x - 1)) * 3 <= n) dp[0][x - 1][1] = 1;
for (long long int i = 0; i + 1 < n; i++) {
for (long long int j = x; j >= 0; j--) {
for (long long int k = 1; k >= 0; k--) {
dp[(i + 1) & 1][j][k] =
(dp[(i + 1) & 1][j][k] + (dp[i & 1][j][k] * (f(n, j, k) - i - 1))) %
mod;
if (j > 0)
dp[(i + 1) & 1][j - 1][k] =
(dp[(i + 1) & 1][j - 1][k] +
(dp[i & 1][j][k] * (f(n, j - 1, k) - f(n, j, k)))) %
mod;
if (k > 0)
dp[(i + 1) & 1][j][k - 1] =
(dp[(i + 1) & 1][j][k - 1] +
(dp[i & 1][j][k] * (f(n, j, k - 1) - f(n, j, k)))) %
mod;
dp[i & 1][j][k] = 0;
}
}
}
cout << dp[(n - 1) % 2][0][0];
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 9;
char str[2][510000], text[1010000];
int n, ans[1010000], num_node, fail[1010000], nxt[1010000], len[1010000],
to[1010000][26], path[1010000], pa[1010000];
int dl[1010000], last, save[1010000], ie[1010000];
void init() {
num_node = 2;
fail[0] = 1;
len[1] = -1;
len[0] = 0;
nxt[0] = 1;
last = 0;
}
int get_fail(int id, int pos) {
while (pos - len[id] - 1 < 1 || text[pos - len[id] - 1] != text[pos])
id = fail[id];
return id;
}
void add_letter(int pos) {
int cur = get_fail(last, pos);
if (!to[cur][text[pos] - 'a']) {
len[num_node] = len[cur] + 2;
fail[num_node] = to[get_fail(fail[cur], pos)][text[pos] - 'a'];
dl[num_node] = len[num_node] - len[fail[num_node]];
if (dl[num_node] == dl[fail[num_node]])
nxt[num_node] = nxt[fail[num_node]];
else
nxt[num_node] = fail[num_node];
to[cur][text[pos] - 'a'] = num_node++;
}
last = to[cur][text[pos] - 'a'];
}
int main() {
scanf("%s%s", str[0], str[1]);
n = strlen(str[0]);
int i, j, s, p, q;
for (i = 0; i < n; i++) {
text[2 * i] = str[0][i];
text[2 * i + 1] = str[1][i];
}
n *= 2;
for (i = n - 1; i >= 0; i--) text[i + 1] = text[i];
init();
for (i = 1; i <= n; i++) {
add_letter(i);
ans[i] = inf;
for (j = last; len[j] > 0; j = nxt[j]) {
save[j] = ans[i - len[nxt[j]] - dl[j]] + 1;
path[j] = i - len[nxt[j]] - dl[j];
if (dl[j] == dl[fail[j]]) {
if (save[j] > save[fail[j]]) {
save[j] = save[fail[j]];
path[j] = path[fail[j]];
}
}
if (!(i & 1)) {
if (ans[i] > save[j]) {
ans[i] = save[j];
pa[i] = path[j];
}
}
}
if (!(i & 1) && text[i] == text[i - 1]) {
if (ans[i] > ans[i - 2]) {
ans[i] = ans[i - 2];
pa[i] = i - 2;
}
}
}
if (ans[n] == inf)
puts("-1");
else {
printf("%d\n", ans[n]);
int id = n;
while (id > 0) {
if (pa[id] + 2 != id) printf("%d %d\n", pa[id] / 2 + 1, id / 2);
id = pa[id];
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, nn;
int t[50][50];
int s[50][50];
int main() {
cin >> n;
nn = (n + 1) / 2;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> t[i][j];
int sol = -1e9;
for (int c = 0; c < (1 << nn); c++) {
int sol2 = 0;
for (int i = 1; i <= nn; i++)
if ((c >> (i - 1)) & 1)
s[i][nn] = 1;
else
s[i][nn] = -1;
for (int i = 1; i <= nn; i++) sol2 += s[i][nn] * t[i][nn];
for (int i = 1; i < nn; i++) {
s[i + nn][nn] = s[i][nn] * s[nn][nn];
sol2 += s[i + nn][nn] * t[i + nn][nn];
}
for (int j = 1; j < nn; j++) {
int sol3 = -1e9;
for (s[nn][j] = -1; s[nn][j] <= 1; s[nn][j] += 2) {
s[nn][j + nn] = s[nn][j] * s[nn][nn];
int sol4 = s[nn][j] * t[nn][j] + s[nn][j + nn] * t[nn][j + nn];
for (int i = 1; i < nn; i++) {
int sol5 = -1e9;
for (s[i][j] = -1; s[i][j] <= 1; s[i][j] += 2) {
s[i][j + nn] = s[i][j] * s[i][nn];
s[i + nn][j] = s[i][j] * s[nn][j];
s[i + nn][j + nn] = s[i + nn][j] * s[i + nn][nn];
sol5 = max(sol5, s[i][j] * t[i][j] + s[i + nn][j] * t[i + nn][j] +
s[i][j + nn] * t[i][j + nn] +
s[i + nn][j + nn] * t[i + nn][j + nn]);
}
sol4 += sol5;
}
sol3 = max(sol3, sol4);
}
sol2 += sol3;
}
sol = max(sol, sol2);
}
cout << sol << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int half1 = (n - 1) / 2, x, d;
long double sum = 0.0;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &d);
sum += (long long)x * (long long)n;
if (d > 0) {
sum += (long long)(n - 1) * n / 2 * (long long)d;
} else {
sum += ((long long)(n - half1 - 1) * (n - half1) / 2 +
(long long)half1 * (half1 + 1) / 2) *
(long long)d;
}
}
sum = sum / n;
cout << fixed << setprecision(15) << sum << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
const int M = 200001;
int n, m;
int a[N];
pair<long long, int> b[M];
long long ans[N];
long long res[M];
multiset<int> st;
int solve(long long q) {
st.clear();
int res = 0;
for (int i = 0; i < n; ++i) {
if (a[i] < 0) st.insert(a[i]);
q += a[i];
while (q < 0) {
q -= *st.begin();
st.erase(st.begin());
res++;
}
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; ++i) {
scanf("%I64d", &b[i].first);
b[i].second = i;
}
b[0].first = 0;
b[m + 1].first = 1e18;
sort(b + 1, b + m + 1);
for (int i = 0; i <= n; ++i) {
int l = -1, r = m + 2;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (solve(b[mid].first) <= i) {
r = mid;
} else {
l = mid;
}
}
ans[i] = b[r].first;
}
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
if (ans[j] <= b[i].first) {
res[b[i].second] = j;
break;
}
}
}
for (int i = 1; i <= m; ++i) printf("%d ", res[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int data[26][800005];
int lazy[26][800005];
void updateValue(int low, int high, int idx, int index, int val, int alph) {
if (low == high) {
data[alph][index] = val;
return;
}
int mid = (high + low) / 2;
if (idx <= mid) {
updateValue(low, mid, idx, 2 * index + 1, val, alph);
} else
updateValue(mid + 1, high, idx, 2 * index + 2, val, alph);
data[alph][index] = data[alph][2 * index + 1] + data[alph][2 * index + 2];
}
void updateRange(int l, int r, int low, int high, int index, int diff,
int alph) {
if (l > r) return;
if (lazy[alph][index] != -1) {
data[alph][index] = (high - low + 1) * lazy[alph][index];
if (low != high) {
lazy[alph][2 * index + 1] = lazy[alph][index];
lazy[alph][2 * index + 2] = lazy[alph][index];
}
lazy[alph][index] = -1;
}
if (high < l or low > r) return;
if (low >= l and high <= r) {
data[alph][index] = (high - low + 1) * diff;
if (low != high) {
lazy[alph][2 * index + 1] = diff;
lazy[alph][2 * index + 2] = diff;
}
return;
}
int mid = (low + high) / 2;
updateRange(l, r, low, mid, 2 * index + 1, diff, alph);
updateRange(l, r, mid + 1, high, 2 * index + 2, diff, alph);
data[alph][index] = data[alph][2 * index + 1] + data[alph][2 * index + 2];
}
int getQuery(int l, int r, int low, int high, int index, int alph) {
if (lazy[alph][index] != -1) {
data[alph][index] = (high - low + 1) * lazy[alph][index];
if (low != high) {
lazy[alph][2 * index + 1] = lazy[alph][index];
lazy[alph][2 * index + 2] = lazy[alph][index];
}
lazy[alph][index] = -1;
}
if (high < l or low > r) {
return 0;
}
if (low >= l and high <= r) {
return data[alph][index];
}
int mid = (low + high) / 2;
return getQuery(l, r, low, mid, 2 * index + 1, alph) +
getQuery(l, r, mid + 1, high, 2 * index + 2, alph);
}
int main() {
ios::sync_with_stdio(false);
for (int(i) = 0; (i) < (26); (i)++) {
for (int(j) = 0; (j) < (800005); (j)++) {
data[i][j] = 0;
lazy[i][j] = -1;
}
}
int n, m;
cin >> n >> m;
string s;
cin >> s;
for (int(i) = 0; (i) < (n); (i)++) {
updateValue(0, n - 1, i, 0, 1, s[i] - 'a');
}
while (m--) {
int temp1, temp2, c;
cin >> temp1 >> temp2 >> c;
int calc[26];
for (int(i) = 0; (i) < (26); (i)++) {
calc[i] = getQuery(temp1 - 1, temp2 - 1, 0, n - 1, 0, i);
}
if (c == 1) {
int st = temp1 - 1;
int en = st + calc[0] - 1;
for (int(i) = 0; (i) < (26); (i)++) {
updateRange(st, en, 0, n - 1, 0, 1, i);
updateRange(temp1 - 1, st - 1, 0, n - 1, 0, 0, i);
updateRange(en + 1, temp2 - 1, 0, n - 1, 0, 0, i);
if (i != 25) {
st = en + 1;
en = st + calc[i + 1] - 1;
}
}
} else {
int st = temp1 - 1;
int en = st + calc[25] - 1;
for (int i = 25; i >= 0; i--) {
updateRange(st, en, 0, n - 1, 0, 1, i);
updateRange(temp1 - 1, st - 1, 0, n - 1, 0, 0, i);
updateRange(en + 1, temp2 - 1, 0, n - 1, 0, 0, i);
if (i != 0) {
st = en + 1;
en = st + calc[i - 1] - 1;
}
}
}
}
for (int(i) = 0; (i) < (n); (i)++) {
for (int(j) = 0; (j) < (26); (j)++) {
if (getQuery(i, i, 0, n - 1, 0, j) == 1) {
char ch = 'a' + j;
cout << ch;
break;
}
}
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, mark[100005];
int dfs(int i) {
mark[i] = 1;
if (i) {
int x, y;
x = i / 2;
y = (i + n) / 2;
if (mark[y])
dfs(x);
else
dfs(y);
}
cout << i << " ";
}
int main() {
cin >> n;
if (n & 1)
cout << -1;
else {
dfs(n / 2);
cout << 0;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 13;
const long long INF64 = 1e18;
int n, m;
long long a[N];
vector<pair<int, long long>> g[N];
long long dist[N];
void Dijkstra() {
set<pair<long long, int>> q;
for (int i = 0; i < int(n); i++) {
dist[i] = a[i];
q.insert({dist[i], i});
}
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (auto it : g[v]) {
int u = it.first;
long long w = it.second;
if (dist[u] > dist[v] + w) {
q.erase({dist[u], u});
dist[u] = dist[v] + w;
q.insert({dist[u], u});
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int _ = 0; _ < int(m); _++) {
int f, t;
long long w;
scanf("%d%d%lld", &f, &t, &w);
--f, --t;
w *= 2;
g[f].push_back({t, w});
g[t].push_back({f, w});
}
for (int i = 0; i < int(n); i++) {
scanf("%lld", &a[i]);
}
Dijkstra();
for (int i = 0; i < int(n); i++) printf("%lld ", dist[i]);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace ::std;
int main() {
int t, n, a, b;
cin >> t;
for (int i1 = 0; i1 < t; i1++) {
cin >> n;
for (int i = 0; i < n; i++) {
b = a;
cin >> a;
if (i % 2 != 0) {
cout << a << " ";
cout << b * -1 << " ";
}
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int t, cont = 0, i, j;
long int L, v, l, r, k;
cin >> t;
for (i = 0; i < t; i++) {
cin >> L >> v >> l >> r;
cout << L / v - (r / v - (l - 1) / v) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1);
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
int n, m, k;
int A[N];
char str[N];
signed main() {
int T = 1;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
int mn = 1e6;
for (int i = 1; i <= n; i++) scanf("%d", &A[i]), mn = min(mn, A[i]);
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (cnt == n / 2) break;
if (A[i] == mn) continue;
printf("%d %d\n", A[i], mn);
cnt++;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 1e9 + 1;
const double eps = 1e-15;
const double EPS = 1e-9;
const double PI = acos(-1.0);
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
if (n == 1) {
if (s[0] != '0' && k) {
cout << 0;
} else
cout << s;
return 0;
}
if (s[0] != '1' && k) {
s[0] = '1';
k--;
}
for (int i = 1; i < n && k; i++) {
if (s[i] != '0') {
s[i] = '0';
k--;
}
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a, b;
cin >> a >> b;
int n;
cin >> n;
int x = n / 4, y = n % 4;
if (n % 4 == 2 || n % 4 == 0) {
cout << "undefined" << endl;
return 0;
} else if (y == 1) {
if (a == '^' && b == '>')
cout << "cw" << endl;
else if (a == '>' && b == 'v')
cout << "cw" << endl;
else if (a == 'v' && b == '<')
cout << "cw" << endl;
else if (a == '<' && b == '^')
cout << "cw" << endl;
else if (a == '^' && b == '<')
cout << "ccw" << endl;
else if (a == '>' && b == '^')
cout << "ccw" << endl;
else if (a == 'v' && b == '>')
cout << "ccw" << endl;
else if (a == '<' && b == 'v')
cout << "ccw" << endl;
} else if (y == 3) {
if (a == '^' && b == '>')
cout << "ccw" << endl;
else if (a == '>' && b == 'v')
cout << "ccw" << endl;
else if (a == 'v' && b == '<')
cout << "ccw" << endl;
else if (a == '<' && b == '^')
cout << "ccw" << endl;
else if (a == '^' && b == '<')
cout << "cw" << endl;
else if (a == '>' && b == '^')
cout << "cw" << endl;
else if (a == 'v' && b == '>')
cout << "cw" << endl;
else if (a == '<' && b == 'v')
cout << "cw" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r;
cin >> n >> l >> r;
long long int x = pow(2, l - 1);
long long int ans1 = n - log2(x * 2) + (pow(2, log2(x * 2)) - 1);
long long int y = pow(2, r - 1);
long long int ans2 = (y * (n - log2(y * 2))) + (pow(2, log2(y * 2)) - 1);
cout << ans1 << " " << ans2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct pair_hash {
template <typename T1, typename T2>
size_t operator()(const pair<T1, T2> &p) const {
auto h1 = hash<T1>{}(p.first);
auto h2 = hash<T2>{}(p.second);
return h1 ^ h2;
}
};
const long long INFLL = 2 * (long long)1e18 + 100;
const int INFINT = 2 * (int)1e9 + 100;
void die() {
cout << "NO";
exit(0);
}
const int NMAX = 1e5 + 5;
const int MOD = 1e9 + 7;
const double PI = atan(1) * 4;
const double EPS = 1e-12;
string s, t, st;
int z[2 * NMAX];
bool good[NMAX];
void calc_z() {
int l = 0, r = 0;
for (int i = 1; i < st.size(); i++) {
if (i > r) {
l = r = i;
while (r < st.size() && st[r - l] == st[r]) r++;
z[i] = r - l;
r--;
} else {
if (z[i - l] <= r - i)
z[i] = z[i - l];
else {
l = i;
while (r < st.size() && st[r - l] == st[r]) r++;
z[i] = r - l;
r--;
}
}
}
}
long long a[NMAX], q1[NMAX], q2[NMAX], sol;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s >> t;
st = t + "$" + s;
calc_z();
for (int i = 1; i < st.size(); i++)
if (z[i] == t.size()) good[i - 1] = 1;
for (int i = 1; i <= s.size(); i++) {
if (good[i])
a[i] = (q2[i - t.size()] + i - t.size() + 1 + MOD) % MOD;
else
a[i] = a[i - 1];
q1[i] = (q1[i - 1] + a[i]) % MOD;
q2[i] = (q2[i - 1] + q1[i]) % MOD;
sol += a[i];
sol %= MOD;
}
cout << sol;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int p[101];
int w[101];
int find(int n) {
if (p[n] == -1) return -1;
if (n == p[n]) return n;
return p[n] = find(p[n]);
}
bool unionn(int a, int b) {
int p1 = find(a);
int p2 = find(b);
if (p1 == p2) return false;
if (w[p1] > w[p2]) {
p[p2] = p1;
w[p1] += w[p2];
} else {
p[p1] = p2;
w[p2] += w[p1];
}
return true;
}
int main() {
int m, n, cnt;
scanf("%d%d", &m, &n);
for (int c = 0; c < m; c++) {
p[c] = c;
w[c] = 1;
}
bool lang[m][n];
for (int c = 0; c < m; c++) {
for (int d = 0; d < n; d++) lang[c][d] = false;
}
for (int c = 0; c < m; c++) {
scanf("%d", &cnt);
if (cnt == 0) p[c] = -1;
int hmm;
for (int d = 0; d < cnt; d++) {
scanf("%d", &hmm);
lang[c][hmm - 1] = true;
}
}
for (int c = 0; c < m; c++) {
for (int d = 0; d < c; d++) {
for (int e = 0; e < n; e++) {
if (lang[c][e] && lang[d][e]) {
unionn(c, d);
break;
}
}
}
}
int grp = 0;
int idiots = 0;
for (int c = 0; c < m; c++) {
if (p[c] == -1)
idiots++;
else if (p[c] == c)
grp++;
}
if (idiots == m)
printf("%d\n", idiots);
else
printf("%d\n", idiots + grp - 1);
}
| 3 |
#include<iostream>
#include<string.h>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const int MAXN = 1000 + 10;
ll C_arr[MAXN + 10][MAXN + 10];
void C_init(int n, int pr) {
for (int i = 0; i <= n; i++) {
C_arr[i][0] = C_arr[i][i] = 1;
for (int j = 1; j < i; j++)
C_arr[i][j] = (C_arr[i - 1][j - 1] + C_arr[i - 1][j]) % pr;
}
}
ll C(int n, int m) {
return C_arr[n][m];
}
bool cmp(const int& a, const int& b) {
return a > b;
}
int main() {
int t, n, k;
int a[MAXN];
C_init(MAXN, MOD);
cin >> t;
while (t--) {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, cmp);
int cnt1 = 1, cnt2 = 0;
for (int i = k; i < n && a[i] == a[i - 1]; i++) cnt2++;
for (int i = k - 2; i >= 0 && a[i] == a[i + 1]; i--) cnt1++;
int m = cnt1 + cnt2;
int n = cnt1;
cout << C(m, n) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, n1, n2;
cin >> n >> n1 >> n2;
vector<int> a(n);
for (int(i) = 0; (i) < (n); ++(i)) cin >> a[i];
sort(a.begin(), a.end());
if (n1 > n2) swap(n1, n2);
long double s1 = 0, s2 = 0;
for (int i = 0; i < n1; ++i) s1 += a[n - i - 1];
for (int i = 0; i < n2; ++i) s2 += a[n - i - 1 - n1];
cout << fixed << setprecision(6)
<< (s1 / ((long double)n1) + s2 / ((long double)n2));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4000010, mod = 1e9 + 7, INF = 0x3f3f3f3f;
const double eps = 1e-6;
int n;
int p[N], te[N];
long long ztot, zcnt, ftot, fcnt;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
if (p[i] - i > 0) {
zcnt++;
ztot += p[i] - i;
te[p[i] - i]++;
} else {
fcnt++;
ftot += (i - p[i]);
}
}
long long ans = ftot + ztot, id = 0;
for (int i = 1; i < n; i++) {
ztot -= zcnt;
zcnt -= te[i];
ftot += fcnt;
fcnt += te[i];
int x = p[n - i + 1];
ftot -= n + 1 - x;
fcnt--;
if (x > 1)
te[x - 1 + i]++, ztot += x - 1, zcnt++;
else
fcnt++;
if (ans > ztot + ftot) ans = ztot + ftot, id = i;
}
printf("%lld %lld\n", ans, id);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
char s[155];
int a[155];
int best[155][155], pal[155][155][155];
int main() {
int n;
gn(n);
for (int i = 1; i <= n; i++) {
gn(a[i]);
if (a[i] == -1) a[i] = -0x3f3f3f3f;
}
scanf("%s", s + 1);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
for (int k = 0; k <= n; k++) pal[i][j][k] = -0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
pal[i][i][1] = 0;
pal[i][i][0] = a[1];
smax(best[i][i], a[1]);
}
for (int L = 2; L <= n; L++) {
for (int i = 1; i <= n; i++) {
int j = i + L - 1;
if (j > n) break;
for (int k = 1; k <= L; k++) {
if (s[i] == s[j] && k > 1) smax(pal[i][j][k], pal[i + 1][j - 1][k - 2]);
for (int m = i + k - 1; m < j; m++)
smax(pal[i][j][k], pal[i][m][k] + pal[m + 1][j][0]);
for (int m = i; m <= j - k; m++)
smax(pal[i][j][k], pal[i][m][0] + pal[m + 1][j][k]);
smax(pal[i][j][0], pal[i][j][k] + a[k]);
}
smax(best[i][j], pal[i][j][0]);
for (int m = i; m < j; m++) smax(best[i][j], best[i][m] + best[m + 1][j]);
}
}
printf("%d\n", best[1][n]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
set<pair<string, string> > st;
set<pair<string, string> >::iterator it;
set<string> st2;
set<string>::iterator it2;
string s2;
int j;
void Rec(int i, string s) {
if (i > s2.size()) return;
if (s.size() == j) {
it2 = st2.find(s);
if (it2 == st2.end()) {
st2.insert(s);
mp[s]++;
}
st.insert(make_pair(s, s2));
i -= s.size() - 1;
s = "";
}
Rec(i + 1, s + s2[i]);
}
int main() {
int n, q;
cin >> n;
while (n--) {
cin >> s2;
for (j = 1; j <= s2.size(); j++) Rec(0, "");
st2.clear();
}
cin >> q;
while (q--) {
cin >> s2;
cout << mp[s2] << " ";
if (mp[s2] == 0)
cout << "-" << endl;
else {
it = st.lower_bound(make_pair(s2, ""));
cout << it->second << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
int memo[1005];
int solve(int ridesLeft) {
if (ridesLeft <= 0) return 0;
if (memo[ridesLeft] != -1) return memo[ridesLeft];
return memo[ridesLeft] =
std::min(solve(ridesLeft - 1) + a, solve(ridesLeft - m) + b);
}
int main() {
cin >> n >> m >> a >> b;
memset(memo, -1, sizeof memo);
int ans = solve(n);
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
cin >> n;
for (int i = 0; i < 32; i++) count += ((n >> i) & 1) ? 1 : 0;
cout << count;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, bil, cons, ans;
vector<int> temp;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> bil;
if (bil > 0) temp.push_back(bil);
}
temp.push_back(1000000000 + 10);
sort(temp.begin(), temp.end());
cons = 1;
ans = 0;
for (int i = 1; i < temp.size(); i++) {
if (temp[i] == temp[i - 1])
cons++;
else {
if (cons > 2) {
cout << "-1\n";
return 0;
}
if (cons == 2) ans++;
cons = 1;
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
map<int, int> aMap;
map<int, int> bMap;
for (int i = 0; i < n; i++) {
int ai, bi;
cin >> ai >> bi;
bMap.insert(make_pair(ai, bi));
aMap.insert(make_pair(bi, ai));
}
vector<int> seq(n);
int index = 1;
int A = 0;
while (index < n) {
seq[index] = bMap[A];
A = bMap[A];
index += 2;
}
map<int, int>::iterator it;
for (it = bMap.begin(); it != bMap.end(); it++) {
if (aMap.find(it->first) == aMap.end()) break;
}
(seq[0] = it->first, index = 2, A = seq[0]);
while (index < n) {
seq[index] = bMap[A];
A = bMap[A];
index += 2;
}
for (int i = 0; i < n; i++) cout << seq[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxN = (int)3e5 + 100;
const int MOD = (int)100000000;
const unsigned int Modu = 1000000007;
using namespace std;
const int N = 6e5 + 100;
int dp[222222][26];
vector<int> v[222222];
pair<int, int> p[N];
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
set<long long> st;
void dfs(string s) {
if (s.length() > 10) {
return;
}
long long num = stoll(s);
st.insert(num);
dfs(s + "4");
dfs(s + "7");
}
int solve() {
int n;
cin >> n;
int pref[7] = {0};
for (int i = 0; i < (n); ++i) {
int x;
cin >> x;
pref[x - 1]++;
}
n /= 3;
if (pref[0] != n || pref[4] > 0 || pref[6] > 0 || pref[2] > pref[5] ||
(pref[1] + pref[2]) != (pref[3] + pref[5])) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < (pref[2]); ++i) {
cout << "1 3 6" << endl;
}
pref[5] -= pref[2];
for (int i = 0; i < (pref[3]); ++i) {
cout << "1 2 4" << endl;
}
for (int i = 0; i < (pref[5]); ++i) {
cout << "1 2 6" << endl;
}
return 0;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int q;
cin >> q;
while (q--) {
long long int i, j, k = 1, k1, n, m, x, y, c = 1, r, t, l2 = 0, r2, p = 0;
cin >> n;
long long int a[2 * n];
m = 2 * n;
for (i = 0; i < m; i++) cin >> a[i];
vector<long long int> v;
i = 0;
while (i < m) {
p = a[i];
j = i + 1;
c = 1;
while (j < m && a[j] < p) {
j++;
c++;
}
i = j;
v.push_back(c);
}
sort(v.begin(), v.end());
x = v.size();
long long int d[x + 1][n + 1];
for (i = 0; i <= n; i++) d[0][i] = 0;
for (i = 0; i <= x; i++) d[i][0] = 0;
for (i = 1; i <= x; i++) {
for (j = 1; j <= n; j++) {
if (j < v[i - 1])
d[i][j] = d[i - 1][j];
else if (j == v[i - 1])
d[i][j] = 1;
else
d[i][j] = max(d[i - 1][j - v[i - 1]], d[i - 1][j]);
}
}
if (d[x][n] == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e3 + 5;
const int INF = 0x3f3f3f3f;
long long n;
long long f(long long x) { return n / x; }
int main() {
scanf("%I64d", &n);
long long ans = n - f(2) - f(3) - f(5) - f(7) + f(6) + f(10) + f(14) + f(15) +
f(21) + f(35) - f(105) - f(70) - f(42) - f(30) + f(210);
printf("%I64d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const double eps = 1e-10;
const double pi = acos(-1.0);
inline int read() {
int x = 0, f = 1;
char ch;
ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch & 15);
ch = getchar();
}
if (f)
return x;
else
return -x;
}
char s[110];
int n, ty, ls, len, top = 0;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
ty = (n + 19) / 20;
ls = n % ty;
if (ls == 0) ls = ty;
len = (n + ty - 1) / ty;
printf("%d %d\n", ty, len);
for (int i = ls; i >= 1; i--) {
for (int j = len; j >= 1; j--) printf("%c", s[++top]);
printf("\n");
}
for (int i = ls + 1; i <= ty; i++) {
for (int j = len; j >= 2; j--) printf("%c", s[++top]);
printf("*\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans[500005], n, a, b, c, d;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a % 2 && b % 2)
ans[i] = 1;
else if (a % 2)
ans[i] = 2;
else if (b % 2)
ans[i] = 3;
else
ans[i] = 4;
}
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d\n", ans[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
string s;
vector<pair<int, int> > a;
cin >> t;
for (int n = 0; n < t; n++) {
a.clear();
for (int i = 0; i < 8; i++) {
cin >> s;
for (int j = 0; j < 8; j++) {
if (s[j] == 'K') a.push_back(pair<int, int>(i, j));
}
}
if ((a[1].first - a[0].first) % 4 == 0 &&
(a[1].second - a[0].second) % 4 == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[10000], b[10000], c[10000];
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i] >> c[i];
}
int sum = (a[1] + a[2] + b[0] + b[2] + c[0] + c[1]) / 2;
a[0] = sum - a[1] - a[2];
b[1] = sum - b[0] - b[2];
c[2] = sum - c[0] - c[1];
for (int i = 0; i < 3; i++) {
cout << a[i] << " " << b[i] << " " << c[i] << " " << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long modulo(long long base, long long exp, long long m);
long long powerr(long long base, long long exp, long long m);
long long inverse(long long a, long long m);
void display(long long i) { cout << "Case #" << i << ": "; }
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, h;
cin >> n >> m >> h;
vector<long long> f(m);
vector<long long> l(n);
vector<vector<long long> > top(n, vector<long long>(m));
for (long long i = 0; i < m; i++) cin >> f[i];
for (long long i = 0; i < n; i++) cin >> l[i];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> top[i][j];
}
for (long long k = 0; k < m; k++) {
for (long long i = 0; i < n; i++) {
if (top[i][k] == 1) top[i][k] = f[k];
}
}
for (long long k = 0; k < n; k++) {
for (long long i = 0; i < m; i++) {
if (top[k][i] != 0 && top[k][i] > l[k]) top[k][i] = l[k];
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cout << top[i][j] << " ";
cout << endl;
}
return 0;
}
long long modulo(long long base, long long exp, long long m) {
long long answer = 1;
while (exp > 0) {
if (exp % 2 == 1) answer = (answer * base) % m;
exp = exp / 2;
base = (base * base) % m;
}
return answer;
}
long long powerr(long long base, long long exp, long long m) {
base = base % m;
if (exp == 0)
return 1;
else {
if (exp % 2 == 0) {
long long x = powerr(base, exp / 2, m);
return (x * x) % m;
} else {
long long x = powerr(base, (exp - 1) / 2, m);
return (base * ((x * x) % m)) % m;
}
}
}
void EE(long long a, long long b, long long &co1, long long &co2) {
if (a % b == 0) {
co1 = 0;
co2 = 1;
return;
}
EE(b, a % b, co1, co2);
long long temp = co1;
co1 = co2;
co2 = temp - co2 * (a / b);
}
long long inverse(long long a, long long m) {
long long x, y;
EE(a, m, x, y);
if (x < 0) x += m;
return x;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i;
cin >> t;
while (t--) {
int n, m;
string s;
cin >> n >> s;
m = n;
for (i = 0; i < n; i++) {
if (s[i] == '1') {
m = max(m, 2 * max(i + 1, n - i));
}
}
cout << m << endl;
}
}
| 1 |
#include <bits/stdc++.h>
long long min(long long a, long long b) { return a < b ? a : b; }
int oo[1 + ((5000 * 3) - 1) * 2], oj[1 + ((5000 * 3) - 1) * 2];
int link(int o, int j) {
static int _ = 1;
oo[_] = o, oj[_] = j;
return _++;
}
int count(int n, int p) { return n < p ? 0 : n / p + count(n / p, p); }
int ae[(5000 * 3)], pp[(5000 * 3)], dd[(5000 * 3)], sz[(5000 * 3)],
ii[5000 + 1], n;
void init() {
static char composite[5000 + 1];
static int primes[5000 + 1];
int n_, a, b, cnt, i, j;
for (a = 2; a <= 5000 / a; a++) {
if (composite[a]) continue;
for (b = a * a; b <= 5000; b += a) composite[b] = 1;
}
cnt = 0;
for (a = 2; a <= 5000; a++)
if (!composite[a]) primes[cnt++] = a;
n_ = 0;
pp[n_] = -1, dd[n_] = 0;
ii[1] = n_++;
for (a = 2; a <= 5000; a++) {
int h, d, d_;
d = 0;
for (h = 0; h < cnt; h++) d += count(a, primes[h]);
d_ = 0;
for (h = cnt - 1; h >= 0; h--) {
d_ += count(a - 1, primes[h]);
if (a % primes[h] == 0) break;
}
i = ii[a - 1], j = -1;
while (1)
if (dd[i] > d_)
j = i, i = pp[i];
else if (dd[i] == d_) {
pp[n_] = i, dd[n_] = d, n_++;
ii[a] = n_ - 1;
break;
} else {
int k = n_++;
pp[k] = i, dd[k] = d_;
if (j != -1) pp[j] = k;
pp[n_] = k, dd[n_] = d, n_++;
ii[a] = n_ - 1;
break;
}
}
for (j = 1; j < n_; j++) {
i = pp[j];
ae[i] = link(ae[i], j), ae[j] = link(ae[j], i);
}
}
long long dfs1(int p, int i) {
int o;
long long x;
x = (long long)sz[i] * dd[i];
for (o = ae[i]; o; o = oo[o]) {
int j = oj[o];
if (j != p) {
x += dfs1(i, j);
sz[i] += sz[j];
}
}
return x;
}
long long ans;
void dfs2(int p, int i, long long x) {
int o;
ans = min(ans, x);
for (o = ae[i]; o; o = oo[o]) {
int j = oj[o];
if (j != p) {
int w = abs(dd[i] - dd[j]);
dfs2(i, j, x - (long long)sz[j] * w + (long long)(n - sz[j]) * w);
}
}
}
int main() {
int i;
init();
scanf("%d", &n);
for (i = 0; i < n; i++) {
int a;
scanf("%d", &a);
sz[ii[a > 0 ? a : 1]]++;
}
ans = 0x3f3f3f3f3f3f3f3fLL;
dfs2(-1, 0, dfs1(-1, 0));
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, m, x, y, c, z, r, p, R, v, i;
string s;
while (cin >> s) {
c = 0;
n = 0;
m = 0;
for (i = 0; i < s.size(); i++) {
c = c + (s[i] - 48);
}
if (s.size() == 1 || c < 1)
n = 0;
else
n = 1;
while (c >= 10) {
a = c;
n++;
m = 0;
while (a != 0) {
m = m + (a % 10);
a = a / 10;
}
c = m;
}
cout << n << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using ulli = unsigned long long int;
using ld = long double;
template <class T>
using heap = priority_queue<T, vector<T>, greater<T>>;
template <class A, class B>
using hmap = unordered_map<A, B>;
template <class T>
using hset = unordered_set<T>;
template <class T>
struct Matrix : public vector<vector<T>> {
Matrix(int dim1 = 0, int dim2 = 0, T v = T())
: vector<vector<T>>(dim1, vector<T>(dim2, v)) {}
};
namespace std {
template <class T>
struct hash<vector<T>> {
size_t operator()(vector<T> const& v) const {
size_t c = v.size();
for (auto& e : v) {
c ^= (size_t)e + 0x9e3779b9 + (c << 6) + (c >> 2);
}
return c;
}
};
} // namespace std
const int INF = 1e9;
const lli LLINF = 4 * 1e18;
const lli MOD = 1e9 + 7;
const ld PI = 3.141592653589793;
template <typename T>
inline T sqr(T val) {
return val * val;
}
template <class T>
inline void minset(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void maxset(T& a, T b) {
if (a < b) a = b;
}
template <typename T>
T modul(T val, T __modulo = MOD) {
return (val % __modulo + __modulo) % __modulo;
}
template <class V>
typename V::value_type sum(const V& els) {
auto s = 0;
for (const auto& e : els) {
s += e;
};
return s;
}
template <class V>
typename V::value_type min(const V& els) {
return *min_element(els.begin(), els.end());
}
template <class V>
typename V::value_type max(const V& els) {
return *max_element(els.begin(), els.end());
}
struct __RM_UNUSED {
__RM_UNUSED() {
(void)INF;
(void)LLINF;
(void)PI;
}
};
string tostr(char c) { return string(1, c); }
template <typename T>
string tostr(T c) {
return to_string(c);
}
int toint(char c) { return c - '0'; }
int toint(string s, int base = 10) { return stoi(s, 0, base); }
template <class T>
inline T ri() {
T v;
cin >> v;
return v;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (T& e : v) {
is >> e;
}
return is;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cout << fixed << setprecision(10);
int nbTrains, nbHours, nbMinutes, k;
cin >> nbTrains >> nbHours >> nbMinutes >> k;
nbMinutes /= 2;
vector<int> trains;
vector<int> real_trains;
for (int iTrain = 0; iTrain < nbTrains; iTrain++) {
int h, t;
cin >> h >> t;
if (t > nbMinutes) {
t -= nbMinutes;
}
real_trains.push_back(t);
trains.push_back(t);
trains.push_back(t + nbMinutes);
}
sort(trains.begin(), trains.end());
int optAt = 0, minCancel = nbTrains;
deque<int> cancel;
for (int iTrain = 0; iTrain < (int)trains.size(); iTrain++) {
while (!cancel.empty() && cancel.front() <= trains[iTrain] - k) {
cancel.pop_front();
}
if ((int)cancel.size() < minCancel && trains[iTrain] >= k) {
minCancel = cancel.size();
optAt = trains[iTrain];
}
cancel.push_back(trains[iTrain]);
}
cout << minCancel << " " << (optAt % nbMinutes) << "\n";
for (int iTrain = 0; iTrain < nbTrains; iTrain++) {
if ((real_trains[iTrain] > optAt - k && real_trains[iTrain] < optAt) ||
(real_trains[iTrain] + nbMinutes > optAt - k &&
real_trains[iTrain] + nbMinutes < optAt)) {
cout << (iTrain + 1) << " ";
}
}
}
| 7 |
#include <bits/stdc++.h>
const int MAXN = 33;
const int MAXV = 909;
int n, m;
int arr[2][MAXN][MAXN];
bool solved() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (arr[0][i][j] != arr[1][i][j]) return false;
return true;
}
int x, y;
std::vector<std::pair<int, int>> as;
int flip_cnt = 0;
void flip() {
int siz = std::max(n, m);
for (int i = 0; i < 2; ++i)
for (int j = 1; j <= siz; ++j)
for (int k = j + 1; k <= siz; ++k) std::swap(arr[i][j][k], arr[i][k][j]);
std::swap(n, m);
std::swap(x, y);
flip_cnt += 1;
}
void write_as(int nx, int ny) {
if (flip_cnt & 1)
as.push_back({ny, nx});
else
as.push_back({nx, ny});
}
void STEP(int dx, int dy) {
int nx = x + dx, ny = y + dy;
std::swap(arr[0][x][y], arr[0][nx][ny]);
write_as(nx, ny);
x = nx, y = ny;
}
bool solve_line_left() {
int bak[MAXN];
for (int i = 1; i <= m; ++i) bak[i] = arr[0][1][i];
for (int i = 1; i < m; ++i) {
as.clear();
x = 1, y = i;
write_as(x, y);
for (int j = i + 1; j <= m; ++j) {
STEP(0, 1);
if (solved()) return true;
}
for (int j = 1; j <= m; ++j) arr[0][1][j] = bak[j];
}
return false;
}
bool solve_line() {
if (solve_line_left()) return true;
for (int k = 0; k < 2; ++k)
for (int i = 1, j = m; i < j; ++i, --j)
std::swap(arr[k][1][i], arr[k][1][j]);
if (not solve_line_left()) return false;
if (flip_cnt & 1)
for (auto &p : as) p.first = m + 1 - p.first;
else
for (auto &p : as) p.second = m + 1 - p.second;
return true;
}
void jizz() {
x = -1, y = -1;
for (int i = 1; x == -1 and i <= n; ++i)
for (int j = 1; y == -1 and j <= m; ++j)
if (arr[0][i][j] == arr[1][1][1]) x = i, y = j;
write_as(x, y);
while (n > 2 or m > 2) {
while (x < n) STEP(1, 0);
while (y < m) STEP(0, 1);
if (n < m) flip();
int tx = n;
for (int ty = m; ty >= 1; --ty) {
int fx = -1, fy = -1;
for (int i = 1; fx == -1 and i <= n; ++i)
for (int j = 1; fx == -1 and j <= m; ++j)
if (arr[0][i][j] == arr[1][tx][ty]) fx = i, fy = j;
int x_bfr = fx == 1 ? 1 : -1;
if (fy == ty) {
while (fx + 1 < x) STEP(-1, 0);
if (x_bfr == -1) {
STEP(-1, 0);
fx += 1;
}
} else {
int fix_dir = fy < ty ? 1 : -1;
while (fx < x) STEP(-1, 0);
while (fy != y) STEP(0, -fix_dir);
fy += fix_dir;
while (fy != ty) {
STEP(x_bfr, fix_dir);
STEP(-x_bfr, fix_dir);
STEP(0, -fix_dir);
fy += fix_dir;
}
STEP(x_bfr, fix_dir);
}
int y_bfr = fy == 1 ? 1 : -1;
while (fx != tx) {
if (x < fx) {
STEP(1, y_bfr);
STEP(1, -y_bfr);
}
STEP(-1, 0);
fx += 1;
}
if (ty != 1) STEP(1, -1);
}
n -= 1;
}
while (not solved()) {
int dx = x == 1 ? 1 : -1, dy = y == 1 ? 1 : -1;
int tmp = rand() % 3;
STEP(tmp == 1 ? 0 : dx, tmp == 2 ? 0 : dy);
}
}
int main() {
scanf("%d%d", &n, &m);
std::vector<int> cnt(MAXV);
for (int i = 0; i < 2; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= m; ++k) {
int t;
scanf("%d", &t);
arr[i][j][k] = t, cnt[t] += i ? 1 : -1;
}
}
}
bool ok = true;
for (int c : cnt) ok &= c == 0;
if (not ok) {
;
} else if (n == 1 or m == 1) {
if (m == 1) flip();
ok = solve_line();
} else {
jizz();
}
if (ok) {
printf("%u\n", as.size() - 1);
for (auto p : as) printf("%d %d\n", p.first, p.second);
} else {
puts("-1");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int p[200000 + 5], v[200000 + 5], Q, head[200000 + 5], cnt,
tot = 1, size[200000 + 5], mx[200000 + 5];
int son[200000 + 5], dep[200000 + 5], fa[200000 + 5], top[200000 + 5],
nl[200000 + 5], nr[200000 + 5], dn, inv[200000 + 5];
struct edge {
int to, next;
} e[200000 + 5];
inline void ins(int f, int t) {
e[++cnt] = (edge){t, head[f]};
head[f] = cnt;
}
void Pre(int x) {
size[x] = 1;
mx[x] = 0;
for (int i = head[x]; i; i = e[i].next) {
dep[e[i].to] = dep[x] + 1;
fa[e[i].to] = x;
Pre(e[i].to);
size[x] += size[e[i].to];
if (size[e[i].to] > size[mx[x]]) mx[x] = e[i].to;
}
}
void Dfs(int x, int tp) {
top[x] = tp;
nl[x] = ++dn;
if (mx[x]) Dfs(mx[x], tp);
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != mx[x]) Dfs(e[i].to, e[i].to);
nr[x] = dn;
}
bool flag = 0;
struct Seg {
struct Tree {
int l, r, x, val, tag;
} T[200000 * 4 + 5];
void Build(int x, int l, int r) {
if ((T[x].l = l) == (T[x].r = r)) {
T[x].x = flag;
return;
}
int mid = l + r >> 1;
Build(x << 1, l, mid);
Build(x << 1 | 1, mid + 1, r);
T[x].x = (T[x << 1].x + T[x << 1 | 1].x) % 1000000007;
}
inline void Mark(int x, int v) {
if (!T[x].tag) T[x].tag = T[x].val = 1;
T[x].val = 1LL * T[x].val * v % 1000000007;
T[x].x = 1LL * T[x].x * v % 1000000007;
}
inline void pushdown(int x) {
Mark(x << 1, T[x].val);
Mark(x << 1 | 1, T[x].val);
T[x].tag = 0;
}
void Modify(int x, int k, int v) {
if (T[x].l == T[x].r) {
T[x].x = v;
return;
}
int mid = T[x].l + T[x].r >> 1;
if (T[x].tag) pushdown(x);
Modify(x << 1 | (k > mid), k, v);
T[x].x = (T[x << 1].x + T[x << 1 | 1].x) % 1000000007;
}
void Modify(int x, int l, int r, int v) {
if (T[x].l == l && T[x].r == r) {
Mark(x, v);
return;
}
int mid = T[x].l + T[x].r >> 1;
if (T[x].tag) pushdown(x);
if (r <= mid)
Modify(x << 1, l, r, v);
else if (l > mid)
Modify(x << 1 | 1, l, r, v);
else
Modify(x << 1, l, mid, v), Modify(x << 1 | 1, mid + 1, r, v);
T[x].x = (T[x << 1].x + T[x << 1 | 1].x) % 1000000007;
}
int Query(int x, int l, int r) {
if (T[x].l == l && r == T[x].r) return T[x].x;
int mid = T[x].l + T[x].r >> 1;
if (T[x].tag) pushdown(x);
if (r <= mid)
return Query(x << 1, l, r);
else if (l > mid)
return Query(x << 1 | 1, l, r);
else
return (Query(x << 1, l, mid) + Query(x << 1 | 1, mid + 1, r)) %
1000000007;
}
} s, S;
int pow(int x, int k) {
int sum = 1;
for (; k; k >>= 1, x = 1LL * x * x % 1000000007)
if (k & 1) sum = 1LL * sum * x % 1000000007;
return sum;
}
int main() {
v[0] = read();
Q = read();
inv[0] = inv[1] = 1;
for (int i = 2; i <= 200000; ++i)
inv[i] =
1LL * (1000000007 - 1000000007 / i) * inv[1000000007 % i] % 1000000007;
for (int i = 1; i <= Q; ++i)
if (read() == 1)
p[i] = read(), v[i] = read(), ins(p[i], ++tot), p[i] = tot;
else
v[i] = read();
Pre(1);
Dfs(1, 1);
s.Build(1, 1, tot);
flag = 1;
S.Build(1, 1, tot);
s.Modify(son[1] = 1, 1, v[0]);
for (int i = 1; i <= Q; ++i)
if (!p[i]) {
int x = v[i] == 1 ? 1 : S.Query(1, nl[fa[v[i]]], nl[fa[v[i]]]);
printf("%d\n", 1LL * pow(x, 1000000007 - 2) *
s.Query(1, nl[v[i]], nr[v[i]]) % 1000000007);
} else {
int k = 1LL * inv[son[fa[p[i]]]] * (son[fa[p[i]]] + 1) % 1000000007;
++son[fa[p[i]]];
s.Modify(1, nl[fa[p[i]]], nr[fa[p[i]]], k);
S.Modify(1, nl[fa[p[i]]], nr[fa[p[i]]], k);
s.Modify(
1, nl[p[i]],
1LL * v[i] * S.Query(1, nl[fa[p[i]]], nl[fa[p[i]]]) % 1000000007);
son[p[i]] = 1;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 123, MAXN = 2e5 + 47, MEGAINF = 1e18;
template <class T>
inline istream& operator>>(istream& in, vector<T>& a) {
for (auto& i : a) in >> i;
return in;
}
template <class T>
inline ostream& operator<<(ostream& out, vector<T>& a) {
for (auto& i : a) out << i << " ";
return out;
}
template <class T, class U>
inline istream& operator>>(istream& in, vector<pair<T, U>>& a) {
for (auto& i : a) in >> i.first >> i.second;
return in;
}
template <class T, class U>
inline ostream& operator<<(ostream& out, vector<pair<T, U>>& a) {
for (auto& i : a) out << i.first << " " << i.second << endl;
return out;
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
signed main() {
setlocale(LC_ALL, "rus");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> cnt(26);
for (auto& i : s) ++cnt[i - 'a'];
long long res = 0;
for (long long len = 1; len <= n; ++len) {
long long x = len / gcd(len, k);
long long grab = 0;
for (long long u = 0; u < 26; ++u) grab += cnt[u] / x * x;
if (grab >= len) res = len;
}
cout << res << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
struct greaterr {
template <class T>
bool operator()(T const &a, T const &b) const {
return a > b;
}
};
int cnt[1000010] = {0};
int main() {
std::ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int l = 0;
int maxc = 0, maxdiff = 0, maxl = 0, maxr = 0;
for (int r = 0; r < n; r++) {
cnt[a[r]]++;
if (cnt[a[r]] == 1) maxc++;
while (maxc > k) {
cnt[a[l]]--;
if (cnt[a[l]] == 0) maxc--;
l++;
}
if (r - l >= maxdiff) {
maxdiff = r - l;
maxr = r;
maxl = l;
}
}
cout << maxl + 1 << " " << maxr + 1 << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100010];
vector<pair<int, int> > point[100010];
map<pair<int, int>, int> vis;
int n, v, k, depth[100010], pos[100010][2], tot;
char s[100010][23];
void Dfs(int k, int d) {
pos[k][0] = ++tot;
point[d].push_back(make_pair(tot, k));
depth[k] = d;
for (vector<int>::iterator p = adj[k].begin(); p != adj[k].end(); ++p) {
Dfs(*p, d + 1);
}
pos[k][1] = ++tot;
}
int solve() {
if (vis[make_pair(v, k)]) return vis[make_pair(v, k)] - 1;
vector<pair<int, int> >::iterator l, r;
set<string> str;
l = lower_bound(point[depth[v] + k].begin(), point[depth[v] + k].end(),
make_pair(pos[v][0], 100010));
r = lower_bound(point[depth[v] + k].begin(), point[depth[v] + k].end(),
make_pair(pos[v][1], 0));
for (vector<pair<int, int> >::iterator p = l; p != r; ++p) {
str.insert(s[(*p).second]);
}
return (vis[make_pair(v, k)] = str.size() + 1) - 1;
}
int main() {
int p, m, i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%s%d", &s[i], &p);
adj[p].push_back(i);
}
Dfs(0, 0);
scanf("%d", &m);
while (m--) {
scanf("%d%d", &v, &k);
printf("%d\n", solve());
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int p1 = arr[0];
int max1 = 0;
for (int i = 1; i < n; i++) {
if (arr[i] != p1) max1 = i;
}
int p2 = arr[n - 1];
int max2 = 0;
for (int i = n - 2; i >= 0; i--) {
if (arr[i] != p2) {
max2 = n - 1 - i;
}
}
cout << max(max1, max2) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
long long t, i;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long f = 0;
for (i = 0; i < (n - 1); i++) {
if (a[i + 1] - a[i] == 1) {
f = 1;
break;
}
}
if (f == 1)
cout << 2 << endl;
else
cout << 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
n = 2 * n - 2;
map<char, int> keys;
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
keys[s[i]]++;
} else {
if (keys[char(int(s[i]) + 32)] <= 0) {
cnt++;
} else
keys[char(int(s[i]) + 32)]--;
}
}
cout << cnt << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, ta, b, tb;
cin >> a >> ta >> b >> tb;
string q;
cin >> q;
int t = 0;
int s = q[0];
t += (s - 48) * 600;
s = q[1];
t += (s - 48) * 60;
s = q[3];
t += (s - 48) * 10;
s = q[4];
t += (s - 48);
int min = t - tb;
int max = t + ta;
int odp = 0;
s = 300;
while (s < 1440) {
if (min < s && s < max) {
odp++;
}
s += b;
}
cout << odp;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int A[MAXN];
int N;
double ans_d, x, y, z;
bool check(double d) {
ans_d = d;
int i = 0;
x = A[i] + d;
i = upper_bound(A, A + N, x + d) - A;
if (i == N) return true;
y = A[i] + d;
i = upper_bound(A, A + N, y + d) - A;
if (i == N) return true;
z = A[i] + d;
if (z + d >= A[N - 1]) return true;
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
sort(A, A + N);
double L = 0, R = 1e9 + 1;
while (R - L > 1e-7) {
double m = (L + R) / 2;
if (check(m)) {
R = m;
} else
L = m + 1e-7;
}
check(R);
printf("%.6lf\n", ans_d);
printf("%.6lf %.6lf %.6lf\n", x, y, z);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T input() {
T res;
cin >> res;
return res;
}
int main() {
std::iostream::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n = input<int>();
const int max_go = 49;
bool good[max_go + 1][max_go + 1];
for (int i = 0; i <= max_go; ++i)
for (int j = 0; j <= max_go; ++j) good[i][j] = 1;
for (int i = 0; i <= max_go; ++i)
for (int j = 0; j <= max_go; ++j)
for (int iprime = 0; iprime <= max_go; ++iprime)
for (int jprime = 0; jprime <= max_go; ++jprime)
if (4 * iprime + 9 * jprime < 4 * i + 9 * j and
(4 * i + 9 * j) % 49 == (4 * iprime + 9 * jprime) % 49)
good[i][j] = 0;
int64_t ans = 0;
for (int num4 = 0; num4 <= n and num4 <= max_go and num4 < 9; ++num4)
for (int num9 = 0; num9 + num4 <= n and num9 <= max_go; ++num9)
if (good[num4][num9]) ans += (n - num9 - num4 + 1);
cout << ans << "\n";
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
signed main(){
ios_base::sync_with_stdio(0) , cin.tie(0);
int $;cin>>$;
while($--){
int d,k;
cin>>d>>k;
int row=0,col=0;
int cnt=0;
while(row*row + col*col <= d*d){
cnt++;
if(row<col)row+=k;
else col+=k;
}
cnt--;
if(cnt%2==0){
cout<<"Utkarsh"<<endl;
}else cout<<"Ashish"<<endl;
}
return 0;
}
/*
stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do something instead of nothing
* Keep your ideas Organised
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
vector<int> v[N];
int num[N];
bool vis[N];
int len, n;
bool Doit() {
int i;
for (i = 1; i <= n; i++) {
if (v[i].size() != 4) return 0;
}
return 1;
}
bool DFS(int a, int fa, int th) {
if (th == n + 1) return 1;
if (!vis[a]) {
int j;
bool f1, f2;
vis[a] = 1;
num[th] = a;
vector<int>::iterator it, it1;
for (it = v[a].begin(); it != v[a].end(); it++) {
if (fa == -1) {
if (DFS((*it), a, th + 1)) return 1;
} else {
f1 = f2 = 0;
j = (*it);
if (j == fa) continue;
for (it1 = v[j].begin(); it1 != v[j].end(); it1++) {
if ((*it1) == a) f1 = 1;
if ((*it1) == fa) f2 = 1;
}
if (f1 && f2) {
if (DFS(j, a, th + 1)) return 1;
}
}
}
vis[a] = 0;
}
return 0;
}
int main() {
int i, a, b;
while (scanf("%d", &n) != EOF) {
for (i = 1; i <= n; i++) {
v[i].clear();
}
for (i = 1; i <= 2 * n; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
if (Doit()) {
memset(vis, 0, sizeof(vis));
len = 0;
if (DFS(1, -1, 1)) {
for (i = 1; i <= n; i++) {
if (i != 1) printf(" ");
printf("%d", num[i]);
}
printf("\n");
} else
printf("-1\n");
} else {
printf("-1\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int64_t LINF = 9187201950435737471;
const int64_t nLINF = -9187201950435737472;
const int64_t INF = 2139062143;
const int nINF = -2139062144;
const uint64_t ULINF = numeric_limits<uint64_t>::max();
const int64_t MAXN = 2e5 + 15;
const int64_t MAXE = 1e5 + 15;
const double PI = acos(-1);
const int64_t MOD = 1e9 + 7;
const int64_t P = 29;
const double EPS = 1e-10;
auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
mt19937 rnd(seed);
bool isEqual(double a, double b) { return abs(a - b) <= EPS; }
inline void IO() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
template <typename T>
istream& operator>>(istream& in, vector<T>& a) {
for (auto& i : a) in >> i;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
for (auto& i : a) {
out << i << " ";
}
return out;
}
template <typename T, typename D>
istream& operator>>(istream& in, pair<T, D>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T, typename D>
ostream& operator<<(ostream& out, const pair<T, D>& a) {
out << a.first << " " << a.second;
return out;
}
inline void solve() {
int n, m;
cin >> n >> m;
vector<int> from_num_to_string(n * m + 1);
vector<vector<int> > s(n);
vector<vector<int> > ans(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
s[i].resize(m);
for (int j = 0; j < m; ++j) {
cin >> s[i][j];
from_num_to_string[s[i][j]] = i;
}
}
for (int i = 1; i < m; ++i) {
for (int j = 0; j < n; ++j) {
int x;
cin >> x;
}
}
for (int j = 0; j < n; ++j) {
int x;
cin >> x;
int str = from_num_to_string[x];
for (int i = 0; i < m; ++i) {
ans[j][i] = s[str][i];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << ans[i][j] << " ";
}
cout << "\n";
}
}
signed main() {
IO();
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
unsigned long long int i, j, k, m, x, y, count = 0, l, n;
char string[10], cap;
gets(string);
cap = string[strlen(string) - 1];
string[strlen(string) - 1] = '\0';
n = atoll(string);
if (n % 4 == 1 || n % 4 == 2) {
unsigned long long int row1;
if (n % 4 == 1)
row1 = ((n - 1) / 4) + 1;
else
row1 = ((n - 2) / 4) + 1;
unsigned long long int row;
if (n % 4 == 1)
row = (row1 * 2) - 1;
else
row = (row1 * 2);
count = count + n - 1;
count = count + (row - 1) * 6;
if (cap == 'a')
count = count + 4;
else if (cap == 'b')
count = count + 5;
else if (cap == 'c')
count = count + 6;
else if (cap == 'd')
count = count + 3;
else if (cap == 'e')
count = count + 2;
else if (cap == 'f')
count = count + 1;
} else {
unsigned long long int row1;
if (n % 4 == 3)
row1 = ((n - 3) / 4) + 1;
else
row1 = ((n - 4) / 4) + 1;
unsigned long long int row;
if (n % 4 == 3)
row = (row1 * 2) - 1;
else
row = (row1 * 2);
count = count + (n - 1) - 2;
count = count + (row - 1) * 6;
if (cap == 'a')
count = count + 4;
else if (cap == 'b')
count = count + 5;
else if (cap == 'c')
count = count + 6;
else if (cap == 'd')
count = count + 3;
else if (cap == 'e')
count = count + 2;
else if (cap == 'f')
count = count + 1;
}
printf("%llu\n", count);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,fma,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimization("unroll-loops")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long m, t, r, x;
cin >> m >> t >> r;
long long a[1000], i, j, k;
memset(a, 0, sizeof(a));
unordered_set<long long> st;
for (i = 0; i < m; i++) {
cin >> x;
st.insert(299 + x);
}
if (r > t) {
cout << -1;
return 0;
}
for (i = 300; i < 700; i++) {
if (st.find(i) == st.end() || a[i] >= r) {
continue;
}
for (j = i - 1; j >= i - t; j--) {
if (a[j] != -1) {
a[j] = -1;
for (k = j + 1; k < j + t + 1; k++)
if (a[k] != -1) {
a[k]++;
}
}
if (a[i] >= r) break;
}
}
long long ans = 0;
for (i = 0; i < 700; i++) ans += (a[i] == -1);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c;
while (~scanf("%lf%lf%lf", &a, &b, &c)) {
if (a == 0 && b == 0)
if (c == 0)
puts("-1");
else
puts("0");
else if (a == 0 && c == 0)
puts("1\n0");
else if (b == 0 && c == 0)
puts("1\n0");
else if (a == 0)
printf("1\n%.10lf\n", -c / b);
else {
double tem = b * b - 4 * a * c;
if (tem < 0)
printf("0\n");
else if (tem == 0)
printf("1\n%.10lf\n", -b / (a * 2));
else {
double x1, x2;
x1 = (-b - sqrt(tem)) / (a * 2);
x2 = (-b + sqrt(tem)) / (a * 2);
if (x1 > x2) swap(x1, x2);
printf("2\n%.10lf\n%.10lf\n", x1, x2);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
using namespace std;
inline int read() {
int X = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 1) + (X << 3) + ch - '0';
ch = getchar();
}
if (flag) return X;
return ~(X - 1);
}
int n, b;
int a[N];
vector<int> v;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> b;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] & 1)
cnt++;
else
cnt--;
if (i == n) break;
if (cnt == 0) v.push_back(abs(a[i] - a[i + 1]));
}
sort(v.begin(), v.end());
int res = 0;
for (auto w : v) {
if (b >= w) {
res++;
b -= w;
} else
break;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ld = long double;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using vvi = std::vector<vi>;
using vii = std::vector<pii>;
using vll = std::vector<ll>;
using pll = std::pair<ll, ll>;
template <typename T>
int sign(const T& t) {
return (t > 0) - (t < 0);
}
template <typename T, typename U>
bool remax(T& a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T, typename U>
bool remin(T& a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
T gcd(T a, T b) {
a = std::abs(a);
b = std::abs(b);
while (b) {
a %= b;
std::swap(a, b);
}
return a;
}
template <typename T>
T lcm(T a, T b) {
a = std::abs(a);
b = std::abs(b);
return a / gcd(a, b) * b;
}
double get_time() { return static_cast<double>(clock()) / CLOCKS_PER_SEC; }
uint32_t mrand_32t() {
static std::random_device rd;
static std::mt19937 rng(rd());
return rng();
}
uint64_t mrand_64t() {
static std::random_device rd;
static std::mt19937_64 rng(rd());
return rng();
}
template <typename T>
void make_unique(std::vector<T>& v) {
std::sort(std::begin(v), std::end(v));
v.erase(std::unique(std::begin(v), std::end(v)), std::end(v));
}
namespace std {
template <typename A, typename B>
string to_string(const pair<A, B>& p) {
string str;
str += "(";
str += to_string(p.first);
str += ", ";
str += to_string(p.second);
str += ")";
return str;
}
string to_string(bool value) { return value ? "true" : "false"; }
template <typename T>
string to_string(const vector<T>& vec) {
string str = "{ ";
bool first = true;
for (const auto& it : vec) {
if (!first) {
str += ", ";
}
str += to_string(it);
first = false;
}
str += " }";
return str;
}
template <typename T>
string to_string(const set<T>& s) {
string str = "{ ";
bool first = true;
for (const auto& it : s) {
if (!first) {
str += ", ";
}
str += to_string(it);
first = false;
}
str += " }";
return str;
}
template <typename K, typename V>
string to_string(const map<K, V>& m) {
string str = "{ ";
bool first = true;
for (const auto& it : m) {
if (!first) {
str += ", ";
}
first = false;
str += to_string(it.first);
str += " -> ";
str += to_string(it.second);
}
str += " }";
return str;
}
string to_string(const string& s) { return "\"" + s + "\""; }
string to_string(const char* s) { return to_string(string(s)); }
string to_string(char ch) { return "\'" + string(1, ch) + "\'"; }
template <size_t N>
string to_string(const bitset<N>& b) {
string res(N, '0');
for (size_t i = 0; i < N; ++i) {
res[i] = '0' + b[i];
}
return res;
}
template <typename T>
string to_string(const T& t) {
std::stringstream ss;
ss << t;
return ss.str();
}
} // namespace std
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
std::cerr << " " << std::to_string(H);
debug_out(T...);
}
using namespace std;
int n;
bool read() {
if (!(cin >> n)) {
return 0;
}
return 1;
}
int ask(vi vs) {
cout << "? " << int((vs).size()) << endl;
for (int v : vs) {
cout << v + 1 << " ";
}
cout << endl;
int m;
cin >> m;
if (m == -1) {
exit(0);
}
return m;
}
struct Ans {
bool ok;
vi vs;
void print() const {
if (ok) {
cout << "Y ";
} else {
cout << "N ";
}
cout << int((vs).size()) << endl;
for (int v : vs) {
cout << v + 1 << " ";
}
cout << endl;
}
};
void append(vi& a, const vi& b) {
for (const auto& x : b) {
a.push_back(x);
}
}
vi merge(const vi& a, const vi& b) {
vi c = a;
append(c, b);
return c;
}
Ans solve() {
const auto get_edge = [&](const vi& vs, int v) {
{
vi cur = vs;
cur.push_back(v);
if (ask(cur) == 0) {
return -1;
}
}
int L = -1;
int R = int((vs).size());
while (L != R - 1) {
int M = (L + R) / 2;
auto cur = vi(vs.begin(), vs.begin() + (M + 1));
cur.push_back(v);
if (ask(cur) > 0) {
R = M;
} else {
L = M;
}
}
if (R == int((vs).size())) {
return -1;
}
return vs.at(R);
};
vvi g(n);
const function<bool(int, int, vi&, vi&)> dfs = [&](int v, int want, vi& was,
vi& path) -> bool {
assert(!was[v]);
was[v] = 1;
path.push_back(v);
if (v == want) {
return 1;
}
for (int u : g[v]) {
if (!was[u]) {
if (dfs(u, want, was, path)) {
return 1;
}
}
}
assert(path.back() == v);
path.pop_back();
return 0;
};
const auto addE = [&](int v, int u) {
if (v == -1 || u == -1) {
return;
}
g[v].push_back(u);
g[u].push_back(v);
};
vi left___;
vi right___;
left___.push_back(0);
vi used(n, 0);
used[0] = 1;
vi pref;
while (1) {
vi rest;
for (int v = int(0); v < int(n); ++v) {
if (!used[v]) {
rest.push_back(v);
}
}
if (rest.empty()) {
break;
}
vi lr = left___;
append(lr, right___);
const int base = ask(lr);
int L = -1;
int R = int((rest).size());
while (L != R - 1) {
int M = (L + R) / 2;
const int old = int((lr).size());
append(lr, vi(rest.begin(), rest.begin() + (M + 1)));
int xxx = ask(vi(rest.begin(), rest.begin() + (M + 1)));
if (ask(lr) > base + xxx) {
R = M;
} else {
L = M;
}
lr.resize(old);
}
if (R == int((rest).size())) {
append(pref, left___);
left___.clear();
right___.clear();
const int v = rest.at(0);
used[v] = 1;
left___.push_back(v);
continue;
}
const int v = rest.at(R);
used[v] = 1;
int Lv = get_edge(left___, v);
int Rv = get_edge(right___, v);
if (Lv != -1 && Rv != -1) {
vi was(n, 0);
vi path;
bool found = dfs(Lv, Rv, was, path);
assert(found);
path.push_back(v);
return Ans{false, path};
}
addE(Lv, v);
addE(Rv, v);
if (Lv != -1) {
right___.push_back(v);
} else if (Rv != -1) {
left___.push_back(v);
} else {
assert(0);
}
}
append(pref, left___);
return Ans{true, pref};
}
int main() {
read();
auto ans = solve();
ans.print();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
string s;
cin >> s;
int c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '<')
c1++;
else if (s[i] == '>')
c2++;
}
if (c1 == 0 || c2 == 0)
cout << n << endl;
else {
set<int> ans;
for (int i = 0; i < n; i++) {
if (s[i] == '-') {
ans.insert(i);
ans.insert((i + 1) % n);
}
}
cout << ans.size() << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
const int INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long a, b;
cin >> a >> b;
if (gcd(a, b) != 1)
cout << "Impossible" << endl;
else {
while (a != 1 && b != 1) {
if (a > b) {
cout << a / b << "A";
a %= b;
} else {
cout << b / a << "B";
b %= a;
}
}
if (a > b) {
cout << a / b - 1 << "A";
} else {
cout << b / a - 1 << "B";
}
}
return 0;
}
| 8 |
#include<bits/stdc++.h>
#define Fast ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define MMM 1000000007
using namespace std;
ll POW(ll a,ll b, ll m)
{
ll ans=1;
while(b)
{
if(b&1)
ans=(ans*a)%m;
b/=2;
a=(a*a)%m;
}
return ans;
}
/* Problems to do: Topic
-> Little Girl and Maximum Sum -> Fenwick tree
*/
/*
---------------------------------------------------------------------------------------------------------------------------------------------------
(Problem related to this snippet: "Linova and Kingdom, source: Codeforces")
->LEVEL OF ANY NODE(stored in Level)
->COUNT OF NODES IN SUBTREE(stored in dp)
->*{subtract 1 if you want to know count of nodes below a specified node}*
vector<ll>adj[250005];
ll dp[250005];
ll Level[250005];
void dfs(ll node, ll level = 0, ll parent = -1)
{
ll cnt = 0;
Level[node] = level;
for(auto &it: adj[node])
{
if(it != parent)
{
dfs(it, level + 1, node);
cnt += dp[it];
}
}
dp[node] = 1 + cnt;
}
---------------------------------------------------------------------------------------------------------------------------------------------------
*/
class DSU{
public:
map<int,int>children;
std::vector<int>rk,par;
int N;
DSU(int n)
{
for(int i= 0; i <= n; i++){
par.push_back(i);
rk.push_back(0);
}
N = n;
}
//Return the parent of node x
int get(int x)
{
return x == par[x] ? x : par[x] = get(par[x]);
}
//Checks if they both have same parent or not
bool same_set(int x, int y){
return (get(x) == get(y));
}
void Union(int x, int y)
{
x = get(x), y = get(y);
if(rk[x] > rk[y])
{
par[y] = x;
}
else if(rk[x] < rk[y])
{
par[x] = y;
}
else
{
par[x] = y;
rk[y]++;
}
}
//Setting the number of children parent has;
void setChildren()
{
for(int i = 1; i <= N; i++)
{
children[get(i)]++;
}
}
//Returns the total number of nodes parent of x is connected to
//Parent is also included in count
int get_size(int x){
return children[get(x)];
}
};
vector<int>adj[700000];
int main()
{
Fast;
ll t;
cin >> t;
while(t--)
{
ll n;
cin >> n;
ll arr[n];
for(ll i = 0; i < n; i++)
{
cin >> arr[i];
}
cout << 6 * (n / 2) << "\n";
for(ll i = 0; i < n; i++)
{
cout << 1 << " " << i + 1 << " " << i + 2 << "\n";
cout << 2 << " " << i +1<< " " << i + 2 << "\n";
cout << 1 << " " << i +1<< " " << i + 2 << "\n";
cout << 1 << " " << i+1 << " " << i + 2 << "\n";
cout << 2 << " " << i+1 << " " << i + 2 << "\n";
cout << 1 << " " << i + 1 << " " << i + 2 << "\n";
i++;
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200], b[200], c[200], cost[200], n;
bool d[200];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", &a[i], &b[i], &c[i], &cost[i]);
d[i] = true;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if ((a[j] < a[i]) && (b[j] < b[i]) && (c[j] < c[i])) d[j] = false;
int price = 100000, p = 0;
for (int i = 1; i <= n; i++)
if ((d[i] == true) && (cost[i] < price)) {
price = cost[i];
p = i;
}
printf("%d\n", p);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 100005;
int flag[maxm], id[maxm];
char str[maxm];
vector<int> v[30];
int main() {
int n, i, j, k, sum, len, cnt, rev, ans = 0;
scanf("%s", str);
len = strlen(str);
for (i = 0; str[i] != '\0'; i++) v[str[i] - 'a'].push_back(i);
sum = 0;
for (k = 0; k < 26; k++) {
ans = 0;
for (i = 1; i < len; i++) {
cnt = 0;
for (j = 0; j < 26; j++) flag[j] = 0;
for (j = 0; j < v[k].size(); j++) {
int now = v[k][j] + i;
if (now >= len) now = v[k][j] + i - len;
flag[str[now] - 'a']++;
}
for (j = 0; j < 26; j++) {
if (flag[j] == 1) cnt++;
}
ans = max(ans, cnt);
}
sum += ans;
}
double x = sum, y = len;
printf("%.15f\n", x / y);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int POPCNT(int _x) { return __builtin_popcount(_x); }
inline int POPCNT(long long _x) { return __builtin_popcountll(_x); }
const int iINF = 1L << 30;
const long long lINF = 1LL << 60;
double EPS = 1e-9;
inline bool in_range(int _v, int _mx, int _mi) { return _mi <= _v && _v < _mx; }
inline bool in_range(double _v, double _mi, double _mx) {
return -EPS < _v - _mi && _v - _mx < EPS;
}
inline bool in_range(int _x, int _y, int _W, int _H) {
return 0 <= _x && _x < _W && 0 <= _y && _y < _H;
}
const int DX[4] = {0, 1, 0, -1}, DY[4] = {-1, 0, 1, 0};
const int DX_[8] = {0, 1, 1, 1, 0, -1, -1, -1},
DY_[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int n;
struct Primes {
int max_p;
vector<int> primes;
vector<int> prime_num;
vector<int> composit;
Primes(int _mx) : max_p(_mx) { enum_primes(); }
void enum_primes() {
primes.clear();
prime_num.assign(max_p + 1, 0);
vector<bool> is_p(max_p + 1, true);
for (int i = 2; i < max_p + 1; ++i) {
if (is_p[i]) {
prime_num[i]++;
primes.push_back(i);
for (int j = 2 * i; j <= max_p; j += i) is_p[j] = false;
} else {
composit.push_back(i);
}
prime_num[i] += prime_num[i - 1];
}
}
int p_count(int _x) { return prime_num[_x]; }
int p_count(int _mi, int _mx) { return prime_num[_mx] - prime_num[_mi - 1]; }
int at(int _i) { return primes[_i]; }
int cat(int _i) { return composit[_i]; }
bool p_search(int x) {
return binary_search(primes.begin(), primes.end(), x);
}
bool c_search(int x) {
return binary_search(composit.begin(), composit.end(), x);
}
};
void solve() {
Primes primes((int)1e6);
for (int i = 3; i < (int)1e6; ++i) {
if (primes.c_search(i)) {
int s = n - i;
if (primes.c_search(s)) {
cout << i << " " << s << endl;
return;
}
}
}
}
int main() {
cin >> n;
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int prv[400000], nxt[400000], n, x;
vector<int> ans;
int main() {
cin >> n;
int last = n;
int cnt = 0;
for (int i = 2; i < n; i++) {
prv[i] = i - 1;
nxt[i] = i + 1;
}
prv[last] = n - 1;
nxt[last] = last;
prv[1] = 1;
nxt[1] = 2;
ans.push_back(1);
for (int i = 0; i < n - 1; i++) {
cin >> x;
prv[nxt[x]] = prv[x];
nxt[prv[x]] = nxt[x];
if (x == last) {
last = prv[x];
cnt -= x - prv[x] - 1;
} else
cnt++;
ans.push_back(cnt + 1);
}
ans.push_back(1);
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, cap, flow;
edge() : to(-1), cap(0), flow(0){};
edge(int _to, int _cap, int _flow) : to(_to), cap(_cap), flow(_flow){};
};
const int INF = 1e9 + 7;
const int MAXN = 2050;
vector<int> g[MAXN];
int d[MAXN], ptr[MAXN];
vector<edge> ed;
int par[MAXN];
int s, t;
void add_edge(int u, int v, int cap, int flow) {
g[u].push_back(ed.size());
ed.push_back(edge(v, cap, flow));
g[v].push_back(ed.size());
ed.push_back(edge(u, 0, 0));
}
bool bfs() {
fill(d, d + MAXN, INF);
fill(ptr, ptr + MAXN, 0);
d[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int id : g[u]) {
if (d[ed[id].to] == INF && ed[id].cap - ed[id].flow > 0) {
d[ed[id].to] = d[u] + 1;
par[ed[id].to] = id;
q.push(ed[id].to);
}
}
}
return (d[t] != INF);
}
long long max_flow() {
long long flow = 0;
while (bfs()) {
int p = t, pushed = INF;
while (p != s) {
pushed = min(pushed, ed[par[p]].cap - ed[par[p]].flow);
p = ed[par[p] ^ 1].to;
}
flow += pushed;
p = t;
while (p != s) {
ed[par[p]].flow += pushed;
ed[par[p] ^ 1].flow -= pushed;
p = ed[par[p] ^ 1].to;
}
}
return flow;
}
int main() {
int n, m;
cin >> n >> m;
s = m + 1;
t = m + 2;
for (int i = 0; i < n; ++i) {
int w;
cin >> w;
add_edge(i + m + 3, t, w, 0);
}
long long sum = 0;
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
sum += w;
u--;
v--;
add_edge(i, u + m + 3, INF, 0);
add_edge(i, v + m + 3, INF, 0);
add_edge(s, i, w, 0);
}
cout << sum - max_flow();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-6;
int n, A[2000000];
bool ok(double t) {
int secondStart = upper_bound(A, A + n, A[0] + 2 * t) - A;
if (secondStart == n) return 1;
int thirdStart = upper_bound(A, A + n, A[secondStart] + 2 * t) - A;
if (thirdStart == n) return 1;
int fourhtStart = upper_bound(A, A + n, A[thirdStart] + 2 * t) - A;
if (fourhtStart == n) return 1;
return 0;
}
double binarySearch() {
double lo = 0, med, hi = 1e9 + 5;
int cnt = 100;
while (cnt--) {
med = (lo + hi) / 2;
if (ok(med))
hi = med;
else
lo = med;
}
return med;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", A + i);
sort(A, A + n);
double t = binarySearch();
printf("%lf\n%lf ", t, A[0] + t);
int secondStart = upper_bound(A, A + n, A[0] + 2 * (t + EPS)) - A;
printf("%lf ", A[secondStart] + t);
int thirdStart = upper_bound(A, A + n, A[secondStart] + 2 * (t + EPS)) - A;
printf("%lf\n", A[thirdStart] + t);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int tree[100000 * 4], prop[100000 * 4];
int get(int l, int r, int n = 1, int rl = 0, int rr = 100000) {
if (prop[n]) {
tree[n] += (rr - rl + 1) * prop[n];
if (n < 200000) {
prop[n * 2] += prop[n];
prop[n * 2 + 1] += prop[n];
}
prop[n] = 0;
}
if (rl > r || rr < l) return 0;
if (rl == rr) return tree[n];
if (rl >= l && rr <= r) return tree[n];
return get(l, r, n * 2, rl, (rl + rr) / 2) +
get(l, r, n * 2 + 1, (rl + rr) / 2 + 1, rr);
}
void insert(int l, int r, int val, int n = 1, int rl = 0, int rr = 100000) {
if (rl > r || rr < l) return;
if (rl == rr)
tree[n] += val;
else if (rl >= l && rr <= r)
prop[n] += val;
else {
insert(l, r, val, n * 2, rl, (rl + rr) / 2);
insert(l, r, val, n * 2 + 1, (rl + rr) / 2 + 1, rr);
tree[n] += (min(rr, r) - max(l, rl) + 1) * val;
}
}
int width, queries;
int direc = 1;
int start = 0;
int main() {
cin >> width >> queries;
insert(0, width - 1, 1);
for (int i = 0; i < queries; i++) {
int q;
cin >> q;
if (q == 1) {
int pos;
cin >> pos;
if (pos > width / 2) {
pos = width - pos;
start += width * direc;
direc *= -1;
}
if (direc == -1) {
for (int i = 0; i < pos; i++) {
insert(start - pos * 2 + i, start - pos * 2 + i,
get(start - i - 1, start - i - 1));
}
} else {
for (int i = 0; i < pos; i++) {
insert(start + pos * 2 - i - 1, start + pos * 2 - i - 1,
get(start + i, start + i));
}
}
start += pos * direc;
width -= min(pos, width - pos);
} else {
int a, b;
cin >> a >> b;
if (direc == 1) {
cout << get(start + a, start + b - 1) << "\n";
} else {
cout << get(start - b, start - a - 1) << "\n";
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, dad[200005], cyc, ord[200005], ty[200005], x[200005], y[200005];
vector<long long> v[200005];
bool vis[200005], current[200005];
queue<long long> q;
void dfs(int ver) {
if (current[ver]) {
cyc = 1;
return;
}
if (vis[ver]) return;
vis[ver] = 1;
current[ver] = 1;
for (int i = 0; i < v[ver].size(); i++) {
dfs(v[ver][i]);
}
current[ver] = 0;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> ty[i] >> x[i] >> y[i];
if (ty[i] == 1) {
v[x[i]].push_back(y[i]);
dad[y[i]]++;
}
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
dfs(i);
}
if (cyc) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (dad[i] == 0) q.push(i);
}
int c = 0;
while (!q.empty()) {
long long p = q.front();
q.pop();
ord[p] = c++;
for (int i = 0; i < v[p].size(); i++) {
dad[v[p][i]]--;
if (dad[v[p][i]] == 0) q.push(v[p][i]);
}
}
for (int i = 0; i < m; i++) {
if (ty[i] == 1)
cout << x[i] << ' ' << y[i] << endl;
else {
if (ord[x[i]] < ord[y[i]])
cout << x[i] << ' ' << y[i] << endl;
else
cout << y[i] << ' ' << x[i] << endl;
}
}
}
for (int i = 1; i <= n; i++) {
v[i].clear();
vis[i] = 0;
current[i] = 0;
cyc = 0;
ord[i] = 0;
dad[i] = 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, A[12][N], q;
struct node {
int ans, lrt[12], rrt[12];
void trans(int u, int v) {
ans--;
for (int i = 1; i <= n; i++) {
if (lrt[i] == u) lrt[i] = v;
if (rrt[i] == u) rrt[i] = v;
}
}
} t[N << 2];
node _merge(node a, node b, int l, int r) {
node ret;
ret.ans = a.ans + b.ans;
for (int i = 1; i <= n; i++) ret.lrt[i] = a.lrt[i], ret.rrt[i] = b.rrt[i];
for (int i = 1; i <= n; i++) {
if (A[i][l] == A[i][r] && a.rrt[i] != b.lrt[i]) {
ret.trans(a.rrt[i], b.lrt[i]);
a.trans(a.rrt[i], b.lrt[i]);
}
}
return ret;
}
void build(int u, int l, int r) {
if (l == r) {
t[u].ans = n;
for (int i = 1; i <= n; i++) t[u].lrt[i] = t[u].rrt[i] = (l - 1) * n + i;
for (int i = 1; i <= n; i++)
if (A[i][l] == A[i - 1][l]) t[u].trans(t[u].lrt[i], t[u].lrt[i - 1]);
return;
}
int mid = (l + r) / 2;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
t[u] = _merge(t[u << 1], t[u << 1 | 1], mid, mid + 1);
}
node query(int u, int l, int r, int L, int R) {
if (l == L && r == R) return t[u];
int mid = (l + r) / 2;
if (R <= mid)
return query(u << 1, l, mid, L, R);
else if (L > mid)
return query(u << 1 | 1, mid + 1, r, L, R);
else
return _merge(query(u << 1, l, mid, L, mid),
query(u << 1 | 1, mid + 1, r, mid + 1, R), mid, mid + 1);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &A[i][j]);
build(1, 1, m);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", query(1, 1, m, l, r).ans);
}
return 0;
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.