solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cout << i << " ";
cout << endl;
return 0;
}
int main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n;
cin >> t;
while (t--) {
string ans = "YES";
cin >> n;
long long arr[n], maxi = -1;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
maxi = max(maxi, arr[i]);
}
for (long long i = 0; i < n; i++) {
if ((maxi - arr[i]) % 2 != 0) {
ans = "NO";
break;
}
}
cout << ans << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int n, ax[maxn], pre[maxn], suf[maxn];
long long sum[maxn];
int main() {
int T;
T = 1;
for (int i = 1; i <= maxn - 10; i++) sum[i] = i + sum[i - 1];
while (T--) {
scanf("%d", &n);
long long ans = 0;
int max1 = 0, index1 = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &ax[i]);
if (ax[i] > max1) {
max1 = ax[i];
index1 = i;
}
}
int now = 0, id = 1;
for (int i = id; i <= n; i++) {
if (now == max1) break;
if (ax[i] > now) {
suf[id] = i;
pre[i] = id;
now = ax[i];
id = i;
}
}
int mm = n, max2 = 0;
while (true) {
for (int i = index1 + 1; i <= mm; i++) {
ans += max1 - ax[i];
}
if (max2 != 0) ans += sum[max2 - max1 - 1];
max2 = max1;
max1 = ax[pre[index1]];
int dis = index1 - pre[index1];
if (max2 - dis > max1) ans += max2 - dis - max1, max1 = max2 - dis;
mm = index1 - 1;
if (index1 == 0) break;
index1 = pre[index1];
}
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
int n,s;
signed main(){
cin>>n>>s;
for(int i=2;i*i<=n;i++){
int tmp=n,sum=0;
while(tmp){
sum+=tmp%i;
tmp/=i;
}
if(sum==s){
cout<<i<<endl;
return 0;
}
}
// n/b + n%b = s
// n = n/b*b + n%b
// n - s = n/b*(b-1)
// let n/b = i
for(int i=(int)sqrt(n);i>0;i--){
if(i*i>=n)continue;
if((n-s)%i==0){
int b=(n-s)/i+1;
if(b>1&&n/b==i){
cout<<b<<endl;
return 0;
}
}
}
if(n==s){
cout<<n+1<<endl;
return 0;
}
cout<<-1<<endl;
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
#define vvi std::vector<std::vector<int> >
#define vvl std::vector<std::vector<ll> >
#define MODs 1000000007;
typedef long long int ll;
using namespace std;
vvl dot(vvl a, vvl b, ll M){
vvl c = vv(a.size(), b[0].size(), 0, ll);
for(int i=0;i<a.size();i++){
for(int j=0;j<b[0].size();j++){
for(int k=0;k<b.size();k++){
c[i][j] = (c[i][j] + (a[i][k]*b[k][j])%M)%M;
}
}
}
return c;
}
int main(int argc, char const *argv[]) {
ll L, A, B, M;
cin >> L >> A >> B >> M;
vector<ll> keta(19, 0);
ll now = 1, wa=0;
for(int i=0;i<18;i++){
now *= 10;
if(A >= now) keta[i+1]=0;
else{
keta[i+1] = (now-1 - A)/B + 1;
keta[i+1]-=wa;
}
if(i==17) keta[i+1] = L - wa;
if(wa + keta[i+1] <= L) wa += keta[i+1];
else keta[i+1] = L - wa, wa = L;
}
now = 1;
vvl ans = vv(1, 3, 0, ll);
ans[0][0] = 0, ans[0][1] = A%M, ans[0][2] = 1;
for(ll i=1;i<19;i++) {
now *= 10;
vvl c = vv(3, 3, 0, ll);
c[0][0] = now%M, c[1][0] = 1, c[1][1] = 1, c[2][1] = B%M, c[2][2]=1;
while(keta[i]>0){
if(keta[i]%2==1) ans = dot(ans, c, M);
c = dot(c, c, M);
keta[i]/=2;
}
}
std::cout << ans[0][0] << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 32;
const int U_MAX = 32;
int n, u, r;
int a[N_MAX], b[N_MAX], k[N_MAX], p[N_MAX];
long long ans = LLONG_MIN;
void bk(int curr, bool lastOp = 1) {
if ((u - curr + 1) % 2 == 0) {
long long sum = 0;
for (int i = 1; i <= n; i++) sum += 1LL * a[i] * k[i];
ans = max(ans, sum);
}
if (curr == u + 1) return;
if (lastOp != 0) {
for (int i = 1; i <= n; i++) a[i] ^= b[i];
bk(curr + 1, 0);
for (int i = 1; i <= n; i++) a[i] ^= b[i];
}
int save[N_MAX];
for (int i = 1; i <= n; i++) save[i] = a[i];
for (int i = 1; i <= n; i++) a[i] = save[p[i]] + r;
bk(curr + 1, 1);
for (int i = 1; i <= n; i++) a[i] = save[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> u >> r;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) cin >> k[i];
for (int i = 1; i <= n; i++) cin >> p[i];
bk(1);
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000 * 100 + 1;
const long long INF = 1e18;
const int MOD = 1000 * 1000 * 1000 + 7;
const int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
vector<long long> s[200005], a;
vector<long long>::iterator it;
queue<int> q;
int h[200005] = {}, n, x;
int r, arr[200005], b[200005], cnt;
int qinsert(int node) {
h[node] = 1;
int cnt = 0;
a.push_back(node);
for (auto i : s[node]) {
if (!h[i]) cnt += qinsert(i);
}
arr[node] = cnt + 1;
return cnt + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int i, j, z = 0, l, m, k, x, c, y, p = 0, sum = 0;
cin >> n >> k;
x = n;
for (int i = (2); i <= (n); i++) {
cin >> x;
s[x].push_back(i);
}
qinsert(1);
for (int i = (0); i <= (a.size() - 1); i++) b[a[i]] = i;
for (int i = (0); i <= (k - 1); i++) {
cin >> l >> c;
if (arr[l] < c) {
cout << -1 << endl;
} else
cout << a[b[l] + c - 1] << endl;
}
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int d[1005][1005];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int big = n * n;
for (int i = 1; i <= n; i++)
for (int j = n; j >= k; j--) {
d[i][j] = big;
big--;
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += d[i][k];
for (int i = 1; i <= n; i++)
for (int j = k - 1; j >= 1; j--) d[i][j] = big--;
cout << ans << endl;
for (int i = 1; i <= n; i++, printf("\n"))
for (int j = 1; j <= n; j++) printf("%d ", d[i][j]);
return 0;
}
| 3 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n, q, b, e, k;
cin >> n;
vector<int> A(n);
vector<int>::iterator a = A.begin();
for(int i = 0;i < n;i++) cin >> A[i];
cin >> q;
for(int i = 0;i < q;i++){
cin >> b >> e >> k;
cout << count(a + b, a + e, k) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
int p1 = max(3 * a / 10, a - a / 250 * c);
int p2 = max(3 * b / 10, b - b / 250 * d);
if (p1 > p2) {
printf("Misha\n");
} else if (p2 > p1) {
printf("Vasya\n");
} else
printf("Tie\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep2(i, i0, n) for (int i = i0; i < n; ++i)
int main() {
int h, w, k;
cin >> h >> w >> k;
int x1, x2, y1, y2;
cin >> y1 >> x1 >> y2 >> x2;
x1--;
y1--;
x2--;
y2--;
vector<vector<bool>> c(h, vector<bool>(w, false));
rep(i, h) {
string s;
cin >> s;
rep(j, w) {
if (s[j] == '@') c[i][j] = true;
}
}
vector<vector<int>> d(h, vector<int>(w, -1));
queue<pair<pair<int, int>, int>> que;
que.push({{x1, y1}, 0});
d[y1][x1] = 0;
while (!que.empty()) {
int cx = que.front().first.first;
int cy = que.front().first.second;
int cd = que.front().second;
que.pop();
if (cx == x2 && cy == y2) {
cout << cd << endl;
return 0;
}
int shift[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
rep(i, 4) {
rep2(j, 1, k + 1) {
int nx = cx + j * shift[i][0];
int ny = cy + j * shift[i][1];
int nd = cd + 1;
if (nx < 0 || nx >= w || ny < 0 || ny >= h) break;
if (c[ny][nx]) break;
if (d[ny][nx] >= 0 && d[ny][nx] <= cd) break;
if (d[ny][nx] < 0 || d[ny][nx] > nd) {
que.push({{nx, ny}, nd});
d[ny][nx] = nd;
}
}
}
}
cout << -1 << endl;
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
using namespace std;
struct node{
node *l,*p,*r;
int key;
};
node *t ,*NIL;
void insert(int k){
node *y=NIL;
node *x=t;
node *z;
z = new node;
z->key = k;
z->l = NIL;
z->r = NIL;
while(x!=NIL){
y=x;
if(z->key<x->key){
x=x->l;
}
else{
x=x->r;
}
}
z->p=y;
if(y==NIL){
t=z;
}
else {
if(z->key<y->key)y->l=z;
else y->r=z;
}
}
void In(node *c){
if (c== NIL){
return;
}
In(c->l);
printf(" %d",c->key);
In(c->r);
}
void Pre(node *c){
if (c== NIL){
return;
}
printf(" %d",c->key);
Pre(c->l);
Pre(c->r);
}
int main(){
int n;
string com;
cin>>n;
for(int i=0;i<n;i++){
cin>>com;
if(com=="insert"){
int x;
cin>>x;
insert(x);
}
else{
In(t);
cout<<endl;
Pre(t);
cout<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int power[32] = {0};
void solve() {
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int j = 0; j < n; j++) cin >> v[j];
long long int cnt[32] = {0};
for (long long int j = 0; j < n; j++) {
long long int h = 0;
while (power[h] < v[j]) h++;
if (power[h] > v[j]) h--;
cnt[h]++;
}
long long int res = 0;
for (long long int j = 0; j < 32; j++) {
res += (cnt[j] * (cnt[j] - 1)) / 2;
}
cout << res << '\n';
return;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
power[0] = 1;
for (long long int j = 1; j <= 30; j++) power[j] = power[j - 1] * 2;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int q;
cin >> q;
for (long long int j = 0; j < q; j++) {
string s, p;
cin >> s;
cin >> p;
long long int n = s.length();
long long int g = p.length();
sort(s.begin(), s.end());
bool k = false;
if (g < n) {
cout << "NO\n";
continue;
}
for (int x = 0; x <= g - n; x++) {
string f = p.substr(x, n);
sort(f.begin(), f.end());
bool r = true;
for (int y = 0; y < n; y++) {
if (s[y] != f[y]) r = false;
}
if (r) k = true;
}
if (k)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define MAX 334
typedef pair<int, int> pii;
int main()
{
int s, d, m;
while (cin >> s >> d >> m) {
vector<pii> v[s];
for (int i = 0; i < s; i++) {
int k, w, p;
cin >> k;
for (int j = 0; j < k; j++) {
cin >> w >> p;
v[i].push_back(pii(w, p));
}
}
int dp[MAX], f;
memset(dp, -1, sizeof(dp));
dp[m] = 0;
for (int i = 0; i < d; i++) {
cin >> f;
for (int j = 0; j < (int)v[f].size(); j++) {
for (int k = 0; k <= m; k++) {
if (dp[k] == -1) continue;
int nm = k - v[f][j].second;
if (nm >= 0) {
dp[nm] = max(dp[nm], dp[k] + v[f][j].first);
}
}
}
}
int idx = m;
for (int i = m-1; i >= 0; i--) {
if (dp[i] > dp[idx]) {
idx = i;
}
}
cout << dp[idx] << " " << m - idx << endl;
}
return 0;
}
| 0 |
#include <cstdio>
#include <cstring>
const int N = 1e9 + 7;
int n, m, f[3005][3005][2];
int main() {
scanf("%d%d", &n, &m);
f[0][0][1] = 1;
for (int i = 1; i <= n; ++i) f[0][i][0] = 1;
for (int i = 0; i < m; ++i) {
for (int j = 0; j <= n; ++j) {
for (int k = 0; k < 2; ++k) {
if (j > 0) {
f[i + 1][j][k | (j == 1)] = (f[i][j][k] + f[i + 1][j][k | (j == 1)]) % N;
f[i + 1][j - 1][k | (j == 1)] = (f[i][j][k] + f[i + 1][j - 1][k | (j == 1)]) % N;
}
if (j < n) {
f[i + 1][j][k] = (f[i][j][k] + f[i + 1][j][k]) % N;
f[i + 1][j + 1][k] = (f[i][j][k] + f[i + 1][j + 1][k]) % N;
}
}
}
}
int tot = 0;
for (int i = 0; i <= n; ++i) tot = (tot + f[m][i][1]) % N;
printf("%d\n", tot);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long L[200005];
long long R[200005];
int ans[200005];
struct node {
long long fs;
long long sc;
int idx;
node(long long fs, long long sc, int idx) {
this->fs = fs;
this->sc = sc;
this->idx = idx;
}
};
bool cmp(node p1, node p2) {
if (p1.sc != p2.sc) return p1.sc < p2.sc;
return p1.fs < p2.fs;
}
int main() {
int n, m;
long long x;
set<pair<long long, int> > bridges;
set<pair<long long, int> >::iterator it;
vector<node> islands;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> L[i] >> R[i];
for (int i = 0; i < m; i++) {
cin >> x;
bridges.insert(make_pair(x, i));
}
if (m < n - 1) {
puts("No");
return 0;
}
for (int i = 0; i < n - 1; i++)
islands.push_back(node(L[i + 1] - R[i], R[i + 1] - L[i], i));
sort(islands.begin(), islands.end(), cmp);
for (int i = 0; i < islands.size(); i++) {
it = bridges.lower_bound(make_pair(islands[i].fs, -1));
if (it == bridges.end() || it->first > islands[i].sc) {
puts("No");
return 0;
} else {
ans[islands[i].idx] = it->second;
bridges.erase(it);
}
}
puts("Yes");
for (int i = 0; i < islands.size(); i++) cout << ans[i] + 1 << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> G[maxn];
int ans, last;
void dfs(int cur, int pre, int len) {
if (len > ans) {
ans = len;
last = cur;
}
for (int i = 0; i < G[cur].size(); i++) {
int to = G[cur][i];
if (to != pre) dfs(to, cur, len + 1);
}
}
int main() {
int n, m;
while (cin >> n >> m) {
for (int i = 0; i < maxn; i++) G[i].clear();
for (int i = 0, x, y; i < m; i++) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
ans = 0;
dfs(1, 0, 0);
ans = 0;
dfs(last, 0, 0);
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
string w = "";
for (int i = 0; i < s.length(); i++) {
if (i % 2 == 0) w += s[i];
}
cout << w << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 13;
string s[25], t[25];
int main() {
int n, m, q;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> s[i];
for (int i = 1; i <= m; ++i) cin >> t[i];
cin >> q;
int second;
while (q--) {
cin >> second;
int tt = second % n;
if (tt == 0) tt = n;
int ttt = second % m;
if (ttt == 0) ttt = m;
cout << s[tt] + t[ttt] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct data {
long long a, b, c;
};
vector<struct data> ans;
int main() {
long long n, k, i, j;
cin >> n;
long long ara[n + 5];
long long mx = -1;
for (i = 1; i <= n; i++) {
scanf("%lld", &ara[i]);
mx = max(mx, ara[i]);
}
long long p = 1000000 - mx;
ans.push_back({1, n, p});
for (i = 1; i <= n; i++) {
ara[i] += p;
}
for (i = 1; i <= n; i++) {
ans.push_back({2, i, ara[i] - i});
}
cout << n + 1 << endl;
for (i = 0; i < ans.size(); i++) {
printf("%lld %lld %lld\n", ans[i].a, ans[i].b, ans[i].c);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define rep(i,x,y) for (int i=(x);i<=(y);i++)
#define lc (now<<1)
#define rc (now<<1|1)
using namespace std;
const int N=3e5+10;
int w,h,n,top1,stk1[N],top2,stk2[N],mx[N<<2],tag[N<<2],ans;
struct node{int x,y;}a[N];
const bool cmp(node x,node y){return x.x<y.x;}
void build(int now,int l,int r){
mx[now]=tag[now]=0;
if (l==r) return;
int mid=(l+r)>>1;
build(lc,l,mid); build(rc,mid+1,r);
mx[now]=max(mx[lc],mx[rc]);
}
void down(int now,int l,int r){
if (tag[now]){
mx[lc]+=tag[now],tag[lc]+=tag[now];
mx[rc]+=tag[now],tag[rc]+=tag[now];
tag[now]=0;
}
}
void mdy(int now,int l,int r,int x,int y,int z){
if (x<=l&&r<=y){tag[now]+=z,mx[now]+=z; return;}
down(now,l,r);
int mid=(l+r)>>1;
if (x<=mid) mdy(lc,l,mid,x,y,z);
if (y>mid) mdy(rc,mid+1,r,x,y,z);
mx[now]=max(mx[lc],mx[rc]);
}
void work(){
sort(a+2,a+1+n,cmp);
build(1,1,n);
mdy(1,1,n,1,n,h);
top1=top2=0; stk1[0]=stk2[0]=1;
rep (i,2,n){
mdy(1,1,n,1,i-1,a[i].x-a[i-1].x);
ans=max(ans,mx[1]);
if (a[i].y<=h/2){
mdy(1,1,n,stk1[top1],i-1,0-a[i].y);
while (top1&&a[stk1[top1]].y<a[i].y){
mdy(1,1,n,stk1[top1-1],stk1[top1]-1,a[stk1[top1]].y-a[i].y);
top1--;
}
stk1[++top1]=i;
} else{
mdy(1,1,n,stk2[top2],i-1,a[i].y-h);
while (top2&&a[stk2[top2]].y>a[i].y){
mdy(1,1,n,stk2[top2-1],stk2[top2]-1,a[i].y-a[stk2[top2]].y);
top2--;
}
stk2[++top2]=i;
}
}
}
int main(){
scanf("%d%d%d",&w,&h,&n); ++n;
rep (i,2,n) scanf("%d%d",&a[i].x,&a[i].y);
a[++n].x=w,a[n].y=h;
work();
swap(w,h); rep (i,1,n) swap(a[i].x,a[i].y);
work();
printf("%d\n",ans<<1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int64_t const base = 1e9 + 7;
vector<int> Primes;
map<int64_t, int64_t> mp;
map<int64_t, int64_t>::iterator it;
void Fact(int64_t first) {
for (int64_t i = 2; i * i <= first; i++) {
if (first % i == 0) {
mp[i] = 0;
while (first % i == 0) {
first /= i;
}
}
}
if (first != 1) mp[first] = 1;
}
int64_t Pow(int64_t a, int64_t b) {
if (b == 0) return 1LL % base;
int64_t tmp = Pow(a, b / 2);
tmp = (tmp * tmp) % base;
if (b % 2 == 0)
return tmp;
else
return tmp * a % base;
}
int64_t poww(int64_t a, int64_t b) {
if (b == 0) return 1LL;
int64_t tmp = Pow(a, b / 2);
tmp = (tmp * tmp);
if (b % 2 == 0)
return tmp;
else
return tmp * a;
}
int main() {
ios_base::sync_with_stdio(0);
int64_t first;
int64_t n;
cin >> first >> n;
Fact(first);
int64_t ans = 1;
for (it = mp.begin(); it != mp.end(); it++) {
int64_t pre = n, cur = 0, k = (*it).first;
int64_t s = k;
int64_t cnt = 0, _n = n;
cerr << "k"
<< " = " << k << '\n';
;
while (_n >= k) {
_n /= k;
cnt++;
}
for (int i = 1; i <= cnt; i++) {
cur = n / poww(k, i);
ans = (ans * Pow(Pow(k, i - 1), pre - cur) + base) % base;
pre = cur;
}
ans = (ans * (Pow(Pow(k, cnt), cur)) + base) % base;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 130, MOD = 1e9 + 7;
typedef long long Mat[MAXM][MAXM];
typedef bool BIT[7];
int w[7], mat[7][MAXM][MAXM], aa, ls[MAXM], ans[MAXM];
bool C[7], L[7], R[7];
Mat f, res, tmp;
void mul(Mat a, Mat b, Mat &c, int cc) {
for (int i = 0; i < (1 << cc); i++)
for (int j = 0; j < (1 << cc); j++) c[i][j] = 0;
for (int i = 0; i < (1 << cc); i++)
for (int j = 0; j < (1 << cc); j++)
for (int k = 0; k < (1 << cc); k++)
c[i][j] = (c[i][j] + a[i][k] * b[k][j]) % MOD;
}
void bt(int pos, int t, int l, int r) {
if (pos == t) {
bool c = 1;
for (int i = 1; i <= t; i++)
if (C[i - 1] && C[i] && L[i - 1] && R[i - 1]) c = 0;
aa += c;
return;
}
bt(pos + 1, t, l, r);
C[pos] = true;
bt(pos + 1, t, l, r);
C[pos] = false;
}
void tobit(int a, BIT A) {
int i = 0;
while (a) {
if (a % 2) A[i] = 1;
i++;
a /= 2;
}
}
void tv(int k) {
if (k == 1) ls[(1 << k) - 1] = 1;
int b = w[k - 1];
for (int i = 0; i < (1 << k); i++)
for (int j = 0; j < (1 << k); j++)
f[i][j] = mat[k - 1][i][j], res[i][j] = 0;
for (int i = 0; i < (1 << k); i++) res[i][i] = 1;
for (; b; b /= 2) {
if (b % 2) {
mul(res, f, tmp, k);
swap(res, tmp);
}
mul(f, f, tmp, k);
swap(tmp, f);
}
for (int i = 0; i < (1 << k); i++) ans[i] = 0;
for (int i = 0; i < (1 << k); i++)
for (int kp = 0; kp < (1 << k); kp++)
ans[i] = (ans[i] + ls[kp] * res[i][kp]) % MOD;
if (k < 7) {
fill_n(ls, MAXM, 0);
for (int i = 0; i < (1 << k); i++) ls[i * 2 + 1] = ans[i];
}
}
int main() {
for (int i = 0; i < 7; i++) cin >> w[i];
for (int i = 1; i <= 7; i++) {
fill_n(C, 7, 0);
C[0] = 1;
C[i] = 1;
for (int j = 0; j < (1 << i); j++)
for (int k = 0; k < (1 << i); k++) {
for (int p = 0; p < 7; p++) L[p] = R[p] = 0;
tobit(j, L);
tobit(k, R);
aa = 0;
bt(1, i, j, k);
mat[i - 1][j][k] = aa;
}
}
for (int i = 1; i <= 7; i++) tv(i);
cout << ans[(1 << 7) - 1];
}
| 5 |
#include <bits/stdc++.h>
const int INF = 1e9;
using namespace std;
const int MAX = 2e5 + 5;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> a(n), cnt(MAX);
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
if (cnt[a[i]] > 2) {
cout << "NO" << '\n';
return 0;
}
}
vector<bool> taken(MAX);
vector<int> inc, dec;
for (int i = 0; i < n; i++) {
if (taken[a[i]]) {
continue;
}
inc.push_back(a[i]);
if (cnt[a[i]] == 2) {
dec.push_back(a[i]);
}
taken[a[i]] = true;
}
sort(inc.begin(), inc.end());
sort(dec.rbegin(), dec.rend());
cout << "YES" << '\n' << inc.size() << '\n';
for (int i = 0; i < inc.size(); i++) {
cout << inc[i] << " ";
}
cout << '\n' << dec.size() << '\n';
for (int i = 0; i < dec.size(); i++) {
cout << dec[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<n;i++)
vector<pair<int,int>> gra[100010];
ll dist[100010];
void dfs(ll x,ll y){
for(const auto& it:gra[x]){
ll s=it.first,len=it.second;
if(dist[s]!=-1)continue;
dist[s]=y+len;
dfs(s,dist[s]);
}
}
int main(){
int n,q,k;cin >> n;
rep(i,n-1){
ll a,b,c;cin >> a>>b>>c;
gra[a].push_back({b,c});
gra[b].push_back({a,c});
}
cin >> q>>k;
rep(i,100010)dist[i]=-1;
dist[k]=0;
dfs(k,0);
rep(i,q){
ll x,y;cin >> x>>y;
ll ans=dist[x]+dist[y];
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int block = 400;
const long double eps = 1e-7;
const long long pe = 137;
const long long pe2 = 1181;
const long long N = 1e4 + 200;
const long long mod = 1e9 + 7;
const long long mod2 = 1e9 + 9;
const long long INF = 1e16;
int n, m;
char a[200][200];
int dp[200][200], h[200], lrow;
int fos[200], lpos[200];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int st = 0, last = m + 1, c = 0;
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
dp[i][j] = 1e9;
if (a[i][j] == 'W') {
last = j;
if (st == 0) st = j;
c++;
}
}
if (i % 2 == 0) swap(last, st);
fos[i] = st;
lpos[i] = last;
if (c > 0) lrow = i;
h[i] = h[i - 1] + c;
if (i % 2) {
if (fos[i] == 0) fos[i] = m + 1;
if (lpos[i] == m + 1) lpos[i] = 0;
} else {
if (fos[i] == m + 1) fos[i] = 0;
if (lpos[i] == 0) lpos[i] = m + 1;
}
}
dp[1][1] = 0;
for (int i = 1; i <= n; i++) {
if (i % 2) {
for (int j = 1; j <= m; j++) {
if (dp[i][j] != 1e9) {
for (int k = 1; k <= m; k++) {
if (j + k >= lpos[i] && j + k <= m) {
dp[i][j + k] = min(dp[i][j + k], dp[i][j] + k);
}
}
if (j >= lpos[i] || h[i] - h[i - 1] == 0) {
if (fos[i + 1] <= j) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + 1);
}
}
}
}
} else {
for (int j = m; j >= 1; j--) {
if (dp[i][j] != 1e9) {
for (int k = 1; k <= m; k++) {
if (j - k >= 1 && j - k <= lpos[i]) {
dp[i][j - k] = min(dp[i][j - k], dp[i][j] + k);
}
}
if (j <= lpos[i] || h[i] - h[i - 1] == 0) {
if (fos[i + 1] >= j) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + 1);
}
}
}
}
}
}
int ans = 1e9;
if (lrow % 2) {
for (int i = lpos[lrow]; i <= m; i++) {
ans = min(ans, dp[lrow][i]);
}
} else {
for (int i = 1; i <= lpos[lrow]; i++) {
ans = min(ans, dp[lrow][i]);
}
}
if (ans == 1e9) ans = 0;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int arr[n];
for (int x = 0; x < n; x++) {
cin >> arr[x];
}
int f = 0;
int g = 0;
for (int x = 0; x < n; x++) {
if (arr[x] == 0) {
f = x;
}
if (arr[x] == 1) {
g = x;
}
}
cout << min(f, g) + 1;
}
| 1 |
#include<iostream>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
typedef long long ll;
const ll mod = 1000000;
string pat[][4]={
"0xxxxxxx","","","",
"110yyyyx","10xxxxxx","","",
"1110yyyy","10yxxxxx","10xxxxxx","",
"11110yyy","10yyxxxx","10xxxxxx","10xxxxxx"
};
string in[1000];
ll pow2[1001];
ll countup(int num,int which){
ll numofx=0,numofy=0,numofy1=0,reqy=0;
rep(i,num+1){
int ind=which-num+i;
rep(j,8){
if (pat[num][i][j] == '0' && in[ind][j] == '1')return 0;
if (pat[num][i][j] == '1' && in[ind][j] == '0')return 0;
if (pat[num][i][j] == 'y'){
reqy++;
if (in[ind][j] == 'x')numofy++;
if (in[ind][j] == '1')numofy1++;
}
if (pat[num][i][j] == 'x'){
if (in[ind][j] == 'x')numofx++;
}
}
}
ll ret=1;
if (reqy > 0){
if (numofy1 > 0)ret=(pow2[numofy])%mod;
else if (numofy == 0)return 0;
else {
ret=(pow2[numofy]+mod-1)%mod;
}
}
ret=(ret*pow2[numofx])%mod;
return ret;
}
ll dp[1000];
ll solve(int n){
rep(i,n)dp[i]=0;
rep(i,n){
rep(len,4){
if (i-(len+1) == -1){
dp[i]=(dp[i]+countup(len,i))%mod;
}else if (i-(len+1) >= 0){
dp[i]=(dp[i]+dp[i-(len+1)]*countup(len,i))%mod;
}
}
}
return dp[n-1];
}
int main(){
pow2[0]=1;
REP(i,1,1001)pow2[i]=(pow2[i-1]*2)%mod;
int n;
while(cin>>n && n){
rep(i,n)cin>>in[i];
cout << solve(n) << endl;
}
return false;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int a[maxn], n, m, k;
struct node {
int color, id;
} pp[maxn];
inline int max(int a, int b) { return a > b ? a : b; }
bool cmp(node a, node b) {
return a.color < b.color || (a.color == b.color && a.id < b.id);
}
int find(int x) {
int l = 1, r = n, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (pp[mid].color > x)
r = mid - 1;
else
l = mid + 1;
}
return r;
}
int main(int argc, char** argv) {
while (~scanf("%d%d%d", &n, &m, &k)) {
for (int i = 1; i <= n; ++i) scanf("%d", &pp[i].color), pp[i].id = i;
sort(pp + 1, pp + n + 1, cmp);
int maxx = 1;
for (int i = 1; i <= n;) {
int l = i, r = find(pp[i].color);
int tmp = r - l + 1, cnt = 0;
pp[l - 1].id = pp[l].id - 1;
int ll = 0, rr = -1;
for (int j = l; j <= r; ++j) {
cnt += pp[j].id - pp[j - 1].id - 1;
a[++rr] = j;
if (cnt > k) {
maxx = max(maxx, a[rr - 1] - a[ll] + 1);
cnt -= pp[a[ll + 1]].id - pp[a[ll]].id - 1;
++ll;
}
}
if (cnt <= k) maxx = max(maxx, a[rr] - a[ll] + 1);
i += tmp;
}
cout << maxx << endl;
}
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int n,l,t,x[123456],w[123456],lp[123456];
int main()
{
scanf("%d%d%d",&n,&l,&t);
ll cs=0;
for(int i=0;i<n;i++)
{
scanf("%d%d",x+i,w+i);
if(w[i]==1)
{
lp[i]=(x[i]+t)%l;
cs+=(x[i]+t)/l%n;
}
else
{
lp[i]=((x[i]-t)%l+l)%l;
if(x[i]-t<0) cs-=(t-x[i]+l-1)/l%n;
}
}
sort(lp,lp+n); cs=(cs%n+n)%n;
for(int i=0;i<n;i++)
printf("%d\n",lp[(i+cs)%n]);
}
| 0 |
#include<bits/stdc++.h>
#define IL inline
#define x first
#define y second
typedef long long ll;
using namespace std;
const int N=200010;
int c[N];
vector<int>v[N][2];
int l[N];
int r[N];
bool st[N];
int main()
{
int t;
cin>>t;
while(t--)
{
int n,lx,rx;
cin>>n>>lx>>rx;
for(int i=1;i<=n;i++)
{
l[i]=r[i]=0;
st[i]=0;
v[i][0].clear();
v[i][1].clear();
}
for(int i=1;i<=n;i++)
{
cin>>c[i];
if(i<=lx)
l[c[i]]++,v[c[i]][0].push_back(i);
else
r[c[i]]++,v[c[i]][1].push_back(i);
}
int cost=0;
int num=n;
for(int i=1;i<=n;i++)
{
while(l[i] && r[i])
{
l[i]--;
r[i]--;
lx--;
rx--;
v[i][0].pop_back();
v[i][1].pop_back();
}
}
if(lx==rx)
{
cout<<lx<<endl;
}
else if(lx<rx)
{
cost+=(rx+lx)/2-lx;
cost+=lx;
int left=(lx+rx)/2-lx;
int tt=(lx+rx)/2-lx;
for(int i=1;i<=n;i++)
{
while(v[c[i]][1].size()>=2 && tt)
{
left--;
tt--;
v[c[i]][1].pop_back();
v[c[i]][1].pop_back();
//v[c[i]][1].size()-=2;
}
}
cost+=left;
cout<<cost<<endl;
}
else
{
cost+=(lx+rx)/2-rx;
cost+=rx;
int left=(lx+rx)/2-rx;
int tt=(lx+rx)/2-rx;
for(int i=1;i<=n;i++)
{
while(v[c[i]][0].size()>=2 && tt)
{
tt--;
v[c[i]][0].pop_back();
v[c[i]][0].pop_back();
left--;
}
}
cost+=left;
cout<<cost<<endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 22;
int n, p;
int s[maxn], len[maxn], t[maxn], ord[maxn];
pair<int, int> ans[maxn];
int f[1 << maxn];
short g1[1 << maxn], g2[1 << maxn], prv[1 << maxn];
bool cmp(int a, int b) { return s[a] < s[b]; }
int main() {
scanf("%d%d", &n, &p);
for (int i = 0; i < (n); ++i) {
scanf("%d%d%d", &s[i], &len[i], &t[i]);
ord[i] = i;
}
sort(ord, ord + n, cmp);
if (s[0] == 1) {
puts("NO");
return 0;
}
for (int mask = 0; mask < (1 << n); ++mask) f[mask] = int(2e9);
f[0] = 1;
g1[0] = g2[0] = 0;
for (int mask = 0; mask < (1 << n); ++mask) {
if (f[mask] == int(2e9)) continue;
for (int i = 0; i < (n); ++i)
if (!((mask >> i) & 1)) {
int last = f[mask], ng1 = g1[mask], ng2 = g2[mask];
while (ng1 < n || ng2 < n) {
if (ng1 < n && s[ord[ng1]] <= last + t[i]) {
if ((mask >> ord[ng1]) & 1) last = s[ord[ng1]] + len[ord[ng1]];
ng1++;
continue;
}
if (ng2 < n && s[ord[ng2]] <= last) {
if (!((mask >> ord[ng2]) & 1))
last = max(last, s[ord[ng2]] + len[ord[ng2]]);
ng2++;
continue;
}
break;
}
if (last + t[i] < s[i]) {
if (last + t[i] < f[mask ^ (1 << i)]) {
f[mask ^ (1 << i)] = last + t[i];
g1[mask ^ (1 << i)] = ng1;
g2[mask ^ (1 << i)] = ng2;
prv[mask ^ (1 << i)] = i;
}
}
}
}
if (p == 1) {
if (f[(1 << n) - 1] != int(2e9)) {
puts("YES");
int cur = (1 << n) - 1;
while (cur) {
int i = prv[cur];
ans[i] = make_pair(1, f[cur] - t[i]);
cur ^= (1 << i);
}
for (int i = 0; i < (n); ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
} else {
for (int mask = 0; mask < (1 << n); ++mask) {
if (f[mask] != int(2e9) && f[((1 << n) - 1) ^ mask] != int(2e9)) {
puts("YES");
int cur = mask;
while (cur) {
int i = prv[cur];
ans[i] = make_pair(1, f[cur] - t[i]);
cur ^= (1 << i);
}
cur = ((1 << n) - 1) ^ mask;
while (cur) {
int i = prv[cur];
ans[i] = make_pair(2, f[cur] - t[i]);
cur ^= (1 << i);
}
for (int i = 0; i < (n); ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
}
}
puts("NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double dp[105][100005];
double pref[105][100005];
int xs[105];
int main() {
int n, m, score = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> xs[i];
score += xs[i];
}
int j = 1;
for (; j <= m; j++) {
dp[1][j] = dp[1][j - 1];
if (j != xs[1]) dp[1][j] += 1;
}
for (; j <= n * m; j++) {
dp[1][j] = dp[1][m];
}
for (int i = 2; i <= n; i++) {
for (int j = i; j <= n * m; j++) {
if (j - xs[i] < i - 1)
dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1] / (m - 1);
else
dp[i][j] = dp[i][j - 1] +
(dp[i - 1][j - 1] - dp[i - 1][j - xs[i]] +
(dp[i - 1][j - xs[i] - 1] - dp[i - 1][max(0, j - m - 1)])) /
(m - 1);
}
}
cout.precision(10);
cout << fixed << 1.0 + dp[n][score - 1] << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define M 1000000007
#define pb push_back
#define ll long long int
using namespace std;
struct mat
{
ll a[50][50];
int n;
mat()
{
memset(a,0,sizeof(a));
}
mat operator*(mat &o)
{
mat res;
res.n = n;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
res.a[i][j] = 0;
for(int k = 0;k<n;k++)
{
res.a[i][j] += (a[i][k]*o.a[k][j])%M;
res.a[i][j] %= M;
}
}
}
return res;
}
};
mat binexp(mat m, ll k)
{
mat res;
for(int i = 0;i<m.n;i++)
res.a[i][i] = 1;
res.n = m.n;
while(k!=0)
{
if(k&1)
{
res = res*m;
}
m = m*m;
k = (k>>1);
}
return res;
}
int main()
{
int n;
ll k;
cin>>n>>k;
mat m;
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
cin>>m.a[i][j];
}
m.n = n;
mat res = binexp(m,k);
ll ans = 0;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
ans += res.a[i][j];
ans %= M;
}
}
cout<<ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long cnt[10];
long long ans = 0;
long long W;
void dfs(long long id, long long temp) {
if (id == 9) {
ans = max(ans, temp);
return;
}
long long down = min(cnt[id], (W - temp) / id);
long long up = 0;
up = max((long long)0, down - 7);
for (; up <= down; up++) {
dfs(id + 1, temp + id * up);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> W;
for (int i = 1; i <= 8; i++) cin >> cnt[i];
dfs(1, 0);
cout << ans;
}
| 5 |
#include <iostream>
#include <set>
#include <map>
#include <cstring>
#include <string>
#include <cstdlib>
#include <stack>
using namespace std;
bool isop(const string &s) {
return s == "+" || s == "*" || s == "-" || s == "/";
}
int main() {
map<string, set<int> > idx;
int n,m,lb,ub;
string name;
cin>>m;
for (int i=0; i<m; ++i) {
cin>>name>>lb>>ub;
set<int> s;
for (int j=lb; j<=ub; ++j) s.insert(j);
idx[name] = s;
}
cin>>n;
stack<set<int> > st;
string exp;
bool error = false;
for (int i=0; i<n; ++i) {
cin>>exp;
if (error) continue;
if (isop(exp)) {
if (st.size() < 2) {
error = true;
continue;
}
set<int> right = st.top(); st.pop();
set<int> left = st.top(); st.pop();
set<int> v;
for (set<int>::iterator l=left.begin(); l!=left.end(); ++l) {
for (set<int>::iterator r=right.begin(); r!=right.end(); ++r) {
if (exp == "+") v.insert((*l+*r)%256);
if (exp == "-") v.insert((*l-*r+256)%256);
if (exp == "*") v.insert(((*l) * (*r))%256);
if (exp == "/") {
if (*r == 0) error = true;
else v.insert(((*l)/(*r))%256);
}
}
}
st.push(v);
} else if (idx.find(exp) != idx.end()) {
st.push(idx[exp]);
} else {
set<int> v; v.insert(atoi(exp.c_str()));
st.push(v);
}
}
if (error) cout<<"error"<<endl;
else cout<<"correct"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
if (x % 5 == 0)
cout << x / 5;
else
cout << x / 5 + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
enum { N = 1010 };
const int MOD = 1e9 + 7;
int c[N][N];
int binom(int n, int m) {
if (m == n || m == 0) return 1;
if (n == 0) return 0;
if (c[n][m] != -1) return c[n][m];
return c[n][m] = (binom(n - 1, m - 1) + binom(n - 1, m)) % MOD;
}
int main() {
int n, m, k;
memset(c, -1, sizeof(c));
scanf("%d %d %d", &n, &m, &k);
long long val = binom(n - 1, 2 * k);
val *= binom(m - 1, 2 * k);
printf("%d\n", (int)(val % MOD));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
string pat, s[(int)5e5 + 100];
vector<int> ret, adj[(int)5e5 + 100];
int nxt[(int)5e5 + 100][26];
int m;
void preffixFunc() {
ret.resize(pat.size(), 0);
for (int i = 1, k = 0; i < pat.size(); i++) {
while (k && pat[i] != pat[k]) k = ret[k - 1];
if (pat[i] == pat[k]) k++;
ret[i] = k;
}
}
long long ans = 0;
void dfs(int u = 0, int p = -1, int oldK = 0) {
for (auto x : adj[u])
if (x != p) {
int k = oldK;
for (int i = 0; i < s[x].size(); i++) {
k = nxt[k][s[x][i] - 'a'];
if (k == m) ans++, k = ret[k - 1];
}
dfs(x, u, k);
}
}
char c[1000100];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int par;
scanf("%d", &par);
scanf("%s", &c);
s[i] = string(c);
adj[par - 1].push_back(i);
}
scanf("%s", &c);
pat = string(c);
m = pat.size();
preffixFunc();
for (int i = 0; i < pat.size(); i++)
for (int j = 0; j < 26; j++)
nxt[i][j] = (pat[i] - 'a' == j ? i + 1 : (i ? nxt[ret[i - 1]][j] : 0));
dfs();
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e2 + 2;
int n;
int x[MAX_N];
int y[MAX_N];
int z[MAX_N];
double calc(double X, double Y, double Z) {
double dis = 0;
for (int i = 0; i < n; i++)
dis = max(dis, sqrt((X - x[i]) * (X - x[i]) + (Y - y[i]) * (Y - y[i]) +
(Z - z[i]) * (Z - z[i])));
return dis;
}
double ts3(double X, double Y) {
double s = -1e4 - 4, e = 1e4 + 4;
for (int i = 0; i < 55; i++) {
double mid1 = s * 0.55 + e * 0.45;
double mid2 = s * 0.45 + e * 0.55;
if (calc(X, Y, mid1) < calc(X, Y, mid2))
e = mid2;
else
s = mid1;
}
return s;
}
double ts2(double X) {
double s = -1e4 - 4, e = 1e4 + 4;
for (int i = 0; i < 55; i++) {
double mid1 = s * 0.55 + e * 0.45;
double mid2 = s * 0.45 + e * 0.55;
if (calc(X, mid1, ts3(X, mid1)) < calc(X, mid2, ts3(X, mid2)))
e = mid2;
else
s = mid1;
}
return s;
}
double ts1() {
double s = -1e4 - 4, e = 1e4 + 4;
for (int i = 0; i < 55; i++) {
double mid1 = s * 0.55 + e * 0.45;
double mid2 = s * 0.45 + e * 0.55;
if (calc(mid1, ts2(mid1), ts3(mid1, ts2(mid1))) <
calc(mid2, ts2(mid2), ts3(mid2, ts2(mid2))))
e = mid2;
else
s = mid1;
}
return s;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i] >> z[i];
double Xans = ts1();
double Yans = ts2(Xans);
double Zans = ts3(Xans, Yans);
int tmp = 1;
for (int i = 0; i < 100000; i++) tmp = (tmp * i & tmp - i & i ^ (tmp - i));
cerr << tmp << "\n";
cout << fixed << Xans << " " << Yans << " " << Zans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
int a[N];
double c[N][N], f[N][N][N];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) cin >> a[i];
for (int i = 0; i <= n; ++i) c[i][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
f[0][0][0] = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
for (int l = 0; l <= j; ++l) {
for (int p = a[i] * (l - 1) + 1; p <= a[i] * l && p <= j; ++p) {
for (int k = 0; k <= l; ++k) {
f[i][j][l] += c[n - (j - p)][p] * f[i - 1][j - p][k];
}
}
for (int k = 0; k <= a[i] * (l - 1) && k <= j; ++k)
f[i][j][l] += c[n - (j - k)][k] * f[i - 1][j - k][l];
}
}
}
double sum = 0, val = 0;
for (int i = 0; i <= n; ++i) sum += f[m][n][i], val += f[m][n][i] * i;
printf("%.20lf\n", val / sum);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, W[1050], V[1050];
int f[1050], g[1050];
bool vis[1050];
vector<int> vec;
struct edge {
int to, nex;
} e[200050];
int head[1050], ecnt;
inline void addedge(int u, int v) {
e[ecnt] = (edge){v, head[u]}, head[u] = ecnt++;
e[ecnt] = (edge){u, head[v]}, head[v] = ecnt++;
}
void DFS(int u) {
vis[u] = 1, vec.push_back(u);
for (int i = head[u]; ~i; i = e[i].nex) {
int v = e[i].to;
if (vis[v]) continue;
DFS(v);
}
}
void DP() {
int sumw = 0, sumv = 0;
for (int i = 0; i <= K; i++) g[i] = f[i];
for (unsigned int i = 0; i < vec.size(); i++) {
int now = vec[i];
sumw += W[now], sumv += V[now];
for (int j = K; j >= W[now]; j--) {
g[j] = max(g[j], f[j - W[now]] + V[now]);
}
}
for (int i = K; i >= sumw; i--) {
f[i] = max(f[i], f[i - sumw] + sumv);
}
for (int i = 0; i <= K; i++) f[i] = max(f[i], g[i]);
}
int main() {
scanf("%d%d%d", &N, &M, &K);
memset(head, -1, sizeof(head));
for (int i = 1; i <= N; i++) scanf("%d", &W[i]);
for (int i = 1; i <= N; i++) scanf("%d", &V[i]);
for (int i = 1, u, v; i <= M; i++) {
scanf("%d%d", &u, &v), addedge(u, v);
}
for (int i = 1; i <= N; i++)
if (!vis[i]) {
vec.clear(), DFS(i), DP();
}
return printf("%d\n", f[K]), 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace LYYY {
int read() {
int s = 0;
char c = getchar();
int f = 1;
while (c < 48 || c > 57) {
if (c == 45) f = -1;
c = getchar();
}
while (c >= 48 && c <= 57) s = (s << 3) + (s << 1) + (c ^ 48), c = getchar();
return s * f;
}
void write(int x) {
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
void W(int x) {
if (x < 0) x = -x, putchar(45);
write(x);
}
} // namespace LYYY
using namespace LYYY;
const int maxn = 111111;
struct hhh {
int Id, ll, rr;
} Q[2][maxn];
pair<int, int> RST[2][maxn];
int N, M, K, cnt[2], tot[2];
bool cmp(const hhh &x, const hhh &y) {
return x.Id == y.Id ? x.ll < y.ll : x.Id < y.Id;
}
int Get(int x) {
for (int i = 30; ~i; --i)
if (x >= (1 << i)) return 1 << i;
return -1;
}
int fnd0() {
int lst = 0;
for (int i = 1; i <= cnt[0]; ++i)
if (Q[0][i].Id && Q[0][i].Id < N) {
if (Q[0][i].Id != lst) {
if (Q[0][i].Id != lst + 1) return lst + 1;
lst = Q[0][i].Id;
}
}
if (lst + 1 < N) return lst + 1;
return 0;
}
int fnd1() {
int lst = 0;
for (int i = 1; i <= cnt[1]; ++i)
if (Q[1][i].Id && Q[1][i].Id < M) {
if (Q[1][i].Id != lst) {
if (Q[1][i].Id != lst + 1) return lst + 1;
lst = Q[1][i].Id;
}
}
if (lst + 1 < M) return lst + 1;
return 0;
}
int main() {
N = read(), M = read(), K = read();
for (int i = 1; i <= K; ++i) {
int a = read(), b = read(), c = read(), d = read();
if (a == c)
Q[0][++cnt[0]] = (hhh){a, min(b, d), max(b, d)};
else
Q[1][++cnt[1]] = (hhh){b, min(a, c), max(a, c)};
}
Q[0][cnt[0] + 1].Id = Q[1][cnt[1] + 1].Id = -1;
sort(Q[0] + 1, Q[0] + 1 + cnt[0], cmp);
sort(Q[1] + 1, Q[1] + 1 + cnt[1], cmp);
int ans = 0;
if (M % 2 == 0) ans ^= N;
if (N % 2 == 0) ans ^= M;
for (int i = 1, Mx = -1, rst = M, Mn = -1; i <= cnt[0]; ++i)
if (Q[0][i].Id && Q[0][i].Id < N) {
int id = Q[0][i].Id, l = Q[0][i].ll, r = Q[0][i].rr;
if (l > Mx) {
rst -= Mx - Mn;
Mx = r, Mn = l;
} else
Mx = max(Mx, r);
if (id != Q[0][i + 1].Id) {
RST[0][++tot[0]] = make_pair(i, rst -= Mx - Mn);
ans ^= M ^ rst;
Mx = -1, Mn = -1, rst = M;
}
}
for (int i = 1, Mx = -1, rst = N, Mn = -1; i <= cnt[1]; ++i)
if (Q[1][i].Id && Q[1][i].Id < M) {
int id = Q[1][i].Id, l = Q[1][i].ll, r = Q[1][i].rr;
if (l > Mx) {
rst -= Mx - Mn;
Mx = r, Mn = l;
} else
Mx = max(Mx, r);
if (id != Q[1][i + 1].Id) {
RST[1][++tot[1]] = make_pair(i, rst -= Mx - Mn);
ans ^= N ^ rst;
Mx = -1, Mn = -1, rst = N;
}
}
if (!ans) {
puts("SECOND");
return 0;
}
puts("FIRST");
int op = Get(ans), op1 = fnd0(), op2 = fnd1();
if (op2 && (op & N)) {
op = N - (N ^ ans);
printf("0 %d %d %d", op2, op, op2);
return 0;
}
if (op1 && (op & M)) {
op = M - (M ^ ans);
printf("%d 0 %d %d", op1, op1, op);
return 0;
}
int flg = 0;
for (int i = 1; i <= tot[0]; ++i)
if (RST[0][i].second & op) {
op = i;
flg = 1;
break;
}
if (!flg) {
for (int i = 1; i <= tot[1]; ++i)
if (RST[1][i].second & op) {
op = i;
flg = 2;
break;
}
}
--flg;
ans = RST[flg][op].second - (RST[flg][op].second ^ ans);
op = RST[flg][op].first;
int opl = op;
for (int i = op - 1; i; --i)
if (Q[flg][i].Id == Q[flg][op].Id) opl = i;
int R = 0, r = 0;
for (int i = opl; i <= op; ++i) {
if (Q[flg][i].ll > r) {
int uuu = min(Q[flg][i].ll - r, ans);
ans -= uuu;
R = r + uuu;
if (!ans) break;
r = Q[flg][i].rr;
} else
r = max(r, Q[flg][i].rr);
}
if (ans) R = r + ans;
if (flg)
printf("0 %d %d %d", Q[flg][op].Id, R, Q[flg][op].Id);
else
printf("%d 0 %d %d", Q[flg][op].Id, Q[flg][op].Id, R);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2000 + 5, K = 21, mod = 1000000007, MOD = 1000000007;
vector<long long> adj[N], vis(N), a(N), cnt(N);
long long d, n;
long long dfs(long long v, long long par, long long init) {
if (a[v] == a[init] && v != init && cnt[v]) return 0;
long long s = 1;
for (long long u : adj[v]) {
if (u == par) continue;
if (a[init] <= a[u] && a[u] <= a[init] + d) {
s *= (1 + dfs(u, v, init));
s %= mod;
}
}
return s % mod;
}
void solve() {
cin >> d >> n;
long long x, y;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
queue<long long> q;
q.push(1);
vis[1] = 1;
long long ans = 0;
while (!q.empty()) {
long long v = q.front();
q.pop();
long long t = dfs(v, 0, v);
ans += t;
ans %= mod;
cnt[v] = 1;
for (long long u : adj[v]) {
if (!vis[u]) {
vis[u] = 1;
q.push(u);
}
}
}
cout << ans << endl;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long TESTS = 1;
while (TESTS--) {
solve();
}
return 0;
}
| 4 |
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define N 105
#define eps 1e-8
#define INF 1e30
inline double sqr(double x) {
return x * x;
}
int n, m;
double a[N][N], b[N][N], d[N][N];
double gao(int p, int q) {
double s1 = 0, s2 = 0;
for (int i = 1; i <= m; ++i) {
s1 += a[p][i] * a[q][i];
s2 += sqr(a[q][i]);
}
if (abs(s2) < eps) {
double s = 0;
for (int i = 1; i <= m; ++i)
s += sqr(a[p][i]);
return s;
}
double k = s1 / s2;
double ret = 0;
for (int i = 1; i <= m; ++i)
ret += sqr(k * a[q][i] - a[p][i]);
return ret;
}
double f[N];
bool vis[N];
double g[N][N];
int pre[N];
bool del[N], vst[N];
double solve(int v) {
double res = 0;
int num = n;
memset(del, false, sizeof(del));
while(1) {
int i;
//æ´æ°preæ°ç»
for (i = 1; i <= n; ++i) {
if (del[i] || i == v) continue;
pre[i] = i;
g[i][i] = INF;
for (int j = 1; j <= n; ++j) {
if (del[j]) continue;
if (g[j][i] < g[pre[i]][i])
pre[i] = j;
}
}
for (i = 1; i <= n; ++i) {
//æ¾ç¯
if (del[i] || i == v) continue;
int j = i;
memset(vst, 0, sizeof(vst));
while (!vst[j] && j != v) {
vst[j] = true;
j = pre[j];
}
if (j == v) continue;
i = j;
//æ´æ°resï¼æåç¯ç¼©ç¹
res += g[pre[i]][i];
for(j = pre[i]; j != i; j = pre[j]) {
res += g[pre[j]][j];
del[j] = true;
}
for(j = 1; j <= n; ++j) {
if(del[j]) continue;
if(g[j][i] != INF)
g[j][i] -= g[pre[i]][i];
}
//æ´æ°ç¼©ç¹ä»¥åçæåç¯åå
¶ä»ç¹çè¾¹æ
for(j = pre[i]; j != i; j = pre[j]) {
for(int k = 1; k <= n; ++k) {
if(del[k])continue;
g[i][k] = min(g[i][k], g[j][k]);
if(g[k][j] != INF)
g[k][i] = min(g[k][i], g[k][j] - g[pre[j]][j]);
}
}
//å®æ缩ç¹
for(j = pre[i]; j != i; j = pre[j]) {
del[j] = true;
}
break;
}
//ä¸åå¨æåç¯æ¶ï¼åæ¢å¾ªç¯ï¼å¾åºresæç»å¼
if(i > n) {
for(int i = 1; i <= n; ++i) {
if(del[i] || i == v) continue;
res += g[pre[i]][i];
}
break;
}
}
return res;
}
int main() {
scanf("%d %d", &m, &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
scanf("%lf", &a[i][j]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
d[i][j] = gao(j, i);
double ans = INF;/*
for (int i = 1; i <= n; ++i, puts(""))
for (int j = 1; j <= n; ++j)
printf(" %.3f", d[i][j]);*/
for (int i = 1; i <= n; ++i) {
double s = 0;
for (int j = 1; j <= m; ++j)
s += sqr(a[i][j]);
for (int j = 1; j <= n; ++j)
memcpy(g[j], d[j], sizeof(d[j]));
ans = min(ans, s + solve(i));
}
printf("%.8f\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, sum;
string s;
char a, b;
cin >> s;
cin >> n;
sum = 0;
while (n--) {
cin >> a >> b;
x = 0, y = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == a)
x++;
else if (s[i] == b)
y++;
else {
sum += min(x, y);
x = 0;
y = 0;
}
}
sum += min(x, y);
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[30001][505];
long long int a[30001];
int last, offset;
long long int dpfunc(long long int curr, long long int len) {
if (curr > last) return 0;
if (dp[curr][len - offset] != -1) return dp[curr][len - offset];
long long int ans = 0;
if (len - 1 > 0) ans = max(ans, a[curr] + dpfunc(curr + len - 1, len - 1));
if (len > 0) ans = max(ans, a[curr] + dpfunc(curr + len, len));
if (len + 1 > 0) ans = max(ans, a[curr] + dpfunc(curr + len + 1, len + 1));
return dp[curr][len - offset] = ans;
}
int main() {
int N, i, j, k, d;
cin >> N >> d;
for (i = 1; i <= N; i++) {
int x;
cin >> x;
if (i == N) last = x;
a[x]++;
}
offset = d - 245;
memset(dp, -1, sizeof(dp));
long long int ans = dpfunc(d, d);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double X, Y;
void Input() { scanf("%lf %lf", &X, &Y); }
void Print() { printf("x=%10.3lf y=%10.3lf\n", X, Y); }
double Dist(Point p) {
return sqrt(((X - p.X) * (X - p.X)) + ((Y - p.Y) * (Y - p.Y)));
}
};
struct Line {
double A, B, C;
void Create(Point a, Point b) {
A = b.Y - a.Y, B = a.X - b.X, C = -A * a.X - B * a.Y;
}
double Dist(Point p) {
return fabs((A * p.X + B * p.Y + C) / sqrt(A * A + B * B));
}
void Print() { printf("A=%10.3lf B=%10.3lf C=%10.3lf\n", A, B, C); }
};
const int N = 1024;
const int K = 21;
const int M = 100000;
const int INF = 2000000000;
int n, m, k, l, p;
bool ok;
int a, b;
char s[N][N];
void PrintData(int par = 0);
void Input();
void Output();
void Main();
void Init();
int Find(char* s);
int main() {
Init();
Input();
Main();
Output();
return 0;
}
void Init() { n = 0, m = 0, k = 0; }
void Main() {
s[0][0] = '+';
p = 1;
if (k == 0) return;
p = 1;
for (int i = 0; i < k; i++, p += p) {
for (int j = 0; j < p; j++) strcpy(s[j + p], s[j]);
for (int l = 0; l < p; l++) s[0][l + p] = '+';
for (int l = 0; l < p; l++) s[p][l + p] = '*';
for (int j = 1; j < p; j++) {
for (int l = 0; l < p; l++) s[j][l + p] = s[j][l];
for (int l = 0, ll = p - 1; l < p; l++, ll--)
s[j + p][l + p] = (s[j + p][l] == '*' ? '+' : '*');
}
}
}
void Input() { scanf("%d", &k); }
void Output() {
for (int i = 0; i < p; i++) printf("%s\n", s[i]);
}
void PrintData(int par) {
if (par == 0) {
} else {
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, i, j;
scanf("%d", &n);
char str[n + 1];
scanf("%s", str);
if (n < 3) {
printf("%s\n", str);
return 0;
}
for (i = 0; i < n - 1; i++) {
if (i < n - 2 && str[i] == 'o' && str[i + 1] == 'g' && str[i + 2] == 'o') {
printf("***");
str[i] = str[i + 1] = str[i + 2] = '*';
i += 2;
} else if (i > 0 && str[i - 1] == '*' && str[i] == 'g' &&
str[i + 1] == 'o') {
str[i] = str[i + 1] = '*';
i++;
} else {
printf("%c", str[i]);
}
if (i == n - 1) {
printf("\n");
return 0;
}
}
printf("%c\n", str[n - 1]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void CyBerForCe() {
string s;
cin >> s;
long long l = s.length();
map<char, long long> mp;
for (auto i : s) mp[i]++;
long long e = 0, o = 0;
for (auto i : mp) {
if (i.second % 2 == 0)
e++;
else
o++;
}
if (o <= 1)
cout << "First\n";
else {
if ((o - 1) % 2 == 0)
cout << "First\n";
else
cout << "Second\n";
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
CyBerForCe();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int n;
vector<int> to[100005];
vector<int> dist;
void dfs(int a, int d = 0, int p = -1) {
dist[a] = d;
for (auto& c : to[a]) {
if (c == p) continue;
dfs(c, d + 1, a);
}
}
vector<int> makedist(int a) {
dist = vector<int>(n);
dfs(a);
return dist;
}
int main() {
cin >> n;
int u, v;
cin >> u >> v;
u--; v--;
rep(i, n - 1) {
int a, b; cin >> a >> b;
a--; b--;
to[a].emplace_back(b);
to[b].emplace_back(a);
}
vector<int> distT = makedist(u);
vector<int> distA = makedist(v);
int ans = 0;
rep(i, n) {
if (distT[i] < distA[i]) ans = max(ans, distA[i]);
}
cout << ans - 1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
for (int i = 0; i < T; i++) {
int N, q;
cin >> N >> q;
vector<int> X;
for (int j = 0; j < N; j++) {
int x;
cin >> x;
X.push_back(x);
}
long long ans = 0;
if (N == 1) {
ans += X[0];
cout << ans << "\n";
} else {
int ind = 0;
while (ind < N - 1) {
while (ind < N - 1 && X[ind + 1] >= X[ind]) {
ind++;
}
ans += X[ind];
while (ind < N - 1 && X[ind + 1] <= X[ind]) {
ind++;
}
if (ind != N - 1) {
ans -= X[ind];
}
}
cout << ans << "\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 0x3f3f3f;
int n, m;
int main() {
vector<int> v, num;
int n;
scanf("%d", &n);
int a[n + 10];
num.push_back(n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
v.push_back(-1);
for (int i = n - 1; i >= 1; i--) {
if (a[i] > a[num.back()]) {
int R = num.size() - 1, L = 0;
int mid = (R + L + 1) / 2;
while (R - L > 0) {
mid = (R + L) / 2;
if (a[i] > a[num[mid]])
R = mid;
else
L = mid + 1;
}
v.push_back(num[R] - i - 1);
} else {
v.push_back(-1);
num.push_back(i);
}
}
for (int i = n - 1; i >= 0; i--) printf("%d ", v[i]);
printf("\n");
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
char c[1000000];
int main (){
int t;
cin >> t;
while(t--){
int n;
cin >> n;
for (int i=0;i<n;i++){
cin >> c[i];
}
bool l = 0;
for (int i=0;i<=4;i++){
for (int j=0;j<=4;j++){
if (n-i-j>=0){
if (i+j==4){
int q = 1000;
int x = 0;
for (int z=0;z<=i-1;z++){
x+=(c[z]-'0')*q;
q/=10;
}
for (int z=j;z>=1;z--){
x+=(c[n-z]-'0')*q;
q/=10;
}
if (x == 2020){
l = 1;
}
}
}
}
}
cout << ((l==0)? "NO":"YES") << endl;
}
return 0;
}
| 2 |
#include<iostream>[
using namespace std;
int main(){
int n;
while(cin>>n,n){
int a[5000];
for(int i=0;i<n;i++)cin>>a[i];
int mxm=-1000001;
for(int i=0;i<n;i++){
int b=0;
for(int j=i;j<n;j++){
b+=a[j];
mxm=max(mxm,b);
}
}
cout<<mxm<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using pairll = pair<ll, ll>;
int main() {
ll q, a, b, num, cnt, turns;
string s;
bool win;
bool great;
cin >> q;
while (q--) {
turns = 0;
great = 0;
cnt = 0;
win = 1;
cin >> a >> b;
cin >> s;
for (ll i = 0; i < s.length(); i++) {
if (s[i] == '.') {
num = 0;
while (i < s.length() && s[i] == '.') {
num++;
i++;
}
i--;
if (a > num && b <= num) {
win = 0;
} else if (a <= num && 2 * b + a - 2 >= num) {
turns++;
if (num >= 2 * a) {
great = 1;
}
} else if (2 * b + a - 1 <= num && 2 * a > num) {
win = 0;
} else if (2 * a <= num && num < a + 3 * b - 1) {
turns = turns + 2;
if (num >= 3 * a) {
great = 1;
}
} else if (a + 3 * b - 1 <= num && num < 3 * a) {
win = 0;
} else if (3 * a <= num && num < a + 4 * b - 1) {
turns = turns + 3;
} else if (a + 4 * b - 1 <= num) {
win = 0;
}
if (2 * b <= num) {
cnt++;
if (cnt >= 2) {
win = 0;
}
}
}
}
if (turns % 2 == 0 && !great) {
win = 0;
}
if (!win) {
puts("NO");
} else {
puts("YES");
}
}
}
| 5 |
#include <iostream>
using namespace std;
int main(){
long long n;
cin >> n;
cout << n * (n - 1) / 2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
register int n = 0;
char c = getchar();
bool b = 0;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
b = 1;
}
}
for (; isdigit(c); c = getchar()) {
n = 10 * n + (c - 48);
}
if (b) {
return -n;
}
return n;
}
inline void emp() { printf("\n"); }
int main() {
uint64_t n = read(), m = read();
uint64_t fact[n + 2];
uint64_t total = 0;
fact[0] = 1;
for (int i = 1; i <= n; ++i) {
fact[i] = uint64_t(fact[i - 1] * i) % m;
}
uint64_t temp;
for (uint64_t i = 1; i <= n; ++i) {
temp = uint64_t(fact[i] * fact[n - i]) % m;
temp = uint64_t(temp * (n - i + 1)) % m;
temp = uint64_t(temp * (n - i + 1)) % m;
total = (total + temp) % m;
}
printf("%d\n", total);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum = 0, n;
int arr[10001];
double sm = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sm += arr[i];
}
sm = sm / n;
sum = sm;
if (sum == sm) {
int *mi = min_element(arr, arr + n);
int *ma = max_element(arr, arr + n);
int dif = *ma - sum;
int a, j;
if (*mi == *ma) {
cout << "Exemplary pages.";
return 0;
}
for (int i = 0; i < n; i++) {
if (arr[i] == *ma) a = i + 1;
if (arr[i] == *mi) j = i + 1;
}
*ma -= dif;
*mi += dif;
if (*min_element(arr, arr + n) == *max_element(arr, arr + n))
cout << dif << " ml. from cup #" << j << " to cup #" << a << ".";
else
cout << "Unrecoverable configuration.";
} else
cout << "Unrecoverable configuration." << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define pb push_back
#define sz size()
#define clr clear()
#define rep(i,a) for(int i=0;i<(int)(a);i++)
using namespace std;
typedef long double D;
typedef vector<D> vec;
typedef vector<vec> mat;
const double EPS = 1e-3;
struct matrix{
mat m;
int r,c;
matrix(void){r=c=0;m.clr;}
matrix(mat a){
r = a.sz;c = a[0].sz;
m.resize(r);
rep(i,r)m[i].resize(c);
rep(i,r)rep(j,c)m[i][j] = a[i][j];
}
};
vec gauss_jordan(const mat& A, const vec& b){
int n = A.size();
mat B(n,vec(n+1));
rep(i,n)rep(j,n)B[i][j] = A[i][j];
rep(i,n)B[i][n] = b[i];
rep(i,n){
int p = i;
for(int j=i;j<n;j++){
if(abs(B[j][i]) > abs(B[p][i]))p = j;
}
swap(B[i],B[p]);
if(abs(B[i][i]) < EPS)return vec();
for(int j=i+1;j<=n;j++)B[i][j] /= B[i][i];
rep(j,n){
if(i != j){
for(int k=i+1;k<=n;k++)B[j][k] -= B[j][i] * B[i][k];
}
}
}
vec x(n);
rep(i,n)x[i] = B[i][n];
return x;
}
int main(){
int d;
while(cin >> d,d){
vec v(d+3);
rep(i,d+3)cin >> v[i];
int ans = 0;
rep(i,d+3){
rep(j,d+3){
if(i==j)continue;
mat A; vec b;
rep(k,d+3){
if(i==k || j==k)continue;
vec tmp(d+1); D pow = 1;
rep(l,d+1){
tmp[l] = pow;
pow *= k;
}
A.push_back(tmp);
b.push_back(v[k]);
}
vec x = gauss_jordan(A,b);
D val1 = 0, val2 = 0;
D pow1 = 1, pow2 = 1;
rep(k,x.size()){
val1 += pow1 * x[k]; pow1 *= i;
val2 += pow2 * x[k]; pow2 *= j;
}
if(abs(val1-v[i])<EPS && abs(val2-v[j])+EPS>1.0){
ans = j;
}else if(abs(val1-v[i])+EPS>1.0 && abs(val2-v[j])<EPS){
ans = i;
}
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 5;
int a[N], ans[N];
struct node {
int l, r, v;
} s[N << 2];
void build(int l, int r, int i) {
int mid = l + r >> 1;
s[i].l = l;
s[i].r = r;
if (l == r) {
s[i].v = a[l];
return;
}
build(l, mid, i << 1);
build(mid + 1, r, i << 1 | 1);
s[i].v = max(s[i << 1].v, s[i << 1 | 1].v);
}
int query(int l, int r, int i, int goal, int pos) {
if (s[i].l > pos) return -1;
if (s[i].v <= goal) return -1;
int mid = s[i].l + s[i].r >> 1;
if (s[i].l == s[i].r) {
if (goal < s[i].v) return s[i].l;
return -1;
}
int ans = -1;
if (r > mid) {
ans = max(ans, query(l, r, i << 1 | 1, goal, pos));
}
if (ans != -1) return ans;
if (l <= mid) {
ans = max(ans, query(l, r, i << 1, goal, pos));
}
return ans;
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; ++i) scanf("%d", &a[i + 1]);
for (int i = n; i < 3 * n; ++i) a[i + 1] = a[i + 1 - n];
build(1, 3 * n, 1);
ans[0] = 1;
for (int i = 1; i < 3 * n + 1; ++i) {
int x = query(1, 3 * n, 1, 2 * a[i], i - 1) + 1;
ans[i] = max(ans[i - 1], x);
}
for (int i = 1; i < n + 1; ++i) {
int l = 1, r = 3 * n;
while (l <= r) {
int mid = l + r >> 1;
if (ans[mid] <= i)
l = mid + 1;
else
r = mid - 1;
}
if (l > 3 * n)
printf("-1 ");
else
printf("%d ", l - i);
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5, oo = 1e9;
long long n, k, a[maxn], b[maxn], DP[maxn + 1][2];
void input() {
cin >> n >> k;
for (long long _x = n, i = 0; i < _x; ++i) cin >> a[i];
for (long long _x = n, i = 0; i < _x; ++i) cin >> b[i];
}
long long get(long long pa, long long pb, long long a, long long b) {
long long ans = oo;
if (pa <= k) {
long long sum = pa + a;
long long cnt = sum / k - (sum % k == 0);
if (b == cnt)
ans = min(ans, sum - cnt * k);
else if (b > cnt && b <= a * k)
ans = min(ans, 1ll);
}
if (pb <= k) {
long long cnt = a / k - (a % k == 0);
if (b == cnt)
ans = min(ans, a - cnt * k);
else if (b > cnt && b <= (a - 1) * k + (k - pb))
ans = min(ans, 1ll);
}
return ans;
}
void solve() {
for (long long _x = n, i = 0; i < _x; ++i) {
DP[i + 1][0] = get(DP[i][0], DP[i][1], a[i], b[i]);
DP[i + 1][1] = get(DP[i][1], DP[i][0], b[i], a[i]);
}
puts(min(DP[n][0], DP[n][1]) <= k ? "YES" : "NO");
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
input();
solve();
return 0;
}
| 6 |
#include <cstdio>
using namespace std;
int W, H;
const int SIZE = 20;
char f[SIZE + 1][SIZE + 1];
bool c[SIZE][SIZE];
int dfs(int x, int y){
if(x < 0 || y < 0 || x >= W || y >= H) return 0;
if(c[y][x] || f[y][x] == '#') return 0;
c[y][x] = true;
return 1 + dfs(x + 1, y) + dfs(x, y + 1) + dfs(x - 1, y) + dfs(x, y - 1);
}
int main(){
int sx, sy;
while(true){
scanf("%d%d", &W, &H);
if(H == 0 && W == 0) break;
for(int i = 0; i < H; i++){
scanf("%s", f[i]);
}
for(int y = 0; y < H; y++){
for(int x = 0; x < W; x++){
c[y][x] = false;
if(f[y][x] == '@'){
sx = x; sy = y;
}
}
}
printf("%d\n", dfs(sx, sy));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr1[1005], arr2[1005];
string s1, s2;
cin >> s1 >> s2;
for (int i = 1; i <= n; i++) arr1[i] = s1[i - 1] - '0';
int ans = 0;
for (int i = 1; i <= n; i++) {
arr2[i] = s2[i - 1] - '0';
ans += min(abs(arr2[i] - arr1[i]), 10 - abs(arr2[i] - arr1[i]));
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<string> lft, rgt;
void gen(string z, int ind, int n, bool vis[], string f, vector<string> <) {
int i;
if (ind == n) {
if (z.compare(f) <= 0) {
lt.push_back(z);
}
return;
}
if (ind < n) {
for (i = 0; i < 7; i++) {
if (!vis[i]) {
vis[i] = 1;
char fd = i + '0';
gen(z + fd, ind + 1, n, vis, f, lt);
vis[i] = 0;
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
int temp = n - 1, c = 0;
string s;
if (temp == 0) {
s = "0";
c = 1;
}
while (temp > 0) {
s += (temp % 7 + '0');
temp /= 7;
c++;
}
if (c <= 8) {
reverse(s.begin(), s.end());
int l = 0;
temp = m - 1;
string d;
if (temp == 0) {
d = "0";
l = 1;
}
while (temp > 0) {
d += (temp % 7 + '0');
temp /= 7;
l++;
}
if (c + l <= 8) {
reverse(d.begin(), d.end());
bool vis[10] = {0};
string z;
gen(z, 0, c, vis, s, lft);
bool flg[10] = {0};
string p;
gen(p, 0, l, flg, d, rgt);
int k;
long long ans = 0;
vector<string>::iterator i, j;
for (i = lft.begin(); i != lft.end(); i++) {
for (j = rgt.begin(); j != rgt.end(); j++) {
string mp = *i;
bool hel[10] = {0};
for (k = 0; k < mp.length(); k++) {
hel[mp[k] - '0'] = 1;
}
mp = *j;
for (k = 0; k < mp.length(); k++) {
if (hel[mp[k] - '0'] == 1)
break;
else
hel[mp[k] - '0'] = 1;
}
if (k == mp.length()) ans++;
}
}
cout << ans << endl;
} else
cout << "0\n";
} else
cout << "0\n";
return 0;
}
| 1 |
#include <vector>
#include <iostream>
#include <set>
#include <cstdio>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <ctime>
#include <algorithm>
#include <algorithm>
#include <limits>
#include <map>
using namespace std;
#include <algorithm>
//0-indexed overflow-> max:Height*MOD sum's comment out:2*MOD
template <class T, int SIZE>
struct BinaryIndexedTree {
T seg[SIZE];
inline void init() {
fill_n(seg, SIZE, 0);
}
inline void add(uint i, T x) {
while (i < SIZE) {
seg[i] += x;
i += (i+1) & ~i;
}
}
//[0, i)
inline T sum(uint i) {
T s = 0;
uint d = 1;
while (i >= d) {
i -= d;
s += seg[i];
d = (i+1) & ~i;
}
return s;
}
//[a, b)
inline T sum(uint a, uint b) {
T d = sum(b) - sum(a);
return d;
}
};
typedef long long ll;
typedef pair<int, int> P;
const int MN = 100100;
BinaryIndexedTree<int, MN> b;
int main() {
b.init();
int n, m;
cin >> n >> m;
for (int i = 1; i < MN; i++) {
if (i*2 <= m) {
b.add(max(0, i), 1);
continue;
}
if (m <= i) {
break;
}
int u = m-i;
for (int j = i; j < MN; j += i) {
b.add(max(i, j-u), 1);
b.add(max(i, j), -1);
}
}
for (int i = 1; i <= n-m+1; i++) {
printf("%d", b.sum(i)+m);
if (i < n-m+1) {
printf(" ");
} else {
printf("\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[312345], q[312345];
long long sum;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum += a[i];
}
sort(a + 1, a + n + 1);
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> q[i];
cout << sum - a[n - q[i] + 1] << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, k = 1, flag = 0;
int sum[maxn], num[maxn], num1[maxn], ans[maxn], cou[maxn], dis[maxn];
void check() {
for (int i = 1; i <= n; i++) cou[ans[i]]++;
for (int i = 1; i <= n; i++)
if (cou[ans[i]] + sum[i] != n) flag = 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &sum[i]);
num[sum[i]] = n - sum[i];
cou[sum[i]]++;
}
for (int i = 1; i <= n; i++) {
if (num[sum[i]] > cou[sum[i]]) {
printf("Impossible\n");
flag = 1;
break;
;
}
num1[sum[i]] = num[sum[i]];
}
if (flag) return 0;
dis[sum[1]] = ans[1] = 1;
for (int i = 2; i <= n; i++) {
if (dis[sum[i]] == 0) {
ans[i] = dis[sum[i]] = ++k;
} else {
if (num[sum[i]] == cou[sum[i]]) {
ans[i] = dis[sum[i]];
} else {
if (num[sum[i]] > 1) {
ans[i] = dis[sum[i]];
num[sum[i]]--;
} else {
ans[i] = dis[sum[i]] = ++k;
num[sum[i]] = num1[sum[i]];
}
}
}
}
fill(cou, cou + (n + 1), 0);
check();
if (k > n || flag)
printf("Impossible\n");
else {
printf("Possible\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 220000;
unordered_map<long long, bool> H;
bool ok = true;
int qn, r[N], b[N], deg[N], a[N], vis[N];
vector<int> adj[N], radj[N], vec[N], v;
set<pair<int, int> > cand;
void dfs(int u) {
if (!ok) return;
if (r[u] && !(r[u] > b[u])) {
ok = false;
return;
}
a[u] = (r[u] ? r[u] : b[u] + 1);
vis[u] = 1;
qn++;
for (int v : adj[u]) {
b[v] = max(b[v], a[u]);
if (!(--deg[v]) && !vis[v]) dfs(v);
}
}
int main() {
ios::sync_with_stdio(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> r[i];
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
swap(u, v);
if (H.count(1LL * u * N + v)) continue;
H[1LL * u * N + v] = true;
adj[u].push_back(v);
radj[v].push_back(u);
}
for (int i = 1; i <= n; i++) deg[i] = radj[i].size();
for (int i = 1; i <= n; i++)
if (!deg[i] && !vis[i]) dfs(i);
for (int i = 1; i <= n; i++) b[i] = a[i];
if (!ok || qn != n) return puts("-1"), 0;
for (int i = 1; i <= n; i++)
if (b[i] > k) return puts("-1"), 0;
for (int i = 1; i <= n; i++) vec[b[i]].push_back(i);
for (int i = 1; i <= n; i++) {
deg[i] = adj[i].size();
if (!deg[i] && !r[i]) cand.insert(make_pair(b[i], i));
}
for (int i = k; i >= 1; i--) {
while (!cand.empty() && cand.rbegin()->first >= i)
cand.erase(*cand.rbegin());
v.clear();
for (int j = 0; j < vec[i].size(); j++)
if (b[vec[i][j]] == i) v.push_back(vec[i][j]);
vec[i] = v;
while (vec[i].empty()) {
if (cand.empty()) break;
int x = cand.rbegin()->second;
cand.erase(*cand.rbegin());
b[x] = i;
vec[i].push_back(x);
}
if (vec[i].empty()) {
return puts("-1"), 0;
}
for (int u : vec[i])
for (int v : radj[u]) {
deg[v]--;
if (!deg[v] && !r[v]) cand.insert(make_pair(b[v], v));
}
}
for (int i = 1; i <= n; i++) cout << b[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, x = 0, y = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a >> b;
x += a;
y += b;
}
for (long long i = 0; i < n; i++) {
cin >> a >> b;
x += a;
y += b;
}
cout << x / n << ' ' << y / n << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
string str, str1, str2 = "";
long long int dist;
bool flag, flag1;
cin >> str >> str1;
dist = 0;
flag = flag1 = 0;
long long int len = str.length();
for (int i = 0; i < len; ++i) {
if (str[i] != str1[i]) dist++;
}
if (dist % 2 != 0)
cout << "impossible" << endl;
else {
for (int i = 0; i < len; ++i) {
if (str[i] == str1[i])
str2 += str[i];
else if (flag == 0) {
str2 += str[i];
flag1 = 0;
flag = 1;
} else if (flag1 == 0) {
str2 += str1[i];
flag1 = 1;
flag = 0;
}
}
cout << str2 << endl;
}
str2 = "";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m;
cin >> m;
long long low = 0LL;
long long high = 1000000000000000000LL;
long long ans = -1;
while (low <= high) {
long long mid = (low + high) / 2;
long long re = 0LL;
for (long long i = 2; i * i * i <= mid; i++) {
re += mid / (i * i * i);
}
if (re < m) {
low = mid + 1;
} else {
ans = mid;
high = mid - 1;
}
}
long long re = 0;
for (long long i = 2; i * i * i <= ans; i++) {
re += ans / (i * i * i);
}
if (re == m) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%I64d", &x);
return x;
}
int n;
long long inp[N];
struct Info {
int mx, mx_pos;
int mn, mn_pos;
} t[N * 4];
void Merge(int par, int lft, int rgt) {
if (t[rgt].mx >= t[lft].mx) {
t[par].mx = t[rgt].mx;
t[par].mx_pos = t[rgt].mx_pos;
} else {
t[par].mx = t[lft].mx;
t[par].mx_pos = t[lft].mx_pos;
}
if (t[lft].mn <= t[rgt].mn) {
t[par].mn = t[lft].mn;
t[par].mn_pos = t[lft].mn_pos;
} else {
t[par].mn = t[rgt].mn;
t[par].mn_pos = t[rgt].mn_pos;
}
}
void build(int x, int b, int e) {
if (b == e) {
t[x].mx = inp[b];
t[x].mx_pos = b;
t[x].mn = inp[b];
t[x].mn_pos = b;
return;
}
int m = (b + e) >> 1;
build(x + x, b, m);
build(x + x + 1, m + 1, e);
Merge(x, x + x, x + x + 1);
}
Info get(int x, int b, int e, int l, int r) {
if (b >= l && e <= r) return t[x];
int m = (b + e) >> 1;
if (m >= r)
return get(x + x, b, m, l, r);
else if (m < l)
return get(x + x + 1, m + 1, e, l, r);
else {
Info par, lft, rgt;
lft = get(x + x, b, m, l, r);
rgt = get(x + x + 1, m + 1, e, l, r);
if (rgt.mx >= lft.mx) {
par.mx = rgt.mx;
par.mx_pos = rgt.mx_pos;
} else {
par.mx = lft.mx;
par.mx_pos = lft.mx_pos;
}
if (lft.mn <= rgt.mn) {
par.mn = lft.mn;
par.mn_pos = lft.mn_pos;
} else {
par.mn = rgt.mn;
par.mn_pos = rgt.mn_pos;
}
return par;
}
}
long long Max_find(int l, int r) {
if (l > r) return 0;
if (l == r) return inp[l];
Info found = get(1, 1, n, l, r);
int lft = found.mx_pos - l + 1;
int rgt = r - found.mx_pos + 1;
long long ret = 1ll * lft * rgt * found.mx;
ret = ret + Max_find(l, found.mx_pos - 1) + Max_find(found.mx_pos + 1, r);
return ret;
}
long long Min_find(int l, int r) {
if (l > r) return 0;
if (l == r) return inp[l];
Info found = get(1, 1, n, l, r);
int lft = found.mn_pos - l + 1;
int rgt = r - found.mn_pos + 1;
long long ret = 1ll * lft * rgt * found.mn;
ret = ret + Min_find(l, found.mn_pos - 1) + Min_find(found.mn_pos + 1, r);
return ret;
}
int main() {
n = in();
for (int i = 1; i <= n; i++) {
inp[i] = lin();
}
build(1, 1, n);
long long ans = Max_find(1, n) - Min_find(1, n);
printf("%I64d\n", ans);
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int N = 20005;
int a[N], b[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin>>n;
for (int i=1; i<=n; i++) a[i] = i*n, b[i] = (n+1-i)*n;
for (int i=0; i<n; i++) {
int x;
cin>>x;
a[x] += i;
}
for (int i=1; i<=n; i++) cout<<a[i]<<" "; cout<<endl;
for (int i=1; i<=n; i++) cout<<b[i]<<" "; cout<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
set<int> s;
s.insert(0);
for (int i = 1; i * i <= n; i++) {
if (n / i > 0) {
s.insert(i);
s.insert(n / i);
}
}
cout << s.size() << endl;
for (set<int>::iterator i = s.begin(); i != s.end(); i++) printf("%d ", *i);
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, b, r;
cin >> y >> b >> r;
if (((y + 2) <= (b + 1)) && ((y + 2) <= r)) {
cout << (y + y + 1 + y + 2);
} else if (((b + 1) <= (y + 2)) && ((b + 1) <= r)) {
cout << (b - 1 + b + b + 1);
} else {
cout << (r - 2 + r - 1 + r);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cube[1000];
cube[0] = 1;
for (int i = 1; i < 1000; i++) {
cube[i] = cube[i - 1] + ((i + 1) * (i + 2)) / 2;
}
int n;
cin >> n;
int *p1 = lower_bound(cube, cube + 1000, n);
bool p2 = binary_search(cube, cube + 1000, n);
int ans = p2 == 1 ? p1 - cube + 1 : p1 - cube;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long INF = 1e7;
double EPS = 1e-12;
double tick() {
static clock_t oldt;
clock_t newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
long long int powP(long long int a, long long int b) {
if (b == 0) return 1 % mod;
long long int k;
k = powP(a, b / 2);
k = k * k % mod;
if (b % 2 == 0)
return k;
else
return a * k % mod;
}
bool bitSet(long long int n, long long int i) {
if ((n & (1LL << i)) != 0)
return true;
else
return false;
}
long long int findGcd(long long int a, long long int b) {
if (a == 0)
return b;
else
return findGcd(b % a, a);
}
long long int A[2000010], B[2000010];
int main() {
long long int T, i, n, m, p, j, l, e, r, b, c, k, q, a, d, w, x, y, v, z, t,
curr, prev, sum, ans, pos, val, countA, indicator;
scanf("%lld", &n);
for (long long int i = (0); i <= (n - 1); ++i) {
scanf("%lld", &k);
A[i] = k - 1;
}
a = b = 0;
ans = 0;
long long int id = 0;
for (long long int i = (0); i <= (n - 1); ++i) {
if (A[i] > i)
a++;
else
b++;
t = abs(A[i] - i);
ans += t;
if (A[i] > i)
B[t]++;
else
B[n - t]++;
}
curr = ans;
for (long long int i = (1); i <= (n - 1); ++i) {
curr += (-a + b);
curr += (A[n - i] - (n - A[n - i]));
if (curr < ans) {
ans = curr;
id = i;
}
a++;
b--;
a -= B[i];
b += B[i];
}
printf("%lld %lld\n", ans, id);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, k, i;
scanf("%lld%lld", &N, &k);
if (k > 100) {
puts("NO");
return 0;
}
for (i = 1; i <= k; ++i) {
if (N % i != i - 1) {
puts("NO");
return 0;
}
}
puts("Yes");
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(void) {
long n;
cin >> n;
vector<pair<long,long>> v(n);
for(auto &e: v) {
long x, l;
cin >> x >> l;
e = make_pair(x+l, x-l);
}
sort(v.begin(), v.end());
long r = 0;
long t = -1e18;
for(auto &e: v) {
if(t <= e.second)
r++, t = e.first;
}
cout << r << endl;
}
| 0 |
#include<cstdio>
#define RI register int
#define CI const int&
using namespace std;
const int N=5005,mod=998244353;
int a,b,c,d,f[N][N];
int main()
{
RI i,j; scanf("%d%d%d%d",&a,&b,&c,&d); f[a][b]=1;
for (i=a;i<=c;++i) for (j=b;j<=d;++j)
if (i>a&&j>b) f[i][j]=(1LL*f[i-1][j]*j%mod+1LL*f[i][j-1]*i%mod-1LL*(i-1)*(j-1)*f[i-1][j-1]%mod+mod)%mod;
else if (i>a) f[i][j]=1LL*f[i-1][j]*j%mod; else if (j>b) f[i][j]=1LL*f[i][j-1]*i%mod;
return printf("%d",f[c][d]),0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long dp[N][11];
int n;
char s[N];
long long get(int i, int d) {
if (i < 0 || i >= n) return 0;
if (dp[i][d] != -1) return dp[i][d];
long long& ret = dp[i][d];
ret = 1;
if (i + 1 >= n || s[i + 1] >= d) return ret;
d = (d + 10) % 11;
int cnt = 9 + d * (d + 1) / 2;
cnt %= 11;
ret += get(i + 1, (cnt + s[i + 1] + 1) % 11);
return ret;
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) s[i] -= '0';
memset(dp, -1, sizeof dp);
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (s[i]) ans += get(i, s[i]);
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int N = 1e5 + 7;
int n, m, k, s, arr[N], res[N][150];
struct emp {
int x, y, c;
};
vector<vector<int> > vt;
queue<emp> Q;
int main(void) {
scanf("%d %d %d %d", &n, &m, &k, &s);
vt.resize(n + 1);
for (int i = 1; i <= n; i++) {
int T;
scanf("%d", &T);
Q.push({i, 0, T});
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) res[i][j] = INF;
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
vt[x].push_back(y);
vt[y].push_back(x);
}
while (!Q.empty()) {
emp fr = Q.front();
Q.pop();
if (res[fr.x][fr.c] <= fr.y) continue;
res[fr.x][fr.c] = fr.y;
for (auto next : vt[fr.x]) Q.push({next, fr.y + 1, fr.c});
}
for (int i = 1; i <= n; i++) {
sort(res[i] + 1, res[i] + k + 1);
int ans = 0;
for (int j = 1; j <= s; j++) ans += res[i][j];
printf("%d ", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, n, x, y;
cin >> a >> b >> c >> d >> n;
if (c < d) swap(a, b), swap(c, d);
cout << max(0, n - (c - 1) * a - (d - 1) * b) << " ";
if (b * d >= n) {
cout << n / d;
return 0;
}
cout << b + (n - b * d) / c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef int bang[52][52];
int cs1, cs2, ds, na, ma, nb, mb;
char c[52][52], d[52][52];
bang a, b;
void solve() {
ds = -200000000;
for (int x = 1 - ma; x <= mb - 1; x++)
for (int y = 1 - na; y <= nb - 1; y++) {
int tong = 0;
for (int i = max(1 - x, 1); i <= min(ma, mb - x); i++)
for (int j = max(1 - y, 1); j <= min(na, nb - y); j++)
tong += a[i][j] * b[i + x][j + y];
if (tong > ds) {
cs1 = x, cs2 = y;
ds = tong;
}
}
cout << cs1 << " " << cs2;
cout << "\n";
}
int main() {
scanf("%d%d\n", &ma, &na);
for (int i = 1; i <= ma; i++) {
for (int j = 1; j <= na; j++) {
scanf("%c", &c[i][j]);
if (c[i][j] == '0')
a[i][j] = 0;
else
a[i][j] = 1;
}
scanf("%*c");
}
scanf("%d%d\n", &mb, &nb);
for (int i = 1; i <= mb; i++) {
for (int j = 1; j <= nb; j++) {
scanf("%c", &d[i][j]);
if (d[i][j] == '0')
b[i][j] = 0;
else
b[i][j] = 1;
}
scanf("%*c");
}
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename C>
void ma(C& a, C b) {
if (a < b) a = b;
}
template <typename C>
void mi(C& a, C b) {
if (a > b) a = b;
}
int n, m;
int p[200100], l[200100];
int wyn[200100];
struct prze {
int a, b;
int war;
int len() { return b - a; }
};
int all = 0;
vector<prze> s;
vector<pair<int, int> > zap[200100];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &p[i], &l[i]);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
zap[a].push_back(make_pair(b, i));
}
s.push_back({int(2e9) - 1, int(2e9), 0});
for (int i = n - 1 - 1; i >= 0; i--) {
if (p[i] + l[i] < p[i + 1]) {
all += p[i + 1] - (p[i] + l[i]);
s.push_back({p[i] + l[i], p[i + 1], all});
}
while (p[i] + l[i] >= s.back().b) {
all -= s.back().len();
s.pop_back();
}
if (p[i] + l[i] > s.back().a) {
all -= s.back().len();
s.back().a = p[i] + l[i];
all += s.back().len();
s.back().war = all;
}
for (int j = 0; j < zap[i].size(); j++) {
int pom = p[zap[i][j].first];
int po = 0, ko = s.size();
while (po + 1 != ko) {
int m = (po + ko) / 2;
if (s[m].a < pom)
ko = m;
else
po = m;
}
wyn[zap[i][j].second] = all - s[po].war;
}
}
for (int i = 0; i < m; i++) printf("%d\n", wyn[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t, n, i, j, c, k, m, x, y, f, ans;
string s;
cin >> s;
n = s.length();
if (n < 26) {
cout << "-1\n";
return 0;
}
for (i = 0; i <= n - 26; i++) {
map<long long, long long> mp;
f = 1;
for (j = i; j < 26 + i; j++) {
mp[s[j] - 'A']++;
if (s[j] != '?' && mp[s[j] - 'A'] > 1) {
f = 0;
break;
}
}
if (f) {
c = 0;
for (j = i; j < i + 26; j++) {
while (mp[c]) {
c++;
}
if (s[j] == '?') mp[c]++, s[j] = c + 'A';
}
for (i = 0; i < n; i++) {
if (s[i] == '?')
cout << "A";
else
cout << s[i];
}
return 0;
}
}
cout << "-1\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
if (n >= 2) {
if (s[0] != '?' and s[1] == '?') {
if (s[0] == 'B')
s[1] = 'R';
else
s[1] = 'B';
}
if (s[n - 1] != '?' and s[n - 2] == '?') {
if (s[n - 1] == 'B')
s[n - 2] = 'R';
else
s[n - 2] = 'B';
}
}
for (int j = 0; j < n + 2; j++) {
for (int i = 1; i < n - 1; i++) {
if (s[i] != '?') {
if (s[i + 1] == '?') {
if (s[i] == 'B')
s[i + 1] = 'R';
else
s[i + 1] = 'B';
}
if (s[i - 1] == '?') {
if (s[i] == 'B')
s[i - 1] = 'R';
else
s[i - 1] = 'B';
}
}
}
}
int i = 0;
string tt;
while (i < n) {
tt += 'B';
i++;
if (i == n) break;
tt += 'R';
i++;
}
string x(1, '?');
if (s.find(x) != string::npos) {
s = tt;
}
cout << s << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
//#define cerr if (false) cerr
#define db(x) cerr << #x << "=" << x << endl
#define db2(x, y) cerr << #x << "=" << x << "," << #y << "=" << y << endl
#define db3(x, y, z) cerr << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z << endl
#define dbv(v) cerr << #v << "="; for (auto _x : v) cerr << _x << ", "; cerr << endl
#define dba(a, n) cerr << #a << "="; for (int _i = 0; _i < (n); ++_i) cerr << a[_i] << ", "; cerr << endl
typedef long long ll;
typedef long double ld;
int main() {
int n, H, W;
scanf("%d%d%d", &n, &H, &W);
vector<pair<int, pair<int, int>>> edges(n);
for (int i = 0; i < n; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
edges[i] = {c, {a, H + b}};
}
sort(edges.begin(), edges.end());
vector<int> par(H + W), nume(H + W), siz(H + W, 1);
ll ans = 0;
iota(par.begin(), par.end(), 0);
function<int(int)> root = [&](int a) {
if (par[a] == a) return a;
return par[a] = root(par[a]);
};
for (int i = n - 1; i >= 0; --i) {
int a, b;
tie(a, b) = edges[i].second;
int pa = root(a), pb = root(b);
if (pa == pb) {
if (nume[pa] < siz[pa]) {
++nume[pa];
ans += edges[i].first;
}
continue;
}
if (nume[pa] + nume[pb] + 1 > siz[pa] + siz[pb]) continue;
siz[pb] += siz[pa];
nume[pb] += nume[pa] + 1;
ans += edges[i].first;
par[pa] = pb;
}
printf("%lld\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll n;
cin >> n;
if (n % 2 == 0) {
cout << "Mahmoud";
} else {
cout << "Ehab";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[101];
for (int i = 1; i < 101; i++) a[i] = i;
for (int i = 1; i < 101; i += 2) swap(a[i], a[i + 1]);
int n;
cin >> n;
if (n & 1)
cout << -1 << "\n";
else
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
struct SegmentTree
{
const int INF = 1 << 30;
vector< int > add;
int sz;
SegmentTree(int n)
{
sz = 1;
while(sz < n) sz <<= 1;
add.assign(2 * sz - 1, 0);
}
void update(int a, int b, int x, int k, int l, int r)
{
if(a >= r || b <= l) return;
if(a <= l && r <= b) {
add[k] += x;
return;
}
update(a, b, x, 2 * k + 1, l, (l + r) >> 1);
update(a, b, x, 2 * k + 2, (l + r) >> 1, r);
}
void rangeadd(int a, int b, int x)
{
update(a, b, x, 0, 0, sz);
}
int query(int k)
{
k += sz - 1;
int ret = add[k];
while(k > 0) {
k = (k - 1) >> 1;
ret += add[k];
}
return (ret);
}
};
int main()
{
int N, Q;
scanf("%d %d", &N, &Q);
SegmentTree tree(N);
while(Q--) {
int t;
scanf("%d", &t);
if(t == 0) {
int s, t, x;
scanf("%d %d %d", &s, &t, &x);
tree.rangeadd(--s, t, x);
} else {
int i;
scanf("%d", &i);
printf("%d\n", tree.query(--i));
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int left, right, mid, sum = 0, cup, page, data[105];
scanf("%d%d", &cup, &page);
for (int i = 0; i < cup; i++) {
scanf("%d", &data[i]);
sum += data[i];
}
if (sum < page) {
printf("-1\n");
return 0;
}
sort(data, data + cup, greater<int>());
left = 1;
right = cup;
while (left < right) {
mid = (left + right) / 2;
sum = 0;
for (int i = 0; i < cup; i++) sum += max(data[i] - i / mid, 0);
if (sum >= page)
right = mid;
else
left = mid + 1;
}
printf("%d\n", left);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 200000000000000000LL;
int main() {
int k, a, b;
scanf("%d%d%d", &k, &a, &b);
string s;
cin >> s;
int n = s.length();
if (n < k * a || n > k * b) {
cout << "No solution" << endl;
return 0;
}
string ans = "";
int last = -1, lines = 1;
for (int i = 0; i <= n - 1; i++) {
ans += s[i];
if (last + a <= i && n - i - 1 <= (k - lines) * b && lines < k) {
last = i;
ans += "\n";
lines++;
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve(int a0, int l) {
vector<int> a = {a0};
while(true) {
int aa = a.back();
string atmp = to_string(aa);
sort(atmp.begin(), atmp.end());
int mini = 0;
for(char c : atmp) {
mini *= 10;
mini += c - '0';
}
reverse(atmp.begin(), atmp.end());
int maxi = 0;
for(int i = 0; i < l; ++i) {
maxi *= 10;
if(i < (int)atmp.size()) maxi += atmp[i] - '0';
}
a.push_back(maxi - mini);
for(int i = 1; i < (int)a.size(); ++i) {
for(int j = 0; j < i; ++j) {
if(a[i] == a[j]) {
printf("%d %d %d\n", j, a[j], i - j);
return;
}
}
}
}
}
int main() {
int a0, l;
while(cin >> a0 >> l and l > 0) {
solve(a0, l);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[2][2], num[2], ans[(1000010)], len;
map<int, int> M;
inline bool work() {
if (M.find(A[0][0]) == M.end() || M.find(A[1][1]) == M.end()) return false;
if (!A[0][1] && !A[1][0]) {
int p = 0;
if (A[0][0] && A[1][1]) return false;
if (A[0][0])
p = 0, len = M[A[0][0]];
else if (A[1][1])
p = 1, len = M[A[1][1]];
else
len = 1;
for (int i = 1; i <= len; ++i) ans[i] = p;
return true;
}
for (int i = 0; i < 2; ++i) num[i] = M[A[i][i]];
long long all =
(long long)(num[0] + num[1]) * (long long)(num[0] + num[1] - 1) / 2LL;
if ((long long)A[0][0] + (long long)A[0][1] + (long long)A[1][0] +
(long long)A[1][1] !=
all)
return false;
len = num[0] + num[1];
for (int i = 1; i <= len; ++i) {
if (num[0] && A[0][1] >= num[1])
ans[i] = 0, --num[0], A[0][1] -= num[1];
else
ans[i] = 1, --num[1], A[1][0] -= num[0];
}
return !A[0][1] && !A[1][0];
}
int main() {
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) scanf("%d\n", A[i] + j);
for (int i = 1; i <= 44721; ++i) M[i * (i - 1) / 2] = i;
if (work())
for (int i = 1; i <= len; ++i) printf("%d", ans[i]);
else
puts("Impossible");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > G(101);
bool vis[101];
int co, sw;
void dfs(int u) {
vis[u] = true;
int i, v;
co++;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (!vis[v])
dfs(v);
else
sw++;
}
}
int main() {
int n, m, x, y;
cin >> n >> m;
while (m--) {
cin >> x >> y;
G[x - 1].push_back(y - 1);
G[y - 1].push_back(x - 1);
}
int i, con = 0, banc = 0;
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
if (!vis[i]) {
co = 0;
sw = 0;
dfs(i);
if (co + 1 == sw && co % 2 == 1) banc++;
}
}
n -= banc;
if (n % 2 == 1) banc++;
;
cout << banc << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, r, i = 0, y = 1;
int a[30];
long long int n, k, x;
cin >> t;
while (t--) {
cin >> n >> k;
{
while (k--) {
long long int b = n;
while (b > 0) {
r = b % 10;
b = b / 10;
a[i] = r;
i++;
if (r == 0) {
y = 0;
break;
}
}
sort(a, a + i);
n = n + a[0] * a[i - 1];
x = a[0] * a[i - 1];
if (y == 0) {
i = 0;
break;
}
i = 0;
}
n = n - x;
cout << n << "\n";
y = 1;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
vector<int> a;
int k = 1000;
int tmp = 1;
while (k > 0) {
if (!(tmp % 10 == 3 || tmp % 3 == 0)) {
k--;
a.push_back(tmp);
}
tmp++;
}
while (t--) {
int k;
cin >> k;
cout << a[k - 1] << endl;
}
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.