solution
stringlengths 52
181k
| difficulty
int64 0
6
|
---|---|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200005;
const long long Mod = 1000000007;
int n, m, k;
pair<int, int> a[MaxN];
long long dp[MaxN];
long long fct[MaxN], ifct[MaxN];
long long Power(long long a, long long b) {
long long Resuft = 1;
while (b) {
if (b & 1) {
Resuft = Resuft * a % Mod;
}
b /= 2;
a = a * a % Mod;
}
return Resuft;
}
void Init() {
fct[0] = 1;
for (int i = 1; i < MaxN; i++) {
fct[i] = (fct[i - 1] * i) % Mod;
}
ifct[MaxN - 1] = Power(fct[MaxN - 1], Mod - 2);
for (int i = MaxN - 2; i >= 0; i--) {
ifct[i] = (ifct[i + 1] * (i + 1)) % Mod;
}
}
long long C(int n, int k) {
return (((fct[n] * ifct[k]) % Mod) * ifct[n - k]) % Mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> a[i].first >> a[i].second;
}
a[k] = make_pair(n, m);
sort(a, a + k + 1);
Init();
for (int i = 0; i <= k; i++) {
dp[i] = C(a[i].first + a[i].second - 2, a[i].first - 1);
for (int j = 0; j < i; j++) {
if (a[j].first <= a[i].first && a[j].second <= a[i].second) {
dp[i] = (dp[i] -
dp[j] * C(a[i].first + a[i].second - a[j].first - a[j].second,
a[i].first - a[j].first) +
Mod * Mod) %
Mod;
}
}
}
cout << dp[k];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int m = n;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
if (n != 1)
cout << "1";
else
cout << i;
break;
}
}
if (n == m) cout << n;
}
| 1 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int a[5];
char t;
while(cin >> a[0] >> t >> a[1] >> t >> a[2] >> t >> a[3] >> t >> a[4]){
sort(a,a+5);
if(a[0] == a[3] || a[1] == a[4]){
cout << "four card" << endl;
}
else if((a[0] == a[1] && a[2] == a[4]) || (a[0] == a[2] && a[3] == a[4])){
cout << "full house" << endl;
}
else if((a[0]+1==a[1]&&a[1]+1==a[2]&&a[2]+1==a[3]&&a[3]+1==a[4]) || (a[0]==1&&a[1]==10&&a[2]==11&&a[3]==12&&a[4]==13)){
cout << "straight" << endl;
}
else if(a[0] == a[2] || a[1] == a[3] || a[2] == a[4]){
cout << "three card" << endl;
}
else if((a[0]==a[1]&&(a[2]==a[3]||a[3]==a[4]))||(a[1]==a[2]&&a[3]==a[4])){
cout << "two pair" << endl;
}
else if((a[0]==a[1])||(a[1]==a[2])||(a[2]==a[3])||(a[3]==a[4])){
cout << "one pair" << endl;
}
else{
cout << "null" << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int ccost(int h, int a, int b) {
h = h % (a + b);
if (h == 0) {
return (a + b) / (a) + ((a + b) % (a) != 0) - 1;
} else if (h <= a)
return 0;
else {
return (h) / (a) + ((h) % (a) != 0) - 1;
}
}
int main() {
int n, a, b, k;
cin >> n >> a >> b >> k;
vector<int> h(n);
for (int i = 0; i < (n); i++) cin >> h[i];
vector<int> cost(n);
for (int i = 0; i < (n); i++) {
cost[i] = ccost(h[i], a, b);
}
sort(cost.begin(), cost.end());
int sum = 0;
int i = 0;
while (i < n && sum + cost[i] <= k) {
sum += cost[i++];
}
cout << i << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 1000100;
const int base = 1e9+7;
int n;
ll fac[maxn],ifac[maxn];
ll pw(int a,int n) {
if (n==0) return 1ll;
if (n==1) return a;
ll tg = pw(a,n/2);
tg = (tg*tg) % base;
if (n%2) return (tg*a)%base;
return tg;
}
ll C(int k,int n) {
if (k > n) return 0;
return (fac[n] * ifac[k] % base * ifac[n-k])%base;
}
int main() {
//freopen("in.txt","r",stdin);
ios_base::sync_with_stdio(0); cin.tie(0);
fac[0] = 1, ifac[0] = 1;
for (int i=1;i<maxn;i++) {
fac[i] = (fac[i-1]*1ll*i)%base;
ifac[i] = pw(fac[i],base-2);
}
//cout<<C(1,1)<<endl;
cin>>n;
ll res=fac[n];
for (int i=1;i<n;i++) {
res = (res - C(n-i-1,i-1) * fac[i] %base * fac[n-i-1] % base + base) % base;
}
cout<<res;
}
| 0 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<math.h>
#include<complex>
#include<queue>
#include<iomanip>
using namespace std;
#define rep(i,n) for(int i = 0 ; i < n ; ++i)
using ll = long long;
using ld = long double;
using Point = complex<ld>;
const ld eps = 1e-9;
bool eq(ld a, ld b){
return abs(a-b)<eps;
}
ld dot(Point a, Point b){
return real(conj(a)*b);
}
ld cross(Point a, Point b){
return imag(conj(a)*b);
}
struct Line{
Point a, b;
};
bool isis_ll(Line l, Line m){
return !eq(cross(l.b-l.a, m.b-m.a),0);
}
bool isis_ls(Line l, Line s){
return (cross(l.b-l.a,s.a-l.a)*cross(l.b-l.a,s.b-l.a)<eps);
}
Point is_ll(Line s, Line t){
Point sv= s.b-s.a, tv = t.b-t.a;
return s.a + sv * cross(tv, t.a-s.a)/cross(tv,sv);
}
void solve(int n,int k,int m){
Point p[n];
rep(i,n){
int x,y;
cin>>x>>y;
p[i]=Point(x,y);
}
vector<ld> t(k+1,1e9);
vector<Point> v(k+1);
rep(i,k){
int x,y;
cin>>t[i]>>x>>y;
v[i]=Point(x,y);
}
vector<ld> bt(m);
vector<Point> bp(m),bq(m), bv(m);
rep(i,m){
cin>>bt[i];
ld x,vx,vy,l;
cin>>x>>vx>>vy>>l;
bv[i]=Point(vx,vy);
bp[i]=Point(x,0);
bq[i]=Point(x-l*vx/abs(bv[i]),-l*vy/abs(bv[i]));
bp[i]-=bt[i]*bv[i];
bq[i]-=bt[i]*bv[i];
}
vector<ld> ans(m,1e9+7);
ld st = 0;
rep(i,k+1){
rep(j,n){
rep(bi,m){
if(t[i]<bt[bi])continue;
Point nxt = p[j]+v[i]-bv[bi];
if(abs(nxt-p[j])<eps)continue;
Line l = {p[j],nxt};
Line bl = {bp[bi],bq[bi]};
if(!isis_ls(l,bl))continue;
if(eq(cross(l.a-l.b, bl.a-bl.b),0))continue;
Point cp = is_ll(l,bl);
ld ct = st + real((cp-p[j])/(nxt-p[j]));
if(st-eps<ct&&ct<t[i]+eps&&ct>bt[bi]-eps){
ans[bi]=min(ans[bi],ct);
}
}
}
rep(j,n){
Line s = {p[j],p[(j+1)%n]};
rep(bi,m){
if(t[i]<bt[bi])continue;
Point nxt = bp[bi]-v[i]+bv[bi];
if(abs(nxt-bp[bi])<eps)continue;
Line bl = {bp[bi],nxt};
if(!isis_ls(bl,s))continue;
if(eq(cross(s.a-s.b, bl.a-bl.b),0))continue;
Point cp = is_ll(bl,s);
ld ct = st + real((cp-bp[bi])/(nxt-bp[bi]));
if(st-eps<ct&&ct<t[i]+eps&&ct>bt[bi]-eps){
ans[bi]=min(ans[bi],ct);
}
}
rep(bi,m){
if(t[i]<bt[bi])continue;
Point nxt = bq[bi]-v[i]+bv[bi];
if(abs(nxt-bq[bi])<eps)continue;
Line bl = {bq[bi],nxt};
if(!isis_ls(bl,s))continue;
if(eq(cross(s.a-s.b, bl.a-bl.b),0))continue;
Point cp = is_ll(bl,s);
ld ct = st + real((cp-bq[bi])/(nxt-bq[bi]));
if(st-eps<ct&&ct<t[i]+eps&&ct>bt[bi]-eps){
ans[bi]=min(ans[bi],ct);
}
}
}
rep(j,n){
p[j]+=(ld)(t[i]-st)*v[i];
}
rep(j,m){
bp[j]+=(t[i]-st)*bv[j];
bq[j]+=(t[i]-st)*bv[j];
}
st = t[i];
}
vector<ld> at;
rep(i,m){
if(ans[i]<1e9){
at.push_back(ans[i]);
}
}
sort(at.begin(),at.end());
cout<<at.size()<<endl;
rep(i,at.size()){
cout<<at[i]<<endl;
}
}
int main(){
int n,k,m;
cout<<fixed<<setprecision(10);
while(cin>>n>>k>>m,n!=0)solve(n,k,m);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<string, string> st;
char a[1000];
char b[1000];
char br[1000];
char k;
int main() {
long long int n, m, i, j;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a >> b;
st[b] = a;
}
for (i = 0; i < m; i++) {
cin >> a;
cin >> b;
for (j = 0; b[j] != ';'; j++) {
br[j] = b[j];
}
cout << a << " " << b << " #" << st[br] << endl;
for (j = 0; b[j] != ';'; j++) br[j] = '\0';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[10000000];
int l[10000000];
int r[10000000];
int x[10000000];
int z[10000000];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &l[i], &r[i], &x[i]);
l[i]--;
r[i]--;
}
z[0] = -1;
for (int i = 1; i < n; i++) {
if (a[i - 1] != a[i])
z[i] = i - 1;
else
z[i] = z[i - 1];
}
for (int i = 0; i < m; i++) {
if (a[r[i]] != x[i])
printf("%d\n", r[i] + 1);
else if (z[r[i]] >= l[i])
printf("%d\n", z[r[i]] + 1);
else
printf("%d\n", -1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, num[100100], cnt[100100], qzc[100100], qzs[100100];
namespace Get {
long long g[100100][20];
inline long long gcd(long long u, long long v) {
for (; u && v && u != v;) {
swap(u, v);
u %= v;
}
return max(u, v);
}
void work() {
long long i, j, k, t, l;
for (i = 1; i <= n; i++) g[i][0] = num[i];
for (i = 1; i <= 16; i++) {
for (j = 1; j + (1 << (i - 1)) <= n; j++) {
g[j][i] = gcd(g[j][i - 1], g[j + (1 << (i - 1))][i - 1]);
}
}
for (i = 1; i <= n; i++) {
for (j = l = i, t = num[i]; j <= n;) {
t = gcd(t, num[j]);
for (k = 16; k >= 0; k--) {
if ((j + (1 << k)) > n + 1) continue;
if (g[j][k] % t == 0) {
j += (1 << k);
}
}
cnt[t] += j - l;
l = j;
}
}
}
} // namespace Get
long long f(long long a, long long b, long long c, long long n) {
if (n < 0) return 0;
if (!a) return b / c * (n + 1);
if (a >= c || b >= c)
return f(a % c, b % c, c, n) + a / c * n * (n + 1) / 2 + b / c * (n + 1);
long long m = (a * n + b) / c;
return m * n - f(c, c - b - 1, a, m - 1);
}
inline long long ask(long long a, long long b, long long c) {
if (c < 0) return 0;
return c / a + 1 + f(a, c % a, b, c / a);
}
inline long long solve(long long a, long long ca, long long b, long long cb,
long long c) {
if (a * (ca - 1) + b * (cb - 1) <= c) return ca * cb;
if (c < 0) return 0;
return ask(a, b, c) - ask(a, b, c - a * ca) - ask(a, b, c - b * cb) +
ask(a, b, c - a * ca - b * cb);
}
inline long long calc(long long u) {
long long i, j, l, r, t, res = 0;
for (i = 1; i <= 100000; i++) {
if (!cnt[i]) continue;
t = min(cnt[i], u / i);
res += cnt[i] * t - t * (t - 1) / 2;
}
for (l = r = 1; l < 100000; l++) {
if (!cnt[l]) continue;
if (l < r) res += cnt[l] * (qzc[r - 1] - qzc[l]);
for (; r <= 100000 && qzs[r] - qzs[l] <= u; r++) {
if (l != r && cnt[r]) {
res += solve(l, cnt[l], r, cnt[r], u - (qzs[r - 1] - qzs[l]) - l - r);
}
}
if (r <= 100000) {
if (l != r && cnt[r]) {
res += solve(l, cnt[l], r, cnt[r], u - (qzs[r - 1] - qzs[l]) - l - r);
}
}
}
return res;
}
int main() {
long long i, j, l, r, mid;
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%lld", &num[i]);
}
Get::work();
m = (n + 1) * n / 2;
m = (m + 1) * m / 2;
m = (m + 1) / 2;
for (i = 1; i <= 100000; i++) {
qzc[i] = qzc[i - 1] + cnt[i];
qzs[i] = qzs[i - 1] + cnt[i] * i;
}
for (l = 1, r = qzs[100000] + 1; l < r;) {
mid = ((l + r) >> 1);
if (calc(mid) < m)
l = mid + 1;
else
r = mid;
}
cout << l;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
long long a = 0, b = 0, c = 0;
for (int i = 0; i < S.size(); ++i) {
if (S[i] == 'o') {
b += a;
} else if (i > 0 && S[i - 1] == 'v') {
a++;
c += b;
}
}
cout << c << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2006;
int n;
int a[mxn];
int ans;
vector<pair<int, int>> sol;
void Swap(int x, int y) {
sol.push_back({x, y});
swap(a[x], a[y]);
ans += abs(x - y);
}
void Output() {
printf("%d\n", ans);
printf("%d\n", int(sol.size()));
for (auto &i : sol) printf("%d %d\n", i.first, i.second);
}
void EXEC() {
{
cin >> n;
int a[mxn];
int b[mxn];
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
int t;
cin >> t;
b[t] = i;
}
for (int i = 1; i <= n; ++i) ::a[i] = b[a[i]];
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
int p = find(a + 1, a + n + 1, i) - a;
while (p != i) {
for (int j = p - 1; j >= i; --j)
if (a[j] >= p) {
Swap(p, j);
p = j;
break;
}
}
}
Output();
}
int main() {
EXEC();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int find(vector<int> &V, int x){
if(V[x]==x) return x;
else{
int ret = find(V,V[x]);
V[x] = ret;
return ret;
}
}
int main(){
int N,M;
cin >> N >> M;
vector<int> V(N);
for(int i=0;i<N;i++) V[i] = i;
for(int i=0;i<M;i++){
int a,b;
cin >> a >> b;
a--;b--;
int x = find(V,a), y = find(V,b);
V[y] = x;
}
vector<int> W(N);
for(int i=0;i<N;i++) W[find(V,V[i])]++;
int ans=0;
for(int i=0;i<N;i++) ans = max(ans,W[i]);
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int A,B;cin>>A>>B;
cout<<max(0,A-2*B);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int ans = 0;
for (int i = 1; i < n; i++) {
ans += a[i] - a[i - 1] - 1;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1000];
bool check() {
for (int i = 0; i < n; i++) {
if (a[i] != i) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (check()) {
cout << "Yes" << endl;
exit(0);
}
for (int j = 0; j < n; j++) {
if (j % 2 == 0) {
a[j] = (a[j] + 1) % n;
} else {
a[j] = ((a[j] - 1) % n + n) % n;
}
}
}
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <typename T>
using vc = std::vector<T>;
void solve(istream& cin, ostream& cout) {
if (rand() % 2) {
cout << "red";
} else {
cout << "black";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve(cin, cout);
return 0;
}
| 4 |
#include <cstdio>
#include <cstring>
int main()
{
int h, w;
char s[6];
scanf("%d%d", &h, &w);
for (int i = 0; i < h; ++i)
{
for (int j = 0; j < w; ++j)
{
scanf("%s", s);
if (memcmp(s, "snuke", 5) == 0)
{
printf("%c%d\n", j + 'A', i + 1);
return 0;
}
}
}
} | 0 |
#include<bits/stdc++.h>
#define pi 3.1415926535897932384626
using namespace std;
struct P{
int x,y;
bool operator < (const P &a )const{
//if(y!=a.y)
return y>a.y;
};
};
int a,b,c,d,i,k,n,m,e,dx[10]={1,0,-1,0,1,1,-1,-1},dy[10]={0,1,0,-1,1,-1,1,-1};
long double o[613],x;
int l[610];
int j[302];
long long y,z,mod=1000000007;
//string r;
char r[111];
P u[1];
queue<int> q;
stack<int> s;
map<int,int> p;
vector<int> v[666];
bool as(P a,P b)
{
if(a.x==b.x)
return a.y<b.y;
return a.x<b.x;
}
void f(int n)
{
memset(o,0,sizeof(o));
for(int t=a-1;t;t--)
{
long double y=0;
for(int h=0;h<v[t].size();h++)
o[t]+=1+o[v[t][h]],y=max(y,1+o[v[t][h]]);
if(t==n) o[t]=(o[t]-y)/(v[t].size()-1);
else o[t]=o[t]/v[t].size();
}
//for(int t=1;t<=a;t++)
// printf("%Lf ",o[t]);
x=min(x,o[1]);
}
int main()
{
scanf("%d %d",&a,&b);
for(int t=1;t<=b;t++)
{
scanf("%d %d",&n,&m);
v[n].push_back(m);
l[m]=n;
}
x=12345678;
f(0);
for(int t=1;t<a;t++)
if(v[t].size()>1) f(t);
printf("%Lf",x);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double maxi[100005], mini[100005], prefixA[100005], prefixB[100005],
diceA[100005], diceB[100005], A, B, C, discriminant;
int main() {
int i, j, t, n, m, k, l, r, temp, flag, result, cnt;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%lf", &maxi[i]);
for (i = 1; i <= n; i++) scanf("%lf", &mini[i]);
for (i = 1; i <= n; i++) {
A = 1.00000;
B = prefixA[i - 1] - prefixB[i - 1] - maxi[i] - mini[i];
C = maxi[i] - prefixA[i - 1] * (maxi[i] + mini[i]);
discriminant = B * B - 4.0000 * A * C;
if (discriminant < 0.000) discriminant = 0.0000;
diceA[i] = (-B + sqrt(discriminant)) / 2.000000;
diceB[i] = maxi[i] + mini[i] - diceA[i];
prefixA[i] = prefixA[i - 1] + diceA[i];
prefixB[i] = prefixB[i - 1] + diceB[i];
}
for (i = 1; i <= n; i++) printf("%.8lf ", diceA[i]);
printf("\n");
for (i = 1; i <= n; i++) printf("%.8lf ", diceB[i]);
printf("\n");
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
const int M = 1000000007;
int main() {
int w, h, n;
cin >> w >> h >> n;
vector<P> p(n + 2);
for (int i = 0; i < n; ++i) {
cin >> p[i].first >> p[i].second;
}
int S = n, T = n + 1;
p[S] = P(1, 1);
p[T] = P(w, h);
priority_queue<pair<int, P>, vector<pair<int, P>>, greater<pair<int, P>>> q;
vector<vector<int>> dists(n + 2, vector<int>(1010, 2000));
dists[S][0] = 0;
q.push(make_pair(0, P(S, 0)));
while (!q.empty()) {
pair<int, P> pp = q.top();
q.pop();
int c = pp.first;
int i = pp.second.first;
int r = pp.second.second;
for (int j = 0; j < n; ++j) {
if (i == j) continue;
int nr = max(0, abs(p[i].first - p[j].first) + abs(p[i].second - p[j].second) - r);
if (i < n && nr > 0) {
--nr;
}
if (dists[j][nr] > c + nr) {
dists[j][nr] = c + nr;
q.push(make_pair(c + nr, P(j, nr)));
}
}
}
vector<vector<int>> distt(n + 2, vector<int>(1010, 2000));
distt[T][0] = 0;
q.push(make_pair(0, P(T, 0)));
while (!q.empty()) {
pair<int, P> pp = q.top();
q.pop();
int c = pp.first;
int i = pp.second.first;
int r = pp.second.second;
for (int j = 0; j < n; ++j) {
if (i == j) continue;
int nr = max(0, abs(p[i].first - p[j].first) + abs(p[i].second - p[j].second) - r);
if (i < n && nr > 0) {
--nr;
}
if (distt[j][nr] > c + nr) {
distt[j][nr] = c + nr;
q.push(make_pair(c + nr, P(j, nr)));
}
}
}
int ans = 2000;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 1010; ++j) {
if (j > 0) {
dists[i][j] = min(dists[i][j], dists[i][j - 1] + 1);
distt[i][j] = min(distt[i][j], distt[i][j - 1] + 1);
}
ans = min(ans, dists[i][j] + max(0, abs(p[T].first - p[i].first) + abs(p[T].second - p[i].second) - j));
ans = min(ans, distt[i][j] + max(0, abs(p[S].first - p[i].first) + abs(p[S].second - p[i].second) - j));
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
int d = abs(p[i].first - p[j].first) + abs(p[i].second - p[j].second) - 1;
for (int k = 0; k <= d; ++k)
ans = min(ans, dists[i][k] + distt[j][d - k]);
}
}
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, i, k, go = 0, j;
string x;
cin >> n >> x;
char a[n];
for (i = 0, k = 0, j = 0; j < n; j++) {
if (n % 2 != 0) {
l = n / 2;
if (j % 2 == 0) {
a[l - i + k] = x[j];
} else {
a[l - i] = x[j];
go++;
}
}
k++;
i++;
if (go == 1) {
i--;
go = 0;
}
}
for (i = 0, k = 1, j = 0; j < n; j++) {
if (n % 2 == 0) {
l = (n / 2) - 1;
if (j % 2 == 0)
a[l - i] = x[j];
else {
a[l - i + k] = x[j];
go++;
}
}
k++;
i++;
if (go == 1) {
i--;
go = 0;
}
}
for (i = 0; i < n; i++) cout << a[i];
return 0;
}
| 2 |
#include <bits/stdc++.h>
struct point {
long long x, y;
} a[400001];
long long n, i, k, ans;
bool comp1(point x, point y) { return x.x < y.x || x.x == y.x && x.y < y.y; }
bool comp2(point x, point y) { return x.y < y.y || x.y == y.y && x.x < y.x; }
int main() {
scanf("%I64d\n", &n);
for (i = 1; i <= n; ++i) scanf("%I64d%I64d\n", &a[i].x, &a[i].y);
std::sort(a + 1, a + n + 1, comp1);
for (k = 1, i = 2; i <= n; ++i)
if (a[i].x == a[i - 1].x)
ans += k, ++k;
else
k = 1;
std::sort(a + 1, a + n + 1, comp2);
for (k = 1, i = 2; i <= n; ++i)
if (a[i].y == a[i - 1].y)
ans += k, ++k;
else
k = 1;
for (k = 1, i = 2; i <= n; ++i)
if (a[i].x == a[i - 1].x && a[i].y == a[i - 1].y)
ans -= k, ++k;
else
k = 1;
printf("%I64d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, temp;
float f_angle;
int i_angle;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> temp;
f_angle = 360.0 / (180 - temp);
i_angle = 360 / (180 - temp);
if (i_angle == f_angle)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
const int mod = 1000000007;
const int N = 1000000;
int p[maxn], inv[maxn];
int n, m, ans;
int pow(int a, int b) {
int ret = 1;
for (; b; b >>= 1) {
if (b & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod;
}
return ret;
}
int C(int n, int k) {
if (n < k) return 0;
return 1ll * p[n] * inv[k] % mod * inv[n - k] % mod;
}
int main() {
cin >> n >> m;
p[0] = 1;
for (int i = 1; i <= N; i++) {
p[i] = 1ll * p[i - 1] * i % mod;
}
inv[N] = pow(p[N], mod - 2);
for (int i = N - 1; i >= 0; i--) {
inv[i] = 1ll * inv[i + 1] * (i + 1ll) % mod;
}
for (int i = 0; i <= n - 2; i++) {
int now = 1ll * C(n - 2, i) * p[i] % mod * C(m - 1, i) % mod;
now = 1ll * pow(m, n - 2 - i) * now % mod;
if (n - i - 3 >= 0) {
now = 1ll * now * (i + 2) % mod * pow(n, n - i - 3) % mod;
}
ans = (ans + now) % mod;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
ll n, fl = 0;
cin >> n;
char ar[n][n];
unordered_map<char, ll> mp;
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n; j++) {
cin >> ar[i][j];
mp[ar[i][j]]++;
}
}
if (mp.size() != 2) {
cout << "NO" << endl;
return;
}
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n / 2; j++) {
if (ar[i][j] != ar[i][n - 1 - j]) {
fl = 1;
break;
}
}
}
for (ll i = 0; i < n / 2; i++) {
if (ar[i][n / 2] != ar[n - 1 - i][n / 2]) {
fl = 1;
break;
}
}
if (ar[n / 2][n / 2] != ar[0][0]) fl = 1;
if (fl)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
int main() {
ll t = 1;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for (int i = (a); i <= (b); ++i)
#define REPD(i,a,b) for (int i = (a); i >= (b); --i)
#define FORI(i,n) REP(i,1,n)
#define FOR(i,n) REP(i,0,int(n)-1)
#define mp make_pair
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define ll long long
#define SZ(x) int((x).size())
#define DBG(v) cerr << #v << " = " << (v) << endl;
#define FOREACH(i,t) for (typeof(t.begin()) i=t.begin(); i!=t.end(); i++)
#define fi first
#define se second
const int N = 200200;
int n;
int vis[N], val[N], outdeg[N], p[N];
set<int> vs[N];
int la;
int mex(set<int> &s) {
set<int>::iterator it=s.begin();
int ret=0;
while (it != s.end()) {
if (*it != ret) break;
it++;
ret++;
}
return ret;
}
void dfs(int u) {
vis[u] = 1;
val[u] = mex(vs[u]);
vs[p[u]].insert(val[u]);
outdeg[p[u]]--;
if (outdeg[p[u]]==0) dfs(p[u]);
}
bool ok(int u, int vv) {
int v = u;
val[u] = vv;
while (p[v] != u) {
set<int> st = vs[p[v]];
st.insert(val[v]);
int vc = mex(st);
val[p[v]] = vc;
vis[v] = 1;
v = p[v];
}
la = v;
return val[u] != val[v];
}
int main() {
scanf("%d", &n);
FOR(i,n) scanf("%d", &p[i]);
FOR(i,n) p[i]--;
FOR(i,n) outdeg[p[i]]++;
FOR(i,n) if (!vis[i] && outdeg[i]==0) dfs(i);
FOR(i,n) if (!vis[i]) {
int v1 = mex(vs[i]);
if (!ok(i, v1)) {
vs[i].insert(v1);
int v2 = mex(vs[i]);
if (!ok(i, v2) || val[la] != v1) {
printf("IMPOSSIBLE\n");
return 0;
}
}
}
printf("POSSIBLE\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef pair<ll, ll>P;
ll gcd(ll x, ll y) {
if (y == 0)return x;
return gcd(y, x % y);
}
ll lcm(ll x, ll y) {
return x * y / gcd(x, y);
}
ll basic[33333];
signed main(){
ll n,memo=0,ans=0;
cin>>n;
for(int i=1;i<=33333;i++){
if(i%2==0||i%3==0){
basic[memo]=i;
memo++;
}
}
rep(i,n-1){
cout<<basic[i]<<" ";
ans+=basic[i];
}
ll p=0;
for(int i=2;i<=30000;i++){
if((i%3==(3-(ans%3))%3)&&(i%2==(2-(ans%2))%2)&&(gcd(i,ans)!=1)){
for(int j=0;j<n-1;j++){
if(i==basic[j])p++;
}
if(p==0){
cout<<i;
return 0;
}
}
p=0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for(int i=0; i<(n); i++)
#define readVec(v) forn(i, v.size()){cin >> v[i];}
#define printArr(arr, n) forn(i, n){if (i) cout << " "; cout << arr[i];} cout << endl;
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define f first
#define s second
typedef long long ll;
typedef double ld;
typedef long double lld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector<pii> vpi;
typedef vector<pll> vpl;
typedef vector<vi> vii;
//Printing pairs and vectors
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
//2 147 483 647 int max
//9 223 372 036 854 775 807 ll max
void fast_io(){
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
void file_io(string taskname){
string fin = taskname + ".in";
string fout = taskname + ".out";
const char* FIN = fin.c_str();
const char* FOUT = fout.c_str();
freopen(FIN, "r", stdin);
freopen(FOUT, "w", stdout);
fast_io();
}
int main(){
fast_io();
int n;
cin >> n;
vl a(n), b(n);
forn(i, n){
cin >> a[i];
}
forn(i, n){
cin >> b[i];
}
ll tot = 0;
forn(i, n){
tot += abs(a[i] - b[i]);
}
ll best = 0;
vector<pair<pll, bool> > ints;
forn(i, n){
ints.pb(mp(mp(min(a[i], b[i]), max(a[i], b[i])), (a[i] < b[i])));
}
sort(ints.begin(), ints.end());
ll bfm = -MOD, afm = -MOD;
forn(i, n){
if(ints[i].s){
best = max(best, min(afm, ints[i].f.s) - ints[i].f.f);
bfm = max(bfm, ints[i].f.s);
}else{
best = max(best, min(bfm, ints[i].f.s) - ints[i].f.f);
afm = max(afm, ints[i].f.s);
}
}
cout << tot - best*2 << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
long long sum[N], ans[N], cur;
long long seg[1 << 20];
set<int> nw;
void update(int i, int v, int ni = 0, int ns = 0, int ne = n) {
if (ns > i || ne < i || ns > ne) return;
if (ns == ne && ns == i) {
seg[ni] += v;
return;
}
if (ns >= ne) return;
int l = ni * 2 + 1, r = l + 1, mid = (ns + ne) / 2;
update(i, v, l, ns, mid);
update(i, v, r, mid + 1, ne);
seg[ni] = seg[l] + seg[r];
}
long long query(int qs, int qe, int ni = 0, int ns = 0, int ne = n) {
if (ns > qe || ne < qs || ns > ne) return 0;
if (ns >= qs && ne <= qe) return seg[ni];
int l = ni * 2 + 1, r = l + 1, mid = (ns + ne) / 2;
return query(qs, qe, l, ns, mid) + query(qs, qe, r, mid + 1, ne);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lld", sum + i);
for (int i = 1; i <= n; ++i) nw.insert(i);
for (int i = n - 1; i >= 0; --i) {
int st = 0, en = n - 1;
while (st < en) {
int mid = (st + en + 1) / 2;
long long s = 1ll * mid * (mid + 1) / 2 - query(0, mid);
if (s > sum[i])
en = mid - 1;
else
st = mid;
}
int x = *nw.lower_bound(st + 1);
nw.erase(x);
ans[i] = x;
update(x, x);
}
for (int i = 0; i < n; ++i) printf("%lld ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2003;
const long long mod = 998244353;
int n, m, k;
long long F[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) {
F[i][0] = m;
for (int t = 1; t <= k; ++t)
F[i][t] = (F[i - 1][t] + 1ll * F[i - 1][t - 1] * (m - 1) % mod) % mod;
}
cout << F[n][k];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int fret[6];
for (int i = 0; i < 6; i++) cin >> fret[i];
sort(fret, fret + 6);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
set<tuple<int, int, int>> s;
for (int i = 0; i < n; i++) {
s.emplace(a[i] - fret[5], i, 5);
}
int ans = INT_MAX;
auto update_min = [&]() -> void {
ans = min(ans, get<0>(*s.rbegin()) - get<0>(*s.begin()));
};
update_min();
while (true) {
auto [v, i, j] = *s.begin();
s.erase(s.begin());
if (j == 0) break;
j--;
s.emplace(a[i] - fret[j], i, j);
update_min();
}
cout << ans << '\n';
return 0;
}
| 1 |
#include"bits/stdc++.h"
int main(){long long h;std::cin>>h;printf("%lld\n",(1ll<<(int)std::ceil(std::log2(h+1)))-1);}
| 0 |
#include<iostream>
#include<algorithm>
using namespace std;
#define MAX 256
#define INF 1000000
struct edge {
int money;
int time;
};
int main(){
int n, m;
int count;
edge G[120][120];
while(cin >> n >> m, n || m){
for(int i=0; i < 120; i++){
for(int j=0; j < 120; j++){
G[i][j].money = INF;
G[i][j].time = INF;
}
}
for(int i=0; i < 120; i++){
G[i][i].money = 0;
G[i][i].time = 0;
}
for(int i=0; i < n; i++){
int a, b, mo, t;
cin >> a >> b >> mo >> t;
G[a][b].time=t;
G[a][b].money=mo;
G[b][a].time=t;
G[b][a].money=mo;
}
for(int k=1; k <= m; k++){
for(int i=1; i <= m; i++){
for(int j=1; j <= m; j++){
G[i][j].time = min(G[i][j].time, G[i][k].time+G[k][j].time);
G[i][j].money = min(G[i][j].money, G[i][k].money+G[k][j].money);
}
}
}
cin >> count;
for(int i=0; i < count; i++){
int p;
cin >> n >> m >> p;
if(p) cout << G[n][m].time << endl;
else cout << G[n][m].money << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int amin = a[0], oppV = a[0];
for (int i = 1; i < n; i++) {
if (amin < a[i]) amin = a[i];
oppV = oppV + a[i];
}
long int totalV, k;
for (int j = amin; j < 10000; j++) {
totalV = j * n;
if (totalV - oppV > oppV) {
cout << j;
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int N, M, K;
long long ans;
map<int, int> A[maxn << 1], B[maxn << 1];
map<pair<int, int>, int> S;
int GO(int X, int Y, int D) {
int Sx(X), Sy(Y), Sd(D);
(S.insert(make_pair(pair<int, int>(X, Y), 0)).first->second |= (0));
A[((X) + (Y))].insert(pair<int, int>(((X) - (Y) + M), 0));
B[((X) - (Y) + M)].insert(pair<int, int>(((X) + (Y)), 0));
map<int, int>::iterator NEW;
NEW = (D == 1 || D == 4 ? A[((X) + (Y))].find(((X) - (Y) + M))
: B[((X) - (Y) + M)].find(((X) + (Y))));
do {
int d = NEW->second, dis;
if (d == (D | ((D) >> (1) ? (D) >> (1) : (D) << (4 - (1)))))
D = ((D) >> (4 - (1)) ? (D) >> (4 - (1)) : (D) << (1));
else if (d == (D | ((D) >> (4 - (1)) ? (D) >> (4 - (1)) : (D) << (1))))
D = ((D) >> (1) ? (D) >> (1) : (D) << (4 - (1)));
else if ((__builtin_popcount(d) & 1) && (d & D) == D)
return true;
NEW = (D == 1 || D == 4 ? A[((X) + (Y))].find(((X) - (Y) + M))
: B[((X) - (Y) + M)].find(((X) + (Y))));
if (D == 1 || D == 8)
NEW--;
else
NEW++;
dis = abs((D == 1 || D == 4 ? ((X) - (Y) + M) : ((X) + (Y))) - NEW->first) /
2;
ans += dis;
if (D == 2 || D == 4)
X += dis;
else
X -= dis;
if (D == 1 || D == 2)
Y += dis;
else
Y -= dis;
} while (X != Sx || Y != Sy || D != Sd);
return false;
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 1; i <= K; i++) {
int x, y;
scanf("%d%d", &x, &y);
(S.insert(make_pair(pair<int, int>(x - 1, y - 1), 0)).first->second |= (2)),
(S.insert(make_pair(pair<int, int>(x - 1, y), 0)).first->second |= (4)),
(S.insert(make_pair(pair<int, int>(x, y), 0)).first->second |= (8)),
(S.insert(make_pair(pair<int, int>(x, y - 1), 0)).first->second |= (1));
}
for (int i = 1; i < M; i++)
(S.insert(make_pair(pair<int, int>(0, i), 0)).first->second |= (1 | 8)),
(S.insert(make_pair(pair<int, int>(N, i), 0)).first->second |= (2 | 4));
for (int i = 1; i < N; i++)
(S.insert(make_pair(pair<int, int>(i, 0), 0)).first->second |= (8 | 4)),
(S.insert(make_pair(pair<int, int>(i, M), 0)).first->second |= (1 | 2));
(S.insert(make_pair(pair<int, int>(0, 0), 0)).first->second |= (4 | 8 | 1)),
(S.insert(make_pair(pair<int, int>(0, M), 0)).first->second |=
(8 | 1 | 2));
(S.insert(make_pair(pair<int, int>(N, 0), 0)).first->second |= (8 | 4 | 2)),
(S.insert(make_pair(pair<int, int>(N, M), 0)).first->second |=
(4 | 2 | 1));
for (map<pair<int, int>, int>::iterator i = S.begin(); i != S.end(); i++) {
A[((i->first.first) + (i->first.second))].insert(
pair<int, int>(((i->first.first) - (i->first.second) + M), i->second));
B[((i->first.first) - (i->first.second) + M)].insert(
pair<int, int>(((i->first.first) + (i->first.second)), i->second));
}
int X, Y, D;
char s[3];
scanf("%d%d%s", &X, &Y, s);
D = (s[0] == 'N' && s[1] == 'E' ? 1
: s[0] == 'S' && s[1] == 'E' ? 2
: s[0] == 'S' && s[1] == 'W' ? 4
: 8);
if (D == 8 ? GO(X - 1, Y - 1, D)
: D == 1 ? GO(X - 1, Y, D)
: D == 2 ? GO(X, Y, D)
: GO(X, Y - 1, D)) {
ans++, D = ((D) >> (2) ? (D) >> (2) : (D) << (4 - (2)));
D == 8 ? GO(X - 1, Y - 1, D)
: D == 1 ? GO(X - 1, Y, D)
: D == 2 ? GO(X, Y, D)
: GO(X, Y - 1, D);
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int n, m, q, dot[100001] = {}, maxp[100001] = {};
vector<int> g[100001];
int v[100001], d[100001], c[100001];
void dfs(int col, int step, int f)
{
if (dot[f] == 0) dot[f] = col;
if (maxp[f] >= step) return;
maxp[f] = step;
int length = g[f].size();
for (int i = 0; i < length; i++)
{
if (step - 1 >= 0) dfs(col, step - 1, g[f][i]);
}
}
int main()
{
cin >> n >> m;
int f, t;
for (int i = 1; i <= m; i++)
{
cin >> f >> t;
g[f].push_back(t);
g[t].push_back(f);
}
cin >> q;
for (int i = 1; i <= q; i++)
cin >> v[i] >> d[i] >> c[i];
for (int i = q; i >= 1; i--)
{
dfs(c[i], d[i], v[i]);
}
for (int i = 1; i <= n; i++)
cout << dot[i] << '\n';
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long t, a, b, q, l, r, l0, r0, mi, ma, tot, ans, x[40005];
long long calc2(long long r) {
int pos = lower_bound(x + 1, x + tot + 1, r) - x;
return x[pos] == r ? pos : pos - 1;
}
long long calc1(long long l) {
return tot + 1 - (lower_bound(x + 1, x + tot + 1, l) - x);
}
int main() {
for (scanf("%lld", &t); t--;) {
scanf("%lld%lld%lld", &a, &b, &q);
mi = a * b + 1, ma = -1, tot = 0;
for (long long i = 1; i <= a * b; i++)
if (i % a % b != i % b % a)
mi = min(mi, i), ma = max(ma, i), x[++tot] = i;
while (q--) {
scanf("%lld%lld", &l, &r);
if (ma == -1) {
printf("0 ");
continue;
}
l0 = l / (a * b), r0 = r / (a * b), l %= (a * b), r %= (a * b);
printf("%lld ", (r0 - l0 - 1) * tot + calc1(l) + calc2(r));
}
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long L;
cin >> n >> L;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
a[i] = min(2 * a[i - 1], a[i]);
}
long long ans = 1e18, sum = 0;
for (int i = n - 1; i >= 0; i--) {
int amt = L / (1 << i);
sum += (long long)amt * a[i];
L -= (amt << i);
ans = min(ans, sum + (L > 0) * a[i]);
}
cout << ans << '\n';
return 0;
}
| 3 |
#define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <string,string> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
void dfs(map<char,int>& co,map<char,int>::iterator it,map<char,bool>& pre,int visited,int sum,map<int, map<int,int> >& result){
if(it==co.end()){
result[sum][visited]++;
return;
}
for(int i=0;i<=9;i++){
if(visited & (1<<i)) continue;
if(i==0 && pre[it->first]) continue;
sum += it->second * i;
it++;
visited |= (1<<i);
dfs(co,it,pre,visited,sum,result);
visited &= ~(1<<i);
it--;
sum -= it->second * i;
}
}
int main(){
int n;
while(~scanf("%d",&n)){
if(n==0) break;
int count = 0;
map<char,int> coefficient;
map<char,bool> prefix; // prefix or not
for(int i=0;i<n;i++){
string str;
cin >> str;
if(str.size() > 1) prefix[str[0]] = true;
for(int j=str.size()-1,k=1;j>=0;j--,k*=10){
if(i!=n-1) coefficient[str[j]] += k;
else coefficient[str[j]] -= k;
}
}
map<char,int> co_front;
map<char,int> co_rear;
int ub=0;
map<char,int>::iterator cit;
for(cit = coefficient.begin(); cit != coefficient.end();cit++){
if(ub >= coefficient.size()/2) break;
co_front[cit->first] = cit->second;
ub++;
}
for(; cit != coefficient.end();cit++){
co_rear[cit->first] = cit->second;
}
map<int,map<int,int> > result_front;
map<int,map<int,int> > result_rear;
dfs(co_front,co_front.begin(),prefix,0,0,result_front);
dfs(co_rear,co_rear.begin(),prefix,0,0,result_rear);
int res=0;
for(map<int,map<int,int> >::iterator it = result_front.begin(); it != result_front.end(); it++){
map<int,map<int,int> >::iterator it2;
if((it2 = result_rear.find(-(it->first))) != result_rear.end()){
for(map<int,int>::iterator sit = it->second.begin(); sit != it->second.end(); sit++){
for(map<int,int>::iterator sit2 = it2->second.begin(); sit2 != it2->second.end(); sit2++){
if(!(sit->first & sit2->first)) res+=sit->second * sit2->second;
}
}
}
}
printf("%d\n",res);
}
} | 0 |
#include <iostream>
using namespace std;
int main()
{
long long n,m,l,sum;
cin>>n>>m>>l;
int a[n][m], b[m][l];
for (int i=0; i<n; i++) for (int j=0; j<m; j++) cin>>a[i][j];
for (int i=0; i<m; i++) for (int j=0; j<l; j++) cin>>b[i][j];
for (int i=0; i<n; i++)
{
for (int j=0; j<l; j++)
{
sum=0;
for (int k=0; k<m; k++)
{
sum+=a[i][k]*b[k][j];
}
cout<<sum; if (j!=l-1) cout<<' ';
}
cout<<'\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long gg = 0x7fffffff;
struct node {
int p, e;
} per[230001];
int n, k, ks;
long long ans;
bool u[230001];
bool cmp1(node a, node b) { return a.p > b.p; }
bool cmp2(node a, node b) { return a.e < b.e; }
long long work(int p) {
long long ret = 0;
memset(u, 0, sizeof(u));
int cnt = 0, tot = 0;
for (int i = 1; i <= n; i++)
if (per[i].p >= p - 1) cnt++;
cnt -= k - 1;
for (int i = 1; i <= n && tot < cnt; i++) {
if (per[i].p == p || per[i].p == p - 1) {
ret += per[i].e;
tot++;
u[i] = 1;
}
}
for (int i = 1; i <= n && tot < p; i++) {
if (!u[i]) {
ret += per[i].e;
tot++;
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d%d", &per[i].p, &per[i].e);
sort(per + 1, per + 1 + n, cmp1);
ks = per[k].p;
sort(per + 1, per + 1 + n, cmp2);
ans = gg * gg;
for (int i = ks; i <= ks + 2; i++) {
if (i > n) break;
ans = min(ans, work(i));
}
if (ans == gg * gg) ans = -1;
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char solve(long long n, long long k, long long x) {
if (k == 0) return '.';
if (n % 2 == 0) {
if (k <= n / 2) {
if (x % 2 == 1 || x / 2 + k <= n / 2)
return '.';
else
return 'X';
} else {
if (x % 2 == 0 || x / 2 + k >= n)
return 'X';
else
return '.';
}
} else {
if (x == n) return 'X';
return solve(n - 1, k - 1, x);
}
}
int main() {
long long n, k, x;
int q;
while (cin >> n >> k >> q) {
while (q--) {
cin >> x;
cout << solve(n, k, x);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c, ans[10][10], tabler[10], tablec[10], cakes = 0, i, j, ch;
char in[10][10];
for (i = 0; i < 10; i++) tabler[i] = tablec[i] = 0;
cin >> r >> c;
for (i = 0; i < r; i++) {
ch = getchar();
for (j = 0; j < c; j++) {
cin >> in[i][j];
ans[i][j] = 0;
if (in[i][j] == 'S') tabler[i] = tablec[j] = 1;
}
}
for (i = 0; i < r; i++) {
if (tabler[i] == 0) {
for (j = 0; j < c; j++) ans[i][j] = 1;
}
}
for (j = 0; j < c; j++) {
if (tablec[j] == 0) {
for (i = 0; i < r; i++) ans[i][j] = 1;
}
}
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
if (ans[i][j] == 1) cakes++;
}
}
cout << cakes << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void flash() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long N = 1e4 + 10;
long long sm[N + 5];
void pre() {
sm[0] = 0;
for (long long i = 1; i < N; i++) {
sm[i] = (sm[i - 1] + i);
}
}
long long glob, endsum, stsum;
vector<long long> thisvector = {1, 2, 3, 4, 5};
long long check(long long n) {
if (n > 0) {
glob++;
return 1;
} else {
glob--;
return 0;
}
}
long long call(long long n) {
if (glob > 0) {
endsum = (n * (n + 1)) / 2;
return 1;
} else {
endsum = (n * (n - 1)) / 2;
return 0;
}
}
long long change(long long n) {
sort(thisvector.begin(), thisvector.end());
long long tmp = 0;
for (long long i = 0; i < 5; i++) {
tmp += thisvector[i];
}
if (tmp > endsum) {
stsum = tmp;
return 1;
} else {
stsum = endsum;
return 0;
}
}
void every() { check(5), call(5), change(5); }
void solution() {
every();
long long n, k;
cin >> n >> k;
if (n >= k) {
if (n % 2 == k % 2)
cout << "0"
<< "\n";
else
cout << "1"
<< "\n";
} else {
cout << k - n << "\n";
}
}
int32_t main() {
flash();
long long t;
t = 1;
cin >> t;
pre();
while (t--) {
solution();
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
long long n,k,w[100001],ma=0;
int fp(long long p){
long long sum=0,v=0;
for(int i=0;i<k;i++){
sum=0;
while(sum+w[v]<=p){
sum+=w[v];
v++;
if(v==n)return v;
}
}
return v;
}
int main(){
cin>>n>>k;
for(int i=0;i<n;i++)cin>>w[i];
long long l=0,r=1000000000,m;
while(r-l>1){
m=(l+r)/2;
int v=fp(m);
if(n<=v)r=m;
else l=m;
}
cout<<r<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, a, b, ans;
cin >> n;
while (n--) {
cin >> a >> b;
ans = ((24 - a) * 60) - (b);
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long n, long long temp) {
long long res = 1;
while (n > 0) {
if (n & 1) res = (res * a) % temp;
a = (a * a) % temp;
n >>= 1;
}
return res % temp;
}
int main() {
int n;
scanf("%d", &n);
int a;
int i;
map<int, int> h;
for (i = 0; i < n; i++) {
scanf("%d", &a);
h[a]++;
}
int m;
cin >> m;
vector<int> b(m), c(m);
int id = 0;
for (i = 0; i < m; i++) scanf("%d", &b[i]);
for (i = 0; i < m; i++) scanf("%d", &c[i]);
for (i = 0; i < m; i++) {
if (h[b[i]] > h[b[id]]) {
id = i;
} else if (h[b[i]] == h[b[id]]) {
if (h[c[i]] > h[c[id]]) id = i;
}
}
printf("%d\n", id + 1);
if (0) cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[5000 + 10][5000 + 10], csum[5000 + 10];
int my_abs(int a, int b) { return a > b ? a - b : b - a; }
int main() {
int n, st, nvr, k, flr, mv, df, l, r, i, j;
scanf("%d %d", &n, &st);
scanf("%d %d", &nvr, &k);
for (mv = 0; mv <= k; mv++) {
for (flr = 1; flr <= n; flr++) {
if (!mv)
dp[mv][flr] = flr != nvr;
else {
df = my_abs(flr, nvr) - 1;
l = max(1, flr - df);
r = min(n, flr + df);
dp[mv][flr] = ((csum[r] - csum[l - 1] - dp[mv - 1][flr]) % 1000000007 +
1000000007) %
1000000007;
}
}
for (flr = 1; flr <= n; flr++)
csum[flr] = (csum[flr - 1] + dp[mv][flr]) % 1000000007;
}
printf("%d\n", dp[k][st]);
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#define REP(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
int main() {
int n;
cin>>n;
vector<int> t(n-1);
REP(i,n-1) cin>>t[i];
vector<int> dpa(n+2,100000000);
vector<int> dpb(n+2,100000000);
dpa[1] = 0;
REP(i,n-1) {
vector<int> tmpa(n,1000000000);
vector<int> tmpb(n,1000000000);
REP(j,n/2+1) {
tmpa[j+1] = min(tmpa[j+1], dpa[j]);
tmpa[j+1] = min(tmpa[j+1], dpb[j]+t[i]);
tmpb[j] = min(tmpb[j], dpb[j]);
tmpb[j] = min(tmpb[j], dpa[j]+t[i]);
}
swap(tmpa,dpa);
swap(tmpb,dpb);
}
cout << min(dpa[n/2], dpb[n/2]) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
short base = 0, c = 0, car;
int a, b, t, sum;
scanf("%d%d", &a, &b);
t = a;
while (t) {
base = (base > t % 10) ? base : t % 10;
t /= 10;
}
t = b;
while (t) {
base = (base > t % 10) ? base : t % 10;
t /= 10;
}
base++;
car = 0;
while (a || b || car) {
car = (a % 10 + b % 10 + car) / base;
a /= 10;
b /= 10;
c++;
}
printf("%d", c);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define fio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define en cin.close();return 0;
#define INF ((ll)(2e18))
#define pb push_back
#define fi first//printf("%lli\n",cur);
#define se second//scanf("%lli",&n);
using namespace std;
const ll N = 3e5+5;
ll ans[N], m;
void upd(vector<pair<ll,pair<char,ll> > > &ve)
{
sort(ve.begin(),ve.end());
stack<pair<ll,ll> > st;
for(auto &i:ve)
{
if(i.se.fi=='R')
st.push({i.fi,i.se.se});
else
{
if(st.empty())
st.push({-i.fi,i.se.se});
else
{
auto t = st.top();
st.pop();
ll x = i.fi-t.fi;
ans[t.se]=x/2;
ans[i.se.se]=x/2;
}
}
}
while(st.size()>1)
{
auto t = st.top();
st.pop();
auto t2 = st.top();
st.pop();
t.fi=m+(m-t.fi);
ll x = t.fi-t2.fi;
ans[t.se]=x/2;
ans[t2.se]=x/2;
}
if(st.size()==1)
ans[st.top().se]=-1;
}
int main()
{
fio
//ifstream cin("in.inn");
ll qq;
cin >> qq;
while(qq--)
{
ll n;
cin >> n >> m;
vector<pair<ll,pair<char,ll> > > c[2];
ll pos[n];
char vel[n];
for(auto &i:pos)
cin >> i;
for(auto &i:vel)
cin >> i;
for(ll i = 0;i<n;i++)
c[pos[i]%2].pb({pos[i],{vel[i],i}});
for(ll i = 0;i<2;i++)
upd(c[i]);
for(ll i = 0;i<n;i++)
cout << ans[i] << " ";
cout << "\n";
}
//cin.close();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k;
cin >> k;
for (int i = 0; i < s.size(); ++i) {
int d = (26 - (s[i] - 'a')) % 26;
if (d == 0)
continue;
if (d <= k) {
s[i] = 'a';
k -= d;
}
}
if (k > 0)
s.back() = 'a' + (s.back() - 'a' + (k % 26)) % 26;
cout << s << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, l, res = -1;
cin >> k >> l;
while (l % k == 0) {
l /= k;
res += 1;
}
if (res >= 0 && l == 1) {
cout << "YES"
<< "\n"
<< res;
} else {
cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c,d; cin>>a>>b>>c>>d;
cout<<(a!=c? 1:0)<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[100500];
int main() {
map<long long, long long> mp;
int n;
cin >> n;
long long i = 0, x = 0, y, r = 0;
while (i++ < n) {
cin >> y;
r = max(r, ++mp[x += y]);
}
cout << n - r << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
string str[105];
string temp;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> str[i];
}
for (int i = 1; i < t; i++) {
for (int j = 1; j < t; j++) {
if (str[j - 1].length() > str[j].length()) {
temp = str[j];
str[j] = str[j - 1];
str[j - 1] = temp;
} else if (str[j - 1].length() == str[j].length() &&
str[j - 1] > str[j]) {
temp = str[j];
str[j] = str[j - 1];
str[j - 1] = temp;
}
}
}
for (int i = 0; i < t - 1; i++) {
if (str[i + 1].find(str[i]) == -1) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < t; i++) cout << str[i] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int c = 1;
for (int i = 0; i < n; i++) {
if (a[i] >= c) {
c++;
}
}
cout << c << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
char pan[N][N];
int prv[N][N], vis[N][N];
pair<int, int> que[N * N];
inline pair<int, int> ask(char c) {
cout << c << endl;
cout.flush();
int x, y;
cin >> x >> y;
return make_pair(x, y);
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> pan[i] + 1;
int hd = 0, tl = 0;
que[tl++] = make_pair(1, 1), vis[1][1] = 1;
while (hd < tl) {
auto cur = que[hd++];
for (int d = 0; d < 4; d++) {
int x = cur.first + dx[d], y = cur.second + dy[d];
if (x < 1 || x > n || y < 1 || y > m) continue;
if (pan[x][y] == '*') continue;
if (vis[x][y]) continue;
prv[x][y] = d;
vis[x][y] = 1;
que[tl++] = make_pair(x, y);
}
}
string ans = "";
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (pan[i][j] == 'F') {
int x = i, y = j;
while (x + y > 2) {
int d = prv[x][y];
if (d == 0)
ans += "D";
else if (d == 1)
ans += "R";
else if (d == 2)
ans += "U";
else if (d == 3)
ans += "L";
else
assert(0);
x -= dx[d], y -= dy[d];
}
reverse(ans.begin(), ans.end());
break;
}
int LR = -1, UD = -1;
if (n > 1 && pan[2][1] != '*') {
auto cur = ask('U');
if (cur.first == 2)
UD = 1, ask('D');
else
UD = 0;
}
if (m > 1 && pan[1][2] != '*') {
auto cur = ask('L');
if (cur.second == 2)
LR = 1, ask('R');
else
LR = 0;
}
if (LR == -1 && m > 1) {
for (int i = 2; i <= n; i++) {
if (UD)
ask('U');
else
ask('D');
if (pan[i][2] != '*') {
auto cur = ask('L');
if (cur.second == 2)
LR = 1, ask('R');
else
LR = 0;
for (int j = i; j > 1; j--) {
if (UD)
ask('D');
else
ask('U');
}
break;
}
}
}
if (UD == -1 && n > 1) {
for (int i = 2; i <= m; i++) {
if (LR)
ask('L');
else
ask('R');
if (pan[2][i] != '*') {
auto cur = ask('U');
if (cur.first == 2)
UD = 1, ask('D');
else
UD = 0;
for (int j = i; j > 1; j--) {
if (LR)
ask('R');
else
ask('L');
}
break;
}
}
}
for (auto it : ans) {
if (it == 'L') {
if (LR > 0)
ask('R');
else
ask('L');
}
if (it == 'R') {
if (LR > 0)
ask('L');
else
ask('R');
}
if (it == 'U') {
if (UD > 0)
ask('D');
else
ask('U');
}
if (it == 'D') {
if (UD > 0)
ask('U');
else
ask('D');
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e2 + 10;
const long long MAXK = 22;
const long long Mod = 1e9 + 7;
vector<long long> vertex[MAXN];
long long dp[MAXN][MAXK][MAXK];
long long tmp[MAXK][MAXK];
bool check[MAXN];
long long k;
void dfs(long long v) {
check[v] = true;
dp[v][k + 1][1] = 1;
dp[v][0][0] = 1;
for (long long i = 0; i < vertex[v].size(); i++) {
if (!check[vertex[v][i]]) {
dfs(vertex[v][i]);
for (long long j = 0; j <= k + 1; j++) {
for (long long u = 0; u <= k + 1; u++) {
tmp[j][u] = 0;
}
}
for (long long j = 0; j <= k + 1; j++) {
for (long long u = 0; u <= k + 1; u++) {
for (long long w = 0; w <= k + 1; w++) {
for (long long z = 0; z <= k; z++) {
if (min(j, w + 1) + max(u, z + 1) - 1 > k) {
tmp[min(j, w + 1)][max(u, z + 1)] +=
dp[v][j][u] * dp[vertex[v][i]][w][z];
tmp[min(j, w + 1)][max(u, z + 1)] %= Mod;
} else {
tmp[min(j, w + 1)][0] += dp[v][j][u] * dp[vertex[v][i]][w][z];
tmp[min(j, w + 1)][0] %= Mod;
}
}
}
}
}
for (long long j = 0; j <= k + 1; j++) {
for (long long u = 0; u <= k + 1; u++) {
dp[v][j][u] = tmp[j][u];
}
}
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
long long n, ans = 0;
cin >> n >> k;
for (long long i = 0; i < (n - 1); i++) {
long long v, u;
cin >> v >> u;
vertex[v].push_back(u);
vertex[u].push_back(v);
}
dfs(1);
for (long long i = 0; i <= k; i++) {
ans += dp[1][i][0];
ans %= Mod;
}
cout << ans;
}
| 5 |
#include<iostream>
using namespace std;
int main(){
int p;
int n[1000000];
while(cin >> p, p){
int ans = 0;
for(int i=0; i < p; i++){
cin >> n[i];
}
for(int i=0; i < p; i++){
for(int j = 0; j < p-i-1; j++){
if(n[j] > n[j+1]){
swap(n[j], n[j+1]);
ans++;
}
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
vector<long long> Lis;
int main() {
long long a, b, n;
cin >> n >> a >> b;
int sw = 0;
if (a > b) {
sw = 1;
swap(a, b);
}
for (int i = 0; i < n; i++) {
int val;
scanf("%d", &val);
Lis.push_back(val);
mp[val] = i + 1;
}
sort(Lis.begin(), Lis.end());
int output[n + 10];
map<int, int> yes;
for (int i = 0; i < Lis.size(); i++) {
long long val = Lis[i];
if (mp[val] > 0) {
if (mp[b - val] > 0) {
output[mp[val]] = 1;
output[mp[b - val]] = 1;
mp[val] = 0;
mp[b - val] = 0;
} else if (mp[a - val] > 0) {
output[mp[val]] = 0;
output[mp[a - val]] = 0;
mp[val] = 0;
mp[a - val] = 0;
} else {
puts("NO");
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << (output[i] + sw) % 2 << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[1005];
signed main() {
long long n, k;
scanf("%lld%lld", &n, &k);
long long ans = 0;
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + 1 + n);
for (long long i = 1; i <= n; k = max(k, a[i]), i++)
while (a[i] > k * 2) {
ans++;
k *= 2;
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int s, f, c, r;
};
vector<node> vec[420];
pair<int, int> st[420];
int f[420][420];
int n, m, a[420], tops, mx[420][420];
long long ans;
int main() {
scanf("%d %d", &n, &m);
for (register int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (register int i = 1; i <= n; i++)
for (register int j = i + 1; j <= n; j++) {
mx[i][j] = max(mx[i][j - 1], a[j] - a[j - 1]);
}
for (register int i = 1; i <= m; i++) {
int s, f, c, r;
scanf("%d %d %d %d", &s, &f, &c, &r);
vec[s].push_back((node){s, f, c, r});
}
for (register int s = 1; s <= n; s++) {
tops = 0;
for (register int i = s; i <= n; i++) f[i][0] = a[i] - a[s];
for (register int k = 1; k <= n - s; k++) {
int id = s;
for (register int i = s + 1; i <= n; i++) {
while (id < i - 1 && max(f[id][k - 1], a[i] - a[id]) >
max(f[id + 1][k - 1], a[i] - a[id + 1]))
++id;
f[i][k] = max(f[id][k - 1], a[i] - a[id]);
}
}
for (register int i = 0; i < (int)vec[s].size(); i++) {
node cur = vec[s][i];
ans = max(ans, (long long)cur.c * f[cur.f][min(cur.r, n - s)]);
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
int main() {
char S[100001], s[31];
int i, r = 0;
scanf("%s", S);
scanf("%s", s);
int len = strlen(s);
int Len = strlen(S);
for (i = 0; i < Len; i++) {
if (!strncmp(S + i, s, len)) {
i += len - 1;
r++;
}
}
printf("%d\n", r);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class Init {
public:
Init() noexcept try {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
} catch (...) {
cerr << "Init constructor threw an exception" << endl;
terminate();
}
} __init __attribute__((unused));
using ll = long long;
using ld = long double;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
template <typename T>
istream &operator>>(istream &in, vector<T> &v);
template <typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v);
template <typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (T &i : v) in >> i;
return in;
}
template <typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) {
return in >> p.first >> p.second;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
auto it = v.begin();
if (!v.empty()) out << *it++;
while (it != v.end()) out << " " << *it++;
return out;
}
template <typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) {
return out << p.first << " " << p.second;
}
void push_left(vector<int> &v) {
if (!v[0]) return;
v[0] = 0;
for (int i = 1; i < 10; i++) {
if (v[i] == 0) {
v[i] = 1;
return;
}
v[i] = 1;
}
}
void push_right(vector<int> &v) {
reverse((v).begin(), (v).end());
push_left(v);
reverse((v).begin(), (v).end());
}
int main() {
int n;
string s;
cin >> n >> s;
vector<int> v(10, 0);
for (char c : s) {
if (c == 'L') {
push_left(v);
v[0] = 1;
} else if (c == 'R') {
push_right(v);
v[9] = 1;
} else {
v[c - '0'] = 0;
}
}
for (int i : v) cout << i;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){return o<<"("<<p.fs<<","<<p.sc<<")";}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){o<<"sz = "<<vc.size()<<endl<<"[";for(const T& v:vc) o<<v<<",";o<<"]";return o;}
template<unsigned int mod_>
struct ModInt{
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr static uint mod = mod_;
uint v;
ModInt():v(0){}
ModInt(ll v):v(normS(v%mod+mod)){}
explicit operator bool() const {return v!=0;}
static uint normS(const uint &x){return (x<mod)?x:x-mod;} // [0 , 2*mod-1] -> [0 , mod-1]
static ModInt make(const uint &x){ModInt m; m.v=x; return m;}
ModInt operator+(const ModInt& b) const { return make(normS(v+b.v));}
ModInt operator-(const ModInt& b) const { return make(normS(v+mod-b.v));}
ModInt operator-() const { return make(normS(mod-v)); }
ModInt operator*(const ModInt& b) const { return make((ull)v*b.v%mod);}
ModInt operator/(const ModInt& b) const { return *this*b.inv();}
ModInt& operator+=(const ModInt& b){ return *this=*this+b;}
ModInt& operator-=(const ModInt& b){ return *this=*this-b;}
ModInt& operator*=(const ModInt& b){ return *this=*this*b;}
ModInt& operator/=(const ModInt& b){ return *this=*this/b;}
ll extgcd(ll a,ll b,ll &x,ll &y) const{
ll u[]={a,1,0},v[]={b,0,1};
while(*v){
ll t=*u/ *v;
rep(i,3) swap(u[i]-=t*v[i],v[i]);
}
if(u[0]<0) rep(i,3) u[i]=-u[i];
x=u[1],y=u[2];
return u[0];
}
ModInt inv() const{
ll x,y;
extgcd(v,mod,x,y);
return make(normS(x+mod));
}
bool operator==(const ModInt& b) const { return v==b.v;}
bool operator!=(const ModInt& b) const { return v!=b.v;}
friend istream& operator>>(istream &o,ModInt& x){
ll tmp;
o>>tmp;
x=ModInt(tmp);
return o;
}
friend ostream& operator<<(ostream &o,const ModInt& x){ return o<<x.v;}
};
using mint = ModInt<1000000007>;
const int MX = 1000;
mint f[MX],g[MX],inv[MX];
void precalc(){
f[0]=1;
rep1(i,MX-1) f[i] = f[i-1] * i;
const int mod = 1e9+7;
inv[1]=1;
for(int i=2;i<=MX-1;i++) inv[i] = -inv[mod%i] * (mod/i);
g[0]=1;
rep1(i,MX-1) g[i] = g[i-1] *inv[i];
}
mint dp[2][301][601];
int main(){
precalc();
int N;
cin>>N;
dp[0][0][0] = 1;
rep(i,N){
int d;
cin>>d;
int ni = 1-i%2;
rep(k,301) rep(s,601) dp[ni][k][s] = 0;
rep(k,301) rep(s,601) if(dp[i%2][k][s]){
mint val = dp[i%2][k][s];
if(d>=2){ //sel
int nk = k+1;
int ns = s+(d-2);
dp[ni][nk][ns] += val*g[d-2];
}
{
dp[ni][k][s] += val*g[d-1];
}
}
}
mint ans;
for(int k=3;k<=N;k++) rep(s,601) if(dp[N%2][k][s]){
if(k==N){
mint tmp = dp[N%2][k][s] * f[k-1] / 2;
ans += tmp;
continue;
}
mint tmp = dp[N%2][k][s] * f[N+1-k-2] * s * f[k-1] / 2;
ans += tmp;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool bst;
int i, j, k, l, n, m, s, an, tot, len, L, P;
class arr {
public:
int d, m, r, son, fa;
bool f1, f2, f3;
} a[4];
bool ff[47][47][47][8][8];
void dfs(int n1, int n2) {
if (ff[a[1].d][a[2].d][a[3].d][n1][n2]) return;
for (int i = 1; i <= 3; i++)
if (a[i].d <= 42) an = max(an, a[i].d);
ff[a[1].d][a[2].d][a[3].d][n1][n2] = true;
int mm = 9999;
for (int i = 1; i <= 3; i++) mm = min(mm, a[i].d);
int ju[4];
memset(ju, 0, sizeof(ju));
for (int i = 1; i <= 3; i++)
if (a[i].d > 42) ju[a[i].d - 42] = i;
for (int i = 1; i <= 3; i++)
if (a[i].d <= 42)
if (!(n1 & (1 << (i - 1))))
if (!ju[i]) {
for (int j = max(mm, a[i].d - a[i].m); j <= a[i].d + a[i].m; j++) {
int pp = a[i].d;
a[i].d = j;
dfs(n1 | (1 << (i - 1)), n2);
a[i].d = pp;
}
}
for (int i = 1; i <= 3; i++)
if (a[i].d <= 42)
if (!(n2 & (1 << (i - 1))))
if (!ju[i]) {
for (int j = 1; j <= 3; j++)
if (abs(a[j].d - a[i].d) == 1) {
int pp = a[j].d;
a[j].d = 42 + i;
dfs(n1, n2 | (1 << (i - 1)));
a[j].d = pp;
}
}
for (int i = 1; i <= 3; i++)
if (a[i].d <= 42)
if (ju[i]) {
int y = ju[i];
for (int j = max(mm, a[i].d - a[i].r); j <= a[i].d + a[i].r; j++) {
a[y].d = j;
dfs(n1, n2);
a[y].d = 42 + i;
}
}
}
int main() {
n = 3;
while (scanf("%d%d%d", &a[1].d, &a[1].m, &a[1].r) == 3) {
memset(ff, 0, sizeof(ff));
for (int i = 2; i <= n; i++) scanf("%d%d%d", &a[i].d, &a[i].m, &a[i].r);
an = 0;
dfs(0, 0);
printf("%d\n", an);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 2000;
int n, k;
int a[Max];
int b[Max];
bool cal(int c) {
int t = k;
for (int i = 0; i < n; i++) {
if (a[i] * c > b[i]) t = t - a[i] * c + b[i];
if (t < 0) {
return false;
}
}
return true;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int l, r, mid;
l = 0, r = 2001;
while (l < r) {
mid = (l + r) / 2;
if (cal(mid))
l = mid + 1;
else
r = mid;
}
cout << (l + r) / 2 - 1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int V = 1101000;
const int P = 1000000007;
long long rev[30][2];
int a[V];
int tr[V], N;
void update(int k, int v) {
while (k <= N) {
tr[k] += v;
k += k & -k;
}
}
int read(int k) {
int ret = 0;
while (k > 0) {
ret += tr[k];
k -= k & -k;
}
return ret;
}
void init(int id, int l, int r, int d) {
if (l == r) return;
int mid = (l + r) / 2;
for (int i = l; i <= mid; i++) update(a[i], 1);
for (int i = mid + 1; i <= r; i++) rev[d][1] += read(a[i] - 1);
for (int i = l; i <= mid; i++) update(a[i], -1);
for (int i = r; i > mid; i--) update(a[i], 1);
for (int i = mid; i >= l; i--) rev[d][0] += read(a[i] - 1);
for (int i = r; i > mid; i--) update(a[i], -1);
init(id * 2, l, mid, d + 1);
init(id * 2 + 1, mid + 1, r, d + 1);
}
int r[V];
bool cmp(int x, int y) { return a[x] < a[y]; }
int st[40], n, Q, x;
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= (1 << n); i++) scanf("%d", &a[i]);
for (int i = 1; i <= (1 << n); i++) r[i] = i;
sort(r + 1, r + (1 << n) + 1, cmp);
N = 1;
int pre = a[r[1]];
a[r[1]] = 1;
for (int i = 2; i <= (1 << n); i++) {
if (a[r[i]] != pre) {
pre = a[r[i]];
N++;
}
a[r[i]] = N;
}
memset(rev, 0, sizeof(rev));
memset(st, 0, sizeof(st));
init(1, 1, (1 << n), 0);
scanf("%d", &Q);
while (Q--) {
scanf("%d", &x);
x = n - x;
for (int i = x; i <= n; i++) st[i] ^= 1;
long long ret = 0;
for (int i = 0; i <= n; i++) ret += rev[i][st[i]];
printf("%I64d\n", ret);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[105];
int f = 10, ny = 360, e = 720;
int c, sh;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
f += a[i];
if (f > e) break;
c++;
if (f > ny) sh += f - ny;
}
cout << c << ' ' << sh << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
const long long MOD = 1e9 + 7;
const long long MAXN = 1e5 + 7;
const long long INF = 2e9;
const long long BIG_INF = 2e18;
const long long LOG = 20;
const double eps = 1e-7;
mt19937 engine(chrono::system_clock::now().time_since_epoch().count());
long long mpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
void solve() {
long long k;
cin >> k;
long long ans = 6, kol = 1;
for (long long i = 0; i < k; ++i) {
kol = kol * 2;
}
kol -= 2;
cout << (ans * mpow(4, kol)) % MOD << '\n';
;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long test = 1;
while (test--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
const int Maxt = 300005;
long long t[7][12][Maxt];
int a[Maxn];
void modify(int t1, int t2, int l, int r, int p, int k, long long val) {
if (l == r) {
t[t1][t2][p] = val;
return;
}
int m = (l + r) / 2;
if (k <= m) {
modify(t1, t2, l, m, p * 2, k, val);
} else {
modify(t1, t2, m + 1, r, p * 2 + 1, k, val);
}
t[t1][t2][p] = t[t1][t2][p * 2] + t[t1][t2][p * 2 + 1];
}
long long query(int t1, int t2, int l, int r, int p, int lo, int hi) {
if (l >= lo && r <= hi) return t[t1][t2][p];
int m = (l + r) / 2;
long long ans = 0;
if (lo <= m) {
ans += query(t1, t2, l, m, p * 2, lo, min(m, hi));
}
if (hi > m) {
ans += query(t1, t2, m + 1, r, p * 2 + 1, max(lo, m + 1), hi);
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 2; j <= 6; j++) {
modify(j, i % (2 * j - 2), 1, n, 1, i, (long long)a[i]);
}
}
int m;
scanf("%d", &m);
while (m--) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int p, val;
scanf("%d %d", &p, &val);
for (int j = 2; j <= 6; j++) {
modify(j, p % (2 * j - 2), 1, n, 1, p, (long long)val);
}
} else {
int lf, rg, z;
scanf("%d %d %d", &lf, &rg, &z);
long long ans = 0;
z = 2 * z - 2;
int now = lf % z;
for (int i = 1; i <= z; i++) {
int si;
if (i == 0)
si = 2;
else if (i <= (z + 2) / 2) {
si = i;
} else {
si = z + 2 - i;
}
ans += (long long)si *
query((z + 2) / 2, (now + i - 1) % z, 1, n, 1, lf, rg);
}
printf("%I64d\n", ans);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, n;
int main() {
scanf("%d", &n);
for (i = 1; i <= 4; i++) {
int s1, c1, s2, c2, c = 0;
scanf("%d %d %d %d", &s1, &c1, &s2, &c2);
c = min(s1, c1);
if (c + min(s2, c2) <= n) {
printf("%d %d %d", i, min(s1, c1), n - min(s1, c1));
return 0;
}
}
puts("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> v(n), ans;
set<long long> s;
for (long long i = 1; i <= n; i++) s.insert(i);
for (auto &i : v) cin >> i;
ans.push_back(v[0]);
s.erase(v[0]);
long long maxval = v[0];
bool flag = true;
for (long long i = 1; i < n; i++) {
if (v[i] > maxval)
ans.push_back(v[i]), maxval = v[i], s.erase(v[i]);
else {
auto it = s.begin();
if (*(it) >= v[i]) {
cout << -1 << endl;
flag = false;
break;
}
ans.push_back(*(it));
s.erase(*it);
}
}
if (flag) {
for (auto i : ans) cout << i << ' ';
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} a[105], b[105];
int sum1[105], sum2[105];
bool cmp(struct node a, struct node b) { return a.y > b.y; }
int main() {
int n;
int count1 = 0, count2 = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (x == 1) {
count1++;
a[count1].x = x;
a[count1].y = y;
} else {
count2++;
b[count2].x = x;
b[count2].y = y;
}
}
sort(a + 1, a + count1 + 1, cmp);
sort(b + 1, b + count2 + 1, cmp);
for (int i = 1; i <= count1; i++) sum1[i] = sum1[i - 1] + a[i].y;
for (int i = 1; i <= count2; i++) sum2[i] = sum2[i - 1] + b[i].y;
int ans = 1000000;
for (int i = 0; i <= count1; i++)
for (int j = 0; j <= count2; j++) {
int thi = i + 2 * j, w = sum1[count1] - sum1[i] + sum2[count2] - sum2[j];
if (w <= thi) ans = min(ans, thi);
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> A;
int main() {
int n;
string a;
cin >> n >> a;
sort(a.begin(), a.end());
cout << a << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
vector<int> v;
pair<int, int> ans[100005];
int prime[100005], cnt;
int n, res;
bool vis[100005], flg[100005];
void pre() {
cnt = 0;
for (int i = 2; i <= n / 2; ++i) {
if (!vis[i]) prime[++cnt] = i;
for (int j = 1; j <= cnt && prime[j] * i <= n; ++j) {
vis[prime[j] * i] = 1;
if (!(i % prime[j])) break;
}
}
return;
}
void init() {
n = read();
if (n == 1 || n == 2 || n == 3) puts("0"), exit(0);
pre();
return;
}
void solve() {
for (int i = cnt; i; i--) {
v.clear();
for (int j = prime[i]; j <= n; j += prime[i]) {
if (!flg[j]) v.push_back(j);
flg[j] = 1;
}
int s = v.size();
if (s & 1) --s, swap(v[1], v[s]), flg[v[s]] = 0;
for (int j = 0; j < s; j += 2) ans[++res] = {v[j], v[j + 1]};
}
printf("%d\n", res);
for (int i = 1; i <= res; i++) printf("%d %d\n", ans[i].first, ans[i].second);
return;
}
int main() {
init();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename V>
ostream &operator<<(ostream &os, const pair<T, V> pai) {
return os << pai.first << ' ' << pai.second;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> v) {
for (int i = 0, _i = (((int)(v).size())); i < _i; i++) cout << v[i] << ' ';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> s) {
for (T p : s) cout << p << ' ';
return os;
}
template <typename T, typename V>
ostream &operator<<(ostream &os, const map<T, V> s) {
for (auto p : s) cout << '(' << p << ") ";
return os;
}
template <typename T, typename V>
istream &operator>>(istream &is, pair<T, V> &pai) {
is >> pai.first >> pai.second;
return is;
}
template <typename T>
void umax(T &a, T b) {
a = max(a, b);
}
template <typename T>
void umin(T &a, T b) {
a = min(a, b);
}
int N;
int A[200000];
int B[200000];
int D[18];
vector<int> li;
int convert(int x) {
int ret = 0;
for (int i = 0, _i = (18); i < _i; i++)
if ((x >> i) & 1) ret ^= li[i];
return ret;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> N;
for (int i = 0, _i = (N); i < _i; i++) cin >> A[i];
sort(A, A + N);
copy(A, A + N, B);
for (int i = 0, _i = (N); i < _i; i++) {
for (int j = 17; j >= 0; j--) {
if (not((B[i] >> j) & 1)) continue;
if (D[j])
B[i] ^= D[j];
else {
li.push_back(A[i]);
D[j] = B[i];
break;
}
}
}
int T = find(D, D + 18, 0) - D;
cout << T << '\n';
for (int i = 0, _i = (1 << T); i < _i; i++) {
int r = 0;
for (int j = 0, _j = (T); j < _j; j++)
if (((i ^ (i >> 1)) >> j) & 1) r ^= li[j];
cout << r << ' ';
}
cout << '\n';
}
| 5 |
#include <bits/stdc++.h>
std::vector<int> ans;
std::vector<int> in;
std::vector<int> out;
int n, m;
void transform(int now, int m) {
for (int i = 0; i < m; i++) {
if (i & 1)
out[i / 2] = in[i];
else
out[i / 2 + m / 2] = in[i];
}
if (now & 1) return;
if (m & 1) {
for (auto i = 1; i < m; i++) std::swap(out[i], out[i - 1]);
} else {
for (int i = 0; i < m / 2; i++) std::swap(out[i], out[m - i - 1]);
}
}
void work(int n, int m, int d, bool ver) {
in.resize(m);
out.resize(m);
for (int i = 1; i <= n; i++) {
int start = ver ? i : (i - 1) * m + 1;
for (int j = 0; j < m; j++) in[j] = start + j * d;
transform(i, m);
for (int j = 0; j < m; j++)
if (ver) {
ans[j * n + i - 1] = out[j];
} else {
ans[(i - 1) * m + j] = out[j];
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin >> n >> m;
if (n == m && n == 1) {
std::cout << "YES\n1\n";
return 0;
}
if (n == m && n == 3) {
std::cout << "YES\n";
std::cout << "8 1 6\n"
"3 5 7\n"
"4 9 2\n";
return 0;
}
if (n <= 3 && m <= 3) {
std::cout << "NO\n";
return 0;
}
std::cout << "YES\n";
ans.resize(n * m);
if (m <= 3)
work(m, n, m, 1);
else
work(n, m, 1, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) std::cout << ans[i * m + j] << " ";
std::cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}
using Pi = pair<int, int>;
using Tapris = tuple<int, int, int>;
using vint = vector<int>;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
int N, K;
cin >> N >> K;
vint T(N);
rep(i, N) cin >> T[i];
vint vec;
rep(i, N-1) vec.push_back(T[i+1]-T[i]);
sort(all(vec));
int sum = N;
rep(i, N-K) sum += vec[i]-1;
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 10000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
const int INF = 0x3f3f3f3f;
struct atom {
int mmin, minc;
atom() { mmin = INF, minc = 0; }
atom(int x) { mmin = x, minc = 1; }
atom& operator+=(const atom& rhs) {
if (mmin == rhs.mmin)
minc += rhs.minc;
else if (mmin > rhs.mmin)
*this = rhs;
return *this;
}
atom operator+(const atom& rhs) const {
atom w = *this;
w += rhs;
return w;
}
atom operator+=(const int& v) {
mmin += v;
return *this;
}
atom operator+(const int& v) const {
atom w = *this;
w += v;
return w;
}
};
const int maxn = 600001;
struct segtree {
int n;
int a[maxn];
int addv[maxn * 4];
atom t[maxn * 4];
void build(int o, int l, int r) {
if (l == r) {
t[o].mmin = a[l];
t[o].minc = 1;
return;
}
int mid = (l + r) / 2;
build(o * 2, l, mid);
build(o * 2 + 1, mid + 1, r);
t[o] = t[o * 2] + t[o * 2 + 1];
}
void build() { build(1, 1, n); }
int ul, ur, uv;
void update(int o, int l, int r) {
if (l >= ul && r <= ur) {
t[o] += uv;
addv[o] += uv;
return;
}
int mid = (l + r) / 2;
if (ul <= mid) update(o * 2, l, mid);
if (ur > mid) update(o * 2 + 1, mid + 1, r);
t[o] = t[o * 2] + t[o * 2 + 1] + addv[o];
}
void modify(int l, int r, int v) {
ul = l, ur = r, uv = v;
update(1, 1, n);
}
int ql, qr;
atom query(int o, int l, int r, int add) {
if (l >= ql && r <= qr) {
return t[o] + add;
}
atom res;
int mid = (l + r) / 2;
if (ql <= mid) res += query(o * 2, l, mid, add + addv[o]);
if (qr > mid) res += query(o * 2 + 1, mid + 1, r, add + addv[o]);
return res;
}
atom query(int l, int r) {
ql = l, qr = r;
return query(1, 1, n, 0);
}
} t;
int a[maxn];
int q1[maxn + 1], q2[maxn + 1];
int main() {
init();
int n = readint();
for (int i = 1; i <= n; i++) {
int x = readint();
a[x] = readint();
}
t.n = n;
for (int i = 1; i <= n; i++) t.a[i] = n - i;
t.build();
int l1 = n + 1, l2 = n + 1;
q1[n + 1] = q2[n + 1] = n + 1;
long long ans = 0;
for (int i = n; i; i--) {
while (l1 <= n && a[q1[l1]] <= a[i])
t.modify(q1[l1], q1[l1 + 1] - 1, a[i] - a[q1[l1]]), l1++;
q1[--l1] = i;
while (l2 <= n && a[q2[l2]] >= a[i])
t.modify(q2[l2], q2[l2 + 1] - 1, a[q2[l2]] - a[i]), l2++;
q2[--l2] = i;
atom w = t.query(i, n);
ans += w.minc;
t.modify(1, n, -1);
}
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
long long sum;
int n, k, cnt = 1, w[maxn], ans[maxn];
priority_queue<pair<int, int> > q;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", w + i);
}
for (int i = k + 1; i <= k + n; i++) {
for (; cnt <= n && cnt <= i;) {
q.push(make_pair(w[cnt], cnt)), cnt++;
}
pair<int, int> node = q.top();
q.pop();
ans[node.second] = i;
sum += 1ll * node.first * (i - node.second);
}
printf("%lld\n", sum);
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M, A, B;
int Fact[1000005], Inv[1000005];
const int MOD = 1000000007;
int power(int n, int p) {
int sol = 1;
while (p) {
if (p & 1) sol = (1LL * sol * n) % MOD;
p /= 2;
n = (1LL * n * n) % MOD;
}
return sol;
}
void precalcFact() {
Fact[0] = 1;
for (int i = 1; i <= max(N, M); i++) {
Fact[i] = (1LL * Fact[i - 1] * i) % MOD;
}
Inv[max(N, M)] = power(Fact[max(N, M)], MOD - 2);
for (int i = max(N, M) - 1; i >= 0; i--)
Inv[i] = (1LL * Inv[i + 1] * (i + 1)) % MOD;
}
inline int Comb(int n, int k) {
return (((1LL * Fact[n] * Inv[k]) % MOD) * Inv[n - k]) % MOD;
}
int Arrangement(int n, int k) { return (1LL * Comb(n, k) * Fact[k]) % MOD; }
int forestWithKComponents(int n, int k) {
if (n == k) return 1;
return (1LL * k * power(n, n - k - 1)) % MOD;
}
inline int norm(int x) { return x >= MOD ? x - MOD : x; }
void Solve() {
if (N == 2) {
printf("1\n");
return;
}
int ans = 0;
for (int i = 0; i <= min(N - 2, M - 1); i++) {
int val = 1;
val = (1LL * val * Arrangement(N - 2, i)) % MOD;
val = (1LL * val * Comb(M - 1, i)) % MOD;
val = (1LL * val * forestWithKComponents(N, i + 2)) % MOD;
val = (1LL * val * power(M, N - 1 - i - 1)) % MOD;
ans = norm(ans + val);
}
printf("%d\n", ans);
}
int main() {
scanf("%d%d%d%d", &N, &M, &A, &B);
precalcFact();
Solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int x,n,p,i,f,c,d,a=0;
map<int,int> mp;
cin>>x>>n;
for(i=0;i<n;i++)
{
cin>>p;
mp[p]++;
}
c=1; d=1;
f=x;
while(1)
{
if(!mp[f])
{cout<<f; break;}
a++;
if(a%2!=0)
{f=x-c; c++;}
else
{f=x+d; d++;}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long sum[600006];
int main() {
long long a, b, c, l, ans = 0;
cin >> a >> b >> c >> l;
for (long long i = 0; i <= l; i++) {
ans += ((i + 1) * (i + 2)) / 2;
}
sum[0] = 1;
for (long long i = 1; i <= l; i++) {
sum[i] = sum[i - 1] + i + 1;
}
long long mx = max(c, max(a, b));
for (long long i = 1; i <= a + b + c + l; i++) {
if (i < mx) continue;
if (i - b > l) break;
if (a + c > i) continue;
long long x = l - (i - b);
x = min(x, i - (a + c));
ans -= sum[x];
}
for (long long i = 1; i <= a + b + c + l; i++) {
if (i < mx) continue;
if (i - a > l) break;
if (b + c > i) continue;
long long x = l - (i - a);
x = min(x, i - (b + c));
ans -= sum[x];
}
for (long long i = 1; i <= a + b + c + l; i++) {
if (i < mx) continue;
if (i - c > l) break;
if (a + b > i) continue;
long long x = l - (i - c);
x = min(x, i - (a + b));
ans -= sum[x];
}
cout << ans << endl;
}
| 3 |
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <cmath>
#include <tuple>
#include <cstring>
#include <map>
#include <iomanip>
#include <ctime>
#include <complex>
#include <cassert>
#include <climits>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define _ << " " <<
#define all(X) (X).begin(), (X).end()
#define len(X) (X).size()
#define Pii pair<int, int>
#define Pll pair<ll, ll>
#define Tiii tuple<int, int, int>
#define Tlll tuple<ll, ll, ll>
ll gcd(ll a, ll b) {
if (a < b) swap(a, b);
ll r = a % b;
while (r != 0) {
a = b; b = r;
r = a % b;
}
return b;
}
vector<Pll> PF(ll n) {
vector<Pll> fs;
ll base = n;
for (ll i = 2; i * i <= base; i++) {
if (base % i == 0) {
int cnt = 0;
while (base % i == 0) {
base /= i;
cnt++;
}
fs.emplace_back(i, cnt);
}
}
if (base > 1) fs.emplace_back(base, 1);
return fs;
}
int main() {
int p, q;
cin >> p >> q;
int g = gcd(p, q);
vector<Pll> fs = PF(q / g);
int ans = 1;
for (auto &i : fs) ans *= i.first;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
const int MN = 1e5 + 44;
const int NONE = -1;
int per[MN];
int u[MN];
int find(int x) {
if (u[x] == x)
return x;
else
return u[x] = find(u[x]);
}
void unite(int a, int b) { u[find(a)] = find(b); }
int main() {
int n;
scanf("%d", &n);
if (n % 2 == 1) {
int in = 0;
for (int i = 0; i < n; ++i) {
if (in == 0 && i != 0) {
printf("-1\n");
return 0;
}
in = (2 * in + 1) % n;
}
if (in != 0)
printf("-1\n");
else
for (int i = 0; i <= n; ++i) {
printf("%d ", in);
in = (in * 2 + 1) % n;
}
} else {
for (int i = 0; i < n / 2; ++i) {
per[i] = (i * 2) % n;
per[i + n / 2] = (i * 2 + 1) % n;
}
for (int i = 0; i < n; ++i) u[i] = i;
for (int i = 0; i < n; ++i) unite(i, per[i]);
for (int i = 0; i < n / 2; ++i) {
if (find(i) != find(i + n / 2)) {
std::swap(per[i], per[i + n / 2]);
unite(i, i + n / 2);
}
}
}
int wh = 0;
do {
printf("%d ", wh);
wh = per[wh];
} while (wh);
printf("0\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int n;
cin >> n;
string s;
vector<int> a(n);
vector<int> b(n);
cin >> s;
for (int i = 0; i < n; i++) {
int x = s[i] - '0';
int y = s[i + n] - '0';
a[i] = x;
b[i] = y;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (a[0] == b[0]) {
cout << "NO";
return 0;
} else if (a[0] > b[0]) {
int i = 1;
while (i < n) {
if (a[i] <= b[i]) {
cout << "NO";
return 0;
}
i++;
}
} else {
int i = 1;
while (i < n) {
if (a[i] >= b[i]) {
cout << "NO";
return 0;
}
i++;
}
}
cout << "YES";
return 0;
}
| 2 |
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
int n;
while (cin >> n) {
for (int i = 0; i < n; ++i) {
double xa, ya, ra, xb, yb, rb;
cin >> xa >> ya >> ra >> xb >> yb >> rb;
double d = sqrt((xa-xb)*(xa-xb) + (ya-yb)*(ya-yb));
if (d > ra+rb)
cout << "0" << endl;
else if (d+ra < rb)
cout << "-2" << endl;
else if (d+rb < ra)
cout << "2" << endl;
else
cout << "1" << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 220;
int a[maxn];
int sum;
int num;
int ma = -11111;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n * 2 - 1; ++i) cin >> a[i];
for (int i = 0; i < n * 2 - 1; ++i) {
sum += abs(a[i]);
if (a[i] <= 0) {
num++;
ma = max(ma, a[i]);
} else
ma = max(ma, -a[i]);
}
if (n % 2 == 0 && num % 2 == 1) sum += 2 * ma;
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200001];
int main() {
int N, M, i;
scanf("%d%d", &N, &M);
int sum1 = 0, sum2 = 0;
for (i = 1; i <= N; i++) {
scanf("%d", &a[i]);
if (a[i] == 1)
sum1++;
else
sum2++;
}
while (M--) {
int l, r;
scanf("%d%d", &l, &r);
int count = r - l + 1;
if (count % 2 == 1)
cout << "0\n";
else {
int ans = min(sum1, sum2);
if (2 * ans >= count)
cout << "1\n";
else
cout << "0\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int digits, answer = 0;
cin >> digits;
for (int i = 1; i <= digits; i++) {
if ((i % 2) == 0) {
answer += (pow(2, i / 2) * pow(2, i / 2));
} else {
answer += (pow(2, i / 2) * pow(2, 1 + (i / 2)));
}
}
cout << answer;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> getVal(string a) {
string s = "23456789TJQKA";
string t = "SDHC";
return {s.find(a[0]), t.find(a[1])};
}
bool can(pair<int, int> a, pair<int, int> b) {
return a.first == b.first || a.second == b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
string nxt;
cin >> nxt;
v.push_back(getVal(nxt));
}
reverse(v.begin(), v.end());
if (n == 1) {
cout << "YES";
return 0;
}
if (n == 2) {
if (can(v[0], v[1])) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
if (n == 3) {
if (can(v[0], v[1]) && can(v[0], v[2])) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
set<vector<pair<int, int> > > arr = {{v[0], v[1], v[2]}};
for (int i = 3; i < n; i++) {
set<vector<pair<int, int> > > nxt;
if (arr.size() == 0) {
cout << "NO";
return 0;
}
for (auto cur : arr) {
if (can(cur[0], v[i])) {
nxt.insert({cur[1], cur[2], cur[0]});
}
if (can(cur[0], cur[1])) {
nxt.insert({cur[0], cur[2], v[i]});
}
}
arr = nxt;
}
for (auto cur : arr) {
if (can(cur[0], cur[1]) && can(cur[2], cur[0])) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, n, k;
int main() {
cin >> n >> k >> a >> b >> c >> d;
if (k < n + 1 || n <= 4)
cout << -1;
else {
cout << a << ' ' << c << ' ';
for (int i = 1; i <= n; i++)
if (i != a && i != b && i != c && i != d) cout << i << ' ';
cout << d << ' ' << b << endl;
cout << c << ' ' << a << ' ';
for (int i = n; i; i--)
if (i != a && i != b && i != c && i != d) cout << i << ' ';
cout << b << ' ' << d << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int c[1005];
int dp[1005][1005];
int ans = 0;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> c[i];
dp[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = k; j >= c[i]; j--)
for (int l = 0; l <= k - c[i]; l++)
if (dp[j - c[i]][l]) dp[j][l] = dp[j][l + c[i]] = 1;
for (int i = 0; i <= k; i++)
if (dp[k][i]) ans++;
cout << ans << endl;
for (int i = 0; i <= k; i++)
if (dp[k][i]) cout << i << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int rin(int &r) {
int b = 1, c = getchar();
r = 0;
while (c < '0' || '9' < c) b = c == '-' ? -1 : b, c = getchar();
while ('0' <= c && c <= '9') r = (r * 10) + (c ^ '0'), c = getchar();
return r *= b;
}
const int N = 5e5 + 10;
int ncas, n, lseg, rseg;
int num[N];
set<long long> sig;
int solve() {
int mxval = 0;
long long vark = 1, varb = 0;
sig.clear();
if (num[1] & 1) {
lseg = 1, rseg = num[1] - 1;
mxval = 0;
} else {
lseg = 1, rseg = 0;
sig.insert(num[1] >> 1);
mxval = 1;
}
for (int i = 2; i <= n; i++) {
if (lseg <= rseg) {
if (lseg >= num[i])
lseg = 1, rseg = 0;
else
rseg = min(rseg, num[i] - 1);
}
if (vark == 1) {
while (!sig.empty() && *sig.begin() < 1 - varb) sig.erase(sig.begin());
while (!sig.empty() && *sig.rbegin() >= num[i] - varb)
sig.erase(*sig.rbegin());
} else {
while (!sig.empty() && *sig.begin() <= varb - num[i])
sig.erase(sig.begin());
while (!sig.empty() && *sig.rbegin() > varb - 1) sig.erase(*sig.rbegin());
}
if (num[i] & 1)
if (lseg > rseg && sig.empty()) {
lseg = 1, rseg = num[i] - 1;
} else {
if (lseg <= rseg) {
swap(lseg, rseg);
lseg = num[i] - lseg;
rseg = num[i] - rseg;
}
vark = -vark, varb = num[i] - varb;
mxval++;
}
else if (lseg > rseg && sig.empty()) {
lseg = 1, rseg = 0;
sig.insert((((num[i] >> 1) - varb) / vark));
mxval++;
} else {
vark = -vark, varb = num[i] - varb;
if (lseg <= rseg) {
swap(lseg, rseg);
lseg = num[i] - lseg;
rseg = num[i] - rseg;
}
int x = num[i] >> 1;
if ((lseg <= x && x <= rseg) || sig.count((((x)-varb) / vark))) {
lseg = 1, rseg = 0;
sig.clear();
sig.insert((((x)-varb) / vark));
mxval += 2;
} else {
sig.insert((((x)-varb) / vark));
mxval++;
}
}
}
return (n << 1) - mxval;
}
int main() {
rin(ncas);
while (ncas--) {
rin(n);
for (int i = 1; i <= n; i++) rin(num[i]);
printf("%d\n", solve());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, mod = 1e9 + 7, INF = 0x3f3f3f3f;
char s[maxn];
int main() {
int n;
cin >> n;
scanf("%s", s + 1);
int res = 1;
for (int i = 2; i <= n; ++i) res += s[i] != s[i - 1];
int ans = res;
int cnt2 = 0, cnt3 = 0;
for (int i = 1, j = 1; i <= n; i = j) {
while (j <= n && s[i] == s[j]) ++j;
if (j - i == 2) cnt2++;
if (j - i > 2) cnt3++;
}
if (cnt2) ans = max(ans, res + 1);
if (cnt3) ans = max(ans, res + 2);
if (cnt2 > 1) ans = max(ans, res + 2);
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char n[4];
cin >> n;
cout << (n[1] == n[2] && (n[0] == n[1] || n[2] == n[3]) ? "Yes" : "No");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> adj[5001];
vector<int> adj2[5001];
int idx[5001];
int low[5001];
int now;
vector<int> S;
bool onS[5001];
int comp[5001];
int ncomp;
bool good[5001];
vector<int> elem[5001];
int dist[5001];
int Q[5001], head, tail;
void dfs(int u) {
idx[u] = ++now;
low[u] = idx[u];
S.push_back(u);
onS[u] = true;
for (auto& v : adj[u]) {
if (idx[v] == -1) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (onS[v])
low[u] = min(low[u], idx[v]);
}
if (idx[u] == low[u]) {
ncomp++;
int n;
do {
n = S.back();
S.pop_back();
onS[n] = false;
comp[n] = ncomp;
elem[ncomp].push_back(n);
} while (n != u);
}
}
int main() {
scanf("%d%d", &N, &M);
int a, b;
for (int i = 0; i < M; i++) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
}
memset(idx, -1, sizeof idx);
for (int i = 1; i <= N; i++)
if (idx[i] == -1) dfs(i);
for (int u = 1; u <= N; u++)
for (auto& v : adj[u]) {
if (comp[u] != comp[v])
good[comp[u]] = true;
else
adj2[u].push_back(v);
}
int ans = N;
for (int i = 1; i <= ncomp; i++)
if (!good[i]) {
int mdist = 0x3f3f3f3f;
for (auto& u : elem[i]) {
memset(dist, 0x3f, sizeof dist);
dist[u] = 0;
Q[head = 0] = u;
tail = 1;
while (head < tail) {
int x = Q[head++];
for (auto& y : adj2[x]) {
if (y == u)
mdist = min(mdist, dist[x] + 1);
else if (dist[y] == 0x3f3f3f3f) {
dist[y] = dist[x] + 1;
Q[tail++] = y;
}
}
}
}
if (mdist != 0x3f3f3f3f) ans += mdist * 998 + 1;
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
struct key_tree {
int size;
char key[MAXN];
int num[MAXN];
int head[MAXN];
int next[MAXN];
int ans1, ans2;
key_tree() { clear(); };
void clear() {
size = 0;
key[0] = '#';
memset(head, -1, sizeof(head));
memset(num, 0, sizeof(num));
ans1 = 0;
ans2 = 0;
}
void push(int from, char ch) {
size++;
key[size] = ch;
next[size] = head[from];
head[from] = size;
}
void insert(int v, char s[]) {
num[v]++;
if (s[0] == 0) return;
int i;
for (i = head[v]; i != -1; i = next[i]) {
if (key[i] == s[0]) {
insert(i, s + 1);
return;
}
}
push(v, s[0]);
insert(size, s + 1);
}
int find(int v, char s[]) {
if (s[0] == 0) return num[v];
int i;
for (i = head[v]; i != -1; i = next[i]) {
if (key[i] == s[0]) {
return find(i, s + 1);
}
}
return 0;
}
int dfs1(int v) {
int i, ans;
if (head[v] == -1) {
ans = 1;
} else {
ans = 0;
for (i = head[v]; i != -1; i = next[i]) {
ans += dfs1(i);
}
}
if (key[v] == '\\') ans1 = max(ans1, ans);
return ans;
}
int dfs2(int v) {
int i, ans;
if (head[v] == -1) {
ans = 0;
} else {
ans = 0;
for (i = head[v]; i != -1; i = next[i]) {
ans += dfs2(i);
}
}
if (key[v] == '\\') {
ans2 = max(ans2, ans);
ans++;
}
return ans;
}
} tree[5];
char s[1005];
int main() {
int i, j, n, temp, top, k, d, ans1 = 0, ans2 = 0;
while (scanf("%s", s) != EOF) {
d = s[0] - 'C';
tree[d].insert(0, s + 3);
}
for (i = 0; i < 5; i++) {
tree[i].dfs1(0);
tree[i].dfs2(0);
ans1 = max(ans1, tree[i].ans1);
ans2 = max(ans2, tree[i].ans2);
}
printf("%d %d\n", ans2, ans1);
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.