code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 45
101M
|
|---|---|---|---|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <clocale>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
const int MOD = 1000000007;
const int INF = 1000000000;
const int NIL = -1;
const long long LINF = 1000000000000000000;
const double EPS = 1E-10;
template<class T, class S>
bool chmax(T &a, const S &b){
if(a < b){
a = b; return true;
}
return false;
}
template<class T, class S>
bool chmin(T &a, const S &b){
if(b < a){
a = b; return true;
}
return false;
}
int main(){
int N, A, B; std::cin >> N;
std::vector<int> AB(N);
long long sum(0);
for(int i(0); i < N; ++i){
std::cin >> A >> B;
sum -= B;
AB[i] = A + B;
}
std::sort(AB.rbegin(), AB.rend());
for(int i(0); i < N; i += 2)
sum += AB[i];
std::cout << sum << std::endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define forin(in, n) for(int i=0; i<n; i++) cin>>in[i]
#define forout(out, n) for(int i=0; i<n; i++) cout<<out[i]<<endl
int main(){
int K, S; cin>>K>>S;
int cnt=0;
for(int x=0; x<=K; x++){
for(int y=0; y<=K; y++){
if(x+ y+ max(0, S-x-y) ==S && S-x-y<=K){
cnt++;
}
}
}
cout<<cnt<<endl;
}
| 0 | 97,398,159 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1e5 + 5;
int n, i, x, y;
bitset<Nmax> erased, used;
vector<int> v[Nmax];
bool dfs(int node, int dad)
{
used[node] = 1;
for(auto it : v[node])
if(!used[it] && !dfs(it, node)) return 0;
if(!erased[node])
{
if(erased[dad] || !dad) return 0;
erased[dad] = erased[node] = 1;
}
return 1;
}
int main()
{
cin.sync_with_stdio(false);
cin >> n;
for(i=1; i<n; ++i)
{
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
cout << (dfs(1, 0) ? "Second" : "First") << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fastio ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL)
#define lli long long int
#define rep(i,n,z) for(int i=z;i<n;i++)
#define rrep(i,z) for(int i=z;i>=0;i--)
#define nl cout<<endl
#define vi vector<int>
#define vlli vector<long long int>
#define umap unordered_map
#define pb push_back
#define mp make_pair
#define ss second
#define ff first
#define ipair pair <int,int>
#define llipair pair <lli,lli>
#define pq priority_queue
#define displaymatrix(a,m,n) for(int i=0;i<m;i++){for(int j=0;j<n;j++)cout<<a[i][j]<<" ";cout<<endl;}
#define printarray(a,n) for(int i=0;i<n;i++){cout<<a[i]<<" ";}nl;
#define vinput(a,n) vlli a(n);rep(i,n,0)cin>>a[i]
#define ainput(a,n) rep(i,n,0)cin>>a[i]
#define SO(a) sort(a.begin(),a.end())
#define all(x) (x).begin(),(x).end()
#define SOP(a,comp) sort(a.begin(),a.end(),comp)
#define inf INT_MAX
#define endl '\n'
const int N = 1e7+ 5;
vlli a(N,1),ans(N,0);
int main()
{
fastio;
int n;
cin>>n;
rep(i,N,2){
for(int j = i; j < N; j+= i)a[j]++;
}
ans[1] = 1;
rep(i,N,2){
ans[i] += ans[i - 1];
ans[i] += i*1LL*a[i];
}
cout<<ans[n]<<endl;
}
| 0 | 76,665,751 |
#include<stdio.h>
#include<iostream>
using namespace std;
int main(){
long long int a[10],temp,i,j;
for(i=0;i<10;i++){
cin>>a[i];
}
for(i=0;i<10;i++){
for(j=0;j<10-i-1;j++){
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for(int i=10-1;i>6;i--){
cout<<a[i]<<"\n";
}
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
using namespace std;
#define rp(i,t) for(int i=0;i<(t);i++)
#define rep(i,s,t) for(int i=(s);i<=(t);i++)
#define rsp(i,s,t) for(int i=(s);i<(t);i++)
#define rrp(i,t,s) for(int i=(t);i>=(s);i--)
#define rcp(i,s,b,d) for(int i=(s);b;d)
#define mst(a,x) memset(a,x,sizeof(a))
#define INF 0x3f3f3f3f
#define N 200002
#define Dp puts("")
#define Dw printf
#define Ds printf("#")
typedef long long ll;
char ch,last;
ll n,a[N],sf[N],sb[N],ans;
inline void read(ll &x){x=ch=0;do{last=ch;ch=getchar();}while(ch<'0'||'9'<ch);do{x=x*10+ch-'0';ch=getchar();}while('0'<=ch&&ch<='9');if(last=='-')x=-x;}
int main(void)
{
read(n);
rep(i,1,n)read(a[i]),sf[i]=sf[i-1]+a[i];
rrp(i,n,1)sb[i]=sb[i+1]+a[i];
ans=abs(sf[1]-sb[2]);
rsp(i,2,n)ans=min(ans,abs(sf[i]-sb[i+1]));
printf("%lld",ans);
return 0;
}
| 0 | 18,178,759 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
ll a,b,c,k;
cin >> a >> b >> c >> k;
cout << k - (k > a ? k - a : 0 ) - (k > a + b ? k - (a + b) : 0) << endl;
}
|
#include <iostream>
using namespace std;
#define REP(i, n) for(int (i) = 0; (i) < (n); (i)++)
#define M 1000003
int T[M] = {0};
int h1(int key)
{
return key % M;
}
int h2(int key)
{
return 1 + (key % (M - 1));
}
int h(int key, int i)
{
return (h1(key) + i * h2(key)) % M;
}
void insert(int key)
{
int j, i = 0;
while(1){
j = h(key, i);
if(T[j] == 0){
T[j] = key;
return;
}else{
i++;
}
}
}
bool search(int key)
{
int j, i = 0;
while(1){
j = h(key, i);
if(T[j] == key)
return true;
else if(T[j] == 0 || i >= M)
return false;
else
i++;
}
}
int getChar(char ch)
{
if(ch == 'A')
return 1;
else if(ch == 'C')
return 2;
else if(ch == 'G')
return 3;
else if(ch == 'T')
return 4;
else
return 0;
}
int getKey(string str)
{
int sum = 0, p = 1;
REP(i, str.size()){
sum += p * (getChar(str[i]));
p *= 5;
}
return sum;
}
int main()
{
int n;
cin >> n;
string c, s;
REP(i, n){
cin >> c >> s;
int key;
key = getKey(s);
if(c[0] == 'i')
insert(key);
else
if(search(key))
cout << "yes" << endl;
else
cout << "no" << endl;
}
}
| 0 | 30,786,879 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n; cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans;
double prev = (double)v[0];
for (int i = 1; i < n; i++) {
ans = (double)(prev + v[i]) / 2;
prev = ans;
}
cout << fixed << setprecision(11) << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define ll long long
#define all(x) (x).begin(),(x).end()
#define rep(i, n) for(ll i = 0; i < n; i++)
const ll INF = 1LL << 60;
int main(){
int N; cin >> N;
map<string, int> m;
rep(i, N){
string str;
cin >> str;
sort(all(str));
m[str]++;
}
ll ans = 0;
for(auto x:m){
ans += x.second*(x.second - 1LL) / 2;
}
cout << ans << endl;
}
| 0 | 83,584,952 |
#include<bits/stdc++.h>
#define int long long
using namespace std ;
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL) ;
int k ;
string s ;
cin >> k >> s ;
if(s.size() <=k)
cout << s ;
else
cout << s.substr(0, k ) << "..." ;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
#define INF __INT32_MAX__
int main() {
int A, B;
cin >> A >> B;
vector<vector<char>> G(100, vector<char>(100));
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
if (j <= 49) {
G[i][j] = '.';
} else {
G[i][j] = '#';
}
}
}
int cnt = 0;
bool finish = false;
for (int i = 0; i < 100; i += 2) {
for (int j = 51; j < 100; j += 2) {
if (cnt >= A - 1) {
finish = true;
break;
};
G[i][j] = '.';
cnt++;
}
if (finish) break;
}
cnt = 0;
finish = false;
for (int i = 0; i < 100; i += 2) {
for (int j = 0; j < 50; j += 2) {
if (cnt >= B - 1) {
finish = true;
break;
};
G[i][j] = '#';
cnt++;
}
if (finish) break;
}
cout << 100 << " " << 100 << endl;
rep(i, 100) {
rep(j, 100) {
cout << G[i][j];
}
cout << endl;
}
}
| 0 | 68,198,075 |
#include <iostream>
#include <numeric>
#include <cmath>
#include <limits>
#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++)
ll Max(ll(a), ll(b), ll(c)) {
return max(max(a, b), c);
}
ll Min(ll(a), ll(b), ll(c)) {
return min(min(a, b), c);
}
int main() {
ll K;
string S;
cin >> S >> K;
ll an = 0;
while (an<K-1&&S.at(an) == '1') {
an++;
}
cout << S.at(an) << endl;
}
|
#include<iostream>
#include<vector>
using namespace std;
class DisjointSet{
public:
vector<int> r, p;
DisjointSet(){}
DisjointSet(int num){
r.resize(num, 0);
p.resize(num, 0);
for(int i=0 ; i<num ; ++i) makeSet(i);
}
~DisjointSet(){}
void makeSet(int x){
p[x] = x;
r[x] = 0;
}
void unite(int x, int y){
link(findSet(x), findSet(y));
}
void link(int x, int y){
if(r[x] > r[y]){
p[y] = x;
}else{
p[x] = y;
if(r[x] == r[y]) r[y] = r[y]+1;
}
}
bool same(int x, int y){
return findSet(x) == findSet(y);
}
int findSet(int a){
if(a != p[a]) p[a] = findSet(p[a]);
return p[a];
}
};
int main(){
int n=0, m=0;
int x=0, y=0, com=0;
cin >> n >> m;
DisjointSet ds = DisjointSet(n);
for(int i=0 ; i<m ; ++i){
cin >> com >> x >> y;
if(com == 0) ds.unite(x, y);
else if (com == 1){
if(ds.same(x, y)) cout << 1 << endl;
else cout << 0 << endl;
}
}
}
| 0 | 62,211,956 |
#include <bits/stdc++.h>
#include <iomanip>
using namespace std;
#define int long long
#define puts(x) cout<<x<<endl
#define inf 243000000000000001
#define minf -243000000000000001
signed main(){
int n;
cin>>n;
vector<int>v(n);
vector<int>ans(n);
for(int i=0;i<n;i++){
cin>>v[i];
}
ans[0]=0;
ans[1]=abs(v[1]-v[0]);
for(int i=2;i<=n-1;i++){
ans[i]=min(ans[i-2]+abs(v[i-2]-v[i]),ans[i-1]+abs(v[i-1]-v[i]));
}
puts(ans[n-1]);
}
|
#include<iostream>
#include <stdio.h>
#include <string>
using namespace std;
int main(){
int flag = 0;
string s, p, ring;
getline(cin, s);
getline(cin, p);
ring = s + s;
for(int i = 0; i < 100; i++ ){
if(ring[i] == '\0' || flag == 1) break;
if(ring[i] == p[0]){
flag = 1;
for(int j = 1; j < 100; j++){
if(p[j] == '\0') break;
if(p[j] != ring[i + j]){
flag = 0;
break;
}
}
}
}
if(flag == 1){ cout << "Yes" <<endl;}
else{ cout << "No" << endl;}
return 0;
}
| 0 | 58,418,753 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
if(a*b==15) cout<<"*";
if(a+b==15) cout<<"+";
if(a+b!=15&&a*b!=15) cout<<"x";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m; i >= n; --i)
#define ALL(v) (v).begin(),(v).end()
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 ll INF=1LL<<60;
const int inf=(1<<30)-1;
const int mod=1e9+7;
int dx[8]={1,0,-1,0,-1,-1,1,1};
int dy[8]={0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,l;cin >> n >> l;
vector<ll> a(n);
REP(i,n){
cin >> a[i];
}
int t=-1;
REP(i,n-1){
if(a[i]+a[i+1]>=l) t=i+1;
}
if(t==-1){
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
FOR(i,1,t){
cout << i << endl;
}
FORR(i,n-1,t){
cout << i << endl;
}
}
| 0 | 97,628,575 |
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, n) for (int i = 1; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
int main()
{
string s;
cin >> s;
ll k;
cin >> k;
rep(i, min((ll)s.size(), k)) {
if (s[i] != '1') {
put(s[i]);
return 0;
}
}
put(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool lamp_check(bitset<10> s,int n,int m,vector<vector<int>> &array,vector<int> &p){
for(int i=0;i<m;i++){
int count = 0;
for(int j=0;j<(int)array.at(i).size();j++){
int num = array.at(i).at(j);
if(s.test(num)){
count++;
}
}
if(count % 2 != p.at(i)) return false;
}
return true;
}
int main(){
int n,m;
cin >> n >> m;
vector<vector<int>> switch_array(m);
vector<int> p(m);
for(int i=0;i<m;i++){
int k;
cin >> k;
for(int j=0;j<k;j++){
int l;
cin >> l;
switch_array.at(i).push_back(l-1);
}
}
for(int i=0;i<m;i++) cin >> p.at(i);
int c = 0;
for(int tmp=0; tmp < (1 << n); tmp++){
bitset<10> s(tmp);
if(lamp_check(s,n,m,switch_array,p)){
c++;
}
}
cout << c << endl;
}
| 0 | 40,054,020 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int a,b,c;
cin >> a >> b>> c;
cout<< min(min(a+b,b+c), min(a+b,a+c));
return 0 ;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
const int N = 2e5 + 10, OO = 0x3f3f3f3f, mod = 1e9 + 7;
#define PI acos(-1)
#define clr(arr, val) memset(arr, val, sizeof(arr))
#define loop(i, n) for (int i = 0; i < int(n); i++)
#define rloop(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define xloop(i, a, b) for (int i = int(a); i <= int(b); i++)
#define ALL(v) ((v).begin()), ((v).end())
#define SZ(v) ((int)((v).size()))
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
int n,m,k;
char grid[10][10];
int main()
{
scanf("%d %d %d", &n , &m , &k);
for(int i = 0 ; i < n ; ++i)
scanf("%s" , grid[i]);
int ans = 0 , cnt = 0;
for(int mskR = 0 ; mskR < (1 << n) ; ++mskR){
for(int mskC = 0 ; mskC < (1 << m) ; ++mskC){
cnt = 0;
for(int i = 0 ; i < n ; ++i){
if(mskR & (1 << i)){
for(int j = 0 ; j < m ; ++j){
if(mskC & (1 << j)){
cnt += (grid[i][j] == '#');
}
}
}
}
ans += (cnt == k);
}
}
printf("%d\n" , ans);
return 0;
}
| 0 | 41,911,549 |
#include<map>
#include<set>
#include<cmath>
#include<stack>
#include<queue>
#include<deque>
#include<ctime>
#include<vector>
#include<bitset>
#include<string>
#include<cstdio>
#include<numeric>
#include<utility>
#include<sstream>
#include<cstdlib>
#include<iomanip>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
#include<unordered_map>
#define _USE_MATH_DEFINES
#define inf 999999999999999999
#define rep(i,n,m) for(lli i=(lli)(n);i<(lli)(m);++i)
#define reep(i,n,m) for(int i=(int)(n);i<=(int)(m);++i)
#define per(i,m,n) for(lli i=(int)(m)-1;i>=(int)(n);--i)
#define st(n) sort(n.begin(), n.end())
#define rev(n) reverse(n.begin(),n.end())
#define ou(S) cout << S << endl
#define pb(n) push_back(n)
#define ue(N) N.erase(unique(N.begin(),N.end()),N.end());
#define nou(S) cout << S
#define hou(S) cout << setprecision(30) << S << endl
#define vec(K,L,N,S) vector<L> K(N,S)
#define dv(K,L,N,M,S) vector<vector<L>> K(N,vector<L>(M,S))
#define tv(K,L,N,M,R,S) vector<vector<vector<L>>> K(N,vector<vector<L>>(M,vector<L>(R,S)))
#define pint pair<lli,lli>
#define paf(L,R) pair<L,R>
#define maxx 5100000
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
#define endl "\n"
typedef long long int lli;
typedef unsigned long long int uli;
const uli mod = 1e9 + 7;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
string s,t;
cin>>s>>t;
if(s==t){
cout<<"Yes"<<endl;
return 0;
}
for(uli i=0;i<s.length()-1;++i){
string a;
a=s[s.size()-1];
s.pop_back();
a+=s;
s=a;
if(s==t){
cout<<"Yes"<<endl;
return 0;
}
}
cout<<"No"<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
#define int ll
const int INF=(int)2e18;
const int MOD = 1000000007;
const int PEG = 998244353;
long double pie=acos(-1);
typedef vector< int > vi;
typedef vector< vi > vvi;
typedef pair< int, int > pii;
typedef vector< pii > vpii;
#define X first
#define Y second
#define pb push_back
#define sz(a) (ll)(a).size()
#define all(a) (a).begin(),(a).end()
#define F(i,a,b) for(ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define Fo(i,a,b,j) for(ll i=a;i<=b;i+=j)
#define RFo(i,a,b,j) for(ll i=a;i>=b;i-=j)
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" "
#define out1(a,n) F(i,1,n)cout<<a[i]<<" "
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define popcount __builtin_popcountll
#define pfy cout<<"YES"
#define pfn cout<<"NO"
#define pfn1 cout<<"-1"
#define pf1 cout<<"1"
#define nl cout<<"\n"
#define watch(x) cout<<#x<<" is "<<x<<"\n"
#define dbg(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>void __f(const char* name,Arg1&& arg1);
template <typename Arg1,typename... Args>void __f(const char* names,Arg1&& arg1,Args&&... args);
ll binpow(ll x,ll y,ll p);
signed main()
{
#ifndef ONLINE_JUDGE
#endif
fast;
int N;
cin>>N;
int a[N];
int cnt[N+1]={};
F(i,0,N-1)
{
cin>>a[i];
cnt[a[i]]++;
}
int sum=0;
F(i,1,N)
{
sum+=(cnt[i]*(cnt[i]-1))/2;
}
F(i,0,N-1)
{
if(cnt[a[i]]>1)
{
cout<<sum-(cnt[a[i]]-1);nl;
}
else {cout<<sum;nl;}
}
return 0;
}
ll binpow(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1)
{
std::cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&... args)
{
const char *comma = strchr(names + 1, ',');
std::cout.write(names, comma - names) << " : " << arg1 << "\n";
__f(comma + 1, args...);
}
| 0 | 33,137,303 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int ans=0;
for(int i=1;i<=n;i++){
if(1<=i && i<=9) ans++;
else if(100<=i && i<=999) ans++;
else if(10000<=i && i<=99999) ans++;
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
void primeFactorization(uint64_t a, list<uint64_t> &factors){
long i,sq;
if(a%2==0){
factors.push_back(2);
primeFactorization(a/2,factors);
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors);
return;
}
}
if(a!=1){
factors.push_back(a);
}
}
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
signed main() {
int64_t n,m;
cin >> n >> m;
int count = 0;
if(m>=2){
count += m*(m-1)/2;
}
if(n>=2){
count += n*(n-1)/2;
}
cout << count << endl;
return 0;
}
| 0 | 62,684,133 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
int main(void)
{
int A;
cin >> A;
cout << (A * 800) - ((A / 15) * 200) << endl;
}
|
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <vector>
#include <sstream>
#include <string>
#include <cstdio>
#include <stack>
#include <queue>
#include <list>
#include <numeric>
#include <fstream>
#define NDEBUG
#include <cassert>
using namespace std;
#define TEST
#ifdef TEST
#define dout cout
#define din cin
#else
stringstream dummy;
#define dout dummy.str(""); dummy.clear(stringstream::goodbit); dummy
#endif
#ifdef OUTPUTFILE
#define dout outputfile
ofstream outputfile(OUTPUTFILE);
#define OutputFilePath "/Users/Nag/Documents/Prgm/Test/DerivedData/Test/Build/Products/Debug/output.txt"
#endif
#ifdef INPUTFILE
#define din inputfile
ifstream inputfile(INPUTFILE);
#endif
#define disp(A) dout << #A << " = " << (A) << endl
#define disP(A) dout << setw(3) << (A) << " "
#define rep(i,a,n) for(int (i)=(a); (i)<(n); (i)++)
#define dispAll(A,n) dout << #A << " = "; rep(j, 0, (n)) {disP(A[j]);} dout << endl
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef unsigned long long ll;
const int INF = 1e9-1;
int completeBinaryTree[251];
int parentOf(int i) {
return i/2;
}
int leftChildOf(int i) {
return i*2;
}
int rightChildOf(int i) {
return i*2+1;
}
int main(){
int N; cin >> N;
rep(i,1,N+1) din >> completeBinaryTree[i];
string parentKeyStr;
string leftKeyStr;
string rightKeyStr;
ostringstream oss;
rep(i,1,N+1) {
if(parentOf(i)>0) {
parentKeyStr = "parent key = ";
oss << completeBinaryTree[parentOf(i)];
parentKeyStr += oss.str();
parentKeyStr += ", ";
oss.str("");
} else parentKeyStr = "";
if(leftChildOf(i)<=N) {
leftKeyStr = "left key = ";
oss << completeBinaryTree[leftChildOf(i)];
leftKeyStr += oss.str();
leftKeyStr += ", ";
oss.str("");
} else leftKeyStr = "";
if(rightChildOf(i)<=N) {
rightKeyStr = "right key = ";
oss << completeBinaryTree[rightChildOf(i)];
rightKeyStr += oss.str();
rightKeyStr += ", ";
oss.str("");
} else rightKeyStr = "";
dout << "node " << i << ": key = " << completeBinaryTree[i] << ", "
<< parentKeyStr << leftKeyStr << rightKeyStr << endl;
}
#ifdef INPUTFILE
inputfile.close();
#endif
#ifdef OUTPUTFILE
outputfile.close();
cout << "\"" << OutputFilePath << "\"" << endl;
#endif
return 0;
}
| 0 | 6,121,187 |
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
#define pb push_back
#define mpr make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
#define ll long long
#define ld long double
#define fi first
#define se second
#define all(arr) arr.begin(), arr.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define fo(i, l, r) for (int i = l; i <= r; i++)
#define INF 1000000001
#define inf1 1000000000000000001
#define MOD 1000000007
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define N 200009
#define M 2000009
#define mid(l, r) l + (r - l) / 2
#define vec vector
#define vecl vector<ll>
#define umap unordered_map<ll, ll>
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define endl "\n"
#define int long long
using namespace std;
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
int ddx[8]={1,1,0,-1,-1,-1,0,1},ddy[8]={0,1,1,1,0,-1,-1,-1};
ll gcd(ll a,ll b){ if(!a)return b;return gcd(b%a,a);}
ll lcm(ll a, ll b) { return (a*b)/ gcd(a,b);}
void test_case()
{
ll n,k;
cin >> n >> k;
vector<ll> a(n),s(n+1);
map<ll,ll> m;
rep(i,n){
cin >> a[i];
s[i+1]=s[i]+a[i];
}
for(ll i=1;i<=n;i++){
s[i]-=i;
s[i]%=k;
}
ll ans=0;
for(ll i=0;i<=n;i++){
ans+=m[s[i]];
if(i>=k-1) m[s[i-k+1]]--;
m[s[i]]++;
}
cout << ans << endl;
}
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
int t = 1;
while (t--)
{
test_case();
}
}
|
#include <numeric>
#include<iostream>
#include<set>
#include<queue>
#include<vector>
#include<map>
#include<stack>
#include<algorithm>
#include <sstream>
#include<string>
#include <cmath>
#include <iomanip>
#include <string>
#include<list>
#include<string.h>
#include<memory.h>
using namespace std;
#define inf 100000000007
#define int long long
#define rep(i,j,n) for(int i=j;i<n;i++)
typedef pair<int,int> P;
struct edge{int from,to,cost;};
double pi = 3.141592653589793;
int v,e;
edge es[11451];
int d[114];
bool find_negative_loop(){
memset(d,0,sizeof(d));
rep(i,0,v){
rep(j,0,e){
edge e=es[j];
if(d[e.to]>d[e.from]+e.cost){
d[e.to]=d[e.from]+e.cost;
if(i==v-1)return true;
}
}
}
return false;
}
void shortest_path(int s){
rep(i,0,v)d[i]=inf;
d[s]=0;
while(true){
bool update=false;
rep(i,0,e){
edge e=es[i];
if(d[e.from]!=inf&&d[e.to]>d[e.from]+e.cost){
d[e.to]=d[e.from]+e.cost;update=true;
}
}
if(!update)break;
}
}
signed main(){
cin>>v>>e;
if(v==1){
cout<<0<<endl;
return 0;
}
rep(i,0,e){
int a,b,c;cin>>a>>b>>c;
es[i]=edge{a,b,c};
}
if(find_negative_loop()){
cout<<"NEGATIVE CYCLE"<<endl;
return 0;
}
rep(i,0,v){
shortest_path(i);
rep(j,0,v-1){
if(d[j]==inf)cout<<"INF"<<" ";
else cout<<d[j]<<" ";
}if(d[v-1]==inf)cout<<"INF"<<endl;
else cout<<d[v-1]<<endl;
}
return 0;
}
| 0 | 12,220,045 |
#include <iostream>
#include <string>
#include <cctype>
using namespace std;
string sort1(string str)
{
int i = 0, j;
while (i < str.size() - 1)
{
j = i + 1;
while (j < str.size())
{
if (str[i] > str[j])
{
char temp;
temp = str[i];
str[i] = str[j];
str[j] = temp;
}
j++;
}
i++;
}
return str;
}
string sort2(string str)
{
int i = 0, j;
while (i < str.size() - 1)
{
j = i + 1;
while (j < str.size())
{
if (str[i] < str[j])
{
char temp;
temp = str[i];
str[i] = str[j];
str[j] = temp;
}
j++;
}
i++;
}
return str;
}
int main()
{
string str1, str2;
cin >> str1 >> str2;
str1 = sort1(str1);
str2 = sort2 (str2);
if (str1 < str2) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define debug(x) cerr << #x << " = " << x << endl
int main(int qtd, char* nome[])
{
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
double l = n/3.0;
cout << fixed << setprecision(12) << l*l*l << endl;
return 0;
}
| 0 | 39,202,900 |
#include <bits/stdc++.h>
#include <iostream>
#include <iomanip>
#include <ios>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <cmath>
#include <map>
using namespace std;
typedef long long ll;
int main() {
int N[4];
for(int i=0; i<4; i++){
cin >> N[i];
}
int count[4]={};
for(int i=0; i<4; i++){
if(N[i] == 1) count[0]=1;
if(N[i] == 9) count[1]=1;
if(N[i] == 7) count[2]=1;
if(N[i] == 4) count[3]=1;
}
if (count[0] && count[1] && count[2] && count[3]) cout << "YES" << endl;
else cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ar array
int n;
int a[1000001];
int inp[200001];
void solve(){
cin >> n;
for (int i = 0; i < 1000001; i++)
{
a[i] = 0;
}
int tmp;
for (int i = 0; i < n; i++)
{
cin >> inp[i];
}
sort(inp, inp+n);
int max = inp[n-1];
for (int i = 0; i < n; i++)
{
int x = inp[i];
if(a[x] == 1){
a[x] +=1;
continue;
}
for (int j = x; j <= max; j = j+x)
{
a[j] += 1;
}
}
int ans = 0;
for (int i = 0; i < n; i++)
{
if(a[inp[i]] == 1) ans++;
}
cout << ans << endl;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 0 | 87,065,781 |
#include <iostream>
#include <vector>
#include <algorithm>
#define vi vector<int>
#define REP(n) for(int i=0;i<n;i++)
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
vi v;
v.push_back(a);
v.push_back(b);
v.push_back(c);
sort(v.begin(),v.end());
REP(v.size()){
if(i) cout<<" "<<v[i];
else cout<<v[i];
}
cout<<endl;
}
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
#define int long long
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
vector<vector<int> >adj;
int parent[100005][20];
void dfs(int ver,int pr)
{
parent[ver][0]=pr;
for(auto i:adj[ver])
{
dfs(i,ver);
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
int n;
cin>>n;
adj.resize(n+2);
int x[n+1];
set<pair<int,int> >s;
for(int i=1;i<=n;i++)
{
cin>>x[i];
s.insert({x[i],i});
}
int len;
cin>>len;
for(int i=1;i<=n;i++)
{
auto j=s.lower_bound({x[i]+len+1,-1});
j--;
if(j->second==i)
{
adj[n+1].push_back(i);
}
else
{
adj[j->second].push_back(i);
}
}
dfs(n+1,n+1);
for(int i=1;i<=19;i++)
for(int j=1;j<=n+1;j++)
parent[j][i]=parent[parent[j][i-1]][i-1];
int q;
cin>>q;
int l,r;
while (q--)
{
cin>>l>>r;
if(l>r)
swap(l,r);
if(l==r)
{
continue;
cout<<0<<"\n";
}
int ans=1;
for(int i=19;i>=0;i--)
{
if(parent[l][i]<r)
{
ans+=(1<<i);
l=parent[l][i];
}
}
cout<<ans<<"\n";
}
}
| 0 | 11,345,866 |
#include <bits/stdc++.h>
using namespace std;
using VS = vector<string>; using LL = long long;
using VI = vector<int>; using VVI = vector<VI>;
using PII = pair<int, int>; using PLL = pair<LL, LL>;
using VL = vector<LL>; using VVL = vector<VL>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)
#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)
#ifdef YANG33
#include "mydebug.hpp"
#else
#define DD(x)
#endif
const int INF = 1e9; const LL LINF = 1e16;
const LL MOD = 1000000007; const double PI = acos(-1.0);
LL ans = 0LL;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
LL H, W, N; cin >> H >> W >> N;
int DX[] = { 0, 0, 1, -1, 1, 1, -1, -1,0 }; int DY[] = { 1, -1, 0, 0, 1, -1, 1, -1,0 };
map<PII, int>Map;
FOR(i, 0, N) {
int y, x; cin >> y >> x;
y--, x--;
FOR(k, 0, 9) {
int ny = y + DY[k];
int nx = x + DX[k];
if (1 <= ny && ny < H - 1 && 1 <= nx && nx < W - 1) {
Map[PII(ny, nx)]++;
}
}
}
VL ans(10, 0);
const auto MM = Map;
for (auto m : MM) {
ans[m.second]++;
}
ans[0] = ((H - 2)*(W - 2) - accumulate(ALL(ans), 0LL));
FOR(i, 0, 10) {
cout << ans[i] << endl;
}
return 0;
}
|
#include <iostream>
#include <cmath>
#include <iomanip>
#include <string>
#include <vector>
using namespace std;
float calc_crossZ(vector<float> v1, vector<float>v2){
float result = v1[0]*v2[1] - v1[1]*v2[0];
return result;
}
bool same_sign(float a, float b){
if(a<0 && b<0){
return true;
}else if(a>0 && b>0){
return true;
}
return false;
}
bool do_calc(float x1, float y1, float x2, float y2, float x3, float y3, float xp,float yp){
vector<float> AB;
AB.push_back(x2-x1);
AB.push_back(y2-y1);
vector<float> AC;
AC.push_back(x3-x1);
AC.push_back(y3-y1);
vector<float> AP;
AP.push_back(xp-x1);
AP.push_back(yp-y1);
float std = calc_crossZ(AB, AC);
float comp = calc_crossZ(AB, AP);
if(same_sign(std, comp)){
return true;
}else{
return false;
}
}
int main(){
float x1, y1, x2, y2, x3, y3, xp, yp;
while(cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp){
if(do_calc(x1, y1, x2, y2, x3, y3, xp, yp)&&do_calc(x2, y2, x3, y3, x1, y1, xp, yp)&&do_calc(x3, y3, x1, y1, x2, y2, xp, yp)){
cout << "YES" << endl;
}else{
cout << "NO" << endl;
}
}
return 0;
}
| 0 | 66,490,236 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int a,b,c;
cin >> a >> b >> c;
if (c >= a && c <= b) {
cout << "Yes" << endl;
return 0;
}
cout << "No" << endl;
}
|
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<map>
#include<set>
#include<cstdio>
#include<cmath>
#include<deque>
#include<numeric>
#include<queue>
#include<stack>
#include<cstring>
#include<limits>
#include<functional>
#include<unordered_set>
#include<iomanip>
#include<cassert>
#include<regex>
#include<bitset>
#include<complex>
#include<chrono>
#define rep(i,a) for(int i=(int)0;i<(int)a;++i)
#define pb push_back
#define eb emplace_back
using ll=long long;
constexpr ll mod = 1e9 + 7;
constexpr ll 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;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << "\n"; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " <<to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
void solve(){
int n,m;
cin>>n>>m;
int a;
set<int>s;
int sz[]={2,5,5,4,5,6,3,7,6};
rep(i,m){
cin>>a;
s.insert(a);
}
vector<vector<string>>dp(n+1,vector<string>(9,"0"));
rep(i,9)dp[n][i]="";
for(int i=n;i>=0;--i){
rep(j,9){
if(s.count(j+1)){
if(i-sz[j]>=0){
rep(k,9){
if(dp[i][k]!="0"){
if(dp[i-sz[j]][j].size()==dp[i][k].size()+1)chmax(dp[i-sz[j]][j],dp[i][k]+to_string(j+1));
else if(dp[i-sz[j]][j].size()<dp[i][k].size()+1)dp[i-sz[j]][j]=dp[i][k]+to_string(j+1);
}
}
}
}
}
}
string ans="";
rep(i,9){
if(ans.size()==dp[0][i].size())chmax(ans,dp[0][i]);
else if(ans.size()<dp[0][i].size())ans=dp[0][i];
}
cout<<ans<<endl;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout<<fixed<<setprecision(15);
solve();
return 0;
}
| 0 | 39,511,696 |
#include<bits/stdc++.h>
using namespace std;
#define FOR(i,l,r) for(long long i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
#define REPS(i,n) FOR(i,1,n+1)
#define RFOR(i,l,r) for(long long i=(l);i>=(r);--i)
#define RREP(i,n) RFOR(i,N-1,0)
#define RREPS(i,n) RFOR(i,N,1)
#define int long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
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;
}
const int INF=1e18;
const int MOD=1e9+7;
signed main(){
int A,P;cin>>A>>P;
cout<<(A*3+P)/2<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const int inf = 1e9;
const ll INF = 1e18;
const double pi = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
using Graph = vector<vector<int>>;
using pint = pair<int, int>;
int dx[4] = { 1, 0, -1, 0 }, dy[4] = { 0, 1, 0, -1 };
int main() {
int h, w, a, b;
cin >> h >> w >> a >> b;
int g[h][w];
rep (i, h) {
rep (j, w) {
if ((i < b && j < a) || i >= b && j >= a) g[i][j] = 1;
else
g[i][j] = 0;
}
}
rep (i, h) {
rep (j, w) cout << g[i][j];
cout << "\n";
}
}
| 0 | 90,942,614 |
#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;
const int mod=1e9+7;
int main() {
int N;
cin>>N;
string s;
cin>>s;
map<char,int>k;
for(int i=0;i<N;i++){
k[s[i]]++;
}
int64_t ans=1;
for(auto c:k){
ans*=(c.second+1);
ans%=mod;
}
cout<<ans-1<<endl;
return 0;
}
|
#include<algorithm>
#include<bitset>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<iterator>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a,i,j,v) for(ll k=i;k<=j;k++){a[k]=v;}
int main() {
string s; cin >> s;
ll seg = 1;
REP(i, s.size()) {
if (i != 0) {
if (s[i] != s[i-1]) {
seg++;
}
}
}
cout << seg - 1 << endl;
return 0;
}
| 0 | 47,898,236 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int A, B, C;
cin >> A >> B >> C;
int D = A + B;
if (D > C || D == C) {
cout << "Yes" << endl;
}
else if (D < C) {
cout << "No" << endl;
}
}
|
#include<iostream>
#include<algorithm>
int main(){
long long N,M,m;
std::cin >> N >> m >> M;
if(m>M || (N==1 && m!=M)){
std::cout << "0\n";
return 0;
}
std::cout << 1ll+std::max((M-m)*(N-2),0ll) << "\n";
return 0;
}
| 0 | 43,564,327 |
#include <iostream>
#include <string>
using namespace std;
int main(){
int n,tc=0,hc=0;
string taro,hanako;
cin >> n ;
for (int i=0;i<n;i++){
cin >> taro >> hanako ;
if(taro>hanako)tc+=3;
else if(taro<hanako)hc+=3;
else {
tc++;
hc++;
}
}
cout << tc << " " << hc << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
const int MOD = 1000000007;
const ll INF = 1e18;
const int MX = 200001;
string s;
int cur[MX], dp[MX];
map<int,int> mindp;
int test(int x) {
if (!mindp.count(x)) return MOD;
return mindp[x]+1;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
cin >> s;
int ind = 0;
for (char c: s) {
ind ++;
cur[ind] = cur[ind-1]^(1<<(c-'a'));
}
dp[sz(s)] = 0;
mindp[cur[sz(s)]] = 0;
F0Rd(i,sz(s)) {
dp[i] = MOD;
F0R(j,26) dp[i] = min(dp[i],test(cur[i]^(1<<j)));
F0R(j,26) dp[i] = min(dp[i],test(cur[i]));
if (!mindp.count(cur[i])) mindp[cur[i]] = MOD;
mindp[cur[i]] = min(mindp[cur[i]],dp[i]);
}
cout << dp[0];
}
| 0 | 42,317,990 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long A,B;
cin>>A>>B;
cout<<lcm(A,B)<<endl;
}
|
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <map>
#define FOR(i,k,n) for(int (i) = (k); (i) < (n); ++(i))
#define rep(i,n) FOR(i,0,n)
using namespace std;
typedef pair<int, int> i_i;
int a,w,h;
bool t[22][22],s[22][22];
void dfs(i_i p) {
s[p.first][p.second] = 1;
a += 1;
rep(j,2){
if(t[p.first][p.second+(int)pow(-1,j)] && s[p.first][p.second+(int)pow(-1,j)] == 0) {
dfs(make_pair(p.first,p.second+(int)pow(-1,j)));
}
}
rep(i,2) {
if(t[p.first+(int)pow(-1,i)][p.second] && s[p.first+(int)pow(-1,i)][p.second] == 0) {
dfs(make_pair(p.first+(int)pow(-1,i),p.second));
}
}
}
int main() {
while(1) {
i_i m;
scanf("%d %d",&w,&h);
if(w == 0) break;
FOR(i,1,h+1){
char a[20];
scanf("%s",a);
FOR(j,1,w+1) {
if(a[j-1] == '.') t[i][j] = 1;
if(a[j-1] == '@') m = make_pair(i,j);
}
}
dfs(m);
printf("%d\n",a);
a = 0;
rep(i,22) {
rep(j,22) {
t[i][j] = 0,s[i][j] =0;
}
}
}
return 0;
}
| 0 | 57,268,058 |
#include <bits/stdc++.h>
#define rep(i,s,n) for (int i = s; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i,0,n) cin >> a[i];
vector<int> b = a;
sort(b.rbegin(), b.rend());
int f = b[0], s = b[1];
rep(i,0,n) {
if (a[i] != f) cout << f << endl;
else cout << s << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int H, W;
cin >> H >> W;
while (H > 0 && W > 0) {
for (int i=1; i<=H; i=i+1) {
for (int j=1; j<=W; j=j+1) {
if (i == 1 || i == H || j == 1 || j == W)
cout << '#';
else
cout << '.';
}
cout << endl;
}
cout << endl;
cin >> H >> W;
}
return 0;
}
| 0 | 34,191,163 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
int n=s.size();
for(int i=0; i<n; i++){
if(i==3){
cout << s[i] << " ";
continue;
}
cout << s[i];
}
cout << endl;
}
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define pb push_back
#define INF 9223372036854775807
#define endl '\n'
#define pii pair<ll int,ll int>
#define vi vector<ll int>
#define all(a) (a).begin(),(a).end()
#define F first
#define S second
#define sz(x) (ll int)x.size()
#define hell 1000000007
#define rep(i,a,b) for(ll int i=a;i<b;i++)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define mp make_pair
#define lower(u) transform(u.begin(), u.end(), u.begin(), ::tolower);
#define upper(u) transform(u.begin(), u.end(), u.begin(), ::toupper);
using namespace std;
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define N 100005
void solve()
{
ll h,n,sum=0,x;
cin>>h>>n;
rep(i,0,n)
{
cin>>x;
sum+=x;
}
if(sum>=h)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS=1;
while(TESTS--)
{
solve();
}
return 0;
}
| 0 | 7,087,325 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <array>
#include <iomanip>
using namespace std;
typedef long long ll;
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define SORT(s) sort((s).begin(),(s).end())
int main(){
string n; cin >> n;
REP(i,3){
if(n[i] == '1') n[i] = '9';
else n[i] = '1';
}
cout << n << endl;
}
|
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
#define MAX_N 50
int v[MAX_N];
int n;
int k;
int favour_left[MAX_N][MAX_N + 1];
int favour_right[MAX_N][MAX_N + 1];
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
int i;
for(i = 0; i < n; ++i){
cin >> v[i];
}
int j;
for(i = 1; i <= n; ++i){
priority_queue<int, vector<int>, greater<int> > q;
int max_sum = 0;
for(j = 0; j < i; ++j){
max_sum += v[j];
q.push(v[j]);
}
favour_left[i - 1][i] = max_sum;
for(j = i; j < n; ++j){
if(v[j] > q.top()){
max_sum -= q.top();
q.pop();
max_sum += v[j];
q.push(v[j]);
}
favour_left[j][i] = max_sum;
}
}
for(i = 1; i <= n; ++i){
priority_queue<int, vector<int>, greater<int> > q;
int max_sum = 0;
for(j = 0; j < i; ++j){
max_sum += v[n - 1 - j];
q.push(v[n - 1 - j]);
}
favour_right[i - 1][i] = max_sum;
for(j = i; j < n; ++j){
if(v[n - 1 - j] > q.top()){
max_sum -= q.top();
q.pop();
max_sum += v[n - 1 - j];
q.push(v[n - 1 - j]);
}
favour_right[j][i] = max_sum;
}
}
int max_favour = 0;
int p, q;
for(i = 0; i < n; ++i){
for(p = i + 1; p >= 0; --p){
int op_left = i + 1 + (i + 1 - p);
if(op_left > k){
break;
}
max_favour = max(max_favour, favour_left[i][p]);
}
}
for(j = 0; j < n; ++j){
for(q = j + 1; q >= 0; --q){
int op_right = j + 1 + (j + 1 - q);
if(op_right > k){
break;
}
max_favour = max(max_favour, favour_right[j][q]);
}
}
for(i = 0; i < n; ++i){
for(j = 0; j < n && i + j + 1 < n; ++j){
for(p = i + 1; p >= 0; --p){
int op_left = i + 1 + (i + 1 - p);
if(op_left > k){
break;
}
for(q = j + 1; q >= 0; --q){
int op_right = j + 1 + (j + 1 - q);
if(op_left + op_right > k){
break;
}
max_favour = max(max_favour, favour_left[i][p] + favour_right[j][q]);
}
}
}
}
cout << max_favour << '\n';
return 0;
}
| 0 | 56,451,899 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
string ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string alp = "abcdefghijklmnopqrstuvwxyz";
void Yes() {cout << "Yes" << endl;}
void No() {cout << "No" << endl;}
void YES() {cout << "YES" << endl;}
void NO() {cout << "NO" << endl;}
void neg() {cout << -1 << endl;}
int main() {
int a, b;
cin >> a >> b;
cout << a * b - a - b + 1 << endl;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstring>
#include <iomanip>
#define rep(i,n) for(int i=0; i<(n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
const int MOD = (int)1e9 + 7;
const ll INFLL = 1001001001001001001;
const ll MODLL = (ll)1e9 + 7;
const double EPS = 1e-9;
int main () {
int n,k; cin >>n>>k;
vector<int> a(n); rep(i,n) cin >> a[i];
sort(a.begin(), a.end(), greater<int>());
int ng = n;
int ok = -1;
while (abs(ok-ng)>1) {
int i = (ok+ng)/2;
int mem = a[i];
a.erase(a.begin()+i);
vector<vector<bool> > dp(n, vector<bool>(k, false));
dp[0][0] = true;
for (int j = 0; j < n-1; j++) {
for (int l = 0; l < k; l++) {
dp[j+1][l] = (dp[j+1][l] || dp[j][l]);
if (l - a[j] >= 0) {
dp[j+1][l] = (dp[j+1][l] || dp[j][l - a[j]]);
}
}
}
bool ans = false;
for (int l = 0; l < k; l++) {
if (k - mem <= l) {
ans = (ans || dp[n-1][l]);
}
}
if (ans) {
ok = i;
} else {
ng = i;
}
a.insert(a.begin()+i, mem);
}
cout << n - (ok+1) << endl;
return 0;
}
| 0 | 5,141,311 |
#include <iostream>
using namespace std;
int main(){
int N, A;
cin >> N >> A;
while(N >= 500){
N = N - 500;
}
if(N <= A){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
#include <string.h>
#include <vector>
#define MAX 10000
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define rep(i,a,n) for(int i=a; i<n; i++)
#define r0 return 0
#define INF (int)1e15
#define MOD 1000000007
int gcd(int a,int b){
if(a%b == 0)
return b;
else
return gcd(b,a%b);
}
long long numbers[500005];
long long dt,dx,dy,oldx=0,oldy=0,oldt=0;
int main(){
long long n,flag=0;
cin>>n;
for(int i=0;i<n;i++)
{
long long t,x,y;
cin>>t>>x>>y;
dt = t-oldt;
dx = abs(x-oldx);
dy = abs(y-oldy);
if(dt >= dx+dy && (dt-dx-dy)%2 == 0){
oldt = t;
oldx = x;
oldy = y;
}
else
{
flag = 1;
break;
}
}
if(flag == 1)
cout<<"No"<<endl;
else
cout<<"Yes"<<endl;
return 0;
}
| 0 | 3,967,968 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> iint;
typedef pair<ll,ll> llll;
#define ALL(x) (x).begin(),(x).end()
const ll zero = 0;
const ll INF = 3000000000000000000;
const int inINF = 1000000000;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
int main(){
int N , M;
cin >> N >> M;
vector<int> A(N+1, 0);
int a, b;
for (int i = 0; i < M; i++) {
cin >> a >> b;
A[a]++;
A[b]++;
}
for (int i = 1; i < N+1; i++) {
if(A[i] % 2 == 1){
printf("NO\n");
return 0;
}
}
printf("YES\n"); return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main(){
string S;
cin >> S;
int N=S.length();
int i=0,j;
int check=0;
while(check==0){
j=0;
i++;
while(1){
if(S[j]!=S[(N/2-i+j)])break;
j++;
if(j==N/2-i){
check=1;
break;
}
}
}
cout << 2*j << endl;
return 0;
}
| 0 | 94,530,283 |
#include <bits/stdc++.h>
using namespace std;
const int INF=100000000;
int main(){
int n;
cin>>n;
vector<int> x(n);
for(int i=0;i<n;i++)cin>>x[i];
long long ans=INF;
for(int p=1;p<=100;p++){
long long res=0;
for(int i=0;i<n;i++){
int a=x[i]-p;
res+=a*a;
}
ans=min(ans,res);
}
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int (i) = 0; (i) < (n); (i)++)
#define repp(i, n, m) for(int (i) = (n); (i) < (m); (i)++)
#define repn(i, n) for(int (i) = 1; (i) <= (n); (i)++)
#define repr(i, n) for(int (i) = (n-1); (i) >= 0; (i)--)
#define all(x) (x).begin(), (x).end()
#define lint long long
#define ulint unsigned long long
#define ldou long double
#define fi first
#define se second
#define setpre(x) std::cout << fixed << setprecision(x)
#define ii(x) int x; cin >> (x)
#define ii2(x, y) int x, y; cin >> (x) >> (y)
#define ii3(x, y, z) int x, y, z; cin >> (x) >> (y) >> (z)
#define out(x) cout << (x) << endl
#define outs(x) cout << (x) << " "
#define yn(x) cout << ((x)?("Yes"):("No")) << endl
#define YN(x) cout << ((x)?("YES"):("NO")) << endl
#define bit_c(x) __builtin_popcountll(x)
inline void logger(){ std::cout << " [LOGGER] " << endl; }
template<typename A, typename... B>
void logger(const A& a, const B&... b){
cout << a << " , "; logger(b...);
}
typedef pair<lint, lint> P;
const lint MOD = 1000000007;
const lint MOD9 = 998244353;
const lint INF = MOD * MOD;
const int MAX = 100005;
int main(){
lint n; cin >> n;
lint V = 0, E = 0;
repn(i, n){
V += i * (n-i+1);
}
rep(i, n-1){
lint u,v; cin>>u>>v;
if(u>v) swap(u,v);
E += u * (n-v+1);
}
out(V-E);
}
| 0 | 81,575,277 |
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<map>
#include<set>
#include<cstdio>
#include<cmath>
#include<deque>
#include<numeric>
#include<queue>
#include<stack>
#include<cstring>
#include<limits>
#include<functional>
#include<unordered_set>
#include<iomanip>
#include<cassert>
#include<regex>
#include<bitset>
#include<complex>
#include<chrono>
#include<random>
#define rep(i,a) for(int i=(int)0;i<(int)a;++i)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(),x.end()
using ll=long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
ll gcd(ll n, ll m) {
ll tmp;
while (m!=0) {
tmp = n % m;
n = m;
m = tmp;
}
return n;
}
ll lcm(ll n, ll m) {
return abs(n * m) / gcd(n, m);
}
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;
void solve(){
int n;
cin>>n;
int ans=0;
vector<string>s(n);
int a=0,b=0,sub=0;
rep(i,n)cin>>s[i];
rep(i,n){
int m=s[i].size();
rep(j,m-1){
if(s[i][j]=='A'&&s[i][j+1]=='B')++ans;
}
if(s[i][0]=='B')++b;
if(s[i].back()=='A')++a;
if(s[i][0]=='B'&&s[i].back()=='A')++sub;
}
ans+=min(a,b);
if(a==b&&a==sub&&sub!=0)ans=max(0,ans-1);
cout<<ans;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout<<fixed<<setprecision(15);
solve();
return 0;
}
|
#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
int main(){
ll A,B,M;
cin >> A >> B >> M;
ll a[A],b[B],x[M],y[M],c[M];
ll ans = 0,memo = LINF;
rep(i,0,A){
cin >> a[i];
memo = min(memo,a[i]);
}
ans += memo;
rep(i,0,B){
cin >> b[i];
memo = min(memo,b[i]);
}
ans += memo;
rep(i,0,M){
cin >> x[i] >> y[i] >> c[i];
ans = min(ans,a[x[i]-1]+b[y[i]-1]-c[i]);
}
cout << ans << endl;
return 0;
}
| 0 | 98,771,283 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a,b;
string op;
cin >> a >> op >> b;
if(op == "-"){
cout << a-b<<endl;
}
else
{
cout<<a+b<<endl;}
}
|
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define mp make_pair
#define Debug(x) cout << #x " = " << (x) << endl
#define SORT(a) sort(a.begin(), a.end())
#define SORTR(a) sort(a.rbegin(), a.rend())
#define mod 1000000007
#define pi 3.141592653589793238
#define ll long long int
#define ull unsigned long long
#define be begin()
#define en end()
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define FORI(i, a, b) for (int i = a; i >= b; i--)
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> PI;
typedef pair<ll, ll> PL;
typedef vector<PI> VPI;
int main()
{
IOS;
int n, sum = 0;
cin >> n;
if (n >= 400 && n <= 599)
sum = 8;
else if (n >= 600 && n <= 799)
sum = 7;
else if (n >= 800 && n <= 999)
sum = 6;
else if (n >= 1000 && n <= 1199)
sum = 5;
else if (n >= 1200 && n <= 1399)
sum = 4;
else if (n >= 1400 && n <= 1599)
sum = 3;
else if (n >= 1600 && n <= 1799)
sum = 2;
else if (n >= 1800 && n <= 1999)
sum = 1;
cout << sum << endl;
return 0;
}
| 0 | 81,814,317 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<math.h>
using namespace std;
int main(){
int f=1,i;
int foot[2];
foot[0]=0;
foot[1]=0;
int ans=0,N;
string x;
while (1){
cin >>N;
ans=0;
f=1;
foot[0]=0;
foot[1]=0;
if(N==0)break;
for(i=0;i<N;i++){
cin >> x;
if(x=="lu"){
foot[0]++;
if(f==1 && foot[1]==1){
ans++;
f=0;
}
}
else if(x=="ru"){
foot[1]++;
if(f==1 && foot[0]==1){
ans++;
f=0;
}
}
else if(x=="ld"){
foot[0]--;
if(f==0 && foot[1]==0){
ans++;
f=1;
}
}
else{
foot[1]--;
if(f==0 && foot[0]==0){
ans++;
f=1;
}
}
}
cout << ans <<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define pb push_back
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<ll, ll>;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
ll bpow(ll b, ll p, ll m = 1000000007LL) {
ll rt = 1;
for (; p; p >>= 1, b = b * b % m)
if (p & 1)
rt = rt * b % m;
return rt;
}
ll cnt[200005];
ll a[200005];
int main() {
IOS;
int n, k, s;
cin >> n >> k >> s;
if (s < 1000000000) {
for (int i = 0; i < k; i++)
cout << s << ' ';
for (int i = 0; i < n - k; i++)
cout << s + 1 << ' ';
cout << endl;
} else {
for (int i = 0; i < k; i++)
cout << s << ' ';
for (int i = 0; i < n - k; i++)
cout << s - 1 << ' ';
cout << endl;
}
}
| 0 | 78,702,376 |
#include <bits/stdc++.h>
using namespace std;
#define INCANT cin.tie(0), cout.tie(0), ios::sync_with_stdio(0), cout << fixed << setprecision(20);
#define int long long
#define double long double
const int INF = 1e18, MOD = 1e9 + 7;
int modpow(int x, int n) {
int ret = 1;
while (n > 0) {
if (n & 1) ret = ret * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return ret;
}
signed main() {
int n, a;
cin>>n;
int cnt[66] = {};
for (int i = 0; i < n; i++) {
cin>>a;
for (int j = 0; j < 60; j++) {
if ((a >> j) & 1) {
cnt[j]++;
}
}
}
int ans = 0;
for (int i = 0; i < 60; i++) {
ans += cnt[i] * (n - cnt[i]) % MOD * modpow(2, i);
ans %= MOD;
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#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 srep(i,s,t) for(int i=(int)(s);i<(int)(t);++i)
#define each(a,b) for(auto& (a): (b))
#define all(v) (v).begin(),(v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end())
#define cmx(x,y) x=max(x,y)
#define cmn(x,y) x=min(x,y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout<<#x<<" = "<<(x)<<endl
#define spair(p) cout<<#p<<": "<<p.fi<<" "<<p.se<<endl
#define sar(a,n) cout<<#a<<":";rep(pachico,n)cout<<" "<<a[pachico];cout<<endl
#define svec(v) cout<<#v<<":";rep(pachico,v.size())cout<<" "<<v[pachico];cout<<endl
#define svecp(v) cout<<#v<<":";each(pachico,v)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
#define sset(s) cout<<#s<<":";each(pachico,s)cout<<" "<<pachico;cout<<endl
#define smap(m) cout<<#m<<":";each(pachico,m)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
using namespace std;
typedef pair<int,int> P;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 100005;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vi a(n);
rep(i,n){
cin >> a[i];
}
int ld = 1;
ll ans = 0;
rep(id,n){
if(a[id] > ld){
ans += (a[id]-1) / ld;
if(ld == 1) ld++;
}else if(a[id] == ld){
ld++;
}
}
cout << ans << "\n";
return 0;
}
| 0 | 87,750,519 |
#include <bits/stdc++.h>
using namespace std;
long ans=1,aaa,mod=1000000007,invele;
string l;
long modpow(long modpow_x,long modpow_y) {
long modpow_return=1;
for(long i=1;i<=modpow_y;i*=2) {
if(modpow_y/i%2==1) modpow_return=modpow_return*modpow_x%mod;
modpow_x=modpow_x*modpow_x%mod;
}
return modpow_return;
}
int main() {
cin >> l;
invele=modpow(3,mod-2);
for(long i=0;i<l.size();i++) ans=ans*3%mod;
aaa=ans*invele%mod*2%mod;
for(long i=1;i<l.size();i++) {
if(l[i]=='1') {
aaa=aaa*invele%mod*2%mod;
} else {
ans=(ans+(mod-aaa*invele%mod*2%mod))%mod;
aaa=aaa*invele%mod;
}
}
cout << ans << endl;
}
|
#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main(void){
int n;
string m;
while(1) {
n = 0;
cin >> m;
if(m == "0")
break;
for(int i=0;i<m.size();i++) {
int k = m[i] - '0';
n = n + k;
}
cout << n << endl;
}
}
| 0 | 31,982,129 |
#include <bits/stdc++.h>
#define ll long long int
#define dbg(x) cout<<"( "<<#x<<" -> "<<x<<" )"<<endl;
using namespace std;
int main()
{
ll a,b,k;
scanf("%lld%lld%lld",&a,&b,&k);
if (a>=k)
printf("%lld %lld\n",(a-k),b);
else if ((a+b)>=k)
printf("0 %lld\n",(b-(k-a)));
else
printf("0 0\n");
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
bool check_small(char& a) {
if ('a' <= a && a <= 'z')
return true;
return false;
}
int main(){
std::string s; std::cin >> s;
if (s[0] != 'A') {
std::cout << "WA" << std::endl;
return 0;
}
int count = 0;
int p = 0;
for (int i = 2; i < s.size() - 1; ++i) {
if (s[i] == 'C') {
++count;
p = i;
}
}
if (count != 1) {
std::cout << "WA" << std::endl;
return 0;
}
for (int i = 0; i < s.size(); ++i) {
if (i == 0) continue;
else if(i == p) continue;
else {
if (check_small(s[i]) == false) {
std::cout << "WA" << std::endl;
return 0;
}
}
}
std::cout << "AC" << std::endl;
return 0;
}
| 0 | 79,986,773 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long li;
typedef pair<li, li> pii;
pii make_set(li x, li y) {
if (x < y) {
return make_pair(y, x);
} else {
return make_pair(x, y);
}
}
pii max_of(pii x, pii y) {
vector<li> vs = {x.first, x.second, y.first, y.second};
sort(vs.begin(), vs.end());
return make_set(vs[2], vs[3]);
}
int main() {
li n;
cin >> n;
li m = 1 << n;
vector<li> xs(m);
for (int i = 0; i < m; ++i) {
cin >> xs[i];
}
vector<vector<pair<li, li>>> dp(m, vector<pair<li, li>>(n + 1));
for (int mask = 0; mask < m; ++mask) {
dp[mask][0] = make_pair(xs[mask], 0);
for (int p = 0; p < n; ++p) {
dp[mask][p + 1] = dp[mask][p];
if (mask & (1 << p)) {
dp[mask][p + 1] = max_of(dp[mask][p + 1], dp[mask ^ (1 << p)][p]);
}
}
}
li ans = 0;
for (int i = 1; i < m; ++i) {
ans = max(ans, dp[i][n].first + dp[i][n].second);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} fast;
long long mod = 1000000007;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (long long i = 0; i < (n); i++)
vector<long long> dijkstra(vector<vector<pair<long long, long long>>> graph, long long s) {
vector<long long> ans(graph.size(), -1);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>, greater<pair<long long, long long>>>
pq;
pq.push({0, s});
while (pq.size() > 0) {
ll cur1 = 0;
ll cur2 = 0;
if (ans[pq.top().second] != -1) {
pq.pop();
} else {
cur1 = pq.top().first;
cur2 = pq.top().second;
pq.pop();
ans[cur2] = cur1;
for (long long i = 0; i < graph[cur2].size(); i++) {
pq.push({cur1 + graph[cur2][i].second, graph[cur2][i].first});
}
}
}
return ans;
}
signed main() {
long long n;
cin >> n;
vector<ll> as(n);
REP(i, n) { cin >> as[i]; }
sort(as.begin(), as.end());
vector<ll> cnt(2000777);
ll ans = 0;
REP(i, n) {
if (cnt[as[i]] == 0) {
ans++;
} else {
continue;
}
if (i != n - 1 && as[i + 1] == as[i]) {
if (cnt[as[i]] == 0) {
ans--;
}
}
REP(j, 1000000 / as[i] + 1) { cnt[j * as[i]]++; }
}
cout << ans << endl;
}
| 0 | 23,496,024 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep1(i, n) for(int i = 1; i < n+1; i++)
#define sort(A) sort(A.begin(),A.end())
#define reverse(A) reverse(A.begin(),A.end());
#define vecmin(A) *min_element(A.begin(),A.end());
#define vecmax(A) *max_element(A.begin(),A.end());
typedef long long ll;
int main(){
int a,b;
cin >> a >> b;
int aa = (a+11)%13;
int bb = (b+11)%13;
if(aa > bb) cout << "Alice" << endl;
if(aa == bb) cout << "Draw" << endl;
if(aa < bb) cout << "Bob" << endl;
}
|
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>
using namespace std;
class Solution {
public:
long long solve(vector<int>& X, vector<int>& H, int a, int d) {
int n = X.size();
vector<int> SX(X);
sort(SX.begin(), SX.end());
auto index = [&](int x) {
return lower_bound(SX.begin(), SX.end(), x ) - SX.begin();
};
vector<int> R(n, -1);
iota(R.begin(), R.end(), 0);
for (int i = 0; i < n; ++i) {
long long r = X[i] + 0LL + d * 2LL;
r = min(r, (long long) SX.back() + 1);
X[i] = index(X[i]);
R[i] = index(r);
if (R[i] < n && SX[R[i]] == r) {
++R[i];
}
H[i] = (H[i] + a - 1) / a;
}
{
auto TX = X;
auto TR = R;
auto TH = H;
for (int i = 0; i < n; ++i) {
int x = X[i];
R[x] = TR[i];
H[x] = TH[i];
}
}
vector<long long> cnts(n + 1 + 1, 0);
long long res = 0;
for (int i = 0; i < n; ++i) {
cnts[i + 1] += cnts[i];
auto h = H[i] - cnts[i + 1];
if (h > 0) {
res += h;
int r = R[i];
cnts[i + 1] += h;
cnts[r + 1] -= h;
}
}
return res;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, d, a;
cin >> n >> d >> a;
vector<int> X(n);
vector<int> H(n);
for (int i = 0; i < n; ++i) {
cin >> X[i] >> H[i];
}
Solution sol;
cout << sol.solve(X, H, a, d) << "\n";
return 0;
}
| 0 | 7,394,793 |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; i--)
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 = 1000000007;
const int MOD = 1000000007;
const long long INF = 1000000000000000007;
char c;
int main() {
cin >> c;
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
cout << "vowel";
} else {
cout << "consonant";
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define ordered_set tree<pair<int,int>, null_type,less<pair<int,int> >, rb_tree_tag,tree_order_statistics_node_update>
#define standardVar ll n,m,k,num,num1,num2,flag=0
#define nn <<"\n"
#define __ <<" "<<
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define ff first
#define ss second
#define all(v) v.begin(),v.end()
#define ittr(x,v) for(auto x=v.begin();x!=v.end();x++)
#define itr(x,n) for(int x=0;x<n;x++)
#define itrab(x,a,b) for(int x=a;x<b;x++)
#define itpr(v) ittr(x,v)cout<<*x<<" "; cout nn
#define itppr(v) ittr(x,v)cout<<(*x).ff<<" "<<(*x).ss<<" "; cout nn
#define sz(x) (ll)((x).size())
#define pi 3.14159265359
#define dTor(x) ((x)*pi)/180.0
#define INF 1000000000
#define INFF 1000000000000000000
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef map<ll,ll> ml;
typedef set<ll> sl;
typedef string str;
typedef pair<ll, ll> pl;
typedef vector< pl > vpl;
typedef map<pl,ll> mpl;
typedef set< pl > spl;
typedef vector<str> vst;
typedef vector<vl> vvl;
typedef vector<vb> vvb;
const ll M=1000000007;
const ll N=998244353;
ll power(ll x, ll y, ll p){
ll res=1;
x=x%p;
if(x==0)
return 0;
while(y>0){
if(y&1)
res=(res*x)%p;
y=y>>1;
x=(x*x)%p;
}
return res;
}
ll inv(ll x, ll m){
return power(x,m-2,m);
}
ll nCr(ll n, ll r){
vl fac(10);
if (r==0)
return 1;
return (fac[n]*inv(fac[r],M)%M*inv(fac[n-r],M)%M)%M;
}
struct comp{
template<typename T>
bool operator()(const T &a, const T &b){
if (a.ff==b.ff)
return (a.ss<b.ss);
else
return (a.ff<b.ff);
}
};
bool mod(const pair<ll,ll> &a, const pair<ll,ll> &b){
if(a.ff!=b.ff)
return (a.ff<b.ff);
else
return (a.ss>b.ss);
}
void sieve(ll mn, ll mx, vl &primes){
vector<bool> pr(100000+1,true);
for(ll i=2;i*i<=100000;i++)
if(pr[i]==1)
for(ll j=i*i;j<=100000;j+=i)
pr[j]=0;
for(int i=2;i<100000;i++)
if(pr[i])
primes.pb(i);
}
bool isValid(ll i, ll j, vst &v, ll n, ll m){
if(i>=1&&i<=n&&j>=1&&j<=m){
return true;
}
return false;
}
void dfs(ll v, vvl &adj, vb &vis){
vis[v]=true;
itr(i,sz(adj[v])){
if(!vis[adj[v][i]]){
dfs(adj[v][i],adj,vis);
}
}
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
standardVar;
cin>>n>>k;
vl v(n);
itr(i,n){
cin>>v[i];
}
sort(all(v));
ll ans=0;
itr(i,k){
ans+=v[i];
}
cout<<ans;
return 0;
}
| 0 | 79,340,590 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void bfs(int x) {
int cnt = 1;
queue<ll>Q;
for(int i = 1; i <= 9; i++) {
Q.push(i);
}
while(1) {
ll t = Q.front();Q.pop();
if(cnt == x) {
printf("%lld\n", t);
return ;
}
if(t % 10 == 9) {
Q.push(t * 10 + 8);
Q.push(t * 10 + 9);
}
else if(t % 10 == 0) {
Q.push(t * 10);
Q.push(t * 10 + 1);
}
else {
for(ll j = t % 10 - 1;j <= t % 10 + 1; j++) {
Q.push(t * 10 + j);
}
}
++cnt;
}
}
int main() {
int k;
cin >> k;
bfs(k);
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <string.h>
#include <cstdio>
#include <tuple>
using namespace std; using ll = long long; using ld = long double; using pll = pair<ll, ll>;
using vl = vector<ll>; using vll = vector<vl>; using vpll = vector<pll>;
const ld PI = 3.1415926535897932;
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define rep1(n) for(ll i=0;i<n;++i)
#define rep2(i,n) for(ll i=0;i<n;++i)
#define rep3(i,a,b) for(ll i=a;i<b;++i)
#define rep4(i,a,b,c) for(ll i=a;i<b;i+=c)
#define rep(...) overload4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define mp make_pair
#define mt make_tuple
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define ULL(...) ull __VA_ARGS__;in(__VA_ARGS__)
#define STR(...) string __VA_ARGS__;in(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__;in(__VA_ARGS__)
#define DBL(...) double __VA_ARGS__;in(__VA_ARGS__)
#define LD(...) ld __VA_ARGS__;in(__VA_ARGS__)
void in() {}
void debug_out() { cerr << endl; }
template<typename Head, typename... Tail>
void debug_out(Head h, Tail... t) {
cerr << " " << h;
if (sizeof...(t) > 0) cerr << " :";
debug_out(t...);
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> vec) {
for (size_t i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
ll ctoi(char c) {
switch (c) {
case '0': return 0; case '1': return 1; case '2': return 2;
case '3': return 3; case '4': return 4; case '5': return 5;
case '6': return 6; case '7': return 7; case '8': return 8;
case '9': return 9; default: return 0;
}
}
bool pairCompare(const pll firstElof, pll secondElof)
{
return firstElof.first > secondElof.first;
}
ll i, j, k, l; ll N, M, K, H, W, L, X, Y, Z, R, Q;
ll MOD = 1000000007; ll INF = 1LL << 62; ll ans = 0; ll z = 0, o = 1;
vl flag, color, D; vll path;
int main() {
ll D;
cin >> H >> W >> D;
vll A(H, vl(W, 0));
vpll B(H * W);
for (i = 0; i < H; i++) {
for (j = 0; j < W; j++) {
cin >> A[i][j];
B[A[i][j] - 1] = mp(i, j);
}
}
cin >> Q;
vl sum(H * W);
for (i = 0; i < H*W; i++) {
if (i >= D) sum[i] = sum[i - D] + abs(B[i].first - B[i-D].first) + abs(B[i].second - B[i - D].second);
else sum[i] = 0;
}
for (i = 0; i < Q; i++) {
ll l, r;
cin >> l >> r;
l--; r--;
cout << sum[r] - sum[l] << endl;
}
}
| 0 | 41,903,331 |
#include<iostream>
#include<vector>
#include<utility>
#include<algorithm>
using namespace std ;
int main()
{
int N,A,B ;
cin>>N>>A>>B ;
vector<int>P(N) ;
for(int i=0;i<N;i++) cin>>P.at(i) ;
sort(P.begin(),P.end()) ;
int num_1=0,num_2=0,num_3=0 ;
for(int i=0;i<N;i++){
if(P.at(i)<=A) num_1++ ;
else if(A+1<=P.at(i)&&P.at(i)<=B) num_2++ ;
else if(B+1<=P.at(i)) num_3++ ;
}
int X=(num_1<num_2?num_1:num_2) ;
cout<<(X<num_3?X:num_3)<<endl ;
return 0 ;
}
|
#include <iostream>
using namespace std;
int main() {
string stra;
int x;
bool r=true;
cin >> stra;
x= stra.length();
for(int i=0;i<x;i++){
for(int j=i+1;j<x;j++){
if(stra[i]==stra[j]){
r=false;
break;
}
}
}
if(r==false){
cout << "no" << endl;
}else if(r==true){
cout << "yes" << endl;
}
}
| 0 | 43,922,156 |
#include <iostream>
using namespace std;
int main() {
int K, A, B;
cin >> K >> A >> B;
if (B/K - (A-1)/K >= 1) cout << "OK" << endl;
else cout << "NG" << endl;
}
|
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <unordered_set>
#include <stack>
#include <queue>
#include <math.h>
#include <string>
#include <numeric>
#include <algorithm>
#include <utility>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int gcd(int a, int b) {
while (b != 0) {
auto na = a % b;
a = b;
b = na;
}
return a;
}
void oneCase() {
int a, b;
cin >> a >> b;
if (a % 3 == 0 || b % 3 == 0 || (a + b) % 3 == 0) {
cout << "Possible" << "\n";
} else {
cout << "Impossible" << "\n";
}
}
int main() {
int t = 1;
while (t--) {
oneCase();
}
return 0;
}
ll fact(ll n, ll mod) {
ll res = 1;
while (n > 0) {
res = (res * n) % mod;
--n;
}
return res;
}
| 0 | 89,921,517 |
#include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int X, Y;
cin >> X >> Y;
cout << X + Y / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long int> H(N);
for(int i = 0; i < N; i++) {
cin >> H[i];
}
int ans = 0;
if(N > 1) {
for(int i = 0; i < N - 1; i++) {
int count = 0;
for(int j = 0; j < N - i - 1; j++) {
if(H[i + j] >= H[i + j + 1]) {
count++;
}
else {
break;
}
}
if(count > ans) {
ans = count;
}
}
}
cout << ans << endl;
}
| 0 | 73,869,186 |
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cmath>
#include<vector>
#include<set>
#include<map>
#include<algorithm>
#include<unordered_map>
#include<bits/stdc++.h>
#define ll long long
#define d double
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int r;
cin>>r;
int A=3*r*r;
int a=3*1*1;
cout<<A/a<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long int> a(N);
long long int y = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
y += a[i];
}
long long int x = 0;
long long int min = LLONG_MAX;
for (int i = 0; i < N - 1; i++) {
x += a[i];
y -= a[i];
if (abs(x - y) < min) {
min = abs(x - y);
}
}
cout << min << endl;
return 0;
}
| 0 | 68,935,369 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
using ll = long long;
using P = pair<int,int>;
using PP = pair<int,pair<int,int>>;
using T = tuple<string,int,int>;
const ll INF = 1LL<<60;
const int ny[4] = {-1,1,0,0}, nx[4] = {0,0,-1,1};
int sy,sx,gy,gx;
int main(){
int n,m; cin >> n >> m;
string a[n], b[m];
rep(i,n) cin >> a[i];
rep(i,m) cin >> b[i];
int cnt = 0;
for(int i = 0; i <= n-m; i++){
for(int j = 0; j <= n-m; j++){
bool flg = true;
for(int bi = 0; bi < m; bi++){
for(int bj = 0; bj < m; bj++){
if(b[bi][bj] != a[i+bi][j+bj]) flg = false;
}
}
if(flg) cnt++;
}
}
if(cnt) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define For(i, a, b) for (int(i) = (int)(a); (i) < (int)(b); ++(i))
#define rFor(i, a, b) for (int(i) = (int)(a)-1; (i) >= (int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef pair<lint, lint> pll;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
T div_floor(T a, T b) {
if (b < 0) a *= -1, b *= -1;
return a >= 0 ? a / b : (a + 1) / b - 1;
}
template <class T>
T div_ceil(T a, T b) {
if (b < 0) a *= -1, b *= -1;
return a > 0 ? (a - 1) / b + 1 : a / b;
}
constexpr lint mod = 1000000007;
constexpr lint INF = mod * mod;
constexpr int MAX = 200010;
int main() {
int n, m;
scanf("%d%d", &n, &m);
bool G[n][n];
rep(i, n) rep(j, n) G[i][j] = false;
rep(i, m) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
G[a][b] = G[b][a] = true;
}
int p[n];
iota(p, p + n, 0);
int ans = 0;
do {
bool flag = true;
rep(i, n - 1) if (!G[p[i]][p[i + 1]]) {
flag = false;
break;
}
ans += flag;
} while (next_permutation(p + 1, p + n));
printf("%d\n", ans);
}
| 0 | 54,817,720 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
int main()
{
int a,b,c;
cin>>a>>b>>c;
cout<<max(a,max(b,c))*9+a+b+c<<endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;typedef long long lint;typedef vector<lint> liv;
#define all(v) v.begin(),v.end()
#define linf 1152921504606846976
#define MAXN 100010
#define md 1000000007
#define pb push_back
#define _vcppunko4(tuple) _getname4 tuple
#define _getname4(_1,_2,_3,_4,name,...) name
#define _getname3(_1,_2,_3,name,...) name
#define _trep2(tuple) _rep2 tuple
#define _trep3(tuple) _rep3 tuple
#define _trep4(tuple) _rep4 tuple
#define _rep1(n) for(lint i=0;i<n;++i)
#define _rep2(i,n) for(lint i=0;i<n;++i)
#define _rep3(i,a,b) for(lint i=a;i<b;++i)
#define _rep4(i,a,b,c) for(lint i=a;i<b;i+=c)
#define _trrep2(tuple) _rrep2 tuple
#define _trrep3(tuple) _rrep3 tuple
#define _trrep4(tuple) _rrep4 tuple
#define _rrep1(n) for(lint i=n-1;i>=0;i--)
#define _rrep2(i,n) for(lint i=n-1;i>=0;i--)
#define _rrep3(i,a,b) for(lint i=b-1;i>=a;i--)
#define _rrep4(i,a,b,c) for(lint i=a+(b-a-1)/c*c;i>=a;i-=c)
template<class T>
istream& operator>>(istream& is,vector<T>& vec);
template<class T,size_t size>
istream& operator>>(istream& is,array<T,size>& vec);
template<class T,class L>
istream& operator>>(istream& is,pair<T,L>& p);
template<class T>
ostream& operator<<(ostream& os,vector<T>& vec);
template<class T,class L>
ostream& operator<<(ostream& os,pair<T,L>& p);
template<class T>
istream& operator>>(istream& is,vector<T>& vec){ for(T& x: vec) is>>x;return is; }
template<class T,class L>
istream& operator>>(istream& is,pair<T,L>& p){ is>>p.first;is>>p.second;return is; }
template<class T,class L>
ostream& operator<<(ostream& os,pair<T,L>& p){ os<<p.first<<" "<<p.second;return os; }
inline void in(){}
template <class Head,class... Tail>
inline void in(Head&& head,Tail&&... tail){ cin>>head;in(move(tail)...); }
template <class T>
inline bool out(T t){ cout<<t<<'\n';return 0; }
inline bool out(){ cout<<'\n';return 0; }
template <class Head,class... Tail>
inline bool out(Head head,Tail... tail){ cout<<head<<' ';out(move(tail)...);return 0; }
#define rep(...) _vcppunko4((__VA_ARGS__,_trep4,_trep3,_trep2,_rep1))((__VA_ARGS__))
#define rrep(...) _vcppunko4((__VA_ARGS__,_trrep4,_trrep3,_trrep2,_trrep1))((__VA_ARGS__))
#define lin(...) lint __VA_ARGS__;in(__VA_ARGS__)
#define stin(...) string __VA_ARGS__;in(__VA_ARGS__)
#define vin(type,name,size) vector<type> name(size);in(name)
#define fi i.first
#define se i.second
bool dp[4040][16060];
int main(){
stin(s);
lint n=s.size();
lin(x,y);
lint startx=0,cur=0;
while(cur<n&&s[cur]=='F')++startx,++cur;
++cur;
liv a,b;
liv *ope=&b;
lint ctr=0;
rep(i,cur,n){
while(i<n&&s[i]=='F')++i,++ctr;
ope->push_back(ctr); ctr=0;
if(ope==&b)ope=&a;
else ope=&b;
}
dp[0][8000+startx]=1;
rep(a.size()){
rep(j,16060){
if(0<=j+a[i]&&j+a[i]<16060)dp[i+1][j+a[i]]|=dp[i][j];
if(0<=j-a[i]&&j-a[i]<16060)dp[i+1][j-a[i]]|=dp[i][j];
}
}
bool ans=dp[a.size()][8000+x];
rep(4040)fill(dp[i],dp[i]+16060,0);
dp[0][8000]=1;
rep(b.size()){
rep(j,16060){
if(0<=j-b[i]&&j-b[i]<16060)dp[i+1][j-b[i]]|=dp[i][j];
if(0<=j+b[i]&&j+b[i]<16060)dp[i+1][j+b[i]]|=dp[i][j];
}
}
ans&=dp[b.size()][8000+y];
cout<<(ans?"Yes\n":"No\n");
}
| 0 | 18,601,878 |
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <iomanip>
using namespace std;
float min(float a, float b){
if (a<b){
return a;
}else{
return b;
}
}
int main(){
int N;
cin >> N;
vector<int> t(N+3,0),v(N+2,0);
for(int i=2; i<N+2; i++){
int a;
cin >> a;
t[i]=t[i-1]+2*a;
}
t[N+2]=t[N+1];
for(int i=1; i<N+1; i++){
cin >> v[i];
}
v[0]=0;v[N+1]=0;
vector<float> v_limit(t[N+2]+1,10000);
v_limit[0]=0;
v_limit[t[N+2]]=0;
for(int i=0; i<N+2; i++){
for(int j=t[i]; j<=t[i+1]; j++){
v_limit[j]=min(v_limit[j],v[i]);
}
for(int j=1; t[i]-j>=0; j++){
v_limit[t[i]-j]=min(v_limit[t[i]-j],(float)v[i]+0.5*j);
}
for(int j=1; t[i+1]+j<=t[N+2];j++){
v_limit[t[i+1]+j]=min(v_limit[t[i+1]+j], (float)v[i]+0.5*j);
}
}
float ans=0;
for(int i=0; i<t[N+2]; i++){
ans+=(v_limit[i+1]+v_limit[i]);
if(i%2==0){
}
}
cout << fixed << setprecision(4) << ans/4 << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define revrep(i,a,b) for(int i = a; i > b; i--)
#define int long long
#define exist(s,e) ((s).find(e)!=(s).end())
#define all(v) (v).begin(), (v).end()
#define each(s,itr) for(auto (itr) = s.begin(); (itr) != s.end(); (itr)++)
#define sum(v) accumulate(all(v), (0LL))
#define isin(a, b, c) (b <= a && a <= c)
#define println cout << "\n";
#define sz(v) (int)v.size()
#define bin(x) static_cast<bitset<16> >(x)
#define pb(x) push_back(x)
template<class T> using vec = vector<T>;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef tuple<int, int, int> ti;
typedef map<int, int> mi;
typedef set<int> si;
const int inf = 1LL << 62;
const int mod = 1e9 + 7;
const int dx[8]={1,0,-1,0,-1,1,-1,1};
const int dy[8]={0,1,0,-1,-1,-1,1,1};
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
int input(){int tmp;cin >> tmp;return tmp;}
string raw_input(){string tmp;cin >> tmp;return tmp;}
template<class T> void printx(T n){cout << n;}
template<class T, class U> void printx(pair<T, U> p){cout << "(" << p.first << "," << p.second << ")";}
template<class T, class U, class V> void printx(tuple<T, U, V> t){cout << "{" << get<0>(t) << "," << get<1>(t) <<"," << get<2>(t) << "}" << endl;}
template<class T> void printx(vector<T> v){cout << "{";rep(i,0,v.size()){printx(v[i]);if(i != v.size()-1)printx(",");}cout << "}";}
template<class T> void print(T n){printx(n);cout << endl;}
template<class T> void print(set<T> s){cout << "{";each(s, e){if(e != s.begin()) printx(",");printx(*e);}cout << "}" << endl;}
template<class T, class U> void print(map<T, U> mp){cout << "{";each(mp, e){cout << "(" << e -> first << "," << e -> second << ")";}cout << "}" << endl;}
template<class T> void printans(vec<T> v){rep(i,0,sz(v)){cout << v[i] << (i == sz(v) - 1 ? "" : " ");}cout << endl;}
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; }
template<class T>T cut(T &a, int l, int r){return T(a.begin()+l, a.begin()+r);}
int w, h;
vec<pi> edges;
void in(){
cin >> w >> h;
rep(i,0,w) edges.pb(pi(input(), 0));
rep(i,0,h) edges.pb(pi(input(), 1));
}
void solve(){
sort(all(edges));
int ans = 0;
int hei = 0;
int wid = 0;
rep(i,0,w + h){
int cost;
if(edges[i].second == 0){
wid++;
cost = (h + 1 - hei) * edges[i].first;
ans += cost;
}else{
hei++;
cost = (w + 1 - wid) * edges[i].first;
ans += cost;
}
}
print(ans);
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
in();
solve();
}
| 0 | 74,535,487 |
#include <bits/stdc++.h>
using namespace std;
# define REP(i,n) for (int i=0;i<(n);++i)
# define rep(i,a,b) for(int i=a;i<(b);++i)
# define p(s) std::cout << s ;
# define pl(s) std::cout << s << endl;
# define printIf(j,s1,s2) cout << (j ? s1 : s2) << endl;
# define YES(j) cout << (j ? "YES" : "NO") << endl;
# define Yes(j) std::cout << (j ? "Yes" : "No") << endl;
# define yes(j) std::cout << (j ? "yes" : "no") << endl;
# define all(v) v.begin(),v.end()
# define showVector(v) REP(i,v.size()){p(v[i]);p(" ")} pl("")
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;}
typedef long long int ll;
typedef pair<ll,ll> P_ii;
typedef pair<double,double> P_dd;
template<class T>
vector<T> make_vec(size_t a){
return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template<typename T,typename V>
typename enable_if<is_class<T>::value==0>::type
fill_v(T &t,const V &v){t=v;}
template<typename T,typename V>
typename enable_if<is_class<T>::value!=0>::type
fill_v(T &t,const V &v){
for(auto &e:t) fill_v(e,v);
}
const int MOD = 1000000007;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
void addM(long long &a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
}
void mulM(long long &a, long long b) {
a = ((a%MOD)*(b%MOD))%MOD ;
}
long myPow(long a,long b,int M) {
long ret = 1;
long tmp = a;
while(b>0) {
if((b&1)==1) ret = (ret * tmp) % M;
tmp = (tmp * tmp) % M;
b = b>>1;
}
return ret;
}
int nCk(int n,int k,int M) {
long ret = 1;
int mi = min(k, n-k);
for(int i=1;i<=mi;i++) {
ret = (ret * myPow(i,M-2,M)) % M;
}
for(int i=n-mi+1;i<=n;i++) {
ret = (ret * i) % M;
}
return (int)ret;
};
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) { ++num; n /= p; }
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
int main() {
int n; cin >> n;
vector<int> a(n);
vector<int> b(n);
REP(i,n) cin >> a[i];
REP(i,n) cin >> b[i];
int j=0;
while(a[j]!=a[n-1]) j++;
if(b[j]!=a[n-1] || a[n-1] != b[0]) {
cout << 0 << endl;
return 0;
}
ll ans = 1;
REP(i,n-2) if(a[i]==a[i+1] && b[i+1]==b[i+2]) mulM(ans,min(a[i+1],b[i+1]));
pl(ans)
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define INF 1000000000
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int N;
string S;
cin >> N >> S;
bool flag = true;
if(N%2 == 0){
REP(i, N/2){
if (S[i] != S[N/2+i]) {
flag = false;
break;
}
}
}
else flag = false;
if(flag) cout << "Yes" << endl;
else cout << "No" << endl;
}
| 0 | 97,093,697 |
#include <bits/stdc++.h>
#include<iostream>
#include<vector>
#include<map>
#include<math.h>
#define irep(i,n) for(int i = 0; i < (int)(n); i++)
#define irep2(i,a,n) for(int i = (int)(a); i <= (int)(n); i++)
#define irrep(i,n) for(int i = (int)(n-1); i > -1; i--)
#define irrep2(i,n,a) for(int i = (int)(n); i >= (int)(a); i--)
#define fi first
#define se second
using namespace std;
using ll = long long;
using v_int = vector<int>;
using v2_int = vector<v_int>;
using v_ll = vector<ll>;
using v2_ll = vector<v_ll>;
using v_string = vector<string>;
using v_bool = vector<bool>;
using v2_bool = vector<v_bool>;
using pii = pair<int, int>;
using mii = map<int, int>;
const double PI = 3.1415926535897932;
const int INF = (int)2e9;
const ll LINF = (ll)2e18;
const ll MOD = 1000000007;
const int dc[8] = {1, -1, 0, 0, 1, -1, 1, -1};
const int dr[8] = {0, 0, 1, -1, 1, 1, -1, -1};
template<typename T, typename U> inline
ostream& operator<<(ostream &o, pair<T,U> &p) {
return o << "{" << p.first << "," << p.second << "}";
}
template<typename T> inline
istream& operator>>(istream &is, vector<T> &vec) {
for(auto &v : vec) { is >> v; }
return is;
}
template<typename T> inline
ostream& operator<<(ostream &os, vector<T> &vec) {
for(auto &v : vec) { os << v << ",";}
return os;
}
template<typename T> inline
ostream& operator<<(ostream &os, vector<vector<T> > &mat) {
for(auto &row : mat) { os << row << endl; }
return os;
}
template<typename T> inline
void chmin(T &a, T b) { a = min(a, b); }
template<typename T> inline
void chmax(T &a, T b) { a = max(a, b); }
int main(void)
{
int l, r;
cin >> l >> r;
r = min(r, l + 3000);
int ans = 2019;
for(int i = l; i <= r; i++) {
for(int j = i+1; j <= r; j++) {
int mul = ((ll)i * j) % 2019;
chmin(ans, mul);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
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 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++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
typedef vector<int> vec;
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%m;
a = a * a%m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
void solve() {
int N; cin >> N;
vector<pair<ll, LP>> v;
rep(i, N){
ll a, b; cin >> a >> b;
v.push_back(make_pair(a+b, make_pair(a, b)));
}
sort(all(v));
reverse(all(v));
ll t=0, k=0;
rep(i, N){
if(i%2 == 0){
t += v[i].second.first;
}else{
k += v[i].second.second;
}
}
cout << t - k << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 0 | 14,574,951 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define rep(i, n) for(int i = 0; i < (n); ++i)
int mod = 1e9+7;
int main()
{
int n;
cin >> n;
int dp[n+1] = {0};
dp[0] = 1;
for (int i=1; i<=n; i++) {
for (int j=0; j<=i-3; j++) {
dp[i] += dp[j];
dp[i] %= mod;
}
}
cout << dp[n] << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define lln long long int
#define llu unsigned lln
#define sc(n) scanf("%d",&n);
#define scl(n) scanf("%lld",&n);
#define scd(n) scanf("%lf",&n);
#define pf(res) printf("%d\n",res);
#define pfl(res) printf("%lld\n",res);
#define pfd(res) printf("%lf\n",res);
#define maxii 100005
using namespace std;
typedef pair<int,int> pii;
typedef pair<lln,lln> pll;
typedef vector<int> vi;
typedef vector<lln> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
int arr[maxii];
int arr2[maxii];
int gcd(int a,int b)
{
if(b==0){
return a;
}
return gcd(b,a%b);
}
int lcm(int a,int b)
{
int res=(a*b)/gcd(a,b);
return res;
}
int po(int a,int b)
{
int res=1;
while(b)
{
if(b%2!=0)
{
res*=a;
b--;
}
else
{
a*=a;
b/=2;
}
}
return res;
}
lln modMul(lln a, lln b,lln mod){
lln ans = 0;
a = a % mod;
while (b > 0){
if ( b % 2 )ans = (ans%mod+ a%mod) % mod;
a = (a%mod * 2%mod) % mod;
b /= 2;
}
return ans % mod;
}
lln powerMod(lln a,lln b,lln mod){
if(b==0)return 1LL%mod;
lln x=powerMod( a,b/2,mod );
x = ( x%mod * x%mod ) % mod;
if( b%2==1 )x = ( x%mod * a%mod ) % mod;
return x%mod;
}
int main()
{
string a,b;
cin>>a>>b;
int len1=a.size();
int len2=b.size();
if(len1>len2)cout<<"GREATER";
else if(len2>len1)cout<<"LESS";
else
{
int carry=0,g=0;
for(int i=0;i<len1;i++)
{
if(a[i]!=b[i])
{
g=1;
break;
}
}
if(g==0)
{
cout<<"EQUAL";
return 0;
}
for(int i=len1-1;i>=0;i--)
{
int p=a[i]-'0';
int q=b[i]-'0';
q+=carry;
if(p-q<0)
{
carry=1;;
}
else
{
carry=0;
}
}
if(carry)printf("LESS");
else cout<<"GREATER";
}
}
| 0 | 36,465,018 |
#include <cstdio>
#define ll long long
int main() {
ll a, b, c, k;
scanf("%lld %lld %lld %lld", &a, &b, &c, &k);
if(a - b < -1000000000000000000 || 1000000000000000000 < a - b)
printf("Unfair\n");
else
printf("%lld\n", (a - b) * (1 - k % 2 * 2));
}
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
#define int long long
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
long long power(long long a, long long b,long long m) {
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a %m;
a = a * a %m;
b >>= 1;
}
return res;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
string a;
cin>>a;
int n=a.length();
if(n<4)
{
cout<<"No\n";
}
else
{
if(a.substr(0,4)=="YAKI")
cout<<"Yes";
else
cout<<"No";
}
}
| 0 | 20,847,460 |
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define until(x) while(!(x))
#define unless(x) if(!(x))
#define all(x) (x).begin(),(x).end()
#define F first
#define S second
#define pc __builtin_popcount
string s;
map<char,int> mp;
int32_t main(){
cin>>s;
int n = s.length();
for(int i=0;i<n;i++){
mp[s[i]]++;
}
char mex = 0;
for(char c = 'a';c<='z';c++){
if(!mp[c]){
mex = c;
break;
}
}
if(!mex){
mp.clear();
string t = s;
if(!next_permutation(all(s))){
cout<<-1;
return 0;
}
else {
for(int i=0;i<s.length();i++){
cout<<s[i];
if(s[i]!=t[i]){
return 0;
}
}
}
}
cout<<s+mex;
}
|
#include <iostream>
#include <iomanip>
using namespace std;
int main(){
int n;
cin >> n;
long *data = new long[n];
long min,max,sum=0;
for(int i=0; i<n; i++){
cin >> data[i];
if(i==0){
min=max=sum=data[0];
}else{
if(min>data[i]){
min=data[i];
}
if(max<data[i]){
max=data[i];
}
sum += data[i];
}
}
cout << min << " " << max << " " << sum << endl;
return(0);
}
| 0 | 54,842,884 |
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
#define int long long
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
int n,k;
cin>>n>>k;
if(k==1)
{
cout<<0;
return 0;
}
int ans=n-k;
cout<<ans;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
string ans;
if (a + b > c + d) {
ans = "Left";
}
else if (a + b == c + d) {
ans = "Balanced";
}
else{
ans = "Right";
}
cout << ans << endl;
return 0;
}
| 0 | 84,131,443 |
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int N, K;
int L[60];
int su = 0;
cin >> N >> K;
for (int i = 0; i < N; ++i) cin >> L[i];
sort(L, L+N, greater<int>());
for (int k = 0; k < K; ++k) su += L[k];
cout << su << endl;
}
|
#include <iostream>
#include <string>
#include <map>
using namespace std;
map<string,int> table;
int main(){
string word, frequent, longest;
int frequent_length = 0;
while (cin >> word){
table[word] += 1;
if (table[word] > frequent_length){
frequent_length = table[word];
frequent = word;
}
longest = (word.size() > longest.size()) ? word : longest;
}
cout << frequent << ' ' << longest << endl;
return 0;
}
| 0 | 72,533,906 |
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n;
vector<int> r;
while (scanf("%d",&n) != EOF)
{
int sum=0;
for (int i=n; i<600; i+=n)
{
sum+=i*i*n;
}
r.push_back(sum);
}
for (int i=0; i<r.size(); i++)
{
cout << r[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define prtd(var, i) cout << fixed << setprecision(i) << var << endl;
#define ll long long
using namespace std;
#define INF 1e18LL
const ll MAX = 1000000000000000000;
int main(){
string s;
cin >> s;
bool exist = true;
int cnt = 0;
int n = s.size();
rep(i, n){
if(i == 0){
if(s[i] != 'A') exist = false;
}else if(2 <= i && i <= n-2){
if(s[i] == 'C') cnt++;
}else{
if('a' <= s[i] && s[i] <= 'z'){
continue;
}else{
exist = false;
}
}
}
if(exist && cnt == 1) cout << "AC" << endl;
else cout << "WA" << endl;
}
| 0 | 2,649,321 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i = 0 ; i < (n); ++i)
using namespace std ;
typedef long long ll ;
const int mod=1000000007 ;
void solve(){
int x,y,a,b,t ;
cin>>x>>y>>a>>b>>t ;
int temp1=x*60+y ;
int temp2=a*60+b ;
int c=temp2-temp1 ;
cout<<c-t ;
}
int main(){
int y ;
y=1 ;
while(y--){
solve() ;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define N 250
#define ll long long
#define pb push_back
#define pi pair<ll , ll>
#define mp make_pair
bool check(string v , string& str){
int j = 0 ;
for(int i = 0 ; i <(int)str.length() && j < (int)v.length() ; i++){
if(v[j] == str[i]){
j++;
if(j == (int)v.length())return true;
}
}
return false;
}
int main(){
int n;
cin>>n;
string str;
cin>>str;
set<string> v;
for(int i = 0 ; i < 10 ; i++){
for(int j = 0 ; j < 10 ; j++){
for(int k = 0 ; k < 10 ; k++){
int l = i*100 + j*10 + k;
string s ="123";
s[0] = char(i+'0');
s[1] = (j+'0');
s[2] = (k+'0');
v.insert(s);
}
}
}
int ans = 0;
for(auto it : v){
if(check(it , str) && it.length() == 3){
ans++;
}
}
cout<<ans<<endl;
}
| 0 | 59,719,654 |
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);i++)
typedef long long ll;
using namespace std;
int main(){
ll x,y;
cin >> x >> y;
int ans = 0;
while(y >= x){
x *= 2;
ans += 1;
}
cout << ans << endl;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int n,s[5000+10];
int biggest(int n){
int M=-200000-10;
for(int p=0;p<n;p++){
if(s[p]>M) M=s[p];
for(int q=0;q<p;q++){
if(s[p]-s[q]>M) M=s[p]-s[q];
}
}
return M;
}
int main(){
int n;
while(cin){
cin >> n;
if(n==0) break;
int a[5000+10];
for(int i=0;i<n;i++){
cin >> a[i];
if(i==0) s[i]=a[i];
else s[i]=s[i-1]+a[i];
}
cout << biggest(n) << endl;
}
}
| 0 | 44,532,294 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int now;
int goal;
cin >> now;
cin >> goal;
cout << 2 * goal - now << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n,i,c=1;
cin>>n;
int s[n];
for(i=0;i<n;i++)
{
cin>>s[i];
}
for(i=0;i<n-1;i++)
{
if(s[i]>s[i+1])
{
c++;
}
else
{
s[i+1]=s[i];
}
}
cout<<c<<endl;
return 0;
}
| 0 | 96,080,296 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int,int>
#define fi first
#define sc second
#define all(x) (x).begin(),(x).end()
#define dbg(x) cerr << __LINE__ << " > " << #x << " = " << (x) << endl
void MAIN() {
int a, b;
cin >> a >> b;
cout << (a + b + 1) / 2 << '\n';
}
signed main() {
#ifdef _DEBUG
#endif
ios::sync_with_stdio(0); cin.tie(0);
int T = 1;
while (T--) MAIN();
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
signed main(void)
{
int h, w, a, b;
cin >> h >> w >> a >> b;
int s[h][w];
rep(i, h)
{
rep(j, w)
{
if (i < b && j < a)
s[i][j] = 0;
else if (i < b)
s[i][j] = 1;
else if (j < a)
s[i][j] = 1;
else
s[i][j] = 0;
}
}
rep(i, h)
{
rep(j, w)
cout << s[i][j];
cout << '\n';
}
return 0;
}
| 0 | 57,198,502 |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define SIZE 2005
ll N,M;
ll S[SIZE],T[SIZE];
ll dp[SIZE][SIZE];
vector<int> G[SIZE];
int main(){
scanf("%lld %lld",&N,&M);
for(ll i = 0; i < N; i++){
scanf("%lld",&S[i]);
}
for(ll i = 0; i < M; i++){
scanf("%lld",&T[i]);
}
for(ll i = 0; i < N; i++){
for(ll k = 0; k < M; k++){
if(S[i] == T[k]){
G[i].push_back(k+1);
}
}
}
for(ll i = 0; i <= N; i++){
for(ll k = 0; k <= M; k++){
dp[i][k] = 0;
}
}
dp[0][0] = 1;
for(ll i = 0; i < N; i++){
for(ll k = 0; k <= M; k++){
dp[i+1][k] = dp[i][k];
}
for(ll k = 1; k <= M; k++){
dp[i][k] += dp[i][k-1];
dp[i][k] %= MOD;
}
for(ll k = 0; k < G[i].size(); k++){
dp[i+1][G[i][k]] += dp[i][G[i][k]-1];
dp[i+1][G[i][k]] %= MOD;
}
}
ll ans = 0;
for(ll i = 0; i <= M; i++){
ans += dp[N][i];
ans %= MOD;
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>
#include <map>
#include <bitset>
#include <cmath>
#include <set>
#include <utility>
#define INF 1000000000000
#define MOD 1000000007
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
int main(){
ll N,rs=0,max=0;
cin >> N;
vector<ll> H(N);
for(ll i = 0;i < N;i++)
cin >> H.at(i);
for(ll i = 0;i < N -1;i++){
if(H.at(i) >= H.at(i+1)){
rs++;
}else{
if(rs > max)
max = rs;
rs = 0;
}
if(i == N -2){
if(rs > max)
max = rs;
}
}
cout << max << endl;
}
| 0 | 28,250,414 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define REP(i,n) for (int64_t i=0; i<(n); ++i)
#define P pair<int,int>
using ll=int64_t;
using namespace std;
#define ketasuu(n) fixed<<setprecision(n)
#define btoe(p) p.begin(),p.end()
#define etob(p) p.rbegin(),p.rend()
#define chmax(x,y) x=max(x,y)
int main(){
int n; cin>>n;
int a=n, b=0;
while(a){
b+=a%10;
a/=10;
}
if(n%b==0){
cout<<"Yes"<<endl;
}else{
cout<<"No"<<endl;
}
}
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ff first
#define ss second
#define all(v) v.begin(), v.end()
#define int long long
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define mem(dp,x) memset(dp,x,sizeof dp);
#define mii map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define rightmostbit(x) __builtin_ffsll(x)
#define mod 1000000007
#define inf 1e18
#define pi 3.141592653589793238
#define mk(a,n) int n;cin>>n;vi a(n);for(int i=0;i<n;i++) cin>>a[i]
#define w(x) int x; cin>>x; while(x--)
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int dx[] = { -1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int dx2[] = { -1 , -1 , -1, 0 , 0 , 1 , 1 , 1};
int dy2[] = { -1 , 0 , 1 , -1, 1 , -1, 0, 1};
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
void g_b()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
}
int32_t main()
{
g_b();
int n; cin >> n;
int c = 0;
n--;
for (int i = 1; i <= n; i++) c += (n / i);
cout << c;
return 0;
}
| 0 | 20,687,952 |
#include<bits/stdc++.h>
#define int long long
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<int,int>
#define f(i,l,r) for(int i=l;i<=r;i++)
#define rf(i,r,l) for(int i=r;i>=l;i--)
#define done(i) cout<<"done = "<<i<<endl;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const int inf=1e18;
const int mod=1e9+7;
const int M=100009;
inline int bigmod(int B,int P){int R=1;while(P>0){if(P&1){R=(R*B)%mod;}P>>=1;B=(B*B)%mod;}return R;}
main()
{
fast
int n;
cin>>n;
int a[n+5];
int sum=0;
f(i,1,n)
{
cin>>a[i];
sum+=a[i];
}
int yo=(n*(n+1))/2;
if(sum%yo!=0)
{
cout<<"NO"<<endl;
return 0;
}
int k=sum/yo;
a[n+1]=a[1];
for(int i=2;i<=n+1;i++)
{
int d=a[i]-a[i-1];
int magic=k-d;
if(magic<0)
{
cout<<"NO"<<endl;
return 0;
}
if(magic%n!=0)
{
cout<<"NO"<<endl;
return 0;
}
}
cout<<"YES"<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long int n,m=0,s,l=0,c=0,i,k,b;
cin>>n;
m=n-1;
for(i=1;i<=sqrt(n);i++){
if(!(n % i)){
k=i;
s=n/k;
m=min(m,(k-1)+(s-1));
l=1;
}
}
if(l)
cout<<m;
else
cout<<n-1;
}
| 0 | 36,223,328 |
#include <bits/stdc++.h>
using namespace std;
class UnionFind{
private:
vector<int> parent,rank,tree_w;
int tree_num;
public:
UnionFind(int size){
tree_num=size;
for (int i=0; i<size; i++){
parent.push_back(i);
rank.push_back(0);
tree_w.push_back(1);
}
}
int findset(int x){
return x==parent[x] ? x : parent[x]=findset(parent[x]);
}
void unite(int x,int y){
x=findset(x);y=findset(y);
if (x==y) return;
if (rank[x]>rank[y]) swap(x,y);
parent[x]=y;
tree_num-=1;
tree_w[y]+=tree_w[x];
if (rank[x]==rank[y]) rank[y]+=1;
}
bool same(int x,int y){
return findset(x)==findset(y);
}
int tree_number(){
return tree_num;
}
int tree_weight(int x){
return tree_w[findset(x)];
}
};
int n,q;
int main(){
cin >> n >> q;
UnionFind uf(n);
for(int i=0; i<q; i++){
int c,x,y;
cin >> c >> x >> y;
if(c==0) uf.unite(x,y);
else cout << uf.same(x,y) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char *argv[]) {
int n, m;
cin >> n >> m;
vector<vector<int>> d(n, vector<int>(n, -1)), next(n, vector<int>(n, -1)),
indeces(n, vector<int>(n, -1));
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
d[a][b] = c;
d[b][a] = c;
next[a][b] = b;
next[b][a] = a;
indeces[a][b] = i;
indeces[b][a] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (d[j][i] < 0 || d[i][k] < 0) {
continue;
}
int new_dist = d[j][i] + d[i][k];
if (d[j][k] < 0 || new_dist < d[j][k]) {
d[j][k] = new_dist;
next[j][k] = next[j][i];
}
}
}
}
vector<bool> used(m, false);
for (int i = 0; i < n - 1; ++i) {
for (int j = i + 1; j < n; ++j) {
int cur = i;
while (cur != j) {
if (indeces[cur][next[cur][j]] != -1) {
used[indeces[cur][next[cur][j]]] = true;
}
cur = next[cur][j];
}
}
}
cout << count(used.begin(), used.end(), false) << '\n';
}
| 0 | 13,604,992 |
#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() {
cerr << endl;
}
template <typename H, typename... T>
void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T>
void print(T x) {
cout << x << endl;
}
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> Pll;
typedef pair<int,int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9+7;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> v(N);
REP(i, N) {
ll a, b; cin >> a >> b;
v[i] = {a, b};
}
sort(ALL(v));
priority_queue<ll> q;
int j = 0;
ll ans = 0;
FOR(i, 1, M + 1) {
for(; j < N && i >= v[j].fi; ++j) {
q.push(v[j].se);
}
if (q.empty()) continue;
ans += q.top(); q.pop();
}
print(ans);
}
|
#include <iostream>
#include <string>
#include <array>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <cctype>
#include <map>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define FOR(i,l,r) for(size_t i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
using namespace std;
bool is_integer( float x ){
return floor(x)==x;
}
int main() {
int n;
int a[200000];
int count = 0;
int cur = 1;
cin >> n;
for(int i = 0; i < n; i ++){
cin >> a[i];
}
for(int i = 0; i < n; i ++){
if(a[i] == cur){
cur ++;
}else{
count ++;
}
}
if(count == n) cout << -1;
else cout << count;
return 0;
}
| 0 | 55,451,377 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
int n,k,res=0; cin>>n>>k;
int arr[n];
for(int i=0;i<n;i++)cin>>arr[i];
sort(arr,arr+n);
for(int i=0;i<n;i++){
while(i<n-1 && arr[i]==arr[i+1])++i; res++;
}
if(res<=k)cout<<0;
else{ int M=200005,m=arr[n-1]; long c=0;
int a[M]={0};
for(int i=0;i<n;i++){
a[arr[i]]++;
}
sort(a,a+m+1);
for(int i=0;i<=m;i++){
if(a[i]>0){
c=c+a[i];
res--;
if(res<=k)break;}
}
cout<<c;
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define rep1(i,n) for(int i=1;i<=(int)n;i++)
#define sp(n) cout << fixed << setprecision(n)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
typedef long long ll;
using namespace std;
int main(void){
int w,h,n;cin>>w>>h>>n;
vector<vector<int>> t(h,vector<int>(w,0));
rep(i,n){
int x,y,a;cin>>x>>y>>a;x--;y--;
switch(a){
case 1:
rep(j,h)rep(k,x+1)t[j][k]++;
break;
case 2:
rep(j,h)for(int k=x+1;k<w;k++)t[j][k]++;
break;
case 3:
rep(j,y+1)rep(k,w)t[j][k]++;
break;
case 4:
for(int j=y+1;j<h;j++)rep(k,w)t[j][k]++;
break;
}
}
int res=0;
rep(i,h)rep(j,w)if(t[i][j]==0)res++;
cout<<res<<endl;
}
| 0 | 97,031,391 |
#include <bits/stdc++.h>
using namespace std;
int count_2(int x) {
int ans = 0;
while(x % 2 == 0) {
ans++;
x /= 2;
}
return ans;
}
int power_2(int x) {
if(x == 0) {
return 1;
}
else {
int ans = 1;
for(int i = 0; i < x; i++) {
ans *= 2;
}
return ans;
}
}
int main() {
int N;
cin >> N;
int num = 0;
for(int i = 1; i <= N; i++) {
if(count_2(i) > num) {
num = count_2(i);
}
}
cout << power_2(num) << endl;
}
|
#include <bits/stdc++.h>
#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)
#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=(int)(a)-1;i>=(int)(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)
#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define bit(n) (1LL<<(n))
#ifdef DEBUG
#define dump(...) fprintf(stderr, __VA_ARGS__)
#else
#define dump(...)
#endif
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}
using namespace std;
using ll=long long;
using vi=vector<int>;
using vll=vector<ll>;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int inf = INT_MAX;
const ll INF = LLONG_MAX;
const ll MOD = 1000000007LL;
const int dx[4]={1,0,-1,0};
const int dy[4]={0,1,0,-1};
ll extgcd(ll a,ll b,ll& x,ll& y){x=1,y=0;ll g=a;if(b!=0) g=extgcd(b,a%b,y,x),y-=a/b*x;return g;}
ll ADD(const ll &a, const ll &b, const ll mod=MOD) { return (a+b)%mod;}
ll SUB(const ll &a, const ll &b, const ll mod=MOD) { return (a-b+mod)%mod;}
ll MUL(const ll &a, const ll &b, const ll mod=MOD) { return (1LL*a*b)%mod;}
ll DIV(const ll &a, const ll &b, const ll mod=MOD) {ll x,y; extgcd(b,mod,x,y);return MUL(a,(x+mod)%mod,mod);}
struct UnionFind {
vector<int> data;
UnionFind(int size) : data(size, -1) { }
bool unionSet(int x, int y) {
x = root(x); y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y]; data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) {
return root(x) == root(y);
}
int root(int x) {
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) {
return -data[root(x)];
}
};
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
int n, m; cin >> n >> m;
vi p(n); for(auto& e : p) cin >> e, e--;
vi x(m), y(m);
rep(i, m) cin >> x[i] >> y[i], x[i]--, y[i]--;
UnionFind uf(n);
rep(i, m){
uf.unionSet(x[i], y[i]);
}
int res = 0;
rep(i, n){
if(uf.findSet(i, p[i])) res++;
}
cout << res << endl;
return 0;
}
| 0 | 74,436,988 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin >> a >> b >> c;
int p = min(min(a,b),c);
int q = max(max(a,b),c);
int r = a+b+c-p-q;
a=p;b=r;c=q;
p = c - b;
q = c - a;
r = b - a;
if(p%2==0&&q%2==0) {
cout << p/2 + q/2 << endl;
return 0;
}
else if(p%2==0){
cout << p/2 + (q+1)/2 + 1 << endl;
}else if(q%2==0){
cout << (p+1)/2 + q/2 + 1 << endl;
}else{
cout << p/2 + q/2 + 1 << endl;
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
using namespace std;
ll man(ll x1, ll y1, ll x2, ll y2)
{
return abs(x1 - x2) + abs(y1 - y2);
}
int main()
{
int N, M;
cin >> N >> M;
vector<ll> a(N), b(N), c(M), d(M);
rep(i, N)
{
cin >> a[i] >> b[i];
}
rep(i, M)
{
cin >> c[i] >> d[i];
}
rep(i, N)
{
ll min;
int num;
rep(j, M)
{
if (j == 0)
{
min = man(a[i], b[i], c[j], d[j]);
num = j + 1;
}
else
{
if (min > man(a[i], b[i], c[j], d[j]))
{
min = man(a[i], b[i], c[j], d[j]);
num = j + 1;
}
}
}
cout << num << endl;
}
return 0;
}
| 0 | 86,254,896 |
#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() {
ll n, p;
cin >> n >> p;
vector<int> a(n);
for (int& i : a) cin >> i;
ll c0 = 0, c1 = 0;
for (int i : a) ++(i & 1 ? c1 : c0);
c0 = 1ll << c0;
c1 = (c1 > 0 ? (1ll << (c1 - 1)) : 0);
cout << c0 * max(c1, p ? c1 : 1ll) << endl;
cerr << "c0,c1:" << c0 << "," << c1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
typedef long long ll;
using namespace std;
ll N, D, A, ans=0;
vector<pair<ll, ll>> XH;
vector<ll> C;
signed main(){
cin >> N >> D >> A;
for(int i=0;i<N;i++) {
ll X, H;
cin >> X >> H;
XH.push_back(make_pair(X, H));
C.push_back(0);
}
sort(XH.begin(), XH.end());
for(int i=0;i<N;i++) {
pair<ll, ll> p = XH[i];
ll ileft = lower_bound(XH.begin(), XH.end(), make_pair((ll)p.first-2*D, (ll)-1000000000000))-XH.begin();
ll pre=0;
if(i) {
C[i] = C[i-1];
}
if(ileft!=i&&i>0) {
if(ileft>0) pre += C[i-1]-C[ileft-1];
else pre += C[i-1];
}
p.second -= pre*A;
if(p.second>0){
if(p.second%A==0) {
ll addi = p.second/A;
C[i] += addi;
}
else {
ll addi = p.second/A;
C[i] += addi+1;
}
}
}
cout << C.back() << endl;
return 0;
}
| 0 | 88,211,146 |
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(begin, i, end) for (int i = begin; i < (int)(end); i++)
#define all(v) v.begin(), v.end()
const int MOD = 1000000007;
int main()
{
ll X, t;
cin >> X >> t;
cout << max(X - t, (ll)0) << endl;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FORR(i, a, b) for (int i = b - 1; i >= a; --i)
#define SORT(v) sort(v.begin(), v.end())
#define SORTR(v) sort(v.rbegin(), v.rend())
#define REV(v) reverse(v.begin(), v.end())
#define ITER(v) for (auto itr = v.begin(), itr != v.end(); ++itr)
#define LB(v, x) lower_bound(v.begin(), v.end(), x) - v.begin()
#define UB(v, x) upper_bound(v.begin(), v.end(), x) - v.begin()
#define SZ(v) (int)v.size()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> memo(N);
REP(i, M) {
int a, b;
cin >> a >> b;
--a;
--b;
memo[a]++;
memo[b]++;
}
string res = "YES";
REP(i, N) if (memo[i] % 2) res = "NO";
cout << res << endl;
return 0;
}
| 0 | 71,532,903 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <iomanip>
#include <math.h>
#include <utility>
#include <functional>
#include <cstdlib>
using namespace std;
using vl = vector <long long>;
using vs = vector <string>;
using vc = vector <char>;
using ll= long long;
using vvl = vector<vector<ll> >;
using vd = vector <double>;
#define rep(i,n) for(int i=0; i<n; i++)
#define print(n) cout<<n<<endl;
#define sortp(d) sort(d.begin(),d.end())
#define sortm(d) sort(d.rbegin(),d.rend())
bool is_prime(int x){
if(x<=1) return false;
for(int i=2;i*i<=x;i++)
if(x%i==0) return false;
return true;
}
ll p=0,q=0,r=0;
int main()
{
ll n;
cin>>n;
vl a(n),b(n);
rep(i,n){
cin>>a[i];
b[i]=a[i];
}
sortm(b);
rep(i,n){
if (b[0]==b[1])
{
print(b[0])
}else
{
if(a[i]==b[0]){
print(b[1])
}else print(b[0])
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
template<class T> inline T sqr(T x) {return x*x;}
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL,LL> PLL;
typedef map<int,int> MII;
typedef queue<int> QI;
typedef queue<PII> QPII;
typedef stack<int> SI;
typedef stack<PII> SPII;
typedef deque<int> DI;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQGI;
typedef priority_queue<int, VI, greater<int>> PQLI;
typedef priority_queue<PII> PQGP;
typedef priority_queue<PII, VPII, greater<int>> PQLP;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a)*(a))
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define SORTR(c) sort((c).rbegin(), (c).rend())
#define LB lower_bound
#define UB upper_bound
#define NEXP next_permutation
#define FI first
#define SE second
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORR(i,a,b) for(int i = (b-1);i>=a;i--)
#define REPR(i,n) FORR(i,0,n)
#define BREP(bit,N) for(int bit = 0; bit < (1<<N); ++bit)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX/3;
const LL LINF = LLONG_MAX/3;
const int RINF = INT_MIN/3;
const LL RLINF = LLONG_MIN/3;
const LL MOD = 1e9+7;
const LL MODD = 998244353;
const int MAX = 510000;
inline bool Eq(double a, double b) { return fabs(b - a) < EPS; }
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 COUT(x) cout << (x) << endl
#define COUT2(x,y) cout << (x) << " " << (y) << endl
#define PR(x) cout << (x)
#define ENDL cout << endl
#define SPACE cout << " "
#define BC(x) __builtin_popcountll(x)
void cYes(){ COUT("Yes");exit(0); }
void cNo(){ COUT("No");exit(0); }
void cYES(){ COUT("YES");exit(0); }
void cNO(){ COUT("NO");exit(0); }
void cyes(){ COUT("yes");exit(0); }
void cno(){ COUT("no");exit(0); }
void cMINU(){ COUT(-1);exit(0); }
void cZERO(){ COUT(0);exit(0); }
VI dx = {1,0,-1,0,1,1,-1,-1};
VI dy = {0,1,0,-1,1,-1,1,-1};
VC dc = {'R','D','L','U'};
VS ds = {"R","D","L","U","RD","RU","LD","LU"};
LL Gcd(LL a, LL b) {return __gcd(a,b);}
LL Lcm(LL a, LL b) {return a/Gcd(a,b)*b;}
LL ModPow(LL A, LL N, LL M){
LL res = 1;
while(N>0){
if(N&1) res = res * A % M;
A = A * A % M;
N >>= 1;
}
return res;
}
LL fac[MAX], finv[MAX], inv[MAX];
void ConInit(LL M) {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % M;
inv[i] = M - inv[M%i] * (M / i) % M;
finv[i] = finv[i - 1] * inv[i] % M;
}
}
LL COM(int n, int k, LL M){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % M) % M;
}
template<class T> void VCout(vector<T> &v){
int N = SZ(v);
REP(i,N){
cout << v.at(i);
if(i == N-1) cout << endl;
else cout << " ";
}
return;
}
bool isOK(int N, LL M, int V, int P, VLL &A, int x){
if(x <= P) return true;
LL now = A.at(--x) + M;
if(A.at(--P) > now) return false;
LL sco = 0;
sco += P*M;
sco += (N-x)*M;
FOR(i,P,x) sco += min(M,max(0LL,now-A.at(i)));
return sco >= M*V;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int N,V,P;
LL M;
cin >> N >> M >> V >> P;
VLL A(N);
REP(i,N) cin >> A.at(i);
SORTR(A);
int ok = 0, ng = N+1;
while(abs(ng - ok) > 1){
int mid = (ok+ng) / 2;
if(isOK(N, M, V, P, A, mid)) ok = mid;
else ng = mid;
}
COUT(ok);
return 0;
}
| 0 | 5,840,524 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int q;
cin >> q;
for (; q > 0; q--) {
ll a, b;
cin >> a >> b;
if (a * b <= 2) {
cout << 0 << endl;
continue;
}
if (a > b) {
ll t = a;
a = b;
b = t;
}
ll r = sqrt(a * b);
ll x = r + (r == a), y = r + 1 + (r + 1 == b);
while (x * y >= a * b) {
if (x < y || (x - 1 == a && x == 2)) {
if (y - 1 != b) {
y -= 1;
} else if (y > 2) {
y -= 2;
} else {
break;
}
} else {
if (x - 1 != a) {
x -= 1;
} else {
x -= 2;
}
}
}
cout << (x - (a < x)) + (y - 1 - (b < y)) << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int isprime[1000000];
void hurui() {
isprime[0] = isprime[1] = 0;
for (int i = 2; i < 1000000; i++) {
isprime[i] = 1;
}
for (int i = 0; i < 1000000; i++) {
if (isprime[i]) {
for(int j = i * 2; j < 1000000; j+=i) {
isprime[j] = 0;
}
}
}
}
int main() {
hurui();
int N;
while(cin >> N) {
int count = 0;
for (int i = 0; i <= N; i++) {
if (isprime[i]) count++;
}
cout << count << endl;
}
return 0;
}
| 0 | 100,201,790 |
#include <bits/stdc++.h>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
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;
}
string to_str_with_zero(int i, int w) {
ostringstream sout;
sout << std::setfill('0') << std::setw(w) << i;
string s = sout.str();
return s;
}
int letter_to_int(char c) {
return tolower(c) - 'a';
}
int compare_array(vector<int> a1, vector<int>a2) {
int n1 = a1.size();
int n2 = a2.size();
if (n1 != n2) {
return n1 - n2;
}
for (int i=0; i<n1; i++) {
if (a1.at(i) != a2.at(i)) {
return a1.at(i) - a2.at(i);
}
}
return 0;
}
int gcd(int a, int b) {
if(a % b == 0) {
return b;
}
return gcd(b, a % b);
}
char int_to_char(int a) {
if (a == -1) {
return 'z';
}
else {
return 'a' + a;
}
}
long nCr(int n, int r) {
long ans = 1;
for (int i = n; i > n - r; --i) {
ans = ans*i;
}
for (int i = 1 ; i < r + 1; ++i) {
ans = ans / i;
}
return ans;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int divide_count(int a, int divider) {
int r = 0;
while(a % divider == 0) {
a /= divider;
r++;
}
return r;
}
bool is_prime(int a) {
int i = 2;
while(i * i <= a) {
if(a % i == 0) {
return false;
}
i++;
}
return true;
}
vector<vector<int>> all_comb(int n, int k) {
vector<vector<int>> combs(nCr(n, k), vector<int>(k));
for(int i=0; i<k; i++) {
combs[0][i] = i;
combs[1][i] = i;
}
for(long i=1; i<nCr(n, k); i++) {
int p = 1;
while(combs[i][k - p] == n - p) {
p++;
if(p > k) {
break;
}
}
combs[i][k - p]++;
int q = combs[i][k - p];
for(int j=1; j<p; j++) {
combs[i][k - p + j] = q + j;
}
if(i < nCr(n, k) - 1) {
for(int j=0; j<k; j++) {
combs[i + 1][j] = combs[i][j];
}
}
}
return combs;
}
template <typename TYPE> void co(TYPE a) {
cout << a << endl;
}
template <typename TYPE> void co_2(TYPE a, TYPE b) {
cout << a << ' ' << b << endl;
}
template <typename TYPE> void co_l(vector<TYPE> as) {
int n = as.size();
for(int i=0; i<n; i++) {
cout << as[i] << endl;
}
}
template <typename TYPE> void co_s(vector<TYPE> as) {
int n = as.size();
for(int i=0; i<n; i++) {
if(i > 0) {
cout << ' ';
}
cout << as[i];
}
cout << endl;
}
int main() {
std::cout << std::setprecision(9);
int n;
cin >> n;
vector<long> a(n + 1, 0);
vector<long> p(n);
long ans = 0;
for(int i=0; i<n; i++) {
cin >> p[i];
ans += a[p[i]];
a[p[i]]++;
}
for(int i=0; i<n; i++) {
cout << ans - a[p[i]] + 1 << endl;
}
}
|
#include <iostream>
#include <vector>
using namespace std;
void print(vector<vector<int>> &A, int n)
{
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j > 0) cout << " ";
cout << A[i][j];
}
cout << endl;
}
}
int main()
{
int n;
cin >> n;
int id;
int num;
vector<vector<int>> A(n, vector<int>(n));
for (int i = 0; i < n; i++) {
cin >> id >> num;
if (num == 0) continue;
else {
int tmp;
for (int j = 0; j < num; j++) {
cin >> tmp;
A[id - 1][tmp - 1] = 1;
}
}
}
print(A, n);
return 0;
}
| 0 | 32,894,091 |
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>
#include <map>
#include <bitset>
#include <cmath>
#include <set>
#include <utility>
#include <sstream>
#define INF 1000000000000
#define MOD 1000000007
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) x.begin(),x.end()
#define chmax(x,y) (x = max(x,y))
#define chmin(x,y) (x = min(x,y))
int main(){
ll N,K;
cin >> N >> K;
vector<pair<ll,ll>>A(N);
vector<ll>rui(N+1);
rui.at(0) = 0;
for(ll i = 0;i < N;i++){
cin >> A[i].first >> A[i].second;
}
sort(A.begin(),A.end());
for(ll i = 0;i < N;i++){
rui.at(i+1) = A[i].second + rui.at(i);
}
const ll j = lower_bound(ALL(rui),K) - 1 - rui.begin();
cout << A[j].first << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair< int, int > pii;
typedef pair< pii, int > ppi;
#define fill(a,b) memset(a,b,sizeof(a))
#define all(v) (v).begin(),(v).end()
#define sp(k) cout<<setprecision(k)<<fixed;
#define rep(i,a) for(int i=0;i<a;i++)
#define rep1(i,a,b) for(int i=(a);i<=(b);++i)
#define irep(i,b,a) for(int i=(b);i>=(a);--i)
#define minv(v) *min_element(all(v))
#define maxv(v) *max_element(all(v))
#define unq(v) sort(all(v)),(v).erase(unique(all(v)),(v).end())
#define _ ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl "\n"
#define sqr(a) ((a)*(a))
#define sz(a) int(a.size())
#define ff first
#define ss second
#define pb push_back
const double pi = acos(-1.0);
const int mod = 1000000007;
const int inf = 0x3f3f3f3f;
const int maxn = 500100;
int ans[maxn];
int main(){
_
string s; cin >> s;
int n = sz(s);
for(int i = 0; i<n; i++){
if(s[i]=='<'){
ans[i+1] = max(ans[i+1], ans[i]+1);
}
}
for(int i = n-1; i>=0; i--){
if(s[i]=='>'){
ans[i] = max(ans[i], ans[i+1]+1);
}
}
ll res = 0;
for(int i = 0; i<=n;i++){
res+=ans[i];
}
cout<<res<<endl;
return 0;
}
| 0 | 14,214,075 |
#include<iostream>
#include<queue>
#include<utility>
using namespace std;
int main(){
int n,m;
while(cin>>n>>m,n){
int a,b,ans=0;
priority_queue< pair<int,int> > c;
for(int i=0;i<n;i++){
cin>>a>>b;
c.push(make_pair(b,a));
}
while(!c.empty()){
if(c.top().second>m){
c.push(make_pair(c.top().first,c.top().second-m));
c.pop();
break;
}
else {
m-=c.top().second;
c.pop();
}
}
while(!c.empty()){
ans+=c.top().first*c.top().second;
c.pop();
}
cout<<ans<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#include <numeric>
using namespace std;
#define ll long long
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < n; ++i)
using Graph = vector<vector<int>>;
#define grepq priority_queue<double, std::vector<double>, std::greater<double>>
#define all(v) v.begin(), v.end()
#define PI acos(-1)
const ll INF = 10010001010;
const int inf = 2000000000;
ll lcm(ll a, ll b)
{
return a * b / __gcd(a, b);
}
typedef tuple<string, int, int> TUP;
bool tuplesort(const TUP &right, const TUP &left)
{
if (get<0>(right) != get<0>(left))
{
return get<0>(left) < get<0>(right);
}
if (get<1>(left) != get<1>(right))
{
return get<1>(left) > get<1>(right);
}
return get<2>(left) < get<2>(right);
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll nCr(int n, int r)
{
ll ans = 1;
for (int i = n; i > n - r; --i)
{
ans = ans * i;
}
for (int i = 1; i < r + 1; ++i)
{
ans = ans / i;
}
return ans;
}
int main()
{
int N,R;
cin >> N >> R;
if(N > 9){
cout << R << endl;
}
else{
cout << R + (100 * (10 - N)) << endl;
}
}
| 0 | 30,459,130 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep2(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
typedef long long ll;
int main(){
int N ,Q;
cin >> N >> Q;
vector<int> w(N+1,0);
vector<int> v[N+1];
rep(i,N-1){
int a,b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
rep(i,Q){
int p,x;
cin >> p >> x;
w[p]+=x;
}
queue<int> que;
vector<bool> visit(N+1,false);
que.push(1);
while(!que.empty()){
int cur=que.front();
visit[cur]=true;
que.pop();
for(int next : v[cur]){
if(visit[next]) continue;
w[next]+=w[cur];
que.push(next);
}
}
rep2(i,1,N+1) cout << w[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int X, N, a;
int u, l;
cin >> X >> N;
vector<int> vec(102);
for (int i = 0; i < 102; i++) {
vec.at(i)=0;
}
for (int i = 1; i < N+1; i++) {
cin >> a;
vec.at(a)=1;
}
if (vec.at(X)==0){
cout << X << endl;
}
else{
for (int i=X+1; i < 102; i++){
if (vec.at(i)==0){
u=i;
break;
}
}
for (int i=X-1; i >= 0; i--){
if (vec.at(i)==0){
l=i;
break;
}
}
if (u-X < X-l)
cout << u << endl;
else
cout << l << endl;
}
}
| 0 | 56,543,450 |
#include <stdio.h>
#include <string.h>
char s3[8];
char sub4(int d)
{
if(d==2)return '2';
if(d==3)return '3';
if(d==4)return '4';
if(d==5)return '5';
if(d==6)return '6';
if(d==7)return '7';
if(d==8)return '8';
if(d==9)return '9';
}
void sub3(int c)
{
int cnt=0;
memset(s3,'\0',sizeof(s3));
if(c>=1000){
if(c>=2000)s3[cnt++]=sub4(c/1000);
s3[cnt++]='m';
c=c%1000;
}
if(c>=100){
if(c>=200)s3[cnt++]=sub4(c/100);
s3[cnt++]='c';
c=c%100;
}
if(c>=10){
if(c>=20)s3[cnt++]=sub4(c/10);
s3[cnt++]='x';
c=c%10;
}
if(c>=1){
if(c>=2)s3[cnt++]=sub4(c/1);
s3[cnt++]='i';
}
}
int sub2(char s)
{
if(s=='2')return 2;
if(s=='3')return 3;
if(s=='4')return 4;
if(s=='5')return 5;
if(s=='6')return 6;
if(s=='7')return 7;
if(s=='8')return 8;
if(s=='9')return 9;
}
int sub1(char str[])
{
int i;
int n=0;
int len=strlen(str);
for(i=0;i<len;i++){
if(str[i]=='m'){
if(i!=0)n+=sub2(str[i-1])*1000;
else n+=1000;
}
if(str[i]=='c'){
if(i!=0&&str[i-1]!='m')
n+=sub2(str[i-1])*100;
else n+=100;
}
if(str[i]=='x'){
if(i!=0&&str[i-1]!='m'&&str[i-1]!='c')
n+=sub2(str[i-1])*10;
else n+=10;
}
if(str[i]=='i'){
if(i!=0&&str[i-1]!='m'&&str[i-1]!='c'&&str[i-1]!='x')
n+=sub2(str[i-1])*1;
else n+=1;
}
}
return n;
}
int main(void)
{
int num;
int a,b;
char s1[500],s2[500];
scanf("%d",&num);
while(num--){
scanf("%s%s",s1,s2);
a=sub1(s1);
b=sub1(s2);
sub3(a+b);
printf("%s\n",s3);
}
return 0;
}
|
#include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
#define allr(a) a.rbegin(), a.rend()
#define rev(v) reverse(v.begin(), v.end());
#define io() ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); srand(time(NULL));
#define check cout<<"?\n";
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
signed main(){
io();
int n; cin >> n;
vector<ll> v(n);
for(auto &x : v){
cin >> x;
}
int ans = 0, cur = 0;
for(int i = 0; i < n - 1; ++i){
if(v[i] >= v[i + 1]){
++cur;
}else{
cur = 0;
}
ans = max(cur, ans);
}
return cout << ans << '\n', 0;
}
| 0 | 23,479,702 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <utility>
#include <set>
#include <stack>
#include <climits>
#include <cmath>
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define rep1(i,n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
#define reps(i,s,n) for(int i=s, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';
using namespace std;
int main(void){
string A;
cin>>A;
ll co[26];
MEMSET(co, 0);
ll ans=1;
rep(i, A.size()){
ans+=i-co[A[i]-'a'];
co[A[i]-'a']++;
}
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long res = 0;
for (int l = 0, r = 0, s = a[0]; l < n; l++) {
while (r + 1 < n && (s & a[r + 1]) == 0) {
s += a[r + 1];
r++;
}
s -= a[l];
res += r - l + 1;
}
cout << res << endl;
}
| 0 | 28,122,942 |
#include<iostream>
#include<cmath>
#include<vector>
#include<algorithm>
#include <string.h>
#include <iomanip>
using namespace std;
#define PI 3.14159265358979323846264338327950L
int main() {
string S, T;
cin >> S >> T;
if (!(S.length() >= 1 && S.length() <= 10) ||
T.length() != S.length() + 1) {
goto NO;
}
for (int ii = 0; ii < T.length(); ii++) {
if (!(T[ii] >= 'a' && T[ii] <= 'z')) {
goto NO;
}
if (ii == T.length() - 1) {
continue;
}
if (T[ii] != S[ii]) {
goto NO;
}
}
cout << "Yes" << endl;
return 0;
NO: cout << "No" << endl;
return 0;
}
|
#include<iostream>
#include<string>
using namespace std;
int main(){
int taro=0,hanako=0;
int n; cin>>n;
string tc,hc;
for(int i=0;i<n;i++){
int longSize;
cin>>tc>>hc;
if(tc.size()>hc.size())longSize = tc.size();
else longSize = hc.size();
if(tc==hc){
taro++;
hanako++;
}
for(int j=0;j<longSize;j++){
if(tc[j]-hc[j]>0){
taro+=3;
break;
}else if(tc[j]-hc[j]<0){
hanako+=3;
break;
}
}
}
cout<<taro<<" "<<hanako<<endl;
return 0;
}
| 0 | 100,708,024 |
#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(){
char c;
cin >> c;
char res;
if(c == 'A')res = 'T';
if(c == 'T')res = 'A';
if(c == 'C')res = 'G';
if(c == 'G')res = 'C';
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll MOD = 1000000007;
const ld PI = acos(-1);
const ld EPS = 0.0000000001;
#define REP(i, n) for(ll i=0; i<(ll)(n); i++)
#define REPD(i, n) for(ll i=n-1; 0<=i; i--)
#define FOR(i, a, b) for(ll i=a; i<(ll)(b); i++)
#define FORD(i, a, b) for(ll i=a; (ll)(b)<=i; i--)
#define ALL(x) x.begin(), x.end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int main(){
int n; cin >> n;
string s; cin >> s;
int rc=0, lc=0;
REP(i, n){
if(s[i]=='('){
rc += 1;
}else if(s[i]==')'){
if(0<rc){
rc -= 1;
}else{
lc += 1;
}
}
}
REP(i, lc) cout << '(';
cout << s;
REP(i, rc) cout << ')';
cout << endl;
}
| 0 | 60,782,632 |
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <iomanip>
namespace {
double area(double a, double b, double deg) {
return a * b * std::sin(deg * M_PI / 180.0) / 2.0;
}
double length(double a, double b, double deg) {
return a + b + std::sqrt(a * a + b * b - 2 * a * b * std::cos(deg * M_PI / 180.0));
}
double hight(double a, double b, double deg) {
return b * std::sin(deg * M_PI / 180.0);
}
}
int main() {
int a, b, deg;
std::cin >> a >> b >> deg;
std::cout << std::fixed << std::setprecision(8);
std::cout << area(a, b, deg) << std::endl;
std::cout << length(a, b, deg) << std::endl;
std::cout << hight(a, b, deg) << std::endl;
return EXIT_SUCCESS;
}
|
#include <cstdio>
#include <string>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
struct point{
double x,y;
point(double _x , double _y){
x = _x , y = _y;
}
};
bool insidePoly( point p,vector<point>P ) {
bool inside = false;
int n = P.size();
for( int i = 0, j = n - 1; i < n; j = i++ )
if( (( P[i].x < p.x ) ^ ( P[j].x < p.x )) &&
(P[i].y - P[j].y) * fabs(p.x - P[j].x) < (p.y - P[j].y) * abs(P[i].x - P[j].x) )
inside = !inside;
return inside;
}
int main()
{
double x,y;
while(cin>>x>>y)
{
vector<point>P;
P.push_back(point(x,y));
for( int i = 0 ; i < 2 ; i++ ){
scanf("%lf %lf",&x,&y);
P.push_back(point(x,y));
}
scanf("%lf %lf",&x,&y);
bool f = insidePoly(point(x,y),P);
if(f)puts("YES"); else puts("NO");
}
}
| 0 | 56,844,810 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
while(cin>>n,n!=0){
vector<pair<string,string> >pcc;
vector<string> vc;
for(int i=0;i<n;i++){
string a,b;
cin>>a>>b;
pcc.push_back(make_pair(a,b));
}
int m;
cin>>m;
for(int i=0;i<m;i++){
string a;
cin>>a;
for(int j=0;j<n;j++){
if(a==pcc[j].first){
a=pcc[j].second;
break;
}
}
vc.push_back(a);
}
for(int k=0;k<m;k++)
cout<<vc[k];
cout<<endl;
}
return 0;
}
|
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <algorithm>
#include <climits>
#include <cstring>
#include <cmath>
#include <stack>
#include <iomanip>
#include <tuple>
#include <functional>
#include <cfloat>
#include <map>
using ll = long long;
#define int long long
#define CONTAINS(v,n) (find((v).begin(), (v).end(), (n)) != (v).end())
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ARY_SORT(a, size) sort((a), (a)+(size))
#define MAX(a,b) (((a) > (b)) ? (a) : (b))
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#define REMOVE(v,a) (v.erase(remove((v).begin(), (v).end(), (a)), (v).end()))
#define REVERSE(v) (reverse((v).begin(), (v).end()))
#define LOWER_BOUND(v,a) (lower_bound((v).begin(), (v).end(), (a)))
#define UPPER_BOUND(v,a) (upper_bound((v).begin(), (v).end(), (a)))
#define REP(i, n) for (int (i) = 0; (i) < (n); (i)++)
#define CONTAINS_MAP(m, a) (m).find((a)) != m.end()
using namespace std;
int N;
int X[1000];
int Y[1000];
signed main()
{
cin >> N;
REP(i, N)
{
cin >> X[i] >> Y[i];
}
bool is_ki = ((abs(X[0]) + abs(Y[0])) % 2) == 1;
REP(i, N)
{
if (((abs(X[i]) + abs(Y[i])) % 2) == (is_ki ? 0 : 1))
{
cout << "-1" << endl;
return 0;
}
}
if (is_ki)
{
cout << 32 << endl;
}
else
{
cout << 33 << endl;
REP(i, N)
{
X[i]++;
}
cout << 1 << " ";
}
int a[32];
REP(i, 32)
{
a[i] = (int)pow(2, 31 - i);
cout << a[i] << (i == 31 ? "" : " ");
}
cout << endl;
REP(i, N)
{
if (!is_ki)
{
cout << "L";
}
int x = 0;
int y = 0;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
REP(j, 32)
{
int min_diff = LLONG_MAX;
int min = -1;
for (int d = 0; d < 4; d++)
{
int xx = a[j] * dx[d];
int yy = a[j] * dy[d];
int diff = abs(X[i] - (x + xx)) + abs(Y[i] - (y + yy));
if (min_diff > diff)
{
min_diff = diff;
min = d;
}
}
switch (min)
{
case 0: cout << "R"; break;
case 1: cout << "U"; break;
case 2: cout << "L"; break;
case 3: cout << "D"; break;
}
x += a[j] * dx[min];
y += a[j] * dy[min];
}
cout << endl;
}
}
| 0 | 13,387,700 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
string S, T;
cin >> S >> T;
bool f = true;
string U;
REP(i,0,51) U += 'z';
if(SZ(S) < SZ(T)) f = false;
else {
string V;
REP(i,0,SZ(S)-SZ(T)+1) {
bool g = true;
V = S;
REP(j,0,SZ(T)) {
if(S[i+j] != T[j]) {
if (S[i+j] == '?') V[i+j] = T[j];
else {
g = false;
break;
}
}
}
if(g) {
REP(j,0,SZ(V)) {
if(V[j] == '?') {V[j] = 'a';}
}
U = MIN(U,V);
}
}
}
if(SZ(U) == 51) f = false;
if(f) PR(U);
else PR("UNRESTORABLE");
return 0;
}
|
#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;
}
ll factor(ll x) {
map<ll, ll> m;
if(x == 1) {
m[1]++;
return 1;
}
ll temp = x;
for(ll i = 2;i * i <= x;i++) {
while(temp % i == 0) temp /= i, m[i]++;
}
ll ans = 1;
iter(i, m) ans *= i.second + 1;
return ans;
}
int main(void) {
ll N;
ll ans = 0;
cin >> N;
repi2(i, 1, N) {
if(factor(i) == 8) ans++;
i++;
}
cout << ans << endl;
return 0;
}
| 0 | 88,538,084 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep_inv(i, n, m) for(int i = (int)(n); i > (int)(m); i--)
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vc = vector<char>;
using vvl = vector<vl>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
int main(){
ll X, A, B;
cin >> X >> A >> B;
if(B - A <= 0) cout << "delicious" << endl;
else if(B - A <= X) cout << "safe" << endl;
else cout << "dangerous" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std ;
#define pb(n) push_back(n)
#define fi first
#define se second
#define all(r) (r).begin(),(r).end()
#define gsort(st,en) sort((st),(en),greater<int>())
#define vmax(ary) *max_element(all(ary))
#define vmin(ary) *min_element(all(ary))
#define debug(x) cout<<#x<<": "<<x<<endl
#define fcout(n) cout<<fixed<<setprecision((n))
#define scout(n) cout<<setw(n)
#define vary(type,name,size,init) vector< type> name(size,init)
#define rep(i,n) for(int i = 0; i < (int)(n);++i)
#define REP(i,a,b) for(int i = (a);i < (int)(b);++i)
#define repi(it,array) for(auto it = array.begin(),end = array.end(); it != end;++it)
#define repa(n,array) for(auto &n :(array))
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using dict = map<string,int>;
using pii = pair<int,int> ;
const int mod = 1000000007;
constexpr int imax = ((1<<30)-1)*2+1 ;
constexpr int inf = 100000000;
constexpr double PI = acos(-1.0) ;
double eps = 1e-10 ;
const int dy[] = {-1,0,1,0};
const int dx[] = {0,-1,0,1};
inline bool value(int x,int y,int w,int h){
return (x >= 0 && x < w && y >= 0 && y < h);
}
template<typename T>
void Unique(vector<T> &v){
sort(all(v));
v.erase(unique(all(v)),v.end());
}
template<typename T>
T ston(string& str, T n){
istringstream sin(str) ;
T num ;
sin >> num ;
return num ;
}
void Ans(bool f){
if(f) cout << "YES"<<endl;
else cout << "NO"<<endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,m,cs;
cin >> n >> m;
vector<int> c(m);
vector<vector<int>> dp(50001,vector<int>(m+1,0));
vector<int> dp2(50001,inf);
rep(i,m){
cin >> c[i];
}
dp[1][1] = 1;
dp2[1] = 1;
dp2[0] = 0;
rep(i,n+1){
for(int j = m-1; j >= 0; --j){
if(i >= c[j]){
dp2[i] = min(dp2[i],dp2[i-c[j]] + 1);
}
}
}
cout << dp2[n]<<endl;
return 0;
}
| 0 | 49,082,297 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
ll a[200009], sum = 0;
for(int i=0; i<n; i++) {
cin >> a[i];
sum += a[i];
}
ll res = 500000000000000LL;
ll ps = a[0];
for(int i=1; i<n; i++) {
res = min(res, abs(sum - 2 * ps));
ps += a[i];
}
cout << res << endl;
}
|
#include <cstdio>
#include <iostream>
using namespace std;
int main(){
char str[21];
int count=0;
scanf("%s", str);
while( str[count] != '\0' ) ++count;
for(int i=count-1; i>=0; --i)
printf("%c", str[i]);
printf("\n");
return 0;
}
| 0 | 45,848,006 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define ts to_string
#define all(v) (v).begin(), (v).end()
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vs vector <string>
#define vvs vector <vector<string>>
#define pq priority_queue<int>
using ll = long long;
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
const int INF = 2000000000;
constexpr ll mod = 1e9 + 7;
constexpr long double pi = 3.141592653589793238462643383279;
bool isprime(ll a)
{
if (a < 2) return false;
else if (a == 2) return true;
else if (a % 2 == 0) return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2)
{
if (a % i == 0)
{
return false;
}
}
return true;
}
ll ketasum(ll n) {
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
signed main(){
int s;cin>>s;
vector<int>A;
A.pb(s);
for(int i=0;;i++){
int push=A[i]%2==0?A[i]/2:A[i]*3+1;
auto B=A;
sort(all(B));
if(binary_search(all(B),push)){
cout<<i+2<<endl;
break;
}
else {
A.pb(push);
}
}
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
int red, green, blue;
cin >> red >> green >> blue;
int k;
cin >> k;
while (true) {
if (red < green) {
break;
}
green *= 2;
k--;
}
while (true) {
if (green < blue) {
break;
}
blue *= 2;
k--;
}
if (k >= 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| 0 | 47,775,628 |
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
#define rep(i,n) for(int i = 0; i < ((int)(n)); i++)
int main() {
int A,B;
cin >> A >> B;
bool OK = false;
if (A < B) swap(A,B);
if (A == B) {
OK = true;
} else {
int d = abs(A-B);
int left = 16 - (A+B);
if (left < d * 2 - (left % 2 == 1 ? 1 : 0)) OK = false;
else OK = true;
}
if (OK) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
}
|
#include<cstdio>
int main()
{
int n,a[5000];
while(scanf("%d",&n),n)
{
for(int i=0;i<n;i++)scanf("%d",&a[i]);
for(int i=0;i<n-1;i++)a[i+1]+=a[i];
int ma=-100000000;
for(int l=0;l<n;l++){
for(int r=l;r<n;r++){
int sum;
if(l==0)sum=a[r];
else sum=a[r]-a[l-1];
if(ma<sum)ma=sum;
}
}
printf("%d\n",ma);
}
return 0;
}
| 0 | 1,744,386 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int n,m; cin>>n>>m;
vector<int> a(n);
for(int i=0; i<n; ++i) cin>>a[i];
long double sum=0,res=0;
for(int i=0; i<n; ++i) sum+=a[i];
sum/=4*m;
for(int i=0; i<n; ++i) if(a[i]>=sum) ++res;
if(res>=m) cout<<"Yes"; else cout<<"No";
return 0;
}
|
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
#include<algorithm>
#define rep(i,n) for (int i = 0;i < (n);i++)
#define all(v) v.begin(),v.end()
#define dec(n) cout << fixed << setprecision(n);
#define large "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define small "abcdefghijklmnopqrstuvwxyz"
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b , a % b);
}
const ll MOD = 1000000007;
const ll MAX = 2000001;
ll mod(ll a){
return a % MOD;
}
ll lcm(ll a,ll b){
return (a*b)/gcd(a,b);
}
ll fac[MAX], finv[MAX], inv[MAX];
void nCrprep() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll nCr(ll n, ll r){
if (n < r) return 0;
if (n < 0 || r < 0) return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
ll nCrcheep(ll n,ll r){
if(r == 0) return 1;
else if(r == 1) return n;
else return nCrcheep(n-1,r-1)*n/r;
}
vector<pair<ll,ll>> prime_factorize(ll n){
vector<pair<ll,ll>> res;
for(ll i=2; i*i <= n; i++){
if(n % i != 0) continue;
ll ex = 0;
while(n % i == 0){
ex++;
n /= i;
}
res.push_back({i,ex});
}
if(n != 1) res.push_back({n,1});
return res;
}
int main(){
ll n; cin >> n;
cout << n/3 << endl;
}
| 0 | 71,922,724 |
#include <bits/stdc++.h>
#define ll long long int
#define FASTIO std::ios::sync_with_stdio(false);
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define inf 1e18
#define g(x) cout<<x<<" "<<endl;
#define gg(x,y) cout<<x<<" & "<<y<<" "<<endl
#define jam(t) cout<<"Case #"<<t<<": "
#define ggg(x,y,z) cout<<x<<" & "<<y<<" & "<<z<<" "<<endl
#define all(x) x.begin(),x.end()
#define input_from_file freopen("input.txt", "r", stdin);
#define mod 1000000007ll
#define sz 400005
#define bitcnt(x) __builtin_popcountll(x)
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
ll res[sz];
ll po (ll b, ll p) {
return !p?1:po(b*b%mod,p/2)*(p&1?b:1)%mod;
}
void solve(){
ll n,k;
cin >> n >> k;
for(ll i=1;i<=k;i++){
res[i] = po(k/i,n);
}
for(ll i=k;i>=1;i--){
for(ll j=2*i;j<=k;j+=i){
res[i]-=res[j];
if(res[i] < 0)
res[i]+=mod;
res[i]%=mod;
}
}
ll an = 0;
for(ll i=1;i <=k;i++){
an +=( i*res[i])%mod;
an%=mod;
}
g(an);
}
int main()
{
#ifndef ONLINE_JUDGE
input_from_file
#endif
FASTIO
cin.tie(NULL);
fflush(stdout);
ll t = 1;
for(ll tcase = 1;tcase <= t;tcase++){
solve();
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <iomanip>
#include <algorithm>
#include <string>
#include <cstring>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <cctype>
typedef long long int ll ;
typedef unsigned long long int ull ;
using namespace std ;
int main(void)
{
ios_base::sync_with_stdio(false) ; cin.tie(0) ; cout.tie(0) ;
ll n , a , b , i , result = pow(2 , 60) , flag = 0 ; cin >> n ;
for(i = 2 ; i * i <= n ; ++i)
{
if(!(n % i))
{
a = i ;
b = n / i ;
flag = 1 ;
result = min(result , ((a - 1) + (b - 1))) ;
}
}
if(flag) cout << result << "\n" ;
else cout << n - 1 << "\n" ;
return 0 ;
}
| 0 | 5,937,743 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> a(n);
vector<int> ans(10000000,0);
for(int i=0;i<n;i++)cin>>a[i];
sort(a.begin(),a.end());
for(int i=0;i<n;i++){
for(int j=a[i];j<=a[n-1];j+=a[i]){
ans[j]++;
}
}
long long cnt=0;
for(int i=0;i<n;i++){
if(ans[a[i]]==1)cnt++;
}
cout<<cnt<<endl;
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
using namespace std;
#define INF INT_MAX / 2
int main() {
int n, m;
int c[20];
cin >> n >> m;
for (int i = 0; i < m; i++)
cin >> c[i];
int dp[50000 + 1];
fill_n(dp, n + 1, INF);
dp[0] = 0;
for (int i = 0; i < m; i++)
for (int j = c[i]; j <= n; j++)
dp[j] = min(dp[j], dp[j - c[i]] + 1);
cout << dp[n] << endl;
return 0;
}
| 0 | 69,983,189 |
#include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
#define allr(a) a.rbegin(), a.rend()
#define rev(v) reverse(v.begin(), v.end());
#define io() ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); srand(time(NULL));
#define check cout<<"?\n";
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
signed main(){
io();
int n; cin >> n;
vector<ll> v(n);
for(auto &x : v){
cin >> x;
}
int ans = 0, cur = 0;
for(int i = 0; i < n - 1; ++i){
if(v[i] >= v[i + 1]){
++cur;
}else{
cur = 0;
}
ans = max(cur, ans);
}
return cout << ans << '\n', 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (int i = a; i < (int)(b); i++)
#define all(v) v.begin(), v.end()
const int MOD = 1e9 + 7;
const int INF = 1e9;
int main() {
int n;
cin >> n;
ll sum[n + 1] = {};
rep(i, 0, n) {
int a;
cin >> a;
sum[i + 1] = sum[i] + a;
}
map<ll, ll> mp;
rep(i, 0, n + 1) mp[sum[i]]++;
ll ans = 0;
for (auto i: mp) ans += i.second * (i.second - 1) / 2;
cout << ans << endl;
return 0;
}
| 0 | 11,029,980 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7, mxN = 1e5 + 5, mxC = 2;
int N;
vector<int> adj[mxN];
ll dp[mxN][mxC];
ll rec(int v, int p, int pcol) {
if (dp[v][pcol] != -1)
return dp[v][pcol];
ll tot = 0, ways = 1;
if (pcol == 0) {
for (auto it : adj[v]) {
if (it != p) {
ways = (ways * rec(it, v, 1)) % mod;
}
}
tot = ways;
}
ways = 1;
for (auto it : adj[v]) {
if (it != p) {
ways = (ways * rec(it, v, 0)) % mod;
}
}
tot = (tot + ways) % mod;
return dp[v][pcol] = tot;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < N - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
memset(dp, -1, sizeof(dp));
ll answer = rec(1, 0, 0);
cout << answer;
return 0;
}
|
#include<bits/stdc++.h>
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define vpii vector<pair<int,int>>
#define gph map<int, vector<int>>
#define mp make_pair
#define FOR(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR1(i, n) for (int i = 1; i <= (int)(n); i++)
#define FORD0(i, n) for (int i = (int)n; i >= 0; i--)
#define FORD1(i, n) for (int i = (int)n; i >= 1; i--)
#define FORS(i, n) for(; i < (int)(n); i++)
#define debug(X) { cout << #X << " = " << (X) << endl; }
#define printArr(A,n) { cout << #A << " = "; FOR(i,n) cout << A[i] << ' '; cout << endl; }
using namespace std;
#define int long long int
vi adj[(int)1e5 + 5];
int dfs(int cur, int P){
int xr = 0;
int cnt =0;
for(int child: adj[cur]){
if(child == P)continue;
xr ^= (dfs(child, cur) + 1);
cnt++;
}
return xr;
}
signed main(){
ios_base::sync_with_stdio(false);cin.tie(NULL);
int n;cin >> n;
int x, y;
FOR(i, n -1){
cin >> x >> y;
adj[x].pb(y);
adj[y].pb(x);
}
int ans = dfs(1, -1);
if(ans)cout << "Alice";
else cout << "Bob";
}
| 0 | 99,214,020 |
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<bitset>
#include<cctype>
#include<climits>
#include<cmath>
#include<cstdio>
#include<deque>
#include<list>
#include<map>
#include<set>
#include<stack>
#include<string>
#include<sstream>
#include<queue>
#include<vector>
using namespace std;
int main() {
string str; cin >> str;
int q; cin >> q;
for (int i = 0; i < q; i++) {
string s; cin >> s;
int a, b; cin >> a >> b;
if (s == "replace") {
string r; cin >> r;
str = str.substr(0, a) + r + str.substr(b + 1);
}
else if (s == "reverse") {
string r = str.substr(a, b - a + 1);
reverse(r.begin(), r.end());
str = str.substr(0, a) + r + str.substr(b + 1);
}
else if (s == "print") {
cout << str.substr(a, b - a + 1) << endl;
}
}
return 0;
}
|
constexpr bool isDebugMode = false;
int testcase = 1;
#include <bits/stdc++.h>
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#endif
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
struct edge{long long to,cost;};
const int inf = 1 << 27;
const long long INF = 1LL << 60;
const int COMBMAX = 1001001;
const long long MOD = 1000000007;
const long long dy[] = {-1, 0, 0, 1};
const long long dx[] = {0, -1, 1, 0};
string abc = "abcdefghijklmnopqrstuvwxyz";
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define eachdo(v, e) for (const auto &e : (v))
#define all(v) (v).begin(), (v).end()
#define lower_index(v, e) (long long)distance((v).begin(), lower_bound((v).begin(), (v).end(), e))
#define upper_index(v, e) (long long)distance((v).begin(), upper_bound((v).begin(), (v).end(), e))
long long mpow(long long a, long long n, long long mod = MOD){long long res = 1; while(n > 0){if(n & 1)res = res * a % mod; a = a * a % mod; n >>= 1;} return res;}
void pt(){cout << endl; return;}
template<class Head> void pt(Head&& head){cout << head; pt(); return;}
template<class Head, class... Tail> void pt(Head&& head, Tail&&... tail){cout << head << " "; pt(forward<Tail>(tail)...);}
void dpt(){if(!isDebugMode) return; cout << endl; return;}
template<class Head> void dpt(Head&& head){if(!isDebugMode) return; cout << head; pt(); return;}
template<class Head, class... Tail> void dpt(Head&& head, Tail&&... tail){if(!isDebugMode) return; cout << head << " "; pt(forward<Tail>(tail)...);}
template<class T> void enu(T v){rep(i, v.size()) cout << v[i] << " " ; cout << endl;}
template<class T> void enu2(T v){rep(i, v.size()){rep(j, v[i].size()) cout << v[i][j] << " " ; cout << endl;}}
template<class T> void debug(T v){if(!isDebugMode) return; rep(i, v.size()) cout << v[i] << " " ; cout << endl;}
template<class T> void debug2(T v){if(!isDebugMode) return; rep(i, v.size()){rep(j, v[i].size()) cout << v[i][j] << " " ; cout << endl;}}
template<class T1, class T2> inline bool chmin(T1 &a, T2 b){if(a > b){a = b; return true;} return false;}
template<class T1, class T2> inline bool chmax(T1 &a, T2 b){if(a < b){a = b; return true;} return false;}
template<class T1, class T2> long long recgcd(T1 a, T2 b){return a % b ? recgcd(b , a % b) : b;}
bool valid(long long H, long long W, long long h, long long w) { return 0 <= h && h < H && 0 <= w && w < W; }
void solve();
int main(){
while(testcase--) solve();
return 0;
}
void solve(){
ll N; cin >> N;
vector<string> s(N);
rep(i, N) cin >> s[i];
ll cnta = 0;
ll cntb = 0;
ll cntab = 0;
ll cntba = 0;
rep(i, N){
rep(j, s[i].size() - 1){
if(s[i][j] == 'A' && s[i][j + 1] == 'B') cntab++;
}
if(s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') cntba++;
if(s[i][0] == 'B' && s[i][s[i].size() - 1] != 'A') cntb++;
if(s[i][0] != 'B' && s[i][s[i].size() - 1] == 'A') cnta++;
}
ll ans = 0;
pt(cntab + (cntba == 0 ? min(cnta, cntb) : (cnta + cntb == 0 ? cntba - 1 : cntba + min(cnta, cntb))));
return;
}
| 0 | 39,220,610 |
#include <iostream>
#include <string>
int main() {
using namespace std;
int n, total;
total = 0;
cin >> n;
for (int i=1; i<=n; i++) {
string x = to_string(i);
if (x.size() % 2 == 1) total++;
}
cout << total;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,k,turn;
scanf("%d%d%d%d",&a,&b,&c,&k);
for(;;)
{
if(b<=a)
{
b*=2;
turn++;
}
else
{
break;
}
}
for(;;)
{
if(c<=b)
{
c*=2;
turn++;
}
else
{
break;
}
}
if(turn<=k)
{
printf("Yes");
}
else
{
printf("No");
}
}
| 0 | 19,103,703 |
#include <bits/stdc++.h>
#define rep(i,cc,n) for(int i=cc;i<=n;++i)
using namespace std;
int main() {
int X;
cin >> X;
bool ans = 0;
rep(i,1,X) {
int l = 100 * i, r = 105 * i;
if (l <= X && X <= r) ans = 1;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
int dpp[5005][5005];
int dps[5005][5005];
int ans=0;
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
int n,k;
cin>>n>>k;
int a[n+1];
for(int i=1;i<=n;i++)
cin>>a[i];
dpp[0][0]=1;
for(int i=1;i<=n;i++)
{
for(int j=0;j<=k;j++)
{
if(j-a[i]>=0)
dpp[i][j]|=dpp[i-1][j-a[i]];
dpp[i][j]|=dpp[i-1][j];
}
}
dps[n+1][0]=1;
for(int i=n;i>=1;i--)
{
for(int j=0;j<=k;j++)
{
if(j-a[i]>=0)
dps[i][j]|=dps[i+1][j-a[i]];
dps[i][j]|=dps[i+1][j];
}
}
for(int i=1;i<=n;i++)
{
int z=a[i];
int x=k,y=0;
int tt=k-a[i];
int mn=1e9;
while (x>=0&&y<=k)
{
while (x>=0&&dpp[i-1][x]==0)
{
x--;
}
while (y<tt-x && y<=k)
{
y++;
}
while (dps[i+1][y]==0 && y<=k)
{
y++;
}
if(x>=0)
if(x+y>=tt &&(dpp[i-1][x]&dps[i+1][y]))
{
mn=min(mn,x+y);
}
x--;
}
if(mn<k)
ans++;
}
cout<<n-ans;
}
| 0 | 3,775,227 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
bool check=false;
for(int i=2; i<s.size()-1; i++){
if('a'<=s.at(i) && s.at(i)<='z'){
}
else if(s.at(i)=='C'){
if(check==false){
check=true;
}
else if(check==true){
check=false;
break;
}
}
else break;
}
if(s.at(0)!='A') check=false;
if('a'>s.at(1) || s.at(1)>'z') check=false;
if('a'>s.at(s.size()-1) || s.at(s.size()-1)>'z') check=false;
if(check==true) cout << "AC" << endl;
else cout << "WA" << endl;
}
|
#include <iostream>
#include <algorithm>
int main(){
int x1, y1, x2, y2;
std::cin >> x1 >> y1 >> x2 >> y2;
int x3, y3, x4, y4;
int dx, dy;
if ((x2 >= x1) && (y2 >= y1)){
x3 = x2 - (y2 - y1);
y3 = y2 + (x2 - x1);
x4 = x3 - (x2 - x1);
y4 = y3 - (y2 - y1);
} else if ((x1 > x2) && (y2 >= y1)){
x3 = x2 - (y2 - y1);
y3 = y2 - (x1 - x2);
x4 = x3 + (x1 - x2);
y4 = y3 - (y2 - y1);
} else if ((x1 > x2) && (y1 > y2)){
x3 = x2 + (y1 - y2);
y3 = y2 - (x1 - x2);
x4 = x3 + (x1 - x2);
y4 = y3 + (y1 - y2);
} else if ((x2 >= x1) && (y1 > y2)){
x3 = x2 + (y1 - y2);
y3 = y2 + (x2 - x1);
x4 = x3 - (x2 - x1);
y4 = y3 + (y1 - y2);
}
std::cout << x3 << " " << y3 << " " << x4 << " " << y4 << std::endl;
}
| 0 | 54,456,833 |
#include <bits/stdc++.h>
using namespace std;
long long gcm(long long a, long long b){
if(a % b == 0) return b;
a = a % b;
return gcm(b, a);
}
long long lcm(long long a, long long b){
return a / gcm(a, b) * b;
}
int main() {
int n;
cin >> n;
long long ans = 1;
for(int i = 0; i < n; i++){
long long k;
cin >> k;
ans = lcm(ans, k);
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define fast() ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define test() ll t; cin>>t; while(t--)
#define lp0(i,begin,end) for(ll i=begin;i<end;i++)
#define lp1(i,begin,end) for(ll i=begin;i<=end;i++)
#define rlp(i,begin,end) for(ll i=end;i>=begin;i--)
#define prec(n) fixed<<setprecision(n)
#define initial(a,i) memset(a,i,sizeof(a))
#define pb push_back
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define F first
#define S second
#define all(a) (a).begin(),(a).end()
#define BPC(x) __builtin_popcountll(x)
#define gcd(a,b) __gcd(a,b)
ll gcd(ll a,ll b) {if (a==0) return b;return gcd(b%a,a);}
ll power(ll x,ll n)
{
ll result = 1;
while (n)
{
if (n & 1)
result = result * x;
n = n / 2;
x = x * x;
}
return result;
}
void solution(ll compte)
{
string s;
cin>>s;
ll res=0,ans=0;
lp0(i,0,s.size())
{
if(s[i]=='R')res++;
else ans=max(ans,res),res=0;
}
if(res>0) ans=max(ans,res);
cout<<ans<<'\n';
}
int main()
{
ll compte = 1;
solution(compte);
compte++;
return 0;
}
| 0 | 58,873,380 |
#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>
#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>
#include <regex>
#define REP(i,n) for(int i = 0; i < n; i++)
#define FOR(i,j,n) for(int i = j; i < n; i++)
#define RFOR(i,j,n) for(int i = j-1; i >= n; i--)
#define PREC(n) fixed << setprecision(n)
#define print_array(v) REP(__k, v.size()) { cout << v[__k]; if(__k != v.size()-1) cout << " "; else cout << endl; }
#define YesorNo(a) printf(a?"Yes\n":"No\n")
#define _LIBCPP_DEBUG 0
using namespace std;
int64_t MOD = 1000000007;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << min(a,b) + min(c,d) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define FORD(i,a,b) for(int i=a;i>=b;i--)
#define FORL(i,x) for(int i=head[x];i;i=nxt[i])
#define ALL(a) (a).begin(),(a).end()
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define PB push_back
#define MP make_pair
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(void){
string s; cin >> s;
map<char,int> m;
FOR(i,0,s.length()-1){
++m[s[i]];
}
FOR(i,0,25){
if(m[(char)('a'+i)]==0){
s += (char)('a'+i);
cout << s << endl;
return 0;
}
}
FORD(i,25,0){
--m[s[i]];
int index = (int)(s[i]-'a');
FOR(j,index+1,25){
if(m[(char)('a'+j)]==0){
string ans;
FOR(k,0,i-1) {
ans += s[k];
}
ans += (char)('a'+j);
cout << ans << endl;
return 0;
}
}
}
cout << -1 << endl;
}
| 0 | 83,168,339 |
#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;
cin >> n;
vector<int> a;
rep(i,2*n) {
int x;
cin >> x;
a.push_back(x);
}
sort(a.begin(), a.end());
int ans = 0;
rep(i,n) {
ans += min(a[2*i], a[2*i+1]);
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;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; }
vector<lli> divisor(lli x){
vector<lli> d;
for(lli i = 1; i*i <= x; i++){
if(x%i == 0){
d.push_back(i);
if(i != x/i) d.push_back(x/i);
}
}
sort(d.begin(), d.end());
return d;
}
lli n;
int main(void){
cin >> n;
auto d = divisor(n);
lli ans = 0;
for(auto i : d){
lli m = i-1;
if(0 <= n/i && n/i <= m-1){
ans += m;
}
}
cout << ans << endl;
return 0;
}
| 0 | 76,729,601 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.