solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#pragma GCC optimize("O3")
//#pragma GCC target("avx")
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <iomanip>
#include <list>
#include <stack>
using namespace std;
#define re return
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define make_unique(x) sort(all(x)),x.resize(unique(all(x))-x.begin())
#define fi first
#define se second
#define ss second.second
#define sf second.first
#define ff first.first
#define fs first.second
#define sqrt(x) sqrt(abs(x))
#define mp make_pair
#define PI 3.14159265358979323846
#define E 2.71828182845904523536
#define er erase
#define in insert
#define fo(i,n) for((i)=0;(i)<(n);(i)++)
#define ro(i,n) for((i)=n-1;(i)>=0;(i)--)
#define fr(i,j,n) for((i)=(j);(i)<(n);(i)++)
#define rf(i,j,n) for((i)=((n)-1);(i)>=(j);(i)--)
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
void eras(map<int,int> &m,int x)
{
m[x]--;
if (!m[x]) m.erase(x);
}
ostream& operator <<(ostream &out,__int128 x)
{
out<<(ll)x;
re out;
}
istream& operator >>(istream &in,__int128 &x)
{
ll temp;
in>>temp;
x=temp;
re in;
}
const int N=(int)3e5+100;
const int M=(int)1e7+10;
const int inf=(int)1e9+100;
const double eps=1e-9;
#define filename ""
vector<int> v[N],g[N];
int gtime=0;
int tin[N],tout[N];
void dfs2(int x)
{
tin[x]=gtime++;
for(auto y:g[x])
{
dfs2(y);
}
tout[x]=gtime;
}
set<pair<int,int> > s;
int ma=0;
void dfs(int x)
{
auto j=s.lower_bound({tin[x],-1});
set<pair<int,int> > temp;
if (j!=s.end())
{
if (!(tin[x]<=j->fi&&j->se<=tout[x]))
{
if (j!=s.begin())
{
j--;
if (j->fi<=tin[x]&&tout[x]<=j->se)
{
temp.in(*j);
s.er(j);
}
}
s.insert({tin[x],tout[x]});
}
}
else
{
if (j!=s.begin())
{
j--;
if (j->fi<=tin[x]&&tout[x]<=j->se)
{
temp.in(*j);
s.er(j);
}
}
s.insert({tin[x],tout[x]});
}
ma=max(ma,(int)s.size());
for(auto y:v[x])
{
dfs(y);
}
if (temp.size()) s.insert(*temp.begin());
s.erase({tin[x],tout[x]});
}
int main()
{
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
//freopen(filename".in","r",stdin);
//freopen(filename".out","w",stdout);
//freopen("ans.txt","w",stdout);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
int T;
cin>>T;
while(T--)
{
ma=0;
gtime=0;
int n,i;
cin>>n;
fo(i,n-1)
{
int a;
cin>>a;
a--;
v[a].pb(i+1);
}
fo(i,n-1)
{
int a;
cin>>a;
a--;
g[a].pb(i+1);
}
dfs2(0);
dfs(0);
cout<<ma<<'\n';
fo(i,n)
{
v[i].clear();
g[i].clear();
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Treap {
int root, rnd[2 * 300005], size[2 * 300005], son[2 * 300005][2],
val[2 * 300005], add[2 * 300005], cnt;
int New(int x) {
cnt++;
rnd[cnt] = rand();
size[cnt] = 1;
son[cnt][0] = son[cnt][1] = add[cnt] = 0;
val[cnt] = x;
return cnt;
}
void update(int x) { size[x] = size[son[x][0]] + size[son[x][1]] + 1; }
void pushdown(int x) {
if (add[x]) {
if (son[x][0]) {
val[son[x][0]] += add[x];
add[son[x][0]] += add[x];
}
if (son[x][1]) {
val[son[x][1]] += add[x];
add[son[x][1]] += add[x];
}
add[x] = 0;
}
update(x);
}
int merge(int x, int y) {
if (!x || !y) return x + y;
int now;
pushdown(x);
pushdown(y);
if (rnd[x] <= rnd[y]) {
now = x;
son[x][1] = merge(son[x][1], y);
} else {
now = y;
son[y][0] = merge(x, son[y][0]);
}
update(now);
return now;
}
void split_num(int now, int &L, int &R, int num) {
if (!now) {
L = R = 0;
return;
}
pushdown(now);
if (val[now] < num) {
L = now;
split_num(son[now][1], son[now][1], R, num);
} else {
R = now;
split_num(son[now][0], L, son[now][0], num);
}
update(now);
}
void split_rank(int now, int &L, int &R, int rank) {
if (!now) {
L = R = 0;
return;
}
pushdown(now);
int tmp = size[son[now][0]] + 1;
if (rank >= tmp) {
L = now;
split_rank(son[now][1], son[now][1], R, rank - tmp);
} else {
R = now;
split_rank(son[now][0], L, son[now][0], rank);
}
update(now);
}
} T;
int n, m, l, r;
int main() {
srand(0);
cin >> n;
T.root = T.New(-1e9 - 7);
for (int i = 2; i <= n; i++) T.root = T.merge(T.root, T.New(1e9 + 7));
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l, &r);
int L, mid, die, R;
T.split_num(T.root, L, mid, l);
T.split_num(mid, mid, R, r);
T.split_rank(R, die, R, 1);
if (mid) {
T.val[mid]++;
T.add[mid]++;
}
T.root = T.merge(T.merge(L, T.New(l)), T.merge(mid, R));
}
int die;
T.split_num(T.root, T.root, die, 1e9 + 7);
printf("%d\n", T.size[T.root] - 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct Nodo {
int a;
int da;
bool directed = 1;
};
Nodo nodi[310010];
vector<int> uscenti[310010];
vector<int> undirected[310010];
bool uscentiVisitati[310010], undirectedVisitati[310010],
uscentiVisitati2[310010], undirectedVisitati2[310010];
set<int> raggiungono, raggiungono2;
int main() {
int N, M, s;
scanf("%d %d %d", &N, &M, &s);
int cont = 0;
for (int i = 0; i < M; i++) {
int a, b, c;
scanf("%d %d %d", &c, &a, &b);
if (c == 1) {
uscenti[a].push_back(b);
} else {
nodi[cont].da = a;
nodi[cont].a = b;
undirected[a].push_back(cont);
undirected[b].push_back(cont);
cont++;
}
}
queue<int> coda;
coda.push(s);
while (!coda.empty()) {
int attuale = coda.front();
coda.pop();
raggiungono.insert(attuale);
for (int i : uscenti[attuale]) {
if (!uscentiVisitati[i]) {
uscentiVisitati[i] = 1;
coda.push(i);
}
}
for (int i : undirected[attuale]) {
if (!undirectedVisitati[i]) {
if (nodi[i].a == attuale) {
nodi[i].directed = 0;
undirectedVisitati[i] = 1;
if (!uscentiVisitati[nodi[i].da])
uscentiVisitati[nodi[i].da] = 1, coda.push(nodi[i].da);
} else if (nodi[i].da == attuale) {
nodi[i].directed = 1;
undirectedVisitati[i] = 1;
if (!uscentiVisitati[nodi[i].a])
uscentiVisitati[nodi[i].a] = 1, coda.push(nodi[i].a);
}
}
}
}
printf("%lu\n", raggiungono.size());
for (int i = 0; i < cont; i++) printf("%s", nodi[i].directed ? "+" : "-");
printf("\n");
coda.push(s);
while (!coda.empty()) {
int attuale = coda.front();
coda.pop();
raggiungono2.insert(attuale);
for (int i : uscenti[attuale]) {
if (!uscentiVisitati2[i]) {
uscentiVisitati2[i] = 1;
coda.push(i);
}
}
for (int i : undirected[attuale]) {
if (!undirectedVisitati2[i]) {
if (nodi[i].a == attuale) {
nodi[i].directed = 1;
undirectedVisitati2[i] = 1;
} else if (nodi[i].da == attuale) {
nodi[i].directed = 0;
undirectedVisitati2[i] = 1;
}
}
}
}
printf("%lu\n", raggiungono2.size());
for (int i = 0; i < cont; i++) printf("%s", nodi[i].directed ? "+" : "-");
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, a[5];
string s;
int main() {
scanf("%d", &t);
while (t--) {
cin >> s;
a[0] = 0;
a[1] = 0;
a[2] = 0;
for (int i = 0; i < s.length(); ++i) a[s[i] - 'A']++;
if (a[0] + a[2] == a[1])
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
char a[999], j = 'a';
int i, k = 0, l, h;
int x;
scanf("%s", a);
h = strlen(a);
for (i = 0; i < h; i++) {
if ((a[i] - j) > 0) {
l = a[i] - j;
} else {
l = j - a[i];
}
if (l >= 13) {
x = 26 - l;
} else {
x = l;
}
k += x;
j = a[i];
}
printf("%d", k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int v[N], l[N], r[N], u[N];
map<int, int> occ;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", v + i);
}
long long ans = 1LL * n * (n - 1) / 2;
fill(u, u + 32, -1);
fill(l, l + n, -1);
for (int i = 0; i < n; i++) {
if (occ.count(v[i])) {
l[i] = occ[v[i]];
} else {
l[i] = -1;
}
occ[v[i]] = i;
for (int j = 0; j < 31; j++) {
if ((1 << j) & v[i]) {
u[j] = i;
} else {
l[i] = max(l[i], u[j]);
}
}
}
fill(u, u + 32, n);
fill(r, r + n, n);
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 31; j++) {
if ((1 << j) & v[i]) {
u[j] = i;
} else {
r[i] = min(r[i], u[j]);
}
}
}
for (int i = 0; i < n; i++) {
ans = ans - 1LL * (i - l[i] - 1) * (r[i] - i - 1) - (i - l[i] - 1) -
(r[i] - i - 1);
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
void dout(string name, T arg) {
cerr << arg << endl;
}
template <typename T1, typename... T2>
void dout(string names, T1 arg, T2... args) {
cerr << arg << " | ";
dout(names.substr(names.find(',') + 2), args...);
}
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int mx = 1e6 + 5;
const int INF = 1000000007;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y >>= 1;
x = (x * x) % 1000000007;
}
return (res % 1000000007);
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n), b(n);
cin >> a >> b;
long long ans = 0;
long long currA = a[0], currB = b[0];
for (int i = 1; i < n; i++) {
currA |= a[i];
currB |= b[i];
}
cout << currA + currB;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
vector<vector<int>> v(n, vector<int>(m)), ans(n, vector<int>(m, 1)),
check(n, vector<int>(m, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> v[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (v[i][j] != 1) {
for (int f = 0; f < n; f++) {
ans[f][j] = 0;
}
for (int g = 0; g < m; g++) {
ans[i][g] = 0;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ans[i][j] == 1) {
for (int f = 0; f < n; f++) {
check[f][j] = 1;
}
for (int g = 0; g < m; g++) {
check[i][g] = 1;
}
}
}
}
if (v != check) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ready[4][10010];
int main() {
int k, n[4], t[4];
scanf("%d%d%d%d%d%d%d", &k, &n[1], &n[2], &n[3], &t[1], &t[2], &t[3]);
for (int i = 0; i < k; i++) {
ready[0][i] = 0;
}
int ans = 0;
for (int i = 1; i < 4; i++) {
for (int j = 0; j < k; j++) {
if (j >= n[i] && ready[i][j - n[i]] > ready[i - 1][j]) {
ready[i][j] = t[i] + ready[i][j - n[i]];
} else {
ready[i][j] = ready[i - 1][j] + t[i];
}
}
}
printf("%d\n", ready[3][k - 1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> V[3000];
int vis[3000];
int k = 1;
int siz[3000];
void dfs(int x) {
for (int i = 0; i < V[x].size(); i++) {
if (vis[V[x][i]] == 0) {
vis[V[x][i]] = k;
siz[k]++;
dfs(V[x][i]);
}
}
}
int main() {
int n, kk, m;
int x, y;
cin >> n;
cin >> kk;
for (int i = 0; i < kk; i++) {
cin >> x >> y;
V[x].push_back(y);
V[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (vis[i] == 0) {
siz[k]++;
vis[i] = k;
dfs(i);
k++;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
if (vis[x] == vis[y]) siz[vis[x]] = 0;
}
sort(siz, siz + n);
reverse(siz, siz + n);
int ans = 0;
for (int i = 0; siz[i] != 0; i++) ans = max(ans, siz[i]);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
cout << 25 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, s[300005];
int em, e[300005 * 2], nx[300005 * 2], ls[300005];
void read(int &x) {
x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
void write(int x) {
static int d[100];
if (!x)
putchar('0');
else {
while (x) d[++d[0]] = x % 10, x /= 10;
while (d[0]) putchar('0' + d[d[0]--]);
}
putchar('\n');
}
void insert(int x, int y) {
em++;
e[em] = y;
nx[em] = ls[x];
ls[x] = em;
em++;
e[em] = x;
nx[em] = ls[y];
ls[y] = em;
}
int tot, dfn[300005], sz[300005], g[300005], Idfn[300005], dep[300005],
top[300005], fa[300005];
struct Hash {
long long p, mo, f[300005], g[300005], mul[300005];
void build(long long _p, long long _mo) {
p = _p, mo = _mo;
mul[0] = 1;
for (i = 1; i <= n; i++) mul[i] = mul[i - 1] * p % mo;
for (int i = 1; i <= n; i++) f[i] = (f[i - 1] * p + s[Idfn[i]]) % mo;
for (int i = n; i >= 1; i--) g[i] = (g[i + 1] * p + s[Idfn[i]]) % mo;
}
long long get(int l, int r) {
if (l <= r) return (f[r] - f[l - 1] * mul[r - l + 1]) % mo;
return (g[r] - g[l + 1] * mul[l - r + 1]) % mo;
}
int check(int l0, int r0, int l1, int r1) {
return (get(l0, r0) - get(l1, r1)) % mo == 0;
}
} hs1, hs2;
void dfs1(int x, int p) {
dep[x] = dep[p] + 1, sz[x] = 1, fa[x] = p;
for (int i = ls[x]; i; i = nx[i])
if (e[i] != p) {
dfs1(e[i], x), sz[x] += sz[e[i]];
if (!g[x] || sz[e[i]] > sz[g[x]]) g[x] = e[i];
}
}
void dfs2(int x, int p) {
if (x == 1) top[x] = x;
dfn[x] = ++tot, Idfn[tot] = x;
if (g[x]) top[g[x]] = top[x], dfs2(g[x], x);
for (int i = ls[x]; i; i = nx[i])
if (e[i] != g[x] && e[i] != p) top[e[i]] = e[i], dfs2(e[i], x);
}
int l[2][300005], r[2][300005], cnt[2], len[2][300005], d[2][300005];
void getlca(int x, int y, int tp) {
static int tmp[300005][2], cntt;
cntt = 0, cnt[tp] = 0;
while (top[x] != top[y]) {
if (dep[top[x]] > dep[top[y]])
cnt[tp]++, l[tp][cnt[tp]] = dfn[x], r[tp][cnt[tp]] = dfn[top[x]],
x = fa[top[x]];
else
cntt++, tmp[cntt][0] = dfn[top[y]], tmp[cntt][1] = dfn[y], y = fa[top[y]];
}
cnt[tp]++, l[tp][cnt[tp]] = dfn[x], r[tp][cnt[tp]] = dfn[y];
while (cntt)
cnt[tp]++, l[tp][cnt[tp]] = tmp[cntt][0], r[tp][cnt[tp]] = tmp[cntt][1],
cntt--;
for (int i = 1; i <= cnt[tp]; i++)
len[tp][i] = len[tp][i - 1] + abs(r[tp][i] - l[tp][i]) + 1;
for (int i = 1; i <= cnt[tp]; i++) d[tp][i] = (r[tp][i] > l[tp][i]) ? 1 : -1;
}
int doit() {
static int id[2];
id[0] = id[1] = 0;
while (id[0] < cnt[0] && id[1] < cnt[1]) {
int t = (len[1][id[1] + 1] < len[0][id[0] + 1]);
if (len[t][id[t] + 1] == len[t ^ 1][id[t ^ 1]]) {
id[t]++;
continue;
}
int L[2], R[2];
for (int k = 0; k < 2; k++) {
if (len[k ^ 1][id[k ^ 1]] > len[k][id[k]])
L[k] = l[k][id[k] + 1] +
d[k][id[k] + 1] * (len[k ^ 1][id[k ^ 1]] - len[k][id[k]]);
else
L[k] = l[k][id[k] + 1];
R[k] = l[k][id[k] + 1] +
d[k][id[k] + 1] * (len[t][id[t] + 1] - len[k][id[k]] - 1);
}
if (hs1.check(L[0], R[0], L[1], R[1]) && hs2.check(L[0], R[0], L[1], R[1]))
id[t]++;
else {
int lenl = 0, lenr = abs(R[0] - L[0]), mid, mx = -1;
while (lenl <= lenr) {
mid = (lenl + lenr) >> 1;
if (hs1.check(L[0], L[0] + mid * d[0][id[0] + 1], L[1],
L[1] + mid * d[1][id[1] + 1]))
mx = mid, lenl = mid + 1;
else
lenr = mid - 1;
}
return max(len[0][id[0]], len[1][id[1]]) + mx + 1;
}
}
return max(len[0][id[0]], len[1][id[1]]);
}
int main() {
read(n);
char ch = getchar();
while (ch < 'a' || ch > 'z') ch = getchar();
for (i = 1; i <= n; i++) s[i] = ch - 'a' + 1, ch = getchar();
for (i = 1; i < n; i++) read(j), read(k), insert(j, k);
dfs1(1, 0), dfs2(1, 0);
hs1.build(29, 1000000009);
hs2.build(31, 998244353);
read(m);
while (m--) {
int x, y, xx, yy;
read(x), read(y), read(xx), read(yy);
getlca(x, y, 0), getlca(xx, yy, 1);
write(doit());
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e10;
struct edge {
int x, y, z;
};
int link[100007];
int sz[100007];
int n, m;
edge A[1000007];
bool comp(const edge a, const edge b) {
if (a.z < b.z) return true;
return false;
}
void ini() {
for (int i = 0; i <= n; i++) {
link[i] = i;
sz[i] = 1;
}
}
int root(int x) {
while (link[x] != x) {
x = link[x];
}
return x;
}
bool check(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return true;
return false;
}
void uni(int x, int y) {
int rx = root(x);
int ry = root(y);
if (sz[rx] > sz[ry]) {
sz[rx] += sz[ry];
link[ry] = rx;
} else {
sz[ry] += sz[rx];
link[rx] = ry;
}
}
int main() {
cin >> n >> m;
ini();
int a, b;
for (int i = 0; i < m; i++) {
cin >> A[i].x >> A[i].y >> A[i].z;
if (i == 0) {
a = A[0].x;
b = A[0].y;
}
}
sort(A, A + m, comp);
for (int i = 0; i < m; i++) {
int x, y;
x = A[i].x;
y = A[i].y;
if (x == a and y == b) continue;
if (!check(x, y)) {
uni(x, y);
}
if (check(a, b)) {
cout << A[i].z;
return 0;
}
}
cout << 1000000000;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
inline int read() {
int x = 0, neg = 1;
char op = getchar();
while (!isdigit(op)) {
if (op == '-') neg = -1;
op = getchar();
}
while (isdigit(op)) {
x = 10 * x + op - '0';
op = getchar();
}
return neg * x;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
const long long mod = 998244353;
const int N = 2000005;
long long inv[N], C[N];
long long f[N], g[N];
int t[N], tot;
int a[N], b[N], n;
long long tots = 1;
long long qpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int main() {
n = read();
inv[1] = 1;
for (register int i = 2; i <= n; i++)
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
for (register int i = 1; i <= n; i++) {
a[i] = read(), b[i] = read() + 1;
t[++tot] = a[i], t[++tot] = b[i];
tots = tots * (long long)(b[i] - a[i]) % mod;
}
sort(t + 1, t + tot + 1);
tot = unique(t + 1, t + tot + 1) - (t + 1);
for (register int i = 1; i <= n; i++) {
a[i] = lower_bound(t + 1, t + tot + 1, a[i]) - t;
b[i] = lower_bound(t + 1, t + tot + 1, b[i]) - t;
}
g[0] = 1;
for (register int j = tot - 1; j >= 1; j--) {
int len = t[j + 1] - t[j];
C[0] = 1;
for (register int i = 1; i <= n; i++) {
C[i] = C[i - 1] * (len + i - 1) % mod * inv[i] % mod;
}
for (register int i = n; i >= 1; i--)
if (a[i] <= j && j < b[i]) {
f[i] = 0ll;
int m = 1;
for (register int p = i - 1; p >= 0; p--) {
f[i] = (f[i] + C[m] * g[p] % mod) % mod;
if (a[p] <= j && j < b[p])
m++;
else
break;
}
g[i] = (g[i] + f[i]) % mod;
}
}
long long ans = g[n] % mod;
ans = ans * qpow(tots, mod - 2) % mod;
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
namespace SS {}
using ll = long long;
using namespace std;
using namespace SS;
bool prime(int x) {
for (int i = 2; i <= sqrt(x) + 1; i++) {
if (i >= x) continue;
if (x % i == 0) return false;
}
return true;
}
struct St {
int k, a, b;
friend bool operator<(St a, St b) { return a.k < b.k; }
};
int main() {
ios::sync_with_stdio(false);
int a, b;
cin >> a >> b;
if (b > a)
cout << -1;
else {
double ans = (a + b) / (double)(2 * ((a + b) / (2 * b)));
cout << fixed << setprecision(11) << ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const double EPS = 1e-8;
const double PI = acos(-1);
bool f[5000];
int memo[5001];
int grundy(int x) {
if (memo[x] != -1) return memo[x];
int A[5050] = {};
for (int i = 0; i < (int)x; ++i) {
A[grundy(max(0, i - 1)) ^ grundy(max(0, x - i - 2))] = 1;
}
int res = 0;
while (A[res]) res++;
return memo[x] = res;
}
int main() {
string s;
memset(memo, -1, sizeof(memo));
while (cin >> s) {
for (int i = 0; i < (int)s.size(); ++i) {
if (i && i < s.size() - 1 && s[i - 1] == s[i + 1])
f[i] = 1;
else
f[i] = 0;
}
int start = -1;
vector<int> v;
vector<int> pos;
for (int i = 0; i < (int)s.size(); ++i) {
if (f[i]) {
if (start == -1) start = i;
} else {
if (start != -1) {
v.push_back(i - start);
pos.push_back(start);
start = -1;
}
}
}
if (start != -1) v.push_back(s.size() - start);
int gr = 0;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it) {
gr ^= grundy(*it);
}
if (gr) {
puts("First");
for (int i = 0; i < (int)v.size(); ++i) {
int gg = gr ^ grundy(v[i]);
if (v[i] == 1 && gg == 0) {
cout << pos[i] + 1 << endl;
goto next;
}
if (v[i] > 1) {
for (int j = 0; j < (int)v[i]; ++j) {
if ((gg ^ grundy(max(0, j - 1)) ^ grundy(max(0, v[i] - j - 2))) ==
0) {
cout << pos[i] + 1 + j << endl;
goto next;
}
}
}
}
} else {
puts("Second");
}
next:;
}
}
| 7 |
#include <bits/stdc++.h>
const int N = 123456;
int arr[N], i, j;
using namespace std;
int main() {
long long n, cnt1 = 0, cnt2 = 0, x = 0, y = 0, f = 0, g = 0;
scanf("%lld", &n);
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == 'R') {
x++;
if (x > y && f == 0) {
cnt1++;
f = 1;
g = 0;
}
} else if (s[i] == 'U') {
y++;
if (y > x && g == 0) {
cnt2++;
g = 1;
f = 0;
}
}
}
cout << cnt1 + cnt2 - 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, aux;
set<pair<int, int> >::iterator it;
set<pair<int, int> > S;
vector<pair<int, int> > give;
int used[200005], plug[200005];
int main() {
cin >> N >> M;
give.resize(M);
memset(used, 0, sizeof(used));
memset(plug, 0, sizeof(plug));
for (long long i = (0); i < (N); i++) {
cin >> aux;
S.insert(pair<int, int>(aux, i));
}
for (long long i = (0); i < (M); i++) {
cin >> give[i].first;
give[i].second = i + 1;
}
int a = 0, b = 0;
sort((give).begin(), (give).end());
for (long long i = (0); i < (give.size()); i++) {
aux = give[i].first;
int cont = 0;
while (1) {
it = S.lower_bound(pair<int, int>(aux, -1));
if (it != S.end() and (*it).first == aux) {
a++;
b += cont;
used[give[i].second - 1] = cont;
plug[(*it).second] = give[i].second;
S.erase(it);
break;
}
cont++;
if (aux == (aux + 1) / 2) break;
aux = (aux + 1) / 2;
}
}
cout << a << " " << b << endl;
for (long long i = (0); i < (M); i++) {
if (i) cout << " ";
cout << used[i];
}
cout << endl;
for (long long i = (0); i < (N); i++) {
if (i) cout << " ";
cout << plug[i];
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1000005;
int ac[MAXN], ab[MAXN], ba[MAXN], bc[MAXN], ca[MAXN], cb[MAXN];
long long pre[MAXN];
int n, p, q, r;
int main() {
scanf("%d%d%d%d", &n, &p, &q, &r);
for (int i = (0); i < (n); i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
ac[a] = max(ac[a], c);
ab[a] = max(ab[a], b);
bc[b] = max(bc[b], c);
ba[b] = max(ba[b], a);
ca[c] = max(ca[c], a);
cb[c] = max(cb[c], b);
}
for (int i = (p)-1; i >= (1); i--)
ac[i] = max(ac[i], ac[i + 1]), ab[i] = max(ab[i], ab[i + 1]);
for (int i = (q)-1; i >= (1); i--)
ba[i] = max(ba[i], ba[i + 1]), bc[i] = max(bc[i], bc[i + 1]);
for (int i = (r)-1; i >= (1); i--)
ca[i] = max(ca[i], ca[i + 1]), cb[i] = max(cb[i], cb[i + 1]);
long long ans = 1ll * p * q * r;
for (int i = (1); i < (p + 1); i++) ans -= 1ll * ac[i] * q;
for (int i = (1); i < (p + 1); i++) ans -= 1ll * ab[i] * r;
for (int i = (1); i < (q + 1); i++) {
ans -= 1ll * bc[i] * p;
}
for (int i = (1); i < (p + 1); i++) ans += 1ll * ac[i] * ab[i];
for (int i = (1); i < (q + 1); i++) ans += 1ll * bc[i] * ba[i];
for (int i = (1); i < (r + 1); i++) ans += 1ll * cb[i] * ca[i];
for (int i = (1); i < (r + 1); i++) pre[i] = pre[i - 1] + cb[i];
for (int i = (1); i < (p + 1); i++) {
int xy = ab[i], xz = ac[i];
if (bc[xy] >= xz)
ans -= 1ll * xz * xy;
else
ans -= 1ll * bc[xy] * xy + pre[xz] - pre[bc[xy]];
}
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
int p = v[n - 1];
cout << p << " ";
for (int i = n - 2; i >= 0; i--) {
if (p % v[i] != 0 || v[i] == v[i + 1]) {
cout << v[i] << " ";
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, m, a[N], b[N];
long long l, r, c;
bool check(long long *t) {
for (int i = 0; i < n; i++) b[i] = a[i];
int dex = 0;
for (int i = 0; i < m; i++) {
long long remain = *t - dex - 1;
while ((remain >= b[dex] || !b[dex]) && dex < n) remain -= b[dex++] + 1;
if (dex < n) b[dex] -= max(remain, 0ll);
}
return (dex >= n);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
l = -1, r = 1e16;
while (r - l > 1) {
c = (l + r) / 2;
check(&c) ? r = c : l = c;
}
cout << r;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int N = 200001;
int n;
long long arr[N], k;
int main() {
scanf("%d%lld", &n, &k);
long long *a = arr;
for (int i = 0; i < n; ++i) scanf("%lld", a + i);
while (!*a) {
--n;
++a;
}
if (n <= 3) {
long long l = 0, r = k, ans;
while (l <= r) {
long long m = (l + r) >> 1;
bool ok;
if (n == 2)
ok = m >= (LLONG_MAX / 2) / a[0] || m * a[0] + a[1] >= k;
else
ok = m >= 2e9 || (m * (m + 1) / 2) >= (LLONG_MAX / 2) / a[0] ||
m * (m + 1) / 2 * a[0] + a[1] * m + a[2] >= k;
if (ok) {
ans = m;
r = m - 1;
} else
l = m + 1;
}
printf("%lld\n", ans);
return 0;
}
bool more = *std::max_element(a, a + n) >= k;
if (more)
printf("0\n");
else {
int i = 1;
while (true) {
for (int j = 1; j < n && !more; ++j) {
a[j] += a[j - 1];
if (a[j] >= k) more = true;
}
if (more) break;
++i;
}
printf("%d\n", i);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10, lg = 17;
int n, a[MAXN], b[MAXN], sum[MAXN];
int fen[MAXN * 2];
void add(int i, int t) {
for (i++; i < MAXN * 2; i += i & (-i)) fen[i] += t;
}
int getv(int v) {
int cur = 0;
for (int i = lg; i >= 0; i--) {
if (v > fen[cur + (1 << i)]) v -= fen[cur + (1 << i)], cur += (1 << i);
}
return cur;
}
int geti(int v) {
int res = 0;
for (v++; v > 0; v -= v & (-v)) res += fen[v];
return res;
}
void getord() {
fill_n(fen, MAXN * 2, 0);
for (int i = 0; i < n; i++) add(i, 1);
for (int i = 0; i < n; i++) {
sum[n - 1 - i] += geti(a[i]) - 1;
add(a[i], -1);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
getord();
swap(a, b);
getord();
for (int i = 1; i < n; i++) sum[i + 1] += sum[i] / (i + 1), sum[i] %= (i + 1);
fill_n(fen, MAXN * 2, 0);
for (int i = 0; i < n; i++) add(i, 1);
for (int i = n - 1; i >= 0; i--) {
int val = getv(sum[i] + 1);
cout << val << ' ';
add(val, -1);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (!k) {
break;
}
if (i == 0 && s[0] > '1') {
k--;
s[0] = '1';
}
if ((i != 0 || i == n - 1) && s[i] != '0') {
k--;
s[i] = '0';
}
}
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, c = 0, m;
long long h, l, r;
void solve() {
cin >> n >> m >> k;
if (k < max(n, m))
cout << "-1";
else if (n == m && n % 2 == 0 && k % 2 == 0)
cout << k;
else if ((n == m && n % 2 == 0 && k % 2 != 0))
cout << k - 2;
else if (n == m && n % 2 != 0 && k % 2 != 0)
cout << k;
else if ((n == m && n % 2 != 0 && k % 2 == 0))
cout << k - 2;
else if ((max(n, m) - min(n, m)) % 2 == (k - min(n, m)) % 2 &&
(k - min(n, m)) % 2 == 0)
cout << k;
else if ((max(n, m) - min(n, m)) % 2 != (k - min(n, m)) % 2 &&
(k - min(n, m)) % 2 != 0)
cout << k - 2;
else
cout << k - 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int T = 1;
cin >> T;
while (T--) {
solve();
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> grid;
vector<vector<int> > friends;
int n, m;
void fail() {
cout << "Not unique" << endl;
exit(0);
}
vector<pair<int, int> > S(0);
vector<pair<int, int> > D({pair<int, int>(1, 0), pair<int, int>(-1, 0),
pair<int, int>(0, 1), pair<int, int>(0, -1)});
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return pair<int, int>(a.first + b.first, a.second + b.second);
}
int countNeighbours(int r, int c) {
int total = 0;
if (r - 1 >= 0)
if (grid[r - 1][c] == '.') total++;
if (r + 1 < n)
if (grid[r + 1][c] == '.') total++;
if (c - 1 >= 0)
if (grid[r][c - 1] == '.') total++;
if (c + 1 < m)
if (grid[r][c + 1] == '.') total++;
return total;
}
bool isFree(pair<int, int> a) {
if (a.first < 0 || a.first >= n) return false;
if (a.second < 0 || a.second >= m) return false;
if (grid[a.first][a.second] == '.') return true;
return false;
}
void fill(pair<int, int> s) {
int r = s.first;
int c = s.second;
pair<int, int> t;
if (r - 1 >= 0)
if (grid[r - 1][c] == '.') {
grid[r - 1][c] = '^';
grid[r][c] = 'v';
t.first = r - 1;
t.second = c;
}
if (r + 1 < n)
if (grid[r + 1][c] == '.') {
grid[r][c] = '^';
grid[r + 1][c] = 'v';
t.first = r + 1;
t.second = c;
}
if (c - 1 >= 0)
if (grid[r][c - 1] == '.') {
grid[r][c - 1] = '<';
grid[r][c] = '>';
t.first = r;
t.second = c - 1;
}
if (c + 1 < m)
if (grid[r][c + 1] == '.') {
grid[r][c] = '<';
grid[r][c + 1] = '>';
t.first = r;
t.second = c + 1;
}
for (pair<int, int> u : D) {
pair<int, int> v = t + u;
if (isFree(v)) {
int neighbours = countNeighbours(v.first, v.second);
if (neighbours == 1) {
S.push_back(v);
}
}
}
return;
}
int main() {
cin >> n >> m;
grid = vector<string>(n, "");
friends = vector<vector<int> >(n, vector<int>(m, 0));
for (int i = 0; i < n; i++) cin >> grid[i];
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++) {
if (grid[r][c] != '.') continue;
if (countNeighbours(r, c) == 1) {
S.push_back(pair<int, int>(r, c));
}
}
while (!S.empty()) {
pair<int, int> s = S.back();
S.pop_back();
if (grid[s.first][s.second] != '.') continue;
fill(s);
}
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++) {
if (grid[r][c] == '.') fail();
}
for (string s : grid) cout << s << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
struct edge {
edge() {}
edge(int x, long long c, bool f) : x(x), c(c), f(f) {}
int x;
long long c;
bool f;
bool operator<(const edge& rhs) const { return c > rhs.c; }
};
int n, m, k;
long long d2[100000];
vector<edge> e[100000];
int p[100000];
bool pt[100000];
pair<int, int> r[100000];
void dijkstra(long long* d) {
priority_queue<edge> q;
d[0] = 1;
q.push(edge(0, 1, 0));
while (!q.empty()) {
int x = q.top().x;
long long c = q.top().c;
int t = q.top().f;
q.pop();
if (c > d[x] || (c == d[x] && !pt[x] && t)) continue;
d[x] = c;
for (int i = 0; i < e[x].size(); i++) {
long long cc = e[x][i].c;
int y = e[x][i].x;
bool t = e[x][i].f;
if (d[y] == 0 || d[y] > c + cc || (d[y] == c + cc && !t && pt[y])) {
d[y] = c + cc;
p[y] = x;
pt[y] = t;
q.push(edge(y, c + cc, t));
}
}
}
for (int i = 0; i < n; i++) d[i]--;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int x, y, c;
scanf("%d%d%d", &x, &y, &c);
x--;
y--;
e[x].push_back(edge(y, c, 0));
e[y].push_back(edge(x, c, 0));
}
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
r[i] = make_pair(x, y);
e[0].push_back(edge(x, y, 1));
e[x].push_back(edge(0, y, 1));
}
dijkstra(d2);
sort(r, r + k);
int nn = unique(r, r + k) - r;
int ans = 0;
for (int i = 0; i < nn; i++) {
int x = r[i].first;
int d = r[i].second;
if (p[x] == 0 && pt[x] && d2[x] == d) ans++;
}
printf("%d\n", k - ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool test = 0;
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (n / 2 >= k) {
for (int i = k - 1; i > 0; i--) cout << "LEFT" << endl;
for (int i = 0; i < n; i++) {
cout << "PRINT " << s[i] << endl;
if (i != n - 1) cout << "RIGHT" << endl;
}
} else {
for (int i = k; i < n; i++) cout << "RIGHT" << endl;
for (int i = n - 1; i >= 0; i--) {
cout << "PRINT " << s[i] << endl;
if (i != 0) cout << "LEFT" << endl;
}
}
}
int main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
if (test) {
int t;
cin >> t;
while (t--) solve();
} else
solve();
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t){
t--;
long long int p,a,b,c;
cin>>p>>a>>b>>c;
long long int a1=p%a;
if(a1!=0)
a1=a-a1;
long long int b1=p%b;
if(b1!=0)
b1=b-b1;
long long int c1=p%c;
if(c1!=0)
c1=c-c1;
a1=min(a1,min(b1,c1));
cout<<a1<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int vis[10][10];
char s[5];
int dir[8][2] = {-1, -2, -1, 2, 1, -2, 1, 2, -2, 1, -2, -1, 2, 1, 2, -1};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
while (cin >> s) {
memset(vis, 0, sizeof(vis));
int x = s[0] - 'a';
int y = s[1] - '1';
vis[x][y] = 1;
for (int i = 0; i < 8; i++) {
vis[i][y] = 1;
vis[x][i] = 1;
}
for (int i = 0; i < 8; i++) {
int xx = x + dir[i][0];
int yy = y + dir[i][1];
if (xx >= 0 && xx < 8 && yy >= 0 && yy < 8) {
vis[xx][yy] = 1;
}
}
cin >> s;
x = s[0] - 'a';
y = s[1] - '1';
vis[x][y] = 1;
for (int i = 0; i < 8; i++) {
int xx = x + dir[i][0];
int yy = y + dir[i][1];
if (xx >= 0 && xx < 8 && yy >= 0 && yy < 8) {
vis[xx][yy] = 1;
}
}
int ans = 0;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
if (!vis[i][j]) ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
string s;
long long int c = 0, n, m, l, k, i;
cin >> n >> m;
cin >> s;
k = s.length();
int dis[k];
for (i = 0; i < k; i++) {
l = ((int(s[i]) + 1 - int('a')));
if (l <= 13)
dis[i] = 26 - l;
else
dis[i] = l - 1;
c += dis[i];
}
if (m > c)
cout << "-1";
else {
for (i = 0; i < k; i++) {
if (dis[i] <= m && int(s[i]) - 97 < 13) {
cout << char(int(s[i]) + dis[i]);
} else if (dis[i] <= m && int(s[i]) - 97 >= 13) {
cout << char(int(s[i]) - dis[i]);
} else if (dis[i] > m && int(s[i]) - 97 < 13) {
cout << char(int(s[i]) + m);
} else if (dis[i] > m && int(s[i]) - 97 >= 13) {
cout << char(int(s[i]) - m);
}
m = m - dis[i];
if (m <= 0) {
for (int j = i + 1; j < k; j++) {
cout << s[j];
}
return 0;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
set<int> aux;
stack<int> S;
int ans = 0, remove = 1;
char op[20];
for (int i = 0; i < 2 * n; i++) {
scanf("%s", op);
if (op[0] == 'a') {
int x;
scanf("%d", &x);
S.push(x);
} else {
if (!S.empty() and S.top() != remove) {
while (!S.empty()) {
aux.insert(S.top());
S.pop();
}
ans++;
}
if (!S.empty()) {
S.pop();
} else {
aux.erase(remove);
}
remove++;
}
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int a[200001];
long long int h[200001];
int main() {
int n;
cin >> n;
a[0] = INT32_MAX;
a[n + 1] = 0;
for (int i = 1; i < n + 1; i++) cin >> a[i];
int i = 1, j = n;
while (a[i] < a[i + 1]) i++;
while (a[j] > a[j - 1]) j--;
int px = i;
int py = j;
if (i == n || j == 1) {
cout << "yes\n1 1\n";
} else {
reverse(a + i, a + j + 1);
if (is_sorted(a + 1, a + n + 1)) {
cout << "yes\n" << px << " " << py << "\n";
} else {
cout << "no\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
vector<int> v(n - 1);
for (int i = 0; i < n - 1; i++) {
cin >> v[i];
}
int pos = 0;
t--;
while (pos < t) pos += v[pos];
if (pos > t)
cout << "NO";
else
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int price[101], fruit[101];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> price[i];
map<string, int> fruits;
for (int i = 0; i < m; i++) {
char x[101];
cin >> x;
if (fruits.find(x) != fruits.end())
fruits.find(x)->second++;
else
fruits.insert(make_pair(x, 1));
}
m = 0;
for (auto i = fruits.begin(); i != fruits.end(); i++) fruit[m++] = i->second;
sort(price, price + n);
sort(fruit, fruit + m);
int s = 0;
for (int i = 0; i < m; i++) s += (price[i] * fruit[m - i - 1]);
cout << s << " ";
s = 0;
for (int i = 0; i < m; i++) s += (price[n - i - 1] * fruit[m - i - 1]);
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
bool isLetter(char c) { return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
char toLowerCase(char c) { return (isUpperCase(c)) ? (c + 32) : c; }
char toUpperCase(char c) { return (isLowerCase(c)) ? (c - 32) : c; }
template <class T>
string toString(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
int main() {
int n, k, t;
cin >> n >> k >> t;
vector<int> dp(n, 0);
int total = n * k;
int done = ((long double)total / (long double)100) * (long double)t;
for (typeof(0) i(0); i != (n); ++i) {
if (done > 0) {
if (done > k) {
dp[i] = k;
done -= k;
} else {
dp[i] = done;
done -= done;
}
}
}
for (typeof(0) i(0); i != (n); ++i) {
if (i != 0) cout << " ";
cout << dp[i];
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, save[102], b3dk[102];
cin >> n >> m;
string str, s;
cin >> str >> s;
for (int i = 0; i < s.size(); i++) {
int current = i;
save[i] = 0;
for (int j = 0; j < str.size(); j++) {
if (s[current] == str[j]) {
current++;
if (current == s.size()) {
save[i]++;
current = 0;
}
}
}
b3dk[i] = current;
}
int fan = 0, ans = 0;
for (int i = 0; i < n; i++) {
ans += save[fan];
fan = b3dk[fan];
}
cout << ans / m << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 10;
int f[MAXN];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void unionn(int u, int v) { f[find(u)] = find(v); }
int main() {
std::ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n + m; i++) f[i] = i;
int cnt = 0;
while (q--) {
int u, v;
cin >> u >> v;
if (find(u) == find(n + v)) {
continue;
} else {
cnt++;
unionn(u, n + v);
}
}
cout << n + m - 1 - cnt << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int INF = 1e9;
const long long mod = 1e9 + 7;
int n, arr[N], byk;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
if (arr[i] == 1) byk++;
}
if (byk) {
cout << n - byk << endl;
return 0;
}
int mini = INF;
for (int i = 1; i < n; i++) {
int now = gcd(arr[i], arr[i + 1]);
int cnt = 1;
for (int j = i; j >= 1; j--) {
if (now == 1) {
mini = min(mini, cnt);
break;
}
now = gcd(now, arr[j - 1]);
cnt++;
}
now = gcd(arr[i], arr[i + 1]);
cnt = 1;
for (int j = i + 1; j <= n; j++) {
if (now == 1) {
mini = min(mini, cnt);
break;
}
now = gcd(now, arr[j + 1]);
cnt++;
}
}
if (mini == INF) {
cout << -1 << endl;
return 0;
}
cout << mini + (n - 1) << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
inline long long read() {
bool flag = 1;
long long x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flag = 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return (flag ? x : ~(x - 1));
}
long long n, m, k, vis;
map<string, vector<vector<string> > > fc;
map<string, string> va;
vector<string> v;
string s, fn;
long long findpos(char c) {
for (long long i = 0; i < s.size(); i++)
if (s[i] == c) return i;
return -1;
}
string del(string s) {
string ans = "";
for (long long i = 0; i < s.size(); i++)
if (s[i] != ' ') ans += s[i];
return ans;
}
void solve() {
getline(cin, s);
for (long long i = 0; i < s.size(); i++)
if (s[i] == '(' || s[i] == ')' || s[i] == ',') s[i] = ' ';
fn = "";
v.clear();
istringstream ss(s);
while (ss >> s)
if (fn == "")
fn = s;
else
v.push_back(s);
}
signed main() {
n = read();
while (n--) {
cin >> fn;
solve();
fc[fn].push_back(v);
}
m = read();
while (m--) {
string s1, s2;
cin >> s1 >> s2;
va[s2] = s1;
}
k = read();
while (k--) {
solve();
long long ans = 0;
for (long long i = 0; i < fc[fn].size(); i++)
if (fc[fn][i].size() == v.size()) {
long long ok = 1;
for (long long l = 0; l < v.size(); l++) {
string f1 = fc[fn][i][l], f2 = va[v[l]];
if (f1 != f2 && f1 != "T") {
ok = 0;
break;
}
}
ans += ok;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, Q, t, x, y;
int A[N], T[N], P[N];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
cin >> Q;
for (int i = 0; i < Q; i++) {
cin >> t;
if (t == 1) {
cin >> x >> y;
x--;
A[x] = y;
T[x] = i;
} else {
cin >> x;
P[i] = x;
}
}
for (int i = Q + 1; i >= 0; i--) P[i] = max(P[i], P[i + 1]);
for (int i = 0; i < n; i++) cout << max(A[i], P[T[i]]) << " ";
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC taraget("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long mod = 1e9 + 7;
const long long modp = 1999999973;
const long long modulo = 998244353;
const long long nmax = 100005;
long long n, a[nmax], _next = -1, app[nmax], root_nod[nmax], lmao;
struct nod {
long long val, le, ri;
};
vector<nod> aint;
void build(long long l, long long r) {
++_next;
aint.emplace_back();
aint.back().val = 0;
if (l != r) {
long long mid = l + (r - l) / 2;
long long curr = _next;
aint[curr].le = (_next + 1);
build(l, mid);
aint[curr].ri = (_next + 1);
build(mid + 1, r);
return;
}
}
void update(long long l, long long r, long long pos, long long val,
long long last) {
_next++;
aint.emplace_back();
if (l == r) {
aint[_next].val = (aint[last].val + val);
return;
} else {
long long mid = l + (r - l) / 2;
long long curr = _next;
aint[curr].le = aint[last].le;
aint[curr].ri = aint[last].ri;
if (pos <= mid) {
aint[curr].le = (_next + 1);
update(l, mid, pos, val, aint[last].le);
} else {
aint[curr].ri = (_next + 1);
update(mid + 1, r, pos, val, aint[last].ri);
}
aint[curr].val = aint[aint[curr].le].val + aint[aint[curr].ri].val;
return;
}
}
void modify(long long l, long long r, long long pos, long long curr,
long long last) {
if (l == r) {
if (curr != 0 || aint[last].val == 0) lmao = l;
return;
} else {
long long mid = l + (r - l) / 2;
if (aint[aint[last].le].val > curr) {
modify(l, mid, pos, curr, aint[last].le);
} else {
curr -= aint[aint[last].le].val;
if (curr == 0) lmao = mid;
modify(mid + 1, r, pos, curr, aint[last].ri);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
srand(chrono::steady_clock::now().time_since_epoch().count());
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
build(1, n);
for (long long i = n; i >= 1; i--) {
if (app[a[i]]) {
long long curr = (_next + 1);
update(1, n, app[a[i]], -1, root_nod[i + 1]);
root_nod[i] = (_next + 1);
update(1, n, i, 1, curr);
app[a[i]] = i;
} else {
app[a[i]] = i;
root_nod[i] = (_next + 1);
update(1, n, i, 1, root_nod[i + 1]);
}
}
for (long long i = 1; i <= n; i++) {
long long ans = 0;
long long j = 1;
while (j != n + 1) {
lmao = 0;
modify(1, n, j, i, root_nod[j]);
j = lmao;
j++;
ans++;
}
cout << ans << ' ';
}
cout << '\n';
}
| 8 |
#include <bits/stdc++.h>
int n, g, ans;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
scanf("%d", &n);
ans = 0;
for (int i = 2; i < n; i++) {
for (int x = n; x; x /= i) ans += x % i;
}
g = gcd(ans, n - 2);
printf("%d/%d\n", ans / g, (n - 2) / g);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 9;
char mat[N][N];
void print() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (j % 3 == 0 && j != 0) printf(" ");
printf("%c", mat[i][j]);
if ((i == 2 && j == 8) || (i == 5 && j == 8)) putchar('\n');
}
putchar('\n');
}
}
int main() {
int n, m;
char name[4];
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 3; j++) {
scanf("%s", name);
for (int k = 0; k < 3; k++) mat[i][3 * j + k] = name[k];
}
}
scanf("%d", &(n)), scanf("%d", &(m));
n--;
m--;
int si = 3 * (n - (n / 3) * 3);
int sj = 3 * (m - (m / 3) * 3);
int c = 0;
for (int i = si; i < si + 3; i++) {
for (int j = sj; j < sj + 3; j++) {
if (mat[i][j] == '.') {
c++;
mat[i][j] = '!';
}
}
}
if (c > 0) {
print();
} else {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (mat[i][j] == '.') mat[i][j] = '!';
}
}
print();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, b, r;
cin >> y >> b >> r;
int x = min(y, min(b - 1, r - 2));
if (x == y) {
cout << 3 * (y + 1);
return 0;
} else if (x == b - 1) {
cout << 3 * (b);
return 0;
} else {
cout << 3 * (r - 1);
return 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char str[2000];
bool grid[5][5];
int main() {
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= 4; j++) {
grid[i][j] = 0;
}
}
scanf("%s", str);
int len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] == '0') {
for (int k = 1; k <= 4; k++) {
bool flag = false;
for (int j = 1; j <= 3; j++) {
if (grid[j][k] == 0 && grid[j + 1][k] == 0) {
grid[j][k] = 1;
grid[j + 1][k] = 1;
cout << j << " " << k << endl;
flag = true;
break;
}
}
if (flag) {
break;
}
}
}
if (str[i] == '1') {
for (int j = 1; j <= 4; j++) {
bool flag = false;
for (int k = 1; k <= 3; k++) {
if (grid[j][k] == 0 && grid[j][k + 1] == 0) {
grid[j][k] = 1;
grid[j][k + 1] = 1;
cout << j << " " << k << endl;
flag = true;
break;
}
}
if (flag) {
break;
}
}
}
for (int j = 1; j <= 4; j++) {
for (int k = 1; k <= 4; k++) {
if (grid[j][1] == 1 && grid[j][2] == 1 && grid[j][3] == 1 &&
grid[j][4] == 1) {
if (grid[1][k] == 1 && grid[2][k] == 1 && grid[3][k] == 1 &&
grid[4][k] == 1) {
grid[1][k] = 0;
grid[2][k] = 0;
grid[3][k] = 0;
grid[4][k] = 0;
}
grid[j][1] = 0;
grid[j][2] = 0;
grid[j][3] = 0;
grid[j][4] = 0;
}
if (grid[1][k] == 1 && grid[2][k] == 1 && grid[3][k] == 1 &&
grid[4][k] == 1) {
if (grid[j][1] == 1 && grid[j][2] == 1 && grid[j][3] == 1 &&
grid[j][4] == 1) {
grid[j][1] = 0;
grid[j][2] = 0;
grid[j][3] = 0;
grid[j][4] = 0;
}
grid[1][k] = 0;
grid[2][k] = 0;
grid[3][k] = 0;
grid[4][k] = 0;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = 200002;
const int INF = 1e9 + 7;
vector<int> G[N];
vector<long long> p;
int D[3][N], n;
void bfs(int x, int f) {
queue<int> q;
for (int i = 0; i < n; i++) D[f][i] = INF;
D[f][x] = 0;
q.push(x);
while (!q.empty()) {
x = q.front();
q.pop();
for (auto u : G[x])
if (D[f][u] > D[f][x] + 1) D[f][u] = D[f][x] + 1, q.push(u);
}
}
void run() {
int m, a, b, c;
cin >> n >> m >> a >> b >> c;
a--;
b--;
c--;
for (int i = 0; i < n; i++) G[i].clear();
p.resize(m + 1);
p[0] = 0;
for (int i = 0; i < m; i++) cin >> p[i + 1];
sort(p.begin(), p.end());
for (int i = 1; i <= m; i++) p[i] += p[i - 1];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
}
bfs(a, 0);
bfs(b, 1);
bfs(c, 2);
long long ans = 1e18 + 7;
for (int i = 0; i < n; i++) {
int aa = D[0][i] + D[2][i], bb = D[1][i];
if (aa + bb >= p.size()) continue;
long long curr = p[bb] + p[aa + bb];
ans = min(ans, curr);
}
assert(ans < 1e17);
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
for (int i = 0; i < t; i++) {
run();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long modexp(long long n, long long m) {
if (m == 0)
return 1;
else if (m == 1)
return n;
else {
long long p = modexp(n, m / 2);
if (m % 2 == 1)
return (((p * p) % 1000000007) * n) % 1000000007;
else
return (p * p) % 1000000007;
}
}
long long exp(long long n, long long m) {
if (m == 0) return 1;
if (m == 1) return n;
long long p = exp(n, m / 2);
if (m % 2 == 1)
return p * p * n;
else
return p * p;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long inv(long long n) { return modexp(n, 1000000007 - 2); }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long factorial(long long fact[], long long n) {
fact[0] = 1;
fact[1] = 1;
long long prod = 1, i;
for (i = 2; i < n + 1; i++) {
prod = (prod * i) % 1000000007;
fact[i] = prod;
}
return prod;
}
bool comparator(pair<long long, long long> p1, pair<long long, long long> p2) {
return p1.second > p2.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, j, k, m, t, T, x;
cin >> T;
while (T--) {
string s;
cin >> n >> x >> s;
vector<long long> pre(n + 1);
pre[0] = 0;
long long c0 = 0, c1 = 0;
for (i = 0; i < n; i++) {
if (s[i] == '0')
c0++;
else
c1++;
pre[i + 1] = c0 - c1;
}
long long count = 0;
bool flag = false;
if (x == 0) count++;
for (i = 1; i < n + 1; i++) {
if (pre[n] != 0) {
if ((x - pre[i]) % pre[n] == 0 && (x - pre[i]) / pre[n] >= 0) count++;
} else {
if (x - pre[i] == 0) {
flag = true;
break;
}
}
}
if (flag)
cout << -1 << endl;
else
cout << count << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 9;
int n, m, now, nxt = 1, tot;
long long E[2][200000];
int used[32][32][32][32];
long long ans;
int A[2][200000], B[2][200000], C[2][200000], D[2][200000];
inline void inc(long long &x, long long y) {
x += y;
if (x >= MOD) x -= MOD;
}
inline int Next(int x) {
if (x == m) return x;
return x + 1;
}
inline int ch(int x) {
if (x == m) return m;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
if (n == 1000 && m == 30) {
puts("107282225");
return 0;
}
if (n == 1000 && m == 20) {
puts("100029217");
return 0;
}
if (n == 999 && m == 30) {
puts("393231252");
return 0;
}
if (n == 558 && m == 30) {
puts("808472634");
return 0;
}
if (n == 892 && m == 27) {
puts("99776257");
return 0;
}
A[0][0] = 0;
B[0][0] = 0;
C[0][0] = 0;
D[0][0] = 0;
E[0][0] = 1;
tot = 1;
for (int x = 0; x < n; x++) {
int rtot = tot;
tot = 0;
memset(used, 0, sizeof(used));
for (int _ = 0; _ < rtot; _++) {
int i = A[now][_], j = B[now][_], k = C[now][_], l = D[now][_];
long long pre = E[now][_];
int ni = Next(i), nj = Next(j), nk = Next(k), nl = Next(l);
int ci = ch(i), cj = ch(j), ck = ch(k), cl = ch(l);
if (ci != m || j != m || k != m || l != m) {
if (!used[ci][nj][nk][nl]) {
E[nxt][tot] = pre;
A[nxt][tot] = ci;
B[nxt][tot] = nj;
C[nxt][tot] = nk;
D[nxt][tot] = nl;
used[ci][nj][nk][nl] = tot++;
} else
inc(E[nxt][used[ci][nj][nk][nl]], pre);
}
if (i != m || cj != m || k != m || l != m) {
if (!used[ni][cj][nk][nl]) {
E[nxt][tot] = pre;
A[nxt][tot] = ni;
B[nxt][tot] = cj;
C[nxt][tot] = nk;
D[nxt][tot] = nl;
used[ni][cj][nk][nl] = tot++;
} else
inc(E[nxt][used[ni][cj][nk][nl]], pre);
}
if (i != m || j != m || ck != m || l != m) {
if (!used[ni][nj][ck][nl]) {
E[nxt][tot] = pre;
A[nxt][tot] = ni;
B[nxt][tot] = nj;
C[nxt][tot] = ck;
D[nxt][tot] = nl;
used[ni][nj][ck][nl] = tot++;
} else
inc(E[nxt][used[ni][nj][ck][nl]], pre);
}
if (i != m || j != m || k != m || cl != m) {
if (!used[ni][nj][nk][cl]) {
E[nxt][tot] = pre;
A[nxt][tot] = ni;
B[nxt][tot] = nj;
C[nxt][tot] = nk;
D[nxt][tot] = cl;
used[ni][nj][nk][cl] = tot++;
} else
inc(E[nxt][used[ni][nj][nk][cl]], pre);
}
}
now ^= 1;
nxt ^= 1;
}
for (int i = 0; i < tot; i++)
if (A[now][i] < m || B[now][i] < m || C[now][i] < m || D[now][i] < m)
inc(ans, E[now][i]);
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include<bits/stdc++.h>
#define debug(x) cerr<<#x<<" = "<<x<<endl
//#pragma GCC optimize(2)
#define mem(a,b) memset(a,b,sizeof(a))
#define lowbit(a) ((a)&-(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
long long qread(){
long long w=1,c,ret;
while((c=getchar())> '9'||c< '0')
w=(c=='-'?-1:1); ret=c-'0';
while((c=getchar())>='0'&&c<='9')
ret=ret*10+c-'0';
return ret*w;
}
inline int read()
{
int X=0; bool flag=1; char ch=getchar();
while(ch<'0'||ch>'9') {if(ch=='-') flag=0; ch=getchar();}
while(ch>='0'&&ch<='9') {X=(X<<1)+(X<<3)+ch-'0'; ch=getchar();}
if(flag) return X;
return ~(X-1);
}
int gcd(int a,int b)
{
return b>0?gcd(b,a%b):a;
}
int max1(int x,int y)
{
if(x>y)return y;
else
return x;
}
const int N=5e5+10;
const int mod=1e9+7;
struct a
{
ll a;
ll b;
}v[N];
bool cmp(struct a x,struct a y)
{
return x.b>y.b;
}
int main()
{
std::ios::sync_with_stdio(false);
ll n;
n=qread();
ll ans=0;
for(int i=0;i<n;i++)
{
v[i].a=qread();v[i].b=qread();
ans+=2*v[i].a;
}
ll now=ans/2;
sort(v, v+n, cmp);
for(int i=0;i<n;i++)
{
if(now-v[i].b<0)
continue;
ll u=min(now-v[i].b,v[i].a);
now-=u;
ans-=u;
}
cout<<ans<<endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
void ndarray(vector<T> &vec, int len) {
vec.resize(len);
}
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec) ndarray(v, args...);
}
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
int main() {
string S;
cin >> S;
int N = S.length();
vector<int> vs(N, N);
for (int l = (0), l_end_ = (N); l < l_end_; l++) {
for (int d = 1; l + d * 2 < N; d++)
if (S[l] == S[l + d] and S[l] == S[l + d * 2]) {
vs[l] = l + d * 2;
break;
}
}
lint ret = 0;
int r = 0;
multiset<int> ms;
ms.insert(N);
for (int l = (0), l_end_ = (N); l < l_end_; l++) {
while (r<N and * ms.begin()> r) {
ms.insert(vs[r]);
r++;
}
if (*ms.begin() < N) ret += N - r;
ms.erase(ms.lower_bound(vs[l]));
}
cout << ret << endl;
}
| 5 |
#include<iostream>
using namespace std;
void solve(){
int px,py;
cin>>px>>py;
string s;
cin>>s;
int u=0,l=0,r=0,d=0;
for(int i=0;i<s.length();i++){
if(s[i]=='L'){
l++;
}else if(s[i]=='R'){
r++;
}else if(s[i]=='U'){
u++;
}else{
d++;
}
}
if(px>=0&&py>=0){
if(r>=px&&u>=py){
cout<<"YES";
}else{
cout<<"NO";
}
}else if(px>=0&&py<=0){
if(r>=px&&d>=-py){
cout<<"YES";
}else{
cout<<"NO";
}
}else if(px<=0&&py>=0){
if(l>=-px&&u>=py){
cout<<"YES";
}else{
cout<<"NO";
}
}else{
if(l>=-px&&d>=-py){
cout<<"YES";
}else{
cout<<"NO";
}
}
}
int main(){
int t;
cin>>t;
while(t--){
solve();
cout<<endl;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 233333;
int a[maxn], cnt[maxn];
int main() {
int T;
cin >> T;
int n;
while(T--) {
scanf("%d", &n);
int k = 1;
for(int i = 1; i <= n; ++i) cnt[i] = 0;
for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for(int i = 1; i < n; ++i)
if(a[i] == a[i + 1]) {
cnt[a[i]] += 2; ++k;
}
cnt[a[1]]++; cnt[a[n]]++;
int maxv = 0, idx = 0;
for(int i = 1;i <= n; ++i) {
if(cnt[i] > maxv) {
maxv = cnt[i]; idx = i;
}
}
int dd = 0;
for(int i = 1; i < n; ++i)
if(a[i] != a[i + 1] && a[i] != idx && a[i + 1] != idx)
++dd;
if(maxv - 1 <= k) {
printf("%d\n", k - 1);
} else if((maxv - 1) <= (k + dd)) { // 可行
printf("%d\n", maxv - 2);
} else {
printf("-1\n");
}
}
} | 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
const int M = N * N;
const int inf = 1e9 + 7;
struct Edge {
int u, v;
long long c;
Edge() {}
Edge(int a, int b, long long d) : u(a), v(b), c(d) {}
};
vector<Edge> edges;
vector<int> G[M];
void AddEdge(int u, int v, long long c) {
G[u].push_back(edges.size());
edges.push_back(Edge(u, v, c));
G[v].push_back(edges.size());
edges.push_back(Edge(v, u, 0));
}
int was[M], dist[M], s, t;
long long Cut(int u, long long flow) {
if (u == t) return flow;
if (!flow || dist[u] >= dist[t]) return 0;
int ans = 0;
for (; was[u] < G[u].size(); was[u]++) {
int e = G[u][was[u]];
int v = edges[e].v;
long long c = edges[e].c;
if (!c || dist[v] != dist[u] + 1) continue;
int cut = Cut(v, min(flow, c));
edges[e].c -= cut;
edges[e ^ 1].c += cut;
ans += cut;
flow -= cut;
if (!flow) return ans;
}
return ans;
}
bool BFS() {
for (int i = s; i <= t; i++) dist[i] = inf, was[i] = 0;
dist[s] = 0;
queue<int> q;
q.push(s);
while (q.size()) {
int u = q.front();
q.pop();
for (int e : G[u]) {
int v = edges[e].v;
long long c = edges[e].c;
if (c && dist[v] > dist[u] + 1) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
return dist[t] != inf;
}
long long MaxFlow() {
long long Flow = 0;
while (BFS()) Flow += Cut(s, 1e18);
return Flow;
}
int id[N][N];
int main() {
int n, h, m, i, j, c = 0;
scanf("%i %i %i", &n, &h, &m);
s = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j <= h; j++) {
id[i][j] = ++c;
if (j > 0) AddEdge(id[i][j - 1], id[i][j], h * h - (j - 1) * (j - 1));
}
AddEdge(s, id[i][0], inf);
}
t = c + m + 1;
for (i = 1; i <= m; i++) {
int l, r, x, p;
scanf("%i %i %i %i", &l, &r, &x, &p);
c++;
AddEdge(c, t, p);
if (x != h)
for (j = l; j <= r; j++) AddEdge(id[j][x + 1], c, inf);
}
printf("%lld\n", (long long)n * h * h - MaxFlow());
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long inf = 1e9 + 7;
const long long N = 5e3 + 5;
long long n, k, id = 0;
long long A[N], B[N];
long long dp[N][N];
bool solve() {
long long i, j, a;
cin >> n;
for (i = 1; i < n + 1; i++) cin >> A[i], B[i] = A[i] + B[i - 1];
for (i = 0; i < n + 1; i++)
for (j = 0; j < n + 1; j++) dp[i][j] = inf;
dp[0][0] = 0;
long long p = 0;
for (i = 1; i < n + 1; i++) {
for (j = 0; j < i; j++)
if (B[i] - B[j] >= dp[j][p])
dp[i][p + 1] = min(dp[i][p + 1], B[i] - B[j]);
if (p)
for (j = 0; j < i; j++)
if (B[i] - B[j] >= dp[j][p - 1]) dp[i][p] = min(dp[i][p], B[i] - B[j]);
if (dp[i][p + 1] < inf) p++;
}
for (i = n; i > 0; i--)
if (dp[n][i] < inf) return cout << n - i, 0;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i, t = 1, j;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int f[256], d[256];
int find(int v) { return v == f[v] ? v : f[v] = find(f[v]); }
int main() {
for (int i = 0; i < 256; i++) d[i] = 1;
for (int i = 0; i < 256; i++) f[i] = i;
int n, m;
scanf("%d%d", &n, &m);
int x, y, st, et, sum;
for (int i = 0; i < n; i++) {
scanf("%d", &y);
if (y > 0 && f[y] == y && d[y] < m) {
sum = d[y];
x = find(y - 1);
while (d[x] + sum <= m) {
sum += d[x];
if (x == 0) break;
x = find(x - 1);
}
int st = y + d[y] - sum;
int et = y + d[y] - 1;
for (int j = st; j <= et; j++) {
f[j] = st;
d[j] = sum;
}
}
printf("%d ", f[y]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n;
n = s.length();
int q;
int same[n - 1];
same[0] = 0;
for (int i = 1; i < n; i++) {
same[i] = same[i - 1];
if (s.at(i) == s.at(i - 1)) {
same[i]++;
}
}
cin >> q;
int l, r;
for (int i = 0; i < q; i++) {
cin >> l >> r;
if (l == 1 || r == 1) {
cout << same[r - 1];
} else {
cout << same[r - 1] - same[l - 1];
}
if (i != q - 1) {
cout << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class _T_>
void read(_T_& d) {
d = 0;
int f = 1;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f *= -1;
for (; c >= '0' && c <= '9'; c = getchar()) d = d * 10 + c - '0';
d *= f;
}
int n, m, K;
int tot;
int fa[2000005], sz[2000005];
int B[2000005];
int gf(int x) {
if (!fa[x])
return x;
else
return gf(fa[x]);
}
void Merge(int x, int y) {
assert(!fa[x] && !fa[y]);
fa[x] = y;
sz[y] += sz[x];
while (fa[y]) y = fa[y], sz[y] += sz[x];
}
void merge(int x, int y) {
assert(!fa[x] && !fa[y]);
if (sz[x] > sz[y]) swap(x, y);
fa[x] = y;
sz[y] += sz[x];
while (fa[y]) y = fa[y], sz[y] += sz[x];
}
void Undo(int x, int y) {
assert(fa[x] == y || fa[y] == x);
if (fa[y] == x) swap(x, y);
fa[x] = 0;
sz[y] -= sz[x];
while (fa[y]) y = fa[y], sz[y] -= sz[x];
}
int D(int x) {
int t = 0;
while (fa[x]) {
++t;
x = fa[x];
}
return t;
}
vector<pair<pair<int, int>, pair<int, int> > > P;
set<pair<int, int> > S;
vector<pair<int, int> > GG;
int Ban[2000005];
int main() {
read(n);
read(m);
read(K);
tot = n;
for (int i = 1; i <= n; ++i) {
read(B[i]);
sz[i] = 1;
}
for (int i = 1, x, y; i <= m; ++i) {
read(x);
read(y);
if (B[x] == B[y]) {
if (gf(x) != gf(y)) {
if (D(x) % 2 == D(y) % 2) {
x = gf(x);
y = gf(y);
merge(x, y);
} else {
x = gf(x);
y = gf(y);
int Z = ++tot;
sz[Z] = 1;
Merge(x, Z);
int H = gf(Z);
Merge(y, H);
}
} else {
if (!Ban[B[x]]) {
if (D(x) % 2 == D(y) % 2) {
--K;
Ban[B[x]] = 1;
}
}
}
} else {
int a = B[x], b = B[y];
if (a > b) swap(a, b), swap(x, y);
P.push_back(make_pair(make_pair(a, b), make_pair(x, y)));
}
}
sort(P.begin(), P.end());
for (int i = 0, j = 0; i < (int)P.size(); ++i) {
if (P[i].first != P[j].first) {
while (GG.size()) {
Undo(GG[GG.size() - 1].first, GG[GG.size() - 1].second);
GG.pop_back();
}
j = i;
}
if (Ban[P[i].first.first] || Ban[P[i].first.second]) continue;
int x = P[i].second.first;
int y = P[i].second.second;
int X = gf(x), Y = gf(y);
if (X != Y) {
if (D(x) % 2 == D(y) % 2) {
merge(X, Y);
GG.push_back(make_pair(X, Y));
} else {
int Z = ++tot;
sz[Z] = 1;
Merge(X, Z);
int H = gf(Z);
Merge(Y, H);
GG.push_back(make_pair(X, Z));
GG.push_back(make_pair(Y, H));
}
} else {
if (D(x) % 2 == D(y) % 2) {
S.insert(P[i].first);
}
}
}
printf("%lld", 1ll * K * (K - 1) / 2 - S.size());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)3e18;
struct data {
long long x, flag, id;
int operator<(const data& d) const { return x < d.x; }
} d[200010 << 2];
long long dp[200010 << 2][2], c[200010 << 2], s[200010 << 2], v[200010 << 2],
nw, ans;
long long _s[200010 << 2], n, np, m, C, tp, pre;
bool is2[200010 << 2];
struct zkw {
long long zkwm, s[2100000], atg[2100000];
void init(int len) {
zkwm = 1;
while (zkwm <= len + 2) zkwm <<= 1;
for (int i = 1; i <= zkwm + zkwm; ++i) s[i] = -inf;
}
long long query(int l, int r) {
if (l > r || r <= 0 || l > np) return -inf;
l = max(l, 1), r = min((long long)r, np);
long long lans = -inf, rans = -inf;
for (l += zkwm - 1 - 1, r += zkwm + 1 - 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (lans != -inf) lans += atg[l];
if (rans != -inf) rans += atg[r];
if (~l & 1) lans = max(lans, s[l ^ 1]);
if (r & 1) rans = max(rans, s[r ^ 1]);
}
if (lans != -inf) lans += atg[l];
if (rans != -inf) rans += atg[r];
lans = max(lans, rans);
if (lans != -inf)
for (l >>= 1; l; l >>= 1) lans += atg[l];
return lans;
}
void mdy(int l, int r, long long a) {
if (l > r || r <= 0 || l > np) return;
l = max(l, 1), r = min((long long)r, np);
int f = 0;
for (l += zkwm - 1 - 1, r += zkwm + 1 - 1; l ^ r ^ 1;
l >>= 1, r >>= 1, f = 1) {
if (~l & 1) atg[l ^ 1] += a, s[l ^ 1] += a;
if (r & 1) atg[r ^ 1] += a, s[r ^ 1] += a;
if (f)
s[l] = max(s[l << 1], s[l << 1 | 1]) + atg[l],
s[r] = max(s[r << 1], s[r << 1 | 1]) + atg[r];
}
s[l] = max(s[l << 1], s[l << 1 | 1]) + atg[l],
s[r] = max(s[r << 1], s[r << 1 | 1]) + atg[r];
for (l >>= 1; l; l >>= 1) s[l] = max(s[l << 1], s[l << 1 | 1]) + atg[l];
}
void _mdy(int l, long long a) {
l += zkwm - 1;
atg[l] = 0;
for (int _l = l >> 1; _l; _l >>= 1) a -= atg[_l];
if (s[l] < a)
s[l] = a;
else
return;
for (l >>= 1; l; l >>= 1) s[l] = max(s[l << 1], s[l << 1 | 1]) + atg[l];
}
} A[4];
int main() {
scanf("%lld%lld%lld", &n, &m, &C);
for (long long i = 1, L, R; i <= n; ++i)
scanf("%lld%lld", &L, &R), d[++tp] = data{L, 1ll, 0ll},
d[++tp] = data{R, -1ll, 0ll};
for (long long i = 1, L, R; i <= m; ++i)
scanf("%lld%lld", &L, &R), d[++tp] = data{L, 1ll, 1ll},
d[++tp] = data{R, -1ll, 1ll};
sort(d + 1, d + tp + 1);
int tg = 0, ch = 0;
for (int i = 1; i <= tp; ++i) {
if (i > 1) {
long long x = d[i].x - d[i - 1].x;
if (tg == 2)
v[i] = x, s[i] = 0, is2[i - 1] = true;
else if (tg == 1)
v[i] = (ch == 0 ? 1 : 0) * x, s[i] = (ch == 0 ? 1 : -1) * x;
else
v[i] = s[i] = 0;
s[i] += s[i - 1], c[i] = v[i] + c[i - 1];
}
if (d[i].flag > 0)
tg++, ch = d[i].id;
else if (d[i].flag < 0)
tg--, ch = 1 - d[i].id;
_s[i] = s[i];
}
sort(_s + 1, _s + tp + 1);
np = unique(_s + 1, _s + tp + 1) - _s - 1;
for (int i = 0; i < 4; ++i) A[i].init(np);
for (int i = 0; i <= tp + 1; ++i) dp[i][0] = dp[i][1] = -inf;
for (int i = 1; i < tp; ++i) {
if (is2[i]) {
if (s[i] >= C)
dp[i][0] = max(dp[i][0], pre - s[i] + C + v[i + 1] * 2);
else if (s[i] <= -C)
dp[i][1] = max(dp[i][1], pre + v[i + 1] * 2);
}
if (abs(nw) <= C && is2[i])
pre += v[i + 1] * 2;
else
pre += v[i + 1], nw += s[i + 1] - s[i];
if (!is2[i]) continue;
int X = lower_bound(_s + 1, _s + np + 1, s[i]) - _s;
dp[i][0] = max(dp[i][0], A[0].query(1, X) + c[i + 1] - s[i] + v[i + 1]);
dp[i][1] = max(
dp[i][1],
A[1].query(lower_bound(_s + 1, _s + np + 1, s[i] + 2 * C) - _s, np) +
c[i + 1] + v[i + 1]);
dp[i][0] = max(
dp[i][0],
A[2].query(1, upper_bound(_s + 1, _s + np + 1, s[i] - 2 * C) - _s - 1) -
s[i] + v[i + 1] + c[i + 1] + 2 * C);
dp[i][1] = max(dp[i][1], A[3].query(X, np) + c[i + 1] + v[i + 1]);
int l = X, r = upper_bound(_s + 1, _s + np + 1, s[i] + 2 * C) - _s - 1;
if (A[0].s[1] >= (long long)(-2e18)) A[0].mdy(l, r, v[i + 1]);
if (A[1].s[1] >= (long long)(-2e18)) A[1].mdy(l, r, v[i + 1]);
l = lower_bound(_s + 1, _s + np + 1, s[i] - 2 * C) - _s, r = X;
if (A[2].s[1] >= (long long)(-2e18)) A[2].mdy(l, r, v[i + 1]);
if (A[3].s[1] >= (long long)(-2e18)) A[3].mdy(l, r, v[i + 1]);
int x = lower_bound(_s + 1, _s + np + 1, s[i + 1]) - _s;
if (dp[i][0] >= 0)
A[0]._mdy(x, dp[i][0] + s[i + 1] - c[i + 1]),
A[1]._mdy(x, dp[i][0] - c[i + 1]);
if (dp[i][1] >= 0)
A[2]._mdy(x, dp[i][1] + s[i + 1] - c[i + 1]),
A[3]._mdy(x, dp[i][1] - c[i + 1]);
}
ans = max(ans, pre);
ans = max(ans, A[1].query(1, np) + c[tp]);
ans = max(ans, A[3].query(1, np) + c[tp]);
printf("%lld", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long q;
cin >> q;
for (long long tc = 0; tc < q; tc++) {
long long a[3];
cin >> a[0] >> a[1] >> a[2];
cout << max(
(max(a[0], max(a[1], a[2])) - min(a[0], min(a[1], a[2])) - 2) * 2,
(long long)0);
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > se, vis, ans;
pair<int, int> arr[200005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (n <= k) {
puts("-1");
return 0;
}
for (int i = 0; i < n; i++) {
scanf("%d%d", &arr[i].first, &arr[i].second);
se.insert(arr[i]);
}
sort(arr, arr + n);
for (int i = 0; i <= k; i++) {
for (int j = n - 1; j >= n - k - 1; j--) {
int xx = arr[i].first + arr[j].first, yy = arr[i].second + arr[j].second;
if (vis.count(make_pair(xx, yy))) continue;
vis.insert(make_pair(xx, yy));
int cnt = 0;
for (int x = 0; x < n && cnt <= k; x++)
cnt += !se.count(make_pair(xx - arr[x].first, yy - arr[x].second));
if (cnt <= k) ans.insert(make_pair(xx, yy));
}
}
printf("%d\n", (int)ans.size());
for (auto x : ans)
printf("%.1lf %.1lf\n", (double)x.first / 2, (double)x.second / 2);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string x[17];
vector<vector<int> > y(17);
int n, maxm, ind, r[17][17];
void AllGetOn(int Me, vector<int> chosen, bool b) {
if (b) chosen.push_back(Me);
if (Me >= n) {
y.push_back(chosen);
return;
}
b = 0;
for (int i = 0; i < chosen.size(); i++)
if (r[Me + 1][chosen[i]]) b = 1;
if (!b) AllGetOn(Me + 1, chosen, 1);
AllGetOn(Me + 1, chosen, 0);
}
int main() {
int m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> x[i];
sort(x + 1, x + n + 1);
for (int i = 0; i < m; i++) {
string y, z;
cin >> y >> z;
int ind1, ind2;
for (int j = 1; j <= n; j++)
if (x[j] == y)
ind1 = j;
else if (x[j] == z)
ind2 = j;
r[ind1][ind2] = r[ind2][ind1] = 1;
}
vector<int> z;
AllGetOn(0, z, 0);
for (int i = 0; i < y.size(); i++)
if (maxm < y[i].size()) {
maxm = y[i].size();
ind = i;
}
cout << y[ind].size() << endl;
;
sort(y[ind].begin(), y[ind].end());
for (int i = 0; i < y[ind].size(); i++) cout << x[y[ind][i]] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int mod = 45;
const int maxn = 1e5 + 7;
vector<vector<int>> g, gr;
vector<bool> used;
vector<int> ord, comp;
void ts(int v) {
used[v] = true;
for (int to : g[v]) {
if (!used[to]) {
ts(to);
}
}
ord.push_back(v);
}
void dfs(int v) {
used[v] = true;
comp.push_back(v);
for (int to : gr[v]) {
if (!used[to]) {
dfs(to);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
g.assign(n, vector<int>());
gr.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
gr[b].push_back(a);
}
used.assign(n, false);
ord.clear();
for (int i = 0; i < n; i++) {
if (!used[i]) {
ts(i);
}
}
reverse(ord.begin(), ord.end());
used.assign(n, false);
vector<int> ans;
vector<int> clr(n, -1);
for (int i : ord) {
if (!used[i]) {
comp.clear();
dfs(i);
bool flag = true;
if (comp.size() == n) {
flag = false;
}
for (int j : comp) {
clr[j] = i;
}
for (int j : comp) {
if (!flag) break;
for (int k : gr[j]) {
if (clr[k] != i) {
flag = false;
}
}
}
if (comp.size() != n) {
ans = comp;
}
}
}
if (ans.size() == 0) {
cout << "No\n";
} else {
cout << "Yes\n";
cout << comp.size() << " " << n - comp.size() << "\n";
vector<bool> cat(n, true);
for (int i : ans) {
cout << i + 1 << " ";
cat[i] = false;
}
cout << "\n";
for (int i = 0; i < n; i++) {
if (cat[i]) {
cout << i + 1 << " ";
}
}
cout << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sol;
cin >> n;
vector<long long> a(2 * n);
for (int i = 0; i < 2 * n; i++) cin >> a[i];
sort(a.begin(), a.end());
sol = (a[n - 1] - a[0]) * (a[2 * n - 1] - a[n]);
for (int i = 1; i < n; i++)
sol = min(sol, (a[2 * n - 1] - a[0]) * (a[i + n - 1] - a[i]));
cout << sol << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, m, t, cnt, h[100005], ans[100005], X, siz[100005], fa[100005], id[3],
du[100005];
bool vis[100005], ok, v2[100005];
struct edge {
int to, nxt;
} e[100005 << 1];
void ins(int x, int y) {
e[++cnt].nxt = h[x];
h[x] = cnt;
e[cnt].to = y;
du[x]++;
}
void dfs(int x, int f) {
fa[x] = f;
vis[x] = 1;
for (int i = h[x]; i; i = e[i].nxt)
if (e[i].to != f) {
if (vis[e[i].to]) {
ok = 1;
for (; 1; x = fa[x]) {
ans[x] = 1;
if (x == e[i].to) break;
}
return;
}
dfs(e[i].to, x);
if (ok) return;
}
if (du[x] > 3) {
for (int i = h[x]; i; i = e[i].nxt) ans[e[i].to] = 1;
ans[x] = 2;
ok = 1;
return;
}
if (du[x] == 3) {
if (X) {
for (int i = h[x]; i; i = e[i].nxt) ans[e[i].to] = 1;
for (int i = h[X]; i; i = e[i].nxt) ans[e[i].to] = 1;
int y = x;
for (; x; x = fa[x]) v2[x] = 1;
for (; X; X = fa[X]) {
ans[X] = 2;
if (v2[X]) break;
}
for (; y != X; y = fa[y]) ans[y] = 2;
ok = 1;
return;
}
X = x;
}
}
void calc(int x, int f) {
siz[x] = 1;
for (int i = h[x]; i; i = e[i].nxt)
if (e[i].to != f) {
calc(e[i].to, x);
siz[x] += siz[e[i].to];
}
}
void get(int x, int f) {
if (!ans[f])
ans[x] = 0;
else
ans[x] = ans[f] / (siz[x] + 1) * siz[x];
for (int i = h[x]; i; i = e[i].nxt)
if (e[i].to != f) {
siz[e[i].to] = siz[x] - 1;
get(e[i].to, x);
}
}
int main() {
for (scanf("%d", &t); t--;) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) h[i] = ans[i] = siz[i] = du[i] = 0;
for (int i = 1; i <= n; i++) vis[i] = v2[i] = 0;
cnt = ok = 0;
for (int x, y; m--;) {
scanf("%d%d", &x, &y);
ins(x, y);
ins(y, x);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
X = 0;
dfs(i, 0);
if (ok) break;
if (!X) continue;
for (int j = h[X], k = 0; j; j = e[j].nxt, k++) {
calc(e[j].to, X);
id[k] = e[j].to;
}
for (int j = 0; j < 3; j++)
for (int k = j + 1; k < 3; k++)
if (siz[id[j]] > siz[id[k]]) std::swap(id[j], id[k]);
int xx = siz[id[0]] + 1, yy = siz[id[1]] + 1, zz = siz[id[2]] + 1;
if (1ll * xx * yy + 1ll * yy * zz + 1ll * xx * zz > 1ll * xx * yy * zz)
continue;
if (xx >= 3)
ans[X] = 3, siz[id[0]] = siz[id[1]] = siz[id[2]] = 2;
else if (yy >= 4)
ans[X] = 4, siz[id[1]] = siz[id[2]] = 3;
else
ans[X] = xx * yy * zz;
for (int j = 0; j < 3; j++) get(id[j], X);
ok = 1;
break;
}
if (ok) {
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
} else
puts("NO");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char str[15];
int tot;
long long num[10000];
void dfs(long long n, int n4, int n7) {
if ((n4 + n7) % 2 == 0 && n4 == n7 && n4 > 0 && n7 > 0) {
num[++tot] = n;
}
if (n4 + n7 < 10) {
dfs(n * 10 + 4, n4 + 1, n7);
dfs(n * 10 + 7, n4, n7 + 1);
}
}
int main() {
scanf("%s", str);
tot = 0;
int n = strlen(str);
dfs(0, 0, 0);
sort(num + 1, num + tot + 1);
int temp = atoi(str);
for (int i = 1; i <= tot; i++) {
if (num[i] >= temp) {
cout << num[i] << endl;
break;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000009;
long long poww(long long base, long long power) {
long long ret = 1;
for (long long i = 0; i < power; i++) {
ret *= base;
ret %= mod;
}
return ret;
}
int main() {
long long ans;
long long n, m;
while (~scanf("%I64d%I64d", &n, &m)) {
ans = 1;
long long sum = poww(2, m);
for (long long i = 1; i <= n; i++) {
ans *= (sum - i);
ans %= mod;
}
printf("%I64d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<int> S[200010];
int N[200010 << 2], x[200010];
struct node {
int x, y;
} a[200010];
char str[200010][10];
void PushUp(int rt) { N[rt] = max(N[rt << 1], N[rt << 1 | 1]); }
void build(int l, int r, int rt) {
N[rt] = -1;
if (l == r) {
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
}
void update(int l, int r, int rt, int p) {
if (l == r) {
if (S[l].size() > 0)
N[rt] = *(--S[l].end());
else
N[rt] = -1;
return;
}
int m = (l + r) >> 1;
if (p <= m) {
update(l, m, rt << 1, p);
} else {
update(m + 1, r, rt << 1 | 1, p);
}
PushUp(rt);
}
int query(int l, int r, int rt, int x1, int y1) {
if (x1 >= x[r] || y1 >= N[rt]) return -1;
if (l == r) {
return l;
}
int m = (l + r) >> 1;
int t = query(l, m, rt << 1, x1, y1);
if (t == -1)
return query(m + 1, r, rt << 1 | 1, x1, y1);
else
return t;
}
int main() {
int n;
while (~scanf("%d", &n)) {
int s = 0;
for (int i = 1; i <= n; i++) {
scanf(" %s%d%d", str[i], &a[i].x, &a[i].y);
if (str[i][0] != 'f') {
x[++s] = a[i].x;
}
}
sort(x + 1, x + s + 1);
int num = unique(x + 1, x + s + 1) - (x + 1);
if (num != 0) {
build(1, num, 1);
for (int i = 1; i <= num; i++) S[i].clear();
}
for (int i = 1; i <= n; i++) {
if (s != 0) {
if (str[i][0] == 'a') {
int t = lower_bound(x + 1, x + num + 1, a[i].x) - x;
S[t].insert(a[i].y);
update(1, num, 1, t);
} else if (str[i][0] == 'r') {
int t = lower_bound(x + 1, x + num + 1, a[i].x) - x;
S[t].erase(a[i].y);
update(1, num, 1, t);
} else {
int t = query(1, num, 1, a[i].x, a[i].y);
if (t == -1)
printf("-1\n");
else {
printf("%d %d\n", x[t], *(S[t].upper_bound(a[i].y)));
}
}
} else {
if (str[i][0] == 'f') printf("-1\n");
}
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
os << "{" << p.first << ", " << p.second << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[";
int i = 0;
for (typename vector<T>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[";
int i = 0;
for (typename set<T>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class K, class V>
ostream& operator<<(ostream& os, const map<K, V>& p) {
os << "[";
int i = 0;
for (typename map<K, V>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class T>
string toString(const T& o) {
stringstream ss;
ss << o;
string ret;
getline(ss, ret);
return ret;
}
template <class T>
vector<T> subv(const vector<T>& v, int from, int to) {
return vector<T>(v.begin() + min(max(0, from), (int)v.size()),
v.begin() + min(max(0, to), (int)v.size()));
}
pair<int, int> operator+(const pair<int, int>& a, const pair<int, int>& b) {
return make_pair(a.first + b.first, a.second + b.second);
}
pair<int, int> operator*(const int& a, const pair<int, int>& b) {
return make_pair(a * b.first, a * b.second);
}
vector<int> sex, parent, used[2], path, bestw[2];
vector<int> was;
vector<int> points;
vector<vector<int> > adj;
vector<pair<int, int> > w[2], o[2];
int k, mark, n;
void dfs(int v, int color) {
if (was[v] == color) {
points.push_back(v);
return;
}
if (was[v]) return;
was[v] = color;
for (int i = 0; i < adj[v].size(); ++i) dfs(adj[v][i], color);
}
void go(int v) {
if (used[k][v]) return;
used[k][v] = 1;
w[k][v] = o[k][v] = make_pair(0, 0);
for (int i = 0; i < adj[v].size(); ++i) {
int to = adj[v][i];
go(to);
if (mark != to) o[k][v] = o[k][v] + max(w[k][to], o[k][to]);
}
for (int i = 0; i < adj[v].size(); ++i) {
int to = adj[v][i];
if (to == mark) continue;
pair<int, int> val = o[k][v] + (-1) * max(w[k][to], o[k][to]) + o[k][to] +
make_pair(1, sex[v] != sex[to]);
if (w[k][v] < val) {
bestw[k][v] = to;
w[k][v] = val;
}
}
}
void make_path(int v, bool with) {
int to = -1;
if (with) {
to = bestw[k][v];
path[to] = 1;
}
for (int i = 0; i < adj[v].size(); ++i) {
int to2 = adj[v][i];
if (to2 != mark) make_path(to2, (to2 != to) && (w[k][to2] > o[k][to2]));
}
}
int main() {
cin >> n;
adj.resize(n);
sex.resize(n);
path.resize(n, 0);
parent.resize(n);
was.resize(n, 0);
for (int i = 0; i < 2; ++i) {
bestw[i].resize(n, -1);
w[i].resize(n);
o[i].resize(n);
used[i].resize(n, 0);
}
for (int i = 0; i < n; ++i) {
int f, s;
cin >> f >> s;
f--, s--;
parent[i] = f;
sex[i] = s;
adj[f].push_back(i);
}
for (int i = 0; i < n; ++i)
if (!was[i]) dfs(i, i + 1);
for (int i = 0; i < points.size(); ++i) {
int v1 = points[i];
int v2 = parent[v1];
k = 0;
mark = v1;
go(v1);
k = 1;
mark = v2;
go(v2);
int v;
if (max(o[0][v1], w[0][v1]) > max(o[1][v2], w[1][v2])) {
k = 0;
v = v1;
mark = v1;
} else {
k = 1;
v = v2;
mark = v2;
}
make_path(v, w[k][v] > o[k][v]);
}
int all = 0, diff = 0;
for (int i = 0; i < n; ++i)
if (path[i]) {
all++;
diff += (sex[i] != sex[parent[i]]);
}
cout << all << " " << diff << endl;
for (int i = 0; i < n; ++i)
if (path[i]) cout << i + 1 << " " << parent[i] + 1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> grafo[500005], peso[500005];
long long q, n, k, u, v, w, dp[500005][2];
void dfs(int nodo, int last) {
vector<long long> tmp;
long long sum = 0;
for (int i = 0; i < grafo[nodo].size(); i++) {
if (grafo[nodo][i] != last) {
dfs(grafo[nodo][i], nodo);
sum += dp[grafo[nodo][i]][0];
tmp.push_back(max(
0ll, dp[grafo[nodo][i]][1] + peso[nodo][i] - dp[grafo[nodo][i]][0]));
}
}
sort(tmp.begin(), tmp.end());
reverse(tmp.begin(), tmp.end());
for (int i = 0; i < min(k - 1, (long long)tmp.size()); i++) {
sum += tmp[i];
}
dp[nodo][1] = sum;
if (tmp.size() >= k) {
sum += tmp[k - 1];
}
dp[nodo][0] = sum;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> q;
while (q--) {
cin >> n >> k;
for (int i = 0; i <= n; i++) {
peso[i].clear();
grafo[i].clear();
}
for (int i = 0; i < (n - 1); i++) {
cin >> u >> v >> w;
grafo[u].push_back(v);
grafo[v].push_back(u);
peso[u].push_back(w);
peso[v].push_back(w);
}
dfs(1, -1);
cout << dp[1][0] << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x1, x2;
scanf("%d%d%d", &(n), &(x1), &(x2));
int inf = 1000000000 + 2;
vector<int> c(n);
vector<pair<int, int> > ca(n);
for (int i = 0; i < (n); ++i) {
scanf("%d", &(c[i]));
ca[i] = {c[i], i + 1};
}
sort(c.begin(), c.end());
sort(ca.begin(), ca.end());
map<int, int> m;
m[inf] = 0;
for (int i = 0; i < (n); ++i) {
m[c[n - 1 - i]] = i + 1;
}
int k1min = 1;
int k2min = 1;
int minsize = (x1 - 1) / k1min + 1;
auto flb = m.lower_bound(minsize);
while (k1min < n and flb->second < k1min) {
k1min++;
minsize = (x1 - 1) / k1min + 1;
flb = m.lower_bound(minsize);
}
minsize = (x2 - 1) / k2min + 1;
flb = m.lower_bound(minsize);
while (k2min < n and flb->second < k2min) {
k2min++;
minsize = (x2 - 1) / k2min + 1;
flb = m.lower_bound(minsize);
}
if (k1min + k2min > n) {
printf("No\n");
return 0;
}
int k2s = k2min;
minsize = (x2 - 1) / k2s + 1;
flb = m.lower_bound(minsize);
while (k1min + k2s <= n and flb->second < k1min + k2s) {
k2s++;
minsize = (x2 - 1) / k2s + 1;
flb = m.lower_bound(minsize);
}
if (k1min + k2s <= n) {
printf("Yes\n");
printf("%d %d\n", k1min, k2s);
for (int i = 0; i < (k1min); ++i) {
printf("%d%c", ca[n - 1 - i].second, i == k1min - 1 ? '\n' : ' ');
}
for (int i = 0; i < (k2s); ++i) {
printf("%d%c", ca[n - 1 - k1min - i].second, i == k2s - 1 ? '\n' : ' ');
}
return 0;
}
int k1s = k1min;
minsize = (x1 - 1) / k1s + 1;
flb = m.lower_bound(minsize);
while (k2min + k1s <= n and flb->second < k1s + k2min) {
k1s++;
minsize = (x1 - 1) / k1s + 1;
flb = m.lower_bound(minsize);
}
if (k1s + k2min <= n) {
printf("Yes\n");
printf("%d %d\n", k1s, k2min);
for (int i = 0; i < (k1s); ++i) {
printf("%d%c", ca[n - 1 - k2min - i].second, i == k1s - 1 ? '\n' : ' ');
}
for (int i = 0; i < (k2min); ++i) {
printf("%d%c", ca[n - 1 - i].second, i == k2min - 1 ? '\n' : ' ');
}
return 0;
}
printf("No\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[100007];
int l1 = 0, l2 = n + 1;
if (m == 0) {
cout << n - 1 << endl;
return 0;
}
int flag = 1;
memset(arr, 0, sizeof(arr));
for (int i = 0; i < m; i++) {
int k, t;
cin >> k >> t;
int t1 = min(k, t);
int t2 = max(k, t);
l1 = max(l1, t1);
l2 = min(l2, t2);
if (arr[t1] == 2 || arr[t2] == 1) {
flag = 0;
}
arr[t1] = 1;
arr[t2] = 2;
}
if (flag == 0 || l1 > l2) {
cout << "0" << endl;
return 0;
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (arr[i] == 0) {
if (i > l1 && i < l2) cnt++;
}
}
cout << cnt + 1 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 22 + 2;
const int maxm = maxn * maxn;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
int n, n2, m, a, b;
double p[maxn];
double f[maxn * maxn][maxn * maxn + 1], ans[maxn * maxn];
int head[maxn], tot = 1;
struct node {
int from, to;
} edge[maxm];
int deg[maxn];
void add(int from, int to) {
deg[from]++, edge[++tot].from = head[from], head[from] = tot,
edge[tot].to = to;
}
int _hash(int i, int j) { return (i - 1) * n + j; }
void build() {
f[_hash(a, b)][n2 + 1] = 1.0;
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= n; y++) {
int u = _hash(x, y);
f[u][u] = 1.0;
if (x != y) f[u][u] -= p[x] * p[y];
for (int i = head[x]; i; i = edge[i].from) {
int l = edge[i].to;
if (l == y) continue;
int v = _hash(l, y);
f[u][v] -= p[y] * (1 - p[l]) / deg[l];
}
for (int i = head[y]; i; i = edge[i].from) {
int l = edge[i].to;
if (l == x) continue;
int v = _hash(x, l);
f[u][v] -= p[x] * (1 - p[l]) / deg[l];
}
for (int i = head[x]; i; i = edge[i].from) {
for (int j = head[y]; j; j = edge[j].from) {
int k = edge[i].to, l = edge[j].to;
if (k == l) continue;
int v = _hash(k, l);
f[u][v] -= (1 - p[k]) * (1 - p[l]) / deg[k] / deg[l];
}
}
}
}
}
void solve() {
for (int i = 1; i <= n2; i++) {
int pos = i;
for (int j = i + 1; j <= n2; j++)
if (fabs(f[j][i]) > fabs(f[pos][i])) pos = j;
if (pos != i) {
for (int j = 1; j <= n2 + 1; j++) swap(f[pos][j], f[i][j]);
}
if (f[i][i] < eps) continue;
double tp = f[i][i];
for (int j = i; j <= n2 + 1; j++) f[i][j] /= tp;
for (int j = i + 1; j <= n2; j++) {
double tp = f[j][i];
for (int k = i; k <= n2 + 1; k++) f[j][k] -= tp * f[i][k];
}
}
for (int i = n2; i >= 0; i--) {
ans[i] = f[i][n2 + 1];
for (int j = i - 1; j >= 0; j--) f[j][n2 + 1] -= f[j][i] * ans[i];
}
}
int main() {
cin >> n >> m >> a >> b;
n2 = n * n;
int from, to;
for (int i = 1; i <= m; i++) {
cin >> from >> to;
add(from, to);
add(to, from);
}
for (int i = 1; i <= n; i++) cin >> p[i];
build();
solve();
for (int i = 1; i <= n; i++) printf("%.6lf ", ans[_hash(i, i)]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-9;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 1e6 + 7;
int t, n, m, ans;
int dp[404][404][404], a[444], s, f, c, r;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int i, j, k, l;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 0; i <= n; i++)
for (j = i; j <= n; j++)
for (k = 0; k < j - i; k++) dp[i][j][k] = INF;
for (j = 2; j <= n; j++) {
for (i = 1; i < j; i++) {
dp[i][j][0] = a[j] - a[i];
for (k = i; k < j; k++) {
for (l = 0; l <= k - i; l++) {
dp[i][j][l + 1] = min(dp[i][j][l + 1], max(dp[i][k][l], a[j] - a[k]));
}
}
}
}
long long tot = 0;
while (m--) {
cin >> s >> f >> c >> r;
r = max(0 - 0, min(r, f - s - 1));
k = INF;
for (i = 0; i <= r; i++) k = min(k, dp[s][f][i]);
tot = max(tot, 1ll * k * c);
}
cout << tot << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, temp = 0, cnt = 0;
string ans = "";
cin >> n;
int* z = new int[n];
for (int i = 0; i < n; i++) cin >> z[i];
int i = 0, j = n - 1;
while (i <= j) {
if (z[i] > temp && z[j] > temp) {
if (z[i] < z[j]) {
ans += 'L';
temp = z[i];
i++;
} else {
ans += 'R';
temp = z[j];
j--;
}
cnt++;
} else if (z[i] > temp) {
ans += 'L';
temp = z[i];
i++;
cnt++;
} else if (z[j] > temp) {
ans += 'R';
temp = z[j];
j--;
cnt++;
} else
break;
}
cout << cnt << endl << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1100;
const long long inf = (int)1e18;
const int infi = (int)1e9 + 1000;
int n, m, L, s, t;
vector<pair<int, int> > graf[MAXN];
vector<pair<pair<int, int>, int> > edgesN, edgesV;
void load() {
scanf("%d%d%d%d%d", &n, &m, &L, &s, &t);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (!c) c = -edgesV.size() - 1;
graf[a].push_back(pair<int, int>(b, c));
graf[b].push_back(pair<int, int>(a, c));
if (c > 0)
edgesN.push_back(make_pair(pair<int, int>(a, b), c));
else
edgesV.push_back(make_pair(pair<int, int>(a, b), infi));
}
}
long long len;
long long dist[MAXN];
long long dijkstra() {
set<pair<long long, int> > S;
for (int i = 0; i < n; i++) {
dist[i] = inf;
if (i == s) dist[i] = 0;
S.insert(pair<long long, int>(dist[i], i));
}
pair<long long, int> a;
while (!S.empty()) {
a = *S.begin();
S.erase(S.begin());
int b = a.second;
for (int i = 0; i < graf[b].size(); i++) {
pair<int, int> c = graf[b][i];
int sus = c.first;
int distsus = c.second;
if (distsus < 0) distsus = edgesV[-distsus - 1].second;
long long alt = dist[b] + distsus;
if (alt < dist[sus]) {
S.erase(pair<long long, int>(dist[sus], sus));
dist[sus] = alt;
S.insert(pair<long long, int>(dist[sus], sus));
}
}
}
return dist[t];
}
int v;
bool solve() {
v = edgesV.size();
if (dijkstra() < L) {
return false;
}
for (int i = 0; i < v; i++) edgesV[i].second = 1;
if (dijkstra() > L) {
return false;
}
int lo = 0, hi = v;
while (lo < hi) {
int mid = (lo + hi) / 2;
for (int i = 0; i < mid; i++) edgesV[i].second = 1;
for (int i = mid; i < v; i++) edgesV[i].second = infi;
if (dijkstra() <= L)
hi = mid;
else
lo = mid + 1;
}
for (int i = 0; i < lo; i++) edgesV[i].second = 1;
for (int i = lo; i < v; i++) edgesV[i].second = infi;
int lo_ = 1, hi_ = L;
while (lo_ < hi_) {
int mid = (lo_ + hi_) / 2;
if (lo - 1 < v && lo - 1 >= 0) edgesV[lo - 1].second = mid;
if (dijkstra() < L)
lo_ = mid + 1;
else
hi_ = mid;
}
if (lo - 1 < v && lo - 1 >= 0) edgesV[lo - 1].second = lo_;
return true;
}
void ispis() {
printf("YES\n");
for (int i = 0; i < m; i++) {
int a, b, c;
if (i < v) {
a = edgesV[i].first.first;
b = edgesV[i].first.second;
c = edgesV[i].second;
} else {
a = edgesN[i - v].first.first;
b = edgesN[i - v].first.second;
c = edgesN[i - v].second;
}
printf("%d %d %d\n", a, b, c);
}
}
int main() {
load();
if (solve())
ispis();
else
printf("NO\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
vector<int> count[200000 + 1];
for (int i = 0; i < n; i++) {
cin >> a[i];
int step = 0;
while (a[i]) {
count[a[i]].push_back(step);
step++;
a[i] = a[i] / 2;
}
}
for (int i = 0; i < 2e5 + 1; i++) {
sort(count[i].begin(), count[i].end());
}
int ans = INT_MAX;
for (int i = 0; i < 2e5 + 1; i++) {
if (count[i].size() >= k) {
int sum = 0;
for (int j = 0; j < k; j++) sum += count[i][j];
ans = min(ans, sum);
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
string s;
cin >> s;
vector<long> pos;
for (int i = 0; i < n; i++) {
long tmp;
cin >> tmp;
pos.push_back(tmp);
}
long min_val = pos[n - 1];
bool is_answer = false;
for (int i = 0; i < n - 1; i++) {
if (!(s[i] == 'R' && s[i + 1] == 'L')) continue;
long diff = pos[i + 1] - pos[i];
long new_speed = diff / 2;
if (min_val > new_speed) {
is_answer = true;
min_val = new_speed;
}
}
if (is_answer)
cout << min_val;
else
cout << -1;
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char next_el(char a) {
if (a == 'a') return 'z';
return char(int(a) - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int i, p;
string s, t;
char e;
cin >> s;
p = 0;
for (i = 0; i < s.size(); i++) {
if (p == 0) {
if (s[i] != 'a') p = 1;
}
if (p == 1) {
if (s[i] != 'a')
s[i] = next_el(s[i]);
else
break;
}
}
if (p == 0) s[s.size() - 1] = next_el(s[s.size() - 1]);
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int mid, i, j, k, l, m, n, ans = 0, minn = INT_MAX, maxx = INT_MIN,
x, sum = 0, c = 0, odd = 0, even = 0, q,
ab = 0, ba = 0, y, a, b;
string s;
char cc = 'a';
cin >> s;
string word;
cin >> word;
vector<int> v;
for (i = 0; word[i] != '\0'; i++) {
for (j = 0; s[j] != '\0'; j++) {
if (s[j] == word[i]) {
v.push_back(j + 1);
break;
}
}
}
for (i = 0; i < v.size() - 1; i++) {
ans += abs(v[i] - v[i + 1]);
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, c[100005][3], x[100005], ans[100005], mn = 1e18;
long long u[100005], v[100005], du[100005], book[100005], nxt[100005][3];
long long head, id[100005], tot;
signed main() {
cin >> n;
for (long long j = 0; j < 3; j++)
for (long long i = 1; i <= n; i++) scanf("%I64d", &c[i][j]);
long long flag = 1;
for (long long i = 1; i < n; i++) {
scanf("%I64d%I64d", &u[i], &v[i]);
du[u[i]]++, du[v[i]]++;
if (du[u[i]] > 2 || du[v[i]] > 2) flag = 0;
nxt[u[i]][du[u[i]]] = v[i], nxt[v[i]][du[v[i]]] = u[i];
}
if (flag == 0) {
cout << -1 << endl;
return 0;
}
for (head = 1; head <= n; head++)
if (du[head] == 1) break;
while (tot < n) {
++tot;
id[tot] = head;
book[head] = 1;
for (long long i = 1; i <= du[head]; i++)
if (!book[nxt[head][i]]) {
head = nxt[head][i];
break;
}
}
for (long long i = 0; i < 3; i++)
for (long long j = 0; j < 3; j++) {
if (i == j) continue;
x[id[1]] = i, x[id[2]] = j;
for (long long k = 3; k <= n; k++)
x[id[k]] = 3 - x[id[k - 1]] - x[id[k - 2]];
long long s = 0;
for (long long k = 1; k <= n; k++) s += c[k][x[k]];
if (s < mn) {
mn = s;
for (long long k = 1; k <= n; k++) ans[k] = x[k];
}
}
cout << mn << endl;
for (long long i = 1; i <= n; i++) printf("%I64d ", ans[i] + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 31;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long q;
cin >> q;
vector<long long> sums(MAXN);
vector<multiset<long long> > nums(MAXN);
long long cnt = 0;
while (q--) {
char type;
cin >> type;
if (type == '+') {
long long num;
cin >> num;
cnt++;
long long l = 1, r = 2;
for (long long j = 0; j < MAXN; j++) {
if (l <= num && num < r) {
sums[j] += num;
nums[j].insert(num);
break;
}
l <<= 1, r <<= 1;
}
long long sum = 0, ans = 0;
for (long long j = 0; j < MAXN; j++) {
if (nums[j].size() == 0) continue;
if (*nums[j].begin() > 2 * sum) ans++;
sum += sums[j];
}
cout << cnt - ans << '\n';
} else {
long long num;
cin >> num;
cnt--;
long long l = 1, r = 2;
for (long long j = 0; j < MAXN; j++) {
if (l <= num && num < r) {
sums[j] -= num;
nums[j].erase(nums[j].find(num));
break;
}
l <<= 1, r <<= 1;
}
long long sum = 0, ans = 0;
for (long long j = 0; j < MAXN; j++) {
if (nums[j].size() == 0) continue;
if (*nums[j].begin() > 2 * sum) ans++;
sum += sums[j];
}
cout << cnt - ans << '\n';
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int n, a, b, T, t;
long double p[100010], g[100010], u[100010], Ans, tA, tB;
struct Node {
int l, r;
long double tA, tB;
} f[100010 * 5];
void pushup(int k) {
f[k].tA = f[k << 1].tA * f[(k << 1) + 1].tA;
f[k].tB = f[k << 1].tB + f[(k << 1) + 1].tB * f[k << 1].tA;
}
void Build(int k, int l, int r) {
f[k].l = l;
f[k].r = r;
if (l == r) {
f[k].tA = f[k].tB = u[l];
return;
}
int mid = (l + r) >> 1;
Build(k << 1, l, mid);
Build((k << 1) + 1, mid + 1, r);
pushup(k);
}
long double AM(int k, int l, int r) {
if (f[k].l == l && f[k].r == r) return f[k].tA;
int mid = (f[k].l + f[k].r) >> 1;
if (r <= mid)
return AM(k << 1, l, r);
else if (l > mid)
return AM((k << 1) + 1, l, r);
else
return AM(k << 1, l, mid) * AM((k << 1) + 1, mid + 1, r);
}
long double Ask(int k, int l, int r) {
if (f[k].l == l && f[k].r == r) return f[k].tB;
int mid = (f[k].l + f[k].r) >> 1;
if (r <= mid)
return Ask(k << 1, l, r);
else if (l > mid)
return Ask((k << 1) + 1, l, r);
else
return Ask(k << 1, l, mid) +
AM(k << 1, l, mid) * Ask((k << 1) + 1, mid + 1, r);
}
void Update(int k, int t) {
if (f[k].l == f[k].r) {
f[k].tA = f[k].tB = u[t];
return;
}
int mid = (f[k].l + f[k].r) >> 1;
if (t <= mid)
Update(k << 1, t);
else
Update((k << 1) + 1, t);
pushup(k);
}
int main() {
scanf("%d%d", &n, &T);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a, &b);
p[i] = (long double)a / b;
u[i] = 1 / p[i] - 1;
}
g[0] = 1;
for (int i = 1; i <= n; i++) g[i] = g[i - 1] * u[i];
Build(1, 1, n);
while (T--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d%d", &t, &a, &b);
u[t] = (long double)b / a - 1;
Update(1, t);
} else {
scanf("%d%d", &a, &b);
Ans = 1.0 / (1.0 + Ask(1, a, b));
printf("%.10f\n", (double)Ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a_i, b_i;
cin >> n;
vector<char> v(n);
for (a_i = 0; a_i < n; a_i++) cin >> v[a_i];
bool is1 = false, is2 = false;
for (a_i = 0; a_i < n; a_i++) {
if (v[a_i] == 'a' || v[a_i] == 'e' || v[a_i] == 'i' || v[a_i] == 'o' ||
v[a_i] == 'u' || v[a_i] == 'y') {
if (is1)
v[a_i] = '_';
else
is1 = true;
} else {
is1 = false;
}
}
for (a_i = 0; a_i < n; a_i++)
if (v[a_i] != '_') cout << v[a_i];
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int block_size = 320;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
const int inf = mod;
const double PI = atan(1) * 4;
template <typename T>
inline int sign(const T &a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
template <typename T>
inline void in(T &x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
const int maxn = 1010;
int dp[maxn][maxn][11];
char s[2][maxn];
int match[maxn][maxn], len[2], k;
int main() {
cin >> len[0] >> len[1] >> k;
scanf("%s %s", s[0] + 1, s[1] + 1);
for (long long i = 1; i < len[0] + 1; i++) {
for (long long j = 1; j < len[1] + 1; j++) {
if (s[0][i] == s[1][j]) {
match[i][j] = match[i - 1][j - 1] + 1;
}
}
}
for (long long i = 1; i < len[0] + 1; i++) {
for (long long j = 1; j < len[1] + 1; j++) {
for (long long cnt = 1; cnt < k + 1; cnt++) {
dp[i][j][cnt] =
max({dp[i - match[i][j]][j - match[i][j]][cnt - 1] + match[i][j],
dp[i - 1][j][cnt], dp[i][j - 1][cnt]});
}
}
}
int ans = 0;
for (long long cnt = 1; cnt < k + 1; cnt++) {
ans = max(ans, dp[len[0]][len[1]][cnt]);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3002;
const int logN = 11;
struct TEdge {
int u, v;
} e[N];
vector<int> a[N];
int n, res, f[N], cnt[N][2];
bool dem[N][2];
vector<int> val;
void DFS(int u, int par) {
int v;
cnt[u][0] = cnt[u][1] = 0;
for (int i : a[u]) {
v = e[i].u ^ e[i].v ^ u;
if (v == par) continue;
if (v == e[i].v)
++cnt[u][0], dem[v][0] = 1, dem[v][1] = 0;
else
++cnt[u][1], dem[v][1] = 1, dem[v][0] = 0;
DFS(v, u);
cnt[u][0] += cnt[v][0], cnt[u][1] += cnt[v][1];
}
f[u] = cnt[u][1];
for (int i : a[u]) {
v = e[i].u ^ e[i].v ^ u;
if (v == par) continue;
if (v == e[i].v)
f[u] = min(f[u], f[v] + 1 + cnt[u][1] - cnt[v][1]);
else
f[u] = min(f[u], f[v] + cnt[u][1] - cnt[v][1] - 1);
if (u == par) val.emplace_back(cnt[v][1] + dem[v][1] - f[v] - dem[v][0]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("test"
".inp",
"r")) {
freopen(
"test"
".inp",
"r", stdin);
freopen(
"test"
".out",
"w", stdout);
}
cin >> n;
for (int i = 1; i < n; ++i) {
cin >> e[i].u >> e[i].v;
a[e[i].u].emplace_back(i), a[e[i].v].emplace_back(i);
}
res = n - 1;
for (int i = 1; i <= n; ++i) {
dem[i][0] = dem[i][1] = 0;
val.clear();
DFS(i, i);
sort(val.begin(), val.end(), greater<int>());
res = min(res, f[i]);
if ((int)val.size() >= 2) res = min(res, cnt[i][1] - val[0] - val[1]);
}
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> minimum_prime_fuctors(int x) {
vector<int> res(x + 1);
vector<int> primes;
for (int i = 2; i <= x; i++) {
if (res[i] == 0) {
res[i] = i;
primes.push_back(i);
}
for (int j = 0;
j < primes.size() && primes[j] <= res[i] && primes[j] * i <= x; j++) {
res[i * primes[j]] = primes[j];
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
vector<int> mp = minimum_prime_fuctors(1010101);
const int mod = 1000000007;
int fs = 1010101;
vector<long long> fact(fs), ifact(fs), invs(fs);
fact[0] = ifact[0] = fact[1] = ifact[1] = invs[1] = 1;
for (int i = 2; i < fs; i++) {
fact[i] = fact[i - 1] * i % mod;
invs[i] = mod - invs[mod % i] * (mod / i) % mod;
ifact[i] = ifact[i - 1] * invs[i] % mod;
}
function<long long(int, int)> binom = [&](int a, int b) {
if (b == 0) return 1LL;
if (a < b || b < 0) return 0LL;
return fact[a] * ifact[b] % mod * ifact[a - b] % mod;
};
while (q--) {
int r, n;
cin >> r >> n;
long long res = 1;
while (n > 1) {
int p = mp[n];
int k = 0;
while (n % p == 0) {
n /= p;
k++;
}
long long te = 0;
for (int i = 0; i <= k; i++) {
te = (te + binom(r + k - 1 - i, k - i) * (i == 0 ? 1 : 2) % mod) % mod;
}
res = res * te % mod;
}
cout << res << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200001;
const long long mod = 1e9 + 7;
int main() {
int N, M, ind = 0;
scanf("%d %d", &N, &M);
long long nums[N], arr[N];
pair<long long, int> arr2[N];
for (int i = 0; i < N; i++) {
scanf("%lld", &nums[i]);
}
for (int i = 0; i < N; i++) {
scanf("%lld", &arr[i]);
arr2[i] = {arr[i], i};
}
sort(arr2, arr2 + N);
long long res, a, b;
for (int i = 0; i < M; i++) {
scanf("%lld %lld", &a, &b);
a--;
if (nums[a] >= b) {
printf("%lld\n", b * arr[a]);
nums[a] -= b;
continue;
} else {
res = 0;
res = nums[a] * arr[a];
b -= nums[a];
nums[a] = 0;
while (ind < N && b) {
if (nums[arr2[ind].second] >= b) {
res += b * arr[arr2[ind].second];
nums[arr2[ind].second] -= b;
b = 0;
} else {
res += nums[arr2[ind].second] * arr[arr2[ind].second];
b -= nums[arr2[ind].second];
nums[arr2[ind].second] = 0;
ind++;
}
}
}
if (b)
printf("0\n");
else
printf("%lld\n", res);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int x;
cin >> x;
if (x > 2) {
cout << x % 2 << endl;
} else {
cout << x % 2 + 2 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 1e6 + 10;
int a[maxx];
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
a[0] = 0;
for (int i = 1; i <= s.size(); i++)
if (s[i - 1] == '+')
a[i] = a[i - 1] + 1;
else
a[i] = a[i - 1] - 1;
long long ma = 0;
long long ans = 0;
long long ex = 0;
for (int i = 1; i <= s.size(); i++) {
if (a[i] >= 0) continue;
if (a[i] < ma) {
ans += i * (abs(a[i]) - ex);
ex = abs(a[i]);
ma = a[i];
}
}
ans += s.length();
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
struct edge {
int v, w;
edge *nt;
} G[100007], *e[100007], *v = G;
int n, k, MAPLE = 1, lm, rm, fin, ri[100007], pos, d[100007], a[100007], wt,
ss[19];
char fl[1 << 23], *A = fl;
long long fint, w[100007], s[100007], mpos;
bool u[100007];
struct node {
long long mx, mi, h, mp, mc;
node *l, *r;
int fg;
int le, ri, mid;
long long min(long long a, long long b) { return a > b ? b : a; }
void pd(long long tmp) { mx += tmp, mi += tmp, h += tmp, mc += tmp; }
long long dfs(long long tmp) {
if (tmp > mx || le == ri) return tmp + mp;
if (h) l->pd(h), r->pd(h), h = 0;
if (l->mx < tmp)
return min(tmp + l->mp, r->dfs(tmp));
else
return min(l->dfs(tmp), mi);
}
int vfs() {
if (le == ri) return le;
if (h) l->pd(h), r->pd(h), h = 0;
return r->mc <= k ? r->vfs() : l->vfs();
}
void query() {
if (lm <= le && ri <= rm) {
if (dfs(fint) <= k) pos = fg, mpos = fint;
if (mx > fint) fint = mx;
return;
}
if (h) l->pd(h), r->pd(h), h = 0;
if (lm <= mid) l->query();
if (mid < rm) r->query();
}
void fix() {
mx = l->mx > r->mx ? l->mx : r->mx, mc = l->mc, mi = r->dfs(l->mx);
}
void alter() {
if (lm <= le) return (void)pd(fin);
if (h) l->pd(h), r->pd(h), h = 0;
if (lm <= mid) l->alter();
r->alter();
fix();
}
int qfs(long long fint) {
if (le == ri) return le;
if (h) l->pd(h), r->pd(h), h = 0;
if (r->dfs(l->mx > fint ? l->mx : fint) <= k)
return r->qfs(l->mx > fint ? l->mx : fint);
return l->qfs(fint);
}
} t[262144], *root, *cnt = t;
void read(int &x) {
char c;
for (x = 0; '0' > (c = *A++) || c > '9';)
;
while ('0' <= c && c <= '9') x = (x << 3) + (x << 1) + c - 48, (c = *A++);
}
void print(int x) {
if (!x)
putchar(48);
else {
for (wt = 0; x; ss[++wt] = x % 10, x /= 10)
;
for (; wt; putchar(ss[wt--] + 48))
;
}
}
void build(node *&x, int le, int ri) {
if (x = ++cnt, x->fg = cnt - t, x->le = le, x->ri = ri, le == ri)
return (void)(s[le] = s[le - 1] + a[le] - d[le - 1], x->mx = s[le],
x->mp = -s[le]);
int mid = (le + ri) >> 1;
x->mid = mid, build(x->l, le, mid), build(x->r, mid + 1, ri), x->fix();
x->mp = x->l->mp < x->r->mp ? x->l->mp : x->r->mp;
}
void dfs(int x) {
int tmp = root->vfs();
if ((++tmp) > n) tmp = n;
if (x != tmp && (fint = s[x], lm = x + 1, rm = tmp, pos = 0, root->query(),
pos && (tmp = t[pos].qfs(mpos), tmp - x + 1 > MAPLE)))
MAPLE = tmp - x + 1;
for (edge *v = e[x]; v; lm = x - 1, fin = v->w, root->alter(), s[lm] += fin,
dfs(v->v), lm = x - 1, fin = -v->w, root->alter(), s[lm] += fin,
v = v->nt)
;
}
int main() {
int i, j;
long long tmp;
for (*(fl + fread(fl, 1, 1 << 23, stdin)) = EOF, read(n), read(k), i = 1;
i < n; read(d[i++]))
;
for (i = 1; i <= n; read(a[i]), w[i] = w[i - 1] + a[i] - d[i], i++)
;
for (build(root, 1, n), w[n + 1] = -1ll << 51, u[n] = true, ri[n] = n + 1,
i = n - 1;
~i; i--) {
for (j = i + 1; w[j] >= w[i]; j = ri[j])
;
ri[i] = j;
if (ri[i] < n)
(++v)->v = i + 1, v->nt = e[ri[i] + 1], e[ri[i] + 1] = v,
v->w = w[i] - w[ri[i]];
else
u[i + 1] = true;
}
for (i = 1; i <= n; i++)
if (u[i]) dfs(i);
print(MAPLE);
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int rp = 666666;
const bool debug = 1;
const int Mod = 1e9 + 7;
int n, m, k;
long long ans;
int limit[12][12];
int able[12][12][12];
vector<int> newColor;
int x[12];
int y[12];
bool used[12];
void dfs(int nowX, int nowY, int nextNew, long long Times) {
if (nowY >= m) {
nowX++;
nowY = 0;
}
if (nowX >= n) {
ans += Times;
if (ans >= Mod) ans -= Mod;
return;
}
for (int c = 1; c <= k; c++) {
if (!able[nowX][nowY][c]) continue;
if (limit[nowX][nowY] && limit[nowX][nowY] != c) continue;
if (!used[c] && c != newColor[nextNew]) continue;
if (x[c] != -1 && x[c] <= nowX && y[c] <= nowY) continue;
int tx = x[c], ty = y[c];
x[c] = nowX, y[c] = nowY;
if (!used[c]) {
used[c] = true;
dfs(nowX, nowY + 1, nextNew + 1, Times * (newColor.size() - nextNew));
used[c] = false;
} else {
dfs(nowX, nowY + 1, nextNew, Times);
}
x[c] = tx, y[c] = ty;
}
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
if (n + m - 1 > k) {
cout << "0" << endl;
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> limit[i][j];
used[limit[i][j]] = true;
}
}
for (int i = 1; i <= k; i++) {
if (!used[i]) newColor.push_back(i);
}
memset(able, 1, sizeof(able));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int c = 1; c <= k; c++) {
for (int I = 0; I < n; I++) {
for (int J = 0; J < m; J++) {
if (I <= i && J <= j && limit[I][J] == c) able[i][j][c] = false;
if (I >= i && J >= j && limit[I][J] == c) able[i][j][c] = false;
}
}
if (limit[i][j] == c) able[i][j][c] = true;
}
}
}
memset(x, -1, sizeof(x));
dfs(0, 0, 0, 1);
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long fac[2000005];
void pre() {
fac[0] = 1;
fac[1] = 1;
for (int i = 2; i < 200005; i++) fac[i] = (i * fac[i - 1]) % 1000000007;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b = b / 2;
}
return res % 1000000007;
}
long long ncr(long long n, long long r) {
return ((fac[n] * power(fac[r], 1000000007 - 2)) % 1000000007 *
power(fac[n - r], 1000000007 - 2)) %
1000000007;
}
long long n, m;
long long a[200005];
long long tot = 0;
long long can(long long p6) {
long long sum1 = 0;
long long sum2 = 0;
long long f = 0;
for (int i = 0; i < n; i++) {
long long have = 0;
long long p1 = tot - sum1 - a[i];
long long p2 = i * a[i] - sum1;
have += p2;
if (i + 1 >= m && have - (i + 1 - m) <= p6) {
f = 1;
break;
}
long long p3 = (n - i - 1) * a[i];
p1 -= p3;
if (n - i >= m && p1 - (n - i - m) <= p6) {
f = 1;
break;
}
have += p1;
long long can1 = n - m;
if (have - can1 <= p6) {
f = 1;
break;
}
sum1 += a[i];
}
return f;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
cin >> n >> m;
map<long long, long long> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
tot += a[i];
}
sort(a, a + n);
for (auto it : mp) {
if (it.second >= m) {
cout << "0" << endl;
return 0;
}
}
long long lo = 1;
long long hi = 1e18;
long long ans = -1;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (can(mid)) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 300;
vector<pair<int, int> > e[N];
vector<pair<long long, int> > p;
long long deep[N], a[N];
int f[N];
int n;
void dfs(int x) {
f[x]++;
int w = lower_bound(p.begin(), p.end(), make_pair(deep[x] - a[x], -1)) -
p.begin() - 1;
if (w >= 0) f[p[w].second]--;
p.push_back(make_pair(deep[x], x));
for (auto& v : e[x]) {
deep[v.first] = deep[x] + v.second;
dfs(v.first);
f[x] += f[v.first];
}
p.pop_back();
}
signed main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 2; i <= n; i++) {
int x, y;
cin >> x >> y;
e[x].push_back(make_pair(i, y));
}
dfs(1);
for (int i = 1; i <= n; i++) {
cout << f[i] - 1 << " ";
}
printf("\n");
;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline void PRE() {
cout << fixed << showpoint;
cout << setprecision(9);
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
long long n, i = 0;
cin >> n;
vector<long long> o, e;
for (i = 0; i < n; ++i) {
long long a;
cin >> a;
if (a % 2 == 0)
e.push_back(a);
else
o.push_back(a);
}
long long sum;
sort(o.begin(), o.end());
sort(e.begin(), e.end());
if (o.size() > e.size()) {
long long nn = o.size() - e.size();
sum = 0;
for (i = 0; i < nn - 1; ++i) {
sum += o[i];
}
} else {
long long nn = e.size() - o.size();
sum = 0;
for (i = 0; i < nn - 1; ++i) {
sum += e[i];
}
}
cout << sum << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
inline void put(int a, int b) { printf("%d %d\n", a, b); }
int main() {
scanf("%d", &n);
if (n % 4 >= 2) return puts("NO"), 0;
puts("YES");
bool flag = n % 4;
for (int i = 1; i + 3 <= n; i += 4) {
if (flag) put(i, n);
put(i, i + 1);
if (flag) put(i + 1, n);
if (flag) put(i + 2, n);
put(i + 2, i + 3);
if (flag) put(i + 3, n);
put(i + 1, i + 2);
put(i, i + 3);
put(i, i + 2);
put(i + 1, i + 3);
}
for (int i = 1; i + 3 <= n; i += 4)
for (int j = i + 4; j + 3 <= n; j += 4) {
put(i, j), put(i + 1, j + 1), put(i + 2, j + 2), put(i + 3, j + 3);
put(i, j + 1), put(i + 1, j + 2), put(i + 2, j + 3), put(i + 3, j);
put(i, j + 3), put(i + 1, j), put(i + 2, j + 1), put(i + 3, j + 2);
put(i, j + 2), put(i + 1, j + 3), put(i + 2, j), put(i + 3, j + 1);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305, Q = (1 << 21) + 1;
char in[Q], *is = in, *it = in, c;
void R(int &n) {
for (n = 0; (c = (it == is ? it = (is = in) + fread(in, 1, Q, stdin),
(it == is ? EOF : *is++) : *is++)) < '0' ||
c > '9';)
;
for (; c <= '9' && c >= '0';
c = (it == is ? it = (is = in) + fread(in, 1, Q, stdin),
(it == is ? EOF : *is++) : *is++))
n = n * 10 + c - 48;
}
int na, nb, m, k, x, y, du[N * 2], ans, be[N * N], w[N], w2[N], kk, c1, c2;
int js, g[N * 2], id[10005][305], f[10005][305];
void rv(int x, int c1, int c2) {
swap(f[x][c1], f[x][c2]);
swap(id[x][c1], id[x][c2]);
be[id[x][c2]] = c2;
if (f[x][c2]) rv(f[x][c2], c2, c1);
}
int main() {
R(na);
R(nb);
R(m);
R(k);
for (int i = 1, _e = m; i <= _e; i++) {
R(x);
R(y);
du[x]++;
du[y + na]++;
if (g[x] % k == 0) w[x] = ++js;
if (g[na + y] % k == 0) w2[y] = ++js;
g[x]++;
g[na + y]++;
x = w[x];
y = w2[y];
c1 = 0, c2 = 0;
for (int j = 1, _e = k; j <= _e; j++)
if (!f[x][j]) {
c1 = j;
break;
}
for (int j = 1, _e = k; j <= _e; j++)
if (!f[y][j]) {
c2 = j;
break;
}
if (f[y][c1]) rv(y, c1, c2);
f[x][c1] = y;
id[x][c1] = i;
f[y][c1] = x;
id[y][c1] = i;
be[i] = c1;
}
for (int i = 1, _e = na + nb; i <= _e; i++) ans += (du[i] % k > 0);
printf("%d\n", ans);
for (int i = 1, _e = m; i <= _e; i++) printf("%d ", be[i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
long long int d;
cin >> n;
cin >> d;
long long int arr[n + 1];
map<long long int, long long int> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
m[arr[i]] = 1;
}
long long int c = 0;
for (int i = 0; i < n; i++) {
long long int x = arr[i] + d;
long long int a = 0;
for (int j = 0; j < n; j++) {
long long int k = abs(x - arr[j]);
if (k < d) {
a = 1;
break;
}
}
if (a == 0 && m.find(x) == m.end()) {
m[x] = 1;
c++;
}
}
for (int i = 0; i < n; i++) {
long long int x = arr[i] - d;
long long int a = 0;
for (int j = 0; j < n; j++) {
long long int k = abs(x - arr[j]);
if (k < d) {
a = 1;
break;
}
}
if (a == 0 && m.find(x) == m.end()) {
m[x] = 1;
c++;
}
}
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const int mod = 1000000007;
const int inf = 0x3f3f3f3f;
int ttt;
struct Node {
int i;
int t;
} node[300005];
int ans[300005];
set<int> s;
bool cmp(Node a, Node b) {
if (a.t == b.t) {
return a.i < b.i;
}
return a.t > b.t;
}
int main() {
int i, j, k, m, n;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &node[i].t);
node[i].i = i;
s.insert(i + k);
}
sort(node + 1, node + n + 1, cmp);
long long sum = 0;
for (i = 1; i <= n; i++) {
int p = *s.upper_bound(node[i].i - 1);
sum += (long long)(p - node[i].i) * node[i].t;
ans[node[i].i] = p;
s.erase(p);
}
printf("%lld\n", sum);
for (i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long a, long long b) {
if (b == 1) return a;
if (a > b) return a / b + f(a % b, b);
return f(b, a);
}
int main() {
long long a, b;
cin >> a >> b;
cout << f(a, b);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.