code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main(){
int a, b, c; cin >> a >> b >> c;
bool ok = true;
if(a==b && b!=c){ok = false;}
if(b==c && c!=a){ok = false;}
if(c==a && a!=b){ok = false;}
if(!ok){cout << "Yes" << endl;}
else cout << "No" << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll power(ll p,ll n){
ll result=1;
while(n!=0){
if(n%2==0){
n/=2;
p*=p;
}
else{
n--;
result=result*p;
}
}
return result;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,t,a,b,c,d;
ll mod =1e9+7;
string s1,s2;
stack<ll>stck1;
stack<ll>stck2;
set<ll>st;
cin>>a>>b>>c;
st.insert(a);
st.insert(b);
st.insert(c);
if(st.size()==2){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
}
| 1 |
#include <stdio.h>
int main() {
int A, B;
scanf("%d %d", &A, &B);
int length = A + B + 1, cnt = 0;
char S[50];
scanf("%s", S);
if (S[A] == '-') {
for(int i = 0; i < length; i++) {
if (S[i] >= '0' && S[i] <= '9') {
cnt++;
}
}
if (cnt == length -1) {
printf("Yes\n");
} else {
printf("No\n");
}
} else {
printf("No\n");
}
return 0;
} | #pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,fma,abm,mmx,avx,avx2,tune=native")
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#ifdef rd
#define trace(...) cout<<"Line:"<<__LINE__<<" "; __f(#__VA_ARGS__, __VA_ARGS__)
template<typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cout<<name<<" : "<<arg1<<endl;
}
template<typename Arg1, typename ... Args>
void __f(const char *names, Arg1 &&arg1, Args &&... args) {
const char *comma=strchr(names+1,',');
cout.write(names,comma-names)<<" : "<<arg1<<" | ";
__f(comma+1,args...);
}
#else
#define trace(...)
#define endl '\n'
#endif
#define pb push_back
#define fi first
#define se second
#define int long long
typedef long long ll;
typedef float f80;
#define double long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define sz(x) ((long long)x.size())
#define fr(a,b,c) for(int a=b; a<=c; a++)
#define rep(a,b,c) for(int a=b; a<c; a++)
#define trav(a,x) for(auto &a:x)
#define all(con) con.begin(),con.end()
const ll infl=0x3f3f3f3f3f3f3f3fLL;
const int infi=0x3f3f3f3f;
const int mod=998244353;
//const int mod=1000000007;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> oset;
auto clk=clock();
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0,lim-1);
return uid(rang);
}
int powm(int a, int b) {
int res=1;
while(b) {
if(b&1)
res=(res*a)%mod;
a=(a*a)%mod;
b>>=1;
}
return res;
}
const int N=3e6+5;
int fact[N],ifact[N];
inline int ncr(int n,int r) {
if(n<r||r<0)
return 0;
return (((fact[n]*ifact[r])%mod)*ifact[n-r])%mod;
}
inline int idf(int n, int r) {
return ncr(n+r-1,r-1);
}
int vals[N];
void solve() {
fact[0]=1;
rep(i,1,N)
fact[i]=(fact[i-1]*i)%mod;
ifact[N-1]=powm(fact[N-1],mod-2);
for(int i=N-2; i>=0; i--)
ifact[i]=(ifact[i+1]*(i+1))%mod;
int n,m;
cin>>n>>m;
int ans=idf(3*m,n);
for(int i=2*m+1; i<=3*m; i++) {
ans=(ans-n*idf(3*m-i,n-1))%mod;
}
for(int i=m+2; i<=3*m; i+=2) {
ans=(ans-ncr(n,i)*idf((3*m-i)/2,n))%mod;
}
if(ans<0)
ans+=mod;
cout<<ans<<endl;
}
signed main() {
ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
cout<<fixed<<setprecision(10);
int t=1;
// cin>>t;
fr(i,1,t)
{
solve();
}
#ifdef rd
cout<<endl<<endl<<endl<<endl<<"Time elapsed: "<<(double)(clock()-clk)/CLOCKS_PER_SEC<<endl;
#endif
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for(int i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
vi dir = {-1, 0, 1, 0, -1, -1, 1, 1, -1};
int main() {
int n;
cin >> n;
multiset<ll> st;
rep(i, n) {
ll a;
cin >> a;
st.insert(a);
}
ll ans = 0;
ll p2 = pow(2, 34);
while(!st.empty()) {
auto it = st.end();
it--;
ll p = p2;
while(p > *it) {
p /= 2;
auto jt = st.lower_bound(p - *it);
if(jt == it || jt == st.end() || *jt != p - *it) continue;
st.erase(jt);
ans++;
break;
}
st.erase(it);
}
cout << ans << endl;
} | #include <iostream>
#include <sstream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <set>
#include <map>
#include <queue>
#include <string>
#include <cstring>
#include <bitset>
#include <functional>
#include <random>
#define REP(_i,_a,_n) for(int _i=_a;_i<=_n;++_i)
#define PER(_i,_a,_n) for(int _i=_n;_i>=_a;--_i)
#define hr putchar(10)
#define pb push_back
#define lc (o<<1)
#define rc (lc|1)
#define mid ((l+r)>>1)
#define ls lc,l,mid
#define rs rc,mid+1,r
#define x first
#define y second
#define io std::ios::sync_with_stdio(false)
#define endl '\n'
#define DB(_a) ({REP(_i,1,n) cout<<_a[_i]<<',';hr;})
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int P = 1e9+7, INF = 0x3f3f3f3f;
ll gcd(ll a,ll b) {return b?gcd(b,a%b):a;}
ll qpow(ll a,ll n) {ll r=1%P;for (a%=P;n;a=a*a%P,n>>=1)if(n&1)r=r*a%P;return r;}
ll inv(ll x){return x<=1?1:inv(P%x)*(P-P/x)%P;}
inline int rd() {int x=0;char p=getchar();while(p<'0'||p>'9')p=getchar();while(p>='0'&&p<='9')x=x*10+p-'0',p=getchar();return x;}
//head
#ifdef __APPLE__
const int N = 1e2+50;
#else
const int N = 1e6+50;
#endif
int n, a[N];
map<int,int> v;
int main() {
scanf("%d", &n);
REP(i,1,n) scanf("%d", a+i), ++v[a[i]];
sort(a+1,a+1+n,greater<int>());
int ans = 0;
REP(i,1,n) if (v[a[i]]) {
REP(j,0,30) {
int t = (1<<j)-a[i];
if (!v.count(t)) continue;
if (a[i]!=t&&v[t]||v[t]>=2) {
++ans, --v[a[i]], --v[t];
break;
}
}
}
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
#define ll long long
#define rep(i,a,b) for(long long i=a; i<b; i+=1)
#define repr(i,a,b) for(long long i=a; i<=b; i+=1)
#define vec vector<ll>
#define mapa map<char,int>
#define repa(p,A) for(auto p:A)
#define pb push_back
/*#define sort(a) sort(a.begin(),a.end())*/
#define reverse(a) reverse(a.begin(),a.end())
const double PI=acos(-1);
using namespace std;
int main( ) {
vec A,B;
ll N;
cin>>N;
rep(i,0,N) {
ll a;
cin>>a;
if(i%2==0) {
A.push_back(a);
}
else {
B.push_back(a);
}
}
map<ll,ll> C,D;
rep(i,0,A.size()) {
C[A[i]]++;
}
rep(i,0,B.size()) {
D[B[i]]++;
}
vector<pair<ll,ll>> E,F;
for(auto p:C) {
E.push_back(pair<ll,ll>(p.first,p.second));
}
for(auto p:D) {
F.push_back(pair<ll,ll>(p.first,p.second));
}
auto comp = [](pair<int, int> a, pair<int, int> b) {
return a.second>b.second;
};
ll count=0;
sort(E.begin(),E.end(),comp);
sort(F.begin(),F.end(),comp);
if(E[0].first==F[0].first) {
if(E.size()>=2) {
count+=E[0].second+max(E[1].second,F[1].second);
}
else count+=E[0].second;
}
else count+=E[0].second+F[0].second;
cout<<N-count<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin>>n;
int m=n;
int ans=0;
for(int i=0;i<n;i++)
{
int p;
cin>>p;
if(p<=m)ans++;
m=min(p,m);
}
cout<<ans<<"\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string a;
int b;
int main(){
cin>>a>>b;
for(int i=0;i<a.size();i+=b)
cout<<a[i];
return 0;
} | #include <bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
using namespace std;
const long long int INF = 1e18;
const long long int mod = 1e9+7;
typedef pair<ll,ll> pairs;
vector<pairs> p;
ll gcd(ll A,ll B){
if (A%B==0)return(B);
else return(gcd(B,A%B));
}
ll keta(ll N){
int tmp{};
while( N > 0 ){
tmp += ( N % 10 );
N /= 10;
}
N = tmp;
return N;
}
vector<vector<ll>> combination(ll n, ll r){
vector<vector<ll>> v(n + 1, vector<ll>(n + 1, 0));
for(ll i=0;i<v.size();++i){
v[i][0] = 1;
v[i][i] = 1;
}
for(ll i=1;i<v.size();++i){
for(ll j=0;j<i;++j){
v[i][j] = (v[i - 1][j - 1] + v[i - 1][j]);
}
}
return v;
}
bool kai(string S){
bool flag = true;
for(ll i=0;i<S.size()/2;++i){
if(S[i] != S[S.size()-i-1]){
flag = false;
break;
}
}
return flag;
}
// ---------------------------------------------
int main(){
string s;
cin>>s;
ll w;
cin>>w;
for(ll i=0;i<s.size();i+=w){
cout<<s[i];
}
cout<<endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<char> sL(n), sR(n);
for (int i = 0; i < n; i++) {
cin >> sL[i];
}
for (int i = 0; i < n; i++) {
cin >> sR[i];
}
map<pair<string, string>, int> mpL;
for (int bit = 0; bit < 1<<n; bit++) {
string reds = "", blues = "";
for (int i = 0; i < n; i++) {
if (bit & 1<<i) {
reds.push_back(sL[i]);
}
else {
blues.push_back(sL[i]);
}
}
mpL[make_pair(reds, blues)]++;
}
long long ans = 0;
for (int bit = 0; bit < 1<<n; bit++) {
string reds = "", blues = "";
for (int i = 0; i < n; i++) {
if (bit & 1<<i) {
reds.push_back(sR[i]);
}
else {
blues.push_back(sR[i]);
}
}
reverse(reds.begin(), reds.end());
reverse(blues.begin(), blues.end());
ans += mpL[make_pair(blues, reds)];
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,n) for(ll i=0;i<n;i++)
#define Graph vector<vector<ll>>
#define INF (1ll<<60)
#define mod 1000000007
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
string N;cin>>N;
reverse(N.begin(),N.end());
vector<vector<ll>> dp(1000010,vector<ll>(2/*桁上がりあるか*/,INF));
dp[0][0]=0;
N.push_back('0');
for(ll i=0;i<N.size();i++){
ll now=N[i]-'0';
//前桁上がり判定ありの時
ll nowb=now+1;
if(dp[i][1]!=INF){
//今equal
chmin(dp[i+1][0],dp[i][1]+nowb);
//今もbigger
chmin(dp[i+1][1],dp[i][1]+(10-nowb));
}
//前桁上がり判定無し
if(dp[i][0]!=INF){
//今桁上がり判定無し
chmin(dp[i+1][0],dp[i][0]+now);
//今桁上がり判定あり
chmin(dp[i+1][1],dp[i][0]+(10-now));
}
}
cout<<min(dp[N.size()][0],dp[N.size()][1])<<endl;
return 0;
}
| 0 |
#include<cstdio>
typedef long long ll;
const ll mod=998244353;
inline ll rev(ll x)
{ll k=mod-2,r=1;for(;k;k>>=1,(x*=x)%=mod)if(k&1)(r*=x)%=mod;return r;}
ll fac[1111111],inv[1111111];
inline ll C(int n,int r)
{return((((fac[n]*inv[r])%mod)*inv[n-r])%mod);}
int main()
{
int n,m;
scanf("%d%d",&n,&m);
if(n<m)n^=m,m^=n,n^=m;
fac[0]=inv[0]=1;
register int i;
for(i=1;i<=n+m;i++)fac[i]=(fac[i-1]*i)%mod;
inv[n+m]=rev(fac[n+m]);
for(i=n+m-1;i;i--)inv[i]=inv[i+1]*(i+1)%mod;
ll ans=0;
for(i=1;i<=m;i++)
(ans+=C(i*2,i)*C(n+m-2*i,n-i))%=mod;
(((ans*=rev(2*C(n+m,n)))%=mod)+=n+mod)%=mod;
printf("%lld\n",ans);
} | #pragma GCC optimize("Ofast","inline")
#include <bits/stdc++.h>
#define clr(x) memset(x,0,sizeof (x))
#define For(i,a,b) for (int i=a;i<=b;i++)
#define Fod(i,b,a) for (int i=b;i>=a;i--)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define _SEED_ ('C'+'L'+'Y'+'A'+'K'+'I'+'O'+'I')
#define outval(x) printf(#x" = %d\n",x)
#define outvec(x) printf("vec "#x" = ");for (auto _v : x)printf("%d ",_v);puts("")
#define outtag(x) puts("----------"#x"----------")
#define outarr(a,L,R) printf(#a"[%d...%d] = ",L,R);\
For(_v2,L,R)printf("%d ",a[_v2]);puts("");
using namespace std;
typedef long long LL;
LL read(){
LL x=0,f=0;
char ch=getchar();
while (!isdigit(ch))
f|=ch=='-',ch=getchar();
while (isdigit(ch))
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return f?-x:x;
}
const int N=2005,mod=998244353;
void Add(int &x,int y){
if ((x+=y)>=mod)
x-=mod;
}
void Del(int &x,int y){
if ((x-=y)<0)
x+=mod;
}
int del(int x,int y){
return x-y<0?x-y+mod:x-y;
}
int Pow(int x,int y){
int ans=1;
for (;y;y>>=1,x=(LL)x*x%mod)
if (y&1)
ans=(LL)ans*x%mod;
return ans;
}
int n,m;
int dp[N][N];
const int BN=1000005;
int Fac[BN],Inv[BN],Iv[BN];
int C(int n,int m){
if (m<0||m>n)
return 0;
return (LL)Fac[n]*Inv[m]%mod*Inv[n-m]%mod;
}
int IC(int n,int m){
return (LL)Inv[n]*Fac[m]%mod*Fac[n-m]%mod;
}
void prework(){
int n=BN-1;
for (int i=Fac[0]=1;i<=n;i++)
Fac[i]=(LL)Fac[i-1]*i%mod;
Inv[n]=Pow(Fac[n],mod-2);
Fod(i,n,1)
Inv[i-1]=(LL)Inv[i]*i%mod;
For(i,1,n)
Iv[i]=(LL)Inv[i]*Fac[i-1]%mod;
}
namespace so60{
void prework(){
int n=3,m=3;
For(i,0,n)
For(j,0,m){
if (i==0&&j==0)
dp[i][j]=0;
else if (i>=j){
dp[i][j]=((LL)dp[i-1][j]*i%mod*Iv[i+j]+dp[i][j])%mod;
if (j>0)
dp[i][j]=((LL)(dp[i][j-1]+1)*j%mod*Iv[i+j]+dp[i][j])%mod;
}
else {
dp[i][j]=((LL)dp[i][j-1]*j%mod*Iv[i+j]+dp[i][j])%mod;
if (i>0)
dp[i][j]=((LL)(dp[i-1][j]+1)*i%mod*Iv[i+j]+dp[i][j])%mod;
}
}
}
const int N=500005;
int a[N],d[N],dd[N],ddd[N];
int main(){
prework();
For(i,1,3){
a[i]=dp[i][i];
d[i]=(dp[i][i]-dp[i-1][i-1]+mod)%mod;
dd[i]=(d[i]-d[i-1]+mod)%mod;
ddd[i]=(LL)Pow(dd[i],mod-2)*Pow(2,i*2)%mod;
}
For(i,4,n){
ddd[i]=(LL)ddd[i-1]*(i*4-2)%mod*Pow(i-2,mod-2)%mod;
dd[i]=(LL)Pow(2,i*2)*Pow(ddd[i],mod-2)%mod;
d[i]=(d[i-1]+dd[i])%mod;
a[i]=(a[i-1]+d[i])%mod;
}
cout<<a[n]<<endl;
return 0;
}
}
int main(){
prework();
n=read(),m=read();
if (n>m)
swap(n,m);
// if (n==m)
// return so60::main();
int ans=(LL)n*C(n+m,n)%mod;
For(i,1,n)
Del(ans,(LL)C(i+i-1,i)*C(n-i+m-i,n-i)%mod);
ans=(LL)ans*IC(n+m,n)%mod;
ans=(n+m-ans+mod)%mod;
cout<<ans<<endl;
return 0;
} | 1 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <functional>
#include <ctime>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
class UnionFind {
public:
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
int main() {
ll n;
cin >> n;
ll a = 11;
while (n > 0) {
ll k = 0;
for (int i = 2; i < sqrt(a)+1; i++) {
if (a % i == 0)k = 1;
}
if (k == 0) {
cout << a;
n--;
if (n == 0)break;
cout << " ";
}
a += 5;
}
cout << endl;
} | #include <iostream>
#include <vector>
#include <climits>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <bitset>
#include <utility>
#include <numeric>
#include <queue>
#include <stack>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9 + 7);
template<typename T>
vector<T> prime_factorization(T n) {
vector<T> ret;
vector<bool> is_prime(n + 1, true);
for(T i = 2; i <= n; ++i) {
if( is_prime[i] ) {
for(T j = 2 * i; j <= n; j += i) {
is_prime[j] = false;
}
if( i % 5 == 1 ) ret.push_back(i);
}
}
return ret;
}
int main(void) {
int n;
cin >> n;
vector<int> primes = prime_factorization(55555);
for(int i = 0; i < n; ++i) {
cout << primes[i] << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <array>
using namespace std;
using ULL = unsigned long long;
using UL = unsigned;
using LL = long long;
#define rep(i, n) for(UL i = 0; i < (n); i++)
struct Problem {
UL S[2001][2001] = {};
UL J1[2001][2001] = {};
UL J2[2001][2001] = {};
void Query() {
UL y1, y2, x1, x2; cin >> y1 >> x1 >> y2>> x2;
y1--; x1--;
UL mass = S[x2][y2] + S[x1][y1] - S[x1][y2] - S[x2][y1];
UL J1s = J1[x2][y2] + J1[x1 + 1][y1] - J1[x1 + 1][y2] - J1[x2][y1];
UL J2s = J2[x2][y2] + J2[x1][y1 + 1] - J2[x1][y2] - J2[x2][y1 + 1];
cout << (mass - J1s - J2s) << endl;
}
void Solve() {
UL H, W; cin >> H >> W;
UL Q; cin >> Q;
rep(y, H) rep(x, W) {
char c; cin >> c;
S[x + 1][y + 1] = (c - '0');
}
rep(y, H) rep(x, W) if (S[x][y + 1] && S[x + 1][y + 1]) J1[x + 1][y + 1] = 1;
rep(y, H) rep(x, W) if (S[x + 1][y] && S[x + 1][y + 1]) J2[x + 1][y + 1] = 1;
rep(y, H) rep(x, W) S[x + 1][y + 1] += S[x][y + 1];
rep(y, H) rep(x, W) S[x + 1][y + 1] += S[x + 1][y];
rep(y, H) rep(x, W) J1[x + 1][y + 1] += J1[x][y + 1];
rep(y, H) rep(x, W) J1[x + 1][y + 1] += J1[x + 1][y];
rep(y, H) rep(x, W) J2[x + 1][y + 1] += J2[x][y + 1];
rep(y, H) rep(x, W) J2[x + 1][y + 1] += J2[x + 1][y];
rep(i, Q) Query();
}
Problem();
};
int main() {
unique_ptr<Problem> p(new Problem());
p->Solve();
return 0;
}
Problem::Problem() {
cout << fixed << setprecision(10);
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <bitset>
#include <cstring>
#include <deque>
#include <iomanip>
#include <limits>
#include <fstream>
using namespace std;
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, 0, sizeof(mat))
typedef long long ll;
typedef pair<int, int> P;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n,d1,d2;
cin>>n>>d1>>d2;
vector<int> SQRT(4*n*n+1,-1);
for(int i=0;i<=2*n;i++){
SQRT[i*i]=i;
}
vector<vector<int> > alive(2*n, vector<int>(2*n, 1));
for(int rot=0;rot<2;rot++){
int d=(rot==0?d1:d2);
vector<vector<int> > was(2*n, vector<int>(2*n, 0));
for(int i=0;i<2*n;i++){
for(int j=0;j<2*n;j++){
if(was[i][j]||!alive[i][j])continue;
vector<P> que(1, P(i,j));
was[i][j]=1;
for(int b=0;b<(int)que.size();b++){
int x=que[b].first;
int y=que[b].second;
for(int xx=0;xx<2*n;xx++){
int dy=d-(x-xx)*(x-xx);
if(dy>=0&&dy<=4*n*n&&SQRT[dy]!=-1){
dy=SQRT[dy];
int yy=y-dy;
if(yy>=0&&yy<2*n&&was[xx][yy]==0&&alive[xx][yy]){
que.emplace_back(xx, yy);
was[xx][yy]=3-was[x][y];
}
if(dy != 0){
yy = y + dy;
if(yy>=0&&yy<2*n&&was[xx][yy]==0&&alive[xx][yy]){
que.emplace_back(xx, yy);
was[xx][yy]=3-was[x][y];
}
}
}
}
}
vector<int> cc(3, 0);
for(auto &p : que){
cc[was[p.first][p.second]]++;
}
int best = (cc[1] > cc[2] ? 1 : 2);
for(auto &p : que){
if(was[p.first][p.second] != best){
alive[p.first][p.second] = 0;
}
}
}
}
}
int cc=n*n;
FOR(i,0,2*n){
FOR(j,0,2*n){
if(alive[i][j]){
cc--;
cout << i << " " << j << endl;
if(cc==0) return 0;
}
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
/********************************************************************/
#define M1 1000000007
#define M2 998244353
const double pi = 3.14159265;
#define ll long long
#define pll pair<ll,ll>
#define forr(i, n) for(ll i=0;i<n;i++)
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define MT make_tuple
#define V(a) vector<a>
#define vi vector<ll>
#define CASE(t) ll t; cin>>t; while(t--)
#define endl '\n'
#define space ' '
#define enter cout<<endl
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define all(x) x.begin(), x.end()
#define sortall(x) sort(all(x))
#define collect(v, n) for(ll i = 0; i < n;i++){cin>>v[i];}
#define deci(n) fixed << setprecision(n) //sets no of digits to show after decimal
#define setcount(n) __builtin_popcount(n) //the number of ones in the int
#define setcountll(n) __builtin_popcountll(n) //the number of ones in the ll
#define parity(n) __builtin_parity(n) //the parity (even or odd) of the number of ones
#define clz(n) __builtin_clz(n) //the number of zeros at the beginning of the number
#define clzll(n) __builtin_clzll(n) //the number of zeros at the beginning of the ll
#define ctz(n) __builtin_ctz(n) //the number of zeros at the end of the number
void deb(ll x) { cout << x << endl;}
void deb(int x) { cout << x << endl;}
void deb(unsigned int x) { cout << x << endl;}
void deb(unsigned ll x) { cout << x << endl;}
void deb(float x) { cout << x << endl;}
void deb(double x) { cout << x << endl;}
void deb(long double x) { cout << x << endl;}
void deb(char x) {cout << '\'' << x << '\'' << endl;}
void deb(string s) { cout << '\"' << s << '\"' << endl;}
void deb(vector<ll> v) { for (auto x : v) cout << x << ' '; cout << endl;}
void deb(bool bb) {cout << (bb ? "True" : "False") << endl;}
void deb(map<ll, ll> mpp) {for (auto x : mpp) cout << x.first << ' ' << x.second << endl;}
void deb(pair<ll, ll> pp) { cout << "{" << pp.first << "," << pp.second << "}" << endl;}
ll gcd(ll x, ll y) {
if (x == 0) return y;
return gcd((ll) y % x, (ll) x);
}
template<typename T>
#define o_set(T) tree<T, null_type,less_equal<T>, rb_tree_tag,tree_order_statistics_node_update>
//member functions :
//1. order_of_key(k) : number of elements strictly lesser than k
//2. find_by_order(k) : k-th element in the set
// MULTISET ==> less_equal
// SET ==> less
ll powM(ll x, ll y, ll m) {
ll ans = 1, r = 1;
x %= m;
while (r > 0 && r <= y) {
if (r & y) {
ans *= x;
ans %= m;
}
r <<= 1;
x *= x;
x %= m;
}
return ans;
}
map<long long, long long> factorize(long long n) {
map<long long, long long> ans;
for (long long i = 2; i * i <= n; i++) {
while (n % i == 0) {
ans[i]++;
n /= i;
}
}
if (n > 1) {
ans[n]++;
n = 1;
}
return ans;
}
ll countBits(ll n) {
ll count = 0;
while (n)
{
count++;
n >>= 1;
}
return count;
}
ll isP(ll n) {
if (n == 0 || n == 1)
return 0;
for (ll i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return 0;
}
return 1;
}
/* **********END OF TEMPLATE*********** */
ll check(ll ar[], ll mid, ll k, ll n) {
ll tmp = 0;
for (ll i = 0; i < n; i++) {
tmp += (ar[i] / mid + (ar[i] % mid != 0) - 1);
}
if (tmp <= k)
return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
ll k;
cin >> n >> k;
double ar[n];
for (ll i = 0; i < n; i++) {
cin >> ar[i];
ar[i] = (double)(ar[i] + 1) / (double)2;
}
double prefs[n + 1];
prefs[0] = 0.0000;
for (ll i = 0; i < n; i++) {
prefs[i + 1] = prefs[i] + ar[i];
}
double mx = -1;
for (ll i = k; i <= n; i++) {
if (prefs[i] - prefs[i - k] > mx)
mx = (prefs[i] - prefs[i - k]);
}
cout << deci(10) << mx << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int d,g,m;
m=pow(10,5);
cin >> d >> g;
vector<pair<int,int>> v;
int a,b;
for(int i=0;i<d;i++){
cin >> a >> b;
pair<int,int> p(a,b);
v.push_back(p);
}
for(int i=0; i<(1<<d); i++){
bitset<10> bit(i);
bitset<10> check(0);
int ans,item;
ans=0;
item=0;
for(int j=0; j<d; j++){
if(bit[j]==1){
ans+=100*(j+1)*v.at(j).first+v.at(j).second;
check.set(j,1);
item+=v.at(j).first;
}
}
int stop = d-1;
while(true){
if(ans>=g || stop<0){
break;
}
if(check[stop]==0){
check.set(stop,1);
if(ans+100*(stop+1)*(v.at(stop).first-1)>g){
item+=ceil(1.0*(g-ans)/(100*(stop+1)));
ans = g;
break;
}
else{
ans += 100*(stop+1)*(v.at(stop).first-1);
item+=v.at(stop).first-1;
}
}
stop--;
}
if(m>item && ans >= g){
m=item;
}
}
cout << m << endl;
}
| 0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define MAX 100
int min(int,int);
int p[MAX+1]={},m[MAX+1][MAX+1]={};
int min(int n1,int n2){
if(n1>n2) return n2;
else return n1;
}
int main()
{
int n,l,i,j,k;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d %d",&p[i-1],&p[i]);
}
for(l=2;l<=n;l++){
for(i=1;i<=n-l+1;i++){
j=i+l-1;
m[i][j]=(1<<21);
for(k=i;k<=j-1;k++){
m[i][j]=min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
}
}
}
printf("%d\n",m[1][n]);
return 0;
} | #include <bits/stdc++.h>
#define N 101
using namespace std;
int A[N];
int mem[N][N],used[N][N];
int dfs(int l,int r){
if(l == r) return 0;
if(r - l == 1) return A[l]*A[r]*A[r+1];
if(used[l][r]++) return mem[l][r];
int res = 1e9;
for(int i=l;i<r;i++){
int a = dfs(l,i);
int b = dfs(i+1,r);
int c = A[l] * A[i+1] * A[r+1];
res = min(res,a + b + c);
}
return mem[l][r] = res;
}
int main(){
int n;
cin>>n;
for(int i=0,cnt=0;i<n;i++){
int a,b;
cin>>a>>b;
if(i == 0) A[cnt++] = a;
A[cnt++] = b;
}
cout<<dfs(0,n-1)<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(), x.end()
int32_t main()
{
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<int> index;
int c = 0;
index.push_back(c);
for (int i = 0; i < s.size() - 1; i++)
{
if (s[i] == 'A')
{
if (s[i + 1] == 'C')
{
index.push_back(++c);
}
else
{
index.push_back(c);
}
}
else
{
index.push_back(c);
}
}
while (q--)
{
int l, r;
cin >> l >> r;
cout<< index[--r]-index[--l]<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
ll factorial(int i) { //階乗
if (i == 0) return 1;
return (factorial(i - 1)) * i;
}
int main() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<int> ac(n);
vector<int> sum(n + 1, 0);
rep(i, n) {
if(i != n) {
if(s[i] == 'A' && s[i + 1] == 'C') {
ac[i]++;
i++;
}
}
}
rep(i, n) {
sum[i + 1] += sum[i] + ac[i];
}
/*cout << endl;
rep(i, n) cout << ac[i] << ' ';
cout << endl;
rep(i, n + 1) cout << sum[i] << ' ';
cout << endl;
//確認済*/
vector<vector<int>> l(q, vector<int>(2));
rep(i, q) {
rep(j, 2) cin >> l[i][j];
}
rep(i, q) {
cout << sum[l[i][1] - 1] - sum[l[i][0] - 1] << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int,int>
#define fi first
#define sc second
#define all(x) (x).begin(),(x).end()
void MAIN() {
int n, m;
cin >> n >> m;
int cnt = 0;
vector<string> s(n + 1);
for (int i = 1; i <= n; i++) {
cin >> s[i];
s[i] = "-" + s[i];
for (int j = 1; j <= m; j++) {
if (s[i][j] == '#') cnt++;
}
}
vector<vector<int>> v(n + 1, vector<int>(m + 1));
struct tup {
int fi, sc, th;
tup() {}
tup(int fi, int sc, int th):
fi(fi), sc(sc), th(th) {}
};
vector<int> r = {-1, 0, 1, 0};
vector<int> c = {0, -1, 0, 1};
queue<tup> q;
q.push(tup(1, 1, 1));
while (q.size()) {
int x = q.front().fi;
int y = q.front().sc;
int z = q.front().th;
q.pop();
if (x < 1 || x > n || y < 1 || y > m) continue;
if (v[x][y] || s[x][y] == '#') continue;
v[x][y] = z;
for (int i = 0; i < 4; i++) {
q.push(tup(x + r[i], y + c[i], z + 1));
}
}
if (v[n][m] == 0) {
cout << -1 << '\n';
return;
}
cout << n * m - cnt - v[n][m] << '\n';
}
signed main() {
#ifdef _DEBUG
// freopen("in" , "r", stdin );
#endif
// ios::sync_with_stdio(0); cin.tie(0);
int T = 1;
// cin >> T;
while (T--) MAIN();
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0; i < (n); ++i)
#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)
using ll = long long;
#define INF 1e9
int N, M;
vector<vector<int>> graph;
vector<int> deg, order;
void toporo(){
queue<int> que;
REP(i, N){
if(deg[i] == 0){
que.push(i);
}
}
while(!que.empty()){
int v = que.front(); que.pop();
order.push_back(v);
for(auto nv : graph[v]){
--deg[nv];
if(deg[nv] == 0) que.push(nv);
}
}
reverse(order.begin(), order.end());
}
int main(){
cin >> N >> M;
deg.resize(N);
graph.resize(N);
vector<vector<int>> in(N);
REP(i, N+M-1){
int a, b;
cin >> a >> b;
a--, b--;
graph[b].push_back(a);
deg[a]++;
}
toporo();
vector<int> depth(N);
REP(i, N){
depth[order[i]] = i;
}
REP(i, N){
int oya = 0, d = -1;
for(auto v :graph[i]){
if(d < depth[v]){
d = depth[v];
oya = v+1;
}
}
cout << oya << endl;
}
return 0;
}
| 0 |
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma warning(disable : 4996)
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>
#include<bitset>
#include<limits.h>
#include<cassert>
#include<iterator>
#include<complex>
#include<stack>
#include<unordered_map>
#include<unordered_set>
#include<time.h>
#include<random>
#include<array>
using namespace std;
#define REP(i, n) for(int i = 0;i < n;++i)
#define REPR(i, n) for(int i = n-1;i >= 0;--i)
#define FOR(i, m, n) for(int i = m;i < n;++i)
#define FORR(i, m, n) for(int i = m-1;i >= n;--i)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v,n) reverse(v,v+n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define print(x) cout<<(x)<<'\n'
#define pe(x) cout<<(x)<<" "
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define lb(v,n) lower_bound(v.begin(), v.end(), (n))
#define ub(v,n) upper_bound(v.begin(), v.end(), (n))
#define int long long
//#define double long double
#define all(x) (x).begin(), (x).end()
#define print_space(v) REP(i,v.size())cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template<typename T1, typename T2> inline void chmin(T1 & a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
typedef pair<int, int>P;
typedef array<int, 3> arr3;
std::random_device rd;
std::mt19937 mt(rd());
constexpr int MOD = 998244353; constexpr int MAX = 2000020;
const double pi = acos(-1); constexpr double EPS = 1e-8;
constexpr ll INF = 1e18;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll add(ll x, ll y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
ll mult(ll x, ll y) {
return (x * y) % MOD;
}
ll bin_pow(ll x, ll p) {
if (p == 0) return 1;
if (p & 1) return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
void solve() {
int N, M; cin >> N >> M;
ll ans = 0;
COMinit();
REP(k, min(N+1,M + 1)) {
if (M % 2 != k%2)continue;
int tmp = COM(N, k);
int c = (3 * M - k) / 2;
tmp = mult(tmp, mult(finv[c],mult(finv[N-1],fac[c + N - 1])));
int c2 = (M - k) / 2;
int sb1 = mult(mult(COM(N,k),k), mult(fac[c2 + N - 1], mult(finv[c2], finv[N - 1])));
int c3 = (M - k - 2) / 2;
if (c3 >= 0) {
int sb2 = mult(mult(COM(N,k),N - k), mult(fac[c3 + N - 1], mult(finv[c3], finv[N - 1])));
tmp = sub(tmp, sb2);
}
tmp = sub(tmp, sb1);
ans = add(ans, tmp);
}
print(ans);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
//int q; cin >> q;
//while (q--)
solve();
}
| #include <bits/stdc++.h>
using i64 = long long;
long long *fact, *inv;
template <typename T, typename U, typename V>
auto pow(T x_, U n_, V mod_) {
using R = std::common_type_t<T, U, V>;
R ret = 1, x = x_, n = n_, mod = mod_;
while(n > 0) {
if ((n & 1) == 1) ret = (ret * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return ret;
}
template <typename T, typename U>
auto inverse(T x, U p) { return pow(x, p - 2, p); }
void init_factorial(int n, long long mod) {
fact = new long long[n + 1];
inv = new long long[n + 1];
fact[0] = 1;
for (long long i = 1; i <= n; i++) fact[i] = fact[i - 1] * i % mod;
inv[n] = inverse(fact[n], mod);
for (long long i = n; i > 0; i--) inv[i - 1] = inv[i] * i % mod;
}
int main() {
constexpr i64 mod = 998244353;
int n, m;
std::cin >> n >> m;
init_factorial(n + 3 * m, mod);
i64 ret = 0;
for (int i = 0; i <= std::min(n, m); i++) {
int r = 3 * m - i;
if (r & 1) continue;
r >>= 1;
i64 t = fact[r + n - 1] * inv[n - 1] % mod * inv[r] % mod;
ret = (ret + t * fact[n] % mod * inv[i] % mod * inv[n - i] % mod) % mod;
}
for (int i = 0; i <= std::min(n, m); i++) {
int r = m - i;
if (r & 1) continue;
r >>= 1;
i64 t = fact[r + n - 1] * inv[n - 1] % mod * inv[r] % mod;
ret = (ret + mod - t * fact[n] % mod * inv[i] % mod * inv[n - i] % mod * n % mod) % mod;
}
for (int i = 0; i <= std::min(n - 1, m); i++) {
int r = m - i;
if (r & 1) continue;
r >>= 1;
i64 t = fact[r + n - 2] * inv[n - 2] % mod * inv[r] % mod;
ret = (ret + t * fact[n - 1] % mod * inv[i] % mod * inv[n - i - 1] % mod * n % mod) % mod;
}
std::cout << ret << std::endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int K;
cin>>K;
string S;
cin>>S;
if(S.size()<=K) cout<<S<<endl;
else cout<<S.erase(K)+"..."<<endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
int main()
{
int t=1;
//cin>>t;
while( t-- )
{
int k;
cin>>k;
string s;
cin>>s;
if( s.size()<=k )
cout<<s;
else
{
for( int i=0 ; i<k ; i++ )
cout<<s[i];
cout<<"..."<<endl;
}
}
return 0;
}
| 1 |
/*
ID: anonymo14
TASK: wormhole
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
void solve(int test_case) {
int n;
cin>>n;
vi arr(n);
for(int &i:arr)cin>>i;
sort(arr.rbegin(),arr.rend());
ll ans=1;
int cnt = 0;
for(int i=0;i<n-1;i++) {
if(arr[i]==arr[i+1])ans*=arr[i],i++,cnt++;
if(cnt==2)break;
}
if(cnt!=2)cout<<0;
else
cout<<ans;
}
int main() {
////// FILE BASED IO////
//freopen("wormhole.in", "r", stdin);
//freopen("wormhole.out", "w", stdout);
///////////////
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
//cin>>t;
REP(i,1,t) {
solve(i);
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
main()
{
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
long long i,j,k,l,m,n,o,p;
string s;
while(cin>>n){
int x[n];
map<long long,long long>mp;
for(i=0;i<n;i++){
cin>>x[i];
}
sort(x,x+n);
long long a=0,b=0;
for(i=n-1;i>0;i--){
if(x[i]==x[i-1]){
if(a==0)a=x[i];
else if(b==0)b=x[i];
else break;
i--;
}
}
cout<<a*b<<endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template<typename T>
struct Segtree {
int n;
T e;
vector<T> dat;
typedef function<T(T a, T b)> Func;
Func f;
Segtree(){}
Segtree(int n_input, Func f_input, T e_input){
initialize(n_input, f_input, e_input);
}
void initialize(int n_input, Func f_input, T e_input){
f = f_input;
e = e_input;
n = 1;
while(n < n_input) n <<= 1;
dat.resize(2*n-1, e);
}
void update(int k, T a){
k += n - 1;
dat[k] = a;
while(k > 0){
k = (k - 1)/2;
dat[k] = f(dat[2*k+1], dat[2*k+2]);
}
}
T get(int k){
return dat[k+n-1];
}
T between(int a, int b){
return query(a, b+1, 0, 0, n);
}
T query(int a, int b, int k, int l, int r){
if(r<=a || b<=l) return e;
if(a<=l && r<=b) return dat[k];
T vl = query(a, b, 2*k+1, l, (l+r)/2);
T vr = query(a, b, 2*k+2, (l+r)/2, r);
return f(vl, vr);
}
};
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> par;
vector<int> sz;
UnionFind(int n=0){
if(n>0) initialize(n);
}
void initialize(int n){
par.resize(n);
sz.resize(n);
for(int i=0; i<n; i++){
par[i] = i;
sz[i] = 1;
}
}
int find(int x){
if(par[x] == x){
return x;
}else{
return par[x] = find(par[x]);
}
}
void unite(int x, int y){
x = find(x);
y = find(y);
if(x == y) return;
if(sz[x] < sz[y]){
par[x] = y;
sz[y] += sz[x];
}else{
par[y] = x;
sz[x] += sz[y];
}
}
bool same(int x, int y){
return find(x) == find(y);
}
};
int main(){
int N;
int64_t D, A[200000];
cin >> N >> D;
for(int i=0; i<N; i++) cin >> A[i];
typedef pair<int64_t, int> P;
const int64_t INF = 1e18;
const P INFP = {INF, 0};
Segtree<P> stL(N, [](P a, P b){ return min(a, b);}, INFP);
Segtree<P> stR(N, [](P a, P b){ return min(a, b);}, INFP);
vector<int> order;
for(int i=0; i<N; i++) order.push_back(i);
sort(order.begin(), order.end(), [&](int i, int j){ return A[i] < A[j];});
vector<vector<int64_t>> edges;
for(int i : order){
auto p = stL.between(0, i);
if(p != INFP){
int64_t cost = p.first + A[i] - (N-i)*D;
edges.push_back({cost, i, p.second});
}
p = stR.between(i, N-1);
if(p != INFP){
int64_t cost = p.first + A[i] - i*D;
edges.push_back({cost, i, p.second});
}
stL.update(i, {A[i] + (N-i)*D, i});
stR.update(i, {A[i] + i*D, i});
}
sort(edges.begin(), edges.end());
UnionFind uf(N);
int64_t ans = 0;
for(auto& e : edges){
if(!uf.same(e[1], e[2])){
uf.unite(e[1], e[2]);
ans += e[0];
}
}
cout << ans << endl;
return 0;
} | //c++ -std=gnu++14 a.cpp
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <tuple>
#include <iomanip>
#include <climits>
#include <fstream>
#include <random>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
//typedef pair<ll, ll> P;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define revrep(i, n) for(int i = (n)-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
#define chmin(x, y) x = min(x, y);
#define chmax(x, y) x = max(x, y);
#define sz(x) ((int)(x).size())
//const ll INFL = LLONG_MAX;//10^18 = 2^60
const ll INFL = 1LL<<60;
//const int INF = INT_MAX;
const int INF = 1 << 30;//10^9
//const int MOD = 1000000007;
const int MOD = 998244353;
//int MOD = 1000000007;
double EPS = 1e-10;
vector<ll> dy = {0, 1, 0, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, 0, -1, 0, 1, -1, 1, -1, 0};
void pres(double A){printf("%.12lf\n", A);}
void BinarySay(ll x, ll y = 60){rep(i, y) cout << (x>>(y-1-i) & 1); cout << endl;}
ll cnt_bit(ll x){return __builtin_popcountll(x);}
ll pow_long(ll x, ll k){
ll res = 1;
while(k > 0){
if(k % 2) res *= x;
x *= x; k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k){
x %= MOD;
ll res = 1;
while(k > 0){
if(k % 2){
res *= x; res %= MOD;
}
x *= x; x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x){return pow_mod(x, MOD - 2);};
ll gcd(ll a, ll b){
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y){
ll res = x / gcd(x, y);
res *= y;
return res;
};
//コンビネーション
const int MAXcomb = 200010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
//facはn!,finvは1/n!
//invは逆元
void COMinit(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < MAXcomb; i++){
fac[i] = fac[i-1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;
finv[i] = finv[i-1] * inv[i] % MOD;
}
}
ll comb(int n, int k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * finv[k] % MOD * finv[n-k] % MOD;
}
const int MAXkai = 200010;
ll kai_memo[MAXkai];
ll kai(ll N){
if(kai_memo[N] != 0) return kai_memo[N];
if(N <= 1) return 1;
return kai_memo[N] = N * kai(N-1) % MOD;
}
ll disit(ll s, ll base = 10){
ll res = 0;
while(s){
res++;
s /= base;
}
return res;
}
//約数の列挙O(√n)
vector<int> divisor(int n){
vector<int> res(0);
for(int i = 1; i * i <= n; i++){
if(n % i == 0){
res.push_back(i);
if(i != n/i) res.push_back(n/i);
}
}
sort(res.begin(), res.end());
return res;
}
int N, X;
struct test{ll b, l, u, up;};
vector<test> T;
ll need;
ll sum[100010];
bool comp_test(test a, test b){
return a.up < b.up;
}
bool can(ll tar){
ll all = tar / X;
if(all >= N) return 1;
ll rest = tar % X;
//all個のテストで満点を取る
rep(i, N){
//i番目のテストは中途半端にとる
ll get;
if(i < all) get = sum[all+1] - T[i].up;
else get = sum[all];
get += max(rest * T[i].l, rest * T[i].u - T[i].b * (T[i].u - T[i].l));
if(get >= need) return 1;
}
return 0;
}
void solve(){
cin >> N >> X;
rep(i, N){
ll b, l, u;
cin >> b >> l >> u;
ll up = (X - b) * u + b * l;
T.pb({b, l, u, up});
need += b * l;
}
sort(T.begin(), T.end(), comp_test);
reverse(T.begin(), T.end());
rep(i, N){
sum[i+1] = sum[i] + T[i].up;
}
ll ng = -1, ok = INFL;
while(ok - ng > 1){
ll mid = (ok + ng) / 2;
if(can(mid)) ok = mid;
else ng = mid;
}
cout << ok << endl;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
solve();
}
| 0 |
#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<map>
#include<string.h>
#include<complex>
#include<math.h>
#include<queue>
#include <functional>
#include<time.h>
using namespace std;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<int> vint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<string> vstring;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
#define all(a) a.begin(),a.end()
#define rep(i,n) for(int i=0;i<n;i++)
#define drep(i,n) for(int i=n-1;0<=i;i--)
#define yes(ans) if(ans)cout<<"yes"<<endl;else cout<<"no"<<endl;
#define Yes(ans) if(ans)cout<<"Yes"<<endl;else cout<<"No"<<endl;
#define YES(ans) if(ans)cout<<"YES"<<endl;else cout<<"NO"<<endl;
#define POSSIBLE(ans) if(ans)cout<<"POSSIBLE"<<endl;else cout<<"IMPOSSIBLE"<<endl;
#define Pi 3.1415926535897932384626
#define mod llint(1e9+7)
#define Inf 2147483647
#define llInf 9223372036854775807
int main() {
int h, w, a, b;
cin >> h >> w >> a >> b;
string ans = "";
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
if (j <= a && i <= b) {
ans += "0";
}
else if (j > a&& i > b) {
ans += "0";
}
else {
ans += "1";
}
}
ans += "\n";
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
int h, w;
cin >> h >> w;
int a, b;
cin >> a >> b;
rep(i, h){
rep(j, w){
bool f1 = (i < b);
bool f2 = (j < a);
if((f1^f2) == true) cout << 0;
else cout << 1;
}
cout << endl;
}
return 0;
} | 1 |
#include<iostream>
using namespace std;
int main(){
int N;
cin >> N;
int a,b,c;
a=N/100, b=(N/10)%10, c=N%10;
if (a == 7 || b == 7 || c == 7){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define boost_io ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define int long long
#define num(a) a-'0'
#define charr(a) (a - 'A' + 1)
#define rep(i,a,b) for(int i=a;i<b;i++)
#define maxs(a,b) if(b>a)a=b
#define mins(a,b) if(b<a)a=b
#define debug(x) cerr<<"["<<#x<<":"<<x<<"] "
#define debug2(a,b) debug(a);debug(b)
#define debug3(a,b,c) debug2(a,b);debug(c)
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*b)/(__gcd(a,b))
#define print(arr) for(auto it = arr.begin();it < arr.end();it ++){cout << *it << " ";}cout << ln;
#define all(a) (a).begin(), (a).end()
#define vi vector<long long>
#define v vector
#define p pair
#define pb push_back
#define mk make_pair
#define f first
#define s second
#define ln "\n"
typedef long double ld;
typedef double d;
using namespace std;
int modF=1e9+7;
int INF=1e11;
void solve(){
string n;
cin>>n;
int l=n.length();
for(int i=0;i<l;i++){
if(n[i]=='7'){
cout<<"Yes\n";
return;
}
}
cout<<"No\n";
}
signed main(){
boost_io;
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
const int INF=1001001001;
int main() {
string s;
cin>>s;
int n=s.size();
stack<char>k;
for(int i=0;i<n;i++){
if(k.empty()){k.push(s[i]);}
else if(s[i]=='S'){k.push(s[i]);}
else if(s[i]=='T'){
if(k.top()=='T'){k.push('T');}
else if(k.top()=='S'){k.pop();}
}
//cout<<k.top()<<endl;
}
cout<<k.size()<<endl;
return 0;
} | //#include<bits/stdc++.h>
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
/*#define fast ios_base::sync_with_stdio(0); cin.tie(0)*/
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
const double pi = acos(-1);
typedef long long ll;
int main()
{
//fast;
ll n,ans;
cin>>n;
cout<<n/3;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
class Graph {
vector<vector<int>> adj;
vector<int> color;
public:
Graph(int n) : adj(n), color(n, -1) {}
void connect(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
}
bool dfs(int from = 0, int cur = 0) {
color[from] = cur;
for (auto to : adj[from]) {
if (color[to] == cur) return false;
if (color[to] == -1 && !dfs(to, 1 - cur)) return false;
}
return true;
}
vector<int> &getColor() {
return color;
}
};
int main() {
int n, m;
cin >> n >> m;
Graph graph(n);
rep(i, 0, m) {
int a, b;
cin >> a >> b;
graph.connect(--a, --b);
}
long long ans;
if (graph.dfs()) {
int cnt[2] = {0};
for (auto i : graph.getColor()) cnt[i]++;
ans = (long long)cnt[0] * cnt[1] - m;
} else {
ans = (long long)n * (n - 1) / 2 - m;
}
cout << ans << endl;
return 0;
} | /*====Corycle====*/
#include<algorithm>
#include<iostream>
#include<iomanip>
#include<cstring>
#include<cstdlib>
#include<complex>
#include<cstdio>
#include<vector>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<map>
#define ll long long
using namespace std;
const int inf=0x3f3f3f3f;
const int N=1e5+5;
int read(){
int s=0,f=1;char c=getchar();
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){s=s*10+c-'0';c=getchar();}
return s*f;
}
int n,m,a[N],num[2][N],f[2][2],g[2][2];
int main(){
// freopen("_.in","r",stdin);
// freopen("_.out","w",stdout);
n=read();
for(int i=1;i<=n;i++){a[i]=read();num[i&1][a[i]]++;}
for(int t=0;t<2;t++){
for(int i=1;i<N;i++){
if(f[t][0]<=num[t][i]){
f[t][1]=num[t][g[t][1]=g[t][0]];
f[t][0]=num[t][g[t][0]=i];
}
else if(f[t][1]<=num[t][i]){
f[t][1]=num[t][g[t][1]=i];
}
}
}
if(g[0][0]!=g[1][0])printf("%d\n",n-f[0][0]-f[1][0]);
else printf("%d\n",min(n-f[0][0]-f[1][1],n-f[0][1]-f[1][0]));
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define vi vector<int>
#define vvi vector<vector<int>>
#define pi pair<int, int>
#define ALL(a) (a).begin(), (a).end()
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end()) //sortしてからつかうこと
constexpr ll MOD = 1e9 + 7;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
int intceil(int a, int b) {
return (a + (b - 1)) / b;
}
signed main() {
cin >> N;
vi a(N);
cin >> a;
map<int, int> mp;
vector<ll> v;
REP(i, N) {
int x = ++mp[a[i]];
if ((x & 1) == 0) {
v.push_back(a[i]);
}
}
sort(v.rbegin(), v.rend());
if (v.size() >= 2)
cout << (ll)v[0] * (ll)v[1] << endl;
else
cout << 0 << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0;i < (n);i++)
using ll = long long;
const ll MOD=1000000007;
int main()
{
ll N; cin>>N;
vector<ll> vecA(N);
rep(i,N)
{
cin>>vecA.at(i);
}
sort(vecA.begin(),vecA.end());
reverse(vecA.begin(),vecA.end());
ll L=0;
rep(i,N-1)
{
if(vecA.at(i)==vecA.at(i+1))
{
if(L==0) {L=vecA.at(i); i++; continue;}
cout<<L*vecA.at(i)<<endl; return 0;
}
}
cout<<0<<endl;
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
#define loop(i,a,b) for(int i=(a);i<int(b);i++)
#define rep(i,b) loop(i,0,b)
typedef pair<int, int> pii;
int main(){
int n;
while(cin >> n && n){
vector<pii> v(n);
rep(i,n) v[i].second = i;
int game = n * (n-1) / 2;
rep(i,game){
int a,b,c,d;
cin >> a >> b >> c >> d;
if(c>d) v[a-1].first += 3;
else if(c < d) v[b-1].first += 3;
else v[a-1].first++, v[b-1].first++;
}
sort(v.rbegin(), v.rend());
int score = -1;
int rank = 1;
rep(i,n){
if (v[i].first == score) v[i].first = rank;
else {
score=v[i].first;
v[i].first=i+1;
rank=i+1;
}
}
sort(v.begin(), v.end(), [](pii l,pii r){
return l.second < r.second;
});
rep(i,n)cout<<v[i].first<<endl;
}
} | // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define forever for (;;)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
template<typename A> using V = std::vector<A>;
template<typename A> using F = std::function<A>;
template<typename A, typename B> using P = std::pair<A, B>;
using pii = P<int, int>;
using vi = V<int>;
using vd = V<double>;
using vs = V<std::string>;
using vpii = V<pii>;
using vvi = V<vi>;
using vvpii = V<vpii>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979;
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int n) { return n & 1; }
constexpr bool even(const int n) { return ~n & 1; }
template<typename T> std::istream &operator>>(std::istream &is, std::vector<T> &v) { for (T &x : v) is >> x; return is; }
template<typename A, typename B> std::istream &operator>>(std::istream &is, std::pair<A, B> &p) { is >> p.first; is >> p.second; return is; }
using namespace std;
// clang-format on
main {
int n;
cin >> n;
vi v(n);
rep(i, n * (n - 1) / 2) {
int a, b, c, d;
cin >> a >> b >> c >> d;
--a, --b;
if (c == d) {
v[a]++;
v[b]++;
continue;
}
v[c > d ? a : b] += 3;
}
rep(i, n) {
int r = 1;
rep(j, n) r += v[i] < v[j];
cout << r << endl;
}
} | 1 |
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ll long long
using namespace std;
const ll P = 1000000007;
const long long INF = 1LL << 60;
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
vector<char> Alphabet = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
vector<char> alphabet = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
int main()
{
cout << fixed << setprecision(10);
int N,K;
cin >> N >> K;
vector<char> D(K);
rep(i,K) cin >> D[i];
vector<string> vec(100100);
rep(i,100100)
{
int n = i;
string str;
str = to_string(n);
vec[i] = str;
}
for(int i=N;i<P;i++)
{
int n = vec[i].size();
bool ok = true;
rep(j,n)
{
rep(k,K)
{
if(vec[i][j]==D[k])
{
ok = false;
}
}
}
if(ok)
{
cout << i << endl;
return 0;
}
}
return 0;
} | #include<iostream>
using namespace std;
const int N=2e5+10;
int n,k;
int d[N];
int hs(int x){
int f=0;
while(x>0){
if(d[x%10]) f=1;
x/=10;
}
if(f) return 0;
else return 1;
}
int main(){
cin>>n>>k;
for(int i=1;i<=k;i++){
int x;
cin>>x;
d[x]=1;
}
for(int i=n;;i++)
if(hs(i)){
printf("%d",i);
break;
}
return 0;
} | 1 |
#include"bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using pi = pair<int, int>;
const ll INF = 1LL << 60;
int main() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<int>ac(n, 0), acsum(n + 1,0);
for (int i = 0; i < n-1; i++) {
if (s.substr(i, 2) == "AC") {
ac[i]++;
i++;
}
}
rep(i, n)acsum[i + 1] = acsum[i] + ac[i];
int l, r;
rep(i, q) {
cin >> l >> r;
cout << acsum[r-1] - acsum[l-1] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
using graph=vector<vector<int>>;
void add_directed_edge(graph& G,int u,int v){
G[u].emplace_back(v);
}
vector<int> topological_order(const graph& D){
int n=D.size();
vector<int> deg(n);
rep(u,n) for(int v:D[u]) deg[v]++;
vector<int> res;
queue<int> Q;
rep(u,n) if(deg[u]==0) Q.emplace(u);
while(!Q.empty()){
int u=Q.front(); Q.pop();
res.emplace_back(u);
for(int v:D[u]) if(--deg[v]==0) Q.emplace(v);
}
return res;
}
int main(){
int n,m; scanf("%d%d",&n,&m);
m+=n-1;
graph G(n);
rep(i,m){
int u,v; scanf("%d%d",&u,&v); u--; v--;
add_directed_edge(G,u,v);
}
vector<int> dp(n);
for(int u:topological_order(G)){
for(int v:G[u]) dp[v]=max(dp[v],dp[u]+1);
}
vector<int> ans(n,-1);
rep(u,n) for(int v:G[u]) if(dp[v]==dp[u]+1) ans[v]=u;
rep(u,n) printf("%d\n",ans[u]+1);
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
using namespace std;
#define rg register
void read(int &x){
char ch;bool ok;
for(ok=0,ch=getchar();!isdigit(ch);ch=getchar())if(ch=='-')ok=1;
for(x=0;isdigit(ch);x=x*10+ch-'0',ch=getchar());if(ok)x=-x;
}
const int maxn=2010,mod=1e9+7,N=4e6;
int n,m,f[maxn][maxn],fac[maxn*maxn],inv[maxn*maxn];
int mul(int x,int y){return 1ll*x*y-1ll*x*y/mod*mod;}
int add(int x,int y){return x+y>=mod?x+y-mod:x+y;}
int del(int x,int y){return x-y<0?x-y+mod:x-y;}
int mi(int a,int b){int ans=1;while(b){if(b&1)ans=mul(ans,a);b>>=1,a=mul(a,a);}return ans;}
void prepare(){
fac[0]=inv[0]=1;
for(rg int i=1;i<=N;i++)fac[i]=mul(fac[i-1],i);
inv[N]=mi(fac[N],mod-2);
for(rg int i=N-1;i;i--)inv[i]=mul(inv[i+1],i+1);
}
int C(int n,int m){return mul(fac[n],mul(inv[m],inv[n-m]));}
int main(){
read(n),read(m),prepare();
if(m==1)return printf("1\n"),0;
for(rg int i=1;i<=n;i++){
f[i][0]=1;
for(rg int j=1;j<=i;j++)
f[i][j]=add(f[i-1][j],mul(mul(f[i][j-1],n-j+1),C(n*m-(j-1)*(m-1)-i-1,m-2)));
}
printf("%d\n",f[n][n]);
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{
int n, k; cin >> n >> k;
vector<double> v(n);
vector<double> expected(n);
for(int i = 0; i < n; ++i)
{
cin >> v[i];
expected[i] = ((v[i]*(v[i]+1.0))/2.0)/v[i];
if(i)
expected[i] += expected[i-1];
}
double maxi = expected[k-1];
double tolerance = 0.0000001;
for(int i = k-1; i < n; ++i)
{
int pre = i - k;
if(pre >= 0)
{
double cur = expected[i] - expected[pre];
if(cur-maxi > tolerance)
maxi = cur;
}
}
cout << setprecision(17) << maxi;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m; cin >> n >> m;
string ans = "";
for (int i = 0; i < n; i++) {
ans += 'x';
}
for (int i = 0; i < m; i++) {
int s; char c; cin >> s >> c;
s--;
if (ans[s] != 'x') {
if (ans[s] == c) {}
else { // ans[s] != c
cout << -1 << endl;
return 0;
}
}
else { // ans[s] == 'x'
ans[s] = c;
}
}
for (int i = 0; i < n; i++) {
if (i != 0 && ans[i] == 'x') ans[i] = '0';
else if (i == 0 && ans[i] == 'x' && ans.size() != 1) ans[i] = '1';
else if (i == 0 && ans[i] == 'x' && ans.size() == 1) ans[i] = '0';
}
if (ans[0] == '0' && 2 <= ans.size()) ans = "-1";
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define MAX 1010
using namespace std;
vector<int> adj[MAX];
int visited[MAX];
int graph[MAX][MAX];
vector<int> dfs(int v, int root)
{
vector<int> ans;
visited[v] = 1;
if (v != root)
{
for (int i : adj[v])
{
if (i != root && visited[i]) return ans;
}
if (graph[v][root])
{
ans.push_back(v);
return ans;
}
}
for (int i : adj[v])
{
vector<int> res = dfs(i, root);
if (!res.empty())
{
int flag = 1;
for (int j : res)
{
if (graph[v][j] && i != j)
{
flag = 0;
break;
}
}
if (!flag) continue;
res.push_back(v);
return res;
}
}
visited[v] = 0;
return ans;
}
int main(void)
{
int N, M;
cin >> N >> M;
for (int i = 0; i < M; i++)
{
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
graph[u][v] = 1;
}
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++) visited[j] = 0;
vector<int> res = dfs(i, i);
reverse(res.begin(), res.end());
if (!res.empty())
{
cout << res.size() << endl;
for (int j : res) cout << j + 1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
int H, W, f[maxn][maxn], pre[maxn], suf[maxn];
char s[maxn][maxn];
bool chk[maxn][maxn];
int main() {
scanf("%d %d", &H, &W);
for (int i = 1; i <= H; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= W; j++) {
if (i > 1 && j > 1) {
int cnt = (s[i][j] == '.') + (s[i - 1][j] == '.') +
(s[i][j - 1] == '.') + (s[i - 1][j - 1] == '.');
if (cnt & 1) chk[i - 1][j - 1] = 1;
}
}
}
H--, W--;
for (int i = 1; i <= H; i++) {
for (int j = 1; j <= W; j++) {
f[i][j] = chk[i][j] ? 0 : (f[i - 1][j] + 1);
}
}
int ans = max(H + 1, W + 1);
for (int i = 1; i <= H; i++) {
stack<int> st;
f[i][0] = f[i][W + 1] = -1;
st.push(0);
for (int j = 1; j <= W; j++) {
while (f[i][st.top()] >= f[i][j]) st.pop();
pre[j] = st.top(), st.push(j);
}
while (!st.empty()) st.pop();
st.push(W + 1);
for (int j = W; j; j--) {
while (f[i][st.top()] >= f[i][j]) st.pop();
suf[j] = st.top(), st.push(j);
}
for (int j = 1; j <= W; j++) {
ans = max(ans, (f[i][j] + 1) * (suf[j] - pre[j]));
}
}
printf("%d\n", ans);
return 0;
} | #include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <algorithm>
#include <queue>
#include <stack>
#include <functional>
#include <bitset>
#include <assert.h>
#include <unordered_map>
#include <fstream>
#include <ctime>
#include <complex>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef pair<int,int> pii;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(int i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 510000;
ll dy[8] = {1,-1,0,0,1,-1,1,-1};
ll dx[8] = {0,0,1,-1,1,-1,-1,1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
if(a>b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
if(a<b){
a = b; return true;
}
else return false;
}
template<typename T> inline void print(T &a){
rep(i,a.size()) cout << a[i] << " ";
cout << "\n";
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){cout << a << " " << b << "\n";}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << "\n";
}
ll pcount(ll x) {return __builtin_popcountll(x);}
//const int mod = 1e9 + 7;
const int mod = 998244353;
int main(){
int h,w; cin >> h >> w;
vs s(h); rep(i,h) cin >> s[i];
vl dist(h+1,-1);
int ans = w;
rep(j,w){
vector<pii> st;
st.emplace_back(0,0);
REP(i,1,h+1){
if(i < h){
if(j==0 || dist[i] == 1){
int d = 0;
bool rev = s[i][j] != s[i-1][j];
REP(k,j,w){
if(rev == (s[i][k] != s[i-1][k])) d++;
else break;
}
dist[i] = d;
}else{
dist[i]--;
}
}else{
dist[i] = 0;
}
if(st.empty() || st.back().first < dist[i]){
st.emplace_back(dist[i],i);
}else{
int pos = i;
while(!st.empty()){
if(st.back().first >= dist[i]){
pii p = st.back();
chmax(ans, p.first*(i-p.second)+p.first);
pos = p.second;
st.pop_back();
}else{
st.emplace_back(dist[i], pos);
break;
}
}
}
}
}
cout << ans << "\n";
} | 1 |
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
int main(){
ll N,D;
ll A[200005];
cin>>N>>D;
ll ret = D*(N-1);
for(int i = 0;i < N;i++){
cin>>A[i];
ret += A[i];
}
for(int i = 1;i < N;i++){
A[i]=min(A[i-1]+D,A[i]);
}
for(int i = N-2;i >=0;i--){
A[i]=min(A[i+1]+D,A[i]);
}
for(int i = 1;i < N-1;i++){
ret += A[i];
}
cout<<ret<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=1<<18;
const ll INF=1LL<<55;
int n;
pair<ll,int> dat[2*MAX-1][2];
void init(int n_){
n=1;
while(n<n_) n*=2;
for(int i=0;i<2*n-1;i++){
dat[i][0]={INF,i-(n-1)};
dat[i][1]={INF,i-(n-1)};
}
}
void update(int k,ll a,int kind){
k+=n-1;
dat[k][kind].first=a;
while(k>0){
k=(k-1)/2;
dat[k][kind]=min(dat[k*2+1][kind],dat[k*2+2][kind]);
}
}
pair<ll,int> query(int a,int b,int k,int l,int r,int kind){
if(r<=a||b<=l) return {INF,-1};
if(a<=l&&r<=b) return dat[k][kind];
else{
pair<ll,int> vl=query(a,b,2*k+1,l,(l+r)/2,kind);
pair<ll,int> vr=query(a,b,2*k+2,(l+r)/2,r,kind);
return min(vl,vr);
}
}
struct edge{
int from;
int to;
ll dis;
};
bool compare(edge a,edge b){
return a.dis<b.dis;
}
int par[MAX],size[MAX];
void initUF(int n){
for(int i=0;i<n;i++){
par[i]=i;
size[i]=1;
}
}
int root(int a){
if(par[a]==a) return a;
else return par[a]=root(par[a]);
}
void unite(int a,int b){
if(root(a)!=root(b)){
size[root(a)]+=size[root(b)];
par[root(b)]=root(a);
}
}
bool check(int a,int b){
return root(a)==root(b);
}
int main(){
ll N;
ll D;cin>>N>>D;
vector<ll> A(N);
for(int i=0;i<N;i++) cin>>A[i];
vector<int> id(N);
iota(all(id),0);
sort(all(id),[&](int i,int j){
return A[i]<A[j];
});
init(N);
vector<edge> S;
for(int i:id){
auto left=query(0,i+1,0,0,n,0),right=query(i,n+1,0,0,n,1);
if(left.first!=INF){
S.push_back({left.second,i,A[left.second]+A[i]+D*(i-left.second)});
}
if(right.first!=INF){
S.push_back({i,right.second,A[i]+A[right.second]+D*(right.second-i)});
}
update(i,D*(N-1-i)+A[i],0);
update(i,D*i+A[i],1);
}
sort(all(S),compare);
initUF(N);
ll ans=0;
for(edge e:S){
int a=e.from,b=e.to;
ll c=e.dis;
if(check(a,b)) continue;
ans+=c;
unite(a,b);
}
cout<<ans<<endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+7, K = 18;
vector<int> cld[N];
int par[N], level[N], anc[N][K];
bool done[N];
int n, k;
priority_queue<pair<int, int>> pq;
void setup(int u) {
if (par[u] != u) level[u] = level[par[u]]+1;
pq.push({level[u], u});
anc[u][0] = par[u];
for (int k=1; k<K; k++) anc[u][k] = anc[anc[u][k-1]][k-1];
for (int v: cld[u]) setup(v);
}
int getanc(int u, int d) {
if (d >= N) d = N-1;
for (int k=0; k<K; k++)
if (d & (1<<k))
u = anc[u][k];
return u;
}
void dfs(int u) {
if (done[u]) return;
done[u] = 1;
for (int v: cld[u])
dfs(v);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin>>n>>k;
cin>>par[1];
int ans = 0;
if (par[1] != 1) ans++, par[1] = 1;
for (int i=2; i<=n; i++) {
cin>>par[i];
cld[par[i]].push_back(i);
}
setup(1);
while (pq.size()) {
int u = pq.top().second;
int d = pq.top().first;
pq.pop();
// cout<<u<<" --> "<<d<<endl;
if (d <= k) continue;
if (done[u]) continue;
int g = getanc(u, k-1);
ans++;
dfs(g);
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i < (n); i++)
using namespace std;
using ll = long long;
int main(){
ios::sync_with_stdio(false);
int N,M; cin>>N;
vector<string> s(N);
rep(i,N) cin>>s[i];
cin>>M;
vector<string> t(M);
rep(i,M) cin>>t[i];
int ans=0;
rep(i,N){
string taka = s[i];
int money = 0;
rep(j,N){
if(taka == s[j]) money++;
}
rep(k,M){
if(taka == t[k]) money--;
}
ans = max(ans,money);
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
#define ff first
#define ss second
char s[1000010];
bool comp(ii a, ii b){
return a.ss > b.ss;
}
int32_t main(){
int n;
scanf("%d", &n);
vector<ii> v1, v2;
for(int z=0; z<n; ++z){
scanf("%s", s);
int q = 0;
int tam = int(strlen(s));
int a=0, b=0;
for(int i = 0; i<tam; ++i){
if(s[i]==')'){
if(q>0) --q;
else ++b;
}
else ++q;
}
a = q;
if(a>b) v1.emplace_back(a, b);
else v2.emplace_back(a, b);
}
sort(v1.begin(), v1.end(), comp);
sort(v2.begin(), v2.end());
int q = 0;
for(auto x:v2){
int a = x.ff;
int b = x.ss;
if(a>q){
printf("No\n");
return 0;
}
q-=a;
q+=b;
}
for(auto x:v1){
int a = x.ff;
int b = x.ss;
if(a>q){
printf("No\n");
return 0;
}
q-=a;
q+=b;
}
if(q==0)
printf("Yes\n");
else
printf("No\n");
}
| #include "bits/stdc++.h"
using namespace std;
#ifndef LOCAL
#define endl '\n'
#endif
#define fr(i, a, b) for(int i = a; i <= b; i++)
#define rf(i, a, b) for(int i = a; i >= b; i--)
#define pf push_front
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)x.size()
#define lb lower_bound
#define ub upper_bound
typedef long long ll;
typedef long double f80;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
int pct(int x) { return __builtin_popcount(x); }
int pct(ll x) { return __builtin_popcountll(x); }
int bt(int x) { return 31 - __builtin_clz(x); } // floor(log2(x))
int bt(ll x) { return 63 - __builtin_clzll(x); } // floor(log2(x))
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
ll cdiv(ll a, ll b) { return a / b + !(a < 0 || a % b == 0); }
int nxt_C(int x) { int c = x & -x, r = x + c; return (((r ^ x) >> 2) / c) | r; }
ll nxt_C(ll x) { ll c = x & -x, r = x + c; return (((r ^ x) >> 2) / c) | r; }
vector<int> get_bits(int mask) {
vector<int> bb;
while(mask) { int b = bt(mask); bb.pb(b); mask ^= (1 << b); }
reverse(all(bb));
return bb;
}
int get_mask(vector<int> v) {
int mask = 0;
for(int x : v) { mask ^= (1 << x); }
return mask;
}
template<typename T>
void uniq(vector<T> &v) { sort(all(v)); v.resize(unique(all(v)) - v.begin()); }
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll rand(ll l, ll r){
uniform_int_distribution<ll> uid(l, r);
return uid(rng);
}
void sc() {}
template <typename Head, typename... Tail>
void sc(Head &H, Tail &... T) { cin >> H; sc(T...); }
#ifdef LOCAL
#define debug(...) cerr << "[L:" << __LINE__ << "][" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// #ifndef LOCAL
// string to_string(__int128 x) {
// string s = "";
// bool neg = 0;
// if(x < 0) { s += "-"; neg = 1; x = -x; }
// if(!x) s += '0';
// while(x) {
// int rem = x % 10;
// s += to_string(rem);
// x /= 10;
// }
// reverse(s.begin() + neg, s.end());
// return s;
// }
// #endif
const int mod = 1e9 + 7; // 998244353;
int pwr(int a,ll b) {
int ans = 1;
while(b) {
if(b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
/*
Lookout for overflows!!
Check array sizes!!
Clear before test cases!!
Use the correct modulo!!
Check for corner cases!!
Are you forgetting something?!
Read problem statement carefully!!!
*/
const int N = 2005;
int pre[3][N][N];
char a[N][N];
int get(int b,int r1,int c1,int r2,int c2) {
if(r1 > r2 || c1 > c2) return 0;
r1--, c1--;
return pre[b][r2][c2] - pre[b][r1][c2] - pre[b][r2][c1] + pre[b][r1][c1];
}
void solve() {
int n, m, q;
sc(n, m, q);
fr(i, 0, n + 1) {
fr(j, 0, m + 1) {
a[i][j] = '0';
}
}
fr(i, 1, n) {
fr(j, 1, m) {
sc(a[i][j]);
pre[0][i][j] = pre[0][i - 1][j] + pre[0][i][j - 1] - pre[0][i - 1][j - 1] + (a[i][j] == '1');
pre[1][i][j] = pre[1][i - 1][j] + pre[1][i][j - 1] - pre[1][i - 1][j - 1] + (a[i][j] == '1' && a[i - 1][j] == '1');
pre[2][i][j] = pre[2][i - 1][j] + pre[2][i][j - 1] - pre[2][i - 1][j - 1] + (a[i][j] == '1' && a[i][j - 1] == '1');
debug(i, j, pre[0][i][j]);
}
}
fr(i, 1, q) {
int r1, c1, r2, c2;
sc(r1, c1, r2, c2);
int g1 = get(0, r1, c1, r2, c2);
int g2 = get(1, r1 + 1, c1, r2, c2);
int g3 = get(2, r1, c1 + 1, r2, c2);
debug(g1, g2, g3);
cout << g1 - g2 - g3 << endl;
}
}
int main() {
ios :: sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin >> t;
for(int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, x;
cin >> n >> x;
ll a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int ans = 0;
int index = 0;
while (x > 0 && index < n) {
if (x >= a[index]) {
ans++;
x -= a[index];
if (index == n - 1 && x > 0) {
ans--;
x = 0;
}
}
index++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define INF_LL 1LL << 39
#define INF 100000000
#define MOD 1000000007LL
#define ll long long
#define all(x) x.begin(), x.end()
#define REP(i, a, b) for(int i = a; i < b; i++)
#define rep(i, n) REP(i, 0, n)
#define prique priority_queue
#define PI acos(-1)
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<P> vp;
typedef vector<ll> vl;
typedef vector<vector<int>> matrix;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int sign[2] = {1, -1};
template <class T> bool chmax(T &a, T b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
struct edge {
int to, cost;
};
ll dp[202][100010];
signed main() {
int n, x;
cin >> n >> x;
vi s(n);
rep(i, n) cin >> s[i];
sort(all(s), greater<int>());
dp[0][x] = 1;
rep(i, n) REP(j, 0, x + 1) {
dp[i + 1][j % s[i]] += dp[i][j];
dp[i + 1][j] += dp[i][j] * (n - i - 1);
dp[i + 1][j] %= MOD;
}
// rep(i, n + 1) {
// rep(j, x + 1) cout << dp[i][j] << " ";
// cout << endl;
// }
ll res = 0;
REP(i, 1, x + 1) {
res += dp[n][i] * i;
res %= MOD;
}
cout << res << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
string s;
cin >> n >> s;
vector<int> w(n + 1, 0), e(n + 1, 0);
rep(i, 0, n) {
if (s[i] == 'W')
w[i + 1] = w[i] + 1;
else
w[i + 1] = w[i];
}
repr(i, 0, n) {
if (s[i] == 'E')
e[i] = e[i + 1] + 1;
else
e[i] = e[i + 1];
}
int ans = 1e9;
rep(i, 1, n + 1) {
// test
chmin(ans, w[i - 1] + e[i]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<n;++i)
#define all_map(pos,mp) for(ll pos=mp.begin();pos!=mp.end();pos -++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll LINF = 1LL << 62;
const int INF = 1e9 + 7;
int main(){
ll n, k;
cin >> n >> k;
vector<ll> v(n);
rep(i, n)cin >> v[i];
ll ans = 0;
rep(left, min(n, k) + 1)rep(right, min(n, k) + 1 - left){
vector<ll> res = v;
res.erase(res.begin()+left, res.end()-right);
sort(ALL(res));
rep(i, k-left-right){
if(res.empty() || res.front() >= 0)break;
res.erase(res.begin());
}
ans = max(ans, accumulate(ALL(res), 0LL));
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin>>N;
vector<int> p(60000,1);
vector<int> q;
for(int i=2;i<55556;i++){
if(p[i]){
for(int j=i*2;j<=55555;j+=i){
p[j]=0;
}
if(i%5==1){
q.push_back(i);
}
}
}
for(int i=0;i<N;i++){
cout<<q[i];
if(i-1==N){
cout<<endl;
}
else{
cout<<" ";
}
}
} | const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Ans[2] = {"No", "Yes"};
string ANS[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
int A[505][505];
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 6; n > 0; i += 5)
{
int t = 1;
for (int j = 2; j < i; j++) if (i % j == 0) t = 0;
if (t)
{
cout << i << " ";
n--;
}
}
}
/* Note:
Check constants at the beginning of the code.
N is set to 4e5 but be careful in problems with large constant factor.
Setting N in every problem is more effective.
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
| 1 |
//
// Created on 2020/08/10.
//
#include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <math.h>
#include <ios>
#include <iomanip>
#include <numeric>
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
typedef long long ll;
using namespace std;
const long long LINF =1e18;
const int INF = 1e9;
int main() {
int n;
cin>>n;
vector<int>L;
int init;
cin>>init;
L.push_back({init});
for (int i = 1; i < n; ++i) {
int a;
cin>>a;
int ok = L.size() - 1;
int ng = -1;
int mid = (ok + ng) / 2;
while(1 < abs(ok - ng)){
if(L[mid] < a){
ok = mid;
}else{
ng = mid;
}
mid = (ok + ng) / 2;
}
if(L[ok] < a){
L[ok] = a;
}else if(L[ok] >= a){
L.push_back(a);
}}
cout<<L.size()<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define ASC(x) sort(ALL((x)))
#define DESC(x) sort(ALL((x)),greater<ll>())
#define REV(x) reverse(ALL((x)))
#define pb push_back
int main()
{
ll H, W;
cin >> H >> W;
mat A(H+1, vec(W+1, 0)), B(H+1, vec(W+1, 0));
REP(i,1,H+1) REP(j,1,W+1) cin >> A[i][j];
REP(i,1,H+1) REP(j,1,W+1) cin >> B[i][j];
ll K = 160 * 80;
bool dp[H+1][W+1][K+1];
REP(i,0,H+1) {
REP(j,0,W+1) {
REP(k,0,K+1) dp[i][j][k] = false;
}
}
dp[0][1][0] = true;
dp[1][0][0] = true;
ll d;
REP(i,1,H+1) {
REP(j,1,W+1) {
REP(k,0,K+1) {
d = abs(A[i][j] - B[i][j]);
if(k + d <= K) {
dp[i][j][k+d] |= dp[i][j-1][k];
dp[i][j][k+d] |= dp[i-1][j][k];
}
if(abs(k - d) <= K) {
dp[i][j][abs(k-d)] |= dp[i][j-1][k];
dp[i][j][abs(k-d)] |= dp[i-1][j][k];
}
}
}
}
REP(k,0,K) {
if(dp[H][W][k]) {
PR(k);
break;
}
}
return 0;
}
/*
*/ | 0 |
# include <iostream>
using namespace std;
static const int ans[] = {
0, 3, 14, 39, 84, 155, 258, 399, 584, 819, 1110
};
int main() {
int a;
cin >> a;
cout << ans[a] << endl;
return 0;
} | #include<iostream>
#include<string>
#include<algorithm>
#include<iterator>
int main(){
std::string str;
std::cin >> str;
std::reverse_copy(str.begin(), str.end(),
std::ostream_iterator<char>(std::cout,""));
std::cout << std::endl;
return 0;
} | 0 |
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 100010;
const ll mod = 1e9 + 7;
ll fac[N << 1], inv[N << 1];
int h, w, a, b;
ll power(ll a, int b) {
ll ans = 1;
while(b) {
if(b & 1) ans = ans * a % mod;
a = a * a % mod; b >>= 1;
}
return ans;
}
ll C(int n, int m) {
return fac[m] * inv[n] % mod * inv[m - n] % mod;
}
ll Calc(int h, int w) {return C(h - 1, h + w - 2);}
int main() {
scanf("%d%d%d%d", &h, &w, &a, &b);
fac[0] = inv[0] = 1;
a = h - a + 1;
for(int i = 1; i <= 200000; ++i) fac[i] = 1LL * fac[i - 1] * i % mod;
for(int i = 1; i <= 200000; ++i) inv[i] = power(fac[i], mod - 2);
ll ans = 0;
for(int i = b + 1; i <= w; ++i) {
ans = (ans + 1LL * Calc(a - 1, i) * Calc(h - a + 1, w - i + 1) % mod) % mod;
}
printf("%lld\n", ans);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,d,k;
cin>>a>>b>>c>>d>>k;
int x = (c-a);
int y = (d-b);
int ans = (x*60)+y;
ans=ans-k;
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
#ifdef local
#define debug(a...) qqbx(#a, a)
template <typename H, typename ...T> void qqbx(const char *s, const H &h, T&&...a) {
for(; *s && *s != ','; ++s) if(*s != ' ') std::cerr<<*s;
std::cerr<<" = "<<h<<(sizeof...(T) ? ", " : "\n");
if constexpr(sizeof...(T)) qqbx(++s, a...);
}
#else
#define debug(...) ((void)0)
#endif // local
#define pb emplace_back
#define all(v) begin(v),end(v)
using namespace std;
const int MOD = 1000000007, N = 200025, inf = 2e9;
int a[N], b[N], ca[N], cb[N];
int A[N], B[N];
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for(int i = 0; i < n; i++) cin >> a[i];
for(int i = 0; i < n; i++) cin >> b[i];
for(int i = 0; i < n; i++) ++ca[a[i]];
for(int i = 0; i < n; i++) ++cb[b[i]];
for(int i = 1; i <= n; i++) if(ca[i] + cb[i] > n) return cout << "No\n", 0;
for(int i = 1; i <= n; i++) ca[i] += ca[i-1];
for(int i = 1; i <= n; i++) cb[i] += cb[i-1];
int mx = 0;
for(int i = 1; i <= n; i++) mx = max(mx, ca[i] - cb[i-1]);
cout << "Yes\n";
for(int i = 0; i < n; i++)
cout << b[(i+n-mx)%n] << ' ';
cout << '\n';
}
| #include <iostream>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N);
unordered_map<int, int> Acnt;
rep(i, N) {
cin >> A[i];
Acnt[A[i]]++;
}
vector<int> B(N);
unordered_map<int, int> Bcnt;
rep(i, N) {
cin >> B[i];
Bcnt[B[i]]++;
}
for (auto& a : Acnt) {
if (Bcnt.count(a.first) && (N < a.second + Bcnt[a.first])) {
cout << "No" << endl;
return 0;
}
}
int j = 0;
int prev = -1;
rep(i, N) {
if (prev != A[i]) j = 0;
if (A[i] == B[i]) {
for (; j < N; ++j) {
if (A[i] != A[j] && A[i] != B[j]) {
swap(B[i], B[j]);
break;
}
}
}
prev = A[i];
}
cout << "Yes" << endl;
rep(i, N) {
if (i != 0) cout << " ";
cout << B[i];
}
cout << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define loop(i,n)for(i=0;i<n;i++)
#define INF 1000000000
using ll = long long int;
typedef pair<int,int> pii;
typedef vector<pii> vii;
typedef vector<int> vi;
#define MAX 100005
int main()
{
IOS;
//freopen("inputfile.txt","r",stdin);
ll n;cin>>n;
ll ar[n];
ll count = 0;ll mi;
for(ll i=0;i<n;i++)
{
ll x;cin>>x;
if(i==0)mi = x;
else if(x>mi)count++;
else mi = x;
}
cout<<n-count<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define rep2(i,a,n) for(int i=(a); i<(n); i++)
#define all(vec) vec.begin(),vec.end()
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
int main(){
int N; cin >> N;
vi P(N); rep(i,N) cin >> P[i];
int count = 0;
int minA = P[0];
rep(i,N){
if (P[i] <= minA) {count++; minA = P[i];}
}
cout << count << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
int w;
cin >> s >> w;
int n = s.length();
string ans;
for (int i = 0; i < n; i += w) {
ans += s[i];
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(a) (a).begin(),(a).end()
#define ll long long
long long min(long long x,long long y){return (x<y ? x:y);}
long long max(long long x,long long y){return (x>y ? x:y);}
#define ld long double
int stoi(string s) {return atoi(s.c_str());}
int keta(ll x){ if(x<10){return 1;} else{return keta(x/10) + 1;}}
#define LINEY "YES\n"
#define Liney "Yes\n"
#define LINEN "NO\n"
#define Linen "No\n"
int main(){
int N,K; cin>>N>>K;
int r = N-K+1;
printf("%d\n",r);
} | 0 |
#include <bits/stdc++.h>
#define pb emplace_back
#define ll long long
#define fi first
#define se second
#define mp make_pair
#define sz(x) int(x.size())
//#define int int64_t
using namespace std;
typedef pair<int, int> pii;
const int N = 302;
const int mod = 998244353;
string s;
int k, n, f[N][N][N];
int DP(int l, int r, int k) {
if(f[l][r][k] != -1) return f[l][r][k];
if(r < l) return f[l][r][k] = 0;
if(l == r) return f[l][r][k] = 1;
if(l + 1 == r) {
if(k >= 1 || s[l] == s[r]) return f[l][r][k] = 2;
return f[l][r][k] = 1;
}
int&res = f[l][r][k];
res = max(DP(l + 1, r, k), DP(l, r - 1, k));
if(s[l] == s[r]) {
res = max(res, DP(l + 1, r - 1, k) + 2);
} else if(k >= 1) {
res = max(res, DP(l + 1, r - 1, k - 1) + 2);
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
#define Task "test"
if(fopen(Task".inp", "r")) {
freopen(Task".inp", "r", stdin);
freopen(Task".out", "w", stdout);
}
cin >> s >> k; n = sz(s);
s = ' ' + s;
memset(&f, -1, sizeof f);
cout << DP(1, n, k);
}
| // luogu-judger-enable-o2
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<bits/stdc++.h>
#define R register
using namespace std;
char s[351];int len,k;
int f[351][351][351],ans;
inline void read(R int &x)
{
x=0;R int f=1;
R char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-') f=-1;
c=getchar();
}
while(c>=48&&c<=57)
{
x=(x<<1)+(x<<3)+(c^48);
c=getchar();
}
x=x*f;
}
inline void input_data()
{
char ch=getchar();
while(ch>='a'&&ch<='z')
s[++len]=ch,ch=getchar();
read(k);return;
}
int dfs(R int k,R int l,R int r)
{
if(l>r) return false;
if(l==r) return s[l]==s[r];
if(f[k][l][r]) return f[k][l][r];
f[k][l][r]=max(dfs(k,l+1,r),dfs(k,l,r-1));
if(s[l]==s[r]) f[k][l][r]=max(f[k][l][r],dfs(k,l+1,r-1)+2);
if(k>=1) f[k][l][r]=max(f[k][l][r],dfs(k-1,l+1,r-1)+2);
return f[k][l][r];
}
int main()
{
input_data();
for(R int i=0;i<=k;++i)
ans=max(ans,dfs(i,1,len));
printf("%d\n",ans);
return 0;
} | 1 |
#include <iostream>
#include <cmath>
using namespace std;
int dummy_prime(int n,int i){return i>1 ? n%i ? dummy_prime(n,i-1) : 0 : 1;}
int isprime(int n){return n>1 ? dummy_prime(n,(int)sqrt(n)) : 0;}
int main(){
int n;
while(cin >> n && n){
while(n>4){
if(isprime(n) && isprime(n-2)){
cout << n-2 << " " << n << endl;
break;
}
n--;
}
}
} | #include<algorithm>
#include<functional>
#include<cstdio>
#include<iostream>
using namespace std;
int flg[1000000];
int main(void)
{
int i,j,k,n,f;
for(i=2;i<=1000000;i++) flg[i]=1;
for(i=2;i*i<=1000000;i++){
if(flg[i]==1){
for(j=2;j*i<1000000;j++) flg[i*j]=0;
}
}
cin>>n;
while(n) {
for(i=n;i>=4;i--) {
if(flg[i]==1&&flg[i-2]==1) {
cout<<i-2<<" "<<i<<endl;
break;
}
}
cin>>n;
}
}
| 1 |
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
#include<algorithm>//next_permutation
#define rep(i,n) for (int i = 0;i < (n);i++)
#define all(v) v.begin(),v.end()
#define dec(n) cout << fixed << setprecision(n);
#define large "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define small "abcdefghijklmnopqrstuvwxyz"
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b , a % b);
}
const ll MOD = 1000000007;
const ll MAX = 2000001;
ll mod(ll a){
return a % MOD;
}
ll lcm(ll a,ll b){
return (a*b)/gcd(a,b);
}
ll fac[MAX], finv[MAX], inv[MAX];
void nCrprep() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll nCr(ll n, ll r){
if (n < r) return 0;
if (n < 0 || r < 0) return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
ll nCrcheep(ll n,ll r){
if(r == 0) return 1;
else if(r == 1) return n;
else return nCrcheep(n-1,r-1)*n/r;
}
vector<pair<ll,ll>> prime_factorize(ll n){
vector<pair<ll,ll>> res;
for(ll i=2; i*i <= n; i++){
if(n % i != 0) continue;
ll ex = 0;
while(n % i == 0){
ex++;
n /= i;
}
res.push_back({i,ex});
}
if(n != 1) res.push_back({n,1});
return res;
}
int main(){
ll n; cin >> n;
cout << 180*(n-2) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
cout << n / 3;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<n; i++)
int n, k;
int d[11];
inline int nextCombination(int comb)
{
int x = comb & -comb, y = comb + x;
return (((comb & ~y) / x) >> 1) | y;
}
template<typename T> inline void _tostr(const T t, string& s){ostringstream o;o<<t;s=o.str();}
template<typename T> inline string _tostr(const T t){ostringstream o;o<<t;return o.str();}
template<typename T> inline void _toint(const string s, T& n){istringstream i(s);i>>n;}
template<typename T> inline T _toint(const string s){istringstream i(s);T n;i>>n;return n;}
int main(int argc, char *argv[])
{
while(cin >> n, n){
cin >> k;
rep(i, n) cin >> d[i];
vector<string> res;
for(int comb = (1 << k) - 1; comb < (1 << n); comb = nextCombination(comb)){
vector<int> vec;
rep(mask, n) if(comb & 1 << mask) vec.push_back(mask);
do{
string s = "";
rep(i, k) s += _tostr(d[vec[i]]);
res.push_back(s);
}while(next_permutation(vec.begin(), vec.begin() + k));
}
sort(res.begin(), res.end());
res.erase(unique(res.begin(), res.end()), res.end());
cout << res.size() << endl;
}
return 0;
} | #include<iostream>
#include<set>
#include<algorithm>
using namespace std;
int main(){
int n, k;
while(cin >> n >> k){
if(n + k == 0) break;
string x[n];
for(int i = 0; i < n; i++) cin >> x[i];
sort(x, x+n);
set<int> ans;
do{
string tmp = "";
for(int i = 0; i < k; i++) tmp = tmp + x[i];
ans.insert(stoi(tmp));
}while(next_permutation(x, x+n));
cout << ans.size() << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(m);
int odd = 0;
for (int i = 0; i < m; i++) {
cin >> a[i];
odd += a[i] & 1;
}
if (odd > 2) {
cout << "Impossible\n";
return 0;
}
for (int i = 0; i < m && odd > 0; i++) {
if (a[i] & 1) {
swap(a[i], a[0]);
odd--;
break;
}
}
for (int i = m - 1; i >= 0 && odd > 0; i--) {
if (a[i] & 1) {
swap(a[i], a[m - 1]);
odd--;
break;
}
}
for (int i = 0; i < m; i++) {
cout << a[i] << ' ';
}
cout << '\n';
vector<int> b;
for (int i = 0; i < m; i++) {
b.push_back(a[i] + (i == 0 ? -1 : (i == m - 1 ? 1 : 0)));
}
if (m == 1) {
b.push_back(1);
}
cout << (int) b.size() - (b[0] == 0) << '\n';
for (int i = (b[0] == 0); i < (int) b.size(); i++) {
cout << b[i] << ' ';
}
cout << '\n';
return 0;
} | ////////////////////////// Author
////////////////////////// Nasim Hossain Rabbi
////////////////////////// JU-CSE28
////////////////////////// CF - imnasim3.1415
////////////////////////// UVA - imnasim3.1415
////////////////////////// Mail - [email protected]
#include<bits/stdc++.h>
using namespace std;
#define E end()
#define B begin()
#define sz size()
#define EM empty()
#define fi first
#define se second
#define cl clear()
#define sqr(a) (a*a)
#define mk make_pair
#define po pop()
#define pu push
#define pb push_back
#define pf push_front
#define pob pop_back()
#define pof pop_front()
string en="\n";
string sp=" ";
string t="hello";
string Y="YES\n";
string N="NO\n";
#define rep(i,n) for(i=0;i<n;i++)
#define Rep(i,n) for(i=1;i<=n;i++)
#define per(i,n) for(i=n-1;i>=0;i--)
#define peR(i,n) for(i=n;i>0;i--)
#define mem(a,b) memset(a,b,sizeof(a))
#define all(cont) cont.begin(),cont.end()
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL)
#define pi 3.1415926535897932384626433832795
#define vi vector<long long>
#define vs vector<string>
#define MX LLONG_MAX
#define MN LLONG_MIN
#define MOD 1000000007
#define vp(vi,x) cin>>x; vi.pb(x);
#define bsearch(a,x) binary_search(all(a),x)
#define LB(a,x) (lower_bound(all(a),x)-a.B)
#define UB(a,x) (upper_bound(all(a),x)-a.B)
typedef long long LL;
typedef long double LD;
typedef unsigned long long ULL;
bool isprm(LL a){if(a==1)return false; for(LL i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
bool palin(string a){for(int i=0;i<a.sz;i++){if(a.at(i)!=a.at(a.sz-i-1))return 0;} return 1;}
bool isVowel(char ch){ ch=toupper(ch); if(ch=='A'||ch=='U'||ch=='I'||ch=='O'||ch=='E') return true; return false;}
int toInt(string s){int sm;stringstream ss(s);ss>>sm;return sm;}
LL ceil2(LL a,LL b){LL c=a/b; if(a%b)c++; return c; }
LL bpow(LL a,LL b){if(b==0)return 1;LL r=bpow(a,b/2);if(b%2)return r*r*a;else return r*r;}
LL binpow(LL a,LL b){LL r=1;while(b>0){if(b&1)r=r*a;a=a*a;b>>=1;}return r;}
LL binpow(LL a,LL b,LL m){a%=m;LL r=1;while(b>0){if(b&1) r=r*a%m;a=a*a%m; b>>=1;}return r;}
template<typename T>inline T gcd(T a,T b){if(a<0)return gcd(-a,b);if(b<0)return gcd(a,-b);return (b==0)?a:gcd(b,a%b);}
template<typename T>inline T lcm(T a,T b) {if(a<0)return lcm(-a,b);if(b<0)return lcm(a,-b);return a*(b/gcd(a,b));}
int main()
{
// fast;
LL i,j,k,n,m,l,s=0,x,y,tc=1,p,q,a,b,c=0;
bool f=0,ff=0;string st,s1,s2,s3; char ch;
while(cin>>n>>m)
{
a=b=0;
bool ar[n+5];
rep(i,n+5)ar[i]=0;
map<LL,LL>mp;
while(m--)
{
cin>>p>>st;
if(ar[p])continue;
if(st=="AC") a++,ar[p]=1;
else mp[p]++;
}
for(auto it=mp.B;it!=mp.E;it++)
{
if(ar[it->fi])b+=it->se;
}
cout<<a<<sp<<b<<en;
}
return 0;
}
| 0 |
#include <cstdio>
#include <algorithm>
using namespace std;
char S[1001001];
int D[10], F[10];
int main()
{
scanf ("%s", S);
for (int i = 0; i < 10; i++) D[i] = i;
for (int t = 0; S[t]; t++){
for (int j = 0; j < 10; j++) F[j] = 1e9;
for (int j = 0; j < 10; j++) for (int i = 0; i < 10; i++){
int k = j * 10 + i - (S[t] - '0');
if (k < 0) continue;
int c = i + k / 10;
k %= 10;
if (F[k] > D[j] + c)
F[k] = D[j] + c;
}
for (int j = 0; j < 10; j++) D[j] = F[j];
}
int ans = 1e9;
for (int j = 0; j < 10; j++) if (ans > D[j] + j) ans = D[j] + j;
printf ("%d\n", ans);
return 0;
}
| //高知能系Vtuberの高井茅乃です。
//Twitter: https://twitter.com/takaichino
//YouTube: https://www.youtube.com/channel/UCTOxnI3eOI_o1HRgzq-LEZw
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF INT_MAX
#define LLINF LLONG_MAX
#define REP(i,n) for(int i=0;i<n;i++)
#define REP1(i,n) for(int i=1;i<=n;i++)
#define MODA 1000000007
template <typename T>
std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
for (T& x: vec) { is >> x; }
return is;
}
int main() {
ll ans = 0;
ll tmp;
string s;
cin >> s;
s = "0" + s;
int dp[s.size()][2] = {};
dp[0][0] = 0;
dp[0][1] = 1;
REP1(i, s.size()-1){
int num = s[i] - '0';
dp[i][0] = min(dp[i-1][0] + num, dp[i-1][1] + 10 - num);
dp[i][1] = min(dp[i-1][0] + num + 1, dp[i-1][1] + 10 - (num + 1));
}
cout << dp[s.size()-1][0] << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[1001][1001];
int main(){
string s1,s2; cin>>s1>>s2;
for(int i=0;i<1001;i++){
for(int j=0;j<1001;j++) dp[i][j]=INT_MAX;
}
dp[0][0]=0;
for(int i=1;i<=(int)s1.size();i++) dp[i][0]=i;
for(int i=1;i<=(int)s2.size();i++) dp[0][i]=i;
for(int i=1;i<=(int)s1.size();i++){
for(int j=1;j<=(int)s2.size();j++){
dp[i][j]=min(dp[i-1][j],dp[i][j-1])+1;//挿入(=削除)
int cost=(s1[i-1]==s2[j-1])?0:1;
dp[i][j]=min(dp[i][j],dp[i-1][j-1]+cost);//置き換え
}
}
cout<<dp[s1.size()][s2.size()]<<endl;
return 0;
} | #include <stdint.h>
#include <cstdlib>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <iostream>
#include <bitset>
#include <array>
#include <stdio.h>
using namespace std;
# define MAX 1000
uint64_t D0[MAX]={0}, HP[MAX]={0}, HN[MAX]={0}, VP[MAX]={0}, VN[MAX]={0};
uint64_t Cmap[MAX][20] = {};
int Mayer(size_t M, size_t N, string &a, string &b){
unsigned int tmax = (M - 1) >> 6;
unsigned int tlen = M - tmax * 64;
// cout << "M:" << M << " " << "N:" << N << endl;
// cout << "tmax:" << tmax << endl;
// cout << "tlen:" << tlen << endl;
for(size_t i = 0; i < tmax; ++i) {
for(size_t j = 0; j < 64; ++j) Cmap[a[i * 64 + j]][i] |= (1L << j);
}
for(size_t i = 0; i < tlen; ++i){
Cmap[a[tmax * 64 + i]][tmax] |= (1L << i);
// printf("%c\n", a[tmax * 64 + i]);
}
int D = tmax * 64 + tlen;
uint64_t top = (1L << (tlen - 1));
uint64_t lmb = (1L << 63);
for(size_t i = 0; i < tmax; ++i) VP[i] = ~0;
for(size_t i = 0; i < tlen; ++i) VP[tmax] |= (1L << i);
for(size_t i = 0; i < N; ++i) {
uint64_t *PM = Cmap[b[i]];
for(int r = 0; r <= tmax; ++r) {
uint64_t X = PM[r];
if(r > 0 && (HN[r - 1] & lmb)) X |= 1L;
D0[r] = (((X & VP[r]) + VP[r]) ^ VP[r]) | X | VN[r];
HP[r] = VN[r] | ~(D0[r] | VP[r]);
HN[r] = D0[r] & VP[r];
X = (HP[r] << 1L);
if(r == 0 || HP[r - 1] & lmb) X |= 1L;
VP[r] = (HN[r] << 1L) | ~(D0[r] | X);
if(r > 0 && (HN[r - 1] & lmb)) VP[r] |= 1L;
VN[r] = D0[r] & X;
}
if(HP[tmax] & top) ++D;
else if(HN[tmax] & top) --D;
}
// free(D0), free(HP), free(HN), free(VP), free(VN);
return D;
}
int main() {
string str1, str2;
std::cin >> str1 >> str2;
if(str1.length() > str2.length()){
string tmp = str1;
str1 = str2;
str2 = tmp;
}
// int res = edit_distance_fixed_<1000, string, 1000>(str1,str2);
int res = Mayer(str1.length(), str2.length(), str1, str2);
std::cout << res << std::endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string field[12];
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
void sol(int x, int y);
int main()
{
while (cin >> field[0]){
long ct = 0;
for (int i = 1; i < 12; i++){
cin >> field[i];
}
for (int i = 0; i < 12; i++){
for (int j = 0; j < 12; j++){
if (field[i][j] == '1'){
field[i][j] = '0';
sol(i, j);
ct++;
}
}
}
cout << ct << endl;
}
}
void sol(int x, int y)
{
for (int i = 0; i < 4; i++){
if (!(0 <= x + dx[i] && 0 <= y + dy[i] && x + dx[i] < 12 && y + dy[i] < 12)) continue;
if (field[x + dx[i]][y + dy[i]] == '1'){
field[x + dx[i]][y + dy[i]] = '0';
sol(x + dx[i], y + dy[i]);
}
}
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define endl '\n'
#define pb push_back
#define fi first
#define se second
#define all(c) (c).begin(),(c).end()
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define TRACE
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
const ll inf = 2e18;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
int dp[1 << 16], sum[1 << 16];
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int a[n][n];
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
sum[0] = 0;
for(int mask = 1; mask < (1LL << n); mask++) {
vi v;
for(int i = 0; i < n; i++) {
if(mask & (1LL << i)) {
v.pb(i);
}
}
for(int i = 0; i < v.size(); i++) {
for(int j = i + 1; j < v.size(); j++) {
sum[mask] += a[v[i]][v[j]];
}
}
}
memset(dp, -63, sizeof(dp));
dp[0] = 0;
for(int mask = 1; mask < (1LL << n); mask++) {
for(int s = mask; s > 0; s = mask & (s - 1)) {
dp[mask] = max(dp[mask], sum[s] + dp[mask ^ s]);
}
}
cout << dp[(1 << n) - 1];
return 0;
} | 0 |
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
#include <utility>
#include <set>
#include <cctype>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
using namespace std;
#define INF 100000000
typedef long long ll;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
const int MAXN = 1010;
int dp[MAXN][MAXN];
int main(void) {
string s1, s2;
cin >> s1;
cin >> s2;
for (int i = 0; i <= s1.size(); i++) {
dp[i][0] = i;
}
for (int i = 0; i <= s2.size(); i++) {
dp[0][i] = i;
}
for (int i = 1; i <= s1.size(); i++) {
for (int j = 1; j <= s2.size(); j++) {
int cost;
if (s1[i-1] == s2[j-1]) cost = 0;
else cost = 1;
dp[i][j] = dp[i-1][j-1] + cost;
dp[i][j] = min(dp[i][j], dp[i][j-1] + 1);
dp[i][j] = min(dp[i][j], dp[i-1][j] + 1);
// cout << dp[i][j] << " ";
}
// cout << endl;
}
cout << dp[s1.size()][s2.size()] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for(int i = n-1; i >= 0; i--)
#define all(x) (x).begin(),(x).end() // 昇順ソート
#define rall(v) (v).rbegin(), (v).rend() // 降順ソート
#define FastIO ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
typedef long long ll;
using P = pair<int,int>;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VP = vector<P>;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return true; } return false; }
int main(){
int n, k;
cin >> n >> k;
int ans = 1;
rep(i,n){
if (ans * 2 > ans + k) ans += k;
else ans *= 2;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define endl '\n';
int main()
{
int a, b, c;
cin >> a >> b >> c;
cout << c << " " << a << " " << b << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = s; i < (int)(n); i++)
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
using pii = pair<int, int>;
//const ll INF = 1e18L + 5;
//const int INF = 1e9 + 5;
//const double pi = 3.14159265358979323846;
void solve()
{
int n;
cin >> n;
if (n == 1)
cout << "Hello World" << endl;
else {
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
}
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
string a;
int main()
{
cin>>a;
if(a.size()==2)
cout<<a<<endl;
else
cout<<a[2]<<a[1]<<a[0]<<endl;
} | #include<bits/stdc++.h>
using namespace std;
const int MAXN = 305;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); }
template <typename T> void read(T &x) {
x = 0; int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T> void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
write(x);
puts("");
}
char s[MAXN];
int n, m, ans, dp[MAXN][MAXN][MAXN];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1), read(m);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
for (int k = 0; k <= n; k++)
dp[i][j][k] = m + 1;
dp[1][n][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = n; j >= i; j--)
for (int k = 0; k <= n; k++) {
int tmp = dp[i][j][k];
if (tmp == m + 1) continue;
chkmin(dp[i + 1][j][k], tmp);
chkmin(dp[i][j - 1][k], tmp);
if (i == j) chkmax(ans, 2 * k + 1);
else {
int cost = s[i] != s[j];
if (cost + tmp <= m) {
chkmin(dp[i + 1][j - 1][k + 1], tmp + cost);
chkmax(ans, 2 * k + 2);
}
}
}
writeln(ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> duo;
#define TT template<typename T>
TT T sq(T x){ return x*x; }
TT int ubnd(vector<T>& v,T x){ return upper_bound(v.begin(), v.end(), x) - v.begin(); }
TT int lbnd(vector<T>& v,T x){ return lower_bound(v.begin(), v.end(), x) - v.begin(); }
TT void sort(T& v){ sort(v.begin(), v.end()); }
TT void revs(T& v){ reverse(v.begin(), v.end()); }
TT void uniq(T& v){ sort(v); v.erase(unique(v.begin(), v.end()), v.end()); }
TT void show(T& v,char d=' ',char e='\n'){for(int i=0;i<v.size();++i)cout<<v[i]<<((i==v.size()-1)?e:d);}
TT void inpt(vector<T>& v,int n){ v.reserve(n);for(int i=0;i<n;++i){T x; cin>>x; v.push_back(x);} }
TT T In(T& x){ cin >> x; return x; }
static inline void fast_io(){ ios::sync_with_stdio(0); cin.tie(0); }
static inline int in(){ int x; scanf("%d", &x); return x; }
static inline string instr(){ string x; cin >> x; return x; }
static const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
static const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
struct Rect {
int h, w, d;
Rect(int h, int w) : h(h), w(w), d(sq(h) + sq(w)) {}
bool operator<(const Rect& x) const {
return d == x.d ? h < x.h : d < x.d;
}
};
int main()
{
vector<Rect> v;
int h, w;
for (int x = 1; x <= 150; x++){
for (int y = 1; y < x; y++){
v.push_back(Rect(y, x));
}
}
sort(v);
while (h = in(), w = in(), h || w){
Rect r = Rect(h, w);
int index = ubnd(v, r);
printf("%d %d\n", v[index].h, v[index].w);
}
return (0);
} | #include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cmath>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int hikaku(int a,int b,int c,int d){
int A=a*a+b*b;
int C=c*c+d*d;
if(A>C)return 1;
if(C>A)return -1;
if(a>c)return 1;
if(c>a)return -1;
return 0;
}
int main(void){
int h,w;
for(;;){
cin >> h >> w;
if(h==0)return 0;
int retH=1000,retW=1000;
for(int H=1;H<=150;H++){
for(int W=H+1;W<=150;W++){
if(h==H && w == W)continue;
if(hikaku(h,w,H,W)<0){
if(hikaku(H,W,retH,retW)<0){
retH=H;
retW=W;
}
}
}
}
cout << retH <<" "<<retW<<endl;
}
return 0;
} | 1 |
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define BIL ((ll)1e9)
#define MOD ((ll)1e9+7)
#define INF (1LL<<60) //1LL<<63でオーバーフロー
#define inf (1<<29) //1<<29でオーバーフロー
int main(int argc,char* argv[]){
int a,b;
cin >> a >> b;
int plug=1;
int tap=0;
while(plug<b){
tap++;
plug=plug-1+a;
}
cout << tap << endl;
return 0;
}
| #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int N, M;
cin>>N>>M;
int arr[N+1];
for(int i=0;i<=N;++i) arr[i] = 0;
int L, R;
for(int i=0;i<M;++i) {
cin>>L>>R;
L--;
arr[L]++;
arr[R]--;
}
for(int i=1;i<=N;++i) arr[i] += arr[i-1];
int ans = 0;
for(int i=0;i<=N;++i) {
if(arr[i]==M) ans++;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define int long long
#define INF 1000000000000000000
using namespace std;
#define ANS(f) if(f) cout << "YES" << endl; else cout << "NO" << endl;
typedef vector<int> vec;
typedef vector<vec> mat;
typedef pair<int, int> Pii;
template<typename T>
void readv(vector<T> &a){ REP(i, a.size()) cin >> a[i]; }
void readi(vector<int> &a){ REP(i, a.size()){cin >> a[i]; a[i]--;} }
void debug(mat m){REP(i, m.size()){ REP(j, m[0].size()){ cout << m[i][j] << ","; } cout << endl; }}
class RMQ_segment_tree
{
using data_type = int;
public:
vector<data_type> dat;
int N;
data_type inf;
RMQ_segment_tree(int n, data_type inf): inf(inf) {
N = 1;
while(n > N) N = N << 1;
dat = vector<data_type>(2 * N - 1, inf);
}
//k番目の値をaに更新
void update(int k, data_type a){
k += N - 1;
dat[k] = a;
while(k > 0){
k = (k - 1) / 2;
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
//[a, b)の最小値
data_type minval(int a, int b){
return query(a, b, 0, 0, N);
}
data_type query(int a, int b, int k, int l, int r){
if(r <= a || b <= l) return inf;
if(a <= l && r <= b) return dat[k];
else{
data_type vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
data_type vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
}
};
signed main(){
int N, Q, A, B; cin >> N >> Q >> A >> B;
vec x(Q); readv(x);
RMQ_segment_tree P(N + 1, INF), M(N + 1, INF);
P.update(A, llabs(x[0] - B) + A);
M.update(A, llabs(x[0] - B) - A);
P.update(B, llabs(x[0] - A) + B);
M.update(B, llabs(x[0] - A) - B);
int ans = 0;
FOR(i, 1, Q){
int tmp = llabs(x[i] - x[i - 1]);
ans += tmp;
int mm = M.minval(0, x[i]) + x[i] - tmp;
int mp = P.minval(x[i], N + 1) - x[i] - tmp;
int v = P.minval(x[i - 1], x[i - 1] + 1) - x[i - 1];
int m = min(v, min(mm, mp));
P.update(x[i - 1], m + x[i - 1]);
M.update(x[i - 1], m - x[i - 1]);
}
int m = INF;
FOR(i, 1, N + 1) m = min(m, P.minval(i, i + 1) - i);
ans += m;
cout << ans;
return 0;
} | #include <cstdio>
typedef long long ll;
int n,x,y,z,s,t;
int f[50][1<<17],Ans=1;
const int p=1000000007;
int main()
{
scanf("%d%d%d%d",&n,&x,&y,&z);
for(int i=1;i<=n;++i)Ans=(ll)Ans*10%p;
t=(1<<(x-1))|(1<<(x+y-1))|(1<<(x+y+z-1));
s=(1<<(x+y+z))-1;
f[0][0]=1;
for(int i=1;i<=n;++i)
for(int j=0;j<=s;++j)
for(int k=1;k<=10;++k)
{
int r=(j<<k|(1<<(k-1)))&s;
if((r&t)!=t)(f[i][r]+=f[i-1][j])%=p;
}
for(int i=0;i<=s;++i)Ans=(Ans-f[n][i]+p)%p;
printf("%d\n",Ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n); for(int i = 0;i<n;++i)
using ll = long long;
using P = pair<int,int>;
int main(){
string s;
cin >> s;
int n = s.size();
cout << s.substr(0,n-8) << endl;
return 0;
}
| #include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <iomanip>
#include <math.h>
#include <utility>
#include <vector>
#include <map>
#include <cstdlib>
#define div1 1000000007
const long long INF = 1LL << 60;
using namespace std;
// a>b -> a==b;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
// a<b -> a==b;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
int main(void)
{
string s;
int i;
cin >> s;
for(i=0; i<s.size(); i++){
if(i < s.size() - 8){
cout << s[i];
}
}
cout << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using pii = pair<int,int>;
using ll = long long;
using pll = pair<ll,ll>;
using pli = pair<ll,int>;
using pil = pair<int,ll>;
using ld = long double;
using ui = unsigned int;
using ull = unsigned long long;
using ui128 = __uint128_t;
#define all(x) (x).begin(),(x).end()
#define mp make_pair
#define lc ind<<1
#define rc ind<<1|1
const int MN = 1e5 + 2, LOG = 17, INF = 1e8;
char s[MN];
int wot[MN];
int main () {
int n;
scanf ("%d",&n);
auto nxt = [&] (int a) {int x = a + 1; return x > n ? 1 : x;};
auto lst = [&] (int a) {int x = a - 1; return x < 1 ? n : x;};
scanf ("%s",s+1);
for (int a = 0; a < 2; a++) {
for (int b = 0; b < 2; b++) {
wot[1] = a; wot[2] = b;
for (int i = 3; i <= n; i++) {
if ((s[i-1] == 'o' && wot[i-1] == 0) || (s[i-1] == 'x' && wot[i-1] == 1)) wot[i] = wot[i-2];
else wot[i] = wot[i-2] ^ 1;
}
bool ok = 1;
for (int i = 1; i <= n; i++) {
if ((s[i] == 'o' && wot[i] == 0) || (s[i] == 'x' && wot[i] == 1)) ok &= wot[nxt(i)] == wot[lst(i)];
else ok &= wot[nxt(i)] != wot[lst(i)];
}
if (ok) {
for (int i = 1; i <= n; i++) putchar(wot[i]?'W':'S');
return 0;
}
}
}
printf ("-1\n");
return 0;
}
| #include <cmath>
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
#include<queue>
#include<set>
#include<tuple>
#include<bitset>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll inf = 1000000007;
ll n;
vector<vector<P>>v;
bool check(int bit) {
for (int i = 0; i < n; i++) {
if (!(bit & (1 << i)))continue;
for (P id : v[i]) {
int x = id.first;
int y = id.second;
if (y == 1 && !(bit & (1 << x))) {
return false;
}
if (y == 0 && (bit & (1 << x))) {
return false;
}
}
}
return true;
}
int main(void) {
cin >> n;
v.resize(n);
for (int i = 0; i < n; i++) {
int a; cin >> a;
v[i].resize(a);
for (int j = 0; j < a; j++) {
cin >> v[i][j].first >> v[i][j].second;
--v[i][j].first;
}
}
int res = 0;
for (int bit = 0; bit < (1 << n); bit++) {
if (check(bit)) {
int count = 0;
for (int i = 0; i < n; i++) {
if (bit & (1 << i)) {
count++;
}
}
res = max(res, count);
}
}
cout << res << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int board = 1;
int N, K;
cin >> N >> K;
int i;
for(i = 0; i < N; i++){
if(board > K)
break;
board *= 2;
}
for(;i < N; i++)
board += K;
cout << board << endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main()
{
int a, b;
cin >> a >> b;
if (a < 9 && b < 9) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
const int mod = 1e9+7;
const int mx = INT_MAX;
const long double pi = 4*atan((long double)1);
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef vector<pii> vii;
#define file "orz"
const int mxN = 2e5+5;
int arr[mxN], st[20][mxN];
int jump(int pos, int x)
{
for(int i=19;i>=0;i--)
if((x>>i)&1)
pos = st[i][pos];
return pos;
}
int main()
{
//freopen(file".inp","r",stdin);
//freopen(file".out","w",stdout);
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int n;
cin>>n;
for(int i=1;i<=n;i++)
cin>>arr[i];
int L;
cin>>L;
for(int i=1;i<=n;i++)
{
int l = ub(arr+1,arr+n+1,arr[i]+L)-arr-1;
st[0][i]=l;
}
for(int i=1;i<20;i++)
for(int j=1;j<=n;j++)
st[i][j]=st[i-1][st[i-1][j]];
int q;
cin>>q;
while(q--)
{
int x,y;
cin>>x>>y;
if(x>y)
swap(x,y);
int l=0, r=n;
while(l<r)
{
int mid=(l+r)>>1;
if(jump(x,mid)>=y)
r = mid;
else
l = mid+1;
}
cout<<r<<endl;
}
}
| #include<iostream>
#include<string>
using namespace std;
int main() {
string str, cmd;
int a, b, q;
cin >> str >> q;
for (int i = 0; i < q; i++) {
cin >> cmd >> a >> b;
if (cmd == "print") {
for (int j = a; j <= b; j++)
cout << str[j]; cout << endl;
}
else if (cmd == "reverse") {
int fend = (b - a + 1) / 2;
for (int j = 0; j < fend; j++)
swap(str[a++], str[b--]);
}
else if (cmd == "replace") {
string p; int n = 0;
cin >> p;
for (int k = a; k <= b; k++) {
str[k] = p[n++];
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define f first
#define s second
using namespace std;
int main(){
int x, y;
cin >> x >> y;
int a[100]; memset(a,0,sizeof(a));
bool ok = true;
int cnt = 0;
for(int i = 1; i <= 16; i++){
cnt++;
if(cnt > 100){
ok = false; break;
}
int prev = i-1;
if(prev < 1)prev = 16;
if(a[i] == 0 && a[prev] != 1){
a[i] = 1;
x--;
if(x == 0)break;
}
if(i == 16)i = 0;
}
cnt = 0;
for(int i = 1; i <= 16; i++){
cnt++;
int prev = i-1;
if(prev < 1)prev = 16;
if(cnt > 100){
ok = false; break;
}
if(a[i] == 0 && a[prev] != 2){
a[i] = 2;
y--;
if(y == 0)break;
}
if(i == 16)i = 0;
}
cout << (ok ? "Yay!" : ":(") << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int> P;
int INF = 1e9+7;
int mod = 1e9+7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0 ,-1};
signed main(){
int A,B;
cin >> A >> B;
if(A <= 8 && B <= 8) {
cout << "Yay!" << endl;
}
else {
cout << ":(" << endl;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
vector<ll>m(1002);
vector<pair<long long, long long> > prime_factorize(long long N) {
vector<pair<long long, long long> > res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
long long ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
res.push_back({a, ex});
m[a]+=ex;
}
// 最後に残った数について
if (N != 1){
res.push_back({N, 1});
m[N]++;
}
return res;
}
int main() {
ll N;
cin >>N;
rep2(i,N){
prime_factorize(i);
}
ll ans=1;
rep2(i,N){
ans= (ans*(m[i]+1))%mod;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define all(v) begin(v),end(v)
using ll = long long;
int main() {
ll n;cin>>n;
string s;
while(n){
n--;
s+=(char)('a'+n%26);
n/=26;
}
reverse(all(s));
cout<<s<<endl;
} | 0 |
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<utility>
#include<set>
#include<complex>
#define vi vector<int>
#define vvi vector<vector<int> >
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i,n) for(int i=0;i<n;i++)
#define CC puts("-------ok--------");
#define all(in) in.begin(), in.end()
#define bv vector<bool>
using namespace std;
typedef pair<int, int>PA;
using namespace std;
#define MAX 999999
int main(){
int n,s;
while(cin >> n >> s,n+s){
int temp = s;
vi v(n,0); int count = 0; bool check = true;
while(true){
if(s != 0){s-=1;v[count]++; if(v[count] == temp){cout << count << endl; break;}
}else if(s == 0){
s+=v[count]; v[count] = 0;
}
if(count == n-1)
count =0;
else
count++;
}
}
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n,p,P;
int have[50];
int remain=0;
int plase=0;
while(1){
for(int i=0;i<50;i++){
have[i]=0;
}
cin>>n>>p;
P=p;
plase=0;
if(n==0 && p==0) break;
while(1){
if(have[plase%n]==P) break;
if(p==0){
p=have[plase%n];
have[plase%n]=0;
plase++;
}else{
have[plase%n]++;
plase++;
p--;
}
}
cout<<plase%n<<endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
using namespace std;
const int N=1000005;
int n,pos,ans,head,tail,q[N];
char s[N],t[N];
int main(){
scanf("%d%s%s",&n,s+1,t+1);
if(!strcmp(s+1,t+1)){
puts("0");
return 0;
}
pos=n;
head=1,tail=0;
for(int i=n;i>=1;i--){
if(t[i]==t[i-1]){
continue;
}
pos=min(pos,i);
while(pos&&t[i]!=s[pos]){
pos--;
}
if(!pos){
puts("-1");
return 0;
}
while(head<=tail){
if(q[head]-(tail-head+1)+1>i){
head++;
}else{
break;
}
}
q[++tail]=pos;
if(i!=pos){
ans=max(ans,tail-head+1);
}
}
printf("%d\n",ans+1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
//
int num, l;
int sum = 0;
int small = 999999;
cin >> num >> l;
for (int i = 1; i <= num; i++) {
int tmp;
tmp = l + i - 1;
sum += tmp;
if (abs(tmp) < abs(small)) small = tmp;
}
cout << sum - small;
//
}
| 0 |
#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
int main(){
double x1,x2,y1,y2;
double d;
cin >> x1 >> y1 >> x2 >> y2;
d = (double)sqrt(((x2-x1)*(x2-x1))+((y2-y1)*(y2-y1)));
printf("%.6lf\n",d);
return 0;
} | #include "bits/stdc++.h"
using namespace std;
using ll = long long; using ull = unsigned long long;
#define int ll
using vb = vector<bool>; using vvb = vector<vb>;
using vi = vector<int>; using vvi = vector<vi>;
using vl = vector<ll>; using vvl = vector<vl>;
using pii = pair<int,int>; using pll = pair<ll,ll>;
#define FOR(i,a,b) for(ll i = (a); i < (ll)(b); ++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(ll i = (ll)(b)-1;i >= a;--i)
#define RREP(i,n) RFOR(i,0,n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1);
const double EPS = 1e-10;
const ll MOD = 1e9+7;
void cioacc(){//accelerate cin/cout
cin.tie(0);
ios::sync_with_stdio(false);
}
signed main(){
cout << fixed << setprecision(10);
double a,b;
cin >> a >> b;
complex<double> c = {a,b};
cin >> a >> b;
complex<double> d = {a,b};
cout << abs(c-d) << endl;
}
| 1 |
#include <cstdio>
#include <algorithm>
#pragma warning(disable : 4996)
using namespace std;
int n, m, c[1009], s[510009], t[510009], cnt[32777], sum[32777];
int main() {
while (scanf("%d%d", &n, &m), n) {
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
sort(c, c + n);
int b = 0;
for (int i = 0; i <= n; i++) {
for (int j = i; j <= n && c[i] + c[j] <= m; j++) {
s[b++] = c[i] + c[j];
}
}
for (int i = 0; i < 30; i += 15) {
fill(cnt, cnt + 32768, 0); sum[0] = 0;
for (int j = 0; j < b; j++) cnt[(s[j] >> i) & 32767]++;
for (int j = 0; j < 32768; j++) sum[j + 1] = sum[j] + cnt[j];
for (int j = 0; j < b; j++) t[sum[(s[j] >> i) & 32767]++] = s[j];
for (int j = 0; j < b; j++) s[j] = t[j];
}
int r = b - 1, ret = 0;
for (int i = 0; i < b && i <= r; i++) {
while (r > 0 && s[i] + s[r] > m) r--;
ret = max(ret, s[i] + s[r]);
}
printf("%d\n", ret);
}
return 0;
} | #include<iostream>
#include<vector>
#include<map>
#include<utility>
#include<algorithm>
#include<queue>
#include<stack>
#include<string>
#include<stdlib.h>
#include<stdio.h>
#include<cmath>
#include<cstdlib>
#include<typeinfo>
#include<sstream>
#include<list>
#include<set>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define fori(i,k,n) for(int i=k;i<(int)n;i++)
using namespace std;
int in()
{
int x;cin>>x;
return x;
}
int stringInt(string a)
{
return atoi(a.c_str());
}
string intString(int a)
{
stringstream ss;
ss<<a;
return ss.str();
}
vector<int> SieveOfEratosthenes(int x)
{
vector<int> a;
vector<int> b(x+1,0);
for(int i=2;i<=x;i++)
{
if(b[i]==0)
{
a.push_back(i);
for(int l=i;l<=x;l+=i)
{
b[l]=1;
}
}
}
return a;
}
int main ()
{
int n,m;
while(cin>>n>>m&&n&&m)
{
vector<long long > a,b;
b.push_back(0);
rep(i,n)
{
b.push_back(in());
}
rep(i,n+1)
{
rep(l,n+1)
{
a.push_back(b[i]+b[l]);
}
}
long long ans = 0;
sort(a.begin(),a.end());
rep(i,a.size())
{
vector<long long>::iterator t=upper_bound(a.begin(),a.end(),m-a[i]);
if(t==a.begin())continue;
t--;
ans=max(ans,*t+a[i]);
}
cout<<ans<<endl;
}
} | 1 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> a;
for(int i=1;i<=n;++i){
if(i%3==0)
a.push_back(i);
else if(i%10==3)
a.push_back(i);
else if(i/10%10==3)
a.push_back(i);
else if(i/100%10==3)
a.push_back(i);
else if(i/1000%10==3)
a.push_back(i);
}
sort(a.begin(),a.end());
for(int i=0;i<a.size();++i){
cout<<" "<<a[i];
}
cout<<endl;
return 0;
}
/*void call(int n){
int i = 1;
CHECK_NUM:
int x = i;
if ( x % 3 == 0 ){
cout << " " << i;
goto END_CHECK_NUM;
}
INCLUDE3:
if ( x % 10 == 3 ){
cout << " " << i;
goto END_CHECK_NUM;
}
x /= 10;
if ( x ) goto INCLUDE3;
END_CHECK_NUM:
if ( ++i <= n ) goto CHECK_NUM;
cout << endl;
}
int main()
{
call(30);
}*/ | #include <bits/stdc++.h>
using namespace std;
void call(int);
int main() {
int n;
cin >> n;
call(n);
return 0;
}
void call(int n)
{
for (int i = 1; i <= n; i++)
{
if (i % 3 == 0)
{
cout << " " << i;
continue;
}
else if (i % 10 == 3 || (i / 10) % 10 == 3 || (i / 100) % 10 == 3 || (i / 1000) % 10 == 3 || (i / 10000) % 10 == 3)
{
cout << " " << i;
continue;
}
}
cout << endl;
}
| 1 |
//Tonight's the night and it is going to happen again and again.
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mp make_pair
#define pb push_back
#define T ll t; cin>>t; while(t--)
#define mod 1000000007
#define inf 1000000000000000000
#define mem(name,val) memset(name,val,sizeof(name))
#define f(n) for(ll i=0;i<n;i++)
#define rep(i,a,n) for(ll i=a;i<n;i++)
#define endl "\n"
ll gcd(ll a,ll b){if(b==0){return a;}return gcd(b,a%b);}
int main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int n;ll sum=0;cin>>n;int a[n];
f(n){cin>>a[i];}
rep(i,1,n)
{
if(a[i]<a[i-1]){sum+=a[i-1]-a[i];a[i]=a[i-1];}
}
cout<<sum;
} | #include<bits/stdc++.h>
#define int long long int
#define mod 998244353
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output1.txt","w", stdout);
#endif
int n;
cin>>n;
int a[n];
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
int ans=0,s;
s=a[0];
for (int i = 1; i < n; ++i)
{
s=max(s,a[i]);
ans+=(s-a[i]);
}
cout<<ans;
#ifndef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
} | 1 |
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ll long long
using namespace std;
const ll P = 1000000007;
const long long INF = 1LL << 60;
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main()
{
cout << fixed << setprecision(10);
int K,T;
cin >> K >> T;
vector<int> a(T);
rep(i,T) cin >> a[i];
sort(ALL(a));
int sum = 0;
rep(i,T-1)
{
sum += a[i];
}
if(sum>a[T-1])
{
cout << 0 << endl;
}
else
{
cout << a[T-1] - sum - 1 << endl;
}
return 0;
}
| #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
using namespace std;
int main()
{
int n,m;cin >> n >> m;
vector<int> a(m);
rep(i,m) cin >> a[i];
vector<vector<int>> dp(m+1, vector<int>(n+1, -1));
sort(a.begin(), a.end());
vector<int> b = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
dp[0][0] = 0;
rep1(i,m) {
rep(j,n+1) {
if(j - b[a[i-1]] >= 0) {
if(dp[i][j - b[a[i-1]]] != -1) {
dp[i][j] = max(dp[i][j - b[a[i-1]]] + 1, dp[i-1][j]);
}
else dp[i][j] = dp[i-1][j];
}
else dp[i][j] = dp[i-1][j];
}
}
// rep(i,m+1) {
// rep(j,n+1) {
// cout << dp[i][j] << " ";
// }
// cout << "\n";
// }
int x = m, y = n;
while(y > 0 ) {
if(y - b[a[x-1]] >= 0) {
if( dp[x][y] - 1 == dp[x][y - b[a[x-1]]] ) {
cout << a[x-1];
y -= b[a[x-1]];
}
else x--;
}
else x--;
}
cout << "\n";
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string str;
int num,rest=0,result=0;
cin>>str;
for(long int i=str.size()-1;i>=0;i--){
num=str[i]-'0'+rest;
if(num<(10-num) || (num==5 && str[i-1]<'5')){
rest=0;
result+=num;
}
else{
rest=1;
result+=(10-num);
}
}
result+=rest;
cout<<result;
}
| #include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
using namespace boost::adaptors;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int64_t m = s.size();
vector a(1, 0L);
int64_t t = 0;
for (auto c : s) {
if (c == '0') {
a.push_back(t);
} else {
++t;
}
}
a.push_back(t);
int64_t k;
cin >> k;
k = min(k, a.back());
int64_t n = a.size();
constexpr auto M = 998244353L;
vector dp(vector(k + 1, vector(a.back() + 1, 0L)));
int64_t mk = 0;
dp[0][0] = 1;
for (auto i : irange(0L, n - 1)) {
for (auto j : irange(mk, -1L, -1L)) {
auto r = min(k - j, a[i + 1] - a[i]);
for (auto d : irange(1L, r + 1L)) {
auto w = j + d;
for (auto c : irange(0L, a.back() - a[i + 1] + 1)) {
auto b = c + d;
dp[w][c] += dp[j][b];
if (dp[w][c] >= M) {
dp[w][c] -= M;
}
}
}
for (auto c : irange(1L, a.back() - a[i + 1] + 1)) {
dp[j][c] += dp[j][c - 1];
if (dp[j][c] >= M) {
dp[j][c] -= M;
}
}
}
mk = min(k, mk + a[i + 1] - a[i]);
}
int64_t ans = 0;
for (auto i : irange(0L, mk + 1)) {
ans += dp[i][0];
}
cout << ans % M << "\n";
}
| 0 |
#include <bits/stdc++.h>
#include <math.h>
#define ALL(a) a.begin(), a.end()
#define rep(i, K, N) for(long long int i = K; i < N; i++)
#define ll long long int
using namespace std;
int main(){
ll N, Ans = 1000000000, K;cin >> N >> K;
bool C = 0;
vector<ll> n;
vector<ll> p{0};
rep(i, 0, N){
ll a;cin >> a;
if(a == 0)continue;
if(a > 0)C = 1;
if(C)p.push_back(a);
else n.push_back(a);
}
n.push_back(0);
reverse(ALL(n));
if(p == n && p.size() == 1){cout << 0;exit(0);}
//for(auto q : n)cout << q << endl;
int A = K - n.size() + 1, B = K, D = p.size() - 1;
for(ll i = max(A, 0); i <= min(B, D); i++){
Ans = min(Ans, min(2*p[i] + abs(n[K - i]), 2*abs(n[K - i]) + p[i]));
}
cout << Ans;
} | #define _GLIBCXX_DEBUG
#include"bits/stdc++.h"
using namespace std;
//loops
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define OneToN(i,n) for(ll i=1;i<(ll)(n+1);i++)
#define ZeroToN(i,n) for(ll i=0;i<(ll)(n+1);i++)
#define AToB(i,a,b) for(ll i=a;i<(ll)(b+1);i++)
#define FOR(i,a,b) for(ll i=(a);i<=(b);i++)
#define FORD(i,a,b) for(ll i=(a);i>=(b);i--)
//bitsearch
#define BITSEARCH(bit, n) for (int bit = 0; bit < (1<<n); ++bit)
#define isOne(bit, i) bit & (1<<i)
//arrays
#define ALL(x) (x).begin(),(x).end() //sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) //sizeをsize_tからllに直しておく
#define add push_back
template<typename T>
std::vector<T> slice(std::vector<T> const &v, int m, int n)
{
auto first = v.cbegin() + m;
auto last = v.cbegin() + n + 1;
std::vector<T> vec(first, last);
return vec;
}
//v need to be sorted
#define remove_unique(v) v.erase(unique(ALL(v)), v.end())
//comparision
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
//pair
#define fir first
#define sec second
#define mp make_pair
//types
#define ll long long
#define vec vector
#define cord2d pair<int,int>
#define intP pair<int, int>
//UNCOMMENT WHEN NEEDED
//#define int ll
//input
template <class T> T get(){ T s; cin >> s; return(s);}
#define gi get<int>()
#define gs get<string>()
#define gll get<ll>()
template <class T> vector<T> getv(int n) { vec<T> v(n); REP(i, n) cin >> v[i]; return v; }
#define gim(n) getv<int>(n)
#define gsm(n) getv<string>(n)
#define gllm(n) getv<ll>(n)
//output
void print(int a){ cout << a << endl; }
void print(long long a){ cout << std::fixed << a << endl; }
void print(string a){ cout << a << endl; }
void print(char a){ cout << a << endl; }
void print(double a){ cout << a << endl; }
void print(double a, int dig){ cout << std::setprecision(dig) << a << endl; }
template <class T>ostream &operator<<(ostream &o,const vector<T>&v)
{o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}
template <class T = int>
void print(vec<T> v){ cout << v << endl; }
template <class T = int>
void print2dVec(vec<vec<T>> v2d){for(vec<T> v: v2d) {print(v);}}
void YesNo1(bool i = true){ return print(i?"Yes":"No"); }
void YESNO2(bool i = true){ return print(i?"YES":"NO"); }
//debug output
#define var_name(var) #var
template <class T> void debug(T &var, int nest = 0, string before = "") { cout << string(" ", nest) << before; print(var); }
//name replacement
#define y0 y0__
#define y1 y1__
#define j0 j0__
#define j1 j1__
//bool lambdas
#define lamb(exp) [](auto i){return exp;}
#define isEven [](int i){return i % 2 == 0;}
#define isOdd [](int i){return i % 2 != 0;}
//constants
const ll INF = 1e18;
const int MOD = 1000000007;
const vec<string> alphabets = { "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z" };
//maths
int factorial(int k){ int sum = 1; for (int i = 1; i <= k; ++i) { sum *= i; } return sum; }
ll gcd(ll a, ll b) { if (b == 0) { return a; } return gcd(b, a % b); }
ll lcm(ll a, ll b) { ll temp = gcd(a, b); return temp ? (a / temp * b) : 0; }
////////////////////
void Main() {
//code here
int n = gi, k = gi;
vec<int> nums = gim(n);
int minDif = INT_MAX;
REP(i, n-k+1) {
int l = i;
int r = l+k-1;
int dif = min(abs(nums[r]), abs(nums[l])) + abs(nums[l]-nums[r]);
chmin(minDif, dif);
}
print(minDif);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
Main();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector< int64_t > divisor(int64_t n) {
vector< int64_t > ret;
for(int64_t i = 1; i * i <= n; i++) {
if(n % i == 0) {
ret.push_back(i);
if(i * i != n) ret.push_back(n / i);
}
}
return (ret);
}
int main(){
cin.tie(0); ios::sync_with_stdio(false);
int64_t n,a,b,c; cin>>n>>a>>b; if(n==3)cin>>c;
vector<int64_t> v;
for(auto t:divisor(a))if(!(b%t))v.push_back(t);
if(n==3)for(auto t:v)if(c%t)v.erase(find(v.begin(),v.end(),t));
sort(v.begin(),v.end());
for(auto t:v)cout<<t<<'\n';
}
| // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using vd = vector<double>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vpii = vector<pii>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvpii = vector<vpii>;
template<typename A> using fn = function<A>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int &n) { return n & 1; }
constexpr bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
vi divisors(int n) {
vi v;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
v.pb(i);
if (n != 1 && i * i != n) v.pb(n / i);
}
}
sort(all(v));
return v;
}
void solve() {
int n;
cin >> n;
vi a(n);
rep(i, n) cin >> a[i];
vvi x;
transform(all(a), back_inserter(x), [](int x) {
return divisors(x);
});
vi ds = accumulate(x.begin() + 1, x.end(), x.front(), [](vi a, vi x) {
vi w;
set_intersection(all(a), all(x), back_inserter(w));
return w;
});
for (auto x : ds) cout << x << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long int n;
cin>>n;
cout<<(1+n)*n/2-(3+n-n%3)*(n-n%3)/3/2-(5+n-n%5)*(n-n%5)/5/2+(15+n-n%15)*(n-n%15)/15/2<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll N, O = 0;
cin >> N;
for (ll i = 0; i <= N; i++) {
if (i % 3 != 0 && i % 5 != 0) {O += i;}
}
cout << O << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int main(void) {
int n; ll x, cnt=0;
cin >> n >> x;
ll a[n];
rep(i,n) cin >> a[i];
rep(i,n-1) {
if(a[i+1] > 0) {
if(a[i]+a[i+1]>x) {
cnt += (min(a[i+1],a[i]+a[i+1]-x));
a[i+1] -= min(a[i+1],a[i]+a[i+1]-x);
} else ;
}
if(a[i]>0) {
if(a[i]+a[i+1]>x) {
cnt += (min(a[i],a[i]+a[i+1]-x));
a[i] -= min(a[i],a[i]+a[i+1]-x);
} else ;
}
}
//rep(i,n) cout << a[i] << endl;
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, X;
cin >> N >> X;
vector<long long int> A(N);
long long int ans = 0;
for (long long int i = 0; i < N; i++) cin >> A.at(i);
for (long long int i = 1; i < N; i++) {
if (A.at(i) + A.at(i - 1) > X) {
ans += A.at(i) + A.at(i - 1) - X;
if (A.at(i - 1) > X) {
A.at(i - 1) = X;
A.at(i) = 0;
}
else {
A.at(i) = X - A.at(i - 1);
}
}
}
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define fi first
#define se second
#define pb push_back
#define soo(v) sort(v.rbegin(),v.rend())
#define so(v) sort(v.begin(),v.end())
#define lb(v,x) lower_bound(v.begin(),v.end(),x)
#define ub(v,x) upper_bound(v.begin(),v.end(),x)
#define endl '\n'
#define dbv(v) cout<<endl;cout<<#v<<"-->> ";for(auto it:v){cout<<it<<" ";}cout<<endl;
#define dbm(m)cout<<endl;cout<<#m<<"-->> ";for(auto it:m){cout<<it.fi<<" "<<it.se.fi<<" "<<it.se.se<<endl;}
#define dbs(s)cout<<endl;cout<<#s<<"-->> ";for(auto it:s){cout<<it<<" ";}cout<<endl;
#define mod 1000000007
#define db1(x) cout<<#x<<"="<<x<<endl;
#define db2(x,y) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<endl;
#define db3(x,y,z) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<","<<#z<<"="<<z<<endl;
#define mx 1e18
#define mxe(v) *max_element(v.begin(),v.end())
#define mne(v) *min_element(v.begin(),v.end())
#define double long double
int powe(int x,int n)
{
if(n==0)return 1;
if(n%2==0)
return powe((x%mod*x%mod)%mod,n/2)%mod;
return (x%mod*powe((x%mod*x%mod)%mod,(n-1)/2))%mod;
}
int gcd(int A,int B)
{
if(B==0)return A;
return gcd(B,A%B);
}
#define io std::ios::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL);
#define re(s) reverse(s.begin(),s.end())
int32_t main()
{
io
int a;
cin>>a;
cout<<a*(1+a+a*a)<<endl;
} | #include <bits/stdc++.h>
using namespace std;
double solve(vector<vector<vector<double>>> &dp,int a, int b, int c, int n) {
if (dp[a][b][c]) return dp[a][b][c];
if (!a&&!b&&!c) return 0;
dp[a][b][c] = 1.0*n/(a+b+c);
if (a) dp[a][b][c] += solve(dp,a-1,b,c,n)*a/(a+b+c);
if (b) dp[a][b][c] += solve(dp,a+1,b-1,c,n)*b/(a+b+c);
if (c) dp[a][b][c] += solve(dp,a,b+1,c-1,n)*c/(a+b+c);
return dp[a][b][c];
}
int main() {
int N;
cin >> N;
int ones = 0, twos = 0, threes = 0, a;
vector<vector<vector<double>>> dp(N+1,vector<vector<double>>(N+1,vector<double>(N+1)));
for (int i = 0; i < N; i++) {
cin >> a;
ones += a == 1;
twos += a == 2;
threes += a == 3;
}
cout.precision(20);
cout << solve(dp,ones,twos,threes,N);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
using vec_int = vector<int>;
using P = pair<int,int>;
using T = tuple<int,int,int>;
using ll = long long;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
int charToInt(char c){
char zero_num = '0';
return (int)c - (int)zero_num;
}
signed main(){
int N; cin>>N;
vec_int A(N);
rep(i,N)cin>>A.at(i);
int status = 1;
int tot = 0;
for(int i=N-1;i>-1;i--){
if(A.at(i)>i){
cout<<-1<<endl;
return 0;
}
if(status==1){
tot += A.at(i);
if(i>0){
if(A.at(i-1)<A.at(i)){
status=0;
if(A.at(i)-A.at(i-1)>1){
cout<<-1<<endl;
return 0;
}
}
}
}else{
if(i>0){
if(A.at(i-1)>=A.at(i))status=1;
}
}
}
cout<<tot<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i,n) for(ll (i)=0; (i)<(ll)(n); (i)++)
#define frep(i,m,n) for(ll (i)=(m); (i)<=(ll)(n); (i)++)
#define rrep(i,n) for(ll (i)=(n)-1; (i)>-1; (i)--)
#define frrep(i,m,n) for(ll (i)=(n); (i)>(ll)(m); (i)--)
#define ALL(x) (x).begin(), (x).end()
const ll INF = 100100100100100100;
const ll MOD = 1000000007;
// get abs
ll my_abs(ll a);
// a^n
ll a_n(ll a, ll n);
// get gcd
ll my_gcd(ll a, ll b);
// a^(-1) % MOD
ll inv(ll a);
// (a+b+c)%MOD
ll madd(ll a, ll b, ll c);
// (a-b)%MOD
ll msub(ll a, ll b);
// (a*b*c)%MOD
ll mtime(ll a, ll b, ll c);
int main() {
ll n, ans = 0; cin >> n;
vector<ll> a(n), b(n, 0);
rep(i, n) cin >> a[i];
if(a[0] != 0) {
cout << -1 << endl;
return 0;
}
else {
rep(i, n-1) {
if(a[i]+1 < a[i+1]) {
cout << -1 << endl;
return 0;
}
}
rep(i, n) {
b[i-a[i]]++;
}
ll index = 0;
rep(i, n) {
rep(j, b[i]) {
a[index] = i;
index++;
}
}
set<ll> s;
rep(i, n) {
if(!s.count(a[n-1-i])) {
s.insert(a[n-1-i]);
ans += (n-1-i) - a[n-1-i];
}
}
cout << ans << endl;
}
return 0;
}
ll my_abs(ll a) {
if(a >= 0) return a;
else return -1 *a;
}
ll a_n(ll a, ll n) {
if(n == 0) return 1;
ll ret = a, count = 1;
while(count * 2 < n) {
ret *= ret;
count *= 2;
}
if(count == n) return ret;
else return (ret * a_n(a, n-count));
}
ll my_gcd(ll a, ll b) {
if(b == 0) return a;
return my_gcd(b, a%b);
}
ll inv(ll a) {
return a_n(a, MOD-2);
}
ll madd(ll a, ll b, ll c) {
ll ret = (a+b) % MOD;
return (ret+c) % MOD;
}
ll msub(ll a, ll b) {
if(a < b) return (a-b+MOD) % MOD;
else return (a-b) % MOD;
}
ll mtime(ll a, ll b, ll c) {
ll ret = (a*b) % MOD;
return (ret*c) % MOD;
}
| 1 |
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
ll const INF = 1LL << 60;
int main() {
string S;
int w;
cin >> S >> w;
int i = 0;
string ans = "";
ans += S[0];
while (i + w < S.length()) {
i = i + w;
ans += S[i];
}
cout << ans << endl;
return 0;
} | #include"bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
string S;
int w;
cin >> S >> w;
rep(i, S.size()) {
if (i % w == 0) {
cout << S.at(i);
}
}
cout << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll,ll>;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define rep2(i,m,n) for(int (i)=(m);(i)<(n);(i)++)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
const ll INF = 1LL<<60;
const ll MOD = 1e9+7;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n,k;cin>>n>>k;
vector<ll> x(n);rep(i,n)cin>>x[i];
ll ans = INF;
for(int i=0; i+k-1<n; i++){
ll l = x[i], r = x[i+k-1];
ll a;
if(r<0)a=-l;
else if(l<0)a=min(r-2*l, 2*r-l);
else a=r;
ans = min(ans, a);
}
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, e) for (int i = s; i < e; ++i)
#define sort_(a) stable_sort(a.begin(), a.end())
#define rsort(a) stable_sort(a.rbegin(), a.rend())
#define sum(a) accumulate(a.begin(), a.end(), 0LL)
#define join(a, d) accumulate(a.begin() + 1, a.end(), a[0], [](string s, string t) {return s + d + t;})
#define all(a) a.begin(), a.end()
// #define __lcm(a, b) std::__detail::__lcm(a, b)
typedef long long ll;
const long mod = 1e9 + 7;
ll lcm(ll x, ll y) {
return x / __gcd(x, y) * y;
}
int main(void) {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
long N, K;
cin >> N >> K;
vector<long> A(N);
rep(i, 0, N) cin >> A[i];
long maxa = accumulate(all(A), A[0], [](long x, long y) {return max(x, y);});
if (maxa < K) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
long gcd1 = accumulate(all(A), A[0], [](long x, long y) {return __gcd(x, y);});
long gcd2 = __gcd(gcd1, K);
if (gcd1 == gcd2) {
cout << "POSSIBLE" << endl;
} else {
cout << "IMPOSSIBLE" << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string s, t, r;
int n, a, b;
cin >> s >> n;
for (int i = 0; i < n; i++) {
cin >> t >> a >> b;
if (t == "print")
cout << s.substr(a, b - a + 1) << endl;
else if (t == "reverse")
for (int j = 0; j < (b - a + 1) / 2; j++)
swap(s[a + j], s[b - j]);
else {
cin >> r;
s.replace(a, b - a + 1, r);
}
}
} | // class point の練習（クラスの高度な実装）
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cstring>
typedef long long llong;
using namespace std;
int main() {
char strin[1010];
int a, b;
int q;
char querin[10];
char repin[1100];
char revin[1100];
scanf("%s", strin);
getchar();
cin >> q;
for (int i = 0; i < q; i++) {
scanf("%s %d %d", querin, &a, &b);
if (!strcmp(querin, "replace")) {
scanf("%s", repin);
for (int j = a; j <= b; j++) {
strin[j] = repin[j - a];
}
}
else if (!strcmp(querin, "print")) {
for (int j = a; j <= b; j++) {
printf("%c", strin[j]);
}
cout << '\n';
}
else if (!strcmp(querin, "reverse")) {
for (int j = a; j <= b; j++) {
revin[j - a] = strin[j];
}
for (int j = b; j >= a; j--) {
strin[a + b - j] = revin[j - a];
}
}
}
return 0;
}
| 1 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int wh, bk; cin >> wh >> bk;
int h = 100 / 2, w = 100;
cout << h * 2 << " " << w << endl;
auto func = [&](char c0, char c1, int cnt) {
vector<string> s(h, string(w, c0));
for (int i = 1; i < h - 1; i += 2) for (int j = 0; j < w; j += 2) {
if (cnt) s[i][j] = c1, cnt--;
}
for (auto &si: s) cout << si << endl;
};
func('.', '#', bk - 1);
func('#', '.', wh - 1);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define FASTINOUT ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
int main()
{
FASTINOUT;
ll a,b,k;
cin>>a>>b>>k;
bool t=1;
while (k--)
{
if (t)
{
if (a&1)
a--;
b=b+a/2;
a/=2;
t=0;
}
else
{
if (b&1)
b--;
a=a+b/2;
b/=2;
t=1;
}
}
cout<<a<<" "<<b<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N, Q;
cin >> N >> Q;
vector<vector<int>> vec(N,vector<int>(3));
for(int i=0; i<N; i++){
for(int j=0; j<3; j++){
cin >> vec.at(i).at(j);
}
}
vector<int> query(Q+2,-1e9);
for(int i=1; i<=Q; i++){
cin >> query.at(i);
}
query.at(Q+1) = 1e9+10;
vector<vector<int>> in(Q+2,vector<int>(0));
vector<vector<int>> out(Q+2,vector<int>(0));
vector<int>::iterator pos;
int idx;
for(int i=0; i<N; i++){
int s = vec.at(i).at(0);
int e = vec.at(i).at(1);
int p = vec.at(i).at(2);
pos = lower_bound(query.begin(),query.end(),s-p);
idx = distance(query.begin(),pos);
in.at(idx).push_back(p);
pos = lower_bound(query.begin(),query.end(),e-p);
idx = distance(query.begin(),pos);
out.at(idx).push_back(p);
}
map<int,int> mp;
mp[1e9+10] = 1;
for(int i=0; i<Q+1; i++){
for(int j=0; j<in.at(i).size(); j++){
if(mp.count(in.at(i).at(j))){
mp[in.at(i).at(j)]++;
}
else{
mp[in.at(i).at(j)] = 1;
}
}
for(int j=0; j<out.at(i).size(); j++){
mp[out.at(i).at(j)]--;
if(mp[out.at(i).at(j)] == 0){
mp.erase(out.at(i).at(j));
}
}
if(i != 0){
int x = mp.begin()->first;
if(x == 1e9+10){
cout << -1 << endl;
}
else{
cout << x << endl;
}
}
}
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
inline int Calcu(int a,int b){
return min(a, b);
}
class SegTree{
public:
int n;
int g;
std::vector<int> data;
SegTree(std::vector<int> a, int _g){
g = _g;
for (n = 1; n < (int) a.size(); n *= 2);
data.resize(n * 2, g);
//for (int i = 0; i < (int) a.size(); i++) data[i + n] = a[i];
//for (int i = n - 1; i >= 1; i--)
// data[i] = min(data[i], Calcu(data[i * 2], data[i * 2 + 1]));
}
int rec(int l, int r, int node, int node_l, int node_r, int val) {
if (node_r <= l || node_l >= r) return g;
if (node_l >= l && node_r <= r) return data[node] = min(data[node], val);
int mid = (node_l + node_r) / 2;
return Calcu(
rec(l, r, node * 2, node_l, mid, val),
rec(l, r, node * 2 + 1, mid, node_r,val));
}
void query(int l,int r, int val){
rec(l,r,1,0,n,val);
}
int get(int index){
int res = data[index += n];
for(;index /= 2;)
res = min(res, data[index]);
return res;
}
};
int main()
{
int n, q; cin >> n >> q;
vector<tuple<int,int,int>> p(n);
vector<int> c(q);
for(int i = 0; i < n; i++) {
int a, b, c; cin >> a >> b >> c;
a -= c;
b -= c;
p[i] = tie(a, b, c);
}
for(int i = 0; i < q; i++)cin >> c[i];
map<int,int> mp;
for(int i = 0; i < n; i++)mp[get<0>(p[i])] = -1, mp[get<1>(p[i])] = -1;
for(int i = 0; i < q; i++)mp[c[i]] = -1;
int za = 0;
for(auto &i : mp)i.second = za++;
for(int i = 0; i < n; i++)get<0>(p[i]) = mp[get<0>(p[i])], get<1>(p[i]) = mp[get<1>(p[i])];
for(int i = 0; i < q; i++)c[i] = mp[c[i]];
const int INF = 2e9;
SegTree tree(vector<int>(za), INF);
for(int i = 0; i < n; i++) {
int a, b, c; tie(a, b, c) = p[i];
tree.query(a, b, c);
}
for(int i = 0; i < q; i++) {
cout << (tree.get(c[i]) == INF ? -1 : tree.get(c[i])) << endl;
}
} | 1 |
#include <iostream>
#include <string>
int func(int x)
{
return x * x;
}
int main(void)
{
const int max_x = 600;
int d = 0;
while (std::cin >> d) {
int loop = max_x / d;
int sum = 0;
for (int i = 0; i < loop; i++) {
sum += d * func(d * i);
}
std::cout << sum << std::endl;
}
return 0;
} | #include<stdio.h>
int main()
{
int h1,h2,m1,m2,k;
scanf("%d%d%d%d%d",&h1,&m1,&h2,&m2,&k);
m1+=60*h1;
m2+=60*h2;
printf("%d\n",m2-m1-k);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
class MP
{
public:
vector<long long> pattern;
long long plen;
vector<long long> table;
MP(const vector<long long>& s) : pattern(s), plen((long long)pattern.size()), table(plen + 1){
table[0] = -1;
long long j = -1;
for(long long i = 0; i < plen; ++i){
while(j >= 0 && pattern[i] != pattern[j]){
j = table[j];
}
table[i+1] = ++j;
}
}
void search(const vector<long long>& text, vector<long long>& res){
long long head = 0, j = 0, tlen = (long long)text.size();
while(head + j < tlen){
if(pattern[j] == text[head + j]) {
if(++j == plen){
res.push_back(head);
head = head + j - table[j];
j = table[j];
}
}else{
head = head + j - table[j];
if(j) j = table[j];
}
}
}
void minimum_cycle(vector<long long>& res){
res.resize((long long)pattern.size());
for(long long i = 0; i < (long long)pattern.size(); ++i){
res[i] = i + 1 - table[i+1];
}
}
};
int main(){
//input
long long N;
cin >> N;
long long a[N], b[N];
long long i;
for(i=0; i<N; i++){
cin >> a[i];
}
for(i=0; i<N; i++){
cin >> b[i];
}
//exceptional
if(N==1){
cout << 0 << " " << (a[0]^b[0]) << endl;
system("pause");
return 0;
}
//calc
vector<long long> AA,BB;
for(i=0; i<N-1; i++){
AA.push_back(a[i]^a[i+1]);
}
AA.push_back(a[N-1]^a[0]);
for(i=0; i<N-1; i++){
AA.push_back(a[i]^a[i+1]);
}
AA.push_back(a[N-1]^a[0]);
for(i=0; i<N-1; i++){
BB.push_back(b[i]^b[i+1]);
}
MP BBBB(BB);
vector<long long> adj;
BBBB.search(AA,adj);
for(i=0; i<adj.size(); i++){
if(adj[i]>=N) break;
cout << adj[i] << " " << (a[adj[i]]^b[0]) << endl;
}
system("pause");
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define all(a) a.begin(),a.end()
#define F first
#define S second
#define pb push_back
#define ll long long
#define vi vector<int>
#define pi pair<int,int>
#define mp make_pair
#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) 42
#endif
const int mod=1e9+7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int mul(int a,int b)
{
return ((a)*1ll*(b))%mod;
}
void add(int &a,int b)
{
a+=b;
if(a>=mod)a-=mod;
}
int sub(int a,int b){
a-=b;
if(a<0){
a+=mod;
}
return a;
}
int powz(int a,int b){
int res=1;
while(b){
if(b&1){
res=mul(res,a);
}
b/=2;
a=mul(a,a);
}
return res;
}
template <typename A, typename B>
istream& operator>>(istream& input,pair<A,B>& x) {
input>>x.F>>x.S;
return input;
}
template <typename A>
istream& operator>>(istream& input,vector<A>& x) {
for(auto& i:x)
input>>i;
return input;
}
template<typename A>
ostream& operator<<(ostream& output,vector<A>& x) {
for(auto& i:x)
output<<i<<' ';
return output;
}
const int N=1000002;
int dp[51][51];
void solve(){
int n;
cin>>n;
ll ans=0;
for(int i=0;i<n;i++){
double x;
cin>>x;
long long val=(x+1e-12)*1e9;
ll tw=0,fv=0;
if(val==0){
ans+=n;
continue;
}
while(val%2==0){
tw++;
val/=2;
}
while(val%5==0){
fv++;
val/=5;
}
for(int j=0;j<=50;j++){
if(tw+j<18){
continue;
}
for(int k=0;k<=50;k++){
if(fv+k>=18){
ans+=dp[j][k];
}
}
}
dp[tw][fv]++;
}
cout<<ans;
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
int tc=1;
// cin>>tc;
for(int _=0;_<tc;_++){
// cout<<"Case #"<<_+1<<": ";
solve();
if(_!=tc-1)
cout<<"\n";
}
} | 0 |
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define rSort(v) sort(v.rbegin(), v.rend())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
/* Macros reg. ends here */
const ll INF = 1LL << 50;
struct UnionFind {
vector<ll> par, sizes;
ll cnt;
UnionFind(ll N) : par(N), sizes(N, 1), cnt(N) {
for (ll i = 0; i < N; i++) par[i] = i;
}
ll find(ll x) { return par[x] == x ? x : par[x] = find(par[x]); }
bool same(ll x, ll y) { return find(x) == find(y); }
ll size(ll x) { return sizes[find(x)]; }
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y) return;
if (sizes[x] < sizes[y]) swap(x, y);
par[y] = x;
sizes[x] += sizes[y];
cnt--;
}
ll count() const { return cnt; }
};
int main() {
// ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
ll n, t;
cin >> n >> t;
vll as(n), bs(n);
rep(i, n) cin >> as[i] >> bs[i];
vvll dp1(n + 1, vll(t, 0));
vvll dp2(n + 2, vll(t, 0));
rep(i, n) {
rep(j, t - 1) {
dp1.at(i + 1).at(j + 1) = dp1.at(i + 1).at(j);
chmax(dp1.at(i + 1).at(j + 1), dp1.at(i).at(j + 1));
if (j + 1 - as[i] >= 0)
chmax(dp1.at(i + 1).at(j + 1), bs[i] + dp1.at(i).at(j + 1 - as[i]));
}
}
rep(i, n) {
rep(j, t - 1) {
dp2.at(i + 1).at(j + 1) = dp2.at(i + 1).at(j);
chmax(dp2.at(i + 1).at(j + 1), dp2.at(i).at(j + 1));
if (j + 1 - as[n - 1 - i] >= 0)
chmax(dp2.at(i + 1).at(j + 1),
bs[n - 1 - i] + dp2.at(i).at(j + 1 - as[n - 1 - i]));
}
}
ll juee = 0;
rep(i, n) {
rep(j, t){
ll tmp = dp1[i][j] + bs[i] + dp2[n - 1 - i][t - 1 - j];
chmax(juee, tmp);
}
}
cout << juee << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using P = pair<ll, ll>;
template<typename T> using pq = priority_queue<T>;
template<typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template<typename T, typename K> using ump = unordered_map<T, K>;
const ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll mod = 1000000007;
const ll inf = ll(1e9);
const ll e5 = ll(1e5);
const ll ll_inf = ll(1e9) * ll(1e9);
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repr(i, n) for (ll i = ll(n - 1); i >= 0; i--)
#define each(i, mp) for (auto &i : mp)
#define eb emplace_back
#define F first
#define S second
#define all(obj) (obj).begin(), (obj).end()
template<class T>
ostream &operator<<(ostream &out, const vector<T> &list) {
ll n = list.size();
rep(i, n) out << list[i] << ' ';
return out;
}
template<class T>
istream &operator>>(istream &in, vector<T> &list) {
ll n = list.size();
rep(i, n) in >> list[i];
return in;
}
template<class T>
ostream &operator<<(ostream &out, const vector<vector<T>> &list) {
ll n = list.size();
rep(i, n) out << list[i] << '\n';
return out;
}
/* ------------- ANSWER ------------- */
/* ---------------------------------- */
void solve() {
ll n, t;
cin >> n >> t;
vector<P> ab(n);
rep(i, n) cin >> ab[i].first >> ab[i].second;
vector<vector<ll>> dp(n + 1, vector<ll>(t + (*max_element(all(ab))).first + 1));
ll ans = 0;
sort(all(ab));
rep(i, n) {
rep(j, t) {
ll nxt = j + ab[i].first;
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j]);
dp[i + 1][nxt] = max(dp[i + 1][nxt], dp[i][j] + ab[i].second);
ans = max(ans, dp[i + 1][nxt]);
}
}
cout << ans << '\n';
}
int main() {
#ifdef MY_DEBUG
while (true) {
#endif
solve();
#ifdef MY_DEBUG
}
#endif
return 0;
} | 1 |
#include<bits/stdc++.h>
#define prDouble(x) cout<<fixed<<setprecision(10)<<x
using namespace std;
int n;
double dp[301][301][301];
double solve(int x, int y, int z){
if(x<0 || y<0 || z<0)
return 0.0;
if(x==0&&y==0&&z==0)
return 0.0;
if(dp[x][y][z] > -0.9)
return dp[x][y][z];
double exp = n + x*solve(x-1,y,z) + y*solve(x+1,y-1,z) + z*solve(x,y+1,z-1);
return dp[x][y][z] = exp/(x+y+z);
}
int main(){
cin>>n;
int x,y,z;
x = y = z = 0;
memset(dp, -1, sizeof(dp));
for(int i=0;i<n;i++){
int t;
cin>>t;
if(t==1)
x++;
else if(t==2)
y++;
else
z++;
}
//cout<<solve(x,y,z)<<endl;
cout<<fixed<<setprecision(10)<<solve(x,y,z)<<endl;
return 0;
} | #include <iostream>
#include <math.h>
#include <stdio.h>
#define MAX 100001
int A[MAX];
int n;
int partition(int r) {
int judge_n = A[r];
int i = -1;
int j = 0;
for (j = 0; j < n; j++) {
if (A[j] <= judge_n) {
i++;
std::swap(A[i], A[j]);
}
}
return i;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
// ????????????????????????????????¨??????
int index = partition(n-1);
for (int i = 0; i < n; i++) {
if (i) printf(" ");
if (i == index) printf("[%d]", A[i]);
else printf("%d", A[i]);
}
printf("\n");
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <iomanip>
#include <bitset>
#include <set>
#include <map>
#include <stdio.h>
#include <numeric>
#include <cstring>
#define rep(i,n) for (int i = 0; i < (n); i++)
#define rep1(i,n) for (int i = 1; i < (n); i++)
#define FOR(i,a,b) for (int i=(a); i < (b); i++)
#define MOD 1000000007 //10^9+7
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;
const int INF = numeric_limits<int>::max();
const ll INFL = numeric_limits<ll>::max();
// 負の数にも対応した % 演算
long long mod(long long val, long long m) {
long long res = val % m;
if (res < 0) res += m;
return res;
}
//greatest common divisor
long long gcd(ll a, ll b)
{
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
//least common multiple
long long lcm(ll a, ll b)
{
return a / gcd(a, b) * b ;
}
ll factorial(ll n) {
ll res = 1;
for (ll i = 1; i <= n; i++) {
res *= i;
}
return res;
}
int main()
{
int n; cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
const int MAX = 100001;
vector<int> odd_hist(MAX, 0), even_hist(MAX, 0);
rep(i,n) {
if (i & 1) odd_hist[a[i]]++;
else even_hist[a[i]]++;
}
vector<PII> odd, even;
rep(i,MAX) {
odd.push_back(PII(odd_hist[i], i));
even.push_back(PII(even_hist[i], i));
}
sort(odd.begin(), odd.end(), greater<PII>());
sort(even.begin(), even.end(), greater<PII>());
if (odd[0].second != even[0].second) {
cout << n - (odd[0].first + even[0].first) << endl;
}
else {
cout << n - max(odd[0].first + even[1].first,
odd[1].first + even[0].first) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i, n) for(int i = 0; i < n; i++)
#define REP(i, a, b) for(int i = a; i <= b; i++)
#define all(x) x.begin(), x.end()
#define fi first
#define se second
#define debug(...) cerr<<__LINE__<<" ["<<#__VA_ARGS__<<"]:",debug_out(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec)
{ for (auto v : vec) os << v << ' '; os << '\n'; return os; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa)
{ os << '(' << pa.first << ',' << pa.second << ')'; return os; }
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T)
{ cerr << " " << H; debug_out(T...); }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF = (1<<30) - 1;
const ll LINF = (1LL<<60) - 1;
void solve() {
int n;
cin >> n;
queue<int> A[n];
rep(i, n) {
rep(_, n - 1) {
int a;
cin >> a;
A[i].push(a-1);
}
}
int ans = 0;
while(1) {
bool flag = 1, end = 1;
vector<int> op(n, -1);
rep(i, n) {
if (A[i].empty()) {
continue;
} else {
end = 0;
}
op[i] = A[i].front();
if (op[A[i].front()] == i) {
A[op[i]].pop();
A[i].pop();
flag = 0;
}
}
if (end) break;
if (flag) {
cout << -1 << endl;
return;
}
ans++;
}
cout << ans << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| 0 |
#include <iostream>
using namespace std;
void bubble_sort(int N, float* A){
int nchange = 0;
bool cont = true;
for(int i=0; cont; i++){
cont = false;
//未ソート部分列のスワップが発生しない場合停止
for(int j=N-1; j>i; j--){
if(A[j-1] > A[j]){
swap(A[j-1], A[j]);
cont = true;
nchange++;
}
}
}
for(int i=0; i<N; i++){
if(i==N-1){
cout << A[i] << endl;
}else{
cout << A[i] << " ";
}
}
cout << nchange << endl;
}
int main(){
int N;
cin >> N;
float A[N];
for(int i=0; i<N; i++) cin >> A[i];
bubble_sort(N, A);
return 0;
}
| #include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <set>
#include <list>
#include <unordered_map>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
#include <utility>
using namespace std;
namespace patch
{
template <typename T>
string to_string(const T& n)
{
ostringstream stm;
stm << n;
return stm.str();
}
int stoi(string str)
{
int ret;
istringstream stm(str);
stm >> ret;
if (stm.fail())
{
throw -1;
}
return ret;
}
vector<string> split(const string &str)
{
istringstream stm(str);
vector<string> ret;
copy(istream_iterator<string>(stm),
istream_iterator<string>(),
back_inserter(ret));
return ret;
}
vector<string> split(const string &str, char delim)
{
istringstream stm(str);
vector<string> ret;
string buf;
while (getline(stm, buf, delim))
{
ret.push_back(buf);
}
return ret;
}
}
int bubbleSort(vector<int>& vs)
{
int end = vs.size();
if (end == 1)
{
return 0;
}
int cnt = 0;
for (int j = 0; j < end - 1; ++j)
{
for (int i = 0; i < end - j - 1; ++i)
{
if (vs[i] > vs[i+1])
{
swap(vs[i], vs[i+1]);
++cnt;
}
}
}
return cnt;
}
// bubble sort
int main()
{
ios::sync_with_stdio(false);
// line 1
string s1;
getline(cin, s1);
int n = patch::stoi(s1);
// line 2
vector<int> vs(n);
vector<string> ss;
string s2;
getline(cin, s2);
ss = patch::split(s2);
for (int n = 0, sz = ss.size(); n < sz; ++n)
{
vs[n] = patch::stoi(ss[n]);
}
int cnt = bubbleSort(vs);
bool isFirst = true;
for (int n : vs)
{
//cout << n << " ";
if (isFirst)
{
cout << n;
isFirst = false;
}
else
{
cout << " " << n;
}
}
cout << "\n";
cout << cnt << "\n";
return 0;
} | 1 |
#include<iostream>
#include<cstdio>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
if (i % 3 == 0) {
cout << " " << i;
continue;
}
for (int x = i; x > 0; x /= 10) {
if (x % 10 == 3) {
cout << " " << i;
break;
}
}
}
cout << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
int main()
{
ll n;
cin >> n;
vector<ll> a(n);
unordered_map<ll, ll> mp;
rep(i, n){
cin >> a[i];
if (mp.find(a[i]) != mp.end()){
mp[a[i]] += 1;
}else{
mp[a[i]] = 1;
}
}
ll ans=0;
for(auto x: mp){
if (x.second % 2 == 1){
ans++;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cmath>
#include<vector>
#include<set>
#include<map>
#include<algorithm>
#include<unordered_map>
#include<bits/stdc++.h>
#define ll long long
#define d double
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s,t;
cin>>s>>t;
cout<<t+s<<endl;
return 0;
} | #include <bits/stdc++.h>
const int INF =1e9;
const int MOD =1e9+7;
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define REPD(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < int(b); i++)
#define FORD(i, a, b) for (int i = b - 1; i >= int(a); i--)
#define WRAP(y, x, h, w) (0 <= y && y < h && 0 <= x && x < w)
#define ALL(x) (x).begin(), (x).end()
int dx[4] ={ 1, 0, -1, 0 };
int dy[4] ={ 0, 1, 0, -1 };
int main()
{
int n,r;
cin>>n>>r;
cout<<r+(10-min(10,n))*100<<endl;
} | 0 |
#include <bits/stdc++.h>
#define MOD 998244353
using namespace std ;
int n , m , k ;
int jc[ 200005 ] ;
int ans = 0 ;
inline int qpow ( int a , int b ) {
int res = 1 ;
while ( b ) {
if ( b & 1 ) res = 1LL * res * a % MOD ;
b >>= 1 ;
a = 1LL * a * a % MOD ;
}
return res % MOD ;
}
inline void init () {
jc[ 0 ] = 1 ;
for ( int i = 1 ; i <= n ; i ++ ) jc[ i ] = 1LL * jc[ i - 1 ] * i % MOD ;
}
inline int inv ( int a ) { return qpow ( a , MOD - 2 ) ; }
inline int C ( int n , int m ) { return 1LL * jc[ n ] * inv ( 1LL * jc[ m ] * jc[ n - m ] % MOD ) % MOD ; }
signed main () {
scanf ( "%d%d%d" , &n , &m , &k ) ;
init () ;
for ( int i = 0 ; i <= k ; i ++ ) {
ans = ( ans + 1LL * m * C ( n - 1 , i ) % MOD * qpow ( m - 1 , n - i - 1 ) % MOD ) % MOD ;
}
printf ( "%d\n" , ans % MOD ) ;
return 0 ;
}
/*
题目简述：
给 n 个方格染 m 种颜色，要求最多有 k 组块相连且颜色相同，求方案数对 998244353 取模的结果。
*/
| #include<stdio.h>
#include<math.h>
int main(){
double x1,x2,y1,y2,ans;
scanf("%lf %lf %lf %lf",&x1,&y1,&x2,&y2);
ans=(x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
printf("%lf\n",sqrt(ans));
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
int main(void){
// Your code here!
long long int N,H,W,i,j,k,ans,count,cost,tmp;
long long int S[200010];
long long int Ssum[200010];
string T;
bool flag;
count=0;
ans=std::pow(10,18);
flag=false;
cin >>N>>H;
for (i=H-(N-1);i<=H+(N-1);i++){
if (i==H+(N-1)){
cout <<i <<endl;
}
else{
cout <<i << " ";
}
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int k,x,st,i;
cin>>k>>x;
x-=--k;
k=2*k+1;
while(k--)
cout<<x++<<" ";
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(var) cerr << (#var) << " = " << (var) << endl;
#else
#define debug(var)
#endif
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
}
const int N = 1e5+23;
int a[N];
void solve() {
int n, m; scanf("%d%d", &n, &m);
map<int, int> h;
long long ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", a+i);
if (i) a[i] += a[i-1];
a[i] %= m;
++h[a[i]];
}
for (const auto &e: h) {
if (e.first == 0) continue;
ans += 1LL*e.second*(e.second-1)/2;
}
ans += 1LL*h[0]*(h[0]+1)/2;
printf("%lld", ans);
}
int main() {
int t = 1; //scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9+7;
// const ll MOD = 998244353;
const ll INF = 1ll<<60;
#define FOR(i,a,b) for (ll i=(a);i<(ll)(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
ll N, M;
ll A[100010];
int main(int argc, char **argv)
{
cin >> N >> M;
REP(i, N) cin >> A[i];
A[0] %= M;
REP(i, N-1)
(A[i+1] += A[i]) %= M;
map<ll, ll> m;
REP(i, N)
++m[A[i]];
ll res{0};
for (auto &p : m)
{
if (p.first == 0)
res += p.second;
res += p.second * (p.second-1) / 2;
}
std::cout << res << std::endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define long long ll
#define f(i,n) for(int i=0;i<n;i++)
const int maxn=305;
double dp[maxn][maxn][maxn];
double recur(int k, int b, int c,int n){
if(dp[k][b][c]>=0)return dp[k][b][c];
if(k==0&&b==0&&c==0)return 0.0;
double res=0.0;
// dp[k][b][c]=0.0;
if(k>0)res+=(k)*recur(k-1,b,c,n);
if(b>0)res+=(b)*recur(k+1,b-1,c,n);
if(c>0)res+=(c)*recur(k,b+1,c-1,n);
// dp[k][b][c]/=(n-k-c-b);
res+=n;
res*=1.0/(k+b+c);
return dp[k][b][c]=res;
}
int main() {
cout<<fixed<<setprecision(10);
int n;
cin>>n;
vector<int>a(4,0);
f(i,n){int x;
cin>>x;
a[x]++;
}
memset(dp, -1, sizeof(dp));
cout<<fixed<<setprecision(9)<<recur(a[1],a[2],a[3],n)<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
double dp[305][305][305];
int main(){
int n, a;
cin >> n;
vector<int> sushi(3);
for(int i=0; i<n; ++i){
cin >> a;
++sushi[a-1];
}
int sum1 = sushi[2];
int sum2 = sushi[1] + sushi[2];
int sum3 = sushi[0] + sushi[1] + sushi[2];
for(int k=0; k <= sum1; ++k) for(int j=0; j+k <= sum2; ++j) for(int i=0; i+j+k <=sum3; ++i){
if(i>0) dp[i][j][k] += (dp[i-1][j][k] +(double)n/(i+j+k)) *i /(i+j+k);
if(j>0) dp[i][j][k] += (dp[i+1][j-1][k] +(double)n/(i+j+k)) *j /(i+j+k);
if(k>0) dp[i][j][k] += (dp[i][j+1][k-1] +(double)n/(i+j+k)) *k /(i+j+k);
}
printf("%.15f\n",dp[sushi[0]][sushi[1]][sushi[2]]);
} | 1 |
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int main() {
int n, u, v;
cin >> n >> u >> v;
vector<int> graph[n];
for (int a, b; cin >> a >> b; ) {
graph[a - 1].emplace_back(b - 1);
graph[b - 1].emplace_back(a - 1);
}
int takahashi[n], aoki[n], parent[n], result = 0;
auto bfs = [&](int start, int* distance) {
queue<int> q;
q.emplace(start);
distance[start] = 0;
vector<bool> visited(n);
visited[start] = true;
parent[start] = start;
do {
for (auto next : graph[q.front()]) {
if (!visited[next]) {
parent[next] = q.front();
distance[next] = distance[q.front()] + 1;
visited[next] = true;
q.emplace(next);
}
}
q.pop();
} while (!q.empty());
};
bfs(u - 1, takahashi);
bfs(v - 1, aoki);
if (aoki[u - 1] != 1) {
for (int i = 0; i < n; ++i) {
if (takahashi[i] <= aoki[i]) {
result = max(result, aoki[parent[parent[i]]] + 1);
}
}
}
cout << result;
return 0;
}
| #include<bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define all(v) (v).begin(),(v).end()
using namespace std;
using ll=long long;
using pii=pair<int, int>;
using vi=vector<int>;
const ll INF=1LL<<60;
const int MOD=998244353;
const int N=2e5+5;
int main(){
int N, u, v; cin >> N >> u >> v;
u--, v--;
vector<vi> G(N);
for(int i=0; i<N-1; i++){
int A, B; cin >> A >> B;
A--, B--;
G[A].push_back(B);
G[B].push_back(A);
}
vector<vi> dist(2, vi(N, -1));
for(int i=0; i<2; i++){
queue<int> que;
que.push(v+(u-v)*i);
dist[i][v+(u-v)*i]=0;
while(!que.empty()){
int p=que.front();
que.pop();
for(auto &np : G[p]){
if(dist[i][np] != -1) continue;
dist[i][np]=dist[i][p]+1;
que.push(np);
}
}
}
int res=0;
for(int i=0; i<N; i++){
if(dist[0][i] > dist[1][i]) res=max(res, dist[0][i]);
}
res--;
cout << res << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
string s ;
cin >> s ;
int n ;
cin >> n ;
double t=s.size();
string a ;
for(int i=0 ; i<(t/n) ; i++ ){
a+=s.at(0+i*n);
}
cout << a << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
typedef long long ll;
int main(){
string s; int w; cin>>s>>w;
int k=s.size();
rep(i,k){
if(i%w==0) cout<<s[i];
}
cout<<endl;
} | 1 |
#include <bits/stdc++.h>
#define pb push_back
#define int long long
#define mp make_pair
#define inf 1000000007
#define ll long long
using namespace std;
ll dp[210][100009];
int ka[214514],inv[214514];
void setkaijo(int n){
ka[0]=1;
for(int i=1;i<=n;i++){
ka[i] = ka[i-1] * i;
ka[i] %= inf;
}
}
int modpow(int x,int k){
// x ^ k mod inf
int p2[55],res=1;
p2[0]=1;p2[1]=x%inf;
for(int i=2;i<=50;i++){
p2[i]=p2[i-1]*p2[i-1];
p2[i] %= inf;
}
for(int i=1;i<=50;i++){
if(k%2==1){
res *= p2[i];
res %= inf;
}
k /= 2;
}
return res;
}
void setinv(int n){
for(int i=0;i<=n;i++){
inv[i] = modpow(ka[i],(ll)inf-2);
}
}
int comb(int n,int k){
if(k>n)return 0;
if(k==0 || k==n)return 1;
int res = (ka[n] * inv[k]) % inf;
res = (res*inv[n-k]) % inf;
return res;
}
signed main(){
ll n,x;
cin>>n>>x;
vector<ll> a;
map<ll,ll> mope;
setkaijo(100009);
setinv(100009);
for(int i=0;i<n;i++){
ll tx;
cin>>tx;
a.pb(tx);
mope[tx]++;
}
sort(a.begin(),a.end());
reverse(a.begin(),a.end());
vector< pair<ll,ll> > v;
for(int i=0;i<n;i++){
if( mope[ a[i] ] != 0){
v.pb( mp( a[i], mope[a[i]]) );
mope[a[i]] = 0;
}
}
dp[0][x] = 1;
ll rem = n;
for(int i=0;i<v.size();i++){
ll md = v[i].first;
ll num = v[i].second;
ll cb = comb(rem-1,num-1);
ll cb2 = comb(rem-1,num);
for(int j=0;j<=100000;j++){
dp[i+1][j%md] += ( dp[i][j] * cb )%inf;
dp[i+1][j] += (dp[i][j] * cb2)%inf;
}
rem -= num;
}
ll ans = 0;
for(int i=0;i<=x;i++){
ans = (ans + i*dp[v.size()][i])%inf;
}
cout<<ans<<endl;
return 0;
} | #include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
const int N=205,M=1e5+5;
const int mod=1e9+7;
int dp[N][M],a[N],n,X;
int dfs(int u,int x) {
if(!u) return x%a[u];
if(dp[u][x]!=-1) return dp[u][x];
return dp[u][x]=(dfs(u-1,x%a[u])+1LL*u*dfs(u-1,x))%mod;
}
int main() {
scanf("%d%d",&n,&X);
for(int i=0;i<n;i++) scanf("%d",a+i);
std::sort(a,a+n);
memset(dp,-1,sizeof(dp));
printf("%d\n",dfs(n-1,X));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int,int>;
int MOD = 1e9+7;
//ll po(ll b, ll p){ return !p?1:po(b*b%MOD,p/2)*(p&1?b:1)%MOD;}
// ll pomd(ll a, ll k, ll md) { ll p; if (k == 0){ return 1; } p = pomd(a, k / 2, md); p = p * p % md; if (k % 2){ p = p * a % md; } return p; }
// counting divsrs: vi arr(N); for(int i{1}; i<N; ++i) for(int j=i; j<N; j+=i) d[j]++;
#define mp make_pair
#define pb push_back
#define rsz resize
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
void setIO(string name = ""){
freopen((name+".in").c_str(), "r", stdin);
freopen((name+".out").c_str(), "w", stdout);
}
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
// setIO();
ll n,x; cin >> n >> x;
if(n>=10){
cout << x << "\n";
}else{
cout << x+100*(10-n) << "\n";
}
}
| #include <bits/stdc++.h>
#include <string>
#include <vector>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int INF = 1e9;
int main(){
int n,m;
cin >> n >> m;
set<int> s;
for(int i = 2;i<=sqrt(m);i++){
if(m%i==0) {
s.insert(i);
s.insert(m/i);
}
}
s.insert(m);
int ans = 1;
for(auto it = s.begin();it!=s.end();it++){
if((*it)<=m/n) ans = *it;
else break;
}
cout << ans << endl;
//for(auto it=s.begin();it!=s.end();it++) cout << *it << endl;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
cout << min(N % K, 1) << endl;
return 0;
} | #include <stdio.h>
int main() {
int start = 1, n, t, x = 0;
scanf("%d", &n);
scanf("%d", &t);
for(int i = 0; i < (n-x); i++) {
while(start < t) {
if(x >= n) {
break;
}
start *= 2;
x++;
}
if(x >= n) {
break;
}
start += t;
}
printf("%d", start);
return 0;
} | 0 |
//Author:xht37
#include <bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double
#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair
#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)
#define vi vector <int>
#define pb push_back
#define pq priority_queue
#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)
using namespace std;
namespace io {
const int SI = 1 << 21 | 1;
char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
int f, t;
#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
inline void flush() {
fwrite(OB, 1, OS - OB, stdout), OS = OB;
}
inline void pc(char x) {
*OS++ = x;
if (OS == OT) flush();
}
template <class I>
inline void rd(I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
x *= f;
}
template <class I>
inline void rd(I &x, I &y) {
rd(x), rd(y);
}
template <class I>
inline void rd(I &x, I &y, I &z) {
rd(x), rd(y), rd(z);
}
template <class I>
inline void rda(I *a, int n) {
for (int i = 1; i <= n; i++) rd(a[i]);
}
inline void rdc(char &c) {
for (c = gc(); c < 33 || c > 126; c = gc());
}
inline void rds(char *s, int &n) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (n = 0; c >= 33 && c <= 126; s[++n] = c, c = gc());
s[n+1] = '\0';
}
inline void rds(string &s) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (s.clear(); c >= 33 && c <= 126; s.pb(c), c = gc());
}
template <class I>
inline void print(I x, char k = '\n') {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) ch[++t] = x % 10 + '0', x /= 10;
while (t) pc(ch[t--]);
pc(k);
}
template <class I>
inline void print(I x, I y) {
print(x, ' '), print(y);
}
template <class I>
inline void print(I x, I y, I z) {
print(x, ' '), print(y, ' '), print(z);
}
template <class I>
inline void printa(I *a, int n) {
for (int i = 1; i <= n; i++) print(a[i], " \n"[i==n]);
}
inline void printc(char c) {
pc(c);
}
inline void prints(char *s, int n) {
for (int i = 1; i <= n; i++) pc(s[i]);
pc('\n');
}
inline void prints(string s) {
int n = s.length();
while (t < n) pc(s[t++]);
pc('\n'), t = 0;
}
struct Flush {
~Flush() {
flush();
}
} flusher;
}
using io::rd;
using io::rda;
using io::rdc;
using io::rds;
using io::print;
using io::printa;
using io::printc;
using io::prints;
const int N = 1e5 + 7;
int n, m, v, p, a[N];
ll s[N];
int main() {
rd(n, m), rd(v, p), rda(a, n);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) s[i] = a[i] + s[i-1];
// for (int i = 1; i <= n; i++) debug("%d%c", a[i], " \n"[i==n]);
for (int i = 1; i <= n; i++) {
int c = n + 1 - (upper_bound(a + 1, a + n + 1, a[i] + m) - a);
if (c + 1 > p) continue;
int d = (upper_bound(a + 1, a + n + 1, a[i]) - a) - 2;
// debug("%d %d %d\n", i, c, d);
ll o = 1ll * m * (v - 1 - c - d) - (1ll * (a[i] + m) * (n - 1 - c - d) - (s[n-c] - s[d+1]));
// dbg(o);
if (o <= (s[n-c] - s[n-p+1]) - 1ll * (p - 1 - c) * a[i]) {
print(n - i + 1);
break;
}
}
return 0;
} | #include <iostream>
#include <complex>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <random>
#include <iomanip>
typedef long long int ll;
typedef long double ld;
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
const ll MOD=1000000007;
const ll MAX_N=500010;
const ll INF=999999999999;
ll num[110][8];
int main(){
int H,W,k;
ll ans;
cin>>H>>W>>k;
num[0][0]=1;
bool f=true;
for(int i=1;i<8;i++) num[0][i]=0;
for(int h=1;h<=H;h++){
for(int w=0;w<(1<<(W-1))-1;w++){
for(int i=0;i<W-1;i++){
if(w>>i & 1 && w>>(i+1) & 1) f=false;
}
if(f){
int v[]={0,1,2,3,4,5,6,7};
for(int i=0;i<W-1;i++){
if(w>>i & 1){
v[W-1-i]--;
v[W-1-i-1]++;
}
}
for(int i=0;i<8;i++){
num[h][i]+=num[h-1][v[i]];
num[h][i]%=MOD;
}
}
f=true;
}
}
if(W==1){
ans=1;
}else{
ans=num[H][k-1];
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long ll;
using Graph = vector<vector<int>>;
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 1000000007;
const int INF_32 = 1LL << 30;
const int64_t INF_64 = 1LL << 60;
int main()
{
string s;
cin >> s;
int size = s.size();
reverse(s.begin(), s.end());
s += '0';
int carry = 0;
int ans = 0;
for (int i = 0; i < size + 1; i++) {
int add = 0;
if (s.at(i) - '0' + carry <= 4) {
add = (s.at(i) - '0') + carry;
carry = 0;
} else if (s.at(i) - '0' + carry == 5) {
add = 5;
if (s.at(i + 1) - '0' >= 5) {
carry = 1;
} else {
carry = 0;
}
} else {
add = 10 - ((s.at(i) - '0') + carry);
carry = 1;
}
ans += add;
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
#ifdef LOCAL
#include<debug.h>
#else
#define db(...) 21
#endif
#define debug(x) cout << #x << " = " << x << endl;
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define FOR(it, b, e) for (typeof(b) it = (b); it != (e); ++it)
#define MSET(c, v) memset(c, v, sizeof(c))
const int INF = 0x3F3F3F3F;
const int NEGINF = 0xC0C0C0C0;
const int NULO = -1;
const double EPS = 1e-10;
const ll mod = 1e9 + 7;
inline int cmp(double x, double y = 0)
{
if(fabs(x - y) < EPS)
return 0;
return x > y ? 1 : -1;
}
ll exp(ll a, ll b)
{
ll ans = 1;
while(b)
{
if(b & 1)
ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
const int maxn = 2e6 + 10;
ll fat[maxn], inv[maxn];
ll C(int n, int k)
{
if(n < k)
return 0;
if(n < 0 || k < 0)
return 0;
return (((fat[n] * inv[k]) % mod) * inv[n - k]) % mod;
}
void initFactorials()
{
fat[0] = 1;
inv[0] = 1;
for(int i = 1; i < maxn; i++)
{
fat[i] = (fat[i-1] * i) % mod;
inv[i] = exp(fat[i], mod - 2);
}
}
ll dp[maxn][2];
string s;
ll solve(int pos, int carry)
{
if(pos == s.size())
return carry;
ll &ans = dp[pos][carry];
if(ans != -1)
return ans;
int val = s[pos] - '0' + carry;
ans = 1LL << 60;
ans = min(ans, solve(pos + 1, 1) + 10 - val);
ans = min(ans, solve(pos + 1, 0) + val);
return ans;
}
int main()
{
ios::sync_with_stdio(false);
MSET(dp, -1);
cin >> s;
reverse(s.begin(), s.end());
cout << solve(0,0) << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int M,ans=-1,g=0;
cin>>M;
vector<pair<int,int>> A(M);
for(pair<int,int> &p:A){
cin>>p.first>>p.second;
ans+=p.second;
g+=p.first*p.second;
}
cout<<ans+(g-1)/9<<endl;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define all(x) (x).begin(),(x).end()
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
using Graph = vector<vector<int>>;
double nCk(int n, int k) {
double res=1.0;
for(int i=0; i<n; i++){
res*=0.5;}
for(int i=0; i<k; i++){
res*=(double)(n-i);
res/=(double)(k-i);
}
return res;}
struct edge{ll to, cost;};
typedef pair<ll,ll> P;
struct graph{
ll V;
vector<vector<edge> > G;
vector<ll> d;
graph(ll n){
init(n);
}
void init(ll n){
V = n;
G.resize(V);
d.resize(V);
rep(i,V){
d[i] = INF;
}
}
void add_edge(ll s, ll t, ll cost){
edge e;
e.to = t, e.cost = cost;
G[s].push_back(e);
}
void dijkstra(ll s){
rep(i,V){
d[i] = INF/10;
}
d[s] = 0;
priority_queue<P,vector<P>, greater<P> > que;
que.push(P(0,s));
while(!que.empty()){
P p = que.top(); que.pop();
ll v = p.second;
if(d[v]<p.first) continue;
for(auto e : G[v]){
if(d[e.to]>d[v]+e.cost){
d[e.to] = d[v]+e.cost;
que.push(P(d[e.to],e.to));
}
}
}
}
};
int main() {
ll n; cin>>n;
ll k = 0;
ll wa = 0;
ll ans = 0;
rep(i,n){
ll a,b; cin>>a>>b;
wa += a*b;
k += b;
}
ll f;
while(wa>=10){
f = wa%10;
wa/=10;
k+=wa;
wa +=f;}
cout << k-1 << endl;}
| 1 |
#include<iostream>
using namespace std;
int a[13][32];
void day(void)
{
int check=3;
for(int i=1;i<13;i++){
for(int j=1;j<32;j++){
a[i][j]=check;
check++;
if(check==7)check=0;
if((i==4||i==6||i==9||i==11)&&j==30)break;
else if(i==2&&j==29)break;
}
}
}
int main()
{
int mon,date;
day();
while(1){
cin>>mon>>date;
if(mon==0&&date==0)break;
if(a[mon][date]==0)cout<<"Monday\n";
else if(a[mon][date]==1)cout<<"Tuesday\n";
else if(a[mon][date]==2)cout<<"Wednesday\n";
else if(a[mon][date]==3)cout<<"Thursday\n";
else if(a[mon][date]==4)cout<<"Friday\n";
else if(a[mon][date]==5)cout<<"Saturday\n";
else cout<<"Sunday\n";
}
} | #include <iostream>
#include <string>
using namespace std;
int main()
{
int month[]={0,31,29,31,30,31,30,31,31,30,31,30,31};
int m,day,sumday;
while(1){
cin >> m; // 月
if (m==0){ break;}
cin >> day; //日付
for(int i=0;i<m;i++){
day+=month[i];
}
switch(day%=7){
case 1:
cout<<"Thursday"<<endl;
break;
case 2:
cout<<"Friday"<<endl;
break;
case 3:
cout<<"Saturday"<<endl;
break;
case 4:
cout<<"Sunday"<<endl;
break;
case 5:
cout<<"Monday"<<endl;
break;
case 6:
cout<<"Tuesday"<<endl;
break;
default:
cout<<"Wednesday"<<endl;
break;
}
}
return 0;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.