code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 2
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,A;
cin >> N >> A;
if(N % 1000 > A){
cout << "No" << endl;
}
else{
cout << "Yes" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
if (x%500 <= y) {
cout << "Yes" << endl;
}
if (x%500 > y) {
cout << "No" << endl;
}
} | 1 | 52,679,228 |
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <utility>
#include <iomanip>
#include <tuple>
#include <numeric>
#include <cstdio>
#include <cmath>
using namespace std;
using ll = long long;
const int INF = 1e9;
int a, b, c;
int N, rtn = INF;
vector<int> l(8);
void dfs(int depth, vector<pair<int, int>>& abcd) {
if (depth == N) {
if (abcd[0].second == 0 || abcd[1].second == 0 || abcd[2].second == 0) return;
int irtn = abs(a - abcd[0].first) + abs(b - abcd[1].first) + abs(c - abcd[2].first);
for (int i = 0; i < 3; i++) {
if (abcd[i].second >= 2) irtn += (10 * (abcd[i].second - 1));
}
rtn = min(rtn, irtn);
return;
}
for (int i = 0; i < 4; i++) {
abcd[i].first += l[depth];
abcd[i].second++;
dfs(depth+1, abcd);
abcd[i].first -= l[depth];
abcd[i].second--;
}
}
int main() {
cin >> N >> a >> b >> c;
vector<pair<int, int>> abcd(4);
for (int i = 0; i < N; i++) cin >> l[i];
dfs(0, abcd);
cout << rtn << endl;
} | #include<iostream>
#include<algorithm>
#include<cmath>
#include<map>
#include<stdio.h>
#include<vector>
#include<queue>
#include<math.h>
using namespace std;
#define int long long
#define double long double
#define rep(s,i,n) for(int i=s;i<n;i++)
#define c(n) cout<<n<<endl;
#define ic(n) int n;cin>>n;
#define sc(s) string s;cin>>s;
#define mod 1000000007
#define inf 1000000000000000007
#define f first
#define s second
#define mini(c,a,b) *min_element(c+a,c+b)
#define maxi(c,a,b) *max_element(c+a,c+b)
#define pi 3.141592653589793238462643383279
#define e_ 2.718281828459045235360287471352
#define P pair<int,int>
#define upp(a,n,x) upper_bound(a,a+n,x)-a;
#define low(a,n,x) lower_bound(a,a+n,x)-a;
#define UF UnionFind
int keta(int x){
rep(0,i,30){
if(x<10){
return i+1;
}
x=x/10;
}
}
int gcd(int x,int y){
if(x==0||y==0)return x+y;
int aa=x,bb=y;
rep(0,i,1000){
aa=aa%bb;
if(aa==0){
return bb;
}
bb=bb%aa;
if(bb==0){
return aa;
}
}
}
int lcm(int x,int y){
int aa=x,bb=y;
rep(0,i,1000){
aa=aa%bb;
if(aa==0){
return x/bb*y;
}
bb=bb%aa;
if(bb==0){
return x/aa*y;
}
}
}
bool p(int x){
if(x==1)return false;
rep(2,i,sqrt(x)+1){
if(x%i==0&&x!=i){
return false;
}
}
return true;
}
int max(int a,int b){
if(a>=b)return a;
else return b;
}
string maxst(string s,string t){
int n=s.size();
int m=t.size();
if(n>m)return s;
else if(n<m)return t;
else{
rep(0,i,n){
if(s[i]>t[i])return s;
if(s[i]<t[i])return t;
}
return s;
}
}
int min(int a,int b){
if(a>=b)return b;
else return a;
}
int n2[41];
int nis[41];
int nia[41];
int mody[41];
int nn;
int com(int n,int y){
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
int bunsi=1,bunbo=1;
rep(0,i,y)bunsi=(bunsi*(n-i))%mod;
rep(0,i,y)bunbo=(bunbo*(i+1))%mod;
mody[0]=bunbo;
rep(1,i,41){
bunbo=(bunbo*bunbo)%mod;
mody[i]=bunbo;
}
rep(0,i,41)nis[i]=0;
nn=mod-2;
for(int i=40;i>=0;i-=1){
if(nn>n2[i]){
nis[i]++;
nn-=n2[i];
}
}
nis[0]++;
rep(0,i,41){
if(nis[i]==1){
bunsi=(bunsi*mody[i])%mod;
}
}
return bunsi;
}
int gyakugen(int n,int y){
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
mody[0]=y;
rep(1,i,41){
y=(y*y)%mod;
mody[i]=y;
}
rep(0,i,41)nis[i]=0;
nn=mod-2;
for(int i=40;i>=0;i-=1){
if(nn>n2[i]){
nis[i]++;
nn-=n2[i];
}
}
nis[0]++;
rep(0,i,41){
if(nis[i]==1){
n=(n*mody[i])%mod;
}
}
return n;
}
int yakuwa(int n){
int sum=0;
rep(1,i,sqrt(n+1)){
if(n%i==0)sum+=i+n/i;
if(i*i==n)sum-=i;
}
return sum;
}
bool integer(double n){
if(n==long(n))return true;
else return false;
}
int poow(int y,int n){
if(n==0)return 1;
n-=1;
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
int yy=y;
mody[0]=yy;
rep(1,i,41){
yy=(yy*yy)%mod;
mody[i]=yy;
}
rep(0,i,41)nis[i]=0;
nn=n;
for(int i=40;i>=0;i-=1){
if(nn>=n2[i]){
nis[i]++;
nn-=n2[i];
}
}
rep(0,i,41){
if(nis[i]==1){
y=(y*mody[i])%mod;
}
}
return y;
}
int minpow(int x,int y){
int sum=1;
rep(0,i,y)sum*=x;
return sum;
}
int ketawa(int x,int sinsuu){
int sum=0;
rep(0,i,100)sum+=(x%poow(sinsuu,i+1))/(poow(sinsuu,i));
return sum;
}
int sankaku(int a){
return a*(a+1)/2;
}
int sames(int a[1111111],int n){
int ans=0;
rep(0,i,n){
if(a[i]==a[i+1]){
int j=i;
while(a[j+1]==a[i]&&j<=n-2)j++;
ans+=sankaku(j-i);
i=j;
}
}
return ans;
}
bool search(int x){
int n;
int a[n];
int l=0,r=n;
while(r-l>=1){
int i=(l+r)/2;
if(a[i]==x)return true;
else if(a[i]<x)l=i+1;
else r=i;
}
return false;
}
int XOR(int a,int b){
int ni=1;
rep(0,i,41){
n2[i]=ni;
ni*=2;
}
rep(0,i,41)nis[i]=0;
for(int i=40;i>=0;i-=1){
if(a>=n2[i]){
nis[i]++;
a-=n2[i];
}
if(b>=n2[i]){
nis[i]++;
b-=n2[i];
}
}
int sum=0;
rep(0,i,41)sum+=(nis[i]%2*n2[i]);
return sum;
}
struct UnionFind {
vector<int> par;
vector<int> siz;
UnionFind(int N) :par(N),siz(N){
for(int i = 0; i < N; i++){
par[i] = i;
siz[i]=1;
}
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
if(siz[rx]>siz[ry]){
siz[rx]+=siz[ry];
par[y]=x;
}
else{
siz[ry]+=siz[rx];
par[x]=y;
}
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
int size(int x){
return siz[root(x)];
}
};
int d[11];
signed main(){
ic(n)
ic(a) ic(b) ic(c)
int ma[1024577][21];
for(int bit=0;bit<(1<<2*n);bit++)rep(0,i,2*n)if(bit&(1<<i))ma[bit][i]=1;
rep(0,i,n)cin>>d[i];
int ans=inf;
rep(0,i,minpow(4,n)){
int A=0,B=0,C=0;
int sum=0;
rep(0,j,n){
if(ma[i][j*2]==0&&ma[i][j*2+1]==1){
if(A>0)sum+=10;
A+=d[j];
}
else if(ma[i][j*2]==1&&ma[i][j*2+1]==0){
if(B>0)sum+=10;
B+=d[j];
}
else if(ma[i][j*2]==1&&ma[i][j*2+1]==1){
if(C>0)sum+=10;
C+=d[j];
}
}
if(A>0&&B>0&&C>0){
sum+=abs(A-a)+abs(B-b)+abs(C-c);
ans=min(sum,ans);
}
}
c(ans)
} | 1 | 9,932,231 |
#include<bits/stdc++.h>
using namespace std;
main(){
int N,K;
cin>>N>>K;
vector<int>a(N);
for(auto&x:a)cin>>x;
sort(a.begin(),a.end());
int ans=N,sum=0;
for(int i=a.size()-1;i>=0;--i)
if(sum+a[i]<K)
sum+=a[i];
else
ans=i;
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int len = 5005;
int arr[len];
bool pref[len][len], suf[len][len];
int main(){
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++)
scanf("%d", &arr[i]);
pref[0][0] = suf[n+1][0] = true;
for (int i = 1; i <= n; i++)
for (int j = k; j >= 0; j--)
if (pref[i-1][j] == true)
pref[i][j] = pref[i][min(k, j+arr[i])] = true;
for (int i = n; i >= 1; i--)
for (int j = k; j >= 0; j--)
if (suf[i+1][j] == true)
suf[i][j] = suf[i][min(k, j+arr[i])] = true;
int ans = 0;
for (int i = 1; i <= n; i++){
int un = 1;
for (int a = k-1, b = 0, mx = 0; a >= 0; a--){
if (pref[i-1][a] == false)
continue;
while (b < k-1-a){
b++;
if (suf[i+1][b])
mx = b;
}
if (mx+a+arr[i] >= k)
un = 0;
}
ans += un;
}
printf("%d\n", ans);
return 0;
} | 1 | 14,739,890 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define FOR(i, n, m) for(ll (i)=(m);(i)<(n);++(i))
#define REP(i, n) FOR(i,n,0)
#define OF64 std::setprecision(10)
const ll MOD = 1000000007;
const ll INF = (ll) 1e15;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll A, B, C;
cin >> A >> B >> C;
ll mx = std::max({A, B, C});
ll ans = 0;
while (A + 2 <= mx) {
ans++;
A += 2;
}
while (B + 2 <= mx) {
ans++;
B += 2;
}
while (C + 2 <= mx) {
ans++;
C += 2;
}
ll n = 0;
if (A != mx)
n++;
if (B != mx)
n++;
if (C != mx)
n++;
if (n == 1)
ans += 2;
if (n == 2)
ans++;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int X[3];
cin >> X[0] >> X[1] >> X[2];
int ans = 0;
while(1) {
sort(X, X+3);
if (X[0] == X[1] && X[1] == X[2]) break;
if (X[0] == X[1]) {
X[0]++;
X[1]++;
} else if (X[1] - X[0] == 1) {
X[0]++;
X[2]++;
} else {
X[0] += 2;
}
ans++;
}
cout << ans << endl;
return 0;
} | 1 | 3,677,472 |
#include<iostream>
using namespace std;
int main(){
int a,b;
double A,B;
cin>>a>>b;
cout<<a/b<<" "<<a%b<<" ";
A=a;
B=b;
cout<<fixed<<A/B<<endl;
return 0;
} | #include<iostream>
#include<string>
#include<cmath>
#include<queue>
#include<vector>
#include<functional>
#include<algorithm>
#include<cstdio>
using namespace std;
int main() {
int a, b, d, r;
long double f;
cin >> a >> b;
d = floor(a / b);
r = a%b;
f = (long double)a / b;
printf("%d %d %LF", d, r, f);
cin >> a;
} | 1 | 30,077,678 |
#include<bits/stdc++.h>
using namespace std;
#define Boost() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
typedef long long ll;
typedef long long int lli;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int,int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<int>::iterator vit;
typedef set<int>::iterator sit;
#define rep0(i,n) for(i=0;i<n;i++)
#define rep1(i,n) for(i=1;i<=n;i++)
#define sf scanf
#define pf printf
#define pb push_back
#define all(c) c.begin(),c.end()
#define MK make_pair
#define F first
#define S second
#define endl '\n'
#define mem(a,b) memset(a, b, sizeof(a) )
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*(b/gcd(a,b)))
#define sqr(a) ((a) * (a))
inline bool checkBit(ll n, int i)
{
return n&(1LL<<i);
}
inline ll setBit(ll n, int i)
{
return n|(1LL<<i);;
}
inline ll resetBit(ll n, int i)
{
return n&(~(1LL<<i));
}
string makeintString(int x)
{
stringstream ss;
ss << x;
string str = ss.str();
return str;
}
string makellString(ll x)
{
stringstream ss;
ss << x;
string str = ss.str();
return str;
}
char cpp(char c)
{
return static_cast<char>(c + 1);
}
struct func
{
bool operator()(pii const &a, pii const &b)
{
if(a.F==b.F)
return (a.S<b.S);
return (a.F<b.F);
}
};
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const ll infLL = 9000000000000000000;
#define MOD 1000000007
int main()
{
Boost();
int t;
t=1;
while(t--)
{
ll n,l,x;
cin>>n>>l;
vector<ll>a;
for(ll i=0; i<n; i++)
{
cin>>x;
a.pb(x);
}
ll idx=-1;
for(ll i=0; i<n-1; i++)
{
if(a[i]+a[i+1]>=l)
{
idx=i+1;
break;
}
}
if(idx==-1)
{
cout<<"Impossible"<<endl;
}
else
{
cout<<"Possible"<<endl;
for(ll i=1; i<=(idx-1); i++)
{
cout<<i<<endl;
}
for(ll i=n-1; i>=idx; i--)
{
cout<<i<<endl;
}
}
}
return 0;
} | #include <iostream>
#include <array>
#include <algorithm>
#include <vector>
#include <bitset>
#include <set>
#include <unordered_set>
#include <cmath>
#include <complex>
#include <deque>
#include <iterator>
#include <numeric>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <limits>
#include <iomanip>
#include <functional>
#include <cassert>
using namespace std;
using ll=long long;
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)
#define REP(i, n) rep(i, 0, n)
#define ALL(v) v.begin(),v.end()
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; }
#define DEBUG_VLL(vec) REP(sz, vec.size()) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');
const long long MOD = 1000000007;
const long long HIGHINF = (long long)1e18;
const int INF = (int)1e9;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, l; cin >> n >> l;
vll a(n);
for (ll i = 0; i < n; i++) cin >> a[i];
ll li = -1;
for (ll i = 1; i < n; i++) {
if (a[i - 1] + a[i] >= l) {
li = i;
break;
}
}
if (li == -1) cout << "Impossible\n";
else {
cout << "Possible\n";
for (ll i = 0; i < li - 1; i++) cout << i + 1 << '\n';
for (ll i = n - 1; i > li; i--) cout << i << '\n';
cout << li << '\n';
}
return 0;
} | 1 | 29,685,828 |
#include <iostream>
#include <vector>
using namespace std;
int main()
{
while (true) {
int n, a, b, c, x;
cin >> n >> a >> b >> c >> x;
if (n == 0 && a == 0 && b == 0 && c == 0 && x == 0) {
return 0;
}
vector<int> ys;
for (int i = 0; i < n; ++i) {
int y;
cin >> y;
ys.push_back(y);
}
int x_ = x;
auto lcg = [a, b, c, &x_] {
auto x__ = x_;
x_ = (a * x_ + b) % c;
return x__;
};
int count = 0;
for (int i = 0; i < n; ++i) {
while (true) {
auto xx = lcg();
count += 1;
if (ys[i] == xx) {
break;
}
if (count > 10000) {
count = -1;
break;
}
}
if (count == -1) {
break;
}
}
cout << (count == -1 ? count : count - 1) << endl;
}
} | #define _crt_secure_no_warnings
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
int main()
{
long long int N, A, B, C, X;
vector <int >data;
while (1)
{
int count = -1;
data.clear();
cin >> N >> A >> B >> C >> X;
if (N == 0)break;
data.resize(N);
for (size_t i = 0; i < N; i++)
{
cin >> data[i];
}
while (data.size())
{
if (*data.begin()==X)
{
data.erase(data.begin());
}
X = (A*X + B) % C;
count++;
if (count > 10000)
{
count = -1;
break;
}
}
cout << count<< endl;
}
} | 1 | 36,922,477 |
#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() {
string s,t;
cin >> s >> t;
int n = s.length();
int m = t.length();
sort(s.begin(),s.end());
sort(t.rbegin(),t.rend());
if(s<t){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <deque>
#include <queue>
#include <fstream>
#include <iomanip>
#include <stack>
#include <algorithm>
#include <set>
#include <map>
#include <list>
#define endl "\n"
typedef long long ll;
using namespace std;
void Lancer() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }
bool isPrime(ll n){
if (n == 2 || n == 3 || n == 5)
return true;
else if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n == 1)
return false;
else {
for (int i = 5; i <= sqrt(n); i += 2){
if (n%i == 0)
return false;
}
return true;
}
}
int main(){
Lancer();
string s1, s2;
cin >> s1 >> s2;
sort(s1.begin(), s1.end());
sort(s2.begin(), s2.end());
if (s2[s2.length() - 1] > s1[0])
cout << "Yes";
else if (s1.length() < s2.length()){
for (int i = 0; i < s1.length(); i++){
if (s1[i] != s2[i]){
cout << "No";
return 0;
}
}
cout << "Yes";
}
else cout << "No";
cout << endl;
return 0;
} | 1 | 9,375,796 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s,t;cin>>s>>t;int k=INT_MIN;
for(int i=0;i<=s.length()-t.length();i++)
{
int p=0;
for(int j=0;j<t.length();j++)
{
if(s[j+i]==t[j])
{p++;}
}
k=max(p,k);
}
cout<<t.length()-k;
} | #pragma region
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; ++i)
#define per(i, a, n) for (int i = n; i >= a; --i)
namespace fastIO {
#define BUF_SIZE 100000
#define OUT_SIZE 100000
bool IOerror = 0;
inline char nc() {
static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, BUF_SIZE, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'; }
template <class T>
inline bool R(T &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return false;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (sign) x = -x;
return true;
}
inline bool R(double &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return false;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (ch == '.') {
double tmp = 1;
ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc())
tmp /= 10.0, x += tmp * (ch - '0');
}
if (sign)
x = -x;
return true;
}
inline bool R(char *s) {
char ch = nc();
for (; blank(ch); ch = nc())
;
if (IOerror)
return false;
for (; !blank(ch) && !IOerror; ch = nc())
*s++ = ch;
*s = 0;
return true;
}
inline bool R(char &c) {
c = nc();
if (IOerror) {
c = -1;
return false;
}
return true;
}
template <class T, class... U>
bool R(T &h, U &... t) { return R(h) && R(t...); }
#undef OUT_SIZE
#undef BUF_SIZE
};
using namespace fastIO;
template <class T>
void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) { _W(x.F), putchar(' '), _W(x.S); }
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &... tail) { _W(head), putchar(sizeof...(tail) ? ' ' : '\n'), W(tail...); }
#pragma endregion
const int maxn = 1e3 + 5;
char s[maxn], t[maxn];
int main() {
R(s + 1);
R(t + 1);
int maxx = 0;
int n = strlen(s + 1), m = strlen(t + 1);
rep(i, 1, n - m + 1) {
int tmp = 0;
rep(j, 1, m)
if (t[j] == s[i + j - 1]) ++tmp;
maxx = max(maxx, tmp);
}
W(m - maxx);
} | 1 | 16,559,873 |
#include <iostream>
#include <vector>
#include <utility>
#include <string>
#include <algorithm>
#include <numeric>
using namespace std;
int main() {
int n, min = -1;
vector<int> v;
for (;;) {
cin >> n;
if (n == 0) break;
v.resize(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int i = 0; i < n - 1; i++) {
if (min == -1)min = v[i + 1] - v[i];
else if (min > v[i + 1] - v[i]) min = v[i + 1] - v[i];
}
cout << min << endl;
min = -1;
}
} | #include <stdio.h>
#include <iostream>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <sstream>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <complex>
#include <vector>
#include <cstdio>
#include <math.h>
#include <cmath>
#include <time.h>
#define all(c) ((c).begin(),(c).end())
#define rall(c) (c).rbegin(),(c).rend()
#define sort(v,n) sort(v,v+n)
#define vsort(v) sort(v.begin(),v.end())
#define vvsort(v) sort(v.begin(),v.end(),greater<int>())
#define ll long long
#define pb(a) push_back(a)
#define fi first
#define se second
#define inf 999999999
using namespace std;
const ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
int n;
int a[1000];
int main() {
while (cin >> n, n) {
for (int i = 0; i < n; i++)cin >> a[i];
sort(a, n);
int ans = inf;
for (int i = 1; i < n; i++) {
ans = min(ans, a[i] - a[i - 1]);
}
cout << ans << endl;
}
} | 1 | 22,647,489 |
#include<bits/stdc++.h>
#define ll long long
#define all(a) a.begin(),a.end()
#define sz(a) a.size()
#define re return
#define MP make_pair
#define pb push_back
#define pii pair<int,int>
#define se second
#define fi first
using namespace std;
int n;
string s;
bool used[105];
int cnt1,cnt2;
signed main(){
ios_base::sync_with_stdio(0);
cin>>n>>s;
for(int i=0;i<n;i++){
if(s[i]=='('&&!used[i]){
used[i]=1;
bool found=0;
for(int j=i+1;j<n;j++){
if(s[j]==')'&&!used[j]){
used[j]=1;
found=1;
break;
}
}
if(!found) cnt2++;
}
if(s[i]==')'&&!used[i]){
used[i]=1;
bool found=0;
for(int j=i-1;j>=0;j--){
if(s[j]=='('&&!used[j]){
used[j]=1;
found=1;
break;
}
}
if(!found) cnt1++;
}
}
for(int i=0;i<cnt1;i++) cout<<'(';
cout<<s;
for(int i=0;i<cnt2;i++) cout<<')';
re 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mp(a,b) make_pair(a,b)
#define big 1000000007
#define all(a) sort((a).begin(),(a).end())
#define Re(a) reverse((a).begin(),(a).end())
#define YN(a) if(a){cout<<"Yes"<<endl;}else cout<<"No"<<endl;
const int MOD=1000000007;
const double pi = 3.141592653589793;
int main(){
int n;
cin>>n;
string s;
cin>>s;
deque<char> d;
int k=0;
rep(i,n){
if(s[i]=='('){
k++;
}
else{
k--;
}
d.push_back(s[i]);
if(k<0){
d.push_front('(');
k++;
}
}
while(k>0){
d.push_back(')');
k--;
}
int ds = d.size();
rep(i,ds){
cout<<d[i];
}
cout<<endl;
} | 1 | 41,953,177 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#define N 10010
using namespace std;
int n,k,a[N],f[N],ok=1,s;
int main(){
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++) scanf("%d",&a[i]),a[i]=min(a[i],k),s+=a[i];
sort(a+1,a+n+1);
f[0]=1;
for(int i=n;i>=0;i--){
ok=1;
for(int j=max(k-s,0);j<=k-1;j++)
if(f[j]==1) {ok=0;break;}
if(ok){
printf("%d",i);
break;
}
for(int j=k;j>=a[i];j--) f[j]=f[j-a[i]]|f[j];
s-=a[i];
}
} | #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
int main(){
int N, K;cin>>N>>K;
vi a;
a.push_back(0);
for (int i=0;i<N;++i){
int a_;cin>>a_;a.push_back(a_);
}
a.push_back(0);
int left[2][K+1], right[2][K+1];
memset(left, -1, sizeof(left));
memset(right, -1, sizeof(right));
left[0][0]=1;
right[0][0]=1;
vi l_sum[N+2], r_sum[N+2];
l_sum[0].push_back(0);r_sum[N+1].push_back(0);
for (int i=0;i<N+1;++i){
for (int j=0;j<K+1;++j){
if(left[0][j]==1||(j>=a[i+1]&&left[0][j-a[i+1]]==1)) {
left[1][j]=1;
l_sum[i+1].push_back(j);
}
}
for (int j=0;j<K+1;++j) {left[0][j]=left[1][j];}
}
for (int i=N+1;i>=1;--i){
for (int j=0;j<K+1;++j){
if(right[0][j]==1||(j>=a[i-1]&&right[0][j-a[i-1]]==1)) {
right[1][j]=1;
r_sum[i-1].push_back(j);
}
}
for (int j=0;j<K+1;++j) {right[0][j]=right[1][j];}
}
int ans=0;
for (int i=1;i<N+1;++i){
int L=l_sum[i-1].size();
int patience=1;
for (int l=0;l<L;++l){
int R=r_sum[i+1].size();
int x=lower_bound(r_sum[i+1].begin(), r_sum[i+1].end(), K-l_sum[i-1][l]-a[i])-r_sum[i+1].begin();
if (x>R-1) continue;
if(r_sum[i+1][x]+l_sum[i-1][l]<K) patience=0;
}
if(patience==1) ans++;
}
cout << ans << endl;
return 0;
} | 1 | 16,717,323 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<int> X(N);
for(int i = 0; i < N; i++){
cin >> X.at(i);
}
long long sum = 1000000000;
for(int i = 1; i <= 100; i++){
long long cost = 0;
for(int j = 0; j < N; j++){
cost += (X.at(j) - i) * (X.at(j)-i);
}
sum = min(sum, cost);
}
cout << sum << endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
typedef double db;
const double pi = acos(-1) ;
#define pb push_back
#define forab(i,a,b) for(int i=(a);i<=(b);i++)
#define CIN ios_base::sync_with_stdio(0); cin.tie(0)
#define pcase(z,x) printf("Case %ld: %lld\n",z,x)
#define nw "\n"
int main(void)
{
CIN;
ll tc,l,k,sum=0,x=0,y,z=0,m=1,n=0,ans=0;
cin>>n;
int arr[n];
tc=n;
while(tc--)
{
cin>>arr[x];
sum+=arr[x++];
}
x=sum/n;
for(ll i=0;i<n;i++)
{
z+=abs(arr[i]-x)*abs(arr[i]-x);
}
x++;
for(ll i=0;i<n;i++)
{
ans+=abs(arr[i]-x)*abs(arr[i]-x);
}
ans=min(ans,z);
cout<<ans;
} | 1 | 16,301,263 |
#include<stdio.h>
int main(){
char S[3];
int cnt=0;
scanf("%s",S);
for(int i=0;i<3;i++){
if(S[i]==S[i+1]){
cnt++;
}
}
if(cnt==2){
printf("No");
}else{
printf("Yes");
}
return 0;
} | #include<bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("-ffloat-store")
#define int long long
#define rep(i,begin,end) for(__typeof(end)i=(begin)-((begin)>(end));i!=(end)-((begin)>(end));i+=1-2*((begin)>(end)))
#define F first
#define S second
#define sz(x) ((int)x.size())
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(v) (v).begin(), (v).end()
#define mod 1000000007
#define what_is(x) cerr << #x << " is " << x <<"\n";
#define sortA(v) sort(v.begin(), v.end())
#define sortD(v) sort(v.rbegin(), v.rend())
#define PI 3.14159265358979323846
#define vout(a) for(auto x:a) cout<<x<<" ";
#define INF 10000000000000000
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<int,int>;
using vii = vector<pii>;
using mi = multiset<int>;
using mii = multiset<pii>;
int lcm(int a,int b) {return (a*(b/__gcd(a,b)));}
void solve()
{
int n,m,t,i,k,r,l,u,v,w,j,s,sum=0,pos,flag=0,count=0;
string S,T,U;
cin>>S;
if(S[0]==S[1]&&S[1]==S[2]) cout<<"No";
else cout<<"Yes";
}
signed main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int t=1;
while(t--)
{
solve();
if(t)cout<<"\n";
}
return 0;
} | 1 | 14,564,653 |
#pragma GCC optimize("Ofast")
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define PI 3.141592
#define all(a) (a).begin(), (a).end()
int main(){
int N, K;
cin >> N >> K;
vector<int> H(N);
for(int i = 0; i < N; i++) cin >> H[i];
int count = 0;
for(int h : H){
if(h >= K) count++;
}
cout << count << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int N,K,h,i,c;
cin>>N>>K;
c = 0;
for(i=0;i!=N;i++)
{
cin>>h;
if(h >= K)
c++;
}
cout<<c;
return 0;
} | 1 | 18,495,272 |
#include <bits/stdc++.h>
#include <algorithm>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
int main(){
long long n;
cin >> n;
int ans = 10;
for(int i = 1; i <= sqrt(n); i++) {
if(n % i == 0) {
int keta = 0;
long long syou = n / i;
while(syou > 0) {
syou /= 10;
keta++;
}
ans = min(ans, keta);
}
}
cout << ans;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using int64 = int64_t;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int64 n;
cin >> n;
int ans;
for (int64 i = 1; i * i <= n; i++) {
if (i * (n / i) == n) {
ans = (int)to_string(n / i).size();
}
}
cout << ans;
return 0;
} | 1 | 21,857,892 |
#include <bits/stdc++.h>
#define ll long long
const ll inf=(1LL<<62);
template <class A, class B> inline bool chmin(A &a, const B &b) { return b < a && (a = b, true); }
template <class A> inline A abs(A &a) { return (a < 0 ? -a : a); }
using namespace std;
signed main() {
ll n;
cin >> n;
ll ans = n;
for (int i = 0; i <= n; i++) {
ll a = 0;
ll t = i;
while (t > 0) {
a += t % 6;
t /= 6;
}
t = n - i;
while (t > 0) {
a += t % 9;
t /= 9;
}
if (ans > a) {
ans = a;
}
}
cout << ans << "\n";
return(0);
} | #include <iostream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <string>
#include <cmath>
#include <complex>
#include <numeric>
#include <cassert>
#include <vector>
#include <array>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <utility>
#define int64 long long
#define uint64 unsigned long long
using namespace std;
int main()
{
int64 nn, tmp;
cin >> nn;
vector<int64> memo(nn + 1);
for(int64 ii = 0;ii <= nn;ii++)
{
memo[ii] = ii;
}
tmp = 1;
while(tmp <= nn)
{
tmp *= 6;
for(int64 jj = 0;jj <= nn;jj++)
{
if(jj + tmp <= nn)
{
if(memo[jj + tmp] > memo[jj] + 1)
{
memo[jj + tmp] = memo[jj] + 1;
}
}
}
}
tmp = 1;
while(tmp <= nn)
{
tmp *= 9;
for(int64 jj = 0;jj <= nn;jj++)
{
if(jj + tmp <= nn)
{
if(memo[jj + tmp] > memo[jj] + 1)
{
memo[jj + tmp] = memo[jj] + 1;
}
}
}
}
cout << memo[nn] << endl;
return 0;
} | 1 | 10,526,405 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
ios_base::sync_with_stdio(false); cin.tie(0);
int n, k, x, y;
cin >> n >> k >> x >> y;
int ans = 0;
if(n < k){
ans += n*x;
}else{
ans += (k*x + (n - k)*y);
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N,K,X,Y;
cin >> N >> K >> X >> Y;
int total_cost = 0;
for(int i=0; i < N; i++) {
if (i < K) {
total_cost += X;
} else {
total_cost += Y;
}
}
cout << total_cost << endl;
} | 1 | 9,470,969 |
#include <bits/stdc++.h>
using namespace std;
#define dump(x) cout << (x) << '\n';
typedef int64_t Int;
Int mod = 1e9+7;
Int INF = 1e9+7;
int main() {
ios::sync_with_stdio(false);
vector<Int> res;
while (true) {
Int n;
cin >> n;
vector<Int> a(n);
if (n == 0) break;
for (Int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
Int mi = 1e9;
for (Int i = 0; i < n - 1; i++) mi = min(mi, a[i + 1] - a[i]);
res.emplace_back(mi);
}
for (Int i = 0; i < (Int)res.size(); i++) dump(res[i]);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n;
int a[1050];
while(cin>>n,n){
for(int i=0;i<n;i++){
cin>>a[i];
}
sort(a,a+n);
int mn=1000000;
for(int i=1;i<n;i++){
mn=min(mn,a[i]-a[i-1]);
}
cout<<mn<<endl;
}
return 0;
} | 1 | 5,016,488 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define eb emplace_back
#define mt make_tuple
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
typedef long long ll;
typedef pair <int, int> ii;
typedef pair <ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef long double ld;
const ll INF=LLONG_MAX;
const int BT=18;
int dp[1<<BT][2];
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int n;
scanf("%d",&n);
for(int i=0; i<(1<<n); i++)scanf("%d",&dp[i][1]);
for(int i=0; i<n; i++){
for(int mask=0; mask < (1<<n); mask++){
if(!dp[mask][1])continue;
if(mask>>i&1){
dp[mask][0]=max(dp[mask][0],dp[mask^(1<<i)][1]);
if(dp[mask][0]>dp[mask][1])swap(dp[mask][0],dp[mask][1]);
}
}
}
int res = 0;
for(int i=1; i<(1<<n); i++){
res = max(res,dp[i][0]+dp[i][1]);
cout << res << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
#define maxn 600020
#define rep(i,l,r) for(register int i = l ; i <= r ; i++)
#define repd(i,r,l) for(register int i = r ; i >= l ; i--)
#define rvc(i,S) for(register int i = 0 ; i < (int)S.size() ; i++)
#define rvcd(i,S) for(register int i = ((int)S.size()) - 1 ; i >= 0 ; i--)
#define fore(i,x)for (register int i = head[x] ; i ; i = e[i].next)
#define pb push_back
#define prev prev_
#define stack stack_
#define mp make_pair
#define fi first
#define se second
#define inf 0x3f3f3f3f
typedef long long ll;
typedef pair<int,int> pr;
int a[maxn],f[maxn],g[maxn];
int n,S;
int main(){
scanf("%d",&n);
S = (1 << n) - 1;
rep(i,0,S) scanf("%d",&f[i]) , g[i] = -inf;
rep(i,0,n - 1){
rep(j,0,S){
if ( j & (1 << i) ){
if ( f[j] < f[j ^ (1 << i)] ){
g[j] = f[j] , f[j] = f[j ^ (1 << i)];
if ( g[j] < g[j ^ (1 << i)] ) g[j] = g[j ^ (1 << i)];
}
else if ( g[j] < f[j ^ (1 << i)] ) g[j] = f[j ^ (1 << i)];
}
}
}
rep(i,1,S){
int pre = 0,ans = f[i] + g[i];
repd(j,n - 1,0){
if ( i & (1 << j) ){
ans = max(ans,f[pre | ((1 << j) - 1)] + g[pre | ((1 << j) - 1)]);
pre |= 1 << j;
}
}
printf("%d\n",ans);
}
} | 1 | 56,838,502 |
#include<iostream>
int main()
{
int n;
std::cin >> n;
for (int i = 0; i < n; i++)
{
long double x1, y1, x2, y2, x3, y3, x4, y4;
std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
std::cout << (x1 == x2 && x3 == x4 || (y1 - y2) / (x1 - x2) == (y3 - y4) / (x3 - x4) ? "YES" : "NO") << std::endl;
}
return 0;
} | #include <iostream>
#include <complex>
#include <cmath>
#include <vector>
using namespace std;
typedef complex<double> P;
const double eps = 1e-8;
bool cross(P a, P b) {
return a.real()*b.imag() - a.imag()*b.real();
}
int main() {
int Tc;
cin >> Tc;
while(Tc--) {
vector<P> ps(4);
for(int i = 0; i < 4; ++i) {
cin >> ps[i].real() >> ps[i].imag();
}
if(abs(cross(ps[1]-ps[0], ps[3]-ps[2])) < eps) cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
} | 1 | 67,028,959 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
#include<queue>
#include<map>
#include<math.h>
#include<string>
#include <cctype>
#include <cstdlib>
#include<bitset>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for (int i = s; i < (int)(n); i++)
#define out(x) cout << x << endl
#define INF 1ll<<60;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
using namespace std;
using ll = long long;
typedef pair<int, int> P;
int main(){
int n, k;
cin >> n >> k;
int count = 0;
rep(i, n){
int h;
cin >> h;
if(h>=k) count++;
}
out(count);
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i=0;i < (n); ++i)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<vector<int>> Graph;
int main() {
int n,k,h,ans=0;
cin >> n >> k;
rep(i,n){
cin >> h;
if (h>=k) ans++;
}
cout << ans << endl;
} | 1 | 11,740,511 |
#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 N, L;
cin >> N >> L;
vector<string> s(N);
rep (i,N) {
cin >> s.at(i);
}
sort(s.begin(), s.end());
for (int i = 0; i < N; ++i) {
cout << s.at(i);
}
cout << endl;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <climits>
#include <iomanip>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
int main(){
ll n,l;
cin >> n >> l;
vector<string> s(n);
for(int i = 0;i < n;i++)cin >> s[i];
sort(s.begin(),s.end());
string res;
for(int i = 0;i < n;i++)res += s[i];
cout << res << endl;
} | 1 | 36,751,632 |
#include <iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<set>
#include<map>
using namespace std;
int main(void){
int n,k;
cin>>n>>k;
int ans=1;
while(n--){
ans= min(ans*2, ans+k);
}
cout<<ans;
} | #include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);i++)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using namespace std;
template <typename T>
using vec = std::vector<T>;
int main() {
int N,K;
cin >> N >> K;
int now = 1;
rep(i,N){
if(now <= K) now*=2;
else now+=K;
}
cout << now << endl;
} | 1 | 26,118,206 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <map>
#include <set>
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <iomanip>
#include <assert.h>
#include <math.h>
#include <stack>
#include <queue>
#include <list>
using namespace std;
#ifdef __DEBUG__
bool debug_disabled = false;
#else
bool debug_disabled = true;
#endif
#define dbg if (debug_disabled) {} else cerr
void solve() {
int d, t, s;
cin >> d >> t >> s;
if (s * t >= d) cout << "Yes" << endl;
else cout << "No" << endl;
}
int main() {
cout.setf(ios::fixed, ios::floatfield);
cout.setf(ios::showpoint);
cout.precision(12);
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int T = 1;
for (int i = 1; i <= T; ++i) {
solve();
}
return 0;
} | #include <iostream>
#include <vector>
#include <cstring>
#include <set>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <queue>
#include <deque>
#include <map>
#include <stack>
using namespace std;
#define ll long long
#define pb push_back
#define pp pair<long long,long long>
#define ppp pair<pair<long long,long long>,long long>
#define f firsta
#define s second
#define pd pair<double,long long>
int main() {
ll t,n,i,j,k,l,m;
ios_base::sync_with_stdio(0);
cin.tie(0);
ll p;
t=1;
while (t--) {
double d,s,t,c;
cin>>d>>s>>t;
c=d/s;
if (c<=t)
cout<<"Yes\n";
else
cout<<"No\n";
}
return 0;
} | 1 | 92,222,499 |
#include <iostream>
#include <stdio.h>
#define MAX 101
int A[MAX];
int main() {
int n, x;
int sum = 0;
while (1) {
scanf("%d %d", &n, &x);
if ( n == 0 && x == 0 ) break;
for (int i = 1; i <= n; i++) A[i] = i;
for (int i = 1; i <= n-2; i++) {
for (int j = i+1; j <= n-1; j++) {
for (int k = j+1; k <= n; k++) {
if (A[i] + A[j] + A[k] == x) sum ++;
}
}
}
printf("%d\n", sum);
sum = 0;
}
return 0;
} | #include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int n,x;
while (true) {
cin >> n >> x;
if (n == 0 && x == 0){
break;
}
vector<vector<int> > numbers;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
if (i + j + k == x){
if (i == j || i == k || j == k) {
continue;
}
bool isMatch = false;
if (numbers.size() > 0){
for (int m = 0; m < (int)numbers.size(); m++) {
int judge = 0;
for (int n = 0; n < 3; n++) {
if (i == numbers[m][n] || j == numbers[m][n] || k == numbers[m][n]){
judge++;
}
}
if (judge > 2){
isMatch = true;
break;
}
}
}
if (!isMatch) {
numbers.push_back({i, j, k});
}else{
}
}
}
}
}
printf("%d\n", static_cast<int>(numbers.size()));
}
return 0;
} | 1 | 34,399,863 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,i;
cin>>n;
double l=0,x;
double a[n];
for(i=0;i<n;i++)
{
cin>>a[i];
l=l+1/a[i];
}
x=1/l;
cout<<x;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, c) for (int i = 0; i < (int)c; i++)
int main()
{
int n;
scanf("%d", &n);
double sum = 0;
rep(i, n) {
int a;
scanf("%d", &a);
sum += 1.0 / a;
}
double ans = 1 / sum;
printf("%.10f\n", ans);
return 0;
} | 1 | 68,407,458 |
#include<bits/stdc++.h>
using namespace std;
using lli = long long;
string s;
int main(void){
cin >> s;
lli a=0, b=0;
lli n = s.size();
for(lli i = 0; i < n; i++){
if(s[i] == 'B'){
a+=n-1-i;
b++;
}
}
cout << a-b*(b-1)/2 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define faster ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
typedef long long ll;
typedef vector<int> vi;;
typedef vector<ll> vll;
#define l() length()
#define sz() size()
#define b() begin()
#define e() end()
#define all(x) x.begin(), x.end()
#define pb(i) push_back(i)
#define PB() pop_back()
typedef pair<int, int> pii;
typedef pair<ll,ll> pll;
#define mp make_pair
#define Fi first
#define Se second
const int maxx=1e6+9;
ll _find(string &str){
int n=str.l();
ll last=0;
ll ans=0;
for(int i=n-1;i>=0;i--){
if(str[i]=='B'){
ans+=last;
}
else{
last++;
}
}
return ans;
}
void solve(){
string str;
cin>>str;
cout<<_find(str)<<endl;
}
int main() {
faster;
int t=1;
while(t-->0){
solve();
}
return 0;
} | 1 | 34,672,568 |
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef complex<double> point;
#define xx real()
#define yy imag()
#define REP(i, a, b) for(int i = (a); i < (int)(b); i++)
#define REPN(i, a, b) for(int i = (a); i <= (int)(b); i++)
#define FA(it, x) for(__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define SZ(x) (int)(x).size()
#define BE(x) (x).begin(), (x).end()
#define SORT(x) sort(BE(x))
#define _1 first
#define _2 second
#define x1 gray_cat_x1
#define y1 gray_cat_y1
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
#define file "I1"
const double EPS = 1e-9;
const double PI = acos(-1.);
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
vi g[MAXN];
int v[MAXN];
ll dp[MAXN];
int used[MAXN];
int dfs(int s){
used[s] = 1;
ll dp_sum = 0, dp_mx = 0;
REP(i, 0, SZ(g[s])){
int to = g[s][i];
if (!used[to]){
if (dfs(to)){
return 1;
}
dp_sum += dp[to];
dp_mx = max(dp_mx, dp[to]);
}
}
if (SZ(g[s]) > 1) {
ll a = dp_sum - v[s];
ll b = v[s] - a;
if (a < 0 || b < 0 || a > dp_sum - dp_mx){
return 1;
}
dp[s] = b;
} else {
dp[s] = v[s];
}
return 0;
}
void solve(){
int n;
scanf("%d", &n);
REPN(i, 1, n){
scanf("%d", &v[i]);
}
REP(i, 1, n){
int a, b;
scanf("%d%d", &a, &b);
g[a].pb(b);
g[b].pb(a);
}
if (n == 2){
if (v[1] == v[2]){
printf("YES\n");
} else {
printf("NO\n");
}
return;
}
int s = 1;
REPN(i, 1, n){
if (SZ(g[i]) > 1){
s = i;
}
}
if (dfs(s) || dp[s]){
printf("NO\n");
} else {
printf("YES\n");
}
}
int main(){
int t = 1;
while(t--){
solve();
}
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+10;
char buf[1<<15],*fs,*ft;
inline char getc() { return (ft==fs&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),ft==fs))?0:*fs++; }
template<typename T>inline void read(T &x)
{
x=0;
T f=1, ch=getchar();
while (!isdigit(ch) && ch^'-') ch=getchar();
if (ch=='-') f=-1, ch=getchar();
while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
x*=f;
}
int ver[maxn<<1],Next[maxn<<1],head[maxn],len,deg[maxn];
inline void add(int x,int y)
{
ver[++len]=y,Next[len]=head[x],head[x]=len;
}
ll A[maxn];
bool flag=1;
inline void dfs(int x,int fa)
{
ll sum=0,maxpart=0; int o=0;
for (int i=head[x]; i; i=Next[i])
{
int y=ver[i];
if (y==fa) continue;
++o;
dfs(y,x);
sum+=A[y];
maxpart=max(maxpart,A[y]);
}
if (!o) return ;
ll a=sum-A[x],b=(A[x]<<1)-sum;
if (a<0 || b<0 || a>min(sum-maxpart,sum>>1) || (fa==-1 && b)) flag=0;
A[x]=b;
}
int main()
{
int n;read(n);
for (int i=1; i<=n; ++i) read(A[i]);
for (int i=1,a,b; i<n; ++i) read(a),read(b),add(a,b),add(b,a),++deg[a],++deg[b];
int root=0;
for (int i=1; i<=n; ++i)
if (deg[i]>1) { root=i; break; }
if (root) dfs(root,-1);
else flag=(A[1]==A[2]);
puts(flag?"YES":"NO");
return 0;
} | 1 | 59,658,220 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,D,X;
cin >> N >> D >> X;
vector<int>vec(N);
for(int i=0; i<N; i++){
cin >> vec[i];
X += (D-1)/vec[i]+1;
}
cout << X << endl;
} | #include <bits/stdc++.h>
using namespace std;
int64_t mod = 1000000007;
int64_t large = 9223372036854775807;
double PI = 3.141592653589793;
int main()
{
int N, D, ans, tmp;
cin >> N >> D >> ans;
for (int i = 0; i < N; i++)
{
cin >> tmp;
ans += (D - 1) / tmp + 1;
}
cout << ans;
} | 1 | 48,483,138 |
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <cassert>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long int ll;
const int INF = 1000000000;
const double PI = acos(-1);
const ll mod = 1000000007;
int main()
{
int n;
string s;
cin >> n >> s;
vector<int> c(n);
vector<int> r_num(n + 1, 0);
vector<int> g_num(n + 1, 0);
vector<int> b_num(n + 1, 0);
rep(i, n) {
r_num[i + 1] = r_num[i];
g_num[i + 1] = g_num[i];
b_num[i + 1] = b_num[i];
if (s[i] == 'R') {
c[i] = 0;
r_num[i + 1] = r_num[i] + 1;
}
else if (s[i] == 'G') {
c[i] = 1;
g_num[i + 1] = g_num[i] + 1;
}
else {
c[i] = 2;
b_num[i + 1] = b_num[i] + 1;
}
}
ll ans = 0;
for (int i = 0; i < n-2; i++) {
for (int j = i + 1; j < n-1; j++) {
if (c[i] == c[j]) continue;
if (c[i] + c[j] == 1) {
ans += b_num[n] - b_num[j + 1];
if (2*j - i < n) {
if (c[2 * j - i] == 2) ans -= 1;
}
}
else if (c[i] + c[j] == 3) {
ans += r_num[n] - r_num[j + 1];
if (2 * j - i < n) {
if (c[2 * j - i] == 0) ans -= 1;
}
}
else {
ans += g_num[n] - g_num[j + 1];
if (2 * j - i < n) {
if (c[2 * j - i] == 1) ans -= 1;
}
}
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
string s;
long long ans = 0;
long long count = 0;
long long r, g, b;
r = g = b = 0;
cin >> N >> s;
for (int i = 0; i < N; i++) {
if (s[i] == 'R') {
r++;
}else if (s[i] == 'G'){
g++;
}else if (s[i] == 'B'){
b++;
}
}
for (int i = 1; i <= N/2; i++){
for (int j = 0; j + 2*i < N; j++) {
if ((s[j] != s[j+i]) && (s[j+2*i] != s[j+i]) && (s[j] != s[j+2*i])) {
count ++;
}
}
}
cout << r*g*b - count << endl;
} | 1 | 66,171,911 |
#include <bits/stdc++.h>
#include<cmath>
#define N 100005
#define A 1000005
#define MOD 998244353
#define INF 1000000000000000000
#define ll long long
using namespace std;
#define pii pair<ll, ll>
#define piii pair<ll, pii>
#define ft first
#define sd second
#define pb push_back
#define rep(i, n) for(ll i = 0; i < n; i++)
#define repr(i, n) for(ll i = n-1; i >= 0; i--)
#define itr(it, x) for(auto it = x.begin(); it != x.end(); it++)
#define mem(a, b) memset(a, (ll)b, sizeof(a))
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define edge(v, x, y) v[x].pb(y); v[y].pb(x);
#define popcount __builtin_popcount
#define ANS(s) {cout << s << "\n"; return;}
#define printpii(a) cout << a.ft << " " << a.sd << endl;
#define printpiii(a) cout << a.ft << " " << a.sd.ft << " " << a.sd.sd << endl;
#define print(a, n) rep(i, n) cout << a[i] << " "; cout << endl;
#define printv(v) for(auto x: v)cout << x << " "; cout << endl;
#define printm(a, n, m) rep(i, n) { rep(j, m) cout << a[i][j] << "\t"; cout << endl;}
ll dx[4] = {0, 0, 1, -1};
ll dy[4] = {1, -1, 0, 0};
void fast(){ios_base::sync_with_stdio(false);cin.tie(0);cout << setprecision(12) << fixed;}
void solve(){
ll n, m;
cin >> n >> m;
vector<string> v;
rep(i, n)
{
string s;
cin >> s;
v.pb(s); v.pb(s);
}
for(auto x: v) cout << x << endl;
}
main(){
fast();
ll t = 1;
while(t--){
solve();
}
} | #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++)
using namespace std;
using P = pair<int, int>;
using ll = long long;
int main()
{
int n, m;
cin >> n >> m;
string s[n];
rep(i, n) cin >> s[i];
rep(i, n){
cout << s[i] << endl << s[i] << endl;
}
return 0;
} | 1 | 94,297,145 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l[86];
l[0] = 2;
l[1] = 1;
for (int i = 2; i < 87; i++) {
l[i] = l[i-1] + l[i-2];
}
int n;
cin >> n;
cout << l[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N = 0;
cin >> N;
vector<unsigned long long> A(90);
A.at(0) = 2;
A.at(1) = 1;
for (size_t i = 2; i < 90; i++)
{
A.at(i) = A.at(i-1)+A.at(i-2);
}
cout << A.at(N) << endl;
return 0;
} | 1 | 80,266,838 |
#include <stdio.h>
#include <string.h>
int main(){
char words[105];
int k;
int word;
scanf("%d" ,&k);
scanf("%s" ,words);
word = strlen(words);
if (word <= k){
printf("%s" ,words);
}
else if(word > k){
words[k] = '\0';
printf("%s..." ,words);
}
return 0;
} | #include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<tuple>
#include<cassert>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define Per(i,sta,n) for(int i=n-1;i>=sta;i--)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef long double ld;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ll, ll> LP;
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int k;string s;
void solve(){
cin >> k;
cin >> s;
int n=s.length();
if(n<=k){
cout << s << endl;
}
else{
string v="...";
cout << s.substr(0,k)+v << endl;
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(50);
solve();
} | 1 | 13,888,408 |
#include<bits/stdc++.h>
typedef long long ll;
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define last freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define fr first
#define sc second
#define lcm(a,b) (a*b)/__gcd(a,b)
#define com(i,n) for(int i=0;i<n;i++)
#define dom(i,n) for(int i=1;i<=n;i++)
#define mom(i,n) for(int i=n;i>=0;i--)
#define sortI(a,n) sort(a,a+n)
#define sortD(a,n) sort(a,a+n,greater<int>())
#define sortvi(a) sort(a.begin(),a.end())
#define sortvd(a) sort(a.begin(),a.end(),greater<int>())
#define sumall(a,x) accumulate(a.begin(),a.end(),x)
#define pi 3.14159265358979323846264338327950
#define endl '\n'
using namespace std;
int main()
{
ll n,sum=0;
cin>>n;
if(n==360)
cout << 2 << endl;
else
{
dom(i,100000)
{
sum+=n;
if(sum%360==0)
{
cout << i << endl;
break;
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int X;
cin >> X;
int S = X;
for (int i = 1;; i++) {
if (S % 360 == 0) {
cout << i << endl;
return 0;
}
S += X;
}
} | 1 | 70,162,149 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include<queue>
#include<set>
#include<climits>
using namespace std;
int main()
{
while (true)
{
long long n, tmp = LLONG_MAX;
cin >> n;
if (n == 0)
exit(0);
vector<long long> v(n, 0);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
for (int i = 1; i < n; i++)
{
if (v[i] - v[i - 1] < tmp)
tmp = v[i] - v[i - 1];
}
cout << tmp << endl;
}
} | #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main () {
int n;
while (cin >> n, n) {
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
int min_ = 1e+9;
for (int i = 0; i < n - 1; i++) {
min_ = min(min_, v[i + 1] - v[i]);
}
cout << min_ << endl;
}
return 0;
} | 1 | 33,591,273 |
#include <iostream>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <vector>
#include <queue>
#include <cmath>
#include <bitset>
#include <complex>
#include <functional>
#include <numeric>
#include <iomanip>
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for(int i=(a);i<(n);++i)
#define RFOR(i, a, n) for(int i=(n)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
#define OUT(a, x, b) (x<a || b<=x)
template<class T> inline T chmax(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T chmin(T& a, const T b) { return a = (a > b) ? b : a; }
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
struct INIT {
INIT(){cin.tie(0); ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
}}INIT;
signed main() {
int A, B, C, D, N;
cin >> A >> B >> C >> D >> N;
chmin(B, A*2);
chmin(C, B*2);
chmin(D, C*2);
cout << D*(N/2)+(N%2)*C << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9+7;
int main(){
vector<ll> num(4);
for(int i = 0; i < 4; i++) cin >> num[i];
ll n;
cin >> n;
ll ans = (n*4)*num[0];
ans = min((n*2)*num[1],ans);
ans = min(ans,n*num[2]);
if(n%2 == 1){
ans = min(ans,(n/2)*num[3]+min(num[0]*4,min(num[1]*2,num[2])));
}else ans = min(ans,(n/2)*num[3]);
cout << ans << endl;
return 0;
} | 1 | 65,509,640 |
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define ll long long
#define _GLIBCXX_DEBUG
const ll MOD = 1000000007;
int main() {
string s;
cin >> s;
bool exist1=false, exist2=false;
int ans1, ans2;
for (int i=0; i<s.size()-1; i++) {
if (s[i]==s[i+1]) {
ans1=i+1, ans2=i+2;
exist1 = true;
break;
}
}
for (int i=0; i<s.size()-2; i++) {
if (s[i]!=s[i+1]&&s[i+1]!=s[i+2]&&s[i]==s[i+2]) {
ans1=i+1, ans2=i+3;
exist2 = true;
break;
}
}
if (exist1||exist2) cout << ans1 << " " << ans2 << endl;
else cout << -1 << " " << -1 << endl;
} | #include <bits/stdc++.h>
#include <vector>
# include <cstdint>
#define FOR(i,l,r) for(int i=(l);i<(r);++i)
#define RFOR(i,l,r) for(int i=(l);i>=(int)(r);i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n-1,0)
#define int long long
using namespace std;
const int MX = 1e6;
const int inf = 1e9;
const int mod = 1e9+7;
#define ll long long
signed main() {
string s;
cin >> s;
int st = 0;
int ed = 1;
rep(i, s.length()-1) {
if(s[st]==s[ed]) {
cout << st+1<<" "<<ed+1 << endl;
return 0;
}
st++;
ed++;
}
st = 0;
ed = 2;
rep(i, s.length()-2) {
if(s[st]==s[ed]) {
cout << st+1<<" "<<ed+1 << endl;
return 0;
}
st++;
ed++;
}
cout << "-1 -1" << endl;
return 0;
} | 1 | 37,318,223 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<long long int> a(n);
for(int i=0; i<n; i++){
cin >> a[i];
}
sort(a.begin(), a.end());
vector<long long int> sa(n+1);
for(int i=0; i<n; i++){
sa[i+1] = sa[i] + a[i];
}
int ans = 1;
for(int i=n-1; i>=0; i--){
if(a[i] <= 2 * sa[i]) ans += 1;
else break;
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <string>
#include <cmath>
#include <complex>
#include <numeric>
#include <cassert>
#include <vector>
#include <array>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <utility>
#define PI 3.14159265358979323846
#define int64 long long
#define uint64 unsigned long long
#define coutfix(i) cout << fixed << setprecision(i)
using namespace std;
int main()
{
int64 nn;
cin >> nn;
vector<int64> aa(nn);
for(int64 ii = 0;ii < nn;ii++)
{
cin >> aa[ii];
}
sort(aa.begin(), aa.end());
int64 ans = 0, sum = 0;
for(int64 ii = 0;ii < nn - 1;ii++)
{
sum += aa[ii];
if(aa[ii + 1] <= 2 * sum)
{
ans++;
}
else
{
ans = 0;
}
}
if(aa[nn - 1] > sum * 2)
{
cout << 1 << endl;
}
else
{
cout << ans + 1 << endl;
}
return 0;
} | 1 | 15,382,206 |
#include<bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
typedef long long ll;
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define REP(i,num,n) for(int i=num, i##_len=(n); i<i##_len; ++i)
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; }
#define print(x) (cout << (x) << endl)
#define pb push_back
#define mp make_pair
#define sz(x) int(x.size())
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
#define fs first
#define sc second
template<typename T> vector<T> make_vec(size_t n, T a) { return vector<T>(n, a); }
template<typename... Ts> auto make_vec(size_t n, Ts... ts) { return vector<decltype(make_vec(ts...))>(n, make_vec(ts...)); }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &v) { for (auto &e : v) os << e << ' '; return os; }
#include <boost/rational.hpp>
#include <boost/multiprecision/cpp_int.hpp>
using boost::rational;
using boost::multiprecision::cpp_int;
const double PI = acos(-1);
const int INF = 1e9;
const ll LLINF = 1e16;
const ll MOD = 1e9+7;
template<class T> inline void add(T &a, T b){a = ((a+b) % MOD + MOD) % MOD;};
ll stringcount(string s, char c) {
return count(s.cbegin(), s.cend(), c);
}
template<typename T>
T rp(T a, T b) {
return (a + b - 1) / b;
}
template<typename T>
T digsum(T n) {
T res = 0;
while(n > 0) {
res += n%10;
n /= 10;
}
return res;
}
bool kai (string s) {
string t{s};
reverse(begin(t), end(t));
return s == t;
}
using pint = pair<int, int>;
using pll = pair<ll, ll>;
vector<string> split(const string &s, char delim) {
vector<string> elems;
string item;
for (char ch: s) {
if (ch == delim) {
if (!item.empty())
elems.push_back(item);
item.clear();
}
else {
item += ch;
}
}
if (!item.empty())
elems.push_back(item);
return elems;
}
int main(void)
{
cout.tie(0);
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
double w,h,x,y;
cin >> w >> h >> x >> y;
double mw = w / 2;
double mh = h / 2;
if(mw == x && mh == y){
cout << w * h / 2 << " " << 1 << endl;
} else {
cout << w * h / 2 << " " << 0 << endl;
}
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(int i=0;i<(n);i++)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define all(v) v.begin(),v.end()
#define len(x) (ll)(x).length()
#define maxs(x,y) x = max(x,y)
#define mins(x,y) x = min(x,y)
#define pb push_back
#define sz(x) (int)(x).size()
#define v(T) vector<T>
#define vv(T) vector<vector<T>>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
ll gcd(ll a,ll b){if(a%b==0){return b;}else{return(gcd(b,a%b));}}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
const int INF=1e9;
const ll INFS=1e18;
const int MOD=INF+7;
const int di[] = {-1,0,1,0};
const int dj[] = {0,-1,0,1};
const double PI=acos(-1);
int main() {
ll w,h,x,y;
cin>>w>>h>>x>>y;
double ans=0;
if(w%2==0&&h%2==0){
if(w/2==x&&h/2==y){
ans=(double)w*h/2;
cout<<ans<<" 1"<<endl;
return 0;
}
}
ans=(double)w*h/2;
cout<<ans<<" 0"<<endl;
} | 1 | 55,286,122 |
#include<iostream>
using namespace std;
int main() {
char String[1200];
cin.getline(String, sizeof(String));
for (int i = 0; String[i] != '\0'; i++) {
if ('a' <= String[i] && String[i] <= 'z') {
String[i] += 'A' - 'a';
}
else if ('A' <= String[i] && String[i] <= 'Z') {
String[i] += 'a' - 'A';
}
}
cout << String << endl;
return 0;
} | #include<cstdio>
#include<cctype>
int main() {
char c;
for(;;) {
scanf("%c", &c);
if( isalpha(c) ) {
if( islower(c) ) {
printf("%c", toupper(c));
} else {
printf("%c", tolower(c));
}
} else {
printf("%c", c);
}
if(c == '\n') break;
}
return 0;
} | 1 | 99,465,790 |
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <stack>
#include <vector>
#include <set>
#include <utility>
#include <functional>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main(){
ll n,m,d;
cin >> n >> m >> d;
if(d == 0){
printf("%.14lf\n",(double)(m-1)/n);
}
else{
printf("%.14lf\n",(double)(m-1)*2*(n-d)/(n*n));
}
} | #pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
constexpr int MOD=998244353;
#define INF (1<<30)
#define LINF (lint)(1LL<<56)
#define endl "\n"
#define rep(i,n) for(lint (i)=0;(i)<(n);(i)++)
#define reprev(i,n) for(lint (i)=(n-1);(i)>=0;(i)--)
#define Flag(x) (1<<(x))
#define Flagcount(x) __builtin_popcount(x)
#define pint pair<int,int>
#define pdouble pair<double,double>
#define plint pair<lint,lint>
#define fi first
#define se second
typedef long long lint;
int dx[8]={1,1,0,-1,-1,-1,0,1};
int dy[8]={0,1,1,1,0,-1,-1,-1};
const int MAX_N=2e5+5;
int main(void){
lint n,m,d;
cin >> n >> m >> d;
cout << (d?2:1)*(n-d)*(m-1)/pow(n,2) << endl;
} | 1 | 92,214,938 |
#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() {
string s;
cin >> s;
int n;
cin >> n;
string ans;
for (int i = 0; i < s.size(); i += n) {
ans.push_back(s[i]);
}
cout << ans << endl;
} | #include <ext/pb_ds/assoc_container.hpp>
#include <bits/stdc++.h>
using namespace std;
using namespace __gnu_pbds;
template <class c, class cmp = less<c> > using ordered_set = tree<c, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << std::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
template<class T> ostream& operator<<(ostream &os, vector<T> V) {os << "[ "; for(auto v : V) os << v << " "; return os << "]";}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {return os << "(" << P.first << "," << P.second << ")";}
template <typename T,typename U>pair<T,U> operator+(const pair<T,U> & l,const std::pair<T,U> & r) { return {l.first+r.first,l.second+r.second};}
typedef long long int ll;
const ll mod =1e18;
const int maxn = 300002;
#define endl '\n'
#define int ll
#define ld long double
#define all(x) (x).begin(),(x).end()
int32_t main()
{
IOS
string s;
cin>>s;
int n = s.size();
int k ;
cin>>k;
for(int i = 0;i<n;i+=k){
cout<<s[i];
}
} | 1 | 80,564,588 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b, c;
cin >> a >> b >> c;
int g = 1;
for (int i = min(a, b); i > 0; i--)
{
if (a % i == 0 && b % i == 0)
{
g = i;
break;
}
}
if (c % g == 0)
{
puts("YES");
}
else
{
puts("NO");
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int a = A % B;
for (int i = 2; i < 1000000; i++){
int b = (A * i) % B;
if (b == C){
cout << "YES" << endl;
return 0;
}
if (b == a){
cout << "NO" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
} | 1 | 1,355,869 |
#include<cstdio>
#include<vector>
#include<algorithm>
#include<utility>
#include<numeric>
#include<iostream>
#include<array>
#include<string>
#include<sstream>
#include<stack>
#include<queue>
#include<list>
#include<functional>
#define _USE_MATH_DEFINES
#include<math.h>
#include<map>
#define SENTINEL 1000000001
#define min(a,b) ((a)>(b)?(b):(a))
#define max(a,b) ((a)>(b)?(a):(b))
#define INF 200000000000
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
struct OwnEdge
{
ll from, to, cost;
OwnEdge() :from(-1), to(-1), cost(-1) {}
OwnEdge(ll from, ll to, ll cost) : from(from), to(to), cost(cost) {}
};
OwnEdge edges[10000];
ll tod[100][100];
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int V, E;
scanf("%d %d", &V, &E);
for (int i = 0; i < V; i++)for (int j = 0; j < V; j++)
{
tod[i][j] = INF;
}
for (int i = 0; i < E; i++)
{
int s, t, d;
scanf("%d %d %d", &s, &t, &d);
edges[i] = OwnEdge(s, t, d);
}
for (int k = 0; k < V; k++)
{
tod[k][k] = 0;
bool ns = false;
for (int i = 0; i < V; i++)
{
for (int j = 0; j < E; j++)
{
OwnEdge t = edges[j];
if (tod[k][t.from] != INF&&tod[k][t.to]>(tod[k][t.from] + t.cost))
{
tod[k][t.to] = (tod[k][t.from] + t.cost);
if (i == (V - 1))
{
ns = true;
}
}
}
}
if (ns)
{
printf("NEGATIVE CYCLE\n");
return 0;
}
}
for (int i = 0; i < V; i++)
{
for (int j = 0; j < V; j++)
{
if (j == 0)
{
printf(tod[i][j] == INF ? "INF" : "%lld", tod[i][j]);
}
else
{
printf(tod[i][j] == INF ? " INF" : " %lld", tod[i][j]);
}
}
printf("\n");
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
long long n, e; cin >> n >> e;
vector<vector<long long> > g(n + 1, vector<long long> (n + 1, 1000000000000));
for(long long i = 0; i < n; i++) g[i][i] = 0;
for(long long i = 0; i < e; i++){
long long a, b, d; cin >> a >> b >> d;
g[a][b] = min(g[a][b], d);
}
for(long long k = 0; k < n; k++){
for(long long i = 0; i < n; i++){
for(long long j = 0; j < n; j++){
if(g[i][k] != 1000000000000 && g[k][j] != 1000000000000) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
if(i == j && g[i][j] < 0) return !printf("NEGATIVE CYCLE\n");
}
}
}
for(long long i = 0; i < n; i++){
for(long long j = 0; j < n; j++){
if(g[i][j] == 1000000000000) cout << "INF";
else cout << g[i][j];
if(j != n - 1) cout << " ";
else cout << endl;
}
}
} | 1 | 44,579,227 |
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define int long long
#define all(a) a.begin(), a.end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e15;
int d[100010];
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int k = -1;
for(int i = 1; i * i <= 2 * n; i++){
if(i * (i + 1) == 2 * n){
k = i + 1; break;
}
}
if(k == -1){
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
cout << k << endl;
int now = 1;
vector<vector<int> > ans(k, vector<int>());
rep(i, 0, k){
rep(j, 0, i){
ans[i].push_back(d[j]);
d[j]++;
}
d[i] = now;
rep(j, 0, k - 1 - i){
ans[i].push_back(now);
now++;
}
}
rep(i, 0, ans.size()){
cout << k - 1 << " ";
for(int ii = 0; ii < ans[i].size(); ii++){
if(ii) cout << ' ';
cout << ans[i][ii];
}
cout << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int n,pd,a[2010][2010],ji;
int main()
{
scanf("%d",&n);
for(int i=1;i*(i-1)<=2*n;++i)
{
if(i*(i-1)==2*n)
{
pd=i;
break;
}
}
if(pd==0)
printf("No\n");
else
{
printf("Yes\n");
printf("%d\n",pd);
for(int i=1;i<=pd-1;++i)
a[1][i]=i;
ji=pd-1;
for(int i=2;i<=pd;++i)
{
for(int j=1;j<i;++j)
a[i][j]=a[j][i-1];
for(int j=i;j<=pd-1;++j)
a[i][j]=++ji;
}
for(int i=1;i<=pd;++i)
{
printf("%d ",pd-1);
for(int j=1;j<=pd-1;++j)
printf("%d ",a[i][j]);
printf("\n");
}
}
return 0;
} | 1 | 58,715,632 |
#include <iostream>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <cctype>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <stdlib.h>
#include <tuple>
#include <iomanip>
#include <iterator>
#include <stdio.h>
#include <fstream>
#include <time.h>
#include <bit>
#include <bitset>
#include <cstdint>
using namespace std;
const double PI = 3.14159265358979323846;
const long long int MOD = 1000000000 + 7;
using ll = long long;
struct UnionFind {
vector<int> parent;
UnionFind(int N) : parent(N) {
for (int i = 0; i < N; i++) {
parent[i] = -1;
}
}
int root(int i) {
if (parent[i] < 0) {
return i;
}
return (parent[i] = root(parent[i]));
}
bool unite(int from, int to) {
int rx = root(from);
int ry = root(to);
if (rx != ry) {
parent[ry] += parent[rx];
parent[rx] = ry;
return true;
}
else {
return false;
}
}
bool same(int x, int y) {
return root(x) == root(y);
}
int treeSize(int x) {
return -parent[root(x)];
}
};
long long int modpow(long long int base, long long int pow, long long int mod) {
if (pow == 1) {
return base;
}
else if (pow == 0) {
return 1;
}
if (pow % 2 == 0) {
auto temp = modpow(base, pow / 2, mod);
return (temp * temp) % mod;
}
else {
return (base * modpow(base, pow - 1, mod)) % mod;
}
}
long long int moddiv(long long int X, long long int Y, long long int mod) {
auto fermatDiv = modpow(Y, mod - 2, mod);
return (X * fermatDiv) % mod;
}
long long modCombination(long long left, long long right, long long int mod) {
long long answer = 1;
if (left > right) {
for (long long i = 0; i < right; i++) {
answer = (answer * (left - i)) % mod;
answer = moddiv(answer, (i + 1), mod);
}
}
return answer;
}
bool IsPrime(long long N) {
if (N == 1) {
return false;
}
for (long long i = 2; i * i <= N; i++) {
if (N % i == 0) {
return false;
}
}
return true;
}
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;
}
res.push_back({ a, ex });
}
if (N != 1) res.push_back({ N, 1 });
return res;
}
vector<long long> enum_divisors(long long N) {
vector<long long> res;
for (long long i = 1; i * i <= N; ++i) {
if (N % i == 0) {
res.push_back(i);
if (N / i != i) res.push_back(N / i);
}
}
sort(res.begin(), res.end());
return res;
}
long long gcd(long long a, long long b) {
if (b > a) {
long long temp = b;
b = a;
a = temp;
}
long long c = a % b;
if (c == 0) {
return b;
}
else {
return gcd(b, c);
}
}
int main() {
ll N;
cin >> N;
vector<vector<ll>> route(N + 1);
map<pair<ll, ll>, ll> c;
for (ll i = 0; i < N - 1; i++) {
ll ta, tb, tc;
cin >> ta >> tb >> tc;
route[ta].push_back(tb);
route[tb].push_back(ta);
auto p = make_pair(max(ta, tb), min(ta, tb));
c[p] = tc;
}
ll Q, K;
cin >> Q >> K;
vector<ll> distanceFromK(N+1);
queue<ll> q;
queue<ll> distanceQ;
queue<ll> parent;
q.push(K);
parent.push(-1);
distanceQ.push(0);
while (!q.empty()) {
auto x = q.front();
auto distance = distanceQ.front();
auto parentNode = parent.front();
q.pop();
distanceQ.pop();
parent.pop();
for (auto y : route[x]) {
if (y != parentNode) {
q.push(y);
auto d = distance;
d += c[make_pair(max(y, x), min(y, x))];
distanceQ.push(d);
parent.push(x);
}
}
distanceFromK[x] = distance;
}
for (ll i = 0; i < Q; i++) {
ll x, y;
cin >> x >> y;
ll answer = distanceFromK[x] + distanceFromK[y];
cout << answer << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define rep(i, start, n) for (int i = (int)(start); i < (int)(n); ++i)
#define all(a) a.begin(), a.end()
#define mp(a, b) make_pair(a, b)
const int MOD = 1e9+7;
const int INF = 1001001001;
const ll llINF = 1e18+9;
vector<pii> edge[100010];
int main(){
int N;
cin >> N;
rep(i, 0, N-1){
int a, b, c;
cin >> a >> b >> c;
edge[a-1].push_back(mp(b-1, c));
edge[b-1].push_back(mp(a-1, c));
}
int Q, K;
cin >> Q >> K;
K--;
vector<ll> dist(N, llINF);
dist[K] = 0;
queue<pair<int, ll>> q;
q.push(mp(K, 0));
while (!q.empty()){
int now = q.front().first;
ll nowd = q.front().second;
q.pop();
for (auto x:edge[now]){
int fol = x.first;
ll d = x.second;
ll nextd = nowd+d;
if (dist[fol] < nextd) continue;
dist[fol] = nextd;
q.push({fol, nextd});
}
}
rep(i ,0 , Q){
int x, y;
cin >> x >> y;
--x, --y;
ll ans = dist[x] + dist[y];
cout << ans << endl;
}
} | 1 | 63,036,015 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main()
{
int a, b, c;
fscanf(stdin, "%d %d %d", &a, &b, &c);
double theta = c * M_PI / 180.0;
double S = 0.5 * a * b * sin(theta);
double L = a + b + sqrt(a * a + b * b - 2 * a * b * cos(theta));
double h = b * sin(theta);
fprintf(stdout, "%f\n", S);
fprintf(stdout, "%f\n", L);
fprintf(stdout, "%f\n", h);
return 0;
} | #include<cstdio>
#include<cmath>
int main(){
double a,b,c;
scanf("%lf %lf %lf",&a,&b,&c);
printf("%.7f\n",a*b*sin((M_PI*c/180))/2);
printf("%.7f\n",a+b+sqrt(pow(a,2)+pow(b,2)-2*a*b*cos((M_PI*c/180))));
printf("%.7f\n",b*sin((M_PI*c/180)));
} | 1 | 18,754,514 |
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <iomanip>
#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>
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
int Max(int(a), int(b), int(c)) {
return max(max(a, b), c);
}
int Min(int(a), int(b), int(c)) {
return min(min(a, b), c);
}
int main() {
int A, B;
cin >> A >> B;
if (A % B==0 ) {
A= -1;
}
cout << A<< endl;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define out(ans) cout << ans << endl;
const long long mod = 1e9 + 7;
int main(){
ll x,y;cin>>x>>y;
if(x%y==0){
out(-1);
return 0;
}
for(ll i=x;i<10e18;i+=x){
if(i%y!=0){
out(i);
break;
}
}
return 0;
} | 1 | 74,734,910 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define vec vector
#define fi first
#define se second
#define eb emplace_back
#define ef emplace_front
#define pof pop_front()
#define pob pop_back()
#define Rep(i,n) for(li i=0,nn=(li)(n);i!=nn;++i)
#define Rep1(i,n) for(li i=1,nn=(li)(n)+1;i!=nn;++i)
#define Size(v) (li)(v.size())
#define SortA(v) sort(v.begin(),v.end())
#define SortD(v) sort(v.rbegin(),v.rend())
#define All(a) (a).begin(),(a).end()
#define Input(a) for(li ii=0,nn=(li)(a.size());ii!=nn;++ii){cin>>(a).at(ii);}
#define Input2(a,b) for(li ii=0,nn=(li)(a.size());ii!=nn;++ii){cin>>(a).at(ii)>>(b).at(ii);}
#define mp make_pair
using li = int64_t;
using intl = int64_t;
using vi = vec<li>;
using vb = vec<bool>;
using vvi = vec<vi>;
using qi = deque<li>;
using pi = pair<li,li>;
using vpi = vec<pi>;
using si = set<li>;
using vsi = vec<si>;
using mii = map<li,li>;
using vmii = vec<mii>;
vec<li> dx = {0, 1, 0, -1, 1, 1, -1, -1};
vec<li> dy = {1, 0, -1, 0, 1, -1, 1, -1};
constexpr li INF = 9223372036854775807;
void Yes(li b){
if(b)cout<<"Yes";
else cout<<"No";
}
void yes(li b){
if(b)cout<<"yes";
else cout<<"no";
}
int main(){
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cout.precision(16);
li N,A,B;
cin >>N>>A>>B;
li times = N/(A+B);
if(N%(A+B) < A){cout << times*A+N%(A+B);}
else{cout <<times*A+A;}
} | #include <bits/stdc++.h>
#include <cstdlib>
#include <cmath>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
int main(){
ll n;
ll a;
ll b;
ll x = 0;
ll y = 0;
ll ans = 0;
cin >> n >> a >> b;
x = n % (a+b);
y = n / (a+b);
if (x > a){
ans = y * a + a;
}
if (x <= a){
ans = y * a + x;
}
cout << ans;
return 0;
} | 1 | 30,070,637 |
#include <bits/stdc++.h>
#define ll long long int
#define forr(i,n) for(int i=0;i<n;i++)
#define mod 1000000007
#define oo 100000000000000000
using namespace std;
void _sol(){
int n; cin >> n;
vector<ll> v(n);
for(auto &i: v) cin >> i;
ll ans = 0;
for(int i=1;i<n;i++){
if(v[i] < v[i-1]){
ans += v[i-1] - v[i];
v[i] = v[i-1];
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
_sol();
} | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} fast;
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
long long mod = 1000000007;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define rep(i, a, n) for (long long i = a; i < (n); i++)
long long modpow(long long m, long long n, long long modvalue) {
if (n == 0) return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2, modvalue);
return t * t % modvalue;
} else {
return modpow(m, n - 1, modvalue) * m % modvalue;
}
}
bool bitcheck(ll x, ll y) { return (x >> y) & 1; }
template <typename A, size_t N, typename T> void Fill(A (&array)[N], const T& val) {
std::fill((T*)array, (T*)(array + N), val);
}
long long moddiv(long long a, long long b, ll modvalue) { return (a * modpow(b, mod - 2, modvalue)) % modvalue; }
const ll INF = 1LL << 60;
void print_binary(long long a) {
for (int i = 31; i >= 0; i--) {
cout << (a >> i & 1);
}
cout << endl;
}
ll nCkmod(ll n, ll k, ll modvalue) {
ll numera = 1;
for (int i = n; i > n - k; i--) {
numera *= i;
numera %= modvalue;
}
ll denomi = 1;
REP(i, k) {
denomi *= (i + 1);
denomi %= modvalue;
}
return moddiv(numera, denomi, modvalue);
}
map<ll, ll> cnt;
void primeFactors(long long n) {
while (n % 2 == 0) {
cnt[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cnt[i]++;
n = n / i;
}
}
if (n > 2) {
cnt[n]++;
}
}
struct SegmentTree {
vector<ll> ar;
ll size = 1;
SegmentTree(int n) {
ar.resize(4 * n - 1, 0);
while (size < n) {
size *= 2;
}
}
void update(ll idx, ll x) {
ll k = size + idx;
ar[k] = x;
while (k != 1) {
k /= 2;
ar[k] = max(ar[k * 2], ar[k * 2 + 1]);
}
}
ll findinner(ll s, ll t, ll idx, ll be, ll en) {
ll mid = (be + en) / 2;
if (be == s && t == en) {
return ar[idx];
}
ll two = 0;
ll one = 0;
if (s < mid) {
two = findinner(s, min(t, mid), 2 * idx, be, mid);
}
if (t > mid) {
one = findinner(max(s, mid), t, 2 * idx + 1, mid, en);
}
return max(one, two);
}
ll find(ll s, ll t) { return findinner(s, t, 1, 0, size); }
};
ll LIS(vector<ll> as) {
vector<ll> bs(as);
sort(as.begin(), as.end());
map<ll, ll> cnt;
as.erase(unique(as.begin(), as.end()), as.end());
REP(i, as.size()) { cnt[as[i]] = i; }
SegmentTree sg(bs.size() + 1);
REP(i, bs.size()) { bs[i] = cnt[bs[i]]; }
for (int i = bs.size() - 1; i >= 0; i--) {
sg.update(bs[i], sg.find(bs[i] + 1, bs.size()) + 1);
}
return sg.find(0, bs.size());
}
int main() {
ll n;
cin >> n;
vector<ll> as(n);
REP(i, n) { cin >> as[i]; }
ll sum = 0;
rep(i, 1, n) {
if (as[i] < as[i - 1]) {
sum += (as[i - 1] - as[i]);
as[i] = as[i - 1];
}
}
cout << sum << endl;
} | 1 | 830,068 |
#include <bits/stdc++.h>
#define INF 1000000000000000001
#define ll long long
using namespace std;
int main()
{
string X, Y;
cin >> X >> Y;
ll x = X.size(), y = Y.size();
vector<vector<ll>> dp(x + 1, vector<ll>(y + 1, INF));
for (ll i = 0; i < x; ++i)
{
dp.at(i).at(0) = i;
}
for (ll j = 0; j < y; ++j)
{
dp.at(0).at(j) = j;
}
for (ll i = 0; i < x; ++i)
{
for (ll j = 0; j < y; ++j)
{
dp.at(i + 1).at(j + 1) = min(dp.at(i + 1).at(j + 1), dp.at(i + 1).at(j) + 1);
dp.at(i + 1).at(j + 1) = min(dp.at(i + 1).at(j + 1), dp.at(i).at(j + 1) + 1);
dp.at(i + 1).at(j + 1) = min(dp.at(i).at(j) + 1, dp.at(i + 1).at(j + 1));
if (X.at(i) == Y.at(j))
{
dp.at(i + 1).at(j + 1) = min(dp.at(i).at(j), dp.at(i + 1).at(j + 1));
}
}
}
cout << dp.at(x).at(y) << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main(){
string s, t; cin >> s >> t;
int N = s.size(), M = t.size();
vector<vector<int> > dp(N + 1, vector<int> (M + 1, INF));
for(int i = 0; i <= N; i++) dp[i][0] = i;
for(int i = 0; i <= M; i++) dp[0][i] = i;
for(int i = 1; i <= N; i++){
for(int j = 1; j <= M; j++){
dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + (s[i - 1] != t[j - 1]));
}
}
cout << dp[N][M] << endl;
} | 1 | 74,743,064 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))
template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
int main(void) {
vector<ll> A(3);
cin >> A[0] >> A[1] >> A[2];
sort(A.begin(), A.end());
ll ans = 0;
rep2(i, 1, 3) ans += abs(A[i] - A[i - 1]);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#include <vector>
using namespace std;
int min(int a, int b) {
return a < b ? a : b;
}
int main(void)
{
vector<int> a(3);
for (int i = 0; i < 3; ++i) {
cin >> a.at(i);
}
vector<int> dp(3);
sort(a.begin(), a.end());
dp.at(0) = 0;
for (int i = 1; i < 3; ++i) {
dp.at(i) = dp.at(i - 1) + abs(a.at(i) - a.at(i - 1));
}
cout << dp.at(2) << endl;
} | 1 | 74,464,128 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, n) for (int i = 1; i <= (int)(n); i++)
int64_t lucas(int64_t a, int64_t b, int n){
if (n == 0) return a;
if (n == 1) return b;
if (n == 2) return a + b;
int64_t res = a + b;
return lucas(b, res, n - 1);
}
int main(){
int N;
cin >> N;
int64_t a = 2;
int64_t b = 1;
cout << lucas(a, b, N) << endl;
} | #include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(void) {
int N;
scanf("%d", &N);
long long luca[100];
luca[0] = 2;
luca[1] = 1;
for (int i = 2; i <= N; i++) {
luca[i] = luca[i - 1] + luca[i - 2];
}
printf("%lld\n", luca[N]);
return 0;
} | 1 | 36,533,964 |
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define ld long double
#define INF 1000000000000000000
typedef pair<ll, ll> pll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int macnt = 0, ans = 0;
for (int i = 1; i <= N; i++) {
int cnt = 0;
int s = i;
while (s % 2 == 0) {
cnt++;
s /= 2;
}
if (cnt >= macnt)
macnt = cnt, ans = i;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
using P = pair<int, int>;
int main() {
int N;
cin >> N;
int ans = 1;
while (ans*2 <= N) ans *= 2;
cout << ans << endl;
return 0;
} | 1 | 86,694,078 |
#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;
template<typename key>
using ordered_set = tree<key, null_type, less<key>, rb_tree_tag, tree_order_statistics_node_update>;
#define F first
#define S second
#define T second.first
#define FIO ios_base::sync_with_stdio(0);cin.tie(0);
#define all(v) v.begin(),v.end()
#define OO 0x3f3f3f3fLL
#define INF 0x3f3f3f3f3f3f3f3fLL
#define sz(s) (int)(s.size())
#define RT(s) return cout<<s,0
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pii;
typedef pair<ll,pair<ll,ll>> piii;
const int N = 2e5+5, M= 20, mod = 1000000000;
const double EPS = 1e-10;
int main(){
FIO
string s, t;
cin>>s>>t;
int ans = 0;
for(int i=0; i<sz(s); i++){
if(s[i] != t[i])ans++;
}
cout<<ans;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
int mod=1000000007;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
string s,t;
cin>>s>>t;
int ans=0;
for(int i=0; i<s.size(); i+=1){
if(s[i]!=t[i]){ans++;}
}
cout<<ans;
return 0;
} | 1 | 33,035,538 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int INF = 1000000000;
#define REP(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
#define rep(i,n) REP(i, 0, n)
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
map<string, int> ac;
ac["lu"] = ac["ru"] = 1;
ac["ld"] = ac["rd"] = -1;
int N;
while(cin >> N && N){
int sum = 0, cnt = 0;
bool climbed = false;
rep(i, N){
string a; cin >> a;
sum += ac[a];
if(sum == 2 && !climbed){
climbed = true;
cnt++;
}
if(sum == 0 && climbed){
climbed = false;
cnt++;
}
}
cout << cnt << endl;
}
return 0;
} | #include<iostream>
#include<string.h>
using namespace std;
int main()
{
int N;
while (cin >> N && N != 0)
{
char f[3];
char preF[3] = { 'a', 'a', '\0' };
int right = 0;
int left = 0;
int count = 0;
for (int i = 0; i < N; i++)
{
cin >> f;
if (strcmp(f, "lu") == 0)
{
if (right == 1 && strcmp(preF, "ld") != 0)count++;
strcpy(preF, f);
left = 1;
}
else if (strcmp(f, "ru") == 0)
{
if (left == 1 && strcmp(preF, "rd") != 0)count++;
strcpy(preF, f);
right = 1;
}
else if (strcmp(f, "ld") == 0)
{
if (right == 0 && strcmp(preF, "lu") != 0)count++;
strcpy(preF, f);
left = 0;
}
else if (strcmp(f, "rd") == 0)
{
if (left == 0 && strcmp(preF, "ru") != 0)count++;
strcpy(preF, f);
right = 0;
}
}
cout << count << endl;
}
return 0;
} | 1 | 57,973,438 |
#include<bits/stdc++.h>
#define N 100005
#define LL long long
using namespace std;
vector<int> G[N];
int n,a[N],d[N],rt;
void GG(){ printf("NO"); exit(0);}
void dfs(int t,int fa)
{
int i; LL Max=0,x,sum=0;
if(d[t]==1) return ;
for(i=0;i<G[t].size();i++)
if(G[t][i]!=fa) dfs(G[t][i],t);
for(i=0;i<G[t].size();i++)
if(G[t][i]!=fa)
sum+=a[G[t][i]],Max=max(Max,1LL*a[G[t][i]]);
x=sum-a[t];
if(x<0||2*x>sum) GG();
if(Max*2>sum&&x>sum-Max) GG();
a[t]=sum-2*x;
}
int main()
{
int i,x,y;
scanf("%d",&n);
for(i=1;i<=n;i++) scanf("%d",&a[i]);
for(i=1;i<n;i++){
scanf("%d %d",&x,&y);
G[x].push_back(y),d[x]++;
G[y].push_back(x),d[y]++;
}
for(i=1;i<=n;i++)
if(d[i]!=1) rt=i;
if(rt==0){
if(a[1]!=a[2]) GG();
else printf("YES");
return 0;
}
dfs(rt,0);
if(a[rt]!=0) GG();
printf("YES");
return 0;
} | #include<cstdio>
#include<algorithm>
#define fo(i,a,b) for(i=a;i<=b;i++)
using namespace std;
const int maxn=100000+10;
int h[maxn],go[maxn*2],nxt[maxn*2],fa[maxn],d[maxn],a[maxn];
int i,j,k,l,t,n,m,tot,root;
bool czy;
void add(int x,int y){
d[y]++;
go[++tot]=y;
nxt[tot]=h[x];
h[x]=tot;
}
void dfs(int x,int y){
if (d[x]==1){
fa[x]=a[x];
return;
}
int t=h[x];
fa[x]=2*a[x];
while (t){
if (go[t]!=y){
dfs(go[t],x);
fa[x]-=fa[go[t]];
}
t=nxt[t];
}
}
void dg(int x,int y){
if (d[x]==1) return;
int t,l=0;
if (fa[x]>a[x]) czy=0;
else{
t=h[x];
while (t){
if (go[t]!=y){
if (fa[go[t]]>a[x]-fa[x]) l+=(fa[go[t]]+fa[x]-a[x]);
}
t=nxt[t];
}
if (l>fa[x]) czy=0;
}
t=h[x];
while (t){
if (go[t]!=y) dg(go[t],x);
t=nxt[t];
}
}
int main(){
scanf("%d",&n);
fo(i,1,n) scanf("%d",&a[i]);
fo(i,1,n-1){
scanf("%d%d",&j,&k);
add(j,k);add(k,j);
}
if (n==2){
if (a[1]==a[2]) printf("YES\n");else printf("NO\n");
return 0;
}
fo(i,1,n)
if (d[i]>1) break;
root=i;
dfs(root,0);
if (fa[root]){
printf("NO\n");
return 0;
}
czy=1;
dg(root,0);
if (czy) printf("YES\n");else printf("NO\n");
} | 1 | 61,451,976 |
#include<iostream>
#include<cstring>
#include<climits>
using namespace std;
int main(){
int n,k;
cin >>n>>k;
int arr[n];
for(int i=0;i<n;i++) cin>> arr[i];
int dp[n];
memset(dp,0,sizeof(dp));
dp[0] = 0;
int ans = 0;
for(int i = 1;i<n;i++){
dp[i] = INT_MAX;
for(int j=1;j<=k;j++){
if(i-j >=0)
dp[i] = min(abs(arr[i-j] - arr[i]) + dp[i-j], dp[i] );
}
}
cout << dp[n-1]<< endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int stone[100000+5];
int dp[100000+5];
int main(int argc, char const *argv[])
{
int N, K;
while(cin >> N >> K) {
memset(stone, 0, sizeof(stone));
memset(dp, 0, sizeof(dp));
for(int i=1; i<=N; i++){
cin >> stone[i];
}
dp[1] = 0;
dp[2] = abs(stone[2] - stone[1]);
for(int i=3; i<=N; i++){
dp[i] = 1e9;
for(int j=min(i-1,K); j>0; j--){
int temp = dp[i-j] + abs(stone[i] - stone[i-j]);
if(dp[i] > temp){
dp[i] = temp;
}
}
}
cout << dp[N] << endl;
}
return 0;
} | 1 | 48,689,392 |
#include<iostream>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
if(a>b){a=a+b;b=a-b;a=a-b;}
if(a>c){a=a+c;c=a-c;a=a-c;}
if(b>c){b=b+c;c=b-c;b=b-c;}
cout<<a<<' '<<b<<' '<<c<<endl;
return 0;
} | #include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main(){
#ifdef CIN
ifstream cin("input.txt");
ofstream cout("output.txt");
#endif
int a, b, c;
int i;
cin >> a >> b >> c;
if (a > b)
{
a ^= b ^= a ^= b;
}
if (b > c)
{
b ^= c ^= b ^= c;
}
if (a > b)
{
a ^= b ^= a ^= b;
}
cout << a << " " << b << " " << c << endl;
return 0;
} | 1 | 89,694,978 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define pii pair<ll,pair<ll,char>>
#define sorted(a_1) sort(a_1.begin(),a_1.end())
#define rsorted(a_1) sort(a_1.rbegin(),a_1.rend())
#define t1(a_1) cout<<a_1<<endl;
#define t2(a_1) for(auto it_test : a_1) cout<<it_test<<" ";
#define MOD 1000000007
ll dp[101][100001];
ll topDown(vector<ll>&arr, ll index, ll k){
if(k==0) return 1LL;
if(index<0) return 0LL;
if(dp[index][k]>=0) return dp[index][k];
ll ways = 0;
for(ll i=min(arr[index],k);i>=0;i--){
ways+=topDown(arr,index-1, k-i)%MOD;
ways%=MOD;
}
dp[index][k] = ways;
return ways;
}
void solve(){
ll n,k;
cin>>n>>k;
vector<ll>arr(n),cnt(n+1,0);
for(auto &i : arr) cin>>i;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i=1;i<=k;i++) dp[0][i] += dp[0][i-1];
for(int i=1;i<=n;i++){
for(int j=0;j<=k;j++){
if(j-arr[i-1]>0){
dp[i][j] = ((dp[i-1][j]%MOD - dp[i-1][j-arr[i-1]-1]%MOD) + MOD)%MOD;
}
else
dp[i][j] = dp[i-1][j]%MOD;
}
for(int j=1;j<=k;j++) {
dp[i][j]+=dp[i][j-1];
dp[i][j]%=MOD;
}
}
t1((dp[n][k] - dp[n][k-1]+MOD)%MOD);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t=1;
while(t--){
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
cin >> n >> k;
int a[n];
long dp[k+1] = {0}, m = 1000000007;
for(i = 0; i < n; ++i)
cin >> a[i];
for(j = 0; j <= a[0]; ++j)
dp[j] = 1;
for(i = 1; i < n; ++i) {
for(j = 0; j < k; ++j)
dp[j+1] = (dp[j] + dp[j+1]) % m;
for(j = k; j >= 0; --j)
if(j-a[i]-1 >= 0)
dp[j] = (dp[j] - dp[j-a[i]-1] + m) % m;
}
cout << dp[k] % m;
return 0;
} | 1 | 78,563,444 |
#include<iostream>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
cout << a/b << " ";
cout << a%b << " ";
double a1,b1;
a1 = static_cast<double>(a);
b1 = static_cast<double>(b);
cout << fixed << a1/b1 << endl;
return 0;
} | #include <iostream>
#include <iomanip>
int main()
{
int a, b;
std::cin >> a >> b;
int d = a / b;
int r = a % b;
double f = static_cast<double>(a) / b;
std::cout << d << " " << r << " " << std::fixed << std::setprecision(5) << f << std::endl;
} | 1 | 73,171,412 |
#include <bits/stdc++.h>
using namespace std;
#include <iostream>
int v[101];
int main(){
int N,M;
int P;
while(cin >>N>>M>>P){
if (N == 0 && M == 0 && P == 0) break;
int NUMP = 0;
int ans = 0;
for(int i = 0;i < N ; i++){
cin >>v[i];
NUMP += v[i];
}
if(v[M-1] == 0){
ans = 0;
cout <<ans<<endl;
}
else{
cout <<100*NUMP*(100-P)/(100*v[M-1])<<endl;
}
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main (void) {
while (1) {
int n, m, p;
cin >> n >> m >>p;
if (n == 0 && m ==0 && p == 0) break;
int x[n];
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> x[i];
sum += x[i];
}
int gold = sum * 100;
int rest = gold - (gold * p * 0.01);
if (x[m-1] != 0)
cout << rest/x[m-1] <<endl;
else
cout << 0 <<endl;
}
return 0;
} | 1 | 100,329,681 |
#include<stdio.h>
#include<iostream>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<algorithm>
#include<string.h>
#include<functional>
#include<limits.h>
#include<stdlib.h>
#include<cmath>
#include<cstring>
#include<set>
#include<climits>
using namespace std;
#define intmax INT_MAX
#define lmax LONG_MAX
#define uintmax UINT_MAX
#define ulmax ULONG_MAX
#define llmax LLONG_MAX
#define ll long long
#define rep(i,a,N) for((i)=(a);(i)<(N);(i)++)
#define rrp(i,N,a) for((i)=(N)-1;(i)>=(a);(i)--)
#define llfor ll i,j
#define sc(a) cin>>a
#define pr(a) cout<<a<<endl
#define pY puts("YES")
#define pN puts("NO")
#define py puts("Yes")
#define pn puts("No")
#define pnn printf("\n")
#define all(a) a.begin(),a.end()
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define size(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
const double pi=acos(-1);
ll cei(ll x,ll y){ll ans=x/y;if(x%y!=0)ans++;return ans;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
ll lcm(ll x,ll y){return x/gcd(x,y)*y;}
ll llpow(ll x,ll n){ll i,ans=1;rep(i,0,n)ans*=x;return ans;}
ll fact(ll x){ll i,ans=1;rep(i,0,x)ans*=(x-i);return ans;}
ll ncr(ll n,ll r){return fact(n)/fact(r)/fact(n-r);}
ll npr(ll n,ll r){return fact(n)/fact(n-r);}
bool prime(ll a){if(a<=1)return false;ll i;for(i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
ll fib(ll x){ll i,fibo[x+10];fibo[0]=1;fibo[1]=1;fibo[2]=1;rep(i,3,x+1)fibo[i]=fibo[i-1]+fibo[i-2];return fibo[x];}
ll dig(ll n){ll d=0,i=0;while(n/10>0){i++;d++;}return d;}
const int dx[4]={1,0,-1,0};const int dy[4]={0,1,0,-1};
llfor;
int main(){
ll n,k;
cin>>n;
k=(ll)sqrt(n)+(ll)1;
if(k>1000000000)k--;
ll c=k*k-n;
printf("0 0 %lld %lld %lld 1\n",c,k,k);
return 0;} | #include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <cstdio>
#include <cmath>
#include <tuple>
#include <iomanip>
#include <numeric>
#include <unordered_map>
#include <sstream>
#include<limits.h>
#include<float.h>
#include<list>
#include <array>
#include <complex>
#include<stdio.h>
#include<string.h>
#include <bitset>
#include<random>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 100010
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template<typename T> void DEBUG(T e){if(DEBUG_OUT == false)return; std::cout << e <<" ";}
template<typename T> void DEBUG(const std::vector<T>& v){if(DEBUG_OUT == false)return;for(const auto& e : v){std::cout<< e << " "; } std::cout << std::endl;}
template<typename T> void DEBUG(const std::vector<std::vector<T> >& vv){if(DEBUG_OUT == false)return;for(const auto& v : vv){ DEBUG(v); } }
template<class T,class... Ts> void DEBUG(T d, Ts... e){if(DEBUG_OUT == false)return;DEBUG(d);DEBUG(e...);}
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; abort();}}
template< typename T1, typename T2 > inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template< typename T1, typename T2 > inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
void solve(void)
{
int S;cin>>S;
int v = 1e9;
int x = (v - S%v)%v;
cout<<0<<" "<<0<<" "<<v<<" "<<1<<" "<<(v - S%v)%v<<" "<<(S+x)/v<<endl;
return;
}
int32_t main(int32_t argc, const char *argv[])
{
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(11);
solve();
return 0;
} | 1 | 13,179,189 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s; cin >> s;
string ans = "";
for (int i = 0; i < s.size(); i++) {
if (i % 2 == 0) {
ans += s[i];
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repI(i, d, n) for (int i = (d); i < (n); ++i)
#define reps1(i, n) for (int i = 1; i < (n); ++i)
using namespace std;
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; }
using ll = long long;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using M = map<int, int>;
using Ml = map<ll, ll>;
ll const INF = 1ll<<61;
double pi = 3.141592653589793238;
int main() {
string s;
string ans = "";
cin >> s;
for(ll i = 0; i < ll(s.size()); i += 2) ans += s[i];
cout << ans << endl;
return 0;
} | 1 | 79,142,952 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
struct edge {int to, cost; };
int dx[] = {-1, 1, 0, 0};
int dy[] = { 0, 0, 1, -1};
ll GCD(ll a, ll b){
if(b==0) return a;
else return GCD(b, a%b);
}
ll LCM(ll a, ll b){
if(a<b) swap(a,b);
return a/GCD(a,b)*b;
}
int par[200005];
int rank_[200005];
void init(int n){
for(int i=0; i<n; i++){
par[i] = i;
rank_[i] = 1;
}
}
int find(int x){
if(x==par[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(rank_[x]<rank_[y]){
par[x]=y;
rank_[y] += rank_[x];
rank_[x] = rank_[y];
}else{
par[y]=x;
rank_[x] += rank_[y];
rank_[y] = rank_[x];
}
}
int main(){
int n, m;
cin >> n >> m;
init(n);
for(int i=0; i<m; i++){
int a, b;
cin >> a >> b;
a--; b--;
unite(a, b);
}
int ans = 0;
for(int i=0; i<n; i++){
ans = max(ans, rank_[i]);
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize ("-ffloat-store")
#pragma GCC optimize ("-fno-defer-pop")
typedef long long int ll;
typedef long double ld;
ll mod = 1e9+7;
ll add(ll a, ll b){
a = a%mod;
b = b%mod;
return (mod+(a+b)%mod)%mod;
}
ll mul(ll a, ll b){
a = a%mod;
b = b%mod;
return (mod+(a*b)%mod)%mod;
}
ll solve(ll node, vector<ll> vec[], vector<ll> &flg){
flg[node] = 1;
ll cnt = 1;
for(ll i: vec[node]){
if(flg[i]==0){
cnt += solve(i, vec, flg);
}
}
return cnt;
}
int main(){
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, m;
cin>>n>>m;
vector<ll> vec[n+1];
vector<ll> flg(n+1, 0);
for(ll i=0;i<m;i++){
ll a, b;
cin>>a>>b;
a--;
b--;
vec[a].push_back(b);
vec[b].push_back(a);
}
ll ans = 0;
for(ll i=0;i<n;i++){
if(flg[i]==0){
ans = max(ans,solve(i, vec, flg));
}
}
cout<<ans<<endl;
} | 1 | 44,366,270 |
# include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template<class T>constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template<class T>constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char>T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char>T_char TU(T_char cX) { return toupper(cX); };
typedef pair<LL, LL> pii;
const int vy[] = { -1, -1, -1, 0, 1, 1, 1, 0 }, vx[] = { -1, 0, 1, 1, 1, 0, -1, -1 };
const int dx[4] = { 0,1,0,-1 }, dy[4] = { 1,0,-1,0 };
int popcnt(unsigned long long n) { int cnt = 0; for (int i = 0; i < 64; i++)if ((n >> i) & 1)cnt++; return cnt; }
int d_sum(LL n) { int ret = 0; while (n > 0) { ret += n % 10; n /= 10; }return ret; }
int d_cnt(LL n) { int ret = 0; while (n > 0) { ret++; n /= 10; }return ret; }
LL gcd(LL a, LL b) { if (b == 0)return a; return gcd(b, a%b); };
LL lcm(LL a, LL b) { LL g = gcd(a, b); return a / g*b; };
# define ALL(qpqpq) (qpqpq).begin(),(qpqpq).end()
# define UNIQUE(wpwpw) sort(ALL((wpwpw)));(wpwpw).erase(unique(ALL((wpwpw))),(wpwpw).end())
# define LOWER(epepe) transform(ALL((epepe)),(epepe).begin(),TL<char>)
# define UPPER(rprpr) transform(ALL((rprpr)),(rprpr).begin(),TU<char>)
# define FOR(i,tptpt,ypypy) for(LL i=(tptpt);i<(ypypy);i++)
# define REP(i,upupu) FOR(i,0,upupu)
# define INIT std::ios::sync_with_stdio(false);std::cin.tie(0)
int a[3], b[3];
int cnt[4];
int main(){
REP(i, 3){
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
cnt[a[i]]++;
cnt[b[i]]++;
}
int one = 2, two = 2;
REP(i, 4){
if(cnt[i] == 1)one--;
if(cnt[i] == 2)two--;
}
cout << (!one && !two ? "YES" : "NO") << endl;
} | #include <iostream>
#include <map>
int main()
{
std::map<int, int> s;
for (int i = 0; i < 6; i++) {
int a; std::cin >> a;
s[a]++;
}
bool b = true;
for (const auto& ss: s) {
if (ss.second >= 3) {
b = false;
}
}
std::cout << (b?"YES":"NO") << std::endl;
return 0;
} | 1 | 71,997,017 |
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <algorithm>
#include <ctime>
#define ll long long
#define vecvec(h, w, name) vector<vector<ll>> name(h, vector<ll>(w));
#define rep(init, i, n) for (ll i = init; i < (n); i++)
#define rev(s) reverse(s.begin(), s.end())
#define sor(v) sort(v.begin(), v.end())
#define PI 3.14159265358979323846264338327950L
using namespace std;
using vec = vector<ll>;
ll facctorialMethod(ll k);
ll modpow(ll a, ll n, ll mod);
ll gcd(ll a, ll b);
ll lcm(ll a, ll b);
struct UnionFind
{
vector<ll> d;
UnionFind(ll n = 0) : d(n, -1) {}
ll find(ll x)
{
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(ll x, ll y)
{
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(ll x, ll y) { return find(x) == find(y); }
ll size(ll x) { return -d[find(x)]; }
};
int main()
{
int clock_on = 0;
int time_clock = clock();
ll K;string S;
cin>>K>>S;
if(S.size()<=K){cout<<S<<endl;return 0;}
else{
cout<<S.substr(0,K)<<"..."<<endl;
}
if (clock_on == 1)
printf("Execution Time: %.4lf sec\n", 1.0 * (clock() - time_clock) / CLOCKS_PER_SEC);
return 0;
}
ll facctorialMethod(ll k)
{
ll sum = 1;
for (ll i = 1; i <= k; ++i)
{
sum *= i;
}
return sum;
}
ll modpow(ll a, ll n, ll mod)
{
ll res = 1;
while (n > 0)
{
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll gcd(ll a, ll b)
{
if (a % b == 0)
{
return b;
}
else
{
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b)
{
return a * b / gcd(a, b);
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int k;
string s, r;
cin >> k;
cin >> s;
if(s.length() <= k) {
cout << s;
} else {
r = s.substr(0,k).append("...");
cout << r;
}
return 0;
} | 1 | 37,237,954 |
#include<iostream>
using namespace std;
int main()
{
int N, H[250];
cin >> N;
for (int i = 0; i < N; i++)
cin >> H[i];
int k = 0;
while (k < N) {
cout << "node " << k + 1 <<": key = " << H[k] << ", ";
int l = (k + 1) / 2 - 1;
if (k!=0)
cout << "parent key = " << H[l]<<", ";
l = (k + 1) * 2-1;
if (l < N)
cout << "left key = " << H[l]<<", ";
l = (k + 1) * 2 ;
if (l < N)
cout << "right key = " << H[l] << ", ";
cout << endl;
k++;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
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; }
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
#define all(x) (x).begin(),(x).end()
ll tmp1,tmp2,tmp3;
const ll mod = 1000000007;
const int INF = 1e9;
const ll INFLONG = 1e18;
void swap(ll *x,ll *y){
ll tmp;
tmp = *x;
*x = *y;
*y = tmp;
}
int main(){
ll h;
cin >> h;
vector<ll> vec(h);
rep(i,h){
cin >> vec[i];
}
rep(i,h){
printf("node %d:",i+1);
printf(" key = %lld,",vec[i]);
if(i != 0){
printf(" parent key = %lld,",vec[(i-1)/2]);
}
if(i * 2 + 1 < h){
printf(" left key = %lld,",vec[i*2+1]);
}
if(i * 2 + 2 < h){
printf(" right key = %lld,",vec[i*2+2]);
}
cout << " " << endl;
}
} | 1 | 33,449,322 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define int ll
typedef pair<int,int> pii;
#define fi first
#define se second
#define Sort(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/4
#define INTINF INT_MAX/2
#define all(x) (x).begin(),(x).end()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define debug_vec(v) cerr<<#v<<":";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
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;}
const int MOD = 1000000007;
int n;
signed main(){
cin >> n;
vll f(n+1,1);
for(int i = 2;i <= n;i++){
int x = i;
while(1){
f[x]++;
x += i;
if(x > n)break;
}
}
int ans = 0;
for(int i = 1;i <= n;i++)ans += i*f[i];
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define _USE_MATH_DEFINES
#include <math.h>
#define rep(i,n) for(int i = 0;i < n;i++)
#define NIL = -1;
#define all(x) x.begin(),x.end()
const ll INF = 1LL<<60;
const ll mod = 1e9 + 7;
int digit(ll x) {
if (x / 10 == 0) return 1;
return digit(x / 10) + 1;
}
ll gcd(long long a,long long b) {
if (a < b) swap(a,b);
if (b == 0) return a;
return gcd(b,a%b);
}
ll lcm(ll a,ll b){
return ((a * b == 0)) ? 0 : (a / gcd(a,b) * b);
}
double DegreeToRadian(double degree){
return degree * M_PI / 180.0;
}
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
int main(){
int n;
cin >> n;
long long ans = 0;
for (int i = 1;i <= n;i++){
ll a = n / i;
ans += a*(a+1)/2*i;
}
cout << ans << endl;
return 0;
} | 1 | 42,489,225 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
int s;
cin >> s;
vector<int> S;
S.push_back(s);
int one = 0;
while (one < 2)
{
if (s % 2 == 0)
{
s /= 2;
}
else
{
s = (3 * s) + 1;
}
S.push_back(s);
if (s == 1)
{
one++;
}
}
for (int i = 0; i < S.size() - 1; i++)
{
for (int j = i + 1; j < S.size(); j++)
{
if (S[i] == S[j])
{
cout << j + 1 << endl;
return 0;
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int s;
cin >> s;
map<int, int> pos;
pos[s]++;
int a_buf, a = s;
int ans = 1;
while(1){
a_buf = a;
if (a_buf%2 == 0) a = a_buf/2;
else a = a_buf*3+1;
pos[a]++;
ans++;
if (pos[a] == 2) break;
}
cout << ans << endl;
return 0;
} | 1 | 75,823,939 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll>pll;
typedef pair<ll,pair<ll,ll>>plll;
#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));
#define vll(v) v.begin(),v.end()
#define all(x) x.rbegin(),x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int,vector<int>,greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))
#define bug cout<<"BUG"<<endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI =3.141592653589793238463;
bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.first > b.first);
}
ll lcm(ll a,ll b)
{
if(a==0 || b==0)return 0;
return a/__gcd(a,b)*b;
}
void input(ll ara[],ll n)
{
for(ll i=0; i<n; i++)cin>>ara[i];
}
void print(ll ara[],ll n)
{
for(ll i=0; i<n; i++)
cout<<ara[i]<<" ";
cout<<endl;
}
int main()
{
fastread();
ll i,j,n,m,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r,ans=0;
bool flag=false;
string str;
cin>>a>>b>>c;
a-=b;
cout<<c-min(c,a)<<endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int A,B,C;
cin>>A>>B>>C;
C -= A-B;
cout<<(C>0? C: 0)<<endl;
} | 1 | 45,564,248 |
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
const int MOD = 1e9 + 7;
const int INF = 1e18 + 9;
constexpr long double pi = 3.141592653589793238462643383279;
int main() {
long long n;
cin >> n;
long long x, y;
x = y = 0;
long long c;
c = 0;
bool flag = true;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (abs(x - a) + abs(y - b) > t - c) {
flag = false;
}
else if (abs(x - a) + abs(y - b) < t - c) {
if ((abs(x - a) + abs(y - b)) % 2 != 0) {
if (t - c % 2 == 0) flag = false;
}
else {
if (t - c % 2 != 0) flag = false;
}
}
x = a;
y = b;
c = t;
}
if (flag) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, t, x, y, i, j, T = 0, X = 0, Y = 0;
cin >> N;
string s = "Yes";
for (i = 0; i < N; i++) {
cin >> t >> x >> y;
T = t - T, X = abs(x - X), Y = abs(y - Y);
if (X + Y > T || (t + x + y) % 2 != 0) {
s = "No";
break;
}
}
cout << s << endl;
} | 1 | 70,085,675 |
#include <iostream>
#include <bits/stdc++.h>
#define rep(i,z) for(int i = 0; i<(int)(z); i++)
#define rep1(i,z) for(int i = 1; i<=(int)(z); i++)
using namespace std;
typedef long long ll;
const ll MOD=1e9+7;
using pear = pair<int,int>;
int main(){
long double l; cin>>l;
cout<< fixed << setprecision(7) << (l / 3) * (l / 3) * (l / 3)<<endl;
} | #include <bits/stdc++.h>
#define INF INT_MAX
#define ll long long
#define ull unsigned long long
#define rep(i,n) for(ll i=0; i<n; ++i)
#define FOR(i, s, e) for(ll i=s; i<e; ++i)
#define MOD 1000000007
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if(a>b) {a=b; return true;} return false;}
template<class T> inline bool chmax(T& a, T b) { if(a<b) {a=b; return true;} return false;}
int main() {
double L; cin >> L;
printf("%.12f\n", L/3*L/3*L/3);
} | 1 | 3,112,252 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define lvector vector<ll>
#define cvector vector<char>
#define svector vector<string>
#define lque queue<ll>
#define lpque priority_queue<ll>
#define dlpque priority_queue<ll,lvector,greater<ll>>
#define P pair<ll,ll>
#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()
#define rep(i,n) for(ll i=0; i<n; ++i)
#define print(a) cout << (a) << endl
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n,L;cin>>n>>L;
lvector A(n);rep(i,n) cin>>A[i];
ll x=-1;
rep(i,n-1) if(A[i]+A[i+1]>=L) {x=i+1;break;}
if(x==-1) print("Impossible");
else {
lvector ans;
rep(i,x-1) ans.emplace_back(i+1);
for(ll i=n-2;i>=x;--i) ans.emplace_back(i+1);
ans.emplace_back(x);
print("Possible");
rep(i,n-1) print(ans[i]);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define repp(i,m,n) for(int (i)=(m);(i)<(n);(i)++)
#define repm(i,n) for(int (i)=(n-1);(i)>=0;(i)--)
#define INF (1ll<<60)
#define all(x) (x).begin(),(x).end()
typedef long long lint;
const lint MOD =1000000007;
const lint MAX = 10000000;
using Graph =vector<vector<lint>>;
typedef pair<lint,lint> P;
lint fac[MAX], finv[MAX], inv[MAX];
void COMinit()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (lint 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(lint n, lint k)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint primary(lint num)
{
if (num < 2) return 0;
else if (num == 2) return 1;
else if (num % 2 == 0) return 0;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
{
return 0;
}
}
return 1;
}
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;
}
lint lcm(lint a,lint b){
return a/__gcd(a,b)*b;
}
lint gcd(lint a,lint b){
return __gcd(a,b);
}
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for(int i = 0; i < N; i++) par[i] = i;
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(){
lint n,l;
cin>>n>>l;
lint a[n];
rep(i,n)cin>>a[i];
lint max=a[0];
bool isp=false;
lint last;
rep(i,n-1){
max+=a[i+1];
if(max>=l){
last=i+1;
isp=true;
}
max-=a[i];
}
if(!isp){
cout<<"Impossible"<<endl;
}else{
cout<<"Possible"<<endl;
repp(i,1,last){
cout<<i<<endl;
}
for(int i=n-1;i>last;i--)cout<<i<<endl;
cout<<last<<endl;
}
} | 1 | 18,311,488 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<n; i++)
#define PI 3.14159265359
#define INF 1000100100
#define MOD 1000000007
#define all(x) (x).begin(),(x).end()
typedef long long ll;
#define P pair<int, int>
#define PP pair<P,int>
#define T tuple<int,int,int>
using namespace std;
int main(){
vector<int> aa(3);
cin>> aa[0] >> aa[1] >> aa[2];
sort(all(aa));
reverse(all(aa));
cout << aa[0]*10+aa[1]+aa[2];
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, a, n) for (ll i = a; i < (ll)n; ++i)
#define INF 10e7
#define MOD 1000000000 + 7
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
using namespace std;
int main(void)
{
vector<int> v(3);
rep(i, 0, 3) cin >> v[i];
sort(all(v), greater<int>());
cout << 10 * v[0] + v[1] + v[2] << endl;
} | 1 | 33,614,941 |
#include<stdio.h>
#include<algorithm>
using namespace std;
int a[100000+1];
int l[100000+1];
int main()
{
int n;
scanf("%d",&n);
for (int i=0;i<n;i++)
scanf("%d",&a[i]);
l[0]=a[0];
int chang=1;
for (int i=1;i<n;i++)
{
if(l[chang-1]<a[i]){
l[chang++]=a[i];
}else{
*lower_bound(l,chang+l,a[i])=a[i];
}
}
printf("%d\n",chang);
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
const int MAX = 1 << 30;
int main(void){
int n;
cin >> n;
vector<int> A(n);
vector<int> dp(n);
for(int i=0;i<n;i++){
cin >> A[i];
dp[i] = MAX;
}
for(int i=0;i<n;i++){
vector<int>::iterator it = lower_bound(dp.begin(), dp.end(), A[i]);
*it = A[i];
}
int count = 0;
for(int i=0;i<n;i++){
if(dp[i]<MAX){
count++;
} else{
break;
}
}
cout << count << endl;
} | 1 | 83,548,351 |
#include <iostream>
#include <vector>
#include <stack>
#include <math.h>
#include <string>
#include <cmath>
#include <iomanip>
int main();
int main(){
std::stack<int> input;
std::vector<int> output;
int dummy = 0;
int count = 0;
while (std::cin >> dummy){
if ((dummy == 0) && (!input.empty())){
output.push_back(input.top());
input.pop();
}
else if((1 <= dummy) && (dummy <= 10)){
input.push(dummy);
}
else{
}
}
for (int i = 0; i < output.size(); i++){
std::cout << output[i] << std::endl;
}
return 0;
} | #include <iostream>
#include <stack>
std::stack<int> st;
int main() {
int x = 0;
while(std::cin >> x) {
if(x == 0) {
int y = st.top();
st.pop();
std::cout << y << std::endl;
} else {
st.push(x);
}
}
} | 1 | 66,660,212 |
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main(){
int n;
string x;
while(cin >> n, n){
int l = 0, r = 0;
int res = 0;
int next = 1;
for(int i = 0;i < n;i++){
cin >> x;
if(x == "lu")l = 1;
if(x == "ru")r = 1;
if(x == "ld")l = 0;
if(x == "rd")r = 0;
if(l == next && r == next){
next ^= 1;
res++;
}
}
cout << res << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
int rc,lc;
int cnt;
string str;
int zen,now;
while(cin>>n,n){
rc=lc=0;
cnt=0;
for(int i=0;i<n;i++){
cin>>str;
if(str[0] == 'r')now = 0;
else now = 1;
if(str == "lu")lc++;
if(str == "ru")rc++;
if(str == "ld")lc--;
if(str == "rd")rc--;
if(lc == rc && zen != now)cnt++;
zen = now;
}
cout<<cnt<<endl;
}
} | 1 | 64,471,483 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,a[4][3][10],b,c,d,e;
cin>>n;
for(int x=0;x<4;x++) for(int y=0;y<3;y++) for(int z=0;z<10;z++) a[x][y][z]=0;
for(int i=0;i<n;i++){
cin>>b>>c>>d>>e;
a[b-1][c-1][d-1]+=e;
}
for(int x=0;x<4;x++){
for(int y=0;y<3;y++){
for(int z=0;z<10;z++) cout<<" "<<a[x][y][z];
cout<<endl;
}
if(x<3) cout<<"####################"<<endl;
}
return 0;
} | #include<iostream>
using namespace std;
int main() {
int n, b, f, r, v;
int count[5][4][11] = { 0 };
cin >> n;
for (int i = 0; i < n; i++) {
cin >> b >> f >> r >> v;
count[b][f][r] += v;
}
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= 3; j++) {
for (int k = 1; k <= 10; k++) {
cout << ' ' << count[i][j][k];
}
cout << "\n";
if (j == 3 && i != 4)
cout << "####################\n";
}
return 0;
} | 1 | 22,735,855 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A,B,C,K,sum=0;
cin >> A >> B >> C >> K;
for(int i=0;i<A;i++){
sum++;
K--;
if(K == 0) break;
}
if(K == 0){
cout << sum << endl;
return 0;
}
for(int i=0;i<B;i++){
K--;
if(K == 0) break;
}
if(K == 0){
cout << sum << endl;
return 0;
}
for(int i=0;i<C;i++){
sum--;
K--;
if(K == 0) break;
}
if(K == 0){
cout << sum << endl;
return 0;
}
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,k;
cin>>a>>b>>c>>k;
if (a + b >= k)
{
cout<<min(a, k);
}
else
{
cout<<a-(k-a-b);
}
return 0;
} | 1 | 28,211,190 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main(){
int N,K;
string S;
cin>>N>>S>>K;
char k = S[K-1];
for (int i(0);i<N;i++){
if (S[i] == k) continue;
S[i] = '*';
}
cout << S << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using P = pair<int, int>;
#define FOR(i, a, n) for(int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define pb(a) push_back(a)
#define all(x) (x).begin(),(x).end()
const int INF = (int)1e9;
const LL INFL = (LL)1e19;
const int MOD = 1e9 + 7;
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n;
string s;
cin >> s;
cin >> k;
REP(i, n)
{
if(s[k-1] != s[i]) s[i] = '*';
}
cout << s << endl;
} | 1 | 59,570,033 |
#include<bits/stdc++.h>
#define mod 1000000007
#define ll long long int
#define pb push_back
#define mk make_pair
#define pii pair<int,int>
#define pll pair<ll,ll>
#define frr(j,i,n) for(int i=j;i<=n;++i)
using namespace std;
int n;
int a[100005];
int dp[100005];
int go(int index)
{
if(index>=n)
return 0;
if(dp[index]!=-1)
return dp[index];
int x=abs(a[index]-a[index+1])+go(index+1);
int y=1e6;
if(index<n-1)
y=abs(a[index]-a[index+2])+go(index+2);
return dp[index]=min(x,y);
}
void solve()
{
cin>>n;
frr(1,i,n) cin>>a[i];
memset(dp,-1,sizeof(dp));
cout<<go(1)<<"\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t=1;
while(t--)
solve();
return 0;
} | #include<bits/stdc++.h>
#define MOD 1000000007
#define IO ios_base::sync_with_stdio(false);cin.tie(NULL);
#define forf(i,a,b) for(i=a;i<b;i++)
#define forr(i,a,b) for(i=a;i>b;i--)
#define mp make_pair
#define f first
#define s second
#define pb(x) push_back(x)
typedef long long int ll;
typedef std::vector<ll> vi;
#define input(vec,a,b) for(ll i =a;i<b;i++) cin>>vec[i]
#define print(vec,a,b) for(ll i=a;i<b;i++) cout<<vec[i]<<" " ;cout<<endl;
#define all(a) a.begin(),a.end()
using namespace std;
void solve(){
ll i,n;
cin>>n;
ll h[n],c[n];
for(i=0;i<n;i++)
cin>>h[i];
c[0]=0;
c[1]=abs(h[0]-h[1]);
for(i=2;i<n;i++)
{
c[i]=min(c[i-1]+abs(h[i]-h[i-1]),c[i-2]+abs(h[i]-h[i-2]));
}
cout<<c[n-1];
}
int main()
{
IO;
ll t=1;
while(t--)
{
solve();
}
return 0;
} | 1 | 41,085,850 |
#include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(),(x).end()
#define COUT(x) cout<<(x)<<"\n"
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define REP(i, n) for(int i=0;i<n;i++)
#define YES(x) cout<<(x?"YES":"NO")<<"\n"
#define Yes(x) cout<<(x?"Yes":"No")<<"\n"
#define dump(x) cout<<#x<<" = "<<(x)<<"\n"
#define endl "\n"
using G = vector<vector<int>>;
using M = map<int,int>;
using P = pair<int,int>;
using PQ = priority_queue<int>;
using PQG = priority_queue<int,vector<int>,greater<int>>;
using V = vector<int>;
using ll = long long;
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; }
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
int main() {
IOS;
int n; cin >> n;
vector<int> d(n); REP(i,n) cin >> d[i];
if (n%2) { COUT(0); return 0;}
sort(ALL(d));
int med = n/2-1;
COUT(d[med+1]-d[med]);
return 0;
} | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<string>
#include<cstring>
#include<algorithm>
#include<set>
#include<map>
#include<iomanip>
#define REP(i,n) for(int i=0;i<(n);i++)
#define EPS (1e-7)
#define INF (2e9)
using namespace std;
typedef long long int ll;
const ll MOD = 1000000007;
int N;
int d[100000];
int main(void){
cin >> N;
REP(i,N) cin >> d[i];
sort(d, d+N);
cout << d[N/2] - d[N/2 - 1] << endl;
return 0;
} | 1 | 70,452,554 |
#include <bits/stdc++.h>
using namespace std;
#define io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define rep(i,n) for (int i = 0; i < (n); ++i)
int main(void) {
io;
string a, t;
cin >> a >> t;
sort(a.begin(), a.end());
sort(t.rbegin(), t.rend());
cout << ((a < t)?"Yes":"No");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string str1, str2;
bool chk = false;
int index = 0;
cin >> str1 >> str2;
sort(str1.begin(), str1.end());
sort(str2.begin(), str2.end(), greater<int>());
if(str1 < str2) cout << "Yes";
else cout << "No";
} | 1 | 47,452,727 |
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n;
cin >> n;
vector<pair<int64_t, int>> numb(n);
for (auto & x: numb) {
cin >> x.first >> x.second;
}
int64_t sum = 0;
for (int i = n - 1; i > -1; --i) {
numb[i].first += sum;
if (numb[i].first % numb[i].second) {
int64_t upd = (numb[i].first / numb[i].second + 1) * numb[i].second - numb[i].first;
sum += upd;
}
}
cout << sum;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define BAI(_a, _b) ((_a - 1) / _b * _b + _b)
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
#define INF 1 << 30
const int mod = 998244353;
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll c(ll n, ll k) { ll a = 1; rep(i, 1, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }
int main() {
int n;
ll ans = 0;
cin >> n;
vector<int> a(n), b(n);
rep(i, 0, n)cin >> a[i] >> b[i];
for (int i = n - 1; i >= 0; i--) {
ans += (b[i] - (a[i] + ans) % b[i]) % b[i];
}
printf("%lld\n", ans);
return 0;
} | 1 | 55,337,195 |
#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
using namespace std;
using ll = long long;
using PII = pair<int, int>;
const int INF = numeric_limits<int>::max();
long long mod(long long val, long long m) {
long long res = val % m;
if (res < 0) res += m;
return res;
}
long long gcd(ll a, ll b)
{
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
long long lcm(ll a, ll b)
{
return a / gcd(a, b) * b ;
}
int main()
{
int n,k; cin >> n >> k;
vector<int> a(n);
int index, minn, tmp;
rep(i,n) {
cin >> tmp;
if (tmp == 1 ) {
index = i;
}
}
if (n <= k) {
cout << 1 << endl;
return 0;
}
cout << (n-2) / (k-1) + 1<< endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n,k;
cin>>n>>k;
int a[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
if(k==n)
{
cout<<1<<endl;
}
else
{
if((n-1)%(k-1)==0)cout<<(n-1)/(k-1);
else cout<<(n-1)/(k-1)+1<<endl;
}
return 0;
} | 1 | 40,984,858 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<P,ll> PLL;
typedef pair<P,P> PP;
typedef vector<ll> VECLL;
typedef vector<P> VECP;
typedef priority_queue<P,VECP,greater<P> > PQP;
typedef priority_queue<ll, VECLL, greater<ll> > PQll;
#define rep(i,a,n) for(ll i = a;i < n;i++)
#define rrep(i,a,n) for(ll i = n; i >= a;i--)
#define index_check(i,n) if(i > n-1 || i < 0) continue;
#define LINF (ll)1e18
#define INF (int)1e9
#define fs first
#define sc second
#include <bits/stdc++.h>
#define rep(i,a,n) for(ll i = a;i < n;i++)
typedef long long ll;
using namespace std;
int main(){
ll n,k;
cin >> n >> k;
ll a[n] = {};
rep(i,0,n) cin >> a[i];
ll memo = min(k, 50LL);
rep(i,0,memo){
ll b[n] = {};
rep(j,0,n){
ll left,right;
left = max(0LL,j-a[j]);
right = min(n-1,j+a[j]);
b[left]++;
if(right+1 < n) b[right+1]--;
}
rep(j,0,n){
if(j > 0) b[j] += b[j-1];
a[j] = b[j];
}
}
rep(i,0,n){
cout << a[i] << " ";
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main(){
int n, k; cin >> n >> k;
vector<int> a(n), b(n, 0);
for(int i = 0; i < n; i++){
scanf("%d", &a[i]);
}
for(int i = 0; i < min(k, 100); i++){
for(int j = 0; j < n; j++) b[j] = 0;
for(int j = 0; j < n; j++){
int left = max(0, j - a[j]);
b[left]++;
int right = a[j] + j;
if(right < n - 1) b[right + 1]--;
}
for(int j= 1; j < n; j++){
b[j] += b[j - 1];
}
a = b;
}
for(int i = 0; i < n; i++){
cout << b[i] << " ";
}
cout << endl;
} | 1 | 4,242,228 |
#include <iostream>
#include <stack>
#define REP(i,n) for(int i = 1; i < n; i++)
using namespace std;
int main() {
REP(i,10){
REP(j,10){
cout << i << "x" << j << "=" << i*j << endl;
}
}
} | #include <iostream>
int main(void)
{
const int minNum = 1;
const int maxNum = 9;
for (int i = minNum; i <= maxNum; i++) {
for (int j = minNum; j <= maxNum; j++) {
std::cout << i << "x" << j << "=" << i * j << std::endl;
}
}
return 0;
} | 1 | 55,222,477 |
#include <bits/stdc++.h>
using namespace std;
using P=pair<int,int>;
using ll=long long;
vector<bool> isprime(1000005);
void eratos(int n){
for(int i=0;i<n+1;i++){
isprime[i]=true;
}
isprime[0]=isprime[1]=false;
for(int i=2;i*i<=n;i++){
if(isprime[i]){
int j=i+i;
while(j<=n){
isprime[j]=false;
j=j+i;
}
}
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin>>n;
ll ans=0;
eratos(1000005);
for(ll i=2;i<1000006;i++){
if(!isprime[i]) continue;
ll j=i;
while(1){
if(n%j==0){
n/=j;
ans++;
j*=i;
}
else{
break;
}
}
while(n%i==0){
n/=i;
}
}
if(n!=1){
ans++;
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
#define endl "\n"
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
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;
}
const long long INF = 1e18;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
ll ans = 0;
for(ll i = 2; i * i <= N; i++) {
if(N % i != 0) continue;
ll num = 0;
while(N % i == 0) {
N /= i;
num++;
}
for(ll j = 1; ; j++) {
if(num >= j) {
num -= j;
ans++;
} else break;
}
}
if(N != 1) ans++;
cout << ans << endl;
return 0;
} | 1 | 70,890,339 |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
#define maxn 101000
int main()
{
int n,i;
scanf("%d%d",&n,&i);
printf("%d\n",n-i+1);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> pll;
const ll mod=1e9+7;
const ll inf=1LL<<61;
int main() {
ll n,i;
cin >> n >> i;
cout << n-i+1 << endl;
} | 1 | 28,239,753 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int A, B, K;
cin >> K >> A >> B;
int i = 0;
bool flag = false;
while (K * i <= B)
{
if (K * i >= A)
{
flag = true;
}
i++;
}
if (flag)
cout << "OK" << endl;
else
cout << "NG" << endl;
} | #include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <math.h>
using namespace std;
#define INF 10000000000
#define PI 3.141592653589793
int main() {
int k, a, b;
string ans = "NG";
cin >> k >> a >> b;
for (int i = a; i < b + 1; i++) {
if (i%k == 0) {
ans = "OK";
break;
}
}
cout << ans;
return 0;
} | 1 | 24,466,191 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int A,B,C;
cin >> A >> B >> C;
if(A<=C && C<=B) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
} | #include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
#include<set>
using namespace std;
int main()
{
int A, B, C;
cin >> A >> B >> C;
if (C >= A && B >= C) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
} | 1 | 30,041,609 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main()
{
string s, t, u;
int a, b;
cin >> s >> t >> a >> b >> u;
if (s.compare(u) == 0)
a--;
else
b--;
cout << a << " " << b << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string color1,color2;
int no1,no2;
string color;
cin>>color1>>color2>>no1>>no2>>color;
if(color==color1){
cout<<--no1<<" "<<no2<<endl;
}
else cout<<no1<<" "<<--no2<<endl;
return 0;
} | 1 | 99,767,626 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
string s;
cin >> s;
if(s[2] == s[3] && s[4] == s[5]) {
cout << "Yes" << "\n";
} else {
cout << "No" << "\n";
}
return 0;
} | #include <bits/stdc++.h>
#define FASTIO ios::sync_with_stdio(false);cin.tie(0);
#define ADD +
#define SUBTRACT -
#define MULTIPLY *
#define DIVIDE /
#define MOD %
#define INCREMENT(x) ++x
#define DECREMENT(x) --x
#define in(a,b) cin>>a>>b;
#define out(a,b) cout<<a<<endl<<b<<endl;
#define scan(a) scanf("%d",&a);
#define print(a) printf("%d\n",a);
#define scanii(a,b) scanf("%d %d",&a,&b);
#define printii(a,b) printf("%d\n%d\n",a,b);
#define scaniii(a,b,c) scanf("%d %d %d",&a,&b,&c);
#define pub push_back
#define pob pop_back
#define puf push_front
#define pof pop_front
#define ll long long
#define ull unsigned long long
#define sll signed long long
#define pi acos(-1)
#define mod 1000000007
#define TRUE 1
#define FALSE 0
#define ZERO 0
#define MP make_pair
#define F first
#define S second
#define f1(i,a) for(int i=0;i<a;++i)
#define f2(i,a) for(int i=a-1;i>=0;--i)
#define en puts("");
#define elif else if
typedef ll int lli;
typedef sll int slli;
typedef ull int ulli;
const int sz=10000;
using namespace std;
int clue();
int result();
void show();
bool check();
bool cmp(pair<int,int>p,pair<int,int>q) {
return p.second<q.second;
}
int main() {
int t;
t=1;
while(t-->0) {
clue();
}
return 0;
}
int clue() {
string s;
cin>>s;
if(s[2]==s[3]&&s[4]==s[5]) {
cout<<"Yes"<<endl;
}
else {
cout<<"No"<<endl;
}
return 0;
} | 1 | 80,019,219 |
#include<bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if(s.at(0) != 'A') {
cout << "WA" << endl;
return 0;
}
int n = s.size();
int count = 0;
for(int i=2; i<n-1; i++) {
if(s.at(i) == 'C') {
count++;
} else if(isupper(s.at(i))) {
cout << "WA" << endl;
return 0;
}
}
if(isupper(s.at(1)) || isupper(s.at(n-1))) {
cout << "WA" << endl;
return 0;
}
if(count == 1) {
cout << "AC" << endl;
} else {
cout << "WA" << endl;
}
} | #include<iostream>
using namespace std;
int main(){
string s;
cin>>s;
bool no=false;
if(s[0]!='A'){
no=true;
}
bool inside=false;
for(int i=1;i<s.size();i++)
{
if(s[i]>='A'&&s[i]<='Z'){
if(!inside&&s[i]=='C'&&(i>=2&&i<=s.size()-2)){
inside=true;
continue;
}
else{
no=true;
break;
}
}
}
if(no||!inside){
cout<<"WA"<<endl;
}
else{
cout<<"AC"<<endl;
}
} | 1 | 60,383,254 |
#include<iostream>
using namespace std;
int main()
{
int n,c=1,d;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
d=a[0];
for(int i=1;i<n;i++)
{
if(a[i]<=d)
{
c++;
d=a[i];
}
}
cout<<c<<endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
int p;
int num=200010;
int count=0;
for(int i=0; i<n; i++){
cin >> p;
if(p<=num){
count++;
num=min(num,p);
}
}
cout << count << endl;
} | 1 | 71,153,562 |
#include <iostream>
using namespace std;
int main() {
int s,h,n,i,a[5000];
while(true) {
cin >> n;
if (n==0) break;
for (i=0;i<n;i++) cin >> a[i];
s=0; h=-100000;
for (i=0;i<n;i++) {
s=(s+a[i]>=a[i]) ? s+a[i] : a[i];
h=(s > h) ? s : h;
}
cout << h << endl;
}
return 0;
} | #include<iostream>
#include<string>
using namespace std;
int a[5000];
int main(){
int n;
while(true){
cin>>n;
if(n==0)
break;
long long best=-1000000000;
for(int i=0;i<n;i++)
cin>>a[i];
for(int start=0;start<n;start++){
long long count=0;
for(int len=start;len<n;len++){
count+=a[len];
best=max(best,count);
}
}
cout<<best<<endl;
}
return 0;
} | 1 | 14,022,949 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int WA[105000];
bool AC[105000];
void solve() {
cin >> N >> M;
int WAnum = 0;
int ACnum = 0;
for(int i = 1; i <= N; i++) {
WA[i] = 0;
AC[i] = false;
}
while(M--) {
int p;
string S;
cin >> p >> S;
if(AC[p]) continue;
if(S == "AC") {
AC[p] = true;
ACnum++;
WAnum += WA[p];
} else if(S == "WA") {
WA[p]++;
}
}
cout << ACnum << " " << WAnum << endl;
return;
}
int main() {
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
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=1001001001;
vector<pair<int64_t,int64_t>>pppp(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
int N,M;
cin>>N>>M;
vector<int>WA(N);
vector<bool>AC(N,false);
int ac=0,wa=0;
for(int i=0;i<M;i++){
int p;
string s;
cin>>p>>s;
if(AC[p]){continue;}
if(s=="AC"){ac++;wa+=WA[p];AC[p]=true;}
if(s=="WA"){WA[p]++;}
}
cout<<ac<<" "<<wa<<endl;
return 0;
} | 1 | 60,992,603 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int,int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<string> > vvs;
typedef vector<vector<ll> > vvll;
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define irep(it, stl) for(auto it = stl.begin(); it != stl.end(); it++)
#define drep(i,n) for(int i = (n) - 1; i >= 0; --i)
#define fin(ans) cout << (ans) << '\n'
#define STLL(s) strtoll(s.c_str(), NULL, 10)
#define mp(p,q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
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;}
struct io{io(){ios::sync_with_stdio(false);cin.tie(0);}};
const int INF = INT_MAX;
const ll LLINF = 1LL<<60;
const ll MOD = 1000000007;
const double EPS = 1e-9;
int main() {
ld n,m,d;
cin>>n>>m>>d;
if(d==0){
printf("%.7Lf\n",(n-d)*(m-1)/(n*n));
} else {
printf("%.7Lf\n",2*(n-d)*(m-1)/(n*n));
}
} | #include<iostream>
#include<stdio.h>
#include<vector>
#include<float.h>
#include<iomanip>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<cmath>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<cassert>
#include<cmath>
#include<cstdint>
#define INF 1e9
#define rep(i,n)for(int i=0;(i)<(int)(n);i++)
#define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define vec(type,n) vector<type>(n)
#define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))
#define ALL(a) (a).begin(),(a).end()
#define chmin(a, b) a = min(a, b)
#define chmax(a, b) a = max(a, b)
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
const int MOD = 1e9 + 7;
int main(){
long double n, m, d;
cin >> n >> m >> d;
long double res = 2 * (n - d) / (n * n) * (m - 1);
if(d == 0)res = 1 / n * (m - 1);
cout << fixed << setprecision(10) << res << endl;
} | 1 | 18,170,573 |