solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int a[maxn], b[maxn];
int main() {
int n, m;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
int l = 0, r = 0, cnt = 0;
long long sa = 0, sb = 0;
while (l < n && r < m) {
if (sa == 0 && sb == 0) {
sa += a[l++];
sb += b[r++];
}
if (sa > sb) {
sb += b[r++];
} else if (sa < sb) {
sa += a[l++];
} else if (sa == sb) {
cnt++;
sa = sb = 0;
}
}
while (l < n) sa += a[l++];
while (r < m) sb += b[r++];
if (sa != sb) {
printf("-1\n");
} else {
printf("%d\n", cnt + (sa == 0 ? 0 : 1));
}
}
| 8 |
#include <bits/stdc++.h>
struct edge_t {
struct edge_t *next;
int v;
};
struct edge_t *e[100005], e_pool[100005 * 2], *ep_top = e_pool;
int deg[100005];
void add_edge(int u, int v) {
deg[u]++, deg[v]++;
ep_top->v = v;
ep_top->next = e[u];
e[u] = ep_top++;
ep_top->v = u;
ep_top->next = e[v];
e[v] = ep_top++;
}
int n;
struct ans_t {
int u, k;
};
struct ans_t make_ans(int u, int k) {
struct ans_t res = {.u = u, .k = k};
return res;
}
struct ans_t ans[100005 * 10], *ans_top = ans;
void dfs(int u, int f, int p) {
const int goal = p - 1;
*ans_top++ = make_ans(u, p);
int sons = deg[u] - (f != -1);
int rollback_cnt = p - 1;
for (struct edge_t *i = e[u]; i; i = i->next) {
int v = i->v;
if (v == f) continue;
if (sons <= rollback_cnt) {
*ans_top++ = make_ans(u, rollback_cnt - sons);
p = rollback_cnt - sons;
rollback_cnt = -1;
}
sons--, p++;
dfs(v, u, p);
*ans_top++ = make_ans(u, p);
}
if (u != 1 && p != goal) *ans_top++ = make_ans(u, goal);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
}
dfs(1, -1, 0);
printf("%ld\n", ans_top - ans);
for (struct ans_t *i = ans; i < ans_top; ++i) printf("%d %d\n", i->u, i->k);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n;
cin >> n;
unsigned long long l = 1000000001, r = 0;
long long pos = -1, flag = 0;
for (unsigned long long i = 1, x, y; i <= n; i++) {
cin >> x >> y;
if (x <= l and r <= y) {
pos = i;
l = x;
r = y;
} else {
if (x < l) {
l = x;
pos = -1;
}
if (r < y) {
r = y;
pos = -1;
}
}
}
cout << pos << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, pos = 1, ans;
int main() {
cin >> n >> m;
for (long long i = 1, x; i <= m; ++i) {
cin >> x;
if (x < pos) {
ans += n - pos + x;
} else {
ans += x - pos;
}
pos = x;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct ww {
double x, y, z;
inline double bei() const { return x * x + y * y; }
inline ww operator-(const ww &A) { return (ww){x - A.x, y - A.y, 0}; }
inline double operator*(const ww &A) { return x * A.y - y * A.x; }
} a[100010], O;
struct w {
double a;
int id;
inline bool operator<(const w &A) const { return a < A.a; }
};
int i, j, k, n, m;
double r, an;
int g[100010], F[100010], L[100010], R[100010], f[100010];
priority_queue<w> b;
inline bool cc1(const ww &a, const ww &b) {
return a.z + (1e-8) < b.z || abs(a.z - b.z) < (1e-8) && a.bei() < b.bei();
}
inline bool ju(int A, int B, int C) {
return (a[C] - a[A]) * (a[B] - a[A]) > -(1e-8);
}
inline void Tu() {
k = 1;
for (i = 2; i <= n; i++)
if (a[i].x < a[k].x || a[i].x == a[k].x && a[i].y < a[k].y) k = i;
swap(a[1], a[k]);
O = a[1];
for (i = n; i; i--) {
a[i].x -= a[1].x, a[i].y -= a[1].y;
a[i].z = atan2(a[i].y, a[i].x);
}
sort(a + 2, a + n + 1, cc1);
g[m = 1] = 1;
for (i = 2; i <= n + 1; i++) {
for (; m > 1 + (i == n + 1) && ju(g[m - 1], g[m], i); m--)
;
g[++m] = i;
}
m--;
a[0] = a[m];
}
inline double dis(ww a, ww b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
inline ww suan(double a, double b, double c, double d, double e, double f) {
ww O = {(f * b - c * e) / (a * e - b * d), (a * f - c * d) / (b * d - a * e)};
return O;
}
inline double pan(int x) {
ww A = a[g[L[x]]], B = a[g[x]], C = a[g[R[x]]];
double s1 = dis(A, B), s2 = dis(B, C), s3 = dis(A, C);
if (s1 + s2 + (1e-8) < s3) {
ww O = suan(2 * (A.x - B.x), 2 * (A.y - B.y), B.bei() - A.bei(),
2 * (A.x - C.x), 2 * (A.y - C.y), C.bei() - A.bei());
double R = dis(O, A);
return sqrt(R);
}
return 0;
}
inline void cal() {
for (i = 1; i <= m; i++) an += a[g[i]] * a[g[i + 1]];
if (an < 0) an = -an;
an /= 2;
for (i = 1; i <= m; i++) {
double s = dis(a[g[i]], a[g[i + 1]]);
s = sqrt(s);
double ag = asin(s / 2 / r) * 2;
double s1 = r * r * ag / 2;
double s2 = r * sin(ag) * r / 2;
an += s1 - s2;
}
printf("%.11lf\n", an);
}
int main() {
scanf("%d%lf", &n, &r);
for (i = 1; i <= n; i++) scanf("%lf%lf", &a[i].x, &a[i].y);
int flag = a[1].x == 2004;
Tu();
for (i = 2; i <= m - 1; i++) L[i] = i - 1, R[i] = i + 1;
L[1] = m, R[m] = 1, R[1] = 2, L[m] = m - 1;
for (i = 1; i <= m; i++) b.push((w){pan(i), i});
for (; b.size() > 2;) {
w A = b.top();
if (A.a < r + (1e-8)) break;
int B = A.id;
b.pop();
if (F[B]) continue;
F[B] = 1;
L[R[B]] = L[B];
R[L[B]] = R[B];
b.push((w){pan(L[B]), L[B]});
b.push((w){pan(R[B]), R[B]});
}
for (; b.size();) {
w A = b.top();
b.pop();
if (!F[A.id]) f[A.id] = 1;
}
k = m, m = 0;
for (i = 1; i <= k; i++)
if (f[i]) {
g[++m] = g[i];
}
g[m + 1] = g[1];
cal();
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
bool mark[4000000 + 10];
int n, m;
int get(int x, int y) {
if (x < 1 || x > n || y < 1 || y > m) return 0;
if (x == 1) return y;
if (x == n) return m + 2 * n - 4 + y;
return m + 2 * (x - 1) - (y == 1);
}
void dfs(int v) {
if (mark[v]) return;
mark[v] = true;
int x = (v <= m) ? (1) : (v <= m + 2 * n - 4) ? ((v - m + 1) / 2 + 1) : (n);
int y = (v <= m) ? (v)
: (v <= m + 2 * n - 4) ? ((v - m + 1) % 2 * (m - 1) + 1)
: (v - m - 2 * n + 4);
dfs(get(n, y + n - x));
dfs(get(n, y - n + x));
dfs(get(1, y + x - 1));
dfs(get(1, y - x + 1));
dfs(get(x + m - y, m));
dfs(get(x - m + y, m));
dfs(get(x + y - 1, 1));
dfs(get(x - y + 1, 1));
}
int main() {
cin >> n >> m;
int ans = 0;
mark[0] = true;
for (int i = 1; i <= 2 * (n + m - 2); i++)
if (!mark[i]) ans++, dfs(i);
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long an = 1;
for (long long i = 2; i <= sqrt(n); i++) {
long long c = 0;
while (n % i == 0) {
c++;
n /= i;
}
if (c) an *= i;
}
if (n >= 2) an *= n;
cout << an << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
const double pi = 3.1415926535897932384626433832795;
template <class T>
inline T Sqr(const T &x) {
return x * x;
}
template <class T>
inline T Abs(const T &x) {
return x >= 0 ? x : -x;
}
long long res;
int l, r;
void test(long long x) {
long long c = 1;
long long y = x;
while (y) {
c *= 10;
y /= 10;
}
c--;
if (x < l || x > r) return;
long long w = x * (c - x);
res = max(res, w);
}
void solve() {
scanf("%d%d", &l, &r);
int t = 1;
for (int i = 0; i < (9); i++) {
t *= 10;
test((t - 1) / 2);
test((t - 1) / 2 + 1);
}
test(l);
test(r);
cout << res;
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, a2, a3, a4;
cin >> a1 >> a2 >> a3 >> a4;
int s[a1 + a2];
for (int i = 0; i < a1 + a2; i++) s[i] = 0;
if ((a3 > a4) || (a3 == a4 && a1 > a3)) {
s[0] = 4;
a1--;
int i = 1;
while (a3 != 0 || a4 != 0) {
if (a3 != 0 && s[i - 1] == 4)
s[i] = 7, a3--, a2--;
else {
if (a4 != 0 && s[i - 1] == 7) {
s[i] = 4;
a4--;
a1--;
} else {
cout << -1;
return 0;
}
}
i++;
}
if (a2 < 0 || a1 < 0) {
cout << -1;
return 0;
}
if (i == 1 && a2 != 0) {
cout << -1;
return 0;
}
for (int j = 0; j < i; j++) {
cout << s[j];
while ((s[j] == 4 && a1 != 0)) {
cout << 4;
a1--;
}
while ((s[j] == 7 && a2 != 0) && (j + 2 >= i)) {
cout << 7;
a2--;
}
}
} else {
s[0] = 7;
a2--;
int i = 1;
while (a3 != 0 || a4 != 0) {
if (a3 != 0 && s[i - 1] == 4)
s[i] = 7, a3--, a2--;
else {
if (a4 != 0 && s[i - 1] == 7) {
s[i] = 4;
a4--;
a1--;
} else {
cout << -1;
return 0;
}
}
i++;
}
if (a2 < 0 || a1 < 0) {
cout << -1;
return 0;
}
if (i == 1 && a1 != 0) {
cout << -1;
return 0;
}
for (int j = 0; j < i; j++) {
cout << s[j];
while ((s[j] == 4 && a1 != 0)) {
cout << 4;
a1--;
}
while ((s[j] == 7 && a2 != 0) && (j + 2 >= i)) {
cout << 7;
a2--;
}
}
}
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize "03"
using namespace std;
const long long int N = 1e5 + 5;
const long long int B = 44;
const long long int mod = 1e9 + 7;
const long long int inf = 1e9 + 9;
struct trie {
long long int z, o, v;
} t[40 * N];
long long int a[N], c = 1;
void merge(long long int nd) {
long long int p = 0;
if (t[nd].o != 0) p += t[t[nd].o].v;
if (t[nd].z != 0) p += t[t[nd].z].v;
t[nd].v = p;
}
void add(long long int nd, long long int x, long long int b) {
if (b == -1) {
t[nd].v++;
return;
}
bool p = (x & (1LL << b));
if (p) {
if (t[nd].o == 0) t[nd].o = ++c;
add(t[nd].o, x - (1LL << b), b - 1);
} else {
if (t[nd].z == 0) t[nd].z = ++c;
add(t[nd].z, x, b - 1);
}
merge(nd);
}
void del(long long int nd, long long int x, long long int b) {
if (b == -1) {
t[nd].v--;
return;
}
bool p = (x & (1LL << b));
if (p)
del(t[nd].o, x - (1LL << b), b - 1);
else
add(t[nd].z, x, b - 1);
merge(nd);
}
long long int query(long long int nd, long long int x, long long int b) {
if (b == -1) return 0;
long long int ans = 0;
bool p = (x & (1LL << b));
if (p) {
if (t[nd].z != 0)
ans = (1LL << b) + query(t[nd].z, x - (1LL << b), b - 1);
else
ans = query(t[nd].o, x - (1LL << b), b - 1);
} else {
if (t[nd].o != 0)
ans = (1LL << b) + query(t[nd].o, x, b - 1);
else
ans = query(t[nd].z, x, b - 1);
}
return ans;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
add(1, 0, B - 1);
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
a[i] = (a[i] ^ a[i - 1]);
add(1, a[i], B - 1);
}
long long int ans = query(1, 0, B - 1);
for (long long int i = n; i >= 1; i--) {
a[i] = (a[i] ^ a[i - 1]);
a[i] = (a[i] ^ a[i + 1]);
ans = max(ans, query(1, a[i], B - 1));
}
cout << ans << '\n';
return 0;
}
| 14 |
#include<bits/stdc++.h>
#define endl "\n"
using ll = long long;
using namespace std;
ll arr[103];
ll ans[103];
void recurse_fill(ll l, ll r, ll d){
if(l > r){
return;
}
ll posm, mx;
mx = -1;
for(ll i = l; i <= r; ++i){
if(arr[i] > mx){
mx = arr[i];
posm = i;
}
}
ans[posm] = d;
recurse_fill(l, posm-1, d+1);
recurse_fill(posm+1, r, d+1);
}
void solve(){
ll n;
cin >> n;
for(ll i = 0; i < n; ++i){
ll x;
cin >> x;
arr[i] = x;
}
recurse_fill(0, n-1, 0);
for(ll i = 0; i < n; ++i){
cout << ans[i] << ' ';
}
cout << endl;
}
int main(){
ll t;
cin >> t;
while(t--){
solve();
}
} | 4 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long int
#define mod 998244353
inline int sum(int a,int b){return a+b<mod?a+b:a+b-mod;}
inline int mul(int a,int b){return (int)((ll)a*b%mod);}
inline int pow(int a,int b)
{
int res=1;
while(b>0){
if(b&1) res=mul(res,a);
a=mul(a,a); b>>=1;
}
return res;
}
inline int inv(int x){return pow(x,mod-2);}
int n,m=0,t,ans=0;
ll l[50],r[50],pos[150];
struct matrix{
int m[50][50];
matrix(void){
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++)
m[i][j]=m[j][i]=0;
m[i][i]=1;
}
return;
}
};
matrix mmul(matrix m1,matrix m2)
{
matrix M;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++){
M.m[i][j]=0;
for(int k=0;k<n;k++)
M.m[i][j]=sum(M.m[i][j],mul(m1.m[i][k],m2.m[k][j]));
}
return M;
}
matrix mpow(matrix m,ll k)
{
matrix M;
while(k>0){
if(k&1) M=mmul(M,m);
m=mmul(m,m); k>>=1;
}
return M;
}
namespace solver
{
int n,m;
ll p[50],q[50];
void prepare(int L,int R)
{
n=R-L+1; m=0;
for(int i=0;i<n;i++){
p[i]=l[i+L];
q[i]=r[i+L];
}
bool opt=0;
for(int i=0;i<n;i++){
if(p[i]==q[i]){
p[i]=q[i]=1e18;
continue;
}
if(opt&&p[i]<=q[i]){
p[i]++;
if(i<n-1) q[i]--;
if(p[i]>q[i]) p[i]=q[i]=1e18;
}
else if(opt&&p[i]>q[i]){
p[i]--; q[i]++;
if(p[i]<q[i]) p[i]=q[i]=1e18;
}
if(p[i]<1e18){
pos[m++]=p[i]; pos[m++]=q[i];
}
opt^=1;
}
sort(pos,pos+m);
return;
}
inline bool check(int a,ll k)
{
return (p[a]<=k&&k<=q[a])||(p[a]>=k&&k>=q[a]);
}
int res[50],temp[50];
inline void update(ll& nowk)
{
for(int x=0;x<n;x++){
temp[x]=0;
for(int y=0;y<x;y++)
if(check(y,nowk))
temp[x]=sum(temp[x],res[y]);
if(p[x]<=nowk&&nowk<=q[x])
temp[x]=sum(temp[x],res[x]);
}
nowk++;
for(int x=0;x<n;x++)
if(!check(x,nowk))
temp[x]=0;
for(int x=0;x<n;x++)
res[x]=temp[x];
return;
}
int solve(int L,int R)
{
prepare(L,R);
ll nowk=pos[0];
for(int i=0;i<n;i++)
if(check(i,nowk))
res[i]=1;
else res[i]=0;
for(int i=0;i<m;i++){
if(nowk<pos[i])
update(nowk);
if(i<m-1){
if(nowk==pos[i]&&nowk<pos[m-1])
update(nowk);
matrix m1;
for(int x=0;x<n;x++){
for(int y=x+1;y<n;y++)
if(check(x,nowk)&&check(y,nowk))
m1.m[x][y]=1;
if(p[x]>nowk||nowk>q[x])
m1.m[x][x]=0;
}
ll k=pos[i+1]-1-nowk;
matrix m2=mpow(m1,k);
for(int x=0;x<n;x++){
temp[x]=0;
for(int y=0;y<n;y++)
temp[x]=sum(temp[x],mul(res[y],m2.m[y][x]));
}
for(int x=0;x<n;x++)
res[x]=temp[x];
nowk=max(nowk,pos[i+1]-1);
}
}
int ans=0;
for(int i=0;i<n;i++)
if(p[i]==pos[m-1]||q[i]==pos[m-1])
ans=sum(ans,res[i]);
return ans;
}
}
bool checkup(void)
{
for(int i=0;i<n;i++)
if(l[i]<r[i])
return 0;
return 1;
}
int main(void)
{
scanf("%d%lld",&n,&l[0]);
for(int i=0;i<n;i++){
scanf("%d",&t);
r[i]=l[i]+t;
if(i!=n-1) l[i+1]=r[i];
}
if(checkup()){
printf("1 %lld\n",(l[0]-r[n-1]+1)%mod);
return 0;
}
int d=0,ans2=0;
ll ans1=0;
while(d<n){
int mx=d,mn=d;
for(int i=d;i<n;i++)
if(r[mx]<=r[i])
mx=i;
for(int i=d;i<=mx;i++)
if(l[mn]>l[i])
mn=i;
if(ans1<r[mx]-l[mn]+1)
ans2=0;
if(ans1<=r[mx]-l[mn]+1){
ans1=r[mx]-l[mn]+1;
ans2=sum(ans2,solver::solve(mn,mx));
}
d=mx+1;
}
printf("%lld %d\n",ans1,ans2);
return 0;
}
/*
9 0
4 -4 4 -4 4 -4 4 -1000000 1000
*/ | 22 |
#include <bits/stdc++.h>
using namespace std;
long long find_1(vector<long long> A) {
for (long long i = 0; i < A.size(); i++) {
if (A[i] == 1) {
return i;
}
}
assert(false);
return -1;
}
int main() {
long long n;
cin >> n;
vector<long long> A(n, 0);
for (long long i = 0; i < n; i++) {
cin >> A[i];
}
vector<long long> B(n, 0);
for (long long i = 0; i < n; i++) {
cin >> B[i];
}
long long a1 = find_1(A);
long long b1 = find_1(B);
vector<long long> A2;
vector<long long> B2;
for (long long i = 0; i < n; i++) {
long long ai = A[(a1 + i) % n];
if (ai != 0) {
A2.push_back(ai);
}
long long bi = B[(b1 + i) % n];
if (bi != 0) {
B2.push_back(bi);
}
}
assert(A2.size() == n - 1);
assert(B2.size() == n - 1);
bool ok = true;
for (long long i = 0; i < A2.size(); i++) {
if (A2[i] != B2[i]) {
ok = false;
}
}
cout << (ok ? "YES" : "NO") << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
SegmentTree *left, *right;
int a, b;
long long sum;
bool lazy;
SegmentTree(int a, int b)
: left(NULL), right(NULL), a(a), b(b), sum(0), lazy(false) {}
};
void flip(SegmentTree *tree) {
if (tree == NULL) return;
tree->sum = tree->b - tree->a + 1 - tree->sum;
}
void push_lazy(SegmentTree *tree, SegmentTree *child) {
if (child == NULL) return;
if (!tree->lazy) return;
flip(child);
if (child->a != child->b) child->lazy = !child->lazy;
}
SegmentTree *build(int *arr, int a, int b) {
if (a > b) return NULL;
SegmentTree *result = new SegmentTree(a, b);
if (a == b) {
result->sum = arr[a];
} else {
int m = (a + b) / 2;
result->left = build(arr, a, m);
result->right = build(arr, m + 1, b);
result->sum = result->left->sum + result->right->sum;
}
return result;
}
long long query(SegmentTree *tree, int a, int b) {
if (tree == NULL) return 0;
if (tree->a > b) return 0;
if (tree->b < a) return 0;
if (tree->a >= a && tree->b <= b) return tree->sum;
push_lazy(tree, tree->left);
push_lazy(tree, tree->right);
tree->lazy = false;
return query(tree->left, a, b) + query(tree->right, a, b);
}
long long update(SegmentTree *tree, int a, int b) {
if (tree == NULL) return 0;
if (tree->a > b) return tree->sum;
if (tree->b < a) return tree->sum;
if (tree->a >= a && tree->b <= b) {
flip(tree);
if (tree->a != tree->b) {
tree->lazy = !tree->lazy;
}
} else {
push_lazy(tree, tree->left);
push_lazy(tree, tree->right);
tree->lazy = false;
tree->sum = update(tree->left, a, b) + update(tree->right, a, b);
}
return tree->sum;
}
void print_tree(SegmentTree *tree, int indent) {
if (tree == NULL) {
printf("%*sNULL\n", indent * 4, "");
} else {
printf("%*sNODE\n", indent * 4, "");
printf("%*s a, b = %d, %d\n", indent * 4, "", tree->a, tree->b);
printf("%*s sum = %d\n", indent * 4, "", tree->sum);
printf("%*s lazy = %d\n", indent * 4, "", tree->lazy);
printf("%*s LEFT:\n", indent * 4, "");
print_tree(tree->left, indent + 1);
printf("%*s RIGHT:\n", indent * 4, "");
print_tree(tree->right, indent + 1);
}
}
SegmentTree *trees[21];
int arr[100005];
int bit_arr[21][100005];
int N, M;
int main() {
cin >> N;
for (int n = 0; n < N; n++) {
cin >> arr[n];
for (int b = 0; b < 21; b++) {
bit_arr[b][n] = (arr[n] >> b) % 2;
}
}
for (int b = 0; b < 21; b++) {
trees[b] = build(bit_arr[b], 0, N - 1);
}
cin >> M;
int type, x, y, z;
for (int m = 0; m < M; m++) {
cin >> type;
if (type == 1) {
cin >> x >> y;
x--;
y--;
long long sum = 0, sum2 = 0;
for (int b = 0; b < 21; b++) {
sum += query(trees[b], x, y) << b;
}
cout << sum << endl;
} else if (type == 2) {
cin >> x >> y >> z;
x--;
y--;
for (int b = 0; b < 21; b++) {
if ((z >> b) % 2 == 1) {
update(trees[b], x, y);
}
}
} else {
cout << "bit 1" << endl;
print_tree(trees[1], 0);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long nikita = 1000000007;
long long bin_pow(int a, int m) {
if (m == 1) return a;
long long ans = bin_pow(a, m / 2);
ans = (ans * ans) % nikita;
if (m % 2 == 1) {
ans = ans * a;
}
return ans % nikita;
}
int main() {
int n, m;
cin >> n >> m;
cout << bin_pow((bin_pow(2, m) - 1), n);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0;
string str;
cin >> n >> str;
for (int i = 0; i < n; i++)
if (str[i] == 'X') x++;
if (x < n / 2) {
cout << (n / 2) - x << endl;
for (int i = 0; i < n; i++) {
if (str[i] == 'x') str[i] = 'X', x++;
if (x == n / 2) break;
}
} else if (x > n / 2) {
cout << x - (n / 2) << endl;
for (int i = 0; i < n; i++) {
if (str[i] == 'X') str[i] = 'x', x--;
if (x == n / 2) break;
}
} else
cout << "0" << endl;
cout << str << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[18][(1 << 16) + 5];
int ans[20], chk[20], pos[20];
int n, m;
long long k;
long long Update(int p) {
memset(dp, 0, sizeof(dp));
dp[1][0] = 1;
memset(chk, -1, sizeof(chk));
for (int i = 1; i <= p; ++i) chk[ans[i]] = i;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < (1 << n); ++j) {
if (!dp[i][j]) continue;
for (int k = 1; k <= n; ++k) {
if (j & (1 << k - 1)) continue;
if (chk[i] != -1 && chk[i] != k) continue;
if ((j & pos[k]) == pos[k]) dp[i + 1][j | (1 << k - 1)] += dp[i][j];
}
}
}
return dp[n + 1][(1 << n) - 1];
}
int main() {
scanf("%d%lld%d", &n, &k, &m);
for (int i = 1; i <= m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
pos[b] |= (1 << a - 1);
}
k -= 2000;
if (Update(0) < k) {
printf("The times have changed");
return 0;
}
int used = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (used & (1 << j - 1)) continue;
ans[i] = j;
long long t = Update(i);
if (k > t)
k -= t;
else {
used |= (1 << j - 1);
break;
}
}
}
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double X, Y;
Point(double x, double y) {
X = x;
Y = y;
}
};
bool doubleEqual(double lhs, double rhs) { return fabs(lhs - rhs) <= 1e-12; }
double pointsEqual(Point *lhs, Point *rhs) {
return doubleEqual(lhs->X, rhs->X) && doubleEqual(lhs->Y, rhs->Y);
}
bool intersect(Point *p0, Point *p1, Point *q0, Point *q1, double &x,
double &y) {
double px = p0->X;
double py = p0->Y;
double pm = (p1->Y - p0->Y) / (p1->X - p0->X);
double qx = q0->X;
double qy = q0->Y;
double qm = (q1->Y - q0->Y) / (q1->X - q0->X);
if (doubleEqual(pm, qm)) {
return false;
}
x = (qy - py + (pm * px) - (qm * qx)) / (pm - qm);
if (x <= px || x <= qx || x >= p1->X || x >= q1->X) {
return false;
}
y = py + (pm * (x - px));
return true;
}
double calcArea(vector<Point *> &pts) {
double area = 0;
for (int i = 1; i < pts.size(); i++) {
Point *prev = pts[i - 1];
Point *curr = pts[i];
area += (curr->Y + prev->Y) * (curr->X - prev->X) / 2;
}
return area;
}
int main() {
std::ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<Point *> points[K];
for (int i = 0; i < K; i++) {
Point *p0 = new Point(0, 0);
Point *pf = new Point(1, 0);
points[i].push_back(p0);
points[i].push_back(pf);
}
for (int i = 0; i < N; i++) {
int Y[K + 1];
for (int j = 0; j <= K; j++) {
cin >> Y[j];
}
double sum = 0;
for (int j = 0; j < K; j++) {
double slope = Y[j + 1] - Y[j];
Point *start = new Point(0, Y[j]);
Point *end = new Point(1, Y[j + 1]);
vector<Point *> temp;
temp.push_back(points[j][0]);
for (int k = 1; k < points[j].size(); k++) {
Point *prev = points[j][k - 1];
Point *curr = points[j][k];
double xi, yi;
if (intersect(start, end, prev, curr, xi, yi)) {
Point *pt = new Point(xi, yi);
temp.push_back(pt);
}
temp.push_back(curr);
}
vector<Point *> nodup;
nodup.push_back(temp[0]);
for (int k = 1; k < temp.size(); k++) {
if (!pointsEqual(temp[k - 1], temp[k])) {
nodup.push_back(temp[k]);
}
}
vector<Point *> next;
for (int k = 0; k < nodup.size(); k++) {
Point *pt = nodup[k];
double x = pt->X;
double y = Y[j] + (slope * x);
if (y >= pt->Y) {
Point *curr = new Point(x, y);
next.push_back(curr);
} else {
next.push_back(pt);
}
}
double areaBefore = calcArea(points[j]);
double areaAfter = calcArea(next);
sum += areaAfter - areaBefore;
points[j] = next;
}
cout << fixed << setprecision(12) << sum << endl;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int c[2005];
vector<pair<int, int> > v;
int main() {
ios::sync_with_stdio(0);
int n;
while (cin >> n) {
v.clear();
int aux, aux2;
int h = 0;
int op = 1;
for (int i = 0; i < 2005; i++) c[i] = 0;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
h = max(h, a);
c[a]++;
v.push_back(make_pair(a, i + 1));
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (c[v[i].first] == 2) {
aux = i;
int res = 0;
for (int j = i + 2; j < n; j++)
if (c[v[j].first] == 2) {
op = 2;
res = 1;
aux2 = j;
break;
}
if (res == 1) break;
i++;
}
if (c[v[i].first] >= 3) {
aux = i;
op = 3;
break;
}
}
if (op == 1) cout << "NO\n";
if (op == 2) {
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << v[i].second << ' ';
}
cout << '\n';
for (int i = 0; i < n; i++) {
if (i != aux)
cout << v[i].second << ' ';
else {
cout << v[i + 1].second << ' ' << v[i].second << ' ';
i++;
}
}
cout << '\n';
for (int i = 0; i < n; i++) {
if (i != aux2)
cout << v[i].second << ' ';
else {
cout << v[i + 1].second << ' ' << v[i].second << ' ';
i++;
}
}
cout << '\n';
}
if (op == 3) {
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << v[i].second << ' ';
}
cout << '\n';
for (int i = 0; i < n; i++) {
if (i != aux)
cout << v[i].second << ' ';
else {
cout << v[i + 2].second << ' ' << v[i + 1].second << ' '
<< v[i].second << ' ';
i += 2;
}
}
cout << '\n';
for (int i = 0; i < n; i++) {
if (i != aux)
cout << v[i].second << ' ';
else {
cout << v[i + 1].second << ' ' << v[i + 2].second << ' '
<< v[i].second << ' ';
i += 2;
}
}
cout << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int l, r, n, a[4][2], tot, ans[8], b[4];
bool pd;
int Query(int r1, int c1, int r2, int c2) {
int ret;
printf("? %d %d %d %d\n", r1, c1, r2, c2);
fflush(stdout);
scanf("%d", &ret);
return ret;
}
int main() {
scanf("%d", &n);
l = 1, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (Query(1, 1, n, mid) == 2)
r = mid;
else
l = mid + 1;
}
l = 1, a[0][0] = r;
while (l < r) {
int mid = (l + r) / 2;
if (Query(1, 1, n, mid) > 0)
r = mid;
else
l = mid + 1;
}
a[0][1] = r;
l = 1, r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (Query(1, mid, n, n) == 2)
l = mid;
else
r = mid - 1;
}
a[1][0] = l;
r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (Query(1, mid, n, n) > 0)
l = mid;
else
r = mid - 1;
}
a[1][1] = l;
l = 1, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (Query(1, 1, mid, n) == 2)
r = mid;
else
l = mid + 1;
}
a[2][0] = r;
l = 1;
while (l < r) {
int mid = (l + r) / 2;
if (Query(1, 1, mid, n) > 0)
r = mid;
else
l = mid + 1;
}
a[2][1] = r;
l = 1, r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (Query(mid, 1, n, n) == 2)
l = mid;
else
r = mid - 1;
}
a[3][0] = l;
r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (Query(mid, 1, n, n) > 0)
l = mid;
else
r = mid - 1;
}
a[3][1] = l;
for (int i = 0; i < 1 << 4; i++) {
for (int j = 0; j < 4; j++)
if (i & 1 << j)
b[j] = 1;
else
b[j] = 0;
bool pd = true;
if (a[3][b[3]] > a[2][b[2]] || a[1][b[1]] > a[0][b[0]] ||
Query(a[3][b[3]], a[1][b[1]], a[2][b[2]], a[0][b[0]]) != 1)
pd = false;
if (a[3][1 ^ b[3]] > a[2][1 ^ b[2]] || a[1][1 ^ b[1]] > a[0][1 ^ b[0]] ||
Query(a[3][1 ^ b[3]], a[1][1 ^ b[1]], a[2][1 ^ b[2]], a[0][1 ^ b[0]]) !=
1)
pd = false;
if (a[0][b[0]] >= a[1][1 ^ b[1]] && a[2][b[2]] >= a[3][1 ^ b[3]])
pd = false;
if (pd) {
ans[0] = a[3][b[3]];
ans[1] = a[1][b[1]];
ans[2] = a[2][b[2]];
ans[3] = a[0][b[0]];
ans[0 + 4] = a[3][1 ^ b[3]];
ans[1 + 4] = a[1][1 ^ b[1]];
ans[2 + 4] = a[2][1 ^ b[2]];
ans[3 + 4] = a[0][1 ^ b[0]];
break;
}
}
putchar('!');
for (int i = 0; i < 8; i++) printf(" %d", ans[i]);
puts("");
fflush(stdout);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b;
cin >> k >> a >> b;
string s;
cin >> s;
long long n = s.size();
if (n >= k * a && n <= k * b) {
long long j = 0, p, l = n - (k * a);
for (int i = 0; i < k; i++) {
p = min(b, a + l);
l -= min(b, a + l) - a;
if (l < 0) l = 0;
cout << s.substr(j, p) << endl;
j = j + p;
}
} else
cout << "No solution";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int op = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') op = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
x *= op;
}
inline void swap(int &x, int &y) { x ^= y ^= x ^= y; }
inline int min(int x, int y) { return x < y ? x : y; }
inline int max(int x, int y) { return x > y ? x : y; }
const int Mod = 998244353;
int Pls(int x, int y) {
x += y;
return x >= Mod ? x - Mod : x;
}
const int MN = 300000 + 10;
int N, M, K;
vector<int> pre[MN], nxt[MN];
bool fob[MN], vis[MN];
int cnt[MN];
vector<pair<int, int> > len;
int dp[MN];
void Adde(int x, int y) {
pre[y].push_back(x);
nxt[x].push_back(y);
}
void DFS(int x) {
if (fob[x]) return;
fob[x] = 1;
for (int y : pre[x]) DFS(y);
for (int y : nxt[x]) DFS(y);
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 1; i <= N; ++i) {
int c;
scanf("%d", &c);
vector<int> A(c);
for (int &x : A) scanf("%d", &x);
for (int j = 1; j < c; ++j) Adde(A[j - 1], A[j]);
}
for (int i = 1; i <= K; ++i) {
sort((pre[i]).begin(), (pre[i]).end());
pre[i].erase(unique((pre[i]).begin(), (pre[i]).end()), pre[i].end());
sort((nxt[i]).begin(), (nxt[i]).end());
nxt[i].erase(unique((nxt[i]).begin(), (nxt[i]).end()), nxt[i].end());
if ((int)(pre[i]).size() > 1 || (int)(nxt[i]).size() > 1) DFS(i);
}
for (int i = 1; i <= K; ++i)
if (!fob[i] && !(int)(pre[i]).size()) {
int l = 0, x = i;
while (1) {
if (vis[x]) {
DFS(x);
break;
}
vis[x] = 1;
l++;
if ((int)(nxt[x]).size())
x = nxt[x][0];
else
break;
}
cnt[l]++;
}
for (int i = 1; i <= K; ++i)
if (cnt[i]) len.push_back(make_pair(i, cnt[i]));
dp[0] = 1;
for (int i = 1; i <= M; ++i)
for (pair<int, int> j : len)
if (j.first <= i)
dp[i] = Pls(dp[i], 1ll * dp[i - j.first] * j.second % Mod);
printf("%d\n", dp[M]);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int n, hi[51], vi[51], h, v;
int main() {
cin >> n, n *= n;
for (int i = 1; i <= n; i++) {
cin >> h >> v;
if (!hi[h] && !vi[v]) hi[h]++, vi[v]++, cout << i << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
vector<vector<int>> sum(n, vector<int>(m));
sum[0][0] = (s[0][0] == 'X');
for (int j = 1; j < m; ++j) {
sum[0][j] = sum[0][j - 1] + (s[0][j] == 'X');
}
for (int i = 1; i < n; ++i) {
sum[i][0] = sum[i - 1][0] + (s[i][0] == 'X');
}
for (int i = 1; i < n; ++i) {
for (int j = 1; j < m; ++j) {
sum[i][j] =
sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + (s[i][j] == 'X');
}
}
auto calc = [&](int i1, int j1, int i2, int j2) {
int ret = sum[i2][j2];
if (i1 > 0) {
ret -= sum[i1 - 1][j2];
}
if (j1 > 0) {
ret -= sum[i2][j1 - 1];
}
if (i1 > 0 && j1 > 0) {
ret += sum[i1 - 1][j1 - 1];
}
return ret;
};
int low = 0;
int high = 1e6 + 7;
while (low + 1 < high) {
int mid = (low + high) >> 1;
vector<vector<int>> d(n, vector<int>(m, -1));
queue<pair<int, int>> q;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int le = j - mid;
if (le < 0) continue;
int ri = j + mid;
if (ri >= m) continue;
int up = i - mid;
if (up < 0) continue;
int dn = i + mid;
if (dn >= n) continue;
if (calc(up, le, dn, ri) == (ri - le + 1) * 1ll * (dn - up + 1)) {
q.emplace(i, j);
d[i][j] = 0;
}
}
}
while (!q.empty()) {
auto [i, j] = q.front();
q.pop();
for (int di = -1; di <= 1; ++di) {
for (int dj = -1; dj <= 1; ++dj) {
int ni = i + di;
int nj = j + dj;
if (0 <= ni && ni < n && 0 <= nj && nj < m && d[ni][nj] == -1) {
d[ni][nj] = d[i][j] + 1;
q.emplace(ni, nj);
}
}
}
}
bool ok = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (s[i][j] == 'X') {
ok &= (d[i][j] <= mid && d[i][j] != -1);
} else {
ok &= (d[i][j] > mid || d[i][j] == -1);
}
}
}
ok ? low = mid : high = mid;
}
cout << low << '\n';
vector<vector<char>> ret(n, vector<char>(m, '.'));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int le = j - low;
if (le < 0) continue;
int ri = j + low;
if (ri >= m) continue;
int up = i - low;
if (up < 0) continue;
int dn = i + low;
if (dn >= n) continue;
if (calc(up, le, dn, ri) == (ri - le + 1) * 1ll * (dn - up + 1)) {
ret[i][j] = 'X';
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << ret[i][j];
}
cout << '\n';
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ss = stringstream;
using ul = unsigned long long;
template <typename T>
inline T LCM(T a, T b) {
return (a * b) / GCD(a, b);
}
template <typename T>
inline T GCD(T a, T b) {
ll t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T>
inline T _max(T a, T b, T c) {
return max(max(a, b), c);
}
template <typename T>
inline T _min(T a, T b, T c) {
return min(min(a, b), c);
}
template <typename T>
inline string toString(T a) {
return to_string(a);
}
template <typename T>
inline void toInt(string s, T &x) {
ss str(s);
str >> x;
}
inline void lower(string &s) {
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); ++it)
*it = tolower(*it);
}
inline void upper(string &s) {
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); ++it)
*it = toupper(*it);
}
const ll inf = 999999999999999999;
bool check(string s) {
string s1 = s;
reverse(s.begin(), s.end());
return (s == s1);
}
ll func(ll n) { return (n * (n + 1)) / 2; }
const int M = 1e9 + 7;
int dp[10005][105];
int v2, t, d;
int func(int v1, int s) {
if (v1 < 0 or s + 1 > t) {
return -1e9 + 500;
}
if (t == s + 1) {
if (v1 == v2) {
return v2;
}
return -1e9 + 500;
}
if (dp[v1][s] != -1e9 + 1) {
return dp[v1][s];
}
for (int i = -d; i <= d; i++) {
dp[v1][s] = max(dp[v1][s], v1 + func(v1 + i, s + 1));
}
return dp[v1][s];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int v1;
cin >> v1 >> v2 >> t >> d;
for (int i = 0; i < 10001; i++) {
for (int j = 0; j <= 100; j++) {
dp[i][j] = -1e9 + 1;
}
}
cout << func(v1, 0);
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[500010];
vector<int> bfstree[500010];
vector<int> st, ed;
int p[500010];
char used[500010];
char oncycle[500010];
vector<vector<int>> cycles;
int cyclenum[500010];
int l[500010], z[500010];
int an[500010];
multiset<int> ms[500010];
int fi[500010];
vector<pair<int, int>> er;
vector<int> drop[500010];
void dfs1(int v, int par) {
used[v] = 1;
for (int to : g[v]) {
if (!used[to]) {
p[to] = v;
dfs1(to, v);
} else if (to != par && used[to] == 1) {
ed.push_back(v);
st.push_back(to);
}
}
used[v] = 2;
}
void dfs2(int v, int par, int di) {
if (cyclenum[v] >= 0 && fi[cyclenum[v]] == 0) {
fi[cyclenum[v]] = v;
}
for (int to : bfstree[v]) {
if (to != par) {
dfs2(to, v, di + 1);
ms[v].insert(l[to] + 1);
if (cyclenum[to] != -1 && cyclenum[v] == cyclenum[to])
er.push_back({v, to});
}
}
if (!ms[v].empty()) l[v] = *ms[v].rbegin();
an[v] = l[v];
}
void calc_z(vector<int> &a) {
set<pair<int, int>> q;
int k = a.size();
for (int t = 0; t < 2; t++) {
for (int i = 0; i < 2 * k; i++) {
while (!q.empty()) {
auto v = *q.rbegin();
if (i - v.second > k / 2)
q.erase(*q.rbegin());
else
break;
}
if (!q.empty()) {
auto v = *q.rbegin();
int value = v.first + v.second;
value += i - v.second;
z[a[i % k]] = max(z[a[i % k]], value);
}
q.insert({l[a[i % k]] - i, i});
}
q.clear();
reverse(a.begin(), a.end());
}
for (auto u : a) an[u] = max(an[u], max(l[u], z[u]));
}
void dfs_go(int v) {
used[v] = true;
for (int to : g[v]) {
if (!used[to]) {
if (oncycle[to]) {
if (oncycle[v] && cyclenum[v] == cyclenum[to])
dfs_go(to);
else {
int old = l[to];
bool ok = false;
if (ms[v].find(old + 1) != ms[v].end())
ms[v].erase(ms[v].find(old + 1)), ok = true;
int val = z[v];
if (!ms[v].empty()) val = max(val, *ms[v].rbegin());
ms[to].insert(val + 1);
for (auto dr : drop[to]) {
if (ms[to].find(dr) != ms[to].end()) ms[to].erase(ms[to].find(dr));
}
l[to] = *ms[to].rbegin();
calc_z(cycles[cyclenum[to]]);
for (auto dr : drop[to]) {
ms[to].insert(dr);
}
l[to] = old;
dfs_go(to);
ms[to].erase(ms[to].find(val + 1));
if (ok) ms[v].insert(old + 1);
}
} else {
bool ok = false;
if (ms[v].find(l[to] + 1) != ms[v].end())
ms[v].erase(ms[v].find(l[to] + 1)), ok = true;
if (!ms[v].empty())
z[to] = max(*ms[v].rbegin(), z[v]) + 1;
else
z[to] = z[v] + 1;
an[to] = max(an[to], z[to]);
if (ok) ms[v].insert(l[to] + 1);
dfs_go(to);
}
}
}
}
void stupid() {
for (int i = 1; i <= n; i++) {
int an = 0;
int d[n + 1];
memset(d, -1, sizeof(d));
d[i] = 0;
queue<int> q;
q.push(i);
while (!q.empty()) {
int v = q.front();
q.pop();
an = max(an, d[v]);
for (int to : g[v]) {
if (d[to] == -1) {
d[to] = d[v] + 1;
q.push(to);
}
}
}
cout << an << ' ';
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int from, to;
cin >> from >> to;
g[from].push_back(to);
g[to].push_back(from);
}
dfs1(1, 1);
for (int i = 0; i < (int)ed.size(); i++) {
int u = ed[i];
cycles.push_back(vector<int>());
for (int v = u; v != st[i]; v = p[v]) cycles.back().push_back(v);
cycles.back().push_back(st[i]);
}
if (cycles.empty()) {
cycles.push_back(vector<int>(1, 1));
}
memset(cyclenum, -1, sizeof(cyclenum));
for (int i = 0; i < (int)cycles.size(); i++) {
for (auto u : cycles[i]) {
oncycle[u] = true;
cyclenum[u] = i;
}
}
memset(used, 0, sizeof(used));
queue<int> q;
for (auto u : cycles[0]) {
q.push(u);
used[u] = true;
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int to : g[v]) {
if (!used[to]) {
q.push(to);
bfstree[v].push_back(to);
bfstree[to].push_back(v);
used[to] = true;
}
}
}
memset(used, 0, sizeof(used));
for (auto u : cycles[0]) {
dfs2(u, u, 0);
}
reverse(er.begin(), er.end());
for (auto p : er) {
int v = p.first;
int to = p.second;
if (fi[cyclenum[v]] == v) {
drop[v].push_back(l[to] + 1);
continue;
}
ms[v].erase(ms[v].find(l[to] + 1));
if (!ms[v].empty())
l[v] = *ms[v].rbegin();
else
l[v] = 0;
an[v] = l[v];
}
calc_z(cycles[0]);
memset(used, 0, sizeof(used));
dfs_go(cycles[0][0]);
for (int i = 1; i <= n; i++) {
cout << an[i] << ' ';
}
cout << endl;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0, b = getchar(), c = 1;
while (!isdigit(b)) c = b == '-' ? -1 : 1, b = getchar();
while (isdigit(b)) a = a * 10 + b - '0', b = getchar();
return a * c;
}
long long d, k, a, b, t, x, y, z, ans;
int main() {
d = read(), k = read(), a = read(), b = read(), t = read();
x = d * a, y = d - k, z = k * a;
if (d <= k)
ans = x;
else
ans = z + y / k * min(z + t, k * b) + min(y % k * a + t, y % k * b);
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int b[100010];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
}
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
int ans = 0;
for (int i = 1; i <= n; ++i) {
int left = 1;
int right = m;
while (left < right) {
int mid = (left + right) >> 1;
if (a[i] < b[mid]) {
right = mid;
} else {
left = mid + 1;
}
}
int test = abs(b[left] - a[i]);
if (left + 1 <= m) {
test = min(test, abs(b[left + 1] - a[i]));
}
if (left - 1 >= 1) {
test = min(test, abs(b[left - 1] - a[i]));
}
ans = max(ans, test);
}
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
int now, n, a[200005];
char str[200005];
char Rev(char c) {
if (c == 'L')
return 'R';
else
return 'L';
}
int b[200005];
char op[200005];
signed main() {
n = read();
for (register int i = (1); i <= (n); ++i) a[i] = read();
sort(a + 1, a + n + 1);
cin >> str + 1;
int l = 1, r = n;
bool rev = 1;
for (register int i = (n); i >= (1); --i) {
if (i == 1) {
b[i] = a[l];
op[i] = str[i];
break;
}
if ((str[i] != str[i - 1]) != (rev)) rev ^= 1;
if (rev)
b[i] = a[r], op[i] = ((n - r + 1) % 2 ? str[n] : Rev(str[n])), --r;
else
b[i] = a[l], op[i] = ((n - l + 1) % 2 ? str[n] : Rev(str[n])), ++l;
}
for (register int i = (1); i <= (n); ++i)
cout << b[i] << ' ' << op[i] << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, m, n, x, y, ans, cnt, d;
while (scanf("%I64d%I64d%I64d%I64d", &n, &x, &m, &y) != EOF) {
if (x > y) {
swap(x, y);
swap(n, m);
}
if (x == y) {
printf("%d\n", max(n, m) + 1);
} else {
ans = 1;
if (x + n < y + m) ans += min((y + m) - (x + n), m);
if (x - n < y - m) ans += min((y - m) - (x - n), n);
for (i = 1; i <= n; i++)
if (y >= x + i) {
d = min(i + x - (y - m), 2 * i);
if (d > 0) ans += 2 * d - 1;
if (d == 2 * i) ans--;
} else {
k = (i + x - 1) - y;
d = min(m - k, y - k - (x - i));
if (d > 0) ans += 2 * d - 1;
if (d == y - k - (x - i)) ans--;
}
printf("%I64d\n", ans);
}
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int maxn = 1e5 + 5;
int n;
int a[maxn];
long long ans;
vector<pair<int, int> > vec;
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", a + i);
if (n == 1) {
if (!(a[0] & 1) || (!a[0]))
puts("cslnb");
else
puts("sjfnb");
return 0;
}
sort(a, a + n);
int same = 0;
for (int i = (0); i < (n - 1); ++i)
if (a[i] == a[i + 1]) ++same;
long long res = 0, emp = 0;
if (same > 1) {
puts("cslnb");
return 0;
} else if (same == 1) {
for (int i = (0); i < (n - 1); ++i)
if (a[i] == a[i + 1]) {
if ((i && a[i] - 1 == a[i - 1]) || a[i] - 1 < 0) {
puts("cslnb");
return 0;
} else
--a[i], ++res;
}
}
for (int i = 0, j = 0; i < n;) {
for (; j < n && a[j] == a[i] + j - i; ++j)
;
vec.push_back(make_pair(a[i], a[j - 1]));
i = j;
}
for (int i = (0); i < (vec.size()); ++i) {
if (!i) {
emp += vec[i].first - 0;
res += (vec[i].second - vec[i].first + 1) * emp;
} else {
emp += vec[i].first - vec[i - 1].second - 1;
res += (vec[i].second - vec[i].first + 1) * emp;
}
}
if (res & 1)
puts("sjfnb");
else
puts("cslnb");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, p, v[50100], ans = 1e15, minn;
long long b[200100], bb[200100];
long long check(long long dis) {
memset(v, 0, sizeof(v));
for (int i = 1, jj = 1; i <= n; i++) {
if (abs(bb[jj] - p) + abs(b[i] - bb[jj]) <= dis && jj <= m) {
v[i] = 1;
jj++;
continue;
}
while (jj <= m - 1) {
jj++;
if (abs(bb[jj] - p) + abs(b[i] - bb[jj]) <= dis) {
v[i] = 1;
jj++;
break;
}
}
}
for (int i = 1; i <= n; i++)
if (!v[i]) return 0;
return 1;
}
int main() {
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= m; i++) cin >> bb[i];
sort(bb + 1, bb + m + 1);
sort(b + 1, b + n + 1);
long long l = 0, r = 2e9 + 5000;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int g[100][100];
int n;
int l1, r1, l2, r2;
long long t[52][52];
long long t1[52][52];
bool better(const pair<int, int>& a, const pair<int, int>& b) {
if (a.first != b.first) return a.first < b.first;
return a.second < b.second;
}
long long solve(int w, int l) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) t[i][j] = 0;
t[0][0] = 1;
for (int i = 0; i < n; i++) {
bool cg =
((i != l) && better(make_pair(g[i][0], i), make_pair(g[w][0], w))) ||
(i == w);
bool cs = (i != w) && (i != l);
if (cs) {
cs = false;
for (int j = 0; j < n - 1 && !cs; j++)
if (better(make_pair(g[w][0], w), make_pair(g[i][j], i)) &&
better(make_pair(g[i][j], i), make_pair(g[l][n - 2], l)))
cs = true;
}
bool cl = (i != w &&
better(make_pair(g[l][n - 2], l), make_pair(g[i][n - 2], i))) ||
(i == l);
for (int g = 0; g <= r1; g++)
for (int s = 0; s <= r2; s++) t1[g][s] = 0;
for (int g = 0; g <= r1; g++)
for (int s = 0; s <= r2; s++) {
if (cg) t1[g + 1][s] += t[g][s];
if (cs) t1[g][s + 1] += t[g][s];
if (cl) t1[g][s] += t[g][s];
}
for (int g = 0; g <= r1; g++)
for (int s = 0; s <= r2; s++) t[g][s] = t1[g][s];
}
long long ans = 0;
for (int i = l1; i <= r1; i++)
for (int j = l2; j <= r2; j++) ans += t[i][j];
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[i][j] = (1 << 29) * (i != j);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a, --b;
g[a][b] = min(g[a][b], c);
g[b][a] = g[a][b];
}
scanf("%d %d %d %d", &l1, &r1, &l2, &r2);
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
for (int i = 0; i < n; i++) {
swap(g[i][i], g[i][n - 1]);
sort(g[i], g[i] + n - 1);
}
long long ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j) ans += solve(i, j);
cout << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline void cpuTime() {
cerr << "cpu time : " << double(clock()) / CLOCKS_PER_SEC << "\n";
return;
}
using ll = long long;
using ull = unsigned long long;
using F = float;
using D = double;
using vi = vector<int>;
using pii = pair<int, int>;
void solve() {
int n = 0, s = 0, t = 0;
cin >> n >> s >> t;
if (n <= s && n <= t) {
cout << "1\n";
return;
}
cout << n - min(s, t) + 1 << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
cin >> t;
while (t--) {
solve();
}
cpuTime();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dfs(int x, const vector<vector<int> > &g, vector<char> &used,
vector<vector<int> > &ans) {
used[x] = 1;
vector<pair<int, int> > from;
vector<int> sons, kill;
for (int dest : g[x])
if (!used[dest]) {
sons.push_back(dest);
int cur = dfs(dest, g, used, ans);
if (cur != -1) {
ans.push_back(vector<int>{cur, dest, x});
kill.push_back(dest);
}
}
sort((sons).begin(), (sons).end());
sort((kill).begin(), (kill).end());
int last = -1;
for (int dest : g[x]) {
assert(used[dest]);
if (used[dest] != 2) continue;
if (binary_search((kill).begin(), (kill).end(), dest)) continue;
if (last == -1)
last = dest;
else
ans.push_back({last, x, dest}), last = -1;
}
used[x] = 2;
return last;
}
void solve(int n) {
int m;
cin >> m;
vector<vector<int> > g(n);
for (int i = 0; i < (int)(m); ++i) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
vector<vector<int> > ans;
vector<char> used(n);
for (int i = 0; i < (int)(n); ++i)
if (!used[i]) dfs(i, g, used, ans);
cout << (int)(ans).size() << "\n";
for (int i = 0; i < (int)((int)(ans).size()); ++i) {
assert((int)(ans[i]).size() == 3);
for (int j = 0; j < (int)(3); ++j) cout << ans[i][j] + 1 << " \n"[j == 2];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
while (cin >> n) solve(n);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
const double error = 1e-7;
const double PI = acos(-1);
mt19937 rng(
(unsigned int)chrono::system_clock::now().time_since_epoch().count());
inline long long int MOD(long long int x, long long int m = mod) {
if (x < m) return x;
return x % m;
}
const int inf = 1e9;
const long long int infl = 1e18 + 1;
const int nmax = 1e5 + 5;
vector<int> adj[nmax];
const int lg_max = 18;
int depth[nmax];
int parent[nmax][lg_max];
void dfs(int root, int par) {
depth[root] = depth[par] + 1;
parent[root][0] = par;
for (int i = 1; i < lg_max; i++)
parent[root][i] = parent[parent[root][i - 1]][i - 1];
for (int x : adj[root]) dfs(x, root);
return;
}
inline int LCA(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
int lift = depth[v] - depth[u];
for (int i = 0; lift != 0; lift >>= 1, i++)
if (lift & 1) v = parent[v][i];
if (u == v) return u;
for (int i = lg_max - 1; i >= 0; i--)
if (parent[u][i] != parent[v][i]) u = parent[u][i], v = parent[v][i];
return parent[u][0];
}
struct node {
node *lc, *rc;
int sum;
node(int s = 0) {
sum = s;
lc = rc = NULL;
}
};
node *build(int l, int r) {
if (l == r) {
return new node(0);
}
node *n = new node(0);
int mid = (l + r) >> 1;
n->lc = build(l, mid);
n->rc = build(mid + 1, r);
return n;
}
node *update(node *n, int l, int r, int k) {
if (r < k || k < l) return n;
if (l == r) return new node(n->sum + 1);
node *t = new node(0);
int mid = (l + r) >> 1;
t->lc = update(n->lc, l, mid, k);
t->rc = update(n->rc, mid + 1, r, k);
t->sum = t->lc->sum + t->rc->sum;
return t;
}
int query(node *n, int l, int r, int L, int R) {
if (r < L || R < l) return 0;
if (L <= l && r <= R) return n->sum;
int mid = (l + r) >> 1;
int p = query(n->lc, l, mid, L, R);
int q = query(n->rc, mid + 1, r, L, R);
return p + q;
}
void print(node *n, int l, int r) {
cout << l << " " << r << " : ";
cout << n->sum << "\n";
if (l == r) {
return;
}
int mid = (l + r) >> 1;
print(n->lc, l, mid);
print(n->rc, mid + 1, r);
}
node *roots[nmax];
struct queryS {
int a, b, k, y1, y2;
};
int destroyed[nmax];
vector<queryS> queries;
int q;
int cnt(int u, int a, int b) { return depth[u] - query(roots[u], 1, q, a, b); }
void treedfs(int root) {
roots[root] = update(roots[parent[root][0]], 1, q, destroyed[root]);
for (int x : adj[root]) treedfs(x);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
int root;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x == 0)
root = i;
else
adj[x].push_back(i);
}
dfs(root, 0);
cin >> q;
for (int i = 1; i <= n; i++) destroyed[i] = q + 1;
for (int i = 1; i <= q; i++) {
int t;
cin >> t;
if (t == 1) {
int u;
cin >> u;
destroyed[u] = i;
} else {
int a, b, k, y;
cin >> a >> b >> k >> y;
queries.push_back({a, b, k, y + 1, i});
}
}
roots[0] = build(1, q);
treedfs(root);
for (auto Q : queries) {
int c = LCA(Q.a, Q.b);
int y1 = Q.y1, y2 = Q.y2;
if (destroyed[Q.a] < y1 || destroyed[Q.a] > y2) Q.k++;
int pc = cnt(c, y1, y2);
int pa = cnt(Q.a, y1, y2);
int pb = cnt(Q.b, y1, y2);
int extra = (destroyed[c] >= y1 && destroyed[c] <= y2) ? 0 : 1;
if (pa - pc < Q.k) {
Q.k -= pa - pc;
if (pb - pc + extra < Q.k) {
cout << -1 << "\n";
continue;
}
int u = Q.b;
for (int i = lg_max - 1; i >= 0; i--) {
if (cnt(parent[u][i], y1, y2) - pc + extra >= Q.k) u = parent[u][i];
}
if (u == Q.b) {
cout << -1 << "\n";
continue;
}
cout << u << "\n";
} else {
int u = Q.a;
for (int i = lg_max - 1; i >= 0; i--) {
int extra =
(destroyed[parent[u][i]] < y1 || destroyed[parent[u][i]] > y2) ? 1
: 0;
if (parent[u][i] == 0) extra = 0;
if (pa - cnt(parent[u][i], y1, y2) + extra < Q.k) u = parent[u][i];
}
u = parent[u][0];
cout << u << "\n";
}
}
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
map<int, int> mp;
vector<int> V[MAXN];
int cnt, tel;
struct node {
int x;
int id;
} a[MAXN];
int get_id(int x) {
if (mp.find(x) != mp.end()) return mp[x];
return mp[x] = cnt++;
}
int main() {
ios::sync_with_stdio(false);
int n, flag, tel;
cin >> n;
cnt = 1;
for (int i = 1; i <= n; i++) {
cin >> a[i].x;
a[i].id = get_id(a[i].x);
}
for (int i = 1; i <= n; i++) V[a[i].id].push_back(i);
tel = 0;
for (int i = 2; i <= n; i++) {
for (int r = 0; r < V[a[i].id].size(); r++) {
flag = 0;
int j = V[a[i].id][r];
if (!(j >= 1 && j < i && (i - j) <= (n - i + 1))) continue;
if (j < tel) continue;
flag = 1;
for (int k = 0; k < i - j; k++) {
if (a[j + k].x != a[i + k].x) {
flag = 0;
break;
}
}
if (flag == 1) break;
}
if (flag == 1) tel = i;
}
if (tel == 0) {
cout << n << endl;
for (int i = 1; i <= n; i++)
i == 1 ? cout << a[i].x : cout << " " << a[i].x;
cout << endl;
return 0;
}
cout << n - tel + 1 << endl;
for (int i = tel; i <= n; i++)
i == tel ? cout << a[i].x : cout << " " << a[i].x;
cout << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> b, a;
int main() {
long long p, k;
scanf("%lld %lld", &p, &k);
for (long long pre = p; pre;) {
long long now = (k - pre) / k;
if (now * k >= k - pre) --now;
b.push_back(pre = now);
}
a.push_back(p);
for (int i = 0; i < b.size(); ++i) {
if ((a[i] += b[i] * k) >= k) {
printf("-1\n");
return 0;
}
a.push_back(b[i]);
}
while (!a.back()) a.pop_back();
printf("%d\n", a.size());
for (int i = 0; i < a.size(); ++i) {
printf("%lld", a[i]);
if (i < a.size() - 1)
printf(" ");
else
printf("\n");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x);
template <typename T>
void write(T x);
template <typename T>
void writesp(T x);
template <typename T>
void writeln(T x);
const long long N = 37, M = 1ull << 19;
long long n, m;
long long num[N];
long long lsh[2][M], h[2];
inline void dfs(long long now, long long end, long long tmp) {
if (now == end + 1) {
if (end != n) {
lsh[0][++h[0]] = tmp;
} else {
lsh[1][++h[1]] = tmp;
}
return;
}
dfs(now + 1, end, tmp);
dfs(now + 1, end, (tmp + num[now]) % m);
}
long long ans;
int main() {
read(n);
read(m);
for (register long long i = 1; i <= n; i++) read(num[i]);
dfs(1, n / 2, 0);
dfs(n / 2 + 1, n, 0);
sort(lsh[0] + 1, lsh[0] + h[0] + 1);
sort(lsh[1] + 1, lsh[1] + h[1] + 1);
for (register long long i = 1; i <= h[0]; i++) {
long long pos1 =
lower_bound(lsh[1] + 1, lsh[1] + h[1] + 1, m - lsh[0][i]) - lsh[1] - 1;
ans = max(ans, (lsh[0][i] + lsh[1][pos1]) % m);
ans = max(ans, (lsh[0][i] + lsh[1][h[1]]) % m);
}
writeln(ans % m);
}
template <typename T>
void read(T &x) {
char wn = getchar();
long long t = 1;
x = 0;
while (wn < '0' || wn > '9') {
if (wn == '-') t = -1;
wn = getchar();
}
while (wn >= '0' && wn <= '9') {
x = x * 10 + wn - '0';
wn = getchar();
}
x *= t;
}
template <typename T>
void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x <= 9) {
putchar(x + '0');
return;
}
write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
putchar('\n');
}
template <typename T>
void writesp(T x) {
write(x);
putchar(' ');
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int block_size = 360;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
long long p, k;
long long fast(long long a, long long b, long long mod) {
long long ans = 1;
while (b > 0) {
if (b % 2 == 0) {
b /= 2;
a = a * a % mod;
} else {
b--;
ans = ans * a % mod;
}
}
return ans;
}
vector<int> test;
void read() { cin >> p >> k; }
void get_factors() {
for (long long i = 1; i * i <= p - 1; i++) {
if ((p - 1) % i == 0) {
test.push_back(i);
test.push_back((p - 1) / i);
}
}
sort(begin(test), end(test));
}
long long get_order() {
for (long long i = 0; i < test.size(); i++) {
if (fast(k, test[i], p) == 1) {
return test[i];
}
}
return -1;
}
void solve() {
read();
if (k == 1) {
cout << fast(p, p, mod) << endl;
return;
}
get_factors();
if (k == 0) {
cout << fast(p, p - 1, mod) << endl;
} else {
long long index = get_order();
cout << fast(p, (p - 1) / index, mod);
}
}
int main() {
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, r, k, x, a[50000];
int main() {
cin >> m >> n;
for (int i = 1; i <= n; i++) {
cout << i << endl;
cin >> a[i];
if (a[i] == 0) {
return 0;
}
}
l = n + 1;
r = m;
k = 0;
while (l <= r) {
k++;
long long mid = (l + r) / 2;
cout << mid << endl;
cin >> x;
if (x == 0) {
return 0;
}
if (x == a[k]) {
l = mid + 1;
} else {
r = mid - 1;
}
k %= n;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, x, y, q, tp, v, Ans, j;
vector<int> g[1400005];
bitset<1000> t[1400005];
int tag[1400005];
int ps[1400005];
int sz[1400005];
bitset<1000> X;
int a[1400005];
int ord[1400005];
bool vis[1400005];
int P[2222];
void dfs(int x, int p) {
ord[++q] = x;
ps[x] = q, sz[x] = 1;
for (int i = 0; i < g[x].size(); i++) {
if (g[x][i] == p) continue;
dfs(g[x][i], x);
sz[x] += sz[g[x][i]];
}
}
void Build(int x, int l, int r) {
if (l == r)
t[x].set(a[ord[l]] % m);
else {
int mid = (l + r) >> 1;
Build(x + x, l, mid);
Build(x + x + 1, mid + 1, r);
t[x] = t[x + x] | t[x + x + 1];
}
}
void Rot(int x, int sq) { t[x] = (t[x] << sq) | (t[x] >> (m - sq)); }
void Push(int x) {
tag[x] %= m;
if (tag[x] != 0) {
Rot(x + x, tag[x]);
Rot(x + x + 1, tag[x]);
tag[x + x] += tag[x];
tag[x + x + 1] += tag[x];
tag[x] = 0;
}
}
void Rotate(int x, int l, int r, int ll, int rr, int shi) {
Push(x), Push(x + x), Push(x + x + 1);
if (l == ll && r == rr) {
Rot(x, shi);
tag[x] += shi;
tag[x] %= m;
Push(x), Push(x + x), Push(x + x + 1);
} else {
Push(x), Push(x + x), Push(x + x + 1);
int mid = (l + r) >> 1;
if (rr <= mid)
Rotate(x + x, l, mid, ll, rr, shi);
else if (ll > mid)
Rotate(x + x + 1, mid + 1, r, ll, rr, shi);
else {
Rotate(x + x, l, mid, ll, mid, shi);
Rotate(x + x + 1, mid + 1, r, mid + 1, rr, shi);
}
Push(x), Push(x + x), Push(x + x + 1);
t[x] = t[x + x] | t[x + x + 1];
Push(x), Push(x + x), Push(x + x + 1);
}
Push(x), Push(x + x), Push(x + x + 1);
}
bitset<1000> Query(int x, int l, int r, int ll, int rr) {
Push(x), Push(x + x), Push(x + x + 1);
if (l == ll && r == rr)
return t[x];
else {
Push(x), Push(x + x), Push(x + x + 1);
int mid = (l + r) >> 1;
if (rr <= mid)
return Query(x + x, l, mid, ll, rr);
else if (ll > mid)
return Query(x + x + 1, mid + 1, r, ll, rr);
else {
bitset<1000> A = Query(x + x, l, mid, ll, mid);
bitset<1000> B = Query(x + x + 1, mid + 1, r, mid + 1, rr);
return A | B;
}
}
Push(x), Push(x + x), Push(x + x + 1);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 2; i < m; i++)
if (!vis[i]) {
P[++P[0]] = i;
for (int j = 2 * i; j < m; j += i) vis[j] = 1;
}
dfs(1, -1);
Build(1, 1, n);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &tp);
if (tp == 1) {
scanf("%d%d", &v, &x);
Rotate(1, 1, n, ps[v], ps[v] + sz[v] - 1, x % m);
} else {
scanf("%d", &v);
Ans = 0;
bitset<1000> A = Query(1, 1, n, ps[v], ps[v] + sz[v] - 1);
for (int j = 1; j <= P[0]; j++) Ans += A.test(P[j]);
printf("%d\n", Ans);
}
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, e;
string s;
int main() {
cin >> a >> s;
for (long long int i = 0; i < a; i++) {
if ((s[i] - '0') % 2 == 0) {
b += i + 1;
}
}
cout << b << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int l, r;
cin >> l >> r;
cout << "YES" << endl;
for (long long int i = l; i <= r; i += 2) {
cout << i << " " << i + 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, h1, h2, a1, a2, x1, y1, x2, y2;
cin >> m >> h1 >> a1 >> x1 >> y1 >> h2 >> a2 >> x2 >> y2;
long long res1, res2, rep1, rep2, count = 0;
res1 = res2 = rep1 = rep2 = -1;
for (int i = 1; i <= 2 * m; i++) {
h1 = (x1 * h1 + y1) % m;
if (h1 == a1) {
if (res1 == -1)
res1 = i;
else if (rep1 == -1)
rep1 = i - res1;
}
h2 = (x2 * h2 + y2) % m;
if (h2 == a2) {
if (res2 == -1)
res2 = i;
else if (rep2 == -1)
rep2 = i - res2;
}
}
if (res1 == -1 or res2 == -1) {
cout << "-1" << endl;
return 0;
}
if (res1 == res2) {
cout << res1 << endl;
return 0;
} else {
while (count < 2000000) {
count++;
if (res1 < res2) {
if (rep1 == -1) {
cout << "-1" << endl;
return 0;
} else
res1 = res1 + rep1;
} else {
if (rep2 == -1) {
cout << "-1" << endl;
return 0;
} else
res2 = res2 + rep2;
}
if (res1 == res2) {
cout << res1 << endl;
return 0;
}
}
cout << "-1" << endl;
return 0;
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
const long long INF = 2 * 1e18;
const long double PI = 3.14159265358979323846;
int main() {
long long n, cnt = 0, t = 0;
bool x = 0;
string s;
cin >> n >> s;
if (n % 2) {
cout << ":(";
return 0;
}
for (long long i = 0; i < n; i++) {
if (s[i] == '(')
cnt++;
else if (s[i] == ')')
cnt--;
else
t++;
}
long long b = (t - cnt) / 2 + cnt, a = (t - cnt) / 2;
if (a < 0 || b < 0) {
cout << ":(";
return 0;
}
for (long long i = 0; i < n; i++) {
if (s[i] == '?') {
if (a > 0) {
a--;
s[i] = '(';
} else {
b--;
s[i] = ')';
}
}
}
cnt = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == '(')
cnt++;
else {
cnt--;
if (i != n - 1) {
if (cnt <= 0) x = 1;
} else {
if (cnt < 0) x = 1;
}
}
}
if (x)
cout << ":(";
else
cout << s;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[101000], n;
int w[101000 / 50 + 1][60];
void calc(int i) {
int t;
for (t = 0; t < 60; t++) {
int b = i * 50;
int e = b + 50;
int v = t;
for (int j = b; j < e; v++) {
if (v % a[j]) j++;
}
w[i][t] = v - t;
}
}
int main() {
int n, i, j, q;
scanf("%d", &n);
for (i = 0; i < n; scanf("%d", &a[i]), i++)
;
for (; i < n + 50; a[i] = 2, i++)
;
for (i = 0; i * 50 < n; calc(i), i++)
;
scanf("%d", &q);
for (; q--;) {
char e[3];
scanf("%s", e);
if (e[0] == 'A') {
scanf("%d%d", &i, &j);
i--;
j--;
int t = 0;
for (; i < j && i % 50; t++) {
if (t % a[i]) i++;
}
if (i < j) {
for (; i + 50 <= j; i += 50) {
t += w[i / 50][t % 60];
}
for (; i < j; t++) {
if (t % a[i]) i++;
}
}
printf("%d\n", t);
} else {
scanf("%d%d", &i, &j);
i--;
a[i] = j;
calc(i / 50);
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int dsu[2001];
int size[2001];
void assign(int n) {
for (int i = 0; i <= n; i++) {
dsu[i] = i;
size[i] = 1;
}
}
int find(int i) {
while (i != dsu[i]) {
dsu[i] = dsu[dsu[i]];
i = dsu[i];
}
return i;
}
void unionn(int x, int y) {
int xx = find(x);
int yy = find(y);
if (size[xx] <= size[yy]) {
size[yy] += size[xx];
dsu[xx] = yy;
} else {
size[xx] += size[yy];
dsu[yy] = xx;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
assign(n);
int k;
cin >> k;
int x, y;
for (int i = 0; i < int(k); i++) {
cin >> x >> y;
unionn(x, y);
}
int m;
cin >> m;
for (int i = 0; i < int(m); i++) {
cin >> x >> y;
if (find(x) == find(y)) {
unionn(0, x);
}
}
int NOO = find(0);
map<int, int> count;
for (int i = 0; i < int(n + 1); i++) {
if (find(i) != NOO) {
count[find(i)]++;
}
}
int MAX = 0;
for (auto it : count) {
if (it.second > MAX) MAX = it.second;
}
cout << MAX << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long f1 = 2, f2 = 3;
long long ans = 2;
if (n == 2) {
cout << 1 << endl;
return 0;
}
long long x;
while (f2 <= n) {
ans++;
x = f2;
f2 += f1;
f1 = x;
}
cout << ans - 1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tc;
cin >> tc;
while (tc--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a == c && b == d)
cout << b << " " << c << '\n';
else if (a == c && b != d)
cout << a << " " << d << '\n';
else if (a != c && b == d)
cout << a << " " << d << '\n';
else if (a != c && b != d)
cout << a << " " << c << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int nu = (int)3e6 + 10;
int n;
char s[nu];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
scanf("%d %s", &n, s);
int d = 0, r = 0, curd = 0, curr = 0;
for (int i = 0; i <= n - 1; i += 1) {
if (s[i] == 'D')
curd++;
else
curr++;
}
for (int i = 0; curd > 0 && curr > 0 && i < n; i++) {
if (s[i] == 'D') {
if (r > 0)
r--, curd--;
else
d++, s[n++] = 'D';
} else {
if (d > 0)
d--, curr--;
else
r++, s[n++] = 'R';
}
}
if (curd == 0)
printf("R\n");
else
printf("D\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using std::copy;
using std::fill;
using std::swap;
const int MaxN = 1 << 19;
const int mod_base = 119, mod_exp = 23;
const int mod_v = (mod_base << mod_exp) + 1;
const int primitive_root = 3;
int epsilon_num;
int eps[MaxN], inv_eps[MaxN], inv2;
int dec(int x, int v) {
x -= v;
return x < 0 ? x + mod_v : x;
}
int inc(int x, int v) {
x += v;
return x >= mod_v ? x - mod_v : x;
}
int pow(int x, int p) {
int v = 1;
for (; p; p >>= 1, x = (long long)x * x % mod_v)
if (p & 1) v = (long long)x * v % mod_v;
return v;
}
void init_eps(int num) {
epsilon_num = num;
int base = pow(primitive_root, (mod_v - 1) / num);
int inv_base = pow(base, mod_v - 2);
eps[0] = inv_eps[0] = 1;
for (int i = 1; i != num; ++i) {
eps[i] = (long long)eps[i - 1] * base % mod_v;
inv_eps[i] = (long long)inv_eps[i - 1] * inv_base % mod_v;
}
}
void transform(int n, int *x, int *w = eps) {
for (int i = 0, j = 0; i != n; ++i) {
if (i > j) swap(x[i], x[j]);
for (int l = n >> 1; (j ^= l) < l; l >>= 1)
;
}
for (int i = 2; i <= n; i <<= 1) {
int m = i >> 1, t = epsilon_num / i;
for (int j = 0; j < n; j += i) {
for (int p = 0, q = 0; p != m; ++p, q += t) {
int z = (long long)x[j + m + p] * w[q] % mod_v;
x[j + m + p] = dec(x[j + p], z);
x[j + p] = inc(x[j + p], z);
}
}
}
}
void inverse_transform(int n, int *x) {
transform(n, x, inv_eps);
int inv = pow(n, mod_v - 2);
for (int i = 0; i != n; ++i) x[i] = (long long)x[i] * inv % mod_v;
}
void polynomial_inverse(int n, int *A, int *B) {
static int T[MaxN];
if (n == 1) {
B[0] = pow(A[0], mod_v - 2);
return;
}
int half = (n + 1) >> 1;
polynomial_inverse(half, A, B);
int p = 1;
for (; p < n << 1; p <<= 1)
;
fill(B + half, B + p, 0);
transform(p, B);
copy(A, A + n, T);
fill(T + n, T + p, 0);
transform(p, T);
for (int i = 0; i != p; ++i)
B[i] = (long long)B[i] * dec(2, (long long)T[i] * B[i] % mod_v) % mod_v;
inverse_transform(p, B);
}
void polynomial_sqrt(int n, int *A, int *B) {
static int T[MaxN], Z[MaxN];
if (n == 1) {
B[0] = 1;
return;
}
int p = 1;
for (; p < n << 1; p <<= 1)
;
int half = (n + 1) >> 1;
polynomial_sqrt(half, A, B);
fill(B + half, B + n, 0);
polynomial_inverse(n, B, T);
for (int i = 0; i != n; ++i) T[i] = (long long)T[i] * inv2 % mod_v;
fill(T + n, T + p, 0);
transform(p, T);
copy(A, A + n, Z);
fill(Z + n, Z + p, 0);
transform(p, Z);
fill(B + half, B + p, 0);
transform(p, B);
for (int i = 0; i != p; ++i)
B[i] = ((long long)B[i] * B[i] + Z[i]) % mod_v * T[i] % mod_v;
inverse_transform(p, B);
}
int tmp[MaxN];
int A[MaxN], B[MaxN], C[MaxN], T[MaxN];
int main() {
int n, m;
std::scanf("%d %d", &n, &m);
int min_v = ~0u >> 1;
for (int i = 0; i != n; ++i) {
std::scanf("%d", tmp + i);
if (min_v > tmp[i]) min_v = tmp[i];
}
inv2 = mod_v - mod_v / 2;
int p = 1;
for (; p < (m + min_v + 1) << 1; p <<= 1)
;
init_eps(p);
A[0] = 1;
for (int i = 0; i != n; ++i) {
int x = tmp[i];
T[x - min_v] = 2;
A[x] = mod_v - 4;
}
polynomial_inverse(m + min_v + 1, T, C);
polynomial_sqrt(m + min_v + 1, A, B);
B[0] = dec(1, B[0]);
for (int i = 1; i <= m + min_v; ++i) B[i] = mod_v - B[i];
for (int i = 0; i <= m; ++i) B[i] = B[i + min_v];
fill(B + m + 1, B + p, 0);
fill(C + m + 1, C + p, 0);
transform(p, B);
transform(p, C);
for (int i = 0; i != p; ++i) B[i] = (long long)B[i] * C[i] % mod_v;
inverse_transform(p, B);
for (int i = 1; i <= m; ++i) std::printf("%d\n", B[i]);
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
long long MOD(long long, long long);
void doublesetprecision(double, int);
bool isEven(long long);
int gcd(int, int);
int n, m, o, ans, k;
int a[1000000];
void solve() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
map<int, int> mm;
for (long long i = 0; i < n; i++) {
mm[a[i]]++;
}
for (long long i = 0; i < n; i++) {
if (mm[a[i]] > 1) {
cout << "YES";
return;
}
}
cout << "NO";
return;
}
int main() {
int t = 1;
scanf("%d", &t);
while (t--) {
solve();
cout << "\n";
}
return 0;
}
bool isEven(long long n) {
if (n % 2 == 0) return 1;
return 0;
}
void doublesetprecision(double x, int p) {
cout << fixed << setprecision(p) << x;
}
long long MOD(long long x, long long M) {
x = x % M;
if (x < 0) x += M;
return x;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 0, sum;
char c;
bool flag;
cin >> n;
vector<int> V(n);
for (int i = 0; i < n; ++i) {
cin >> c;
V[i] = (int)c - 48;
}
for (int i = 0; i < n - 1; ++i) {
s += V[i];
sum = 0;
flag = false;
for (int j = i + 1; j < n; ++j) {
sum += V[j];
if (sum > s)
break;
else if (sum == s) {
sum = 0;
flag = true;
}
}
if (!sum && flag) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100];
string st;
int main() {
cin >> st;
for (int i = 0; i < st.size(); i++) cnt[st[i] - 48]++;
cnt[1]--, cnt[6]--, cnt[8]--, cnt[9]--;
int rest = 0;
for (int i = 9; i > 0; i--)
for (int j = 1; j <= cnt[i]; j++) {
printf("%d", i);
rest = (rest * 10 + i) % 7;
}
rest = rest * 10000 % 7;
if (rest == 0) cout << 1869;
if (rest == 1) cout << 1896;
if (rest == 2) cout << 1986;
if (rest == 3) cout << 1698;
if (rest == 4) cout << 6198;
if (rest == 5) cout << 1689;
if (rest == 6) cout << 1968;
for (int i = 1; i <= cnt[0]; i++) printf("0");
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c;
cin >> n;
a = 1;
b = 1;
c = n - 2;
if (c % 3 == 0) {
b = b + 1;
c = c - 1;
}
cout << a << " " << b << " " << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long area[1001];
vector<pair<long long, int>> leftOfMaxArea;
vector<pair<long long, int>> rightOfMaxArea;
int main() {
cin >> N;
int p1 = 1;
int p2 = 2;
for (int sign, i = 3; i <= N; i++) {
if (i == p1 or i == p2) continue;
printf("2 %d %d %d\n", p1, p2, i);
fflush(stdout);
scanf("%d", &sign);
if (sign < 0) p2 = i;
}
long long maxArea = 0;
int pMaxArea = p2;
for (int i = 2; i <= N; i++) {
if (i == p2) continue;
printf("1 %d %d %d\n", p1, p2, i);
fflush(stdout);
scanf("%lld", &area[i]);
if (area[i] == maxArea) {
int sign;
printf("2 %d %d %d\n", p1, pMaxArea, i);
fflush(stdout);
scanf("%d", &sign);
if (sign < 0) pMaxArea = i;
}
if (area[i] > maxArea) {
maxArea = area[i];
pMaxArea = i;
}
}
rightOfMaxArea.push_back({LLONG_MAX, pMaxArea});
for (int sign, i = 2; i <= N; i++) {
if (i == p2) continue;
if (i == pMaxArea) continue;
printf("2 %d %d %d\n", p1, pMaxArea, i);
fflush(stdout);
scanf("%d", &sign);
if (sign < 0) {
leftOfMaxArea.push_back({area[i], i});
} else {
rightOfMaxArea.push_back({area[i], i});
}
}
sort(leftOfMaxArea.begin(), leftOfMaxArea.end());
sort(rightOfMaxArea.begin(), rightOfMaxArea.end(),
greater<pair<long long, int>>());
rightOfMaxArea.push_back({0, p1});
rightOfMaxArea.push_back({0, p2});
queue<int> S;
for (auto &p : leftOfMaxArea) {
S.push(p.second);
}
for (auto &p : rightOfMaxArea) {
S.push(p.second);
}
printf("0");
while (!S.empty()) {
if (S.front() == 1 or int(S.size()) < N) {
printf(" %d", S.front());
S.pop();
} else {
S.push(S.front());
S.pop();
}
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << (max(a + b, c + d)) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100100];
int b[100100];
map<int, int> us;
void solve() {
int n;
cin >> n;
a[0] = -1;
vector<int> v;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] != a[i - 1]) {
v.push_back(a[i]);
}
us[a[i]] = 1;
}
v.push_back(-1);
int l = 0, k = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != v[l]) {
b[i] = v[l];
l++;
continue;
}
while (us[k] == 1) {
k++;
}
b[i] = k;
k++;
}
l = 0;
us.clear();
for (int i = 1; i <= n; i++) {
us[b[i]] = 1;
while (us[l] == 1) {
l++;
}
if (l < a[i]) {
cout << -1;
return;
}
}
for (int i = 1; i <= n; i++) {
cout << b[i] << " ";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int l = -1;
long long N, M, f[262150][105], w[20], sum[10], jc[20];
int main() {
cin >> N >> M;
for (; N; N /= 10) w[++l] = N % 10;
for (int i = 0; i <= l; ++i) {
sum[w[i]]++;
if (w[i]) f[1 << i][w[i] % M] = 1;
}
for (int i = 1; i <= (1 << l + 1) - 1; ++i) {
for (int k = 0; k <= M - 1; ++k)
for (int j = 0; j <= l; ++j) {
if ((1 << j ^ i) > i) f[1 << j ^ i][(k * 10 + w[j]) % M] += f[i][k];
}
}
long long ans = f[(1 << l + 1) - 1][0];
jc[0] = 1;
for (int i = 1; i <= l + 1; ++i) jc[i] = jc[i - 1] * i;
for (int i = 0; i <= 9; ++i) ans /= jc[sum[i]];
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
struct point {
double first, second;
point(double first = 0, double second = 0) : first(first), second(second) {}
point operator-(point a) { return point(first - a.first, second - a.second); }
point operator+(point a) { return point(first + a.first, second + a.second); }
point operator*(double a) { return point(first * a, second * a); }
point operator/(double a) { return point(first / a, second / a); }
point operator&(point a) {
return point(first * a.first - second * a.second,
first * a.second + second * a.first);
}
double operator^(point a) { return first * a.second - second * a.first; }
double operator*(point a) { return first * a.first + second * a.second; }
point norm() {
double s = nor();
if (s < 1e-8) return *this;
return point(first / s, second / s);
}
double nor() { return sqrt(*this * *this); }
double al() { return atan2(second, first); }
bool operator<(const point &a) const {
if (fabs(first - a.first) > 1e-8) return first < a.first;
return second < a.second - 1e-8;
}
bool operator>(const point &a) const {
if (fabs(first - a.first) > 1e-8) return first > a.first;
return second > a.second + 1e-8;
}
bool operator==(const point &a) const {
if (fabs(first - a.first) > 1e-8) return 0;
return fabs(second - a.second) < 1e-8;
}
void input() { scanf("%lf %lf", &first, &second); }
void print() { printf("%lf %lf\n", first, second); }
};
point p[111], q[111];
point convex[111];
int sgn(double a) { return (a > 1e-8) - (a < -1e-8); }
int intersect(point a, point b, point c, point d, point *p, int &nn) {
if (min(a.first, b.first) > max(c.first, d.first) + 1e-8) return 0;
if (max(a.first, b.first) < min(c.first, d.first) - 1e-8) return 0;
if (min(a.second, b.second) > max(c.second, d.second) + 1e-8) return 0;
if (max(a.second, b.second) < min(c.second, d.second) - 1e-8) return 0;
if (sgn((a - b) ^ (c - b)) * sgn((a - b) ^ (d - b)) >= 0) return 0;
if (sgn((c - d) ^ (a - d)) * sgn((c - d) ^ (b - d)) >= 0) return 0;
double s1 = fabs((a - b) ^ (c - b)), s2 = fabs((a - b) ^ (d - b));
p[nn++] = (c * s2 + d * s1) / (s1 + s2);
return 1;
}
point tmp[111];
int is_on(point a, point b, point c) {
if (fabs((a - b) ^ (b - c)) > 1e-8) return 0;
return sgn((a - c) * (b - c)) <= 0;
}
double calc_al(point a, point b) { return acos((a * b) / a.nor() / b.nor()); }
bool is_in(point a, point *p) {
p[4] = p[0];
for (int i = 0; i < 4; i++) {
if (is_on(p[i], p[i + 1], a)) return 1;
}
double al = 0;
for (int i = 0; i < 4; i++) {
al += calc_al(p[i] - a, p[i + 1] - a) * sgn((p[i] - a) ^ (p[i + 1] - a));
}
return fabs(fabs(al) - 2 * acos(-1)) < 1e-8;
}
int main() {
int w, h, d;
scanf("%d%d%d", &w, &h, &d);
double al = acos(-1) * d / 180.0;
p[0] = point(-w * 0.5, -h * 0.5);
p[1] = point(w * 0.5, -h * 0.5);
p[2] = point(w * 0.5, h * 0.5);
p[3] = point(-w * 0.5, h * 0.5);
for (int i = 0; i < 4; i++) q[i] = p[i] & point(cos(al), sin(al));
q[4] = q[0], p[4] = p[0];
int nn = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++)
intersect(p[i], p[i + 1], q[j], q[j + 1], tmp, nn);
if (is_in(q[i], p)) tmp[nn++] = q[i];
if (is_in(p[i], q)) tmp[nn++] = p[i];
}
sort(tmp, tmp + nn);
nn = unique(tmp, tmp + nn) - tmp;
int top = 0;
for (int i = 0; i < nn; i++) {
while (top > 1 && sgn((convex[top - 2] - convex[top - 1]) ^
(tmp[i] - convex[top - 1])) <= 0)
top--;
convex[top++] = tmp[i];
}
for (int i = nn - 2, t = top; i >= 0; i--) {
while (top > t && sgn((convex[top - 2] - convex[top - 1]) ^
(tmp[i] - convex[top - 1])) <= 0)
top--;
convex[top++] = tmp[i];
}
double ans = 0;
for (int i = 0; i < top - 1; i++) ans += convex[i] ^ convex[i + 1];
printf("%.18lf\n", fabs(ans) / 2);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long cal(long long a, long long x) {
long long ans = 1;
while (x) {
if (x & 1) ans = (ans * a) % MOD;
x >>= 1;
a = (a * a) % MOD;
}
return ans;
}
int main() {
long long p, k;
scanf("%lld%lld", &p, &k);
if (k == 0) {
printf("%lld\n", cal(p, p - 1));
} else if (k == 1) {
printf("%lld\n", cal(p, p));
} else {
int m = 1;
long long w = k;
for (; w != 1; m++) {
w = (long long)w * k % p;
}
printf("%lld\n", cal(p, (p - 1) / m));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct pnt {
int x, y;
};
bool operator<(pnt x, pnt y) { return x.x < y.x; }
bool operator>(pnt x, pnt y) { return x.x > y.x; }
bool operator==(pnt x, pnt y) { return x.x == y.x; }
int main() {
int n, k, sum, cnt;
pnt a[101];
while (cin >> n) {
cin >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i].x;
a[i].y = i + 1;
}
sort(a, a + n);
sum = 0;
for (cnt = 0; cnt < n; ++cnt) {
if (sum + a[cnt].x <= k)
sum += a[cnt].x;
else
break;
}
cout << cnt << endl;
for (int i = 0; i < cnt; ++i) cout << a[i].y << " ";
if (cnt > 0) cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dist[30][30];
int main() {
int i, j, k;
int n, m;
int u, v;
for (i = 0; i < 30; i++) {
for (j = 0; j < 30; j++) dist[i][j] = 100000000;
}
for (i = 0; i < 30; i++) dist[i][i] = 0;
string s, t;
cin >> s >> t;
if (s.length() != t.length()) {
cout << "-1";
return 0;
}
cin >> n;
char c1, c2, c3;
while (n--) {
cin >> c1 >> c2 >> k;
dist[c1 - 'a'][c2 - 'a'] = min(dist[c1 - 'a'][c2 - 'a'], k);
}
for (k = 0; k < 26; k++) {
for (i = 0; i < 26; i++) {
for (j = 0; j < 26; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
n = s.length();
int cost = 0, mn;
for (i = 0; i < n; i++) {
if (s[i] != t[i]) {
mn = 100000000;
c3 = '#';
for (j = 'a'; j <= 'z'; j++) {
k = dist[s[i] - 'a'][j - 'a'] + dist[t[i] - 'a'][j - 'a'];
if (k <= mn) mn = k, c3 = j;
}
cost += mn;
s[i] = t[i] = c3;
if (mn >= 100000000) {
cout << "-1";
return 0;
}
}
}
cout << cost << endl;
cout << s;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
const long long linf = 1ll * inf * inf;
const int N = 200000 + 7;
const int M = 31;
const int multipleTest = 0;
int n, m;
vector<int> a[N];
int r[N];
int get(int u) { return r[u] < 0 ? u : r[u] = get(r[u]); }
void uni(int u, int v) {
if (u == v) return;
if (r[u] > r[v]) swap(u, v);
if (v > m) swap(u, v);
r[u] += r[v];
r[v] = u;
}
vector<int> adj[N];
vector<int> rev[N];
int cnt[N];
int state[N];
void dfs(int u) {
state[u] = 2;
for (int v : adj[u]) {
if (state[v] == 0) {
rev[v].push_back(u);
cnt[u]++;
dfs(v);
} else {
if (state[v] == 2) {
puts("No");
exit(0);
} else {
rev[v].push_back(u);
cnt[u]++;
}
}
}
state[u] = 1;
}
int st[N], top;
int inv[N];
void solve() {
cin >> n >> m;
for (int i = (0), _b = (n); i < _b; ++i) {
int k;
scanf("%d", &k);
a[i].resize(k);
for (int j = (0), _b = (k); j < _b; ++j) scanf("%d", &a[i][j]);
}
for (int i = (1), _b = (m + 5); i < _b; ++i) r[i] = -1;
vector<pair<int, int> > ls;
for (int i = n - 2; i >= 0; --i) {
bool diff = false;
for (int j = (0), _b = (min(a[i].size(), a[i + 1].size())); j < _b; ++j) {
if (a[i][j] == a[i + 1][j]) continue;
int u = a[i][j], v = a[i + 1][j];
ls.push_back(make_pair(u, v));
adj[u].push_back(v);
diff = true;
break;
}
if (!diff && a[i].size() > a[i + 1].size()) {
puts("No");
return;
}
}
for (int j = (1), _b = (m + 1); j < _b; ++j)
if (state[j] == 0) dfs(j);
for (int j = (1), _b = (m + 1); j < _b; ++j)
if (cnt[j] == 0) st[top++] = j;
for (int j = 0; j < top; ++j) {
int v = st[j];
bool ok = true;
for (int u : adj[v]) {
if (inv[u])
ok &= false;
else {
if (v < u)
ok &= true;
else
ok &= false;
}
}
if (!ok) {
int cost = v - m;
for (int u : adj[v]) {
if (inv[u]) {
if (cost > u - m) {
puts("No");
return;
}
} else {
if (cost > u) {
puts("No");
return;
}
}
}
}
inv[v] = !ok;
for (int u : rev[v]) {
--cnt[u];
if (!cnt[u]) st[top++] = u;
}
}
int res = 0;
for (int j = (1), _b = (m + 1); j < _b; ++j) res += inv[j];
puts("Yes");
cout << res << '\n';
for (int j = (1), _b = (m + 1); j < _b; ++j)
if (inv[j]) printf("%d ", j);
}
int main() {
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
| 13 |
#include <bits/stdc++.h>
int n;
long long m;
int xi, yi;
long long check(long long k) {
long long sum = (2 * k * k - 2 * k + 1);
if (k > xi + 1) {
long long tmp = k - (xi + 1);
sum -= ((2 * tmp * tmp - 2 * tmp + 1) - (2 * tmp - 1)) / 2 + (2 * tmp - 1);
}
if (k > yi + 1) {
long long tmp = k - (yi + 1);
sum -= ((2 * tmp * tmp - 2 * tmp + 1) - (2 * tmp - 1)) / 2 + (2 * tmp - 1);
}
if (k > n - xi) {
long long tmp = k - (n - xi);
sum -= ((2 * tmp * tmp - 2 * tmp + 1) - (2 * tmp - 1)) / 2 + (2 * tmp - 1);
}
if (k > n - yi) {
long long tmp = k - (n - yi);
sum -= ((2 * tmp * tmp - 2 * tmp + 1) - (2 * tmp - 1)) / 2 + (2 * tmp - 1);
}
if (k - (xi + 1) > n - yi) {
long long tmp = (k - (xi + 1)) - (n - yi);
sum += ((2 * tmp * tmp - 2 * tmp + 1) - tmp - 3 * (tmp - 1)) / 4 + tmp +
(tmp - 1);
}
if (k - (xi + 1) > yi + 1) {
long long tmp = (k - (xi + 1)) - (yi + 1);
sum += ((2 * tmp * tmp - 2 * tmp + 1) - tmp - 3 * (tmp - 1)) / 4 + tmp +
(tmp - 1);
}
if (k - (n - xi) > yi + 1) {
long long tmp = (k - (n - xi)) - (yi + 1);
sum += ((2 * tmp * tmp - 2 * tmp + 1) - tmp - 3 * (tmp - 1)) / 4 + tmp +
(tmp - 1);
}
if (k - (n - xi) > n - yi) {
long long tmp = (k - (n - xi)) - (n - yi);
sum += ((2 * tmp * tmp - 2 * tmp + 1) - tmp - 3 * (tmp - 1)) / 4 + tmp +
(tmp - 1);
}
return sum;
}
int main() {
scanf("%d %d %d", &n, &xi, &yi);
xi--;
yi--;
scanf("%I64d", &m);
long long left = 1, right = n + 1;
right *= 3;
for (; left < right;) {
long long mid = (left + right) / 2;
long long sum = check(mid);
if (sum >= m)
right = mid;
else
left = mid + 1;
}
printf("%I64d\n", left - 1);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1002;
vector<vector<long long> > digl(MAXN, vector<long long>(MAXN));
vector<vector<long long> > digr(MAXN, vector<long long>(MAXN));
vector<vector<long long> > H(MAXN, vector<long long>(MAXN));
vector<vector<long long> > V(MAXN, vector<long long>(MAXN));
int mat[MAXN][MAXN];
long long triangles1[MAXN][MAXN];
long long triangles2[MAXN][MAXN];
long long Rhombus[MAXN][MAXN];
long long result[MAXN][MAXN];
int h, w, k;
long long get_digl_sm(int i, int j, int K) {
long long sm = 0;
while (K) K--, sm += mat[i][j], i++, j++;
return sm;
}
long long get_H_sm(int i, int j, int K) {
long long sm = 0;
while (K) K--, sm += mat[i][j], i++;
return sm;
}
long long get_V_sm(int i, int j, int K) {
long long sm = 0;
while (K) K--, sm += mat[i][j], j++;
return sm;
}
void init(vector<vector<long long> >& dig) {
for (int i = 0; i < h - k + 1; i++) dig[i][0] = get_digl_sm(i, 0, k);
for (int i = 0; i < w - k + 1; i++) dig[0][i] = get_digl_sm(0, i, k);
for (int i = 1; i < h - k + 1; i++)
for (int j = 1; j < w - k + 1; j++)
dig[i][j] =
dig[i - 1][j - 1] - mat[i - 1][j - 1] + mat[i + k - 1][j + k - 1];
}
void initl() { init(digl); }
void initr() {
for (int i = 0; i < h; i++) reverse(mat[i], mat[i] + w);
init(digr);
for (int i = 0; i < h; i++)
reverse(mat[i], mat[i] + w), reverse(digr[i].begin(), digr[i].begin() + w);
}
void initH() {
int K = 2 * k - 1;
for (int j = 0; j < w; j++) H[0][j] = get_H_sm(0, j, K);
for (int i = 1; i < h - K + 1; i++)
for (int j = 0; j < w; j++)
H[i][j] = H[i - 1][j] - mat[i - 1][j] + mat[i + K - 1][j];
}
void initV() {
int K = 2 * k - 1;
for (int i = 0; i < h; i++) V[i][0] = get_V_sm(i, 0, K);
for (int i = 0; i < h; i++)
for (int j = 1; j < w - K + 1; j++)
V[i][j] = V[i][j - 1] - mat[i][j - 1] + mat[i][j + K - 1];
}
void step1() {
initl();
initr();
initH();
initV();
}
long long get_Rhombus_sum(int a, int b) {
long long sm = 0;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
sm += mat[i][j] * (long long)max(0, min(1, k - abs(i - a) - abs(j - b)));
return sm;
}
void step2() {
long long val = get_Rhombus_sum(k - 1, k - 1);
Rhombus[k - 1][k - 1] = val;
for (int i = k - 1; i < h - k + 1; i++) {
for (int j = k; j < w - k + 1; j++)
Rhombus[i][j] = Rhombus[i][j - 1],
Rhombus[i][j] -= digr[i - k + 1][j - 1] + digl[i][j - 1 - k + 1],
Rhombus[i][j] += digl[i - k + 1][j] + digr[i][j + k - 1],
Rhombus[i][j] += mat[i][j - 1 - k + 1],
Rhombus[i][j] -= mat[i][j + k - 1];
if (i + 1 < (h - k + 1))
Rhombus[i + 1][k - 1] = Rhombus[i][k - 1],
Rhombus[i + 1][k - 1] -= digl[i - k + 1][k - 1] +
digr[i - k + 1][k - 1] -
mat[i - k + 1][k - 1],
Rhombus[i + 1][k - 1] += digl[i + 1][k - 1 - k + 1] +
digr[i + 1][k - 1 + k - 1] -
mat[i + 1 + k - 1][k - 1];
}
}
long long get_Tri_sum(int a, int b) {
long long sm = 0;
for (int i = 0; i < h; i++)
for (int j = 0; j < k; j++)
sm += mat[i][j] * (long long)max(0, min(1, k - abs(i - a) - abs(j - b)));
return sm;
}
long long get_Tri2_sum(int a, int b) {
long long sm = 0;
for (int i = 0; i < k; i++)
for (int j = 0; j < w; j++)
sm += mat[i][j] * (long long)max(0, min(1, k - abs(i - a) - abs(j - b)));
return sm;
}
void step3() {
long long val = get_Tri_sum(k - 1, k - 1);
triangles1[k - 1][k - 1] = val;
for (int i = k - 1; i < h - k + 1; i++) {
for (int j = k; j < w - k + 1; j++)
triangles1[i][j] = triangles1[i][j - 1],
triangles1[i][j] -= digr[i - k + 1][j - 1] + digl[i][j - 1 - k + 1] -
mat[i][j - 1 - k + 1],
triangles1[i][j] += H[i - k + 1][j];
if (i + 1 < (h - k + 1))
triangles1[i + 1][k - 1] = triangles1[i][k - 1],
triangles1[i + 1][k - 1] -= digr[i - k + 1][k - 1],
triangles1[i + 1][k - 1] +=
digl[i + 1][k - 1 - k + 1];
}
triangles2[k - 1][k - 1] = get_Tri2_sum(k - 1, k - 1);
for (int i = k - 1; i < h - k + 1; i++) {
for (int j = k; j < w - k + 1; j++)
triangles2[i][j] = triangles2[i][j - 1],
triangles2[i][j] -= digr[i - k + 1][j - 1],
triangles2[i][j] += digl[i - k + 1][j];
if (i + 1 < (h - k + 1))
triangles2[i + 1][k - 1] = triangles2[i][k - 1],
triangles2[i + 1][k - 1] -= digr[i - k + 1][k - 1],
triangles2[i + 1][k - 1] -= digl[i - k + 1][k - 1],
triangles2[i + 1][k - 1] += mat[i - k + 1][k - 1],
triangles2[i + 1][k - 1] += V[i + 1][0];
}
}
long long get_Rhombus_sum2(int a, int b) {
long long sm = 0;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
sm += mat[i][j] * (long long)max(0, k - abs(i - a) - abs(j - b));
return sm;
}
void step4() {
long long val = get_Rhombus_sum2(k - 1, k - 1);
result[k - 1][k - 1] = val;
for (int i = k - 1; i < h - k + 1; i++) {
for (int j = k; j < w - k + 1; j++)
result[i][j] = result[i][j - 1] - triangles1[i][j - 1],
result[i][j] += Rhombus[i][j] - triangles1[i][j] + H[i - k + 1][j];
if (i + 1 < (h - k + 1))
result[i + 1][k - 1] = result[i][k - 1],
result[i + 1][k - 1] -= triangles2[i][k - 1],
result[i + 1][k - 1] +=
Rhombus[i + 1][k - 1] - triangles2[i + 1][k - 1],
result[i + 1][k - 1] += V[i + 1][0];
}
}
int main() {
scanf("%d%d%d", &h, &w, &k);
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) scanf("%d", &mat[i][j]);
step1();
step2();
step3();
step4();
int a, b;
long long mx = -1;
for (int i = k - 1; i < h - k + 1; i++)
for (int j = k - 1; j < w - k + 1; j++)
if (result[i][j] > mx) mx = result[i][j], a = i, b = j;
printf("%d %d", a + 1, b + 1);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
int array[n];
int min = 1000000001;
for (int i = 0; i < n; i++) {
cin >> array[i];
if (min > array[i]) {
min = array[i];
}
}
bool flag = true;
long long result = 0;
for (int i = 0; i < n; i++) {
if ((array[i] - min) % k != 0) {
flag = false;
break;
}
result += (long long)(array[i] - min) / k;
}
if (flag) {
cout << result << endl;
} else {
cout << "-1" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
const long long linf = 1000000000000000000LL;
const double eps = 0.000001;
const double pi = 3.14159265358979323846;
template <class T>
T abs(T k) {
return k >= 0 ? k : -k;
}
template <class T>
T sqr(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T mod(T a, T b) {
return (a % b + b) % b;
}
template <class T>
void mode(T &a, T b) {
a = mod(a, b);
}
template <class T>
void maxe(T &a, T b) {
a = max(a, b);
}
template <class T>
void mine(T &a, T b) {
a = min(a, b);
}
void fileio_in_out() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
void fileio_txt() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int test;
int n, m;
int s[33333], a[111][33333];
char c[111][33333], str[33333];
int ans() {
for (int i = 0; i < n; i++) {
strcpy(str, c[i]);
strcat(c[i], str);
strcat(c[i], str);
for (int j = 1; j <= 3 * m; j++) s[j] = s[j - 1] + (c[i][j - 1] == '1');
if (!s[m]) return -1;
for (int j = m + 1; j <= 2 * m; j++) {
int l = j, r = 3 * m, mid;
while (l < r) {
mid = (l + r) >> 1;
if (s[mid] > s[j - 1])
r = mid;
else
l = mid + 1;
}
a[i][j] = l - j;
if (s[j]) {
l = 0, r = j - 1;
while (l < r) {
mid = (l + r + 1) >> 1;
if (s[mid] < s[j])
l = mid;
else
r = mid - 1;
}
mine(a[i][j], j - 1 - l);
}
}
}
int ret = inf;
for (int j = m + 1; j <= 2 * m; j++) {
int t = 0;
for (int i = 0; i < n; i++) t += a[i][j];
mine(ret, t);
}
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", c[i]);
printf("%d\n", ans());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
const int inf = 1e9;
const int mo = 998244353;
int a[N];
int main() {
int n;
scanf("%d", &n);
for (auto i = (1); i <= (n); ++i) a[i] = n;
for (auto i = (1); i <= (n); ++i) {
int x;
scanf("%d", &x);
x = min(x, n);
for (auto i = (n); i >= (1); --i) a[i - 1] = min(a[i - 1], a[i]);
for (auto i = (x + 1); i <= (n); ++i) a[i] = n;
for (auto i = (0); i <= (x - 1); ++i) {
a[i + 1] = min(a[i + 1], a[i] + 1);
++a[i];
}
}
int ans = n;
for (auto i = (0); i <= (n); ++i) ans = min(ans, a[i]);
printf("%d\n", ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int siz = 10 + 1e6;
const int siz1 = 5e5 + 10;
int f[siz], a[siz1], n, k, len, L, R;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int l = 0, r = 0, cnt = 0;
while (r < n) {
if (f[a[r]] == 0) cnt++;
f[a[r]]++;
if (cnt <= k)
if (len < r - l + 1) {
L = l;
R = r;
len = r - l + 1;
}
while (cnt > k) {
f[a[l]]--;
if (f[a[l]] == 0) cnt--;
l++;
}
r++;
}
printf("%d %d", ++L, ++R);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2][200005], mod = 1e9 + 7;
int add(int a, int b) {
if (a + b > mod) {
return a + b - mod;
}
return a + b;
}
int main() {
int r, g;
scanf("%d%d", &r, &g);
int i, j;
if (r < g) {
swap(r, g);
}
dp[0][0] = 1;
int h = 0;
for (i = 1; i <= (r + g); i++) {
int sum = i * (i + 1) / 2;
if (sum <= (r + g)) {
h = i;
} else
break;
}
for (i = 1; i <= h; i++) {
for (j = 0; j <= r; j++) {
dp[1][j] = add(dp[1][j], dp[0][j]);
if (j + i <= r) {
dp[1][j + i] = add(dp[1][j + i], dp[0][j]);
}
}
for (j = 0; j <= r; j++) {
dp[0][j] = dp[1][j];
dp[1][j] = 0;
}
}
int sum = h * (h + 1) / 2;
long long ans = 0;
for (i = 0; i <= r; i++) {
int b = sum - i;
if (g - b < 0) {
continue;
}
ans = add(ans, dp[0][i]);
}
printf("%lld", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e6 + 10;
const double Pi = acos(-1.0);
struct Complex {
double x, y;
Complex(double xx = 0, double yy = 0) { x = xx, y = yy; }
} a[maxn], b[maxn];
Complex operator+(Complex a, Complex b) {
return Complex(a.x + b.x, a.y + b.y);
}
Complex operator-(Complex a, Complex b) {
return Complex(a.x - b.x, a.y - b.y);
}
Complex operator*(Complex a, Complex b) {
return Complex(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
}
long long l, r[maxn], c[maxn], sum[maxn], f[maxn], g[maxn];
long long limit = 1;
void fft(Complex *A, long long type) {
long long i, mid, R, j;
for (i = 0; i < limit; i++)
if (i < r[i]) swap(A[i], A[r[i]]);
for (mid = 1; mid < limit; mid <<= 1) {
Complex Wn(cos(Pi / mid), type * sin(Pi / mid));
for (R = mid << 1, j = 0; j < limit; j += R) {
Complex w(1, 0);
for (long long k = 0; k < mid; k++, w = w * Wn) {
Complex x = A[j + k], y = w * A[j + mid + k];
A[j + k] = x + y;
A[j + mid + k] = x - y;
}
}
}
return;
}
signed main() {
long long n, x, i, u;
scanf("%lld%lld", &n, &x);
for (i = 1; i <= n; i++) {
scanf("%lld", &u);
if (u >= x)
u = 0;
else
u = 1;
sum[i] = sum[i - 1] + u;
f[sum[i]]++;
}
f[0]++;
for (i = 0; i <= n; i++) {
g[i] = f[n - i];
}
while (limit <= n + n) {
limit <<= 1;
l++;
}
for (i = 0; i <= n; i++) {
a[i].x = f[i];
b[i].x = g[i];
}
for (i = 0; i < limit; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
fft(a, 1);
fft(b, 1);
for (i = 0; i <= limit; i++) a[i] = a[i] * b[i];
fft(a, -1);
for (i = 0; i <= n; i++) c[i] = (long long)(a[i].x / limit + 0.5);
long long ans0 = 0, p = 0;
for (long long i = 1; i <= n; i++) {
if (sum[i] != sum[i - 1]) p = i;
ans0 += i - p;
}
cout << ans0 << " ";
for (long long i = 1; i <= n; i++) {
printf("%lld ", c[n - i]);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vii = vector<ii>;
const ll MOD = 998244353;
const int INF = 1e9 + 9;
const int MAXN = 1000;
int n, m, k, a[MAXN][MAXN], b[MAXN][MAXN], good, bad;
bool feasible = true;
char s[MAXN], t[MAXN];
void met() { return; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> b[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 1) good++;
if (b[i][j] == 1) bad++;
}
if ((good - bad) % 2) feasible = false;
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
if (a[i][j] == 1) good++;
if (b[i][j] == 1) bad++;
}
if ((good - bad) % 2) feasible = false;
}
if (feasible)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y, z;
double max = 0, temp;
scanf("%d %d", &n, &m);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &x, &y, &z);
temp = (double)(a[x - 1] + a[y - 1]) / z;
if (temp > max) max = temp;
}
printf("%.15f\n", max);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N, K, T, a[22][22], t[22];
char s[200010], q[22], l;
int c[1 << 22];
int main() {
ios::sync_with_stdio(false);
cin >> N >> K >> T >> s;
for (int i = 0; i < K; i++) cin >> t[i];
for (int i = 0; i < K; i++)
for (int j = 0; j < K; j++) cin >> a[i][j];
for (int i = 0; i < N; i++) {
int j, p = s[i] - 'A', f = 0;
for (j = 0; j < l; j++) {
int o = q[j];
c[f] += a[o][p];
c[f | (1 << o)] -= a[o][p];
c[f | (1 << p)] -= a[o][p];
c[f | (1 << o) | (1 << p)] += a[o][p];
if (o == p) break;
f |= (1 << o);
}
if (j == l) l++;
for (; j; j--) q[j] = q[j - 1];
q[0] = p;
}
int w = 0, ans = 0;
for (int i = 0; i < N; i++) w |= (1 << s[i] - 'A');
for (int j = 0; j < K; j++)
for (int i = 0; i < 1 << K; i++)
if (i & (1 << j)) c[i] += c[i ^ (1 << j)];
for (int i = 0; i < 1 << K; i++)
for (int j = 0; j < K; j++)
if ((w & i) & (1 << j)) c[i] += t[j];
for (int i = 0; i < (1 << K) - 1; i++)
if (i != w && (i & w) == i && c[i] <= T) ans++;
cout << ans << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300000;
int ts0[MAX_N], ts1[MAX_N], ts2[MAX_N];
long long tss[MAX_N + 1];
pair<long long, int> ps[MAX_N + 1];
int mxs0[MAX_N + 1], mxs1[MAX_N + 1], mxs2[MAX_N + 1];
void calcmx(int n, int ts[], int mxs[]) {
tss[0] = 0;
ps[0] = pair<long long, int>(0, 0);
for (int i = 0; i < n; i++) {
tss[i + 1] = tss[i] + ts[i];
ps[i + 1] = pair<long long, int>(tss[i + 1], i + 1);
}
sort(ps, ps + n + 1);
int minx = n + 1;
for (int i = n; i >= 0; i--) {
int k = upper_bound(ps, ps + n + 1, pair<long long, int>(tss[i], i)) - ps;
if (k <= n && ps[k].first == tss[i] && minx > ps[k].second)
minx = ps[k].second;
mxs[i] = minx;
}
}
inline void setmax(int &a, int b) {
if (a < b) a = b;
}
int main() {
int n;
scanf("%d", &n);
for (int j = 0; j < n; j++) scanf("%d", ts0 + j), ts2[j] = ts0[j];
for (int j = 0; j < n; j++) scanf("%d", ts1 + j), ts2[j] += ts1[j];
calcmx(n, ts0, mxs0);
calcmx(n, ts1, mxs1);
calcmx(n, ts2, mxs2);
map<pair<int, int>, int> dp;
dp[pair<int, int>(0, 0)] = 0;
int maxd = 0;
while (!dp.empty()) {
map<pair<int, int>, int>::iterator mit0 = dp.begin();
int ui = mit0->first.first, uj = mit0->first.second;
int ud = mit0->second;
dp.erase(mit0);
if (ui == n && uj == n) {
maxd = ud;
break;
}
if (ui <= uj) {
map<pair<int, int>, int>::iterator mit =
dp.find(pair<int, int>(ui + 1, uj));
if (mit == dp.end())
dp[pair<int, int>(ui + 1, uj)] = ud;
else
setmax(mit->second, ud);
int vi = mxs0[ui];
if (vi <= n) {
mit = dp.find(pair<int, int>(vi, uj));
int vd = ud + 1;
if (mit == dp.end())
dp[pair<int, int>(vi, uj)] = vd;
else
setmax(mit->second, vd);
}
}
if (ui >= uj) {
map<pair<int, int>, int>::iterator mit =
dp.find(pair<int, int>(ui, uj + 1));
if (mit == dp.end())
dp[pair<int, int>(ui, uj + 1)] = ud;
else
setmax(mit->second, ud);
int vj = mxs1[uj];
if (vj <= n) {
mit = dp.find(pair<int, int>(ui, vj));
int vd = ud + 1;
if (mit == dp.end())
dp[pair<int, int>(ui, vj)] = vd;
else
setmax(mit->second, vd);
}
}
if (ui == uj && mxs2[ui] <= n) {
int vi = mxs2[ui];
map<pair<int, int>, int>::iterator mit = dp.find(pair<int, int>(vi, vi));
int vd = ud + 1;
if (mit == dp.end())
dp[pair<int, int>(vi, vi)] = vd;
else
setmax(mit->second, vd);
}
}
printf("%d\n", maxd);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b /= 2;
}
return res;
}
long long mod_inv(long long a) { return power(a, mod - 2); }
int k;
const int K = 1e4 + 10;
long long dp[60][K];
long long solve(long long p, int pw, int cur_k) {
if (!cur_k) return power(p, pw);
long long &ret = dp[pw][cur_k];
if (ret != -1) return ret;
ret = 0;
for (int take = 0; take <= pw; take++) {
ret += solve(p, take, cur_k - 1);
ret %= mod;
}
ret *= mod_inv(pw + 1);
ret %= mod;
return ret;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
long long n;
cin >> n >> k;
long long ans = 1;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
long long pr = i;
int pw = 0;
while (n % i == 0) {
pw++;
n /= i;
}
memset(dp, -1, sizeof dp);
ans *= solve(pr, pw, k);
ans %= mod;
}
}
if (n > 1) {
memset(dp, -1, sizeof dp);
ans *= solve(n, 1, k);
ans %= mod;
}
cout << ans;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, t, F[200000 + 5], A[200000 + 5], T[200000 + 5], q[200000 + 5],
Neg[200000 + 5], Pos[200000 + 5], Zero[200000 + 5];
void Prepare() {
for (int i = 2; i <= n; i++) {
if (!F[i]) F[i] = q[++q[0]] = i;
for (int j = 1; i * q[j] <= n && j <= q[0]; j++) {
F[i * q[j]] = q[j];
if (i % q[j] == 0) break;
}
}
}
bool cmp(const int& u, const int& v) { return abs(T[u]) < abs(T[v]); }
int main() {
scanf("%d%d", &n, &t);
Prepare();
for (int i = 1; i <= n; i++) scanf("%d", A + i);
for (int i = 1; i <= n; i++) {
scanf("%d", T + i);
T[i] -= t;
if (T[i] < 0)
Neg[++Neg[0]] = i;
else if (T[i] > 0)
Pos[++Pos[0]] = i;
else
Zero[++Zero[0]] = i;
}
if (Neg[0] == n || Pos[0] == n)
puts("0");
else if (!Neg[0] || !Pos[0]) {
long long sum = 0;
for (int i = 1; i <= Zero[0]; i++) sum += A[Zero[i]];
printf("%lld\n", sum);
} else {
sort(Neg + 1, Neg + Neg[0] + 1, cmp);
sort(Pos + 1, Pos + Pos[0] + 1, cmp);
long long sum = 0, neg = 0, pos = 0, tot;
long double ret = 0.0, _neg = 0.0, _pos = 0.0;
for (int i = 1; i <= Zero[0]; i++) sum += A[Zero[i]];
for (int i = 1; i <= Neg[0]; i++)
neg += A[Neg[i]], _neg += 1LL * A[Neg[i]] * T[Neg[i]];
for (int i = 1; i <= Pos[0]; i++)
pos += A[Pos[i]], _pos += 1LL * A[Pos[i]] * T[Pos[i]];
ret = sum + neg + pos;
if (-_neg > _pos) {
for (int i = Neg[0]; - _neg > _pos; i--) {
long double a = min((long double)A[Neg[i]], (_neg + _pos) / T[Neg[i]]);
_neg -= 1LL * a * T[Neg[i]];
ret -= a;
}
} else if (_pos > -_neg) {
for (int i = Pos[0]; _pos > -_neg; i--) {
long double a = min((long double)A[Pos[i]], (_neg + _pos) / T[Pos[i]]);
_pos -= 1LL * a * T[Pos[i]];
ret -= a;
}
}
printf("%.9f\n", (double)ret);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int x, y, a, b;
int main(void) {
scanf("%d%d%d%d", &x, &y, &a, &b);
if (a <= 0 && 0 <= b) {
if (x + a <= y && y <= x + b)
printf("FIRST\n%d\n", y);
else
puts("DRAW");
} else {
int d = y - x;
bool flag = 0;
if (a <= b && b < 0) {
d = -d;
int tmp = a;
a = -b, b = -tmp;
swap(x, y);
flag = 1;
}
int tmp = d % (a + b);
if (d < 0)
puts("DRAW");
else if (tmp == 0)
puts("SECOND");
else if (tmp >= a && tmp <= b)
printf("FIRST\n%d\n", flag ? y - tmp : x + tmp);
else
puts("DRAW");
}
return 0;
}
| 16 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int nax = 1e7+7;
const int MOD = 1e9+7;
void printarr(vector<int> v){
for(int i=0; i<v.size(); i++){
cout<<v[i]<<" ";
}
cout<<endl;
}
int main(){
int t; cin>>t;
while(t--){
int n; cin>>n;
stack<int> st;
int x; cin>>x;
st.push(x);
for(int i=1; i<n; i++){
cin>>x;
if(st.top()!=x){
st.push(x);
}
}
vector<int> v;
int tmp;
while(!st.empty()){
tmp = st.top();
v.push_back(tmp);
st.pop();
}
reverse(v.begin(), v.end());
// printarr(v);
map<int, int> m;
for(int x: v){
m[x]++;
}
int ans = nax;
for(pair<int, int> p: m){
int cnt = p.second+1;
// cout<<p.first<<" "<<cnt<<endl;
if(v.front()==p.first){
// cout<<"same as first\n";
cnt--;
}
if(v.back()==p.first){
// cout<<"same as last\n";
cnt--;
}
// cout<<cnt<<endl;
ans = min(ans, cnt);
}
// cout<<"The answer: ";
cout<<ans<<endl;
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mo = 1000000007;
long long f[105][100 * 100 + 5], c[105][105], a[105];
long long cal(long long i, long long j) {
if (j == 1) return i;
if (j % 2 == 1) return cal(i, j - 1) * i % mo;
long long k = cal(i, j / 2);
return k * k % mo;
}
int main() {
long long n, m, q;
cin >> n >> m >> q;
f[0][0] = 1;
for (int i = 0; i <= n; i++) c[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mo;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) a[j] = cal(c[n][j], m / n + (m % n >= i));
for (int j = 0; j <= (i - 1) * n && j <= q; j++)
for (int k = 0; k <= n; k++) {
if (j + k > q) break;
(f[i][j + k] += f[i - 1][j] * a[k]) %= mo;
}
}
cout << f[n][q] << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long fpow(long long a, int b, int mod) {
long long res = 1;
for (; b > 0; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res % mod;
}
const int mod = 1e9 + 7;
const int N = 1e4 + 100;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long n;
cin >> n;
long long ans = 0;
long long x = sqrt(n);
for (long long i = 2; i <= x; i++) {
if (n % i == 0) {
ans = gcd(ans, i);
ans = gcd(ans, n / i);
}
}
if (ans != 0)
cout << ans << endl;
else
cout << n << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100 + 5;
int a[M];
vector<int> exam[M];
int ihash[M];
int main() {
int k, n;
cin >> n >> k;
int per = n / k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int q;
cin >> q;
double minv = 1e+6;
double maxv = 0;
for (int i = 0; i < q; i++) {
for (int j = 0; j < per; j++) {
int x;
cin >> x;
exam[i].push_back(x);
ihash[x] = 1;
}
int sum = 0;
for (int j = 0; j < exam[i].size(); j++) {
sum += a[exam[i][j]];
}
double pro = 1.0 * sum / per;
if (pro < minv) {
minv = pro;
}
if (pro > maxv) {
maxv = pro;
}
}
vector<int> left;
for (int i = 1; i <= n; i++) {
if (ihash[i] == 0) {
left.push_back(a[i]);
}
}
sort(left.begin(), left.end());
int examnum = 0;
for (int i = 1; i <= n; i++) {
if (ihash[i] == 1) {
examnum++;
}
}
int len = left.size();
if (len >= per && examnum != per * k) {
int sum = 0;
for (int i = 0; i < per; i++) {
sum = sum + left[i];
}
double pro = 1.0 * sum / per;
if (pro < minv) {
minv = pro;
}
sum = 0;
for (int i = len - 1; i >= len - per; i--) {
sum += left[i];
}
pro = 1.0 * sum / per;
if (pro > maxv) {
maxv = pro;
}
}
if (n < k) {
minv = maxv = 0;
}
printf("%.10f %.10f\n", minv, maxv);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000][1000] = {0};
int n, t;
int m = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t;
if (t > m) m = t;
for (int j = 1; j <= t; j++) a[i][j] = 1;
}
int p = 0;
for (int i = 1; i <= m; i++) {
p = 0;
for (int j = 1; j <= n; j++)
if (a[j][i] == 0) p++;
for (int j = 1; j <= p; j++) a[j][i] = 0;
for (int j = p + 1; j <= n; j++) a[j][i] = 1;
}
int s = 0;
for (int i = 1; i <= n; i++) {
s = 0;
for (int j = 1; j <= m; j++)
if (a[i][j] == 1) s++;
cout << s << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
vector<int> v1;
set<int> s;
for (long long i = (0); i < (n); i++) {
cin >> v[i];
if (s.find(v[i]) == s.end()) {
v1.push_back(v[i]);
}
s.insert(v[i]);
}
sort(v.begin(), v.end());
sort(v1.begin(), v1.end());
if (s.size() >= 4) {
cout << -1;
return 0;
}
if (v1.size() == 3) {
if ((v1[1] - v1[0]) == (v1[2] - v1[1])) {
cout << v1[1] - v1[0];
return 0;
} else {
cout << -1;
return 0;
}
}
if (v1.size() == 2) {
if ((v1[1] + v1[0]) % 2 == 1) {
cout << v1[1] - v1[0];
return 0;
} else {
cout << (v1[1] - v1[0]) / 2;
return 0;
}
}
cout << 0;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool prime[10000004] = {0};
int main() {
int i, j, n, m;
while (cin >> n) {
for (i = 4; i <= 10000004; i += 2) prime[i] = 1;
prime[2] = 0;
for (i = 3; i <= sqrt(10000004); i += 2) {
for (j = i * i; j <= 10000004; j += 2 * i) prime[j] = 1;
}
for (i = 1;; i++) {
m = n * i + 1;
if (prime[m] == 1) {
cout << i << endl;
break;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a, d;
int n, Min = -1;
int getans() {
if (n == 0) return 0;
if (n >= Min) {
int ans = 0;
int m = n;
for (int i = n - 1; i >= n - Min; i--, m--) ans += a[i];
n = m;
if (n > 1)
n -= 2;
else if (n > 0)
n -= 1;
return getans() + ans;
} else {
int ans = 0;
for (int i = 0; i < n; i++) ans += a[i];
n = 0;
return ans;
}
}
int main() {
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int q;
cin >> q;
if (Min == -1 || q < Min) Min = q;
}
cin >> n;
for (int i = 0; i < n; i++) {
int el;
cin >> el;
a.push_back(el);
}
sort(a.begin(), a.end());
cout << getans() << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int h, w;
char s[505][505];
int num[505][505];
int A[505][505];
int B[505][505];
int main() {
cin >> h >> w;
for (int i = 1; i <= h; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++)
if (s[i][j] == '.')
num[i][j] = 1;
else
num[i][j] = 0;
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
if (num[i][j] && num[i][j + 1])
A[i][j] = A[i][j - 1] + 1;
else
A[i][j] = A[i][j - 1];
}
}
for (int i = 1; i <= w; i++) {
for (int j = 1; j <= h; j++) {
if (num[j][i] && num[j + 1][i])
B[j][i] = B[j - 1][i] + 1;
else
B[j][i] = B[j - 1][i];
}
}
int q;
cin >> q;
while (q--) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int ans = 0;
for (int i = x1; i <= x2; i++) ans += A[i][y2 - 1] - A[i][y1 - 1];
for (int i = y1; i <= y2; i++) ans += B[x2 - 1][i] - B[x1 - 1][i];
printf("%d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
long long res = 0;
int n, m, d, q, lim, ar[200010], lol[200010], tmp[200010],
tree[(200010 / 2000) + 5][200010];
void update(int *tree, int p, int v) {
while (p <= lim) {
tree[p] += v;
p += (p & (-p));
}
}
int query(int *tree, int p) {
int res = 0;
while (p) {
res += tree[p];
p ^= (p & (-p));
}
return res;
}
void mergesort(int i, int j) {
if (i == j) return;
int ini = i, k = (i + j) >> 1, l = k + 1;
mergesort(i, k);
mergesort(l, j);
int idx = 0;
while (i <= k && l <= j) {
if (lol[i] <= lol[l])
tmp[idx++] = lol[i++];
else {
res += (l - ini - idx);
tmp[idx++] = lol[l++];
}
}
while (i <= k) tmp[idx++] = lol[i++];
while (l <= j) {
res += (l - ini - idx);
tmp[idx++] = lol[l++];
}
memcpy(&lol[ini], &tmp[0], idx << 2);
}
void build() {
int i, j, k, l, x, y, v;
m = 2000, d = (n - 1) / 2000;
for (i = 0; i < n; i += m) {
for (j = 0, k = i / m; (i + j) < n && j < m; j++) {
update(tree[k], ar[i + j], 1);
}
}
for (i = 0, res = 0; i < n; i++) lol[i] = ar[i];
mergesort(0, n - 1);
}
void modify(int i, int v) {
int j, k, l, x, y;
k = i / m, l = (k * m), x = ar[i], ar[i] = v;
update(tree[k], x, -1);
for (j = i - 1; j >= l; j--) res -= (ar[j] > x);
for (j = i + 1; j < (l + m) && j < n; j++) res -= (ar[j] < x);
for (j = 0; j < k; j++) res -= (m - query(tree[j], x));
for (j = k + 1; j <= d; j++) res -= query(tree[j], x - 1);
update(tree[k], v, 1);
for (j = i - 1; j >= l; j--) res += (ar[j] > v);
for (j = i + 1; j < (l + m) && j < n; j++) res += (ar[j] < v);
for (j = 0; j < k; j++) res += (m - query(tree[j], v));
for (j = k + 1; j <= d; j++) res += query(tree[j], v - 1);
}
int main() {
int i, j, k, l, r, x, y, u, v;
scanf("%d %d", &n, &q);
for (i = 0; i < n; i++) ar[i] = i + 1;
for (lim = 0, i = 0; i < n; i++) {
if (ar[i] > lim) lim = ar[i];
}
build();
while (q--) {
scanf("%d %d", &l, &r);
l--, r--;
if (l != r) {
u = ar[l], v = ar[r];
modify(l, v);
modify(r, u);
}
printf("%lld\n", res);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
A cvt(B x) {
stringstream ss;
ss << x;
A y;
ss >> y;
return y;
}
double PI = acos(-1.0);
int n;
int p[1000];
double area[1000];
vector<int> ch[1000];
long long sqr(long long x) { return x * x; }
long long dist2(vector<int> &c1, vector<int> &c2) {
return sqr(c1[1] - c2[1]) + sqr(c1[2] - c2[2]);
}
double f[1000][2][2];
void solve(int x) {
for (int y : ch[x]) solve(y);
for (int b = 0; b < (int)(2); b++)
for (int a = 0; a < (int)(2); a++) {
double before = (1 - b * 2) * area[x];
for (int y : ch[x]) before += f[y][1 - b][a];
double after = (1 - a * 2) * area[x];
for (int y : ch[x]) after += f[y][b][1 - a];
f[x][b][a] = max(before, after);
}
}
int main() {
scanf("%d", &n);
vector<vector<int> > circ;
for (int i = 0; i < (int)(n); i++) {
vector<int> c(4);
c[3] = i;
scanf("%d %d %d", &c[1], &c[2], &c[0]);
circ.push_back(c);
}
sort((circ).begin(), (circ).end());
reverse((circ).begin(), (circ).end());
for (int i = 0; i < (int)(n); i++) {
p[i] = -1;
for (int j = 0; j < (int)(i); j++) {
if (dist2(circ[i], circ[j]) < sqr(circ[j][0])) p[i] = j;
}
if (p[i] != -1) ch[p[i]].push_back(i);
area[i] = PI * sqr(circ[i][0]);
}
double s = 0;
for (int i = 0; i < (int)(n); i++)
if (p[i] == -1) {
solve(i);
s += f[i][0][0];
}
printf("%.11f\n", s);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int m, n, a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
m = max((3 * a) / 10, a - (a / 250 * c));
n = max((3 * b) / 10, b - (b / 250 * d));
if (m == n)
cout << "Tie";
else if (m > n)
cout << "Misha";
else
cout << "Vasya";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
int n, k1, k2, cnt = 0;
deque<int> p1, p2;
int main() {
scanf("%d", &n);
scanf("%d", &k1);
for (int i = 1; i <= k1; ++i) {
int u;
scanf("%d", &u);
p1.push_back(u);
}
scanf("%d", &k2);
for (int i = 1; i <= k2; ++i) {
int u;
scanf("%d", &u);
p2.push_back(u);
}
while (p1.size() != 0 && p2.size() != 0) {
int c1 = p1.front();
p1.pop_front();
int c2 = p2.front();
p2.pop_front();
if (c1 <= c2) {
p2.push_back(c1);
p2.push_back(c2);
} else {
p1.push_back(c2);
p1.push_back(c1);
}
cnt++;
if (cnt == 10000000) break;
if (p1.size() == 0 || p2.size() == 0) break;
}
if (p1.size() == 0)
cout << cnt << " "
<< "2";
else if (p2.size() == 0)
cout << cnt << " "
<< "1";
else if (cnt == 10000000)
cout << "-1";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char a[2001][2001];
int ans[2001];
void init() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%s", &a[i][0]);
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++) {
if (j - i + 1 >= 0 && a[i][j - i + 1] == 'R') ans[j]++;
if (j + i - 1 < m && a[i][j + i - 1] == 'L') ans[j]++;
if (i + i - 1 <= n && a[i + i - 1][j] == 'U') ans[j]++;
}
for (int i = 0; i < m; i++) cout << ans[i] << " ";
}
int main() {
init();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, q, v;
int ans[MAXN];
int laz1[MAXN << 2];
char tp;
bool laz2[MAXN << 2];
vector<int> pos[MAXN];
vector<int> neg[MAXN];
void fill(vector<int> &sou, vector<int> &tar) {
while (sou.size()) {
tar.push_back(sou.back());
sou.pop_back();
}
}
void upd1(int o, int v) {
laz2[o] = 0;
laz1[o] = v;
}
void upd2(int o) { laz2[o] ^= 1; }
void pushdown(int o) {
if (laz1[o]) {
upd1(o << 1, laz1[o]);
upd1(o << 1 | 1, laz1[o]);
laz1[o] = 0;
}
if (laz2[o]) {
upd2(o << 1);
upd2(o << 1 | 1);
laz2[o] = 0;
}
}
void modify1(int o, int l, int r, int x, int y, int v) {
if (l >= x && r <= y) {
upd1(o, v);
return;
}
pushdown(o);
int mid = l + r >> 1;
if (mid >= x) modify1(o << 1, l, mid, x, y, v);
if (mid + 1 <= y) modify1(o << 1 | 1, mid + 1, r, x, y, v);
}
void modify2(int o, int l, int r, int x, int y) {
if (l >= x && r <= y) {
upd2(o);
return;
}
pushdown(o);
int mid = l + r >> 1;
if (mid >= x) modify2(o << 1, l, mid, x, y);
if (mid + 1 <= y) modify2(o << 1 | 1, mid + 1, r, x, y);
}
void calcans(int o, int l, int r) {
if (l == r) {
if (laz1[o] == -1) fill(pos[l], neg[l]);
if (laz1[o] == 1) fill(neg[l], pos[l]);
if (laz2[o]) swap(pos[l], neg[l]);
for (int i = 0; i < pos[l].size(); i++) ans[pos[l][i]] = l;
for (int i = 0; i < neg[l].size(); i++) ans[neg[l][i]] = -l;
return;
}
pushdown(o);
int mid = l + r >> 1;
calcans(o << 1, l, mid);
calcans(o << 1 | 1, mid + 1, r);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> v;
if (v >= 0)
pos[v].push_back(i);
else
neg[-v].push_back(i);
}
while (q--) {
cin >> tp >> v;
if (tp == '>') {
if (v >= 0)
modify1(1, 0, 100000, v + 1, 100000, -1);
else {
modify2(1, 0, 100000, 0, -v - 1);
modify1(1, 0, 100000, -v, 100000, -1);
}
} else {
if (v <= 0)
modify1(1, 0, 100000, -v + 1, 100000, 1);
else {
modify2(1, 0, 100000, 0, v - 1);
modify1(1, 0, 100000, v, 100000, 1);
}
}
}
calcans(1, 0, 100000);
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
long long n, m, ans = 0;
cin >> n >> m;
vector<vector<long long> > c(n + m + 1, vector<long long>(n + m + 1));
for (int i = 0; i < c.size(); i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j <= i / 2; j++)
c[i][j] = c[i][i - j] = (c[i - 1][j] + c[i - 1][j - 1]) % 998244853;
}
vector<vector<long long> > z(n + 1, vector<long long>(m + 1));
for (int i = 1; i <= m; i++) z[0][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = i; j <= m; j++)
z[i][j] = (z[i - 1][j] + z[i][j - 1]) % 998244853;
vector<vector<long long> > dp(n + 1, vector<long long>(m + 1));
for (int i = 1; i <= n; i++) dp[i][0] = i;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
dp[i][j] = (c[i - 1 + j][j] + dp[i - 1][j] + dp[i][j - 1] -
(c[i + j - 1][i] - z[i][j - 1] + 998244853) % 998244853 +
998244853) %
998244853;
cout << dp[n][m] << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 30000, max0 = 4;
int n, qn;
long long a[maxn + 5], b[maxn + 5];
int posa[maxn + 5], posb[maxn + 5], rk[maxn + 5];
int id[maxn + 5];
int lk[maxn + 5];
bool ok[maxn + 5];
inline bool cmpa(const int &first, const int &second) {
return a[first] > a[second];
}
inline bool cmpb(const int &first, const int &second) {
return b[first] > b[second];
}
inline void init() {
scanf("%d%d", &n, &qn);
for (int i = (0), _end_ = (n); i < _end_; ++i)
scanf("%I64d", a + i), posa[i] = i;
for (int i = (0), _end_ = (n); i < _end_; ++i)
scanf("%I64d", b + i), posb[i] = i;
for (int i = (0), _end_ = (n); i < _end_; ++i) id[i] = i;
}
long long best[maxn + 5][max0];
long long dp[maxn + 5];
inline void calc(const int &first) {
for (int i = (0), _end_ = (max0); i < _end_; ++i) {
if (first - i < 0)
best[first][i] = LLONG_MIN;
else {
best[first][i] = LLONG_MIN;
int l = i + 1;
int st = first - i;
int pos[max0];
for (int j = (0), _end_ = (l); j < _end_; ++j) pos[j] = j;
do {
long long tmp = 0;
for (int j = (0), _end_ = (l); j < _end_; ++j) {
int first = st + j, second = st + pos[j];
if (id[posa[first]] == posb[second]) {
tmp = LLONG_MIN;
break;
}
tmp += a[posa[first]] * b[posb[second]];
}
chkmax(best[first][i], tmp);
} while (next_permutation(pos, pos + l));
}
}
}
int main() {
init();
sort(posa, posa + n, cmpa);
sort(posb, posb + n, cmpb);
for (int i = (0), _end_ = (n); i < _end_; ++i) rk[posa[i]] = i;
for (int i = (0), _end_ = (n); i < _end_; ++i) calc(i);
for (int i = (0), _end_ = (qn); i < _end_; ++i) {
static int first, second;
scanf("%d%d", &first, &second), --first, --second;
swap(id[first], id[second]);
for (int i = (0), _end_ = (max0); i < _end_; ++i) {
if (rk[first] + i < n) calc(rk[first] + i);
if (rk[second] + i < n) calc(rk[second] + i);
}
dp[0] = 0;
for (int i = (1), _end_ = (n + 1); i < _end_; ++i) {
dp[i] = LLONG_MIN;
if (i >= 1) chkmax(dp[i], dp[i - 1] + best[i - 1][0]);
if (i >= 2) chkmax(dp[i], dp[i - 2] + best[i - 1][1]);
if (i >= 3) chkmax(dp[i], dp[i - 3] + best[i - 1][2]);
if (i >= 4) chkmax(dp[i], dp[i - 4] + best[i - 1][3]);
assert(max0 == 4);
}
printf("%I64d\n", dp[n]);
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long a, b, ans = 0;
cin >> a >> b;
long long x, y, z;
cin >> x >> y >> z;
long long s1 = 2 * x + y - a;
long long s2 = 3 * z + y - b;
if (s1 > 0) {
ans += s1;
}
if (s2 > 0) {
ans += s2;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k, c = INT_MAX, x, t;
cin >> n >> k;
for (int i = 1; i <= sqrt(n); ++i) {
if (n % i == 0) {
t = (i * k + (n / i));
if ((i * k + (n / i)) < c && (t / k) * (t % k) == n) c = i * k + (n / i);
t = (i + (n / i) * k);
if ((i + (n / i) * k) < c && (t / k) * (t % k) == n) c = i + (n / i) * k;
}
}
cout << c;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[100000 + 10];
int main() {
cin >> s;
int len = strlen(s), ok = 0, mn = 0, num = s[len - 1] - '0';
for (int i = 0; i < len - 1; ++i)
if (!((s[i] - '0') & 1)) {
ok = 1;
mn = max(mn, i);
if (s[i] - '0' < num) {
swap(s[i], s[len - 1]);
cout << s << endl;
return 0;
}
}
if (ok) {
swap(s[mn], s[len - 1]);
cout << s << endl;
} else
cout << -1 << endl;
return 0;
}
| 5 |
Subsets and Splits