solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
//AUTHOR: RAVAN_2070
//PUNE INSTITUTE OF COMPUTER TECHNOLOGY
/*
I ♥ CLARICE STARLING...
EXPLAINATION BELOW->
*/
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<pair<ll,ll>> vii;
typedef pair<ll,ll> pii;
typedef map<ll,ll> mii;
#define MOD7 1000000007
#define MOD9 1000000009
#define pi 3.1415926535
#define Test_cases ll TC;cin>>TC;while(TC--)
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(), x.rend()
#define sp(x) fixed<<setprecision(x)
#define sz(x) (ll)(x.size())
#define fo(i,a,b) for(i=a;i<b;i++)
#define foe(i,a,b) for(i=a;i<=b;i++)
const ll INF = (ll)2e18 + 77;
int n;
ll ans,cnt;
vector<vector<int>>adj;
vector<int>color,parent;
vector<int>cycle;
void dfs(int u,int p=-1)
{
color[u]=1;
parent[u]=p;
for(auto c:adj[u])
{
if(c!=p)
if(color[c]==0)
{
dfs(c,u);
if(sz(cycle))return;
}
else if(color[c]==1)
{
int x=u;
while(x!=c)
{
//cout<<x<<" ,";
cycle.pb(x);
x=parent[x];
}
//cout<<c<<"\n";
cycle.pb(c);
return;
}
}
color[u]=2;
}
void dfsfortree(int u)
{
color[u]=1;
cnt++;
for(auto c:adj[u])
{
if(color[c]==0)
{
dfsfortree(c);
}
}
}
void solve()
{
ans=0ll;
cin>>n;
adj=vector<vector<int>>(n);
color=vector<int>(n,0);
parent=vector<int>(n);
int i,u,v;
fo(i,0,n)
{
cin>>u>>v;
u--;v--;
adj[u].pb(v);
adj[v].pb(u);
}
dfs(0);
fo(i,0,n)color[i]=0;
fo(i,0,sz(cycle))color[cycle[i]]=1;
fo(i,0,sz(cycle))
{
cnt=0ll;
dfsfortree(cycle[i]);
// cout<<cnt<<" "<<cycle[i]<<"\n";
ans+=((cnt*(cnt-1))/2)+(cnt*(n-cnt));
}
cycle.clear();
cout<<ans<<"\n";
}
int main()
{
fastio
Test_cases
solve();
return 0;
}
//Don't use memset
//**always check if you are not killing input in between
//map<ll,ll,greater<int>> to sort in descending order ,in iterator declaration no greater<int>
//if you want to apply lowerbound on set use s.lower_bound(key),not the one used for vector
// Syntax to create a min heap for priority queue priority_queue <int, vector<int>, greater<int>>;
//for modinverse use modularexponention(x,M-2,M);
//for "each" subtraction from ans(ans-k) if(ans<0) do ans+=MOD,ans%=MOD
//vector<vector<int>>dp(201,vector<int>(n+1)); A way to initialize vector of vector
//string2=string1.substr(pos,length);if len no specified then till end
//void fill (ForwardIterator first, ForwardIterator last, const T& val);
//The range filled is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last.
//If wrong on pretest 2 means logically wrong
/* TIPS FOR DEBUGGING
* Check if values are not overflowing (use long long where required)
* Check if ranges are inclusive or not.
* Check properly if greedy will work or not before using it.
* Check EDGE CASES!! Seriously, even in 2B, saving 8 points by being
* 2 minutes faster will bite you in the ass if you don't make sure
* it works on edge cases.
* Keep adding to this list.
*/
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double infinity = numeric_limits<long double>::infinity();
int main() {
int n;
scanf("%i", &n);
long double max_max = -infinity, min_min = infinity;
for (int i = 1; i <= n; i++) {
int ki;
scanf("%i", &ki);
max_max = max(max_max, static_cast<long double>(ki) / i);
min_min = min(min_min, static_cast<long double>(ki + 1) / i);
}
int left = floor((n + 1) * max_max) - 1;
int right = ceil((n + 1) * min_min);
if (right - left > 2)
printf("not unique\n");
else
printf("unique\n%i\n", left + 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int x;
cin >> x;
int s = 1, cnt = 0;
while(s * (s + 1) / 2 < x) ++s;
if(s * (s + 1) / 2 - 1 == x) ++s;
cout << s;
}
int main() {
int T = 1;
cin >> T;
while(T--) solve(), cout << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000111000;
int main() {
long long a, b, c = 0;
scanf("%I64d %I64d", &a, &b);
for (int n = 1, _d = (int)a; n <= _d; ++n)
if (b % n == 0 && (b / n) <= a) c++;
printf("%I64d\n", c);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct elem {
int inc, sf;
} v[5005];
int fv[5005], v1[5005], v2[5005], k1, k2;
inline bool cmp(const elem &a, const elem &b) {
if (a.inc == b.inc) return a.sf < b.sf;
return a.inc < b.inc;
}
int cauta(int beg, int endi) {
int st = 1, dr = k1, mij = (st + dr) / 2, pozi, sol = k1 + 1;
while (st <= dr) {
if (v1[mij] >= beg)
dr = mij - 1, sol = mij;
else
st = mij + 1;
mij = (st + dr) / 2;
}
st = 1;
pozi = sol;
sol = 0;
dr = k1;
mij = (st + dr) / 2;
while (st <= dr) {
if (v1[mij] <= endi)
st = mij + 1, sol = mij;
else
dr = mij - 1;
mij = (st + dr) / 2;
}
int pozf = sol;
if (pozf >= pozi)
return pozf - pozi + 1;
else
return 0;
}
int cauta2(int beg, int endi) {
int st = 1, dr = k2, mij = (st + dr) / 2, pozi, sol = k2 + 1;
while (st <= dr) {
if (v2[mij] >= beg)
dr = mij - 1, sol = mij;
else
st = mij + 1;
mij = (st + dr) / 2;
}
st = 1;
pozi = sol;
sol = 0;
dr = k2;
mij = (st + dr) / 2;
while (st <= dr) {
if (v2[mij] <= endi)
st = mij + 1, sol = mij;
else
dr = mij - 1;
mij = (st + dr) / 2;
}
int pozf = sol;
if (pozf >= pozi)
return pozf - pozi + 1;
else
return 0;
}
int main() {
int n, q, i, j;
cin >> n >> q;
for (i = 1; i <= q; i++) {
cin >> v[i].inc >> v[i].sf;
fv[v[i].inc] += 1;
fv[v[i].sf + 1] -= 1;
}
sort(v + 1, v + q + 1, cmp);
int sum = 0, k = 0;
for (i = 1; i <= n; i++) {
sum += fv[i];
fv[i] = sum;
if (fv[i] == 1) v1[++k1] = i;
if (fv[i] == 2) v2[++k2] = i;
if (fv[i] != 0) k++;
}
int maxi = 0;
for (i = 1; i < q; i++)
for (j = i + 1; j <= q; j++) {
int placi = 0;
placi += cauta(v[i].inc, v[i].sf);
placi += cauta(v[j].inc, v[j].sf);
if (v[i].sf >= v[j].inc && v[j].sf >= v[i].sf)
placi += cauta2(v[j].inc, v[i].sf);
else if (v[i].sf >= v[j].sf && v[i].inc <= v[j].inc)
placi += cauta2(v[j].inc, v[j].sf);
maxi = max(maxi, k - placi);
}
cout << maxi << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T qmin(const T a, const T b) {
return a < b ? a : b;
}
template <typename T>
inline T qmax(const T a, const T b) {
return a > b ? a : b;
}
template <typename T>
inline void getmin(T &a, const T b) {
if (a > b) a = b;
}
template <typename T>
inline void getmax(T &a, const T b) {
if (a < b) a = b;
}
inline void fileio(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const int inf = 1e9 + 7;
const long long linf = 1e17 + 7;
const int K = 105, N = 1e5 + 7;
int a[K], k;
long long f[K][N], n;
inline long long calc(int i, long long n) {
if (n < N && ~f[i][n]) return f[i][n];
long long ans;
if (n == 0)
ans = 0;
else if (i == k)
ans = n - n / a[i];
else
ans = calc(i + 1, n) - calc(i + 1, n / a[i]);
if (n < N) f[i][n] = ans;
return ans;
}
int main() {
scanf("%I64d%d", &n, &k);
for (int i = 1; i <= k; ++i) scanf("%d", a + i);
sort(a + 1, a + k + 1, greater<int>());
memset(f, -1, sizeof(f));
printf("%I64d\n", calc(1, n));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 210000;
pair<int, int> p[maxN];
int n, k;
set<pair<int, int> > candidates;
vector<pair<int, int> > res;
set<long long> S;
inline long long code(long long x, long long y) { return x * 4000000007LL + y; }
bool check(pair<int, int> c) {
c.first += c.first;
c.second += c.second;
int miss = 0;
for (int i = 1; i <= n; ++i) {
long long cur = code(c.first - p[i].first, c.second - p[i].second);
if (S.find(cur) == S.end()) {
++miss;
if (miss > k) {
return false;
}
}
}
return true;
}
int main() {
srand(987892);
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &p[i].first, &p[i].second);
p[i].first *= 2;
p[i].second *= 2;
}
if (n <= k) {
printf("-1\n");
return 0;
}
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; ++i) {
S.insert(code(p[i].first, p[i].second));
}
for (int i = 1; i <= min(n, 11); ++i)
for (int j = n; j > max(0, n - 11); --j)
candidates.insert(make_pair((p[i].first + p[j].first) / 2,
(p[i].second + p[j].second) / 2));
random_shuffle(p + 1, p + n + 1);
for (set<pair<int, int> >::iterator it = candidates.begin();
it != candidates.end(); ++it)
if (check(*it)) {
res.push_back(*it);
}
printf("%d\n", res.size());
for (int i = 0; i < res.size(); ++i)
printf("%.1lf %.1lf\n", (double)(res[i].first) / 2.0,
(double)(res[i].second) / 2.0);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n % 2 == 0) {
cout << n / 2;
} else {
cout << -(n + 1) / 2;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int MAXN = 1e5 + 5;
long long int fastexpo(long long int b, long long int exp) {
if (exp == 0) return 1;
if (exp == 1) return b;
long long int ans = (fastexpo(b, exp / 2) % MOD);
ans *= ans;
ans %= MOD;
if (exp % 2 == 1) {
ans *= b;
}
ans %= MOD;
return ans;
}
long long int calc(vector<long long int> vec, long long int rem,
long long int l, long long int r) {
long long int res = INT_MAX;
for (long long int i = 0; i <= rem; i++) {
long long int lft = rem - i;
res = min(max(vec[l + i], vec[r - lft]), res);
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m, k;
cin >> n >> m >> k;
vector<long long int> a;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
a.push_back(x);
}
long long int op = min(k, m - 1);
long long int ans = 0;
for (long long int i = 0; i <= op; i++) {
long long int lft = op - i;
ans = max(ans, calc(a, m - op - 1, i, n - 1 - lft));
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int distinct(int n) {
int a[4];
int counter = 0;
while (n > 0) {
a[counter] = n % 10;
n /= 10;
counter++;
}
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
if (a[i] == a[j]) {
return -1;
}
}
}
return 1;
}
int main() {
int n;
cin >> n;
for (n = n + 1; distinct(n) != 1; n++) {
}
cout << n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[200010], n;
bool can[200010];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void Can(int i) {
can[i] = true;
for (int j = 1; j <= i; ++j) {
int s = 0;
for (int k = j; k <= n; k += i) s ^= a[k];
if (s) can[i] = false;
}
}
int main() {
bool v0 = true;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
char c = 0;
while (!isdigit(c)) c = getchar();
a[i] = c - '0';
if (a[i]) v0 = false;
}
queue<int> C;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
C.push(n / i);
Can(i);
}
}
while (!C.empty()) {
Can(C.front());
C.pop();
}
int ans = v0 ? 1 : 0;
for (int i = 1; i < n; ++i)
if (can[gcd(i, n)]) ++ans;
printf("%d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, q, K, x, y, sp, flag, ans_sum, a[200005], b[200005], cc[200005],
c[200005], len[200005], check[200005], ans[200005];
int bl[200005], id[1005][1005], tag[200005], tot[1005][(1 << 14)];
char s[11];
void add(int k) {
if (k != sp) flag += (check[k] > 0);
ans_sum += ans[k];
}
void del(int k) {
if (k != sp) flag -= (check[k] > 0);
ans_sum -= ans[k];
}
void add(int x, int i) {
tot[id[x][i / K]][c[i * k + x]]++;
if (c[i * k + x] == tag[id[x][i / K]]) ans[x]++;
}
void del(int x, int i) {
tot[id[x][i / K]][c[i * k + x]]--;
if (c[i * k + x] == tag[id[x][i / K]]) ans[x]--;
}
void update(int x, int y) {
del(bl[x]);
check[bl[x]] ^= y;
int i = (x - bl[x]) / k;
if (k > K) {
for (; i < len[bl[x]]; i++) {
if (!c[i * k + bl[x]]) ans[bl[x]]--;
c[i * k + bl[x]] ^= y;
if (!c[i * k + bl[x]]) ans[bl[x]]++;
}
} else {
for (; (i < len[bl[x]]) && (i % K); i++) {
del(bl[x], i);
c[i * k + bl[x]] ^= y;
add(bl[x], i);
}
if (i != len[bl[x]]) {
for (; i < len[bl[x]]; i += K) {
ans[bl[x]] -= tot[id[bl[x]][i / K]][tag[id[bl[x]][i / K]]];
tag[id[bl[x]][i / K]] ^= y;
ans[bl[x]] += tot[id[bl[x]][i / K]][tag[id[bl[x]][i / K]]];
}
}
}
add(bl[x]);
}
void write() {
if (flag)
printf("-1\n");
else
printf("%d\n", n - ans_sum);
}
int main() {
scanf("%d%d%d", &n, &k, &q);
K = (int)sqrt(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
sp = n % k;
for (int i = 0; i < n; i++) {
bl[i] = i % k;
len[bl[i]]++;
cc[i] = (a[i] ^ b[i]);
}
c[0] = cc[0];
for (int i = 1; i < n; i++) c[i] = (cc[i - 1] ^ cc[i]);
for (int i = k; i < n; i++) c[i] = (c[i] ^ c[i - k]);
for (int i = n - k; i < n; i++) check[bl[i]] = c[i];
if (k > K) {
for (int i = 0; i < n; i++) ans[bl[i]] += (c[i] == 0);
} else {
int V = 0;
for (int i = 0; i < k; i++)
for (int j = 0; j < len[i]; j += K) id[i][j / K] = ++V;
for (int i = 0; i < n; i++) add(bl[i], (i - bl[i]) / k);
}
for (int i = 0; i < k; i++) add(i);
write();
for (int i = 1; i <= q; i++) {
scanf("%s%d%d", s, &x, &y);
x--;
if (s[0] == 'a') {
update(x, (a[x] ^ y));
if (x < n - 1) update(x + 1, (a[x] ^ y));
a[x] = y;
} else {
update(x, (b[x] ^ y));
if (x < n - 1) update(x + 1, (b[x] ^ y));
b[x] = y;
}
write();
}
}
| 12 |
#include <bits/stdc++.h>
const int maxn = 3e5 + 100;
using namespace std;
vector<pair<int, int> > f[maxn];
vector<int> G[maxn];
long long c[maxn << 1];
long long ans[maxn];
int n, m;
int lowbit(int x) { return x & -x; }
void add(int id, int x) {
while (id <= 2 * n) {
c[id] += x;
id += lowbit(id);
}
}
long long query(int id) {
long long ans = 0;
while (id) {
ans += c[id];
id -= lowbit(id);
}
return ans;
}
long long Q(int l, int r) { return query(r) - query(l - 1); }
void dfs(int u, int fa, int dep) {
for (int i = 0; i < (int)f[u].size(); i++)
add(dep + f[u][i].first, f[u][i].second);
ans[u] = Q(dep, 2 * n);
for (int v : G[u]) {
if (v == fa) continue;
dfs(v, u, dep + 1);
}
for (int i = 0; i < (int)f[u].size(); i++)
add(dep + f[u][i].first, -f[u][i].second);
}
void solve() { dfs(1, 0, 1); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
int q;
scanf("%d", &q);
while (q--) {
int v, d, x;
scanf("%d %d %d", &v, &d, &x);
d = min(d, n);
f[v].push_back(make_pair(d, x));
}
solve();
for (int i = 1; i <= n; i++) printf("%I64d ", ans[i]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, m, i, j, k, l, flag;
while (scanf("%d%d", &n, &m) != EOF) {
if ((n == 1 && m == 1) || (n == 1 && m == 2) || (n == 2 && m == 1)) {
printf("0\n");
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) printf("%d %d\n", i, j);
printf("1 1\n");
} else if (n == 1) {
printf("1\n1 %d 1 1\n", m);
for (i = 1; i <= m; i++) printf("1 %d\n", i);
printf("1 1\n");
} else if (m == 1) {
printf("1\n%d 1 1 1\n", n);
for (i = 1; i <= n; i++) printf("%d 1\n", i);
printf("1 1\n");
} else if (n % 2 == 1 && m % 2 == 1) {
printf("1\n%d %d 1 1\n", n, m);
flag = 1;
for (i = 1; i <= n; i++) {
if (flag == 1)
for (j = 1; j <= m; j++) printf("%d %d\n", i, j);
else
for (j = m; j > 0; j--) printf("%d %d\n", i, j);
flag = -1 * flag;
}
printf("1 1\n");
} else {
printf("0\n");
if (m % 2 == 0) {
for (i = 1; i <= m; i++) printf("1 %d\n", i);
flag = 1;
for (i = m; i > 0; i--) {
if (flag == 1)
for (j = 2; j <= n; j++) printf("%d %d\n", j, i);
else
for (j = n; j > 1; j--) printf("%d %d\n", j, i);
flag = -1 * flag;
}
printf("1 1\n");
} else {
for (i = 1; i <= n; i++) printf("%d 1\n", i);
flag = 1;
for (i = n; i > 0; i--) {
if (flag == 1)
for (j = 2; j <= m; j++) printf("%d %d\n", i, j);
else
for (j = m; j > 1; j--) printf("%d %d\n", i, j);
flag = -1 * flag;
}
printf("1 1\n");
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[200001], p[200001];
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
iota(p, p + n + 1, 0);
sort(p + 1, p + n + 1, [](int i1, int i2) { return a[i1] > a[i2]; });
sort(p + 1, p + m * k + 1);
long long sum = 0;
for (int i = 1; i <= m * k; ++i) sum += a[p[i]];
cout << sum << endl;
for (int i = m; i < m * k; i += m) cout << p[i] << ' ';
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct query {
int a, b;
} q[105];
bool vis[105];
int n, cnt;
void dfs(int x) {
vis[x] = 1;
for (int i = 1; i <= cnt; i++) {
query y = q[i];
if (vis[i]) continue;
if ((y.a < q[x].a && q[x].a < y.b) || (y.a < q[x].b && q[x].b < y.b))
dfs(i);
}
}
int main() {
cin >> n;
while (n--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1) q[++cnt].a = x, q[cnt].b = y;
if (op == 2) {
for (int i = 1; i <= 100; i++) vis[i] = 0;
dfs(x);
if (vis[y])
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, curr, mins, total[128][8], l, r;
int solve(int curr, int floor) {
if (floor >= n) {
if (curr)
return total[floor][2];
else
return total[floor][0];
}
if (curr)
return min((total[floor][2] + solve(0, floor + 1)),
(total[floor][3] + solve(1, floor + 1)));
else
return min((total[floor][0] + solve(0, floor + 1)),
(total[floor][1] + solve(1, floor + 1)));
}
int main() {
char s[128];
scanf("%d%d", &n, &m);
m = m + 2;
for (int i = n; i > 0; i--) {
l = r = 0;
scanf(" %s", s);
for (int j = 0; j < strlen(s); j++) {
if (s[j] == '1') {
if (i == n || n == 1) {
total[i][0] = j + 1;
total[i][1] = j + 1;
if (n == 1) total[i][0]--, total[i][1]--;
} else if (i == 1) {
total[i][0] = 2 * j;
total[i][1] = strlen(s) - 1;
} else {
total[i][0] = 2 * j + 1;
total[i][1] = strlen(s);
}
}
if (s[strlen(s) - j - 1] == '1') {
if (i == n) {
total[i][2] = j + 1;
total[i][3] = j + 1;
} else {
total[i][2] = strlen(s);
total[i][3] = 2 * j + 1;
}
}
}
if (total[i][0] == 0) {
if (i == n)
n--;
else if (i != 1) {
total[i][0] = 1;
total[i][1] = strlen(s);
total[i][2] = strlen(s);
total[i][3] = 1;
}
}
}
printf("%d\n", solve(0, 1));
}
| 4 |
#include <bits/stdc++.h>
double f[5000 + 5][5000 + 5];
int p[5000 + 5], t[5000 + 5];
double ksm(double x, int y) {
double ans = 1.0;
for (int i = 0; i < y; i++) {
ans *= x;
}
return ans;
}
int main() {
int n, T;
scanf("%d%d", &n, &T);
for (int i = 0; i < n; i++) {
scanf("%d%d", &p[i], &t[i]);
}
double ans = 0.0, pp;
double r_1, r_2, now;
f[0][0] = 1.0;
for (int i = 0; i < n; i++) {
pp = p[i] / 100.0;
now = 0.0;
r_2 = ksm(1 - pp, t[i] - 1);
r_1 = r_2 * pp;
for (int j = 0; j < T; j++) {
now += (f[i][j] - now) * pp;
if (j + 1 >= t[i]) {
now -= f[i][j + 1 - t[i]] * r_1;
f[i + 1][j + 1] += now + f[i][j + 1 - t[i]] * r_2;
} else {
f[i + 1][j + 1] += now;
}
}
for (int j = 0; j <= T; j++) {
ans += f[i + 1][j];
}
}
printf("%.9lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
const int maxn = (1 << 20) + 7;
vector<pair<int, int> > ve[maxn];
long long sum;
int ans[maxn], a[maxn], book[maxn], g, h;
void dfs(int x) {
if (x * 2 > (1 << h) - 1) {
ve[x].push_back(make_pair(a[x], x));
return;
}
dfs(x * 2);
dfs(x * 2 + 1);
int st = 0, en = 0;
while (st < ((int)(ve[x * 2]).size()) && en < ((int)(ve[x * 2 + 1]).size())) {
if (ve[x * 2][st] < ve[x * 2 + 1][en])
ve[x].push_back(ve[x * 2][st]), st++;
else
ve[x].push_back(ve[x * 2 + 1][en]), en++;
}
while (st < ((int)(ve[x * 2]).size())) ve[x].push_back(ve[x * 2][st]), st++;
while (en < ((int)(ve[x * 2 + 1]).size()))
ve[x].push_back(ve[x * 2 + 1][en]), en++;
ve[x * 2].clear();
ve[x * 2 + 1].clear();
ve[x].push_back(make_pair(a[x], x));
if (x <= (1 << g) - 1) {
int v = max(ans[x * 2], ans[x * 2 + 1]);
pair<int, int> zz =
*upper_bound(ve[x].begin(), ve[x].end(), make_pair(v, (int)1e9));
ans[x] = zz.first;
book[zz.second] = 1;
sum += ans[x];
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d %d", &h, &g);
for (int i = (1); i <= ((1 << h) - 1); i++) scanf("%d", &a[i]);
dfs(1);
printf("%lld\n", sum);
int fla = 0;
for (int i = ((1 << h) - 1); i >= (1); i--) {
if (book[i] == 0) {
if (fla == 0)
printf("%d", i), fla = 1;
else
printf(" %d", i);
} else
book[i] = 0;
}
printf("\n");
for (int i = (1); i <= ((1 << h) - 1); i++) ans[i] = 0;
ve[1].clear();
sum = 0;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500005;
const long long mod = 1e9 + 7;
vector<long long> cnt(N);
void solve() {
long long x = 0, y = 0, c = 0, ans = 0;
long long n, m, k;
cin >> n >> k;
long long a[k + 1];
x = 1;
for (long long i = 1; i <= k; ++i) {
cin >> a[i];
c += a[i];
if (i > n - a[i] + 1) {
cout << -1 << "\n";
return;
;
}
}
if (c < n) {
cout << -1 << "\n";
return;
;
}
for (long long i = k + 1 - 1; i >= 1; i--) {
cnt[i] = cnt[i + 1] + a[i];
}
for (long long i = 1; i <= k; ++i) {
cout << max(i, n - cnt[i] + 1) << " ";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 9;
const int MAXN = 1e5 + 10;
const int p = 257;
const int q = 1e9 + 7;
multiset<int> H[MAXN];
vector<int> g[MAXN];
int n;
int cnt = 0;
map<multiset<int>, int> M;
int add(int a, int b) { return (a + b) % mod; }
int mul(long long a, long long b) { return a * b % mod; }
int hashing(const multiset<int> H) {
if (not M.count(H)) M[H] = cnt++;
return M[H];
}
void dfs(int x, int p) {
for (int v : g[x]) {
if (v == p) continue;
dfs(v, x);
H[x].insert(hashing(H[v]));
}
for (int i = H[x].size(); i < 4; ++i) {
H[x].insert(mod - 1);
}
}
set<int> Set;
void dfsRoot(int x, int p) {
if (p) {
multiset<int> aux = H[p];
aux.erase(aux.lower_bound(hashing(H[x])));
aux.insert(mod - 1);
H[x].erase(H[x].lower_bound(mod - 1));
H[x].insert(hashing(aux));
}
if (g[x].size() != 4) Set.insert(hashing(H[x]));
for (int v : g[x])
if (v != p) dfsRoot(v, x);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d %d", &u, &v);
g[u].emplace_back(v);
g[v].emplace_back(u);
}
dfs(1, 0);
dfsRoot(1, 0);
cout << Set.size() << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, q, res, now = 0, x, a, ta, b, tb;
char sal[6];
scanf("%d %d", &a, &ta);
scanf("%d %d", &b, &tb);
scanf("%5s", sal);
x = (sal[0] - '0') * 600;
now += x;
x = (sal[1] - '0') * 60;
now += x;
x = (sal[3] - '0') * 10;
now += x;
x = (sal[4] - '0');
now += x;
bool ada = false;
p = floor((now - 300 - tb + b) / b);
if (now + ta > 1439) {
now = 1439 - ta;
ada = true;
}
q = floor((now + ta - 300 + b) / b);
if ((now + ta - 300) % b == 0 && !ada) q--;
if (p < 0) p = 0;
if (q < 0) q = 0;
res = q - p;
if (res < 0) res = 0;
printf("%d\n", res);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[100001];
int visited[100001] = {0};
double sum = 0, c = 0;
void dfs(long long int p, float ans[]) {
int e = 0;
visited[p] = 1;
for (auto x : v[p]) {
if (!visited[x]) {
dfs(x, ans);
ans[p] += ans[x];
e = 1;
}
}
if (e == 1) {
if (p != 1 && v[p].size() > 1)
ans[p] = 1 + ans[p] / ((1.0) * (v[p].size() - 1));
else if (p == 1)
ans[p] = ans[p] / ((1.0) * (v[p].size()));
else
ans[p] = 1;
} else
ans[p] = 1;
}
int main() {
long long int n, x, y, i;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long int p = 1;
float ans[n + 1];
for (i = 0; i < n + 1; i++) ans[i] = 0;
if (n > 1) dfs(p, ans);
cout << fixed << setprecision(15) << ans[1];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e5 + 7;
int n, k, d;
vector<pair<int, int> > adj[MAX];
set<int> ans, v;
bool visited[MAX], used[MAX];
queue<pair<int, int> > q;
void func() {
for (auto j : v) {
q.push(make_pair(j, d));
visited[j] = true;
}
while (!q.empty()) {
pair<int, int> temp = q.front();
q.pop();
if (temp.second <= 0) continue;
for (auto j : adj[temp.first])
if (!visited[j.second]) {
visited[j.second] = true;
ans.erase(j.first);
q.push(make_pair(j.second, temp.second - 1));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
v.insert(x);
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(make_pair(i, v));
adj[v].push_back(make_pair(i, u));
ans.insert(i);
}
func();
cout << ans.size() << endl;
for (auto j : ans) cout << j << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct cmp {
bool operator()(pair<long long, long long> a, pair<long long, long long> b) {
return ((a.first - a.first / 2) * a.second) <
((b.first - b.first / 2) * b.second);
}
};
const long long N = 1e6 + 1;
const long long MOD = 1e9 + 7;
long long func(long long n) { return n * (n + 1) / 2; }
void Anon_mouS() {
long long n;
cin >> n;
vector<long long> v(101);
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v[x]++;
}
long long ans = 0, cnt = 0;
for (long long i = 0; i <= 100; i++) {
if (v[i] == 1 and cnt == 0) {
ans += i;
cnt++;
} else if (v[i] == 0) {
if (cnt == 1) {
ans += i;
break;
} else {
ans += 2 * i;
break;
}
}
}
cout << ans << '\n';
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long q = 1;
cin >> q;
for (long long it = 1; it <= q; it++) {
Anon_mouS();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
long long c = 0;
long long flag = 0;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
c++;
break;
}
}
if (c == 0) {
cout << 1 << endl;
cout << n << endl;
flag = 1;
}
if (flag == 0) {
long long x = n - 2;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
c++;
break;
}
}
if (c == 0) {
cout << 2 << endl;
cout << 2 << " " << x << endl;
flag = 1;
}
}
if (flag == 0) {
for (long long i = 3; i < n; i += 2) {
long long x = i, y = n - i - 3;
long long c = 0, d = 0, p, q;
for (long long j = 3; j * j <= x; j++) {
if (x % j == 0) {
c++;
break;
}
}
for (long long j = 3; j * j <= y; j++) {
if (y % j == 0) {
d++;
break;
}
}
if (c == 0 && d == 0) {
cout << 3 << endl;
cout << 3 << " " << i << " " << n - i - 3 << endl;
flag = 1;
break;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long mod = 1000000007;
const long double eps = 1e-14;
int i, j;
int n, m;
string s, t;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
cin >> s >> t;
int ans = INF;
vector<int> out;
for (int i = 0; i < t.size() - s.size() + 1; i++) {
string cmp = t.substr(i, s.size());
int cnt = 0;
vector<int> v;
v.clear();
for (int j = 0; j < s.size(); j++) {
if (s[j] != cmp[j]) {
cnt++;
v.push_back(j + 1);
}
}
if (cnt < ans) {
ans = cnt;
out = v;
}
}
cout << ans << endl;
for (int i = 0; i < out.size(); i++) cout << out[i] << ' ';
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
long double calc(string s) {
int p = 0, q = 0, o = 0, f = 0;
char w;
for (int i = 0; i < s.length(); i++) {
w = q & 1 ? 'R' : 'L';
if (s[i] == 'X')
q++;
else if (s[i] == w)
p++, q++, f = 0;
else
p++, q += 2, o += f, f = !f;
}
if (q & 1) q++, o += f;
if (p * 2 > q) p -= o, q -= o * 2;
return (long double)p / q;
}
int main() {
cin >> t;
s = "";
for (int i = 0; i < t.length(); i++) {
if (i && t[i] == t[i - 1] && t[i] != 'X') s += 'X';
s += t[i];
}
long double ans;
if (t[0] == t[t.size() - 1] && t[0] != 'X')
ans = max(calc('X' + s), calc(s + 'X'));
else
ans = calc(s);
ans = floor(ans * 1e8) / 1e8;
printf("%.6lf\n", (double)ans * 1e2);
return 0;
}
| 10 |
#include <bits/stdc++.h>
std::queue<std::pair<std::pair<int, int>, std::pair<int, int> > > ans;
std::pair<int, int> position[60];
std::pair<int, int> endPosition[60];
int n;
int taken[60][60] = {0}, ending[60][60] = {0};
void bfs(int i, int j) {
std::queue<std::pair<int, int> > q;
std::queue<std::string> qs;
bool visited[60][60] = {0};
q.push(std::make_pair(i, j));
qs.push("");
while (q.empty() == false) {
std::pair<int, int> top = q.front();
std::string str = qs.front();
q.pop();
qs.pop();
if (visited[top.first][top.second])
continue;
else
visited[top.first][top.second] = true;
if (taken[top.first][top.second]) {
int val = taken[top.first][top.second];
for (int i = str.length() - 1; i >= 0; --i) {
if (str[i] == 'U') {
std::swap(taken[top.first][top.second],
taken[top.first - 1][top.second]);
ans.push(std::make_pair(std::make_pair(top.first, top.second),
std::make_pair(top.first - 1, top.second)));
--top.first;
} else if (str[i] == 'L') {
std::swap(taken[top.first][top.second],
taken[top.first][top.second - 1]);
ans.push(std::make_pair(std::make_pair(top.first, top.second),
std::make_pair(top.first, top.second - 1)));
--top.second;
} else if (str[i] == 'R') {
std::swap(taken[top.first][top.second],
taken[top.first][top.second + 1]);
ans.push(std::make_pair(std::make_pair(top.first, top.second),
std::make_pair(top.first, top.second + 1)));
++top.second;
}
}
ans.push(std::make_pair(std::make_pair(top.first, top.second),
std::make_pair(top.first - 1, top.second)));
std::swap(taken[top.first][top.second], taken[top.first - 1][top.second]);
position[val].first = 1;
position[val].second = j;
return;
}
if (top.first != n) {
++top.first;
q.push(top);
qs.push(str + "U");
--top.first;
}
if (top.second != n) {
++top.second;
q.push(top);
qs.push(str + "L");
--top.second;
}
if (top.second != 1) {
--top.second;
q.push(top);
qs.push(str + "R");
++top.second;
}
}
}
int main() {
int m;
std::cin >> n >> m;
for (int i = 1; i <= m; ++i) {
std::cin >> position[i].first >> position[i].second;
taken[position[i].first][position[i].second] = i;
}
for (int i = 1; i <= m; ++i) {
std::cin >> endPosition[i].first >> endPosition[i].second;
ending[endPosition[i].first][endPosition[i].second] = i;
}
for (int k = n; k >= 1; --k) {
if (!taken[1][k]) {
bfs(2, k);
}
}
int cnt = n;
for (int j = 1; j <= n; ++j) {
for (int i = n; i >= 1; --i) {
if (ending[i][j]) {
int val = ending[i][j];
std::pair<int, int> start = position[ending[i][j]];
while (start.first != cnt) {
ans.push(std::make_pair(
start, std::make_pair(start.first + 1, start.second)));
std::swap(taken[start.first][start.second],
taken[start.first + 1][start.second]);
++start.first;
}
while (start.second != j) {
if (start.second < j) {
ans.push(std::make_pair(
start, std::make_pair(start.first, start.second + 1)));
std::swap(taken[start.first][start.second],
taken[start.first][start.second + 1]);
++start.second;
}
if (start.second > j) {
ans.push(std::make_pair(
start, std::make_pair(start.first, start.second - 1)));
std::swap(taken[start.first][start.second],
taken[start.first][start.second - 1]);
--start.second;
}
}
position[val].first = cnt;
position[val].second = j;
--cnt;
}
}
}
for (int j = 1; j <= n; ++j) {
for (int i = n; i >= 2; --i) {
int curi = i;
int curj = j;
while (1) {
if (taken[curi][curj] || !taken[curi - 1][curj] || curi > n) break;
int val = taken[curi - 1][curj];
ans.push(std::make_pair(std::make_pair(curi - 1, curj),
std::make_pair(curi, curj)));
std::swap(taken[curi][curj], taken[curi - 1][curj]);
position[val].first = curi;
position[val].second = curj;
++curi;
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (ending[i][j]) {
int val = ending[i][j];
std::pair<int, int> start = position[val];
while (start.first != i) {
if (start.first < i) {
ans.push(std::make_pair(
start, std::make_pair(start.first + 1, start.second)));
std::swap(taken[start.first][start.second],
taken[start.first + 1][start.second]);
++start.first;
}
if (start.first > i) {
ans.push(std::make_pair(
start, std::make_pair(start.first - 1, start.second)));
std::swap(taken[start.first][start.second],
taken[start.first - 1][start.second]);
--start.first;
}
}
}
}
}
std::cout << ans.size() << "\n";
while (ans.empty() == false) {
std::pair<std::pair<int, int>, std::pair<int, int> > p = ans.front();
ans.pop();
std::cout << p.first.first << " " << p.first.second << " " << p.second.first
<< " " << p.second.second << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> rc, lc;
set<long long> st;
int main() {
long long n, i, j, a, b, x, y, el;
cin >> n;
cin >> el;
st.insert(el);
auto it1 = st.begin(), it2 = st.begin();
for (i = 1; i < n; i++) {
cin >> el;
it1 = st.upper_bound(el);
--it1;
x = *it1;
it1++;
it2 = st.upper_bound(el);
y = *it2;
if (it2 != st.end() && !lc[y]) {
cout << y << " ";
lc[y] = 1;
} else {
cout << x << " ";
rc[x] = 1;
}
st.insert(el);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int str[5100];
int dp_pre[5100][5100];
int dp_nxt[5100][5100];
int main() {
int i, j, k;
int n, sum, ans;
int tmp, cnt;
while (cin >> n) {
for (i = 1; i <= n; i++) {
cin >> str[i];
}
memset(dp_pre, 0, sizeof(dp_pre));
memset(dp_nxt, 0, sizeof(dp_nxt));
sum = 0;
for (i = 1; i <= n; i++) {
for (j = i - 1; j >= 1; j--) {
if (str[j] > str[i])
dp_pre[i][j] = dp_pre[i][j + 1] + 1;
else
dp_pre[i][j] = dp_pre[i][j + 1];
}
for (j = i + 1; j <= n; j++) {
if (str[j] < str[i])
dp_nxt[i][j] = dp_nxt[i][j - 1] + 1;
else
dp_nxt[i][j] = dp_nxt[i][j - 1];
}
sum += dp_pre[i][1];
}
ans = 0, cnt = 0;
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
tmp = 2 * dp_nxt[i][j - 1] - (j - i - 1) + 2 * dp_pre[j][i + 1] -
(j - i - 1);
if (str[i] < str[j]) {
tmp--;
} else {
tmp++;
}
if (tmp > ans) {
ans = tmp;
cnt = 1;
} else if (tmp == ans) {
cnt++;
}
}
}
printf("%d %d\n", sum - ans, cnt);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long choose(long long n, long long k);
bool isprime(long long n);
void setprime(bool isprime[], long long n);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long count = 0;
for (long long i = s.size() - 1; i >= 0; i--) {
if (s[i] != '1' && s[i] != '4') {
cout << "NO";
return 0;
} else if (s[i] == '4') {
count++;
if (count > 2) {
cout << "NO";
return 0;
}
} else if (s[i] == '1')
count = 0;
}
if (count == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
long long choose(long long n, long long k) {
if (k == 0) return 1;
return (n * choose(n - 1, k - 1)) / k;
}
bool isprime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
void setprime(bool isprime[], long long n) {
for (long long i = 0; i < n; i++) isprime[i] = true;
isprime[0] = false;
isprime[1] = false;
for (long long i = 2; i < n; i++) {
for (long long j = 2; i * j < n; j++) isprime[i * j] = false;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
bool f;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
s += t;
}
scanf("%d", &m);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
if (y >= s) {
for (int i = s; i <= y; ++i) {
if (i >= x) {
printf("%d", i);
return 0;
}
}
}
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, c;
cin >> n >> k;
if (n == 1)
cout << 0;
else if (k <= n / 2)
cout << (((n - 1 + (n - k)) * k) / 2 + k * (n - 2 * k) + k * (k - 1) / 2);
else if (k > n / 2) {
c = k;
k = n / 2;
long long x =
(((n - 1 + (n - k)) * k) / 2 + k * (n - 2 * k) + k * (k - 1) / 2);
if ((c - k) % 2 == 0)
cout << x;
else
cout << x;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, c;
cin >> n;
int f = 0;
int a[101] = {0};
while (n--) {
cin >> c;
++a[c];
f = max(f, a[c]);
}
cout << f << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool pr[1000006];
vector<int> prime, v;
void seive() {
memset(pr, true, sizeof(pr));
pr[1] = pr[0] = false;
for (int i = 2; i < 1000006; i++) {
if (!pr[i]) continue;
prime.push_back(i);
for (int j = i * 2; j < 1000006; j += i) pr[j] = false;
}
}
int sz;
long long ans;
void first(int now, int cnt, long long val, long long y) {
if (val > y) return;
if (now == sz) {
if (cnt % 2)
ans -= (y / val);
else if (cnt)
ans += (y / val);
return;
}
first(now + 1, cnt, val, y);
first(now + 1, cnt + 1, val * v[now], y);
}
long long go(long long y) {
sz = v.size();
ans = y;
first(0, 0, 1, y);
return ans;
}
int main() {
int t, i, j, x, p, k;
seive();
scanf("%d", &t);
for (int cs = 1; cs <= t; cs++) {
v.clear();
scanf("%d", &x);
scanf("%d", &p);
scanf("%d", &k);
j = p;
for (i = 0; prime[i] * prime[i] <= p; i++) {
int cnt = 0;
while (p % prime[i] == 0) {
p /= prime[i];
cnt++;
}
if (cnt) v.push_back(prime[i]);
}
if (p != 1) v.push_back(p);
p = j;
long long val = go(x) + k;
long long lo = 0, hi = (long long)1e18;
while (hi - lo > 1) {
long long mid = (hi + lo) / 2;
if (go(mid) < val)
lo = mid;
else
hi = mid;
}
printf("%lld\n", hi);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define pb push_back
#define pii pair<int, int>
#define chmin(x, v) x = min(x, v)
#define chmax(x, v) x = max(x, v)
#define int long long
using namespace std;
const int N = 1e6 + 1;
signed main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t; cin >> t;
while (t--){
int nVals; cin >> nVals;
vector<int> vals(nVals);
vector<int> vraiTruc(nVals);
for (int& val : vals)
cin >> val;
int last1 = nVals;
for (int ind = nVals - 1; ind >= 0; --ind){
if (vals[ind] != 1)
last1 = ind;
vraiTruc[ind] = last1;
}
int nb = 0;
for (int ind = 0; ind < nVals; ++ind){
last1 = nVals;
for (int ind = nVals - 1; ind >= 0; --ind){
if (vals[ind] != 1)
last1 = ind;
vraiTruc[ind] = last1;
}
if (vals[ind] + ind >= nVals){
nb += vals[ind] - (nVals - ind);
vals[ind] = nVals - ind;
}
while (vals[ind] != 1){
/* cout << "wsh\n";
for (int& val : vals)
cout << val << " ";
cout << endl;*/
int noeud = ind;
++nb;
while (noeud < nVals){
int before = vals[noeud];
vals[noeud] = max(1ll, vals[noeud] - 1);;
noeud += before;
if (noeud < nVals)
noeud = vraiTruc[noeud];
}
}
}
cout << nb << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 2e9;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<int> a(n);
for (int &i : a) cin >> i;
sort(a.begin(), a.end());
vector<int> ans[2];
for (int i = 0; i < n; i++) ans[i & 1].push_back(a[i]);
reverse(ans[1].begin(), ans[1].end());
for (vector<int> &ansi : ans)
for (int &i : ansi) cout << i << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
const int N = 200005;
int main() {
string s;
cin >> s;
cout << s;
reverse(s.begin(), s.end());
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int dirX[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dirY[] = {-1, 0, 1, 0, 1, -1, -1, 1};
long long fact[1000001];
long long inv[1000001];
long long arr[1000007];
long long primes[100007];
long long modPower(long long b, long long p) {
if (p == 0) return 1;
long long halfpow = modPower(b, p / 2);
long long toReturn = (halfpow * halfpow) % mod;
if (p % 2) toReturn = (toReturn * b) % mod;
return toReturn;
}
long long fastPower(long long b, long long p) {
if (p == 0) return 1;
long long ans = fastPower(b, p / 2);
ans = (ans * ans);
if (p % 2 != 0) ans = (ans * b);
return ans;
}
long long GcdRecursive(long long a, long long b) {
if (b == 0) return a;
return GcdRecursive(b, a % b);
}
long long modLCM(long long a, long long b) {
long long val = GcdRecursive(a, b);
long long tmp = ((a % mod) * (b % mod)) % mod;
long long finalVal = ((tmp % mod) * (arr[val] % mod)) % mod;
return finalVal;
}
long long LCM(long long a, long long b) { return (a * b) / GcdRecursive(a, b); }
void move1step(long long& a, long long& b, long long q) {
long long c = a - q * b;
a = b;
b = c;
}
long long GcdIterative(long long a, long long b) {
while (b) move1step(a, b, a / b);
return a;
}
void pre(long long n) {
fact[0] = 1;
inv[0] = 1;
for (long long i = 1; i <= n; i++) {
fact[i] = (i * fact[i - 1]) % mod;
inv[i] = modPower(fact[i], mod - 2);
arr[i] = modPower(i, mod - 2);
}
}
long long npr(long long n, long long r) {
return ((fact[n] * inv[n - r]) % mod);
}
long long ncr(long long n, long long r) {
return ((((fact[n] * inv[n - r]) % mod) * inv[r]) % mod);
}
void sieve(long long val) {
memset(primes, 1, sizeof primes);
primes[0] = primes[1] = false;
for (int i = 2; i * i <= val; i++) {
if (primes[i]) {
for (int j = i * i; j <= val; j += i) {
primes[j] = 0;
}
}
}
}
set<long long> GetDivisors(long long val) {
set<long long> st;
for (long long i = 1; i < sqrt(val) + 1; i++)
if (val % i == 0) st.insert(i), st.insert(val / i);
return st;
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
bool isPrime(long long n) {
if (n <= 1) return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
string findSmallestLexoWithoutDupilcates(string s) {
int cnt[27];
bool vis[27];
for (int i = 0; i < s.size(); i++) cnt[s[i] - 'a']++;
string ans = "";
for (int i = 0; i < s.size(); i++) {
int x = s[i] - 'a';
cnt[x]--;
if (vis[x]) continue;
while (ans.size() > 0 && s[i] < ans.back() && cnt[ans.back() - 'a'] > 0) {
vis[ans.back() - 'a'] = false;
ans.pop_back();
}
ans.push_back(s[i]);
vis[x] = true;
}
return ans;
}
long double dot(complex<long double> a, complex<long double> b) {
return (conj(a) * b).real();
}
long double cross(complex<long double> a, complex<long double> b) {
return (conj(a) * b).imag();
}
long double angleBetVec(complex<long double> a, complex<long double> b) {
long double d = dot(a, b);
d /= abs(a);
d /= abs(b);
return acos(d) * 180 / acos(-1);
}
complex<long double> RotateAbout(complex<long double> a,
complex<long double> about,
long double angle) {
return (a - about) * polar((long double)1.0, angle) + about;
}
vector<int> topological_sort(const vector<vector<int>>& adj) {
int n = int(adj.size());
vector<int> in_degree(n, 0);
vector<int> order;
for (int i = 0; i < n; i++)
for (int neighbor : adj[i]) in_degree[neighbor]++;
for (int i = 0; i < n; i++)
if (in_degree[i] == 0) order.push_back(i);
int current = 0;
while (current < int(order.size())) {
int node = order[current++];
for (int neighbor : adj[node])
if (--in_degree[neighbor] == 0) order.push_back(neighbor);
}
return order;
}
const long long MOD = 998244353;
const long long N = 1e4 + 7;
const long long llinf = INT64_MAX;
const int intinf = INT32_MAX;
struct sec {
int l, r, t, c;
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<sec> v(m);
for (long long i = 0; i < m; i++) cin >> v[i].l >> v[i].r >> v[i].t >> v[i].c;
vector<int> sec(n + 1, 0);
int ctr = 0;
for (long long i = 1; i < n + 1; i++) {
int mx = intinf, win = 0;
for (auto e : v) {
if (e.l <= i && e.r >= i) {
if (e.t < mx) {
mx = e.t;
win = e.c;
}
}
}
ctr += win;
}
cout << ctr;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[17][17][17];
int high_bit(int x) {
for (int i = 3; i >= 0; i--)
if ((1 << i) & x) return i + 1;
return 0;
}
int get_value(char c) {
if ('0' <= c && c <= '9') return c - '0';
return c - 'a' + 10;
}
long long get(string n) {
long long ans = 0;
for (int l = 1; l < n.size(); l++)
for (int t = 1; t < 16; t++)
for (int k = 0; k < 17; k++) {
int sm = max(k, t + 1);
int fh = sm;
if ((l - 1) * 4 > fh - 1) {
} else if ((l - 1) * 4 + 4 > fh - 1) {
if (!(t & (1 << ((fh - 1) & 3)))) continue;
fh = 0;
}
ans += dp[l - 1][fh][k];
}
int second_max = 0;
for (int i = 0; i < n.size(); i++) {
int value = get_value(n[i]);
int first = 0;
if (i == 0) first = 1;
for (int t = first; t < value; t++)
for (int k = 0; k < 17; k++) {
int sm = max(second_max, k);
sm = max(sm, t + 1);
int fh = sm;
if (((int)n.size() - i - 1) * 4 > fh - 1) {
} else if (((int)n.size() - i - 1) * 4 + 4 > fh - 1) {
if (!(t & (1 << ((fh - 1) & 3)))) continue;
fh = 0;
} else {
if ((int)n.size() - 1 - (fh - 1) / 4 < 0 ||
!(get_value(n[n.size() - 1 - (fh - 1) / 4]) &
(1 << ((fh - 1) & 3))))
continue;
fh = 0;
}
ans += dp[n.size() - i - 1][fh][k];
}
second_max = max(second_max, value + 1);
}
return ans;
}
string add(string n) {
int idx = n.size() - 1;
while (idx >= 0 && n[idx] == 'f') {
n[idx] = '0';
idx--;
}
if (idx < 0) return "1" + n;
if (n[idx] == '9')
n[idx] = 'a';
else
n[idx] += 1;
return n;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
dp[0][0][0] = 1;
for (int l = 1; l < 17; l++)
for (int dig = 0; dig < 16; dig++)
for (int first_has = 0; first_has < 17; first_has++)
for (int second_max = 0; second_max < 17; second_max++) {
int nf = first_has;
if (first_has != 0 && 4 * (l - 1) <= first_has - 1 &&
first_has - 1 < 4 * l) {
if (!(dig & (1 << ((first_has - 1) & 3)))) continue;
nf = 0;
}
dp[l][first_has][max(dig + 1, second_max)] +=
dp[l - 1][nf][second_max];
}
int q;
cin >> q;
while (q--) {
string l, r;
cin >> l >> r;
cout << get(add(r)) - get(l) << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> s;
n = s.length();
sort(s.begin(), s.end());
for (int i = (n / 2); i < n; i++) {
cout << s[i];
if (i < n - 1) cout << '+';
}
return 0;
}
| 0 |
#include <iostream>
#include <cstring>
namespace wxy{
const int N = 105;
double f[N][10005];
int a[N],b[N];
void main(){
int n;std::cin >> n;
for (int i = 1; i <= n; i++) std::cin >> a[i] >> b[i];
for (int j = 0; j <= 100; j++){
for (int k = 0; k <= 10000; k++) f[j][k] = -10000;
}
f[0][0] = 0;
double sum = 0;
for (int i = 1; i <= n; i++) sum += b[i];
for (int i = 1; i <= n; i++)
for (int j = i; j >= 1; j--)
for (int k = 10000; k >= a[i]; k--)
f[j][k] = std::max(f[j][k],f[j - 1][k - a[i]] + b[i]);
for (int i = 1; i <= n; i++){
double ans = 0;
for (int j = 1; j <= 10000; j++){
double k = j;
ans = std::max(ans,std::min(k,(sum + f[i][j]) / 2));
}
std::cout << ans << " ";
}
}
}signed main(){wxy::main();return 0;}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Treap {
struct node {
int v, sz, pri, rev;
node *l, *r;
node(int v) : v(v), sz(1), pri(rand()), rev(0), l(0), r(0) {}
} * root;
int size(node* x) { return x == NULL ? 0 : x->sz; }
void pull(node* x) {
if (x) x->sz = size(x->l) + size(x->r) + 1;
}
void push(node* x) {
if (x && x->rev == 1) {
swap(x->l, x->r);
if (x->l) x->l->rev ^= 1;
if (x->r) x->r->rev ^= 1;
x->rev = 0;
}
}
node* merge(node* l, node* r) {
if (!l)
return r;
else if (!r)
return l;
else if (l->pri < r->pri) {
push(r);
push(l);
r->l = merge(l, r->l);
pull(r);
pull(l);
return r;
} else {
push(r);
push(l);
l->r = merge(l->r, r);
pull(l);
pull(r);
return l;
}
}
void split(node* cur, int k, node*& l, node*& r) {
push(cur);
if (cur == NULL)
l = r = 0;
else if (size(cur->l) + 1 <= k) {
l = cur;
split(cur->r, k - size(cur->l) - 1, l->r, r);
pull(l);
} else {
r = cur;
split(cur->l, k, l, r->l);
pull(r);
}
}
void insert(int p, int d) {
node *l, *r;
split(root, p, l, r);
l = merge(l, new node(d));
root = merge(l, r);
}
void reverse(int l, int r) {
node *ll, *rr, *lr, *tmp;
split(root, l, ll, tmp);
split(tmp, r - l + 1, lr, rr);
lr->rev ^= 1;
root = merge(ll, lr);
root = merge(root, rr);
}
void cyclic(int l, int r) {
node *ll, *hl, *lr, *rr;
split(root, l, ll, rr);
split(rr, r - l + 1, lr, rr);
split(lr, r - l, hl, lr);
root = merge(lr, hl);
root = merge(ll, root);
root = merge(root, rr);
}
int query(int p) {
node *l, *r, *t;
split(root, p, l, r);
split(r, 1, t, r);
int ans = t->v;
root = merge(l, t);
root = merge(root, r);
return ans;
}
void getAll(node* rt, vector<int>& a) {
if (rt) {
push(rt);
getAll(rt->l, a);
a.push_back(rt->v);
getAll(rt->r, a);
}
}
} tr;
int main() {
int n, m, q;
scanf("%d %d %d", &n, &q, &m);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
tr.insert(i, x);
}
for (int i = 0; i < q; i++) {
int t, l, r;
scanf("%d %d %d", &t, &l, &r);
l--;
r--;
if (t == 1)
tr.cyclic(l, r);
else
tr.reverse(l, r);
}
vector<int> a;
tr.getAll(tr.root, a);
for (int i = 0; i < m; i++) {
int p;
scanf("%d", &p);
p--;
printf(i == m - 1 ? "%d\n" : "%d ", a[p]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int main() {
int n, i, rest, rest1;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
char ch[n];
rest = 0;
if (a[0] == 0) {
ch[0] = 'r';
rest++;
} else if (a[0] == 1) {
ch[0] = 'c';
} else if (a[0] == 2) {
ch[0] = 'g';
} else {
ch[0] = 'c';
}
for (i = 1; i < n; i++) {
if (a[i] == 0) {
ch[i] = 'r';
rest++;
} else if (a[i] == 1) {
if (ch[i - 1] == 'c') {
ch[i] = 'r';
rest++;
} else {
ch[i] = 'c';
}
} else if (a[i] == 2) {
if (ch[i - 1] == 'g') {
ch[i] = 'r';
rest++;
} else {
ch[i] = 'g';
}
} else {
if (ch[i - 1] == 'c') {
ch[i] = 'g';
} else if (ch[i - 1] == 'g') {
ch[i] = 'c';
}
}
}
rest1 = rest;
if (a[0] == 3) {
rest = 0;
ch[0] = 'g';
for (i = 1; i < n; i++) {
if (a[i] == 0) {
ch[i] = 'r';
rest++;
} else if (a[i] == 1) {
if (ch[i - 1] == 'c') {
ch[i] = 'r';
rest++;
} else {
ch[i] = 'c';
}
} else if (a[i] == 2) {
if (ch[i - 1] == 'g') {
ch[i] = 'r';
rest++;
} else {
ch[i] = 'g';
}
} else {
if (ch[i - 1] == 'c') {
ch[i] = 'g';
} else if (ch[i - 1] == 'g') {
ch[i] = 'c';
}
}
}
}
rest1 = min(rest, rest1);
cout << rest1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int roundInPos(string& s, int pos) {
bool inc = (('0' <= (s[pos]) && (s[pos]) <= '9') && s[pos] >= '5');
int resTo = pos;
bool beforePoint = true;
int res = pos - 1;
for (int i = pos - 1; inc && i >= 0; --i) {
if (s[i] == '.') {
beforePoint = false;
continue;
}
inc = false;
if (beforePoint) res = i;
if (s[i] <= '8')
s[i]++;
else {
inc = true;
s[i] = '0';
if (beforePoint) resTo = i;
}
}
s.resize(resTo);
if (inc) {
s = '1' + s;
++res;
}
return res;
}
void tryIncrease(string& s, int cnt) {
int lstPos = s.find('.') + 1;
int i;
for (int j = 0; j < cnt; ++j) {
for (i = lstPos; i < (int)s.size() && s[i] < '5'; ++i)
;
if (i == (int)s.size() || s[i] == '.') return;
lstPos = roundInPos(s, i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, t;
string num;
cin >> n >> t;
cin >> num;
tryIncrease(num, t);
if (num.back() == '.') num.resize(num.size() - 1);
cout << num << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int c[100];
string s;
int main() {
cin >> c[4] >> c[7] >> c[47] >> c[74];
if (max(c[47], c[74]) > max(c[4], c[7]) || abs(c[47] - c[74]) > 1) {
cout << "-1" << endl;
return 0;
}
if (c[74] > c[47]) {
while (c[74]--) {
s += "74";
c[4]--;
c[7]--;
}
} else if (c[74] < c[47]) {
while (c[47]--) {
s += "47";
c[4]--;
c[7]--;
}
} else {
if (c[4] - c[47] > 0) {
while (c[47]--) {
s += "47";
c[4]--;
c[7]--;
}
s += "4";
c[4]--;
} else {
while (c[74]--) {
s += "74";
c[4]--;
c[7]--;
}
s += "7";
c[7]--;
}
}
if (c[4] < 0 || c[7] < 0) {
cout << "-1" << endl;
return 0;
}
int last7 = -1, last4 = -1;
for (int i = 0; i < s.length(); i++)
if (s[i] == '7')
last7 = i;
else
last4 = i;
if (last4 == -1 && c[4] > 0) {
cout << "-1" << endl;
return 0;
}
if (last7 == -1 && c[7] > 0) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < s.length(); i++) {
cout << s[i];
if (s[i] == '4')
while (0 < c[4]--) cout << s[i];
else if (i == last7)
while (0 < c[7]--) cout << s[i];
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int x;
int n, m;
stack<int> s;
stack<int> ind;
bool rec(int x) {
if (s.empty()) {
cout << "NO";
exit(0);
}
int y = s.top();
if (y == -x) {
s.pop();
ind.pop();
return 1;
}
int d = ind.top();
a[d] = -a[d];
ind.pop();
s.pop();
bool fl = 0;
while (!fl) {
fl = rec(-y);
}
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
a.push_back(x);
}
cin >> m;
for (int i = 0; i < m; i++) {
scanf("%d", &x);
x--;
a[x] = -a[x];
}
if (n % 2 == 1) {
cout << "NO";
return 0;
}
for (int i = 0; i < n; i++) {
x = a[i];
if (x < 0) {
bool ok = 0;
while (!ok) ok = rec(x);
} else {
s.push(x);
ind.push(i);
}
}
while (!s.empty()) {
x = s.top();
s.pop();
int y = ind.top();
a[y] = -a[y];
ind.pop();
bool ok = 0;
while (!ok) ok = rec(-x);
}
cout << "YES\n";
for (int i = 0; i < n; i++) printf("%d ", a[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int c[105][105], n, m, K;
long long f[2][105][105][105];
int main() {
for (int i = 0; i <= 100; i++) c[i][0] = 1;
for (int i = 1; i <= 100; i++)
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
c[i][j] = min(c[i][j], 100 + 1);
}
scanf("%d%d%d", &n, &m, &K);
n++;
f[0][0][1][1] = 1;
long long ans = 0;
for (int i = 0; i <= m; i++) {
if (i) {
long long ret = 0;
for (int j = 2; j <= n; j++)
for (int k = 1; k <= K; k++)
ret = (ret + f[i & 1][j][0][k]) % 1000000007;
ans = (ans + ret * (m - i + 1) % 1000000007) % 1000000007;
}
memset(f[(i + 1) & 1], 0, sizeof f[(i + 1) & 1]);
for (int j = 0; j <= n; j++)
for (int k = 1; k <= n; k++)
for (int l = 1; l <= K; l++)
if (f[i & 1][j][k][l])
for (int t = k; j + t <= n; t++)
if (l * c[t - 1][k - 1] <= K)
(f[(i + 1) & 1][j + t][t - k][l * c[t - 1][k - 1]] +=
f[i & 1][j][k][l]) %= 1000000007;
}
printf("%lld", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5) + 10, mod = int(1e9) + 7;
int n, m, k;
vector<pair<int, pair<int, int> > > g[3 * N], rb[3 * N];
long long ans[N];
bool ux[3][2 * N][3], uy[3][2 * N][3];
void used(int x, int y, int z) {
if (x == 0) ux[0][y][z] = 1;
if (x == n) ux[1][y][z] = 1;
if (y == 0) uy[0][x][z] = 1;
if (y == m) uy[1][x][z] = 1;
}
bool check(int x, int y, int z) {
if (x == 0 && ux[0][y][z]) return 1;
if (x == n && ux[1][y][z]) return 1;
if (y == 0 && uy[0][x][z]) return 1;
if (y == m && uy[1][x][z]) return 1;
return 0;
}
long long T;
void dfs(int x, int y, int z) {
used(x, y, z);
if (z == 0) {
for (int i = 0; i < rb[x - y + N].size(); i++) {
int id = rb[x - y + N][i].first;
if (ans[id] == -1) ans[id] = T + abs(x - rb[x - y + N][i].second.first);
}
if (x == 0 || y == 0) {
int cur = min(n - x, m - y);
T += cur;
if (!check(x + cur, y + cur, 1 - z)) dfs(x + cur, y + cur, 1 - z);
} else {
int cur = min(x, y);
T += cur;
if (!check(x - cur, y - cur, 1 - z)) dfs(x - cur, y - cur, 1 - z);
}
} else {
for (int i = 0; i < g[x + y].size(); i++) {
int id = g[x + y][i].first;
if (ans[id] == -1) ans[id] = T + abs(x - g[x + y][i].second.first);
}
if (x == n || y == 0) {
int cur = min(x, m - y);
T += cur;
if (!check(x - cur, y + cur, 1 - z)) dfs(x - cur, y + cur, 1 - z);
} else {
int cur = min(n - x, y);
T += cur;
if (!check(x + cur, y - cur, 1 - z)) dfs(x + cur, y - cur, 1 - z);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, x, y; i <= k; i++) {
scanf("%d%d", &x, &y);
ans[i] = -1;
g[x + y].push_back(make_pair(i, make_pair(x, y)));
rb[x - y + N].push_back(make_pair(i, make_pair(x, y)));
}
used(0, 0, 0);
used(0, m, 0);
used(n, 0, 0);
used(n, m, 0);
used(0, 0, 1);
used(0, m, 1);
used(n, 0, 1);
used(n, m, 1);
dfs(0, 0, 0);
for (int i = 1; i <= k; i++) {
printf("%I64d\n", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(), cout.tie();
long long n, k;
cin >> n >> k;
long long a[n];
map<long long, long long> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
sort(a, a + n);
int i = 0, j = n - 1;
long long mini = a[0], maxi = a[n - 1];
while (k && i < j) {
while (i + 1 < n && a[i] == a[i + 1]) i++;
while (j - 1 >= 0 && a[j] == a[j - 1]) j--;
if (i < j) {
long long x = mp[a[i]], y = mp[a[j]];
if (x < y) {
long long d = a[i + 1] - a[i];
long long mn = min(k / x, d);
if ((a[i] + mn) == a[i + 1]) {
mp[a[i + 1]] += mp[a[i]];
k -= (mn * mp[a[i]]);
mini = a[i + 1];
i++;
} else {
mini = a[i] + mn;
break;
}
} else {
long long d = a[j] - a[j - 1];
long long mn = min(k / y, d);
if ((a[j] - mn) == a[j - 1]) {
mp[a[j - 1]] += mp[a[j]];
k -= (mn * mp[a[j]]);
maxi = a[j - 1];
j--;
} else {
maxi = a[j] - mn;
break;
}
}
} else {
mini = a[i], maxi = a[i];
}
}
cout << maxi - mini << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1004;
const int SQUARE = 1;
const int LINE = 2;
const int ERASE = 0;
const int NONE = -1;
long long n, a, b, c;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> a >> b >> c;
long long res = 0;
if (b - c < a && n >= b) {
res += (n - b) / (b - c);
n -= (n - b) / (b - c) * (b - c);
}
while (b - c <= a && n >= b) {
res += 1;
n -= b;
n += c;
}
res += n / a;
n -= n / a * a;
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int inf = 0x3f3f3f3f;
long long linf = 0x3f3f3f3f3f3f3f3f;
int popcnt(int a) { return __builtin_popcount(a); }
int popcnt(long long a) { return __builtin_popcountll(a); }
int msb(int a) { return 32 - __builtin_clz(a); }
int msb(long long a) { return 64 - __builtin_clzll(a); }
int lsb(int a) { return __builtin_ctz(a); }
int lsb(long long a) { return __builtin_ctzll(a); }
template <typename T, typename U>
T ipow(T a, U e) {
T b = 1;
while (e) {
if (e & 1) b *= a;
a *= a;
e >>= 1;
}
return b;
}
template <typename T>
void tobin(T v, int len = sizeof(T) * CHAR_BIT) {
while (--len >= 0) putchar("10"[!(v & (1 << len))]);
}
template <class InputIterator>
void prnt(InputIterator first, InputIterator last, char delim = ' ') {
for (auto it = first; it != last; it++) cout << *it << delim;
puts("");
}
template <typename T>
struct range_it : std::iterator<random_access_iterator_tag, T> {
T v;
range_it(T _v) : v(_v) {}
operator T&() { return v; }
T operator*() const { return v; }
};
template <typename T>
struct range {
T b, e, s;
range(T _e) : b(0), e(_e), s(1){};
range(T _b, T _e, T _s = 1) : b(_b), e(_e), s(_s) {}
range_it<T> begin() { return b; };
range_it<T> end() { return e; }
range_it<T> rbegin() { return e - 1; };
range_it<T> rend() { return b - 1; }
};
template <typename T>
struct range<T> lr(T b, T e, T s = 1) {
return range<T>(b + 1, e, s);
} template <typename T>
struct range<T> lR(T b, T e, T s = 1) {
return range<T>(b + 1, e + 1, s);
} template <typename T>
struct range<T> Lr(T b, T e, T s = 1) {
return range<T>(b, e, s);
} template <typename T>
struct range<T> LR(T b, T e, T s = 1) {
return range<T>(b, e + 1, s);
} template <typename T>
struct range<T> Lr(T e) {
return range<T>(e);
} template <typename T>
struct range<T> LR(T e) {
return range<T>(e + 1);
} int main() {
int qq;
scanf("%d", &qq);
while (qq--) {
string s;
cin >> s;
vector<int> a((int)s.size() + 1);
int n = (int)s.size();
a[0] = s[0] == '+' ? 1 : -1;
for (int i = 1; i < (int)s.size(); i++) {
a[i] = a[i - 1] + (s[i] == '+' ? 1 : -1);
}
int mn = 0;
for (int i = 0; i < n; i++) {
a[i] = mn = min(mn, a[i]);
}
int cr = -a[n - 1] + 1;
long long sm = 0;
for (int i = 0; i < n; i++) {
int t = i > 0 ? (a[i] < a[i - 1]) : a[i] < 0;
sm += cr;
cr -= t;
}
cout << sm << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void fen_update(vector<int> &tree, int i, int val) {
for (int k = i; k > 0 && k < tree.size(); k += (k & -k)) tree[k] += val;
}
inline int fen_query(vector<int> &tree, int i) {
int sum = 0;
for (int k = i; k > 0; k &= k - 1) sum += tree[k];
return sum;
}
int main(int argc, char *argv[]) {
int n;
cin >> n;
vector<int> a(n);
vector<pair<int, int> > t;
for (int i = 0; i < n; i++) cin >> a[i], t.push_back(make_pair(a[i], i));
sort(t.begin(), t.end());
for (int i = 0, j = 0; i < n; i++) {
if (i > 0 && t[i].first != t[i - 1].first) j++;
a[t[i].second] = j + 1;
}
vector<int> fen1(n + 1), fen2(n + 1);
for (int i = 0; i < n; i++)
for (int k = a[i]; k <= n; k += (k & -k)) fen2[k]++;
long long ans = 0;
for (int i = 0; i < n; i++) {
fen_update(fen2, a[i], -1);
long long c1 = fen_query(fen1, n) - fen_query(fen1, a[i]);
long long c2 = fen_query(fen2, a[i] - 1);
ans += c1 * c2;
fen_update(fen1, a[i], 1);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long la, ra, lb, rb, ta, tb;
cin >> la >> ra >> ta;
cin >> lb >> rb >> tb;
long long val1 = abs(la - lb);
long long x = gcd(ta, tb);
long long val2 = abs(ra - rb);
if (val1 % x == 0 || val2 % x == 0) {
cout << (ra - la + 1 < rb - lb + 1 ? ra - la + 1 : rb - lb + 1);
return 0;
}
long long maxim = 0;
long long u = val1 / x;
long long c = (val1 - u * x);
if (la <= lb) {
long long l = la + c;
long long r = l + (rb - lb);
maxim = (maxim > (r < ra ? r : ra) - (la > l ? la : l) + 1
? maxim
: (r < ra ? r : ra) - (la > l ? la : l) + 1);
c = (u + 1) * x - val1;
l = lb + c;
r = l + (ra - la);
maxim = (maxim > (r < rb ? r : rb) - (l > lb ? l : lb) + 1
? maxim
: (r < rb ? r : rb) - (l > lb ? l : lb) + 1);
} else {
long long l = lb + c;
long long r = l + (ra - la);
maxim = (maxim > (r < rb ? r : rb) - (lb > l ? lb : l) + 1
? maxim
: (r < rb ? r : rb) - (lb > l ? lb : l) + 1);
c = (u + 1) * x - val1;
l = la + c;
r = l + (rb - lb);
maxim = (maxim > (r < ra ? r : ra) - (la > l ? la : l) + 1
? maxim
: (r < ra ? r : ra) - (la > l ? la : l) + 1);
}
if (ra <= rb) {
u = val2 / x;
c = (val2 - u * x);
long long l, r;
r = ra + c;
l = r - (rb - lb);
maxim = (maxim > (ra < r ? ra : r) - (l > la ? l : la) + 1
? maxim
: (ra < r ? ra : r) - (l > la ? l : la) + 1);
c = ((u + 1) * x - val2);
r = rb + c;
l = r - (ra - la);
maxim = (maxim > (rb < r ? rb : r) - (l > lb ? l : lb) + 1
? maxim
: (rb < r ? rb : r) - (l > lb ? l : lb) + 1);
} else {
u = val2 / x;
c = (val2 - u * x);
long long l, r;
r = rb + c;
l = r - (ra - la);
maxim = (maxim > (rb < r ? rb : r) - (l > lb ? l : lb) + 1
? maxim
: (rb < r ? rb : r) - (l > lb ? l : lb) + 1);
c = ((u + 1) * x - val2);
r = ra + c;
l = r - (rb - lb);
maxim = (maxim > (ra < r ? ra : r) - (l > la ? l : la) + 1
? maxim
: (ra < r ? ra : r) - (l > la ? l : la) + 1);
}
cout << maxim;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, px, py;
double dist(long long px, long long py, long long x1, long long y1,
long long x2, long long y2) {
double d2 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
if (d2 == 0.0) return ((x1 - px) * (x1 - px) + (y1 - py) * (y1 - py));
double t = ((double)((px - x1) * (x2 - x1) + (py - y1) * (y2 - y1))) / d2;
if (t < 0.0)
return ((px - x1) * (px - x1) + (py - y1) * (py - y1));
else if (t > 1.0)
return ((px - x2) * (px - x2) + (py - y2) * (py - y2));
double nx = x1 + t * (x2 - x1);
double ny = y1 + t * (y2 - y1);
return ((nx - px) * (nx - px) + (ny - py) * (ny - py));
}
int main() {
const double PI = atan(1.0) * 4;
cin >> n >> px >> py;
vector<long long> d(n);
vector<double> d2(n);
vector<double> cs(0), xs(n), ys(n);
double x1, x2, y1, y2;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
xs[i] = x;
ys[i] = y;
d[i] = (x - px) * (x - px) + (y - py) * (y - py);
}
for (int i = 0; i < n; i++) {
x1 = xs[i];
x2 = xs[(i + 1) % n];
y1 = ys[i];
y2 = ys[(i + 1) % n];
double dd = dist(px, py, x1, y1, x2, y2);
d2[i] = dd;
}
double maxd = max_element(d.begin(), d.end()) - d.begin();
double mind = min_element(d2.begin(), d2.end()) - d2.begin();
double res;
res = PI * (d[maxd] - d2[mind]);
cout.precision(20);
cout << res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
inline bool upmin(T& a, const S& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T& a, const S& b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
inline void gn(long long& x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int& x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long& x) {
long long t;
gn(t);
x = t;
}
inline void gn(double& x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double& x) {
double t;
scanf("%lf", &t);
x = t;
}
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
int mo = 1000000007;
int qp(int a, long long b) {
int n = 1;
do {
if (b & 1) n = 1ll * n * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return n;
}
int n;
pair<int, int> p[444444];
map<int, int> mx, my;
int xtot = 0, ytot = 0;
int ui[444444], vi[444444];
int del[444444] = {0};
namespace tree {
const int TREE_MAXV = 400000 + 5;
struct edge {
int v, next, id;
} e[TREE_MAXV * 2];
int g[TREE_MAXV], etot;
int qu[TREE_MAXV], pre[TREE_MAXV], vis[TREE_MAXV], upe[TREE_MAXV];
int n;
int deg[TREE_MAXV];
void ae(int u, int v, int id) {
deg[u]++;
deg[v]++;
e[etot].v = v;
e[etot].id = id;
e[etot].next = g[u];
g[u] = etot++;
e[etot].v = u;
e[etot].id = id;
e[etot].next = g[v];
g[v] = etot++;
}
void bfs(int rt) {
int p = 0, q = 0;
pre[rt] = 0;
vis[rt] = 1;
qu[q++] = rt;
while (p != q) {
int u = qu[p++];
for (int i = g[u]; ~i; i = e[i].next)
if (!vis[e[i].v]) {
pre[e[i].v] = u;
vis[e[i].v] = 1;
upe[e[i].v] = e[i].id;
qu[q++] = e[i].v;
}
}
for (int i = (q)-1, _ed = (1); i >= _ed; i--) {
int u = qu[i];
if (deg[u] & 1) {
deg[u]--;
deg[pre[u]]--;
del[upe[u]] = 1;
}
}
}
void tree_init() {
static bool ini = 0;
if (!ini) {
ini = 1;
memset(g, -1, sizeof(g));
} else {
for (int i = 0; i <= n; i++) g[i] = -1;
}
memset((vis), (0), sizeof(vis));
memset((deg), (0), sizeof(deg));
etot = 0;
}
}; // namespace tree
int ans[555555];
namespace tr {
const int TREE_MAXV = 400000 + 5;
struct edge {
int v, id, next;
} e[TREE_MAXV * 2];
int g[TREE_MAXV], etot;
int qu[TREE_MAXV], pre[TREE_MAXV], vis[444444];
int cur[444444];
int n;
void ae(int u, int v, int id) {
e[etot].v = v;
e[etot].id = id;
e[etot].next = g[u];
g[u] = etot++;
}
void bfs(int rt) {
int p = 0, q = 0;
pre[rt] = 0;
qu[q++] = rt;
vis[rt] = 1;
while (p != q) {
int u = qu[p++];
for (int i = g[u]; ~i; i = e[i].next)
if (e[i].v != pre[u]) {
ans[e[i].id] = cur[u];
cur[u] ^= 1;
pre[e[i].v] = u;
cur[e[i].v] = cur[u];
vis[e[i].v] = 1;
qu[q++] = e[i].v;
}
}
}
void tree_init() {
static bool ini = 0;
if (!ini) {
ini = 1;
memset(g, -1, sizeof(g));
} else {
for (int i = 0; i <= n; i++) g[i] = -1;
}
etot = 0;
memset((vis), (0), sizeof(vis));
}
} // namespace tr
namespace eu {
struct edge {
int v, id, vis, next;
} e[888888];
int g[444444], etot;
int vis[444444];
int ans[1000005];
int anslen = 0;
int stk[888888], ine[888888];
void ae(int u, int v, int id) {
e[etot].v = v;
e[etot].id = id;
e[etot].next = g[u];
g[u] = etot++;
e[etot].v = u;
e[etot].id = id;
e[etot].next = g[v];
g[v] = etot++;
}
void dfs(int rt) {
int top = 0;
stk[++top] = rt;
ine[top] = -1;
vis[rt] = 1;
while (top) {
int u = stk[top];
vis[u] = 1;
while (~g[u] && (e[g[u]].vis || e[g[u] ^ 1].vis)) g[u] = e[g[u]].next;
if (~g[u]) {
e[g[u]].vis = e[g[u] ^ 1].vis = 1;
int v = e[g[u]].v;
ine[top + 1] = e[g[u]].id;
g[u] = e[g[u]].next;
stk[++top] = v;
} else {
if (~ine[top]) {
ans[++anslen] = ine[top];
}
top--;
}
}
}
void ini() {
memset((g), (-1), sizeof(g));
etot = 0;
}
}; // namespace eu
int main() {
gn(n);
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
gn(p[i].first);
gn(p[i].second);
mx[p[i].first];
my[p[i].second];
}
for (__typeof((mx).begin()) it = (mx).begin(); it != (mx).end(); it++) {
it->second = ++xtot;
}
for (__typeof((my).begin()) it = (my).begin(); it != (my).end(); it++) {
it->second = ++ytot;
}
tree::tree_init();
tree::n = xtot + ytot;
for (int i = (1), _ed = (n + 1); i < _ed; i++)
tree::ae(ui[i] = mx[p[i].first], vi[i] = my[p[i].second] + xtot, i);
for (int i = (1), _ed = (xtot + ytot + 1); i < _ed; i++)
if (!tree::vis[i]) tree::bfs(i);
tr::tree_init();
for (int i = (1), _ed = (n + 1); i < _ed; i++)
if (del[i]) {
tr::ae(ui[i], vi[i], i);
tr::ae(vi[i], ui[i], i);
}
for (int i = (1), _ed = (xtot + ytot + 1); i < _ed; i++)
if (!tr::vis[i]) tr::bfs(i);
eu::ini();
for (int i = (1), _ed = (n + 1); i < _ed; i++)
if (!del[i]) {
eu::ae(ui[i], vi[i], i);
}
for (int i = (1), _ed = (xtot + ytot + 1); i < _ed; i++)
if (!eu::vis[i]) {
eu::dfs(i);
for (int j = (1), _ed = (eu::anslen + 1); j < _ed; j++)
ans[eu::ans[j]] = j & 1;
}
for (int i = (1), _ed = (n + 1); i < _ed; i++) putchar(ans[i] ? 'r' : 'b');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 0.00001;
const int INF = 1000000007;
const long long LINF = 1000000000000000555;
const int N = 2550555;
const int M = 1125;
int a[N];
int pref[N];
void solve() {
int n, k, z;
cin >> n >> k >> z;
for (int i = 1; i <= 2 * n; i++) {
pref[i] = 0;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
pref[i] = pref[i - 1] + a[i];
}
int k0 = k, z0 = z;
int ans = 0;
for (int i = 1; i <= n; i++) {
int s = pref[i];
k = k0 - i + 1;
if (k < 0) continue;
z = z0;
while (k > 0) {
s += a[i + 1];
k--;
if (z == 0 || k == 0) {
s += pref[i + 1 + k] - pref[i + 1];
break;
}
s += a[i];
z--;
k--;
if (k == 0 || z == 0) {
s += pref[i + k] - pref[i];
break;
}
}
ans = max(ans, s);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
int T = 1;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int mx = 1e6 + 5;
const int inf = 0x3f3f3f3f;
using namespace std;
template <class T, class T2>
class SegTree {
private:
int n, a, b;
vector<T> tree;
void update(int pos, int i, int j, int x, T2 value) {
int esq = 2 * pos;
int dir = 2 * pos + 1;
int mid = (i + j) / 2;
if (i == j) {
tree[pos].first = min(b, tree[pos].first + value);
tree[pos].second = min(a, tree[pos].second + value);
} else {
if (x <= mid)
update(esq, i, mid, x, value);
else
update(dir, mid + 1, j, x, value);
tree[pos].first = tree[esq].first + tree[dir].first;
tree[pos].second = tree[esq].second + tree[dir].second;
}
}
T query(int pos, int i, int j, int l, int r) {
int esq = 2 * pos;
int dir = 2 * pos + 1;
int mid = (i + j) / 2;
T ret;
if (j < l || i > r)
ret = {0, 0};
else if (i >= l && j <= r)
ret = tree[pos];
else {
T left = query(esq, i, mid, l, r), right = query(dir, mid + 1, j, l, r);
ret.first = left.first + right.first;
ret.second = left.second + right.second;
}
return ret;
}
public:
SegTree(int size, int x, int y) {
n = size + 1;
a = x;
b = y;
tree.resize(4 * n, {0, 0});
}
T qry(int l, int r) { return query(1, 0, n - 1, l, r); }
void upd(int x, T2 val) { update(1, 0, n - 1, x, val); }
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
SegTree<pair<int, int>, int> st(n, a, b);
int t;
while (q--) {
scanf("%d", &t);
if (t == 1) {
int d, x;
scanf("%d%d", &d, &x);
st.upd(d, x);
} else {
int p;
scanf("%d", &p);
printf("%d\n", st.qry(0, p - 1).first + st.qry(p + k, n).second);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[10][10001];
int X[10];
pair<int, vector<int>> Calculate(int n, int m, int mask) {
vector<pair<int, int>> v(m);
for (int k = 0; k < m; ++k) {
int c = 0;
for (int i = 0; i < n; ++i) {
if (s[i][k] == '0') {
continue;
}
c += ((mask & (1 << i)) != 0) ? 1 : -1;
}
v[k] = {c, k};
}
int ans = 0;
for (int i = 0; i < n; ++i) {
int c = ((mask & (1 << i)) != 0) ? -1 : 1;
ans += c * X[i];
}
vector<int> p(m);
sort(v.begin(), v.end());
for (int k = 0; k < m; ++k) {
ans += v[k].first * (k + 1);
p[v[k].second] = k + 1;
}
return {ans, p};
}
void Solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &X[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
}
pair<int, vector<int>> ans = {INT_MIN, vector<int>()};
for (int mask = 0; mask < (1 << n); ++mask) {
ans = max(ans, Calculate(n, m, mask));
}
auto [_, p] = ans;
for (int pi : p) {
printf("%d ", pi);
}
printf("\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
Solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 18;
int it[maxn], m;
long long a[maxn];
long long b[maxn];
void read() { cin >> m; }
void update_(int pos, int k) {
while (pos) {
it[pos] += k;
pos -= pos & (-pos);
}
}
void update(int pos, int k) {
while (pos < maxn) {
it[pos] += k;
pos += pos & (-pos);
}
}
int ask(int l, int r) {
int sum = 0;
while (r > 0) {
sum += it[r];
r -= r & (-r);
}
l;
while (l > 0) {
sum -= it[l];
l -= l & (l);
}
cout << sum << endl;
}
void solve() {
long long sz = 1;
long long x, y, z;
double ans;
long long sum = 0LL;
for (int i = 0; i < m; ++i) {
scanf("%lld", &x);
if (x == 1) {
scanf("%lld %lld", &y, &z);
sum += (y * z);
b[y] += z;
} else if (x == 2) {
scanf("%lld", &y);
sum += y;
++sz;
a[sz] = y;
} else if (x == 3) {
sum -= (a[sz] + b[sz]);
b[sz - 1] += b[sz];
a[sz] = 0;
b[sz] = 0;
--sz;
}
ans = (double)sum / (double)sz;
printf("%.6lf\n", ans);
}
}
int main() {
read();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char sa[120000];
char sb[120000];
int main() {
scanf("%s%s", sa, sb);
int s, q;
s = q = 0;
for (int i = 0; sa[i]; i++) {
if (sa[i] != sb[i]) {
if (sa[i] == '7')
q++;
else
s++;
}
}
int step, tmin, tmax;
tmin = min(s, q);
tmax = max(s, q);
step = tmax;
printf("%d\n", tmax);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC target("popcnt")
#pragma GCC optimize("Ofast,inline")
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
template <typename T>
T gcd(T x, T y) {
return y ? gcd(y, x % y) : x;
}
template <typename T>
T lcm(T x, T y) {
return x / gcd(x, y) * y;
}
template <typename T>
void adm(T &x, T y, T z) {
x = x + y;
if (x >= z) x = x - z;
}
template <typename T>
void adj(T &x, T y) {
if (x >= y || x <= -y) x = x % y;
if (x < 0) x = x + y;
}
template <typename T>
T qpow(T x, long long y, T z) {
for (; y; y >>= 1, x = x * x)
if (y & 1) z = z * x;
return z;
}
template <typename T>
T mpow(long long w, T x, long long y, T z) {
for (; y; y >>= 1, x = x * x, x = x % w)
if (y & 1) z = z * x, z = z % w;
return z;
}
template <typename T>
T exgcd(T a, T b, T &x, T &y) {
T t = a;
b ? (t = exgcd(b, a % b, y, x), y = y - (a / b) * x) : (x = 1, y = 0);
return t;
}
const double EPS = 1e-7;
const long long MOD = 998244353LL;
const int M = 5000005;
const int N = 300005;
int _, n, t, ans[N], op, ed, d[N];
bool f[N];
vector<int> g[N];
void bfs(int x) {
for (f[d[op = ed = 1] = x] = true; op <= ed; op++) {
for (auto &i : g[d[op]])
if (!f[i]) f[d[++ed] = i] = true;
}
for (int i = 1; i <= ed; i++) ans[d[i]] = ed;
}
int main() {
for (scanf("%d", &_); _; _--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
vector<int>().swap(g[i]);
f[i] = false;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
g[i].push_back(t);
}
for (int i = 1; i <= n; i++)
if (!f[i]) bfs(i);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define IO ios::sync_with_stdio(false);cin.tie(0)
int main() {
//freopen("in.txt", "r", stdin);
int n, q, k; cin >> n >> q >> k;
vector<int> a(n + 5), d(n + 5);
for(int i = 1; i <= n; ++i) {
cin >> a[i];
d[i] = a[i] - a[i - 1];
}
while(q--) {
int l, r; cin >> l >> r;
cout << 2 * (a[r] - a[l]) + a[l] - 1 + k - a[r] - 2 * (r - l) << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
long long mod(long long x) {
while (x < 0) x += 1000000009;
return (x % 1000000009);
}
long long big(int x) {
if (!x) return 1LL;
long long h = big(x / 2);
h = mod(h * h);
if (x & 1) h = mod(h * 2LL);
return h;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
long long now = mod(big(m) - 1);
if (n == 1)
printf("%lld\n", now);
else {
long long ans = 1;
for (int i = 0; i < n; i++) ans = mod(ans * mod(now - i));
printf("%lld\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 6;
int link[N], cnt = 1, len[N], nxt[N][26], num[N][3], in[N], mi = 0x3f3f3f3f;
char s[N];
int insert(int c, int las, int o) {
if (nxt[las][c]) {
int p = las, q = nxt[las][c];
if (len[p] + 1 == len[q]) {
num[q][o] = 1;
return q;
} else {
int clone = ++cnt;
len[clone] = len[p] + 1;
link[clone] = link[q];
link[q] = clone;
memcpy(nxt[clone], nxt[q], sizeof(nxt[q]));
for (; nxt[p][c] == q; p = link[p]) nxt[p][c] = clone;
num[clone][o] = 1;
return clone;
}
}
int cur = ++cnt;
len[cur] = len[las] + 1;
int p = las;
for (; p && nxt[p][c] == 0; p = link[p]) nxt[p][c] = cur;
if (!p)
link[cur] = 1;
else {
int q = nxt[p][c];
if (len[q] == len[p] + 1)
link[cur] = q;
else {
int clone = ++cnt;
len[clone] = len[p] + 1;
link[clone] = link[q];
link[q] = link[cur] = clone;
memcpy(nxt[clone], nxt[q], sizeof(nxt[q]));
for (; nxt[p][c] == q; p = link[p]) nxt[p][c] = clone;
}
}
num[cur][o] = 1;
return cur;
}
void topu() {
queue<int> q;
for (int i = 1; i <= cnt; i++) in[link[i]]++;
for (int i = 2; i <= cnt; i++)
if (!in[i]) q.push(i);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 1; i <= 2; i++) num[link[now]][i] += num[now][i];
if (--in[link[now]] == 0) q.push(link[now]);
if (now == 1) continue;
int flag = 0;
for (int i = 1; i <= 2; i++)
if (num[now][i] != 1) flag = 1;
if (flag == 0) mi = min(mi, len[link[now]] + 1);
}
}
int main() {
scanf("%s", s + 1);
int len = strlen(s + 1), las = 1;
for (int i = 1; i <= len; i++) las = insert(s[i] - 'a', las, 1);
scanf("%s", s + 1);
len = strlen(s + 1), las = 1;
for (int i = 1; i <= len; i++) las = insert(s[i] - 'a', las, 2);
topu();
if (mi == 0x3f3f3f3f)
cout << -1;
else
cout << mi;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point() {}
Point(int _x, int _y) : x(_x), y(_y) {}
} np[5][55];
struct Ans {
int num;
Point p;
Ans() {}
Ans(int _num, Point _p) : num(_num), p(_p) {}
};
vector<Ans> ans;
int M[5][55];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
cin >> M[i][j];
}
}
for (int i = 1; i < n; i++) np[2][i] = Point(2, i + 1);
np[2][n] = Point(3, n);
for (int i = 2; i <= n; i++) np[3][i] = Point(3, i - 1);
np[3][1] = Point(2, 1);
for (int re = 0; re < 405; re++) {
bool found = 0;
for (int i = 2; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
if (M[i][j] > 0 && M[i][j] == M[((i - 1) ^ 1) + 1][j]) {
ans.push_back(Ans(M[i][j], Point(((i - 1) ^ 1) + 1, j)));
M[i][j] = 0;
found = 1;
}
}
}
int mv = 1;
for (int i = 1; i <= n; i++) {
Point p = np[3][i];
int nx = p.x, ny = p.y;
if (M[3][i] > 0 && M[nx][ny] == 0) {
ans.push_back(Ans(M[3][i], Point(nx, ny)));
swap(M[3][i], M[nx][ny]);
if (i == 1) mv = 2;
found = 1;
}
}
for (int i = n; i >= mv; i--) {
Point p = np[2][i];
int nx = p.x, ny = p.y;
if (M[2][i] > 0 && M[nx][ny] == 0) {
ans.push_back(Ans(M[2][i], Point(nx, ny)));
swap(M[2][i], M[nx][ny]);
found = 1;
}
}
if (!found) break;
}
bool bad = 0;
for (int i = 2; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
if (M[i][j]) {
bad = 1;
break;
}
}
}
if (bad) {
cout << -1;
return 0;
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++)
cout << ans[i].num << " " << ans[i].p.x << " " << ans[i].p.y << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
vector<int> a(n);
deque<int> d;
for (int i = 0; i < n; ++i) {
cin >> a[i];
d.push_back(a[i]);
}
vector<int> b(n, 0);
for (int i = 0; i < n; ++i) {
b[i] = a[i];
}
sort(b.rbegin(), b.rend());
int maximum = b[0];
vector<pair<int, int>> ans;
int count = 0;
while (d[0] != maximum) {
ans.push_back({d[0], d[1]});
auto x = d[0], y = d[1];
d.pop_front();
d.pop_front();
if (x < y) {
swap(x, y);
}
d.push_front(x);
d.push_back(y);
count += 1;
}
for (int i = 0; i < q; ++i) {
long long m;
cin >> m;
if (m <= count) {
cout << ans[m - 1].first << " " << ans[m - 1].second << "\n";
} else {
m -= (count + 1);
m %= (n - 1);
cout << maximum << " " << d[1 + m] << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int sg;
} node[310][310];
int s[3], tmp, t;
void solve(int x, int y, int p) {
s[0] = x;
s[1] = y;
sort(s, s + 2);
if (s[1] > 300)
return;
else
node[s[0]][s[1]].sg = 1;
}
int n, x[5], ans;
int main() {
memset(node, 0, sizeof(node));
int k1, k2, k3;
for (k1 = 0; k1 <= 300; k1++)
for (k2 = k1; k2 <= 300; k2++) {
if (node[k1][k2].sg) continue;
t = 0;
for (tmp = 1; k1 + tmp <= 300; tmp++) solve(k1 + tmp, k2, t);
for (tmp = 1; k2 + tmp <= 300; tmp++) {
solve(k1, k2 + tmp, t);
solve(k1 + tmp, k2 + tmp, t);
}
}
while (~scanf("%d", &n)) {
ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
ans ^= x[i];
}
sort(x + 1, x + n + 1);
if (n == 2) {
ans = node[x[1]][x[2]].sg;
}
if (ans)
printf("BitLGM\n");
else
printf("BitAryo\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v;
int maxx, ans;
int main() {
string s;
cin >> s;
n = s.size();
ans = n;
for (int i = 0; i < 26; i++) {
maxx = 0;
v.clear();
v.push_back(-1);
for (int j = 0; j < n; j++) {
if (s[j] - 'a' == i) v.push_back(j);
}
v.push_back(n);
for (int j = 0; j + 1 < v.size(); j++) {
maxx = max(v[j + 1] - v[j], maxx);
}
ans = min(ans, maxx);
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
int main() {
int n, t;
cin >> n >> t;
vector<double> p(n);
vector<int> t2(n);
for (int i = (0); i < (n); ++i) {
cin >> p[i] >> t2[i];
}
for (auto& i : p) {
i /= 100;
}
vector<vector<double>> dp(n + 1, vector<double>(t + 1));
dp[0][0] = 1;
cout << fixed << setprecision(15);
for (int i = (0); i < (n); ++i) {
double sum = 0;
double pp = pow(1 - p[i], t2[i]);
if (pp < 1e-15) {
pp = 0;
}
for (int j = (0); j < (t + 1); ++j) {
dp[i + 1][j] = sum * p[i];
sum *= (1 - p[i]);
if (0 <= j - t2[i]) {
dp[i + 1][j] += dp[i][j - t2[i]] * pp;
sum -= pp * dp[i][j - t2[i]];
}
sum += dp[i][j];
}
}
double res = 0;
for (int i = (0); i < (n); ++i) {
double y = 1;
for (int j = (t); j > (max(t - t2[i] + 1, 0) - 1); --j) {
res += i * y * dp[i][j];
y *= (1 - p[i]);
if (y < 1e-15) {
y = 0;
}
}
}
for (int j = (0); j < (t + 1); ++j) {
res += n * dp[n][j];
}
cout << res << "\n";
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
for (int it = 1; it <= t; it++) {
int temp;
cin >> temp;
if (temp == 1) {
cout << "HARD";
return 0;
}
}
cout << "EASY";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 1000000000;
const int maxn = 200005;
const int maxa = 300005;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
if (b < 0) return -1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int INF = 10000000;
clock_t start, finish;
double duration;
int sg[maxn];
int main() {
ios::sync_with_stdio(0);
int n;
int a[maxn];
map<int, int> mp;
cin >> n;
for (int i = 0; i < n + 2; i++) sg[i] = -1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mp[a[i]] = i;
}
sg[n] = 0;
if (n != 1) sg[1] = 1;
for (int i = n - 1; i > 1; i--) {
int pos = mp[i];
int vis[maxn];
vis[0] = 0;
for (int j = pos; j > 0; j -= i)
if (a[j] > i && sg[a[j]] >= 0) {
vis[sg[a[j]]] = 1;
if (sg[a[j]] == 0) break;
}
for (int j = pos; j <= n; j += i)
if (a[j] > i && sg[a[j]] >= 0) {
vis[sg[a[j]]] = 1;
if (sg[a[j]] == 0) break;
}
if (vis[0])
sg[i] = 1;
else
sg[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (sg[a[i]] == 0)
cout << "B";
else
cout << "A";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 1e5 + 5, inf = 0x3f3f3f3f;
long double x1, ewqewq, x2, y2;
long double v_max;
long double Dist(long double a, long double b) {
return sqrt((a - x2) * (a - x2) + (b - y2) * (b - y2));
}
long double SimpleReach(long double a, long double b) {
return Dist(a, b) / v_max;
}
long double ReachTime(double vx, double vy, int extra_time) {
long double c_t = 1LL << 40, t = 0;
for (int steps = 100; steps; steps -= 1, c_t /= 2.0) {
long double n_t = c_t + t;
long double nx = x1 + vx * n_t;
long double ny = ewqewq + vy * n_t;
long double reach_time = SimpleReach(nx, ny);
if (reach_time <= n_t + extra_time) {
;
} else {
t = n_t;
}
}
return t;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> x1 >> ewqewq >> x2 >> y2;
int t;
cin >> v_max >> t;
int vx, vy, wx, wy;
cin >> vx >> vy >> wx >> wy;
double a = ReachTime(vx, vy, 0);
if (a < t) {
;
cout << fixed << setprecision(20) << a << '\n';
return 0;
}
x1 += vx * t;
ewqewq += vy * t;
cout << fixed << setprecision(20) << t + ReachTime(wx, wy, t) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, diff;
cin >> n;
int h, m, cashes = 1, min_cashes = 1;
vector<int> time;
while (n--) {
cin >> h >> m;
time.push_back(h * 60 + m);
}
for (int i = 0; i < time.size() - 1; ++i) {
int diff = time[i] - time[i + 1];
diff = (diff < 0 ? -diff : diff);
if (diff < 1) {
++cashes;
if (min_cashes < cashes) {
min_cashes = cashes;
}
} else {
cashes = 1;
}
}
cout << min_cashes << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long int n, k, i, j;
cin >> n >> k;
if (k == 1) {
cout << n;
return 0;
}
i = 1;
vector<long long int> p;
while (i <= n) {
p.push_back(i);
i *= 2;
}
long long int ans = 0;
j = p.size();
j--;
while (j >= 0) {
ans += p[j];
j--;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long NMAX = 300011;
long long c[NMAX];
signed main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
long long a;
cin >> a;
while (a > 0) {
if (a & 1) c[i]++;
a >>= 1;
}
}
long long bad = 0;
for (long long i = 1; i <= n; i++) {
long long sum = c[i];
long long mx = c[i];
if ((c[i] & 1) == 0) bad++;
for (long long j = i + 1; j <= min(n, i + 64); j++) {
sum += c[j];
mx = max(mx, c[j]);
if ((sum & 1) == 0 && 2 * mx > sum) bad++;
}
}
long long cnt2 = 1;
long long cnt1 = 0;
long long sum = 0;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
sum += c[i];
if (sum & 1) {
ans += cnt1;
cnt1++;
} else {
ans += cnt2;
cnt2++;
}
}
cout << ans - bad;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long INFLL = 1e12;
const long long MOD = 1000000007;
const long double eps = 1e-6;
const long long MOD2 = (1 << 30) + 1;
const long long dosz = 5e5;
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long n;
cin >> n;
vector<tuple<long double, long double, long double>> lol(n);
for (tuple<long double, long double, long double> &i : lol) {
long double a, b, c;
cin >> a >> b >> c;
i = {a, b, c};
}
long double answer = INFLL;
for (long long i = 1; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (i == j) continue;
long double a1, b1, c1, a2, b2, c2;
tie(a1, b1, c1) = lol[i];
tie(a2, b2, c2) = lol[j];
long double dist = sqrt((a1 - get<0>(lol[0])) * (a1 - get<0>(lol[0])) +
(b1 - get<1>(lol[0])) * (b1 - get<1>(lol[0])) +
(c1 - get<2>(lol[0])) * (c1 - get<2>(lol[0]))) +
sqrt((a2 - get<0>(lol[0])) * (a2 - get<0>(lol[0])) +
(b2 - get<1>(lol[0])) * (b2 - get<1>(lol[0])) +
(c2 - get<2>(lol[0])) * (c2 - get<2>(lol[0]))) +
sqrt((a1 - a2) * (a1 - a2) + (b1 - b2) * (b1 - b2) +
(c1 - c2) * (c1 - c2));
dist /= 2.0;
answer = min(answer, dist);
}
}
cout << setprecision(12) << answer << endl;
}
signed main() {
fast_io();
long long q = 1;
while (q--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename 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 T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int first[100100], d[100100];
int mx[100100], mn[100100];
int L[100100], R[100100];
long long arr[100100];
void update_mx(int u, int val) {
while (u) {
smax(mx[u], val);
u -= u & -u;
}
}
int calc_mx(int u) {
int ans = 0;
while (u < 100100) {
smax(ans, mx[u]);
u += u & -u;
}
return ans;
}
void update_mn(int u, int val) {
while (u < 100100) {
smin(mn[u], val);
u += u & -u;
}
}
int calc_mn(int u) {
int ans = 100100;
while (u) {
smin(ans, mn[u]);
u -= u & -u;
}
return ans;
}
int B[100100];
void update(int u, int val) {
while (u) {
smax(B[u], val);
u -= u & -u;
}
}
int calc(int u) {
int ans = 0;
while (u < 100100) {
smax(ans, B[u]);
u += u & -u;
}
return ans;
}
int main() {
int n;
gn(n);
for (int i = 0; i < n + 2; i++) gn(first[i]);
for (int i = 1; i <= n; i++) gn(d[i]);
int nn = 0;
for (int i = 1; i <= n; i++) mn[i] = n + 1;
for (int i = 1; i <= n + 1; i++) {
int j = calc_mx(i);
L[i] = j;
if (first[i] - first[j] >= d[i] * 2) continue;
arr[nn++] = first[j] + d[i] * 2LL;
j = upper_bound(first, first + n + 2,
min(0x3f3f3f3f * 2LL, first[j] + d[i] * 2LL)) -
first - 1;
update_mx(j, i);
}
if (L[n + 1]) return puts("0"), 0;
sort(arr, arr + nn);
nn = unique(arr, arr + nn) - arr;
int ans = 0x3f3f3f3f;
for (int i = n; i; i--) {
int j = calc_mn(i);
R[i] = j;
if (first[j] - first[i] >= d[i] * 2) continue;
j = lower_bound(first, first + n + 2, max(-1LL, first[j] - d[i] * 2LL)) -
first;
update_mn(j, i);
}
R[n + 1] = n + 1;
d[n + 1] = 0x3f3f3f3f;
for (int i = 1; i <= n + 1; i++) {
if (first[R[i]] - first[i] < d[i] * 2) {
int j =
calc(lower_bound(arr, arr + nn, first[R[i]] - d[i] * 2LL) - arr + 1);
smin(ans, first[i] - first[j]);
}
if (first[i] - first[L[i]] >= d[i] * 2) continue;
int j = upper_bound(arr, arr + nn, first[L[i]] + d[i] * 2LL) - arr;
update(j, i);
}
for (int i = 1; i <= n; i++) {
smin(ans, first[R[i]] - first[L[i]]);
}
printf("%d", ans / 2);
puts(ans & 1 ? ".5" : "");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200002];
int pos[200002];
int b[200002];
int pos2[200002];
int mark[200002];
int mark2[200002];
int main() {
scanf("%d\n", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &b[i]);
pos2[b[i]] = i;
}
int ans = n;
int uk = 0;
for (int i = 0; i < n; ++i) {
while (uk < pos2[a[i]]) ans = min(ans, pos[b[uk++]]);
++uk;
}
printf("%d\n", n - ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
vector<int> v(26, 0), cnt(26, 0);
vector<pair<int, int> > u;
string ans = "", tmp = "";
int sum = 0;
bool b = 1;
for (int i = 0; i < s.size(); i++) {
v[s[i] - 'a'] = i + 1;
cnt[s[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (v[i]) {
u.push_back({v[i], i});
}
}
sort(u.begin(), u.end());
int j = 1;
for (auto e : u) {
v[e.second] = j;
j++;
}
for (int i = 0; i < 26; i++) {
if (v[i]) {
if (cnt[i] % v[i]) b = 0;
cnt[i] = cnt[i] / v[i];
sum += cnt[i];
}
}
for (int i = 0; i < sum; i++) ans += s[i];
for (auto e : u) tmp += char('a' + e.second);
string aa = ans, bb = "";
int k = sum, m = 0;
for (int i = 0; i < u.size() - 1; i++) {
for (int j = 0; j < aa.size(); j++) {
if (aa[j] != tmp[m]) bb += aa[j];
}
if (k + bb.size() > s.size()) {
b = 0;
break;
}
for (int j = k; j < k + bb.size(); j++) {
if (s[j] != bb[j - k]) b = 0;
}
k += bb.size();
m++;
aa = bb;
bb = "";
}
if (b) {
cout << ans << ' ' << tmp << '\n';
} else
cout << -1 << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
vector<string> y;
int n;
int main() {
cin >> n;
y.resize(n);
for (int i = 0; i < (int)(n); i++) cin >> y[i];
string tmp, tm;
for (int i = 0; i < (int)(n); i++) {
tm = "2012";
for (int j = 0; j < (int)(4); j++)
for (char x = '0'; x <= '9'; x++) {
tmp = y[i];
tmp[j] = x;
if ((!i || tmp >= y[i - 1]) && tmp[0] != '0' && tmp <= "2011" &&
tmp < tm) {
tm = tmp;
break;
}
}
if (tm == "2012") {
cout << "No solution";
exit(0);
} else
y[i] = tm;
}
for (int i = 0; i < (int)(n); i++) cout << y[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(const T &a) {
return a * a;
}
const int MAXN = 1e5 + 100;
int p[MAXN], pRev[MAXN], a[MAXN], b[MAXN], used[MAXN];
int REAL_P[MAXN], REAL_P_REV[MAXN];
int SEED;
int init() {
int n;
scanf("%d", &n);
return n;
}
int ask(int i, int j) {
printf("? %d %d\n", i, j);
fflush(stdout);
int z;
scanf("%d", &z);
if (z == -1) exit(0);
return z;
}
void printAns(int cnt, vector<int> ans) {
printf("!\n%d\n", cnt);
for (int i : ans) printf("%d ", i);
puts("");
}
void solve(int n, int totalXor) {
int k = 0;
for (int i = 1; i < n; i += 2) k ^= a[i];
for (int i = 0; i < n; i += 2) {
p[i] = totalXor ^ k;
k ^= a[i] ^ a[i + 1];
}
k = 0;
for (int i = 2; i < n; i += 2) k ^= a[i];
for (int i = 1; i < n; i += 2) {
p[i] = totalXor ^ k;
k ^= a[i] ^ a[i + 1];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n = init();
for (int i = 0; i < (n); i++) {
int x = ask(i, i);
b[i] = x;
int y = ask((i + 1) % n, i);
a[i] = x ^ y;
}
int totalXor = 0;
for (int i = 0; i < (n); i++) totalXor ^= i;
vector<int> ans;
if (n % 2 == 1) {
solve(n, totalXor);
for (int i = 0; i < (n); i++) ans.push_back(p[i]);
printAns(1, ans);
return 0;
} else {
int ansCnt = 0;
for (int j = 0; j < (n); j++) {
p[n - 1] = j;
int lastA = a[n - 2];
a[n - 2] = a[n - 2] ^ a[n - 1];
solve(n - 1, totalXor ^ j);
a[n - 2] = lastA;
int ok = 1;
for (int i = 0; i < (n); i++) used[i] = 0;
for (int i = 0; i < (n); i++) pRev[p[i]] = i;
for (int i = 0; i < (n); i++) {
if (p[i] >= n) {
ok = 0;
break;
}
if (used[p[i]]) ok = 0;
used[p[i]] = 1;
if (a[i] != (p[i] ^ p[(i + 1) % n])) ok = 0;
if (b[i] != (p[i] ^ pRev[i])) ok = 0;
}
if (ok) {
ansCnt++;
if (!ans.size()) {
for (int i = 0; i < (n); i++) ans.push_back(p[i]);
}
}
}
printAns(ansCnt, ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
int n, m;
cin >> n >> m;
vector<string> v;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (v[i][j] == '#') {
for (int k = 0; k < n; k++) {
if (k == i) continue;
if (v[k][j] == v[i][j] && v[i] != v[k]) {
cout << "No"
<< "\n";
return 0;
}
}
}
}
}
cout << "Yes"
<< "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10, M = 1 << N;
int n, m, k, q[N], e[N][N];
long long a[N][N], f[M];
long long det(int m) {
long long ans = 1;
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
while (a[j][i]) {
long long c = a[i][i] / a[j][i];
for (int k = i; k < m; k++) a[i][k] -= a[j][k] * c;
swap(a[i], a[j]);
ans = -ans;
}
}
ans *= a[i][i];
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
e[u][v]++;
e[v][u]++;
}
int nn = (1 << n);
for (int s = 1; s < nn; s++) {
long long ans = 1;
m = 0;
for (int i = 0; i < n; i++)
if (!(s >> i & 1)) q[m++] = i;
for (int i = 0, cc; i < n; i++)
if (s >> i & 1) {
for (int j = cc = 0; j < m; j++) cc += e[i][q[j]];
ans *= cc;
}
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) a[i][j] = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < i; j++) {
int w = e[q[i]][q[j]];
a[i][i] += w;
a[j][j] += w;
a[i][j] = a[j][i] = -w;
}
ans *= det(m - 1);
if ((n + m + k) & 1)
f[s] = -ans;
else
f[s] = ans;
}
for (int i = 0; i < n; i++)
for (int s = 0; s < nn; s++)
if (!(s >> i & 1)) f[s] += f[s | (1 << i)];
long long ans = 0;
for (int s = 0; s < nn; s++) {
int cc = 0;
for (int i = 0; i < n; i++)
if (s >> i & 1) cc++;
if (cc == k) ans += f[s];
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 1222222, mo = 1e9 + 7;
int k, w, fac[N], ifac[N];
int power(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = 1LL * res * a % mo;
a = 1LL * a * a % mo;
n >>= 1;
}
return res;
}
inline int A(int n, int m) {
return m >= 0 && m <= n ? 1LL * fac[n] * ifac[n - m] % mo : 0;
}
void init(int n) {
fac[0] = 1;
for (register int i = (1); i <= (n); i++) fac[i] = 1LL * fac[i - 1] * i % mo;
ifac[n] = power(fac[n], mo - 2);
for (register int i = (n - 1); i >= (0); i--)
ifac[i] = 1LL * ifac[i + 1] * (i + 1) % mo;
}
int solve(int w) {
int res =
k != 1 ? 1LL * k * (1 - power(k, w - 1)) % mo * power(1 - k, mo - 2) % mo
: w - 1;
res = (res + mo) % mo;
for (int n = w; n < 2 * w && n - w <= k; n++)
res = (res + 1LL * power(A(k, n - w), 2) * power(k, 2 * w - n)) % mo;
for (int n = 2 * w; n <= w + k; n++)
res = (res + 1LL * A(k, n - 2 * w) * power(A(k - (n - 2 * w), w), 2)) % mo;
return res;
}
int main() {
init(N - 1);
read(k);
read(w);
cout << (solve(w) - solve(w - 1) + mo) % mo;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 998244353;
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
if (a < 0) a += MOD;
return a;
}
int mul(int a, int b) { return a * 1ll * b % MOD; }
int power(int a, int b) {
if (b == 0)
return 1;
else {
int i;
for (i = 0; i < b - 1; i++) a = mul(a, 10);
return a;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int e = 1;
while (e--) {
int n, j;
cin >> n;
int i;
vector<vector<int>> v(n);
for (i = 0; i < n; i++) {
int it;
cin >> it;
while (it > 0) {
v[i].push_back(it % 10);
it /= 10;
}
}
int size = v[0].size();
vector<int> s(size);
for (i = 0; i < size; i++) {
for (j = 0; j < n; j++) s[i] = add(s[i], mul(n, v[j][i]));
}
int ans = 0, rem = 0, ten = 10;
for (i = 0; i < s.size(); i++) {
if (i < s.size() - 1) {
ans = add(ans, mul((add(mul(s[i], 11), rem) % 100), power(ten, i * 2)));
rem = (add(mul(s[i], 11), rem) / 100);
} else
ans = add(ans, mul(add(mul(s[i], 11), rem), power(ten, i * 2)));
}
cout << ans;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a[100] = {0}, p, q, i, j, k, n, x, y;
cin >> p >> q;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
x = p;
y = q;
if (n == 1) {
j = 0;
if (p % q == 0) {
p = p / q;
}
if (p != a[0]) {
j = -1;
}
} else {
if (n > 1 && a[n - 1] == 1) {
a[n - 2]++;
n--;
}
i = 0;
j = 0;
while (1) {
if (a[i] != x / y) {
j = -1;
break;
}
k = x % y;
x = y;
y = k;
i++;
if (i == n) {
if (y != 0) {
j = -1;
}
break;
}
if (y == 0) {
j = -1;
break;
}
}
}
if (j != -1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> (n);
long long ar[n + 2][n + 2];
memset(ar, 0, sizeof(ar));
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
char c;
cin >> (c);
if (c == 'o')
ar[i][j] = 1;
else
ar[i][j] = 0;
}
}
bool cnt = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
cnt = ((ar[i - 1][j] + ar[i + 1][j] + ar[i][j - 1] + ar[i][j + 1]) % 2)
? false
: true;
if (!cnt) {
puts("NO");
return 0;
}
}
}
puts("YES");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
int dp[N][N], n;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> dp[i][i];
for (int len = 1; len <= n; len++)
for (int i = len - 1; i; i--) dp[i][len] = dp[i + 1][len] ^ dp[i][len - 1];
for (int len = 1; len <= n; len++)
for (int i = len; i; i--)
dp[i][len] = max(dp[i][len], max(dp[i][len - 1], dp[i + 1][len]));
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
cout << dp[l][r] << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define repn(i,a,b) for(ll i=a;i>=b;i--)
#define ld long double
#define fi first
#define se second
#define pii pair<ll,ll>
#define vi vector<ll>
#define vii vector<pii>
#define pb push_back
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define sz(a) ll(a.size())
#define mem0(a) memset(a, 0, sizeof(a))
#define mem1(a) memset(a, -1, sizeof(a))
#define trav(a, x) for (auto &a : x)
#define popcount(x) __builtin_popcountll(x)
#define SPEED ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define mod 1000000007
ll INF = 1e6;
void solve() {
ll n, m;
cin >> n >> m;
ll temp = 0, lol = 0;
set<ll> s;
while (n != 0) {
temp = n % m;
n /= m;
//if (s.find(temp) != s.end())
s.insert(temp);
lol++;
}
//ll x = ceil(log(lol) / log(m) * 1.0);
//cout << x << endl << s.size();
if (lol == s.size())
cout << "YES";
else cout << "NO";
}
int main() {
SPEED;
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
clock_t z = clock();
ll t = 1;
//cin >> t;
while (t--) solve();
debug("Total Time:%.3Lf\n", (ld)(clock() - z) / CLOCKS_PER_SEC);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
cout << 3 * n / 2 << endl;
for (i = 2; i <= n; i += 2) cout << i << " ";
for (i = 1; i <= n; i += 2) cout << i << " ";
for (i = 2; i <= n; i += 2) cout << i << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e9 + 7;
const long long LINF = (long long)2e18 + 7;
int K, N;
vector<pair<string, int>> V;
map<pair<string, string>, pair<vector<int>, vector<int>>> Mp;
map<string, vector<int>> One;
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
string st;
int a;
cin >> st;
cin >> a;
string n1 = st;
reverse(n1.begin(), n1.end());
if (st == n1) {
One[st].push_back(a);
continue;
}
if (st < n1) {
Mp[make_pair(st, n1)].first.push_back(a);
} else {
Mp[make_pair(n1, st)].second.push_back(a);
}
V.push_back(make_pair(st, a));
}
long long ans = 0;
int mn = 0, mx = 0;
for (auto el : One) {
sort(el.second.begin(), el.second.end());
reverse(el.second.begin(), el.second.end());
for (int i = 0; i < el.second.size(); i += 2) {
if (i + 1 != el.second.size() && el.second[i + 1] + el.second[i] >= 0) {
ans += el.second[i];
ans += el.second[i + 1];
if (el.second[i] < 0)
mn = min(mn, el.second[i]);
else if (el.second[i + 1] < 0)
mn = min(mn, el.second[i + 1]);
} else {
mx = max(mx, el.second[i]);
if (i + 1 < el.second.size()) mx = max(mx, el.second[i + 1]);
}
}
}
ans = max(ans, max(ans + mx, ans - mn));
set<pair<string, string>> used;
for (auto el : Mp) {
if (used.count(el.first) ||
used.count(make_pair(el.first.second, el.first.first)))
continue;
used.insert(el.first);
sort(el.second.first.begin(), el.second.first.end());
reverse(el.second.first.begin(), el.second.first.end());
sort(el.second.second.begin(), el.second.second.end());
reverse(el.second.second.begin(), el.second.second.end());
for (int i = 0; i < min(el.second.first.size(), el.second.second.size());
i++) {
ans += max(0, el.second.first[i] + el.second.second[i]);
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int p = 0, maxk = 0;
for (int i = 0; i < n; i++) {
int k, a;
scanf("%d %d", &k, &a);
maxk = max(k, maxk);
int m = 0, s = 1;
while (s < a) {
s *= 4;
m++;
}
p = max(p, k + m);
}
if (p == maxk) {
p++;
}
printf("%d\n", p);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
void solve()
{
ll x,y; cin >> x >> y;
ll ans=0;
for (ll i=1; i*i<x; i++){
ans+=max(0LL,min(y,x/i-1)-i);
}
cout << ans << '\n';
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int t; cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int from, to, dist;
Edge(int u, int v, int d) : from(u), to(v), dist(d) {}
};
int a[100007];
int n, q;
int l, r;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> l >> r;
cout << (a[r] - a[l - 1]) / 10 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
int noOfpoints;
vector<pair<int, int>> points;
cin >> noOfpoints;
map<int, int> xp, yp;
for (int i = 0; i < noOfpoints; i++) {
int x, y;
cin >> x >> y;
points.push_back({x, y});
xp[x]++;
yp[y]++;
}
for (int i = 0; i < noOfpoints; i++) {
if (xp[points[i].first] >= 3) {
int y = points[i].second;
int down = 1, up = 1;
int left = 1, right = 1;
for (int j = 0; j < noOfpoints; j++) {
if (j == i) continue;
if (points[j].first == points[i].first) {
if (points[j].second > y && up) {
up = 0;
} else if (points[j].second < y && down) {
down = 0;
}
}
if (up == 0 && down == 0) break;
}
if ((up == 0 && down == 0) && yp[points[i].second] >= 3) {
int x = points[i].first;
for (int j = 0; j < noOfpoints; j++) {
if (j == i) continue;
if (points[j].second == points[i].second) {
if (points[j].first > x && right) {
right = 0;
} else if (points[j].first < x && left) {
left = 0;
}
}
if (right == 0 && left == 0) break;
}
}
if (up == 0 && down == 0 && left == 0 && right == 0) ans++;
}
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline bool SR(int &x) { return scanf("%d", &x) == 1; }
inline bool SR(long long &x) { return scanf("%lld", &x) == 1; }
inline bool SR(double &x) { return scanf("%lf", &x); }
inline bool SR(char *s) { return scanf("%s", s); }
inline bool RI() { return 1; }
template <typename I, typename... T>
bool RI(I &x, T &...tail) {
return SR(x) && RI(tail...);
}
inline void SP(const int x) { printf("%d", x); }
inline void SP(const long long x) { printf("%lld", x); }
inline void SP(const double x) { printf("%.10f", x); }
inline void SP(const char *s) { printf("%s", s); }
inline void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I x, const T... tail) {
SP(x);
if (sizeof...(tail)) putchar(' ');
PL(tail...);
}
template <typename I>
inline void _DOING(const char *s, I &&x) {
cerr << s << " = " << x << '\n';
}
template <typename I, typename... T>
void _DOING(const char *s, I &&x, T &&...tail) {
int c = 0;
while (*s != ',' || c != 0) {
if (*s == '(' || *s == '[' || *s == '{') c++;
if (*s == ')' || *s == ']' || *s == '}') c--;
cerr << *s++;
}
cerr << " = " << x << " , ";
_DOING(s + 1, tail...);
}
const int INF = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3fll;
inline int RAND() {
static int x = 880301;
return x = (x * 0xdefacedll + 1ll) % 0x7fffffffll;
}
int n;
map<pair<int, int>, int> rd;
inline bool check(long long a, int b) {
long long x = 1;
while (b) {
if (a >= n) return 0;
if (b & 1) x = x * a;
if (x >= n) return 0;
a = a * a;
b >>= 1;
}
return 1;
}
int dfs(int a, int b) {
if (rd.count(make_pair(a, b))) return rd[make_pair(a, b)];
if (!check(a, b)) return rd[make_pair(a, b)] = 1;
if (a == 1) {
if (!check(a + 1, b))
return rd[make_pair(a, b)] = 0;
else if (dfs(a + 1, b) == -1 || dfs(a, b + 1) == -1)
return rd[make_pair(a, b)] = 1;
else if (dfs(a + 1, b) == 0 || dfs(a, b + 1) == 0)
return rd[make_pair(a, b)] = 0;
else
return rd[make_pair(a, b)] = -1;
} else if (b == 1) {
if (1ll * a * a >= n) {
if ((n - a) & 1)
return rd[make_pair(a, b)] = -1;
else
return rd[make_pair(a, b)] = 1;
} else if (dfs(a + 1, b) == -1 || dfs(a, b + 1) == -1)
return rd[make_pair(a, b)] = 1;
else if (dfs(a + 1, b) == 0 || dfs(a, b + 1) == 0)
return rd[make_pair(a, b)] = 0;
else
return rd[make_pair(a, b)] = -1;
} else {
if (dfs(a + 1, b) == -1 || dfs(a, b + 1) == -1)
return rd[make_pair(a, b)] = 1;
else
return rd[make_pair(a, b)] = -1;
}
}
int main() {
int a, b;
RI(a, b, n);
int res = dfs(a, b);
if (res == 1)
PL("Masha");
else if (res == -1)
PL("Stas");
else
PL("Missing");
return 0;
}
| 6 |
/* CREATED BY
STREAM_CIPHER
may-2021
*/
#include<bits/stdc++.h>
using namespace std;
void __print(long long x) {cerr << x;}void __print(unsigned long long x) {cerr << x;}void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
#define int long long int
#define double long double
#define fix_precision(n) cout<<fixed<<setprecision(n)
#define all(a) a.begin(),a.end()
const double pi=acos(-1.0);
int inf=0x3f3f3f3f3f3f3f3f;
const int mod=1e9+7;
// const int mod=998244353;
const int mx=5*1000000;//5*64M bit ->5*8M byte ->40MB size for long long int (64 bit)
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
#endif
int t;
cin>>t;
while(t--){
int n;
cin>>n;
bool possible=false;
for(int i=0;i<21;i++){
if((n-i*11)%111==0&&(n-i*11)>=0){
possible=1;
break;
}
if((n-i*111)%11==0&&(n-i*111)>=0){
possible=1;
break;
}
}
if(possible){
cout<<"YES\n";
}
else{
cout<<"NO\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, y;
cin >> n >> m;
string s[n], t[m];
for (i = 0; i < n; i++) {
cin >> s[i];
}
for (i = 0; i < m; i++) {
cin >> t[i];
}
long long int q;
cin >> q;
while (q != 0) {
cin >> y;
int k1 = y % (n), k2 = y % (m);
if (k1 == 0) k1 = n;
if (k2 == 0) k2 = m;
cout << s[k1 - 1] + t[k2 - 1] << endl;
q--;
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.