code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 1
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 1e9+7;
char s[N];
int d[N], r[N];
int main(){
int n, ans;
scanf("%d", &n);
scanf("\n%s", s+1);
for(int i=1; i<=n*2; ++i){
d[i] = d[i-1];
if(s[i] == s[i-1]) d[i] ^= 1;
}
for(int i=n*2; i>=1; --i){
if(d[i] == 1) r[i] = r[i+1]+1;
else r[i] = r[i+1]-1;
}
ans = 1;
for(int i=1; i<=n*2; ++i)
if(r[i] < 0){
ans = 0;
break;
}
if(r[1] != 0 || s[1] == 'W') ans = 0;
for(int i=1; i<=n*2; ++i)
if(!d[i]) ans = 1ll*ans*(r[i]+1)%mod;
for(int i=1; i<=n; ++i) ans = 1ll*ans*i%mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<int64_t> A(N);
for(int i=0; i<N; i++) cin >> A[i];
int64_t ans = 0;
while(true){
bool updated = false;
for(int i=0; i<N; i++){
int64_t d = A[i]/N;
ans += d;
if(d > 0) updated = true;
A[i] %= N;
for(int j=0; j<N; j++) if(j!=i) A[j] += d;
}
if(!updated) break;
}
cout << ans << endl;
}
| 0
| 75,245,324
|
#include <cassert>
#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 <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#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 <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#define rep(i,j,k) for(int i=(int)j;i<(int)k;i++)
#define ll long long
#define Sort(v) sort(all(v))
#define INF 1000000000
#define END return 0
#define pb push_back
#define se second
#define fi first
#define pb push_back
#define all(v) (v).begin() , (v).end()
#define MP make_pair
#define MOD 1000000007LL
using namespace std;
int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
struct P{
int x,y;
};
int main (){
ll x,sum=0;cin>>x;
int index;
rep(i,1,x+1){
sum+=i;
if(sum>=x){
index=i;
break;
}
}
rep(i,1,index+1){
if(i==sum-x)continue;
cout<<i<<endl;
}
}
|
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cassert>
using namespace std;
typedef long long LL;
template <typename F, typename S> std::ostream& operator<<(ostream& os, const pair<F,S>& p) {
os << "(" << p.first << "," << p.second << ")"; return os; }
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) {
os << "["; for(const T& a: v){ os << a << ", "; } os << "]"; return os; }
template <typename K, typename V> ostream& operator<<(ostream& os, const map<K,V>& m) {
os << "{"; for(const auto& p: m){ os << p.first <<":"<< p.second << ", "; } os << "}"; return os; }
LL getGain(LL r, LL s, LL p, char c){
if(c == 's') return r;
if(c == 'p') return s;
if(c == 'r') return p;
return 0;
}
LL solve(LL r, LL s, LL p, string str){
LL n = str.size();
vector<LL> win(n+1);
vector<LL> lose(n+1);
for(LL i = 0; i < n; ++i){
if(i == 0 || str[i-1] != str[i]){
win[i+1] = max(win[i+1], win[i] + getGain(r,s,p,str[i]));
lose[i+1] = max(lose[i+1], win[i]);
}else{
win[i+1] = max(win[i+1], lose[i] + getGain(r,s,p,str[i]));
lose[i+1] = max(lose[i+1], win[i]);
}
}
return max(win[n], lose[n]);
}
int main(){
LL n, k, r, s, p;
cin >> n >> k >> r >> s >> p;
string t;
cin >> t;
LL ans = 0;
for(LL i = 0; i < k; ++i){
string str;
for(LL j = i; j < t.size(); j += k){
str += t[j];
}
ans += solve(r, s, p, str);
}
cout << ans << endl;
return 0;
}
| 0
| 68,602,822
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int X;
int A=0;
int B=0;
cin >>X;
while(1)
{
A=A-X;
B++;
if(A<0)A=A+360;
if(A==0)break;
}
cout << B;
}
|
#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define FORR(i,a,b)for(ll i=(a);i<=(b);i++)
#define repR(i,n) for(ll i=n;i>=0;i--)
#define all(v)(v).begin(),(v).end()
#define rall(v)(v).rbegin(),(v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout<<(x)<<endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll,vector<ll>,greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
#define mp make_pair
#define maxs(x,y) (x = max(x,y))
#define mins(x,y) (x = min(x,y))
#define sz(x) (int)(x).size()
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
using vc = vector<char>;
using vvc = vector<vc>;
ll dx[4]={0,1,0,-1};
ll dy[4]={1,0,-1,0};
int main(){
ll n,m;
cin>>n>>m;
vvll x(n,vll(3));
rep(i,n){
cin>>x[i][0]>>x[i][1]>>x[i][2];
}
ll ans=0;
for(int bit=0;bit<(1<<3);bit++){
vll p(0);
rep(i,n){
ll cu=0;
for(int j=0;j<3;j++){
if(bit&(1<<j)){
cu+=x[i][j];
}
else cu-=x[i][j];
}
p.pb(cu);
}
sort(rall(p));
ll k=0;
rep(i,m){
k+=p[i];
}
ans=max(ans,k);
}
COUT(ans);
}
| 0
| 26,415,851
|
#include <iostream>
#include <string>
#include <math.h>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <set>
#include <queue>
#include <deque>
#include <map>
#include <stack>
#include <cmath>
using namespace std;
#define mod 1000000007
#define ten5 100005
#define ten52 200005
#define ten53 300005
#define ten6 1000005
#define PI 3.1415926
#define pb(x) push_back(x)
#define all(x) x.begin(),x.end()
#define mkpr(x1,x2) make_pair(x1,x2)
typedef long long int ll;
map<string,ll> mp;
map<string,ll>::iterator mpit;
vector<ll> vll;
ll num[ten52];
int main(void)
{
ll m=0,n,i=0,j,k=0;
string s;
cin>>n;
for(i=0;i<n;i++)
{
cin>>s;
sort(all(s));
mp[s]++;
}
for(mpit=mp.begin();mpit!=mp.end();mpit++)
{
j=mpit->second;
m+=(j)*(j-1)/2;
}
cout<<m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
vector<vector<vector<vector<ll>>>> plusMinusAbs(2, vector<vector<vector<ll>>>(2, vector<vector<ll>>(2, vector<ll>(0))));
for (int i = 0; i < N; i++)
{
ll x, y, z;
cin >> x >> y >> z;
plusMinusAbs.at(1).at(1).at(1).push_back(x + y + z);
plusMinusAbs.at(1).at(1).at(0).push_back(x + y - z);
plusMinusAbs.at(1).at(0).at(1).push_back(x - y + z);
plusMinusAbs.at(1).at(0).at(0).push_back(x - y - z);
plusMinusAbs.at(0).at(1).at(1).push_back(-1 * x + y + z);
plusMinusAbs.at(0).at(1).at(0).push_back(-1 * x + y - z);
plusMinusAbs.at(0).at(0).at(1).push_back(-1 * x - y + z);
plusMinusAbs.at(0).at(0).at(0).push_back(-1 * x - y - z);
}
ll answer = 0;
for (int i = 0; i <= 1; i++)
{
for (int j = 0; j <= 1; j++)
{
for (int k = 0; k <= 1; k++)
{
sort(plusMinusAbs.at(i).at(j).at(k).begin(), plusMinusAbs.at(i).at(j).at(k).end(), greater<ll>());
ll tmpAnswer = 0;
for (int l = 0; l < M; l++)
{
tmpAnswer += plusMinusAbs.at(i).at(j).at(k).at(l);
}
answer = max(answer, tmpAnswer);
}
}
}
cout << answer << endl;
return 0;
}
| 0
| 25,006,086
|
#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;
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long res = a * c;
for (auto x : {a, b}) {
for (auto y : {c, d}) {
res = max(res, x * y);
}
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
void solve(long long N, std::vector<long long> P){
ll cnt = 1;
vector<ll> M(N, P[0]);
for(ll i = 1; i < N; ++i){
M[i] = min(P[i], M[i-1]);
if(P[i] == M[i]) cnt++;
}
cout << cnt << endl;
return;
}
int main(){
long long N;
scanf("%lld",&N);
std::vector<long long> P(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&P[i]);
}
solve(N, std::move(P));
return 0;
}
| 0
| 75,437,796
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
string S,T;
cin>>N>>S;
if(N%2!=0){
cout<<"No"<<endl;
}
else{
T=S.substr(0,N/2);
if(T==S.substr(N/2,N/2)){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll N=1e6+5,inf=1e18,mod=1e9+7;
#define test ll testcases;cin>>testcases; while(testcases--)
#define lp(var,start,end) for (ll var = start; var <end ; ++var)
#define rlp(var,start,end) for(ll var = start; var>=end ; var--)
#define pb push_back
#define mp make_pair
#define pf push_front
#define ff first
#define ss second
#define vll vector<ll>
#define vld vector<ld>
#define pll pair<ll,ll>
#define pld pair<ld,ld>
#define vpll vector<pll>
#define vpld vector<pld>
#define all(X) X.begin(),X.end()
#define sz(x) ((ll)((x).size()))
const ld pi=3.141592653589793238;
bool check_prime(ll n)
{
ll flag=0,i;
for(i=2;i*i<=n;i++)
{
if(n%i==0)
{
flag=1;
break;
}
}
if(n==1)
{
return false;
}
else if(flag==0 || n==2 || n==3)
{
return true;
}
else
{
return false;
}
}
ll fastexpo(ll a,ll b,ll MOD)
{
ll result=1;
while(b>0)
{
if(b%2==1)
{
result=(result*a)%MOD;
}
a=(a*a)%MOD;
b=b/2;
}
return result;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,p;
cin>>n;
if(n%2==0)
{
n/=2;
p=0;
while(n>0)
{
p+=(n/5);
n=n/5;
}
cout<<p<<"\n";
}
else
{
cout<<"0\n";
}
return 0;
}
| 0
| 87,252,213
|
#include<iostream>
using namespace std;
int main(){
int h1,m1,h2,m2,k;
cin>>h1>>m1>>h2>>m2>>k;
cout<<60*(h2-h1)+m2-m1-k;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
ll A,B,C,D;
cin >>A>>B>>C>>D;
cout << min(A,B)+min(C,D) << endl;
return 0;
}
| 0
| 73,981,711
|
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<n;++i)
#define all_map(pos,mp) for(ll pos=mp.begin();pos!=mp.end();pos -++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll LINF = 1LL << 62;
const int INF = 1e9 + 7;
int main(){
ll n, k;
cin >> n >> k;
vector<ll> v(n);
rep(i, n)cin >> v[i];
ll ans = 0;
rep(left, min(n, k) + 1)rep(right, min(n, k) + 1 - left){
vector<ll> res = v;
res.erase(res.begin()+left, res.end()-right);
sort(ALL(res));
rep(i, k-left-right){
if(res.empty() || res.front() >= 0)break;
res.erase(res.begin());
}
ans = max(ans, accumulate(ALL(res), 0LL));
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int h,w;cin>>h>>w;
string s[h];
for(int i=0;i<h;i++)cin>>s[i];
vector<int> row(h,false),col(w,false);
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(s[i][j]=='#'){
row[i]=true;
col[j]=true;
}
}
}
for(int i=0;i<h;i++)
if(row[i]){
for(int j=0;j<w;j++)
if(col[j]) cout<<s[i][j];
cout<<endl;
}
return 0;
}
| 0
| 22,719,688
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int a1,a2,a3;
cin >> a1 >> a2 >> a3;
if(a1==a2&&a1==a3){
cout << 1 << endl;
}
else if(a1==a2||a1==a3||a2==a3){
cout << 2 << endl;
}
else{
cout << 3 << endl;
}
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <ctime>
#include <cstring>
#include <functional>
#include <iostream>
#include <iomanip>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <regex>
#include <vector>
#define fix(n) cout<<fixed<<setprecision(n)
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define sort(a) sort(all(a))
#define uniq(a) sort(a);(a).erase(unique(all(a), (a).end())
#define reverse(a) reverse(all(a))
#define ctos(c) string(1, (c))
#define out(d) cout << (d)
#define outl(d) std::cout<<(d)<<"\n"
#define YES() cout << "YES" << endl
#define NO() cout << "NO" << endl
#define Yes() cout << "Yes" << endl
#define No() cout << "No" << endl
#define ceil(x, y) ((x + y - 1) / (y))
#define debug(x) cerr << #x << ": " << (x) << '\n'
#define debug2(x, y) cerr << #x << ": " << (x) << ", " << #y << ": " << (y) << '\n'
#define debug3(x, y, z) cerr << #x << ": " << (x) << ", " << #y << ": " << (y) << ", " << #z << ": " << (z) << '\n'
#define dbg(v) for (size_t _ = 0; _ < v.size(); ++_){ cerr << #v << "[" << _ << "] : " << v[_] << '\n'; }
#define pb push_back
#define fst first
#define int long long
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll,ll>;
const ll MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
void solve() {
ll n; cin >> n;
ll c1 = 0, c2 = 0, c3 = 0, sum = 0;
rep(i, n) {
string s; cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A') c1++;
else if (s[0] == 'B') c2++;
else if (s[s.size() - 1] == 'A') c3++;
for (int j = 1; j < s.size(); j++)
if (s[j-1] == 'A' && s[j] == 'B') sum++;
}
if (c1 == 0) outl(sum + min(c2, c3));
else if (c2 + c3 > 0) outl(sum + min(c2, c3) + c1);
else outl(sum + c1 - 1);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
srand((unsigned)time(NULL));
fix(12);
solve();
}
| 0
| 79,156,070
|
#include <cstdio>
#include <cstring>
using namespace std;
int main(){
char p[202],s[101],ch[101];
scanf("%s %s",p,s);
strcpy(ch, p);
strcat(p, ch);
if (strstr(p, s)) printf("Yes\n");
else printf("No\n");
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod = 1e9 + 7;
vector<int> filho[100005];
ll dp[100005][2];
ll dfs(int pai, int cor, int pos)
{
if(dp[pos][cor] > 0)
return dp[pos][cor];
for (int i = 0; i < (int)filho[pos].size(); ++i)
{
int viz = filho[pos][i];
ll valor = 0;
if(viz != pai)
{
if(cor == 0)
{
valor += (dfs(pos, 0, viz) % mod);
valor += (dfs(pos, 1, viz) % mod);
}
else if(cor == 1)
{
valor += (dfs(pos, 0, viz) % mod);
}
if(dp[pos][cor] == 0)
dp[pos][cor] = valor;
else
dp[pos][cor] = (dp[pos][cor] * valor) % mod;
}
}
if(dp[pos][cor] == 0)
return dp[pos][cor] = 1;
return dp[pos][cor];
}
int main()
{
int n, u, v;
cin >> n;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n - 1; ++i)
{
cin >> u >> v;
filho[u].push_back(v);
filho[v].push_back(u);
}
ll resp = (dfs(-1, 0, 1) + dfs(-1, 1, 1)) % mod;
cout << resp << endl;
return 0;
}
| 0
| 36,008,030
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for(int i=0; i<N; i++)
typedef long long ll;
#define dump(x) cerr<<#x<<"="<<x<<endl
using P = pair<int, int>;
int main() {
ll x, t; cin >> x >> t;
if(x<t){
cout << 0 << endl;
}
else{
cout << x-t << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> gr;
int n, q;
struct DSU{
vector<int> par, siz;
int n;
DSU(int n_) {
int n = n_ + 1;
par.resize(n);
siz.resize(n);
fill(siz.begin(), siz.end(), 1);
iota(par.begin(), par.end(), 0);
}
int get(int v) {
if(par[v] == v) {
return v;
}
return par[v] = get(par[v]);
}
void uni(int l, int r) {
l = get(l);
r = get(r);
if(l != r) {
if(siz[l] > siz[r]) {
swap(l, r);
}
par[l] = r;
siz[r] += siz[l];
}
}
};
main() {
cin >> n >> q;
DSU dsu(n);
gr = vector<vector<int>> (n + 1, vector<int> ());
while(q--) {
int id;
cin >> id;
int l, r;
cin >> l >> r;
if(id) {
cout << (dsu.get(l) == dsu.get(r)) << endl;
} else {
dsu.uni(l, r);
}
}
}
| 0
| 56,230,516
|
#include <bits/stdc++.h>
using namespace std;
int n, f[105];
int main() {
scanf("%d", &n);
int mn = 1e9;
for(int i = 1; i <= n; i++) {
int x; scanf("%d", &x);
f[x]++;
mn = min(mn, x);
}
if(f[mn] > 2) {
printf("Impossible\n");
return 0;
}
int up = 2 * mn - (f[mn] == 2);
for(int i = mn + 1; i <= up; i++) {
if(f[i] < 2) {
printf("Impossible\n");
return 0;
}
}
for(int i = up + 1; i <= 100; i++) {
if(f[i] > 0) {
printf("Impossible\n");
return 0;
}
}
printf("Possible\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
#define rep(i,n) for (ll i=0;i<(n);++i)
#define rep2(i,a,b) for (ll i=(a);i<(b);++i)
#define debug(x) cout << #x << '=' << x << endl
#define all(v) (v).begin(),(v).end()
const ll MOD=1e9+7;
const ll INF=1e9;
const ll IINF=1e18;
const double EPS=1e-8;
const double pi=acos(-1);
template<class T> inline bool chmin(T &a,T b){
if (a>b){a=b; return true;}
return false;
}
template<class T> inline bool chmax(T &a,T b){
if (a<b){a=b; return true;}
return false;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll a,b; cin >> a >> b;
if (a%b) cout << a << endl;
else cout << -1 << endl;
}
| 0
| 83,695,071
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
map<int, int> mp;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
mp[arr[i]]++;
}
sort(arr.begin(), arr.end());
int resp = 0;
for (int i = 0; i < n; i++) {
int val = arr[i];
for (int j = val * 2; j <= arr[n - 1]; j += val) {
mp[j]++;
}
if (mp[val] == 1)
resp++;
}
cout << resp << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i< (n); i++)
using ll = long long;
using namespace std;
int main(){
int N, D, X;
cin >> N >> D >> X;
int A[N];
rep(i,N) cin >> A[i];
rep(i,N)rep(j,101) {
int d = j*A[i]+1;
if (d>D) break;
X++;
}
cout << X << endl;
return 0;
}
| 0
| 16,985,847
|
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#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++)
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int k;
cin >> k;
queue<int64_t> lunluns;
rep(i,9) lunluns.push(i+1);
rep(i,k-1) {
int64_t x = lunluns.front();
lunluns.pop();
int64_t n = x * 10 + x % 10;
if (x % 10 != 0) lunluns.push(n-1);
lunluns.push(n);
if (x % 10 != 9) lunluns.push(n+1);
}
cout << lunluns.front() << endl;
return 0;
}
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define F first
#define S second
#define vi vector<int>
#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 zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18 + 1
#define endl '\n'
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define forI(i,a,n) for(int i=a;i<=n;i++)
#define forD(i,a,n) for(int i=n;i>=a;i--)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
void init(){
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int dp[102][100005];
int compute(int *a, int n, int k){
forI(i, 0, k) dp[1][i] = (i > a[1]) ? 0 : 1;
forI(i, 2, n){
forI(j, 0, k){
if(j == 0)
dp[i][j] = dp[i-1][j];
else
dp[i][j] = (mod + dp[i][j-1] + dp[i-1][j] -
((j-a[i]-1 >= 0) ? dp[i-1][j-a[i]-1] : 0))%mod;
}
}
return dp[n][k];
}
void solve(){
int n, k; cin>>n>>k;
mk(a, n+1, int); forI(i, 1, n) cin>>a[i];
memset(dp, -1, sizeof dp);
int ways = compute(a, n, k);
cout<<ways<<endl;
}
int32_t main(){
init();
solve();
return 0;
}
| 0
| 49,768,510
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int INF=1e9;
const int MOD=1e9+7;
int main(){
string s; cin >> s;
map<char,ll> ma;
ll N=s.size();
for(int i=0;i<N;i++){
ma[s[i]]++;
}
ll ans=N*(N-1)/2+1;
for(auto it=ma.begin();it!=ma.end();it++){
ll res=(it->second)*(it->second-1)/2;
ans-=res;
}
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
long long INF = 1e18;
long long N, K;
std::vector<long long> a;
int main(){
std::cin >> N >> K;
a.resize(N);
for(int i = 0; i < N; i++) std::cin >> a[i];
long long ans = INF;
for(int bit = 0; bit < (1 << N - 1); bit++){
std::vector<int> sele(N - 1, 0);
int count = 0;
for(int i = 0; i < N - 1; i++){
if(bit & (1 << i)) {
count++;
sele[i] = 1;
}
}
if(count < K - 1) continue;
long long res = 0;
long long M = a[0];
for(int i = 0; i < N - 1; i++){
if(sele[i] == 1 && M >= a[i + 1]){
res += M + 1 - a[i + 1];
M++;
}
M = std::max(M, a[i + 1]);
}
ans = std::min(ans, res);
}
std::cout << ans << std::endl;
}
| 0
| 47,739,077
|
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <math.h>
#include <cassert>
#define rep(i,n) for(int i = 0; i < n; ++i )
using namespace std;
using ll = long long;
using P = pair<int,int>;
vector<int> g[200005];
int main() {
int n,m;
cin >> n >> m;
rep(i,m){
int a,b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for(int u:g[1])for(int v:g[u]){
if(v==n){
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define optimize() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define file() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define tt int t; cin>>t; while(t--)
#define nl cout<<"\n";
#define sp cout<<" ";
#define rep(i, a, b) for(long long i=a; i<b; i++)
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
double PI = 4*atan(1);
int main()
{
optimize();
int h, w;
cin>> h>> w;
char a[h+10][w+10];
int r[h+1]= {}, c[w+1]={};
for(int i=0; i<h; i++)
{
for(int j=0; j<w; j++)
{
cin>> a[i][j];
if( a[i][j]=='#')
{
r[i]++;
c[j]++;
}
}
}
for(int i=0; i<h; i++)
{
if(r[i]== 0)
continue;
for(int j=0; j<w; j++)
{
if(c[j]== 0)
continue;
cout << a[i][j];
}
nl;
}
return 0;
}
| 0
| 39,812,619
|
#include <bits/stdc++.h>
using namespace std;
void __start__() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef MY
freopen("/home/ainur/CLionProjects/wow/input.txt", "r", stdin);
freopen("/home/ainur/CLionProjects/wow/output.txt", "w", stdout);
#else
#define endl '\n'
#endif
}
#define sz(x) (int)x.size()
#define yes cout<<"Yes\n"
#define no cout << "No\n"
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define ft first
#define sd second
#define read(a) for(auto &qwqw:a)cin >> qwqw;
#define print(a) for(auto qwqw:a)cout<<qwqw<<' ';
#define print_plus(a) for(auto qwqw:a)cout<<qwqw+1<<' ';
mt19937_64 rnd(time(0));
#define int long long
using ll = long long;
using vi = vector<int>;
using ld = long double;
using vb = vector<bool>;
using pii = pair<int, int>;
using vd = vector<long double>;
int log2(int q) {
int c = 0;
while (q) {
q >>= 1;
c++;
}
return c;
}
void test_case() {
int n, m, k, ans = 0;
cin >> n >> m >> k;
vector<string> a(n);
read(a);
for (int mask = 0; mask < (1 << n); ++mask) {
for (int tmask = 0, c = 0; tmask < (1 << m); ++tmask) {
c=0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
c += (!(mask & (1 << i)) && !(tmask & (1 << j))) && a[i][j] == '#';
}
}
ans += (c == k);
}
}
cout << ans;
}
signed main() {
__start__();
int Q = 1;
while (Q--) {
test_case();
}
}
|
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int inf = 0x3f3f3f3f;
const int maxn = 200000 + 10;
map<int, int> pre;
int inline idx(char x)
{
return x - 'a';
}
char s[maxn];
int n;
int main()
{
scanf("%s", s);
n = strlen(s);
pre[0] = 0;
int presum = 0;
for (int i = 0; i < n-1; i++)
{
presum ^= (1 << (idx(s[i])));
if (pre.find(presum) == pre.end())
{
pre[presum] = i + 1;
}
for (int j = 0; j < 26; j++)
{
if (pre.find(presum ^ (1 << j)) != pre.end())
pre[presum] = min(pre[presum], pre[presum ^ (1 << j)] + 1);
}
}
presum ^= (1 << idx(s[n-1]));
if (pre.find(presum) == pre.end())
{
pre[presum] = n - 1;
}
int ans = pre[presum] + 1;
for (int j = 0; j < 26; j++)
{
if (pre.find(presum ^ (1 << j)) != pre.end())
ans = min(ans, pre[presum ^ (1 << j)] + 1);
}
printf("%d\n", ans);
}
| 0
| 53,119,326
|
#include <bits/stdc++.h>
using namespace std;
int x;
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
cin >> x;
for(int i = 1;i <= 1000000;i++) {
if(i*x%360 == 0) {
cout << i;
return 0;
}
}
}
|
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
int n;
cin >> n;
vector<long long> x;
long long tmp;
for(int i = 0;i<n;i++){
cin >> tmp;
x.push_back(tmp);
}
long l;
cin >> l;
x.push_back(1e12);
int db[20][n+1];
int db2[20][n+1];
for(int i = 0;i<n;i++){
db[0][i]=(--upper_bound(x.begin(),x.end(),x[i]+l)-x.begin());
}
db[0][n]=n;
db[0][n-1]=n;
for(int i = 0;i<19;i++){
for(int j = 0;j<=n;j++){
db[i+1][j]=db[i][db[i][j]];
}
}
int q;
cin >> q;
long a,b;
long ans[q];
fill_n(ans,q,0);
for(int i = 0;i<q;i++){
cin >> a >> b;
a--;b--;
if(a>b) swap(a,b);
int cnt = 19;
while(a!=b&&cnt>=0){
if(db[cnt][a]<=b){
ans[i]+=pow(2,cnt);
a = db[cnt][a];
}
cnt--;
}
if(a!=b) ans[i]++;
}
for(int i = 0;i<q;i++) cout << ans[i] << endl;
}
| 0
| 38,031,969
|
#include <bits/stdc++.h>
using namespace std;
string s;
int main () {
cin >> s;
for (char c = 'a'; c <= 'z'; c++){
if (s.find(c) == -1){
cout << c;
return 0;
}
}
cout << "None";
}
|
#include <iostream>
#include <cstdlib>
#include <string>
using namespace std;
int main()
{
string str;
while (getline(cin, str))
{
if(str == "0"){
break;
}
int val = 0;
for (auto c : str)
{
val += c - '0';
}
cout << val << endl;
}
}
| 0
| 19,670,886
|
#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define se second
#define fi first
#define ll long long
#define INF INT_MAX
#define mod 1000000007
#define chutiyaap ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
using namespace std;
ll pw(ll a, ll b) {
if (b == 0) return 1;
ll t = pw(a, b / 2);
if (b % 2 == 0) return (t * t)%mod;
else return ((t * t)%mod * a)%mod;
}
int main()
{
int n;cin>>n;
string s;cin>>s;
int ans=1;
for(int i=1;i<n;i++){
if(s[i]!=s[i-1])ans++;
}
cout<<ans<<"\n";
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <queue>
#define INF 0x3f3f3f
using namespace std;
struct edge
{
int from,to,cost;
};
int V[100],E[100],dis[100][100],N;
edge edges[100];
void floyd()
{
int i,j,k;
for(k=0;k<N;k++)
for(i=0;i<N;i++)
for(j=0;j<N;j++)
dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}
int main()
{
int n,i,j,k,a,b,c,ans,big;
while(scanf("%d",&n)&&n)
{
ans=0;
N=0;
for(k=0;k<100;k++)
for(i=0;i<100;i++)
{
dis[k][i]=INF;
if(k==i)
dis[k][i]=0;
}
for(i=0;i<n;i++)
{
scanf("%d %d %d",&a,&b,&c);
dis[a][b]=c;
dis[b][a]=c;
N=max(N,a);
N=max(N,b);
}
N++;
floyd();
int x[100]={0};
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
x[i]+=dis[i][j];
}
int pos = min_element(x,x+N)-x;
cout<<pos<<" "<<x[pos]<<endl;
}
return 0;
}
| 0
| 67,938,351
|
#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
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 N; cin >> N;
int a[10010], b[10010];
rep(i, N) cin >> a[i];
rep(i, N) cin >> b[i];
ll margin = 0;
ll need = 0;
rep(i, N) {
if(a[i] < b[i]) margin += (b[i] - a[i]) / 2;
if(b[i] < a[i]) need += (a[i] - b[i]);
}
if(margin >= need) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
|
#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>;
#define FOR(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 1000000000000
#define MOD 1000000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int n;cin>>n;
vector<int> d(n);
rep(i,n){
cin>>d[i];
}
sort(ALL(d));
n/=2;
cout<<d[n]-d[n-1]<<endl;
return 0;
}
| 0
| 30,695,614
|
#include <bits/stdc++.h>
using namespace std;
int main() {
float a;
float b;
float ave;
int i_ave;
int sum;
cin >> a >> b;
ave = (a+b)/2.0;
i_ave = ave;
sum = a + b;
cout << i_ave+(sum % 2) * (sum % 2) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
struct SegTree{
int n; vector<ll> dat;
SegTree(int _n){
n=1;
while(n<_n) n*=2;
dat=vector<ll>(2*n-1,0);
}
void update(int k, ll a){
k+=n-1;
dat[k]=a;
while(k>0){
k=(k-1)/2;
dat[k]=dat[2*k+1]+dat[2*k+2];
}
}
ll _query(int a, int b, int k, int l, int r){
if(r<=a || b<=l) return 0;
if(a<=l && r<=b) return dat[k];
ll vl=_query(a,b,2*k+1,l,(l+r)/2);
ll vr=_query(a,b,2*k+2,(l+r)/2,r);
return vl+vr;
}
ll query(int a, int b){
return _query(a,b,0,0,n);
}
};
int main(){
int n,d,a;
cin >>n >>d >>a;
vector<pair<int,int>> v(n);
vector<int> ux(n);
rep(i,n){
int x,h;
cin >>x >>h;
h = (h+a-1)/a;
v[i] = {x,h};
ux[i] = x;
}
sort(all(v));
sort(all(ux));
ll ans = 0;
SegTree st(n);
rep(i,n){
int x = v[i].fi-2*d;
int idx = lower_bound(all(ux),x) - ux.begin();
ll add = max(0LL, v[i].se-st.query(idx,i));
st.update(i,add);
ans += add;
}
cout << ans << "\n";
return 0;
}
| 0
| 85,069,896
|
#include <iostream>
int main()
{
int H,W,x,y,r;
bool in;
std::cin >> W;
std::cin >> H;
std::cin >> x;
std::cin >> y;
std::cin >> r;
if (x < 0 || x > W || y < 0 || y > H) {
in = false;
} else if ((y - r) < 0 || (y + r) > H) {
in = false;
} else if ((x - r) < 0 || (x + r) > W) {
in = false;
} else {
in = true;
}
if (in) {
std::cout << "Yes" << std::endl;
} else {
std::cout << "No" << std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define en '\n'
const int MAXN = 1e6+69;
const int INF = 1e18;
const int mod = 1e9+7;
struct vl{
int x,y;
bool operator<(vl t)const{
if(x==t.x)return (y<t.y);
return x<t.x;
}
};
map<int,int>mp;
int q;
int m,p,n,k;
int x,y,z;
int a[MAXN],b[MAXN];
int cnt;
set<int> s;
int luythua(int x, int y){
if(y==0)return 1;
if(y==1)return x%mod;
int k = luythua(x,y/2);
if(y%2==0)return k*k%mod;
return k*k%mod*x%mod;
}
int fact[MAXN];
int comb(int k, int n){
return fact[n]*luythua(fact[k],mod-2)%mod*luythua(fact[n-k],mod-2)%mod;
}
signed main(){ ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>x>>y;
if((x+y)%3!=0){
cout<<0;
return 0;
}
int k = (x+y)/3;
fact[0]=1;
for(int i=1;i<=1000000;i++){
fact[i]=fact[i-1]*i%mod;
}
if(min(x,y)<k){
cout<<0;
return 0;
}
cout<<comb(min(x,y)-k,k)%mod;
}
| 0
| 9,127,807
|
#include<iostream>
#include<iomanip>
#include<vector>
#include<map>
#include<stack>
#include<queue>
#include<string>
#include<utility>
#include<numeric>
#include<algorithm>
#include<cmath>
#include<climits>
using namespace std;
using ll = long long;
class Stream{
public:
Stream(){
}
void read(){
}
template<typename First, typename... Rest>
void read(First& first, Rest&... rest){
cin >> first;
read(rest...);
}
template<typename T>
void write_vec(vector<T>& v, char divider){
for(size_t i = 0; i < v.size(); i++){
cout << v[i] << divider;
}
}
};
int main(){
Stream io;
int N, i;
io.read(N, i);
cout << N - i + 1;
return 0;
}
|
#include <bits/stdc++.h>
#include <vector>
# include <cstdint>
#define FOR(i,l,r) for(int i=(l);i<(r);++i)
#define RFOR(i,l,r) for(int i=(l);i>=(int)(r);i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n-1,0)
#define int long long
using namespace std;
const int MX = 1e6;
const int inf = 1e13;
const int mod = 1e9+7;
#define ll long long
signed main() {
int n,k;
cin >> n>>k;
vector<int> a(n);
rep(i,n) cin >> a[i];
int cnt =0;
rep(i,n) {
FOR(j,i+1,n) {
if(a[i]>a[j]) {
cnt++;
}
}
}
int ans = cnt*k;
ans %=mod;
cnt=0;
rep(i,n) {
rep(j,n) {
if(a[i]<a[j]) {
cnt++;
}
}
}
int tmp = k*(k-1)/2;
tmp %= mod;
tmp *= cnt;
tmp %= mod;
ans += tmp;
cout << ans%mod << endl;
return 0;
}
| 0
| 51,960,598
|
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <ctime>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <bitset>
#include <vector>
#include <complex>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
typedef vector<int> vi;
#define de(x) cout << #x << "=" << x << endl
#define rep(i,a,b) for(int i=a;i<(b);++i)
#define per(i,a,b) for(int i=(b)-1;i>=(a);--i)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
const int N = 1e5 + 10;
int n , L , T , x[N] , w[N] , ed[N] , ans[N];
int main(){
scanf("%d%d%d",&n,&L,&T);
int pos = 0;
rep(i,0,n) {
scanf("%d%d",x+i,w+i);
if(w[i] == 1) {
ed[i] = (x[i] + T) % L;
pos += (x[i] + T) / L;
pos %= n;
} else {
ed[i] = ((x[i] - T) % L + L) % L;
pos += (x[i] - T) / L - (x[i] < T && (x[i] - T) % L != 0);
pos = (pos % n + n) % n;
}
}
sort(ed , ed + n);
rep(i,0,n) printf("%d\n",ed[(pos+i)%n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int soln(vector<vector<int>>a){
int n=a.size();
int dp[n][3];
dp[0][0]=a[0][0];
dp[0][1]=a[0][1];
dp[0][2]=a[0][2];
for(int i=1;i<n;i++){
dp[i][0]=a[i][0]+max(dp[i-1][1],dp[i-1][2]);
dp[i][1]=a[i][1]+max(dp[i-1][0],dp[i-1][2]);
dp[i][2]=a[i][2]+max(dp[i-1][1],dp[i-1][0]);
}
int i=n-1;
return max(dp[i][0],max(dp[i][1],dp[i][2]));
}
int main() {
int n;cin>>n;
vector<vector<int>>a;
for(int i=0;i<n;i++){
int x,y,z;cin>>x>>y>>z;
a.push_back({x,y,z});
}
cout<<soln(a);
}
| 0
| 68,984,848
|
#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);}
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
string in; cin >> in;
int cnt0 = 0, cnt1 = 0;
for(auto& e : in){
(e == '0' ? cnt0:cnt1)++;
}
cout << 2 * min(cnt0, cnt1) << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<pii> vii;
const double EPS=(double)1e-9;
const double PI=(double)acos(-1.0);
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define FOR(i,n) for(int i=0;i<n;i++)
#define REPP(i,l,r,c) for(int i=l;i<=r;i+=c)
#define REP(i,l,r) REPP(i,l,r,1)
#define FORD(i,n) for(int i=n-1;i>=0;i--)
#define REVV(i,l,r,c) for(int i=l;i>=r;i-=c)
#define REV(i,l,r) REVV(i,l,r,1)
int irand(int lo, int hi){
return (((double)rand())/(RAND_MAX+1.0)) * (hi-lo+1) + lo;
}
string toString(ll x) {
stringstream ss;
ss << x;
return ss.str();
}
ll toNumber(string S) {
ll ret;
sscanf(S.c_str(),"%lld",&ret);
return ret;
}
const int INF=(int)2e9;
const ll MOD=(ll)1e9+7;
const int OFFS = 2;
set<pii> dat;
ll res[15];
int main(){
FOR(i,13) res[i] = (ll)0;
dat.clear();
int h,w,n; scanf("%d %d %d", &h, &w, &n);
res[0] = (ll)(h-2) * (ll)(w-2);
FOR(xxx,n){
int subs[5][5];
int a,b; scanf("%d %d", &a, &b);
REP(i,a-2,a+2) REP(j,b-2,b+2){
subs[i-a+OFFS][j-b+OFFS] = (dat.find(mp(i,j)) != dat.end());
}
REP(i,a-1,a+1) REP(j,b-1,b+1){
if(i-1 < 1 || h < i+1) continue;
if(j-1 < 1 || w < j+1) continue;
int cnt = 0;
REP(ix,i-1,i+1) REP(jx,j-1,j+1){
cnt += subs[ix-a+OFFS][jx-b+OFFS];
}
res[cnt ] -= 1;
res[cnt+1] += 1;
}
dat.insert(mp(a,b));
}
FOR(i,10) printf("%lld\n", res[i]);
return 0;
}
| 0
| 82,957,812
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
typedef tree<ii,null_type,less<ii>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
int main() {
cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);
char ch; cin>>ch;
if (ch=='A') cout<<"T";
else if (ch=='T') cout<<"A";
else if (ch=='C') cout<<"G";
else if (ch=='G') cout<<"C";
else cout<<endl;
return 0;
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define coYES cout << "YES" << endl
#define coNO cout << "NO" << endl
#define coYes cout << "Yes" << endl
#define coNo cout << "No" << endl
#define coyes cout << "yes" << endl
#define cono cout << "no" << endl
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
string s; cin >> s;
reverse(s.begin(), s.end());
vector<string> words = {"dream", "dreamer", "erase", "eraser"};
for(int i = 0; i < 4; i++){
reverse(words[i].begin(), words[i].end());
}
string cal;
for(int i = 0; i < (int)s.size(); i++){
cal += s[i];
for(int j = 0; j < 4; j++){
if((string)cal == words[j]){
cal = "";
}
}
}
cout << (cal == "" ? "YES" : "NO") << endl;
return 0;
}
| 0
| 92,901,326
|
#include<bits/stdc++.h>
#define MOD (long long)(1e9+7)
using namespace std;
long long n,k,dp[100005],c[105],sum[100005];
int main()
{
cin >> n >> k;
for(int i=1; i<=n; i++) cin >> c[i];
dp[0]=sum[0]=1;
for(int i=1; i<=n; i++)
{
for(int j=1; j<=k; j++) sum[j]=(dp[j]+sum[j-1]);
for(int j=1; j<=k; j++) dp[j]=(sum[j]-(j<=c[i]?0:sum[j-c[i]-1]))%MOD;
}
cout << dp[k];
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define repeat(i, n) for (int i = 0; (i) < (n); ++(i))
#define repeat_from(i, m, n) for (int i = (m); (i) < (n); ++(i))
#define sz(x) int(x.size())
using namespace std;
template <class T>
void setmax(T &a, T const &b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T const &b) {
if (a > b) a = b;
}
template <typename T, typename X>
auto vectors(T a, X x) { return vector<T>(x, a); }
template <typename T, typename X, typename Y, typename... Zs>
auto vectors(T a, X x, Y y, Zs... zs) {
auto cont = vectors(a, y, zs...);
return vector<decltype(cont)>(x, cont);
}
int main() {
string s;
cin >> s;
int n = s.size();
repeat(i, n - 1) {
if (s[i] == s[i + 1]) {
cout << i + 1 << " " << i + 2 << endl;
return 0;
}
}
repeat(i, n - 2) {
if (s[i] == s[i + 2]) {
cout << i + 1 << " " << i + 3 << endl;
return 0;
}
}
cout << -1 << " " << -1 << endl;
return 0;
}
| 0
| 72,542,693
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n; cin >>n;
for(int i=0; i<n; i++){
float x1, y1, x2, y2, x3, y3, x4, y4;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
if((x2-x1)*(y3-y4)-(y2-y1)*(x3-x4) == 0){
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b) - 1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i ,n) for (int i = (n) - 1; i >= 0; i--)
#define LL long long
#define ULL unsigned long long
void fastIOS()
{
cin.tie(0);
ios::sync_with_stdio(false);
}
int main()
{
fastIOS();
string s; cin >> s;
int index = 0 , c = 0;
char x = s[0];
int i = 0;
if(s.size()==2 && s[0] == s[1]){
cout<< 1 << " " << 2;
return 0;
}
if(s.size()>=2){
while(i<s.size()){
if(s[i]==x){
c++;
}
else{
c--;
}
if(c<0)
{
c = 1;
i--;
x = s[i];
index = i;
}
if(i-index>=2){
cout << index+1 << " " << i+1 << endl;
return 0;
}
i++;
}
}
cout << -1 << " " << -1 << endl;
return 0;
}
| 0
| 35,665,780
|
#include<bits/stdc++.h>
#define ll long long int
#define endl '\n'
#define M 1000000007
#define yes cout<<"YES\n"
#define no cout<<"NO\n"
#define f first
#define s second
#define b begin
#define e end
#define pb push_back
#define mp make_pair
#define FOR(i,a,b) for(i=a;i<b;i++)
#define RFOR(i,a,b) for(i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define itfr(it,x) for(it=x.begin();it!=x.end();it++)
#define flash ios_base::sync_with_stdio(false); cin.tie(NULL)
using namespace std;
int main()
{
flash;
ll T=1,n,w,h,i,j;
while(T--)
{
cin>>w>>h>>n;
ll led=0,leu=h,brl=0,brr=w;
ll x[n],y[n],a[n];
FOR(i,0,n) cin>>x[i]>>y[i]>>a[i];
FOR(i,0,n)
{
if(a[i]==1)
brl = max(brl,x[i]);
if(a[i]==2)
brr = min(brr,x[i]);
if(a[i]==3)
led = max(led,y[i]);
if(a[i]==4)
leu = min(leu,y[i]);
}
if(leu>=led&&brr>=brl){
ll ans = (leu-led)*(brr-brl);
cout<<ans<<endl;
}
else
cout<<0<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main (void) {
int N, K;
cin >> N >> K;
int n = 0;
int half_n = 0;
for ( int i = 1; i <= N; i++ ) {
if ( K % 2 == 0 ) {
if ( i % K == 0 )
n++;
else if ( i % (K / 2) == 0 )
half_n++;
} else {
if ( i % K == 0 )
n++;
}
}
cout << (long long)n * n * n + (long long)half_n * half_n * half_n << endl;
return 0;
}
| 0
| 87,164,709
|
#include <iostream>
#include <string>
using namespace std;
bool isok(string a, string b)
{
return (a == "lu" && b == "ru") || (a == "ru" && b == "lu") || (a == "ld" && b == "rd") || (a == "rd" && b == "ld");
}
int main(void)
{
int n;
while (cin >> n, n){
string str, prev = "";
int ret = 0;
for (int i = 0; i < n; i++){
cin >> str;
if (isok(str, prev)) ret++;
prev = str;
}
cout << ret << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <algorithm>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using hset = unordered_set<T>;
template<class Key, class T> using hmap = unordered_map<Key, T>;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int main() {
int n, m, p, sum, win, tmp;
while (cin >> n >> m >> p) {
if (n == 0) break;
sum = 0;
for (int i = 1; i <= n; i++) {
cin >> tmp;
sum += tmp;
if (i == m) win = tmp;
}
if (win == 0) cout << 0 << endl;
else cout << (100*sum)*(100-p)/(win*100) << endl;
}
return 0;
}
| 0
| 10,056,474
|
#include <iostream>
using namespace std;
int main(){
char c;
cin >> c;
cout << ((c == 'a' || c == 'i' || c == 'u' || c == 'e' || c == 'o') ? "vowel" : "consonant") << endl;
}
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
ll const INF = 1LL << 60;
ll const MAX_N = 510000;
ll const MOD = 1000000007;
int main() {
ll X;
cin >> X;
vector<bool> dp(X + 105);
dp[0] = true;
for (int i = 0; i < X; i++) {
if (dp[i]) {
dp[i + 100] = dp[i + 101] = dp[i + 102] = dp[i + 103] =
dp[i + 104] = dp[i + 105] = true;
}
}
cout << dp[X] << endl;
return 0;
}
| 0
| 7,028,985
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < n; ++i)
#define rep1(i,n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin >> N;
vector<ll> A(N);
rep(i, N) cin >> A[i];
ll ans = 0;
ll sum = 0;
int right = 0;
rep(left, N) {
while(right < N && (sum ^ A[right]) == sum + A[right]) {
sum += A[right];
right++;
}
ans += right - left;
sum -= A[left];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) rep2(i, 0, n)
#define rep1(i, n) rep1(i, 1, n + 1)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
const long long mod = 1e9 + 7;
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << std::fixed << std::setprecision(15);
long long A;
std::cin >> A;
long long B;
std::cin >> B;
long long C;
std::cin >> C;
if (A == B)
cout << C << endl;
else if (B == C)
cout << A << endl;
else
cout << B << endl;
return 0;
}
| 0
| 5,776,414
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
ll GetDigit(ll num){ return log10(num)+1; }
int main()
{
string s,t;
cin >> s >> t;
int ans = 0;
rep(i,3){
if(s[i] == t[i]) ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define pb push_back
#define pi acos(-1.0)
#define loop(i,a,n) for(int i=a;i<n;i++)
#define rloop(i,n,a) for(int i=n;i>=a;i--)
#define ll long long int
#define ff first
#define ss second
#define pii pair<ll,ll>
#define sc1(a) scanf("%d",&a)
#define sc2(a,b) scanf("%d %d",&a,&b)
#define sc3(a,b,c) scanf("%d %d %d",&a,&b,&c)
#define all(v) v.begin(),v.end()
#define ms(a,b) memset(a,b,sizeof a)
#define FastIO ios_base::sync_with_stdio(0);cin.tie(0),cout.tie(0)
#define fileout freopen("output.txt","w",stdout)
#define filein freopen("input.txt","r",stdin)
#define inf 2e9+5
#define Q int q;cin>>q;while(q--)
#define check cout<<"HI"<<endl;
using namespace std;
int main()
{
int n,p=0;
string s,t;
cin >> n >> s;
loop(i,0,n-1)
{
if(s[i]!=s[i+1])
{
p++;
t=s[i];
}
}
if(t[0]!=s[n-1])p++;
cout<<p<<endl;
}
| 0
| 65,946,202
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
int main(){
int n;
cin>>n;
vector<int>v;
for(int i=0;i<n;i++){
int a;cin>>a;
v.push_back(a);
}
int now=1;
for(int i=0;i<v.size();i++){
if(v[i]==now){
now++;
}
}
if(now==1){cout<<-1<<endl;}
else{
cout<<n-(now-1)<<endl;
}
return 0;
}
|
#include <cstring>
#include <algorithm>
#include <iostream>
struct Card {
char suit;
unsigned int rank;
bool operator<(const Card& rhs) { return rank < rhs.rank; }
};
std::ostream& operator<<(std::ostream& os, const Card& card)
{
return os << card.suit << card.rank;
}
std::istream& operator>>(std::istream& is, Card& card)
{
return is >> card.suit >> card.rank;
}
static void print_cards(const Card cards[], const unsigned int n)
{
const char* sep = "";
for (auto i = 0u; i < n; ++i) {
std::cout << sep << cards[i];
sep = " ";
}
std::cout << std::endl;
}
static void copy_cards(Card card2[], const Card card1[], const unsigned int n)
{
std::memcpy(card2, card1, sizeof(card2[0])*n);
}
static bool is_equal_cards(const Card cards1[], const Card cards2[], const unsigned int n)
{
for (auto i = 0u; i < n; ++i) {
if (cards1[i].rank != cards2[i].rank ||
cards1[i].suit != cards2[i].suit) {
return false;
}
}
return true;
}
static void bubble_sort(Card cards[], const unsigned int n)
{
for (auto j = 0u; j < n-1; ++j) {
for (auto i = n-1; i > j; --i) {
if (cards[i] < cards[i-1]) {
std::swap(cards[i], cards[i-1]);
}
}
}
}
static void selection_sort(Card cards[], const unsigned int n)
{
for (auto i = 0u; i < n-1; ++i) {
auto min_j = i;
for (auto j = i+1; j < n; ++j) {
if (cards[j] < cards[min_j]) {
min_j = j;
}
}
if (i != min_j) {
std::swap(cards[i], cards[min_j]);
}
}
}
int main()
{
unsigned int n;
std::cin >> n;
Card cards1[n], cards2[n];
for (auto i = 0u; i < n; ++i) {
std::cin >> cards1[i];
}
copy_cards(cards2, cards1, n);
bubble_sort(cards1, n);
print_cards(cards1, n);
std::cout << "Stable" << std::endl;
selection_sort(cards2, n);
print_cards(cards2, n);
if (is_equal_cards(cards1, cards2, n)) {
std::cout << "Stable" << std::endl;
} else {
std::cout << "Not stable" << std::endl;
}
}
| 0
| 21,782,295
|
#include<iostream>
#include<cstdio>
#include<queue>
#include<string>
using namespace std;
priority_queue<int>q;
int main()
{
int k;
string com;
while(cin>>com){
if(com=="end"){
break;
}else if(com=="extract"){
printf("%d\n",q.top());
q.pop();
}else{
scanf("%d",&k);
q.push(k);
}
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<long long int>> v(8, vector<long long int>(0));
for (int i = 0; i < n; i++) {
long long int a, b, c;
cin >> a >> b >> c;
for (int ia = -1; ia <= 1; ia += 2) {
for (int ib = -1; ib <= 1; ib += 2) {
for (int ic = -1; ic <= 1; ic += 2) {
int index = 0;
if (ia == 1) index += 4;
if (ib == 1) index += 2;
if (ic == 1) index += 1;
v[index].push_back(ia * a + ib * b + ic * c);
}
}
}
}
long long int res = 0;
for (int i = 0; i < 8; i++) {
sort(v[i].begin(), v[i].end(), greater<long long int>());
res = max(res, accumulate(v[i].begin(), v[i].begin() + m, (long long int)0));
}
cout << res << endl;
}
| 0
| 48,326,022
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i = 0;i<((ll)(n));i++)
#define reg(i,a,b) for(ll i = ((ll)(a));i<=((ll)(b));i++)
#define irep(i,n) for(ll i = ((ll)(n)-1);i>=0;i--)
#define ireg(i,a,b) for(ll i = ((ll)(b));i>=((ll)(a));i--)
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;
template<class T = int> void print(vector<T> v){for(auto a:v)cout<<a<<" ";cout<<endl;}
ll h[2],m[2],k;
int main(void){
rep(i,2)cin>>h[i]>>m[i];
cin>>k;
cout<<(h[1]*60+m[1])-(h[0]*60+m[0])-k<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int selection_Sort(int A[], int N){
int res = 0;
for(int i = 0; i < N-1; ++i){
int min_j = i + 1;
for(int j = i +1; j < N; ++j){
if(A[min_j] > A[j]) min_j = j;
}
if( A[i] > A[min_j]){
swap(A[i], A[min_j]);
++res;
}
}
return res;
}
int main(){
int N;
cin >> N;
int A[110];
for(int i = 0; i < N; ++i) cin >> A[i];
int res = selection_Sort(A, N);
for(int i = 0; i < N-1; ++i) cout << A[i] << " ";
cout << A[N-1] << endl;
cout << res << endl;
return 0;
}
| 0
| 34,449,490
|
#include <iostream>
#include <vector>
#include <sstream>
#include <cstring>
using namespace std;
struct P {
int id;
char name;
};
P newP(int id, char name){
P *v = new P;
v->id = id; v->name = name;
return *v;
}
void swap(P& a, P& b){
P h = newP(a.id, a.name);
a = b;
b = h;
}
bool check(vector<P>& A, vector<P> a){
int *ar1, *ar2;
int n = A.size();
ar1 = new int[n]; ar2 = new int[n];
memset(ar1, 0, n*sizeof(int));
memset(ar2, 0, n*sizeof(int));
for(int i=0;i<n;i++){
if(ar1[i] == 0){
int rank = 1;
ar1[i] = rank;
for(int j=i+1;j<n;j++){
if(A[i].id == A[j].id){
rank++;
ar1[j] = rank;
}
}
}
if(ar2[i] == 0){
int rank = 1;
ar2[i] = rank;
for(int j=i+1;j<n;j++){
if(a[i].id == a[j].id){
rank++;
ar2[j] = rank;
}
}
}
}
bool ans = true;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(A[i].name == a[j].name && A[i].id == a[j].id){
if(ar1[i] != ar2[j]) ans = false;
}
}
}
return ans;
}
void BubbleSort(vector<P>& A){
for(int i = 0;i<A.size();i++){
for(int j = A.size()-1; j>i; j--){
if(A[j].id < A[j-1].id){
swap(A[j], A[j-1]);
}
}
}
}
int SelectionSort(vector<P>& A){
for(int i = 0; i< A.size(); i++){
int mini = i;
for(int j = i; j < A.size(); j++){
if(A[j].id < A[mini].id){
mini = j;
}
}
if(i != mini){
swap(A[i], A[mini]);
}
}
}
int main(){
int n;
string h;
vector<P> v,a,b;
cin >> n;
for(int i=0;i<n;i++){
cin >> h;
v.push_back(newP( h[1]-'0', h[0]));
a.push_back(newP(h[1]-'0', h[0]));
b.push_back(newP(h[1]-'0', h[0]));
}
SelectionSort(a);
BubbleSort(b);
cout << b[0].name << b[0].id;
for(int i=1;i<n;i++){
cout << " " << b[i].name << b[i].id;
}
cout << endl;
if(check(v,b)){
cout << "Stable"<<endl;
} else {
cout <<"Not stable"<<endl;
}
cout << a[0].name << a[0].id;
for(int i=1;i<n;i++){
cout << " " << a[i].name << a[i].id;
}
cout << endl;
if(check(v,a)){
cout << "Stable"<<endl;
} else {
cout <<"Not stable"<<endl;
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
using namespace std;
signed main() {
int A, B, C, D;
cin >> A >> B >> C >> D;
if (B <= C) {
cout << 0 << endl;
}
else if (D <= A) {
cout << 0 << endl;
}
else if(A>=C&&B<=D){
cout << B - A << endl;
}
else if (A <= C && B >= D) {
cout << D - C << endl;
}
else if (A < D && C < B && D < B && C < A) {
cout << D - A << endl;
}
else {
cout << B-C << endl;
}
}
| 0
| 3,231,517
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int main(){
int x,y; cin>>x>>y;
cout<<x+y/2<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
bool G[10][10];
int main() {
int N, M; cin >> N >> M;
for (int i = 0; i < M; ++i) {
int a, b; cin >> a >> b; --a, --b;
G[a][b] = G[b][a] = true;
}
vector<int> ord(N);
for (int i = 0; i < N; ++i) ord[i] = i;
int res = 0;
do {
if (ord[0] != 0) break;
bool ok = true;
for (int i = 0; i + 1 < N; ++i) {
int from = ord[i];
int to = ord[i+1];
if (!G[from][to]) ok = false;
}
if (ok) ++res;
} while (next_permutation(ord.begin(), ord.end()));
cout << res << endl;
}
| 0
| 38,278,630
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin>>N;
for(int i =0 ;i <10 ; i++)
if(111*i>=N &&111*(i-1)<N)
cout<<i*111;
}
|
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
#include <fstream>
#include <utility>
#include <functional>
#define popcount __builtin_popcount
using namespace std;
#include <bits/stdc++.h>
#define rep(i,x) for(long long i=0;i<x;i++)
#define repn(i,x) for(long long i=1;i<=x;i++)
#define rrep(i,x) for(long long i=x-1;i>=0;i--)
#define rrepn(i,x) for(long long i=x;i>1;i--)
#define REP(i,n,x) for(long long i=n;i<x;i++)
#define REPN(i,n,x) for(long long i=n+1;i<x;i++)
#define pr printf
#define re return
#define mod 1000000007
#define INF 1e18+5
const double PI=3.14159265358979323846;
#define fi first
#define se second
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
typedef long long int ll;
typedef pair<long long, long long> P;
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;
}
vector<long long> calc_divisor(long long n) {
vector<long long> res;
for (long long i = 1LL; i*i <= n; ++i) {
if (n % i == 0) {
res.push_back(i);
long long j = n / i;
if (j != i) res.push_back(j);
}
}
sort(res.begin(), res.end());
return res;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int gcd(const vector<int> &v) {
int ret = v[0];
for (int i = 1; i < v.size(); i++)
ret = gcd(ret, v[i]);
return ret;
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int lcm(const vector<int> &v) {
int ret = v[0];
for (int i = 1; i < v.size(); i++)
ret = lcm(ret, v[i]);
return ret;
}
vector<pair<long long,long long>> g[200020];
ll s[200020];
bool used[200020];
bool dp[100005];
ll A,B,C,D,H,K,M,N,Q,T,W,X,Y;
double dA,dB,dC,dH,dK,dM,dN,dQ,dT,dW,dX,dY;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
long long ans,sum,cnt,cnt1,flg,flg1,flg2;
long long max,max1;
long long min,min1;
long long wk,wk1;
max=max1=wk=wk1=sum=ans=cnt=cnt1=flg1=flg2=0;
min=min1=INF;
double dwk,dwk1,dsum,dsum1,dans,dans1;
dwk=dwk1=dsum=dsum1=dans=dans1=0;
string s;
cin >> s;
rep(i,s.size()){
if(s[i]=='0'){
cnt++;
}
}
pr("%lld",(MIN(cnt,s.size()-cnt))*2);
re 0;
}
| 0
| 97,801,527
|
#include <iostream>
#include <complex>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <random>
#include <iomanip>
typedef long long int ll;
typedef long double ld;
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
const ll MOD=1000000007;
const ll MAX_N=500010;
const ll INF=999999999999;
char s[100][100];
int dx[]={0,-1,1,0};
int dy[]={-1,0,0,1};
int main(){
int h,w;
cin>>h>>w;
for(int i=0;i<100;i++){
s[0][i]='.';
s[h+1][i]='.';
s[i][w+1]='.';
s[i][0]='.';
}
for(int j=1;j<=h;j++){
for(int i=1;i<=w;i++){
cin>>s[j][i];
}
}
for(int j=1;j<=h;j++){
for(int i=1;i<=w;i++){
bool f=false;
if(s[j][i]=='#'){
for(int v=0;v<4;v++){
if(s[j-dy[v]][i-dx[v]]=='#') f=true;
}
if(!f){
cout<<"No"<<endl;
return 0;
}
}
}
}
cout<<"Yes"<<endl;
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <map>
#include <set>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <algorithm>
#include <functional>
#include <cstring>
#include <string>
#include <sstream>
#include <bitset>
using namespace std;
#define INF 100000000
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define fi first
#define sec second
#define lb lower_bound
#define ub upper_bound
#define SS stringstream
#define rep(i,n) for(int i = 0; i < n; i++)
#define SORT(x) sort((x).begin(), (x).end())
#define clr(a,b) memset((a),(b),sizeof(a))
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<int> Vi;
typedef vector<ll> Vll;
typedef vector<P> Vp;
typedef priority_queue<P, vector<P>, greater<P> > PQ;
int table[100000];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
while(cin >> n,n){
rep(i,100000) table[i] = 0;
rep(i,n){
char t;
int a,b,c,d,e,f;
cin >> a >> t >> b >> t >> c >> d >> t >> e >> t >> f;
c += a*3600+b*60;
f += d*3600+e*60;
table[c]++;
table[f]--;
}
for(int i = 1; i < 100000; i++) table[i] += table[i-1];
int ans = 0;
rep(i,100000) ans = max(ans,table[i]);
cout << ans << endl;
}
}
| 0
| 53,479,231
|
#include <iostream>
using namespace std;
class Triangle {
public:
double Cross_Product_AB_AP, Cross_Product_BC_BP, Cross_Product_CA_CP;
double Vec_ABx, Vec_BCx, Vec_CAx, Vec_APx, Vec_BPx, Vec_CPx;
double Vec_ABy, Vec_BCy, Vec_CAy, Vec_APy, Vec_BPy, Vec_CPy;
Triangle(double x1, double y1, double x2, double y2, double x3, double y3, double xp, double yp);
bool IsInTriangle();
};
Triangle::Triangle(double x1, double y1, double x2, double y2, double x3, double y3, double xp, double yp){
Vec_ABx = x2 - x1;
Vec_BCx = x3 - x2;
Vec_CAx = x1 - x3;
Vec_APx = xp - x1;
Vec_BPx = xp - x2;
Vec_CPx = xp - x3;
Vec_ABy = y2 - y1;
Vec_BCy = y3 - y2;
Vec_CAy = y1 - y3;
Vec_APy = yp - y1;
Vec_BPy = yp - y2;
Vec_CPy = yp - y3;
Cross_Product_AB_AP = Vec_ABx*Vec_APy - Vec_ABy*Vec_APx;
Cross_Product_BC_BP = Vec_BCx*Vec_BPy - Vec_BCy*Vec_BPx;
Cross_Product_CA_CP = Vec_CAx*Vec_CPy - Vec_CAy*Vec_CPx;
};
bool Triangle::IsInTriangle(){
if ((Cross_Product_AB_AP >= 0 && Cross_Product_BC_BP >= 0 && Cross_Product_CA_CP >= 0) ||
(Cross_Product_AB_AP <= 0 && Cross_Product_BC_BP <= 0 && Cross_Product_CA_CP <= 0)){
return true;
}
else { return false;}
};
int main(){
double x1, y1, x2, y2, x3, y3, xp, yp;
while (cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp){
Triangle Triangle(x1, y1, x2, y2, x3, y3, xp, yp);
if (Triangle.IsInTriangle() == true){
cout << "YES"<<endl;
}
else if (Triangle.IsInTriangle() == false) {
cout << "NO" << endl;
}
}
return 0;
}
|
#pragma region template 2.4
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using pq_asc = priority_queue<T, vector<T>, greater<T>>;
typedef long long ll;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef pair<ll, ll> ii;
typedef vector<ii> vii;
typedef vector<string> vs;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REP1(i, n) for (ll i = 1; i <= (n); ++i)
#define FOR(i, a) for (auto &i : a)
#define CH(f, x, y) x = f(x, y)
#define IN(T, x) \
T x; \
cin >> x;
#define AIN(T, a, n) \
vector<T> a(n); \
FOR(i, a) \
cin >> i;
#define A2IN(T1, a, T2, b, n) \
vector<T1> a(n); \
vector<T2> b(n); \
REP(i, n) \
cin >> a[i] >> b[i];
#define OUT(x) cout << (x) << endl;
#define FOUT(x) cout << fixed << setprecision(15) << (x) << endl;
#define ALL(a) (a).begin(), (a).end()
#define SORT(a) sort(ALL(a))
#define RSORT(a) \
SORT(a); \
reverse(ALL(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define DUMPA(a) \
cout << #a << " = {"; \
JOUT(ALL(a), ", ", cout) << "}" << endl;
template <typename T>
ostream &JOUT(T s, T e, string sep = " ", ostream &os = cout)
{
if (s != e)
{
os << *s;
++s;
}
while (s != e)
{
os << sep << *s;
++s;
}
return os;
}
ostream &YES(bool cond, string yes = "Yes", string no = "No", ostream &os = cout)
{
if (cond)
{
os << yes << endl;
}
else
{
os << no << endl;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p)
{
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v)
{
os << '[';
JOUT(ALL(v), ", ", os) << ']';
return os;
}
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#pragma endregion template
int main()
{
IN(ll, H1);
IN(ll, M1);
IN(ll, H2);
IN(ll, M2);
IN(ll, K);
OUT((H2 - H1) * 60 + (M2 - M1) - K);
}
| 0
| 28,204,814
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[])
{
int n;
cin>>n;
long long x,y,u[n],v[n];
for (int i = 0; i < n; ++i)
{
cin>>x>>y;
u[i]=x+y;
v[i]=x-y;
}
long long r=((u[0]%2LL)+2LL)%2LL;
for (int i = 1; i < n; ++i)
{
if (r!=((u[i]%2LL)+2LL)%2LL)
{
cout<<"-1\n";
return 0;
}
}
int m=31;
if (r==0)
{
m=32;
}
cout<<m<<endl;
long long d[m];
d[0]=1LL;
for (int i = 1; i < m; ++i)
{
if (i==1&&r==0)
{
d[1]=1LL;
++i;
}
d[i]=d[i-1]*2LL;
}
reverse(d,d+m);
cout<<d[0];
for (int i = 1; i < m; ++i)
{
cout<<" "<<d[i];
}
cout<<endl;
for (int i = 0; i < n; ++i)
{
char w[m];
long long nu=0LL,nv=0LL;
for (int j = 0; j < m; ++j)
{
if (nu>u[i])
{
if (nv>v[i])
{
w[j]='L';
nu-=d[j];
nv-=d[j];
}
else
{
w[j]='D';
nu-=d[j];
nv+=d[j];
}
}
else
{
if (nv>v[i])
{
w[j]='U';
nu+=d[j];
nv-=d[j];
}
else
{
w[j]='R';
nu+=d[j];
nv+=d[j];
}
}
}
for (int j = 0; j < m; ++j)
{
cout<<w[j];
}
cout<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for(int i = 0; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<int, int>
#define F first
#define S second
#define mod 1000000007
#define MOD 998244353
#define INF 40000000000000000
int dx8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
int dy8[8] = {1, 1, 1, 0, -1, -1, -1, 0};
int dx4[4] = {-1, 0, 1, 0};
int dy4[4] = {0, -1, 0, 1};
signed main(void) {
int N;
cin >> N;
int A[N];
int sum = 0;
rep(i, N) {
cin >> A[i];
sum += A[i];
}
if(sum % (N * (N + 1) / 2) != 0) {
cout << "NO" << endl;
return 0;
}
sum = sum / (N * (N + 1) / 2);
rep(i, N) {
int X = A[N - 1 - i] + sum - A[(N - i) % N];
if(X % N != 0 || X < 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 0
| 59,311,663
|
#include<bits/stdc++.h>
using namespace std;
vector<vector<int>>G;
vector<bool>seen;
vector<int> cost;
void dfs(int v,int p=-1){
seen[v]=true;
if(v!=0)cost[v]+=cost[p];
for(auto next_v:G[v]){
if(next_v==p)continue;
if(seen[next_v])continue;
dfs(next_v,v);
}
}
int main(){
int n,q;
cin>>n>>q;
G.resize(n);
cost.assign(n,0);
seen.assign(n,false);
for(int i=0;i<n-1;i++){
int a,b;
cin>>a>>b;
a--,b--;
G[a].push_back(b);
G[b].push_back(a);
}
for(int i=0;i<q;i++){
int a,b;
cin>>a>>b;
a--;
cost[a]+=b;
}
for(int i=0;i<n;i++){
if(seen[i])continue;
dfs(i);
}
for(int i=0;i<n;i++){
cout<<cost[i]<<" ";
}
cout<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
using Graph = vector<vector<int>>;
using Edge = map<pair<int,int>,int>;
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
ll gcd(ll a,ll b){
if (a%b == 0) return(b);
else return(gcd(b, a%b));
}
ll lcm(ll a, ll b){
return a*b/gcd(a, b);
}
int main()
{
cout << fixed << setprecision(15);
string s, t;
cin >> s >> t;
sort(s.begin(), s.end());
sort(t.rbegin(), t.rend());
if(s<t){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
}
| 0
| 62,342,025
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int H, N;
cin >> H >> N;
vector<pair<int, int>> magics(N+1);
for (int n = 1; n <= N; ++n) {
int A, B;
cin >> A >> B;
magics[n] = {A, B};
}
sort(magics.begin(), magics.end());
vector<vector<int>> dp(H+1, vector<int>(N+1, 1000000001));
for (int h = 1; h <= H; ++h) {
for (int n = 1; n <= N; ++n) {
int mp = magics[n].second;
if (magics[n].first <= h) {
mp = static_cast<int>(ceil(h / static_cast<float>(magics[n].first))) * magics[n].second;
mp = min(mp, dp[h-magics[n].first][n] + magics[n].second);
}
dp[h][n] = min(mp, dp[h][n-1]);
}
}
cout << dp[H][N] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O0")
typedef long long int ll;
typedef long double ld;
const ll mod = 1e9+7;
const ll INF = 1e18;
#define rep(i,n) for (ll i = 0; i < (n); ++i)
#define Rep(i,a,n) for (ll i = (a); i < (n); ++i)
#define All(a) (a).begin(),(a).end()
#define Pi acos(-1)
using Graph = vector<vector<ll>>;
using V = vector<ll>;
using P = pair<ll,ll>;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << setprecision(15) << fixed;
chrono::system_clock::time_point start,end;
start = chrono::system_clock::now();
ll n, m;
cin >> n >> m;
Graph G(n);
rep(i,m) {
ll a, b;
cin >> a >> b;
--a, --b;
G[a].push_back(b);
G[b].push_back(a);
}
V d(n,-1);
queue<ll> q;
d[0] = 0;
q.push(0);
while (!q.empty()) {
ll v = q.front();
q.pop();
for (ll nv : G[v]) {
if (d[nv] != -1) continue;
d[nv] = v+1;
q.push(nv);
}
}
bool bo = true;
rep(i,n) {
if (d[i] == -1) bo = false;
}
if (bo) {
cout << "Yes\n";
rep(i,n-1) cout << d[i+1] << '\n';
}
else cout << "No\n";
end = chrono::system_clock::now();
auto elapsed = chrono::duration_cast< chrono::milliseconds >(end - start).count();
cerr << elapsed << "ms" << '\n';
}
| 0
| 16,210,367
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n,k;
cin >> n >> k;
long long a[n];
for(int i=0;i<n;i++) cin >> a[i];
long long mod=1000000007;
long long b=0,c=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(a[i]>a[j]) b++;
}
}
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(a[i]>a[j]) c++;
}
}
long long ans;
long long d=(k*(k-1)/2LL)%mod;
ans=(c*k+b*d)%mod;
cout << ans << endl;
}
|
#include <iostream>
#include <string>
#include <array>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#define int long long
using namespace std;
void printVector(const vector<int>& vec) {
for (int value : vec) {
cout << value << " ";
}
cout << endl;
}
signed main() {
string s;
int n;
set<char> S;
cin >> s;
n = s.length();
for(int i = 0; i < n; i ++){
S.insert(s[i]);
}
if(n == S.size()) cout << "yes";
else cout << "no";
return 0;
}
| 0
| 20,221,870
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
string S;
cin >> N >> S;
if(S.size() <= N){
cout << S << endl;
return 0;
} else if(N < S.size()) {
S.erase(N);
cout << S << "..." << endl;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
class Dice{
public:
int s[6];
string str = "EWNSRL";
int d[6][4] = {{0, 3, 5, 2}, {0, 2, 5, 3}, {0, 1, 5, 4}, {0, 4, 5, 1}, {1, 2, 4, 3}, {1, 3, 4, 2}};
void roll(char c){
int idx = str.find(c);
int b = s[d[idx][0]];
for(int i = 0; i < 3; i++){
s[d[idx][i]] = s[d[idx][i + 1]];
}
s[d[idx][3]] = b;
}
int hash(){
int res = 0;
for(int i = 0; i < 6; i++) res = res * 256 + s[i];
return res;
}
};
int main(){
Dice d;
for(int i = 0; i < 6; i++){
cin >> d.s[i];
}
int q;
cin >> q;
string s = "NRRRRNRRRRNRRRRNRRRRERRRRERRRRERRRR";
for(int i = 0; i < q; i++){
int top, south;
cin >> top >> south;
for(int j = 0; j < s.size(); j++){
if(d.s[0] == top && d.s[1] == south){
cout << d.s[2] << endl;
break;
}
d.roll(s[j]);
}
}
}
| 0
| 82,614,702
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
int main() {
string S;
cin >> S;
sort(S.begin(),S.end());
if (S.at(0) == 'a' && S.at(1) == 'b' && S.at(2) == 'c') {
cout << "Yes" << endl;
} else cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Field = vector<vector<ll>>;
using Graph = vector<vector<ll>>;
using VI = vector<int>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VC = vector<char>;
using PI = pair<int, int>;
#define FOR(i, s, n) for (int i = s; i < (n); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(x) x.begin(), x.end()
const long long INF = 1LL<<60;
const int mod = 1000000007;
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; i++) {
if (N % i == 0) return false;
}
return true;
}
vector<long long> enum_divisors(long long N) {
vector<long long> res;
for (long long i = 1; i * i <= N; i++) {
if (N % i == 0) {
res.push_back(i);
if (N / i != i) res.push_back(N / i);
}
}
sort(res.begin(), res.end());
return res;
}
vector<pair<long long, long long>> prime_factorize(long long N) {
vector<pair<long long, long long>> res;
for (long long a = 2; a * a <= N; a++) {
if (N % a != 0) continue;
long long ex = 0;
while (N % a == 0) {
ex++;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1) res.push_back({N, 1});
return res;
}
ll N;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> N;
vector<pair<ll, ll>> pf = prime_factorize(N);
ll ans = 0;
for (auto p : pf) {
ll e = p.second;
ll tmp = 0, cur = 1;
while (e >= cur) {
e -= cur;
cur++;
tmp++;
}
ans += tmp;
}
cout << ans << endl;
return 0;
}
| 0
| 69,689,801
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
int main() {
char a, b;
cin >> a >> b;
if ((a == 'H')&&(b == 'H')) {
cout << 'H' << endl;
} else if ((a == 'H')&&(b == 'D')) {
cout << 'D' << endl;
} else if ((a == 'D')&&(b == 'H')) {
cout << 'D' << endl;
} else if ((a == 'D')&&(b == 'D')) {
cout << 'H' << endl;
} else {
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
#define endl "\n"
#define all(V) V.begin(),V.end()
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
const int MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const int inf = 1 << 25;
constexpr long double pi = 3.141592653589793238462643383279;
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
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;
}
ll fact_mod(ll n, ll mod) {
ll f = 1; for (int i = 2; i <= n; i++) f = f * (i % mod) % mod;
return f;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
ll keta(ll n) {
if (n == 0) return 1;
ll count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
ll mch(ll n) {
if (n == 1) return 1;
else return n * mch(n - 1);
}
ll pow_mod(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
ll inv_mod(ll a, ll mod) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= mod;
if (u < 0) u += mod;
return u;
}
bool is_prime(const unsigned n) {
switch (n) {
case 0:
case 1: return false;
case 2:
case 3: return true;
}
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0) return false;
if (n % (i + 2) == 0) return false;
}
return true;
}
ll sum;
int main(void) {
ll n, k;
cin >> n >> k;
vector<pair<ll, ll>> p(n);
rep(i, n) cin >> p[i].first >> p[i].second;
sort(p.begin(), p.end());
rep(i, n) {
sum += p[i].second;
if (sum >= k) {
cout << p[i].first << endl;
return 0;
}
}
return 0;
}
| 0
| 89,327,699
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long i,j,s,k,r=0;
cin>>k>>s;
for(i=0;i<=k;i++)
{
for(j=0;j<=k;j++)
{
if(s-i-j<=k && s-i-j>=0) r++;
}
}
cout<<r;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
int main(){
long long N;
vector <long long> arr;
cin >> N;
for(int i=0; i < N; ++i){
long long tmp;
cin >> tmp;
arr.push_back(tmp);
}
long long sum = 0;
long long max = arr[0];
for(int i=1; i < N; ++i){
if(max>arr[i]){
sum += (max-arr[i]);
}
else{
max = arr[i];
}
}
cout << sum << endl;
return 0;
}
| 0
| 63,842,638
|
#include <iostream>
using namespace std;
int main()
{
int a[101] = {};
int n;
while (cin >> n) {
a[n-1] += 1;
}
int ma = 0;
for (int i = 0; i < 100; ++i) if (ma < a[i]) ma = a[i];
for (int i = 0; i < 100; ++i) if (a[i] == ma) cout << i + 1 << endl;
}
|
#include <cstdio>
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <utility>
#include <string>
#include <cmath>
#include <iomanip>
#include <deque>
#include <queue>
#include <unordered_map>
#include <stack>
#include <bitset>
#include <cstdlib>
#include <sstream>
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
ll pow(ll N, ll P){
if(P==0) return 1;
if(P%2==0){
ll t = pow(N, P/2);
return t*t;
}
return N * pow(N, P-1);
}
ll modpow(ll N, ll P,ll k){
if(P==0) return 1;
if(P%2==0){
ll t = modpow(N, P/2,k)%k;
return t*t%k;
}
return N * modpow(N, P-1,k)%k;
}
ll modkai(ll n,ll m,ll k){
if(n == m)return 1;
return modkai(n-1,m,k)*n%k;
}
ll mod_cnb(ll n,ll m,ll k){
int m_=modkai(m,0,k);
return modkai(n,n-m,k)*modpow(m_,k-2,k)%k;
}
ll gcd(ll n,ll m){
ll n_ = max(n,m);
ll m_ = min(n,m);
if(n_%m_ == 0)return m_;
return gcd(m_,n_%m_);
}
ll lcm(ll n,ll m){
return n*m/gcd(n,m);
}
int main(){
ll x,y,z,k;cin>>x>>y>>z>>k;
vector<ll>a(x),b(y),c(z),d;
rep(i,x)cin>>a[i];
rep(i,y)cin>>b[i];
rep(i,z)cin>>c[i];
priority_queue<ll>s,ans;
rep(i,x){
rep(j,y){
s.push(a[i]+b[j]);
}
}
for(int i=0;i<k&&!s.empty();i++){
d.push_back(s.top());
s.pop();
}
rep(i,z){
rep(j,d.size()){
ans.push(c[i]+d[j]);
}
}
rep(i,k){
cout<<ans.top()<<endl;
ans.pop();
}
}
| 0
| 14,484,000
|
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <cmath>
#include <tuple>
#include <cstring>
#include <map>
#include <iomanip>
#include <ctime>
#include <complex>
#include <cassert>
#include <climits>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define _ << " " <<
#define all(X) (X).begin(), (X).end()
#define len(X) (X).size()
#define Pii pair<int, int>
#define Pll pair<ll, ll>
#define Tiii tuple<int, int, int>
#define Tlll tuple<ll, ll, ll>
int main() {
int n;
cin >> n;
vector<int> p(n);
map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
m[p[i]] = i;
}
ll ans = 0;
set<ll> fow, rev;
fow.insert(-1); fow.insert(n);
rev.insert(-1); rev.insert(n);
for (int i = n - 1; i >= 0; i--) {
fow.insert(m[i]); rev.insert(n - 1 - m[i]);
ll a, b, c, d;
c = *fow.upper_bound(m[i]);
if (c == n) d = n;
else d = *fow.upper_bound(c);
b = n - 1 - *rev.upper_bound(n - 1 - m[i]);
if (b == -1) a = -1;
else a = n - 1 - *rev.upper_bound(n - 1 - b);
ans += (i + 1) * ((b - a) * (c - m[i]) + (m[i] - b) * (d - c));
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<long long>lve;
typedef vector<pair<ll,ll> > lvp;
typedef vector<pair<string,ll> > svp;
#define spc ' '
#define endl '\n'
#define F first
#define S second
#define pp pop_back`
#define pb push_back
#define mp make_pair
#define GCD(x,y) __gcd(x,y)
#define PI 2*acos(0.0);
#define lb lower_bound
#define bs binary_search
#define all(x) x.begin(),x.end()
#define LCM(x,y) ((x*y)/__gcd(x,y))
#define btpc __builtin_popcountll
#define sp(x) cout<<fixed<<setprecision(x)
const long long cs=2e5+5;
const long long inf=1e18;
const long long mod=1e9+7;
char s[cs],s1[cs];
void solve()
{
ll t,n,m,a,b,d,e,i,j,k,x,y,z,cnt=0,cnt1=0,cnt2=0;
bool flag = false;
char c;
cin>>c;
if(c=='a' || c=='e' || c=='i' || c=='o' || c=='u')
cout<<"vowel"<<endl;
else {
cout<<"consonant"<<endl;
}
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
solve();
return 0;
}
| 0
| 68,262,338
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#include <cstring>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define irep(it, stl) for (auto it = stl.begin(); it != stl.end(); it++)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << '\n'
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return 1;
}
return 0;
}
struct io
{
io()
{
ios::sync_with_stdio(false);
cin.tie(0);
}
};
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
const double EPS = 1e-9;
int main(void)
{
int n, k;
cin >> n >> k;
int r = 0;
vector<int> data(n);
vector<vector<int>> moti(100, vector<int>(100));
int a;
rep (i, k) {
cin >> a;
rep (j,a) {
cin >> moti.at(i).at(j);
data.at(moti.at(i).at(j)-1) = 1;
}
}
rep (i, n) {
if (data.at(i) == 1) r++;
}
cout << n-r;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 100010
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template<typename T> void DEBUG(T e){if(DEBUG_OUT == false)return; std::cout << e <<" ";}
template<typename T> void DEBUG(const std::vector<T>& v){if(DEBUG_OUT == false)return;for(const auto& e : v){std::cout<< e << " "; } std::cout << std::endl;}
template<typename T> void DEBUG(const std::vector<std::vector<T> >& vv){if(DEBUG_OUT == false)return;for(const auto& v : vv){ DEBUG(v); } }
template<class T,class... Ts> void DEBUG(T d, Ts... e){if(DEBUG_OUT == false)return;DEBUG(d);DEBUG(e...);}
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; abort();}}
template< typename T1, typename T2 > inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template< typename T1, typename T2 > inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
void solve(void)
{
int H,W; cin>>H; cin>>W;
int A,B; cin>>A; cin>>B;
vector<vector<int> > res (H,vector<int>(W,0));
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
res[i][j] = (i<B)^(j<A);
}
}
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
cout<<res[i][j];
}
cout<<endl;
}
return;
}
int32_t main(int32_t argc, const char *argv[])
{
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(11);
solve();
return 0;
}
| 0
| 17,230,981
|
#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<ll,ll>;
#define FOR(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 1000000000000
#define inf 2147483647
#define MOD 1000000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define CST(x) cout<<fixed<<setprecision(x)
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int gcd(int a, int b) {
if (b==0) return a;
else return gcd(b, a%b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int two(int n){
ll ans=1;
rep(i,n){
ans*=2;
}
return ans;
}
int n;
vector<vector<int>> p;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int k,x;cin>>k>>x;
if(500*k>=x)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin>>n>>k;
int mod = 1e9 + 7;
vector<int> candies(n+1);
for (int i = 1; i <= n; i++)
cin>>candies[i];
vector<vector<int> > ways(n+1, vector<int>(k+1));
vector<int> sum(k+1);
sum[0] = 1;
for (int child = 0; child <= n; child++)
ways[child][0] = 1;
for (int candy = 1; candy <= k; candy++) {
ways[0][candy] = 0;
sum[candy] = 1;
}
for (int child = 1; child <= n; child++) {
for (int candy = 1; candy <= k; candy++) {
if (candies[child] < candy) {
ways[child][candy] = (sum[candy] - sum[candy - candies[child] -1] + mod)%mod;
}
else {
ways[child][candy] = sum[candy];
}
}
for (int candy = 1; candy <= k; candy++)
sum[candy] = (sum[candy-1] + ways[child][candy])%mod;
}
cout<<ways[n][k]<<"\n";
return 0;
}
| 0
| 65,452,161
|
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
long long ans = 0;
bool rest = false;
for (int i = 0; i < N; i++) {
int A;
cin >> A;
if (rest && A > 0) {
ans++;
A--;
}
ans += (long long)A / 2;
rest = A % 2 == 1;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll sumIt(vector<ll>&V,ll n)
{
vector<ll>L(n+2),R(n+2),LL(n+2),RR(n+2);
V.push_back((ll)(1e9));
V.insert(V.begin(),(ll)(1e9));
ll i,j;
for(i=1;i!=n+1;i++)
{
j = i-1;
while(j > 0 && V[j] < V[i])
j = L[j];
L[i] = j;
}
for(i=n;i>0;i--)
{
j = i+1;
while(j < n+1 && V[j] < V[i])
j = R[j];
R[i] = j;
}
for(i=1;i!=n+1;i++)
{
j = max(L[i]-1,(ll)0);
while(j > 0 && V[j] < V[i])
j = L[j];
LL[i] = j;
}
for(i=n;i>0;i--)
{
j = min(R[i]+1,n+1);
while(j < n+1 && V[j] < V[i])
j = R[j];
RR[i] = j;
}
ll s = 0;
for(i=1;i!=n+1;i++)
s += ((L[i]-LL[i]) * (R[i]-i) + (RR[i]-R[i]) * (i-L[i])) * V[i];
return s;
}
int main()
{
ll n;
cin>>n;
vector<ll>V;
ll i,x;
for(i=0;i!=n;i++)
{
cin>>x;
V.push_back(x);
}
cout<<sumIt(V,n);
return 0;
}
| 0
| 60,997,032
|
#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <cstdio>
#include <cmath>
#include <tuple>
#include <iomanip>
#include <numeric>
#include <unordered_map>
#include <sstream>
#include<limits.h>
#include<float.h>
#include<list>
#include <array>
#include <complex>
#include<stdio.h>
#include<string.h>
#include <bitset>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 10000
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template<typename T> void DEBUG(T e){if(DEBUG_OUT == false)return; std::cout << e <<" ";}
template<typename T> void DEBUG(const std::vector<T>& v){if(DEBUG_OUT == false)return;for(const auto& e : v){std::cout<< e << " "; } std::cout << std::endl;}
template<typename T> void DEBUG(const std::vector<std::vector<T> >& vv){if(DEBUG_OUT == false)return;for(const auto& v : vv){ DEBUG(v); } }
template<class T,class... Ts> void DEBUG(T d, Ts... e){if(DEBUG_OUT == false)return;DEBUG(d);DEBUG(e...);}
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; abort();}}
template< typename T1, typename T2 > inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template< typename T1, typename T2 > inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
void solve(void)
{
int N;cin>>N;
vector<int> A (N,0);
for (int i = 0; i < N; i++)
{
cin>>A[i];
}
vector<int> B (N,0);
for (int i = 0; i < N; i++)
{
cin>>B[i];
}
int E_A = 0, E_B = 0;
for (int i = 0; i < N; i++)
{
if(A[i] >B[i]) E_A += A[i] - B[i];
else E_B += (B[i]-A[i])/2*2;
}
if(E_B < 2*E_A)
{
cout<<"No"<<endl;
}
else
{
cout<<"Yes"<<endl;
}
return;
}
int32_t main(int32_t argc, const char *argv[])
{
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(9);
solve();
return 0;
}
|
#include <iostream>
#include <map>
#include <vector>
using namespace std;
map<int, int> counter(vector<int> nums){
map<int, int> outcome;
for (auto n: nums){
outcome[n]++;
}
return outcome;
}
int main(){
vector<int> nums;
for (int i=0;i<3;i++){
int a, b;cin>>a>>b;
nums.push_back(a);
nums.push_back(b);
}
auto freq = counter(nums);
int one_time, two_times;
one_time = two_times = 0;
for (auto item : freq){
if (item.second == 1){
one_time++;
}
if (item.second == 2){
two_times++;
}
}
if (one_time == 2 && two_times == 2){
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 0
| 96,347,310
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long LL;
const int N = 2e5;
vector<int> adj[N+1];
int p[N+1];
void dfs(int u, int prev)
{
p[u] = prev;
for(const int& v : adj[u])
if(v != prev)
dfs(v,u);
}
int main()
{
int n; cin >> n;
for(int i = 0; i < n-1; i++)
{
int u, v; cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1,-1);
LL ans = n;
for(LL s = 2; s <= n; s++)
if(p[s] < s)
ans += (s-p[s])*(n-s+1);
else
ans += s*(p[s]-s);
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <unordered_map>
#include <deque>
using namespace std;
using ll = long long;
void _cin(){} template <class Head, class... Tail> void _cin(Head&& head, Tail&&... tail){ cin >> head; _cin(forward<Tail>(tail)...); }
void _cout(){ cout << "\n"; } template <class Head, class... Tail> void _cout(Head&& head, Tail&&... tail){ cout << head; _cout(forward<Tail>(tail)...); }
int gcd(int a, int b){ return (b == 0) ? a : gcd(b, a % b); }
template<typename S, typename T> istream& operator>>(istream &is, pair<S, T> &p){ return is >> p.first >> p.second; }
template<typename S, typename T> ostream& operator<<(ostream &os, const pair<S, T> &p){ return os << "[" << p.first << ", " << p.second << "]"; }
#define Sq(x) (x)*(x)
#define For(i, n) for(int i = 0; i < (n); i ++)
#define For1(i, n) for(int i = 1; i <= (n); i ++)
#define Rof(i, n) for(int i = (n)-1; i >= 0; i --)
#define Rep(n) For(_, n)
#define Range(c) c.begin(), c.end()
#define RevRange(c) c.rbegin(), c.rend()
#define Contains(c, x) (find(Range(c), x) != c.end())
#define Search(rb, re, x) distance(rb, find(rb, re, x))
#define Sort(a) sort(Range(a))
#define DeSort(a) sort(RevRange(a))
#define Reverse(c) reverse(Range(c))
#define Unique(a) a.erase(unique(Range(a)), a.end())
#define Cusum(T, xs, sxs) vector<T> sxs(xs.size()+1); For(i, (int)xs.size()) sxs[i+1] = sxs[i] + xs[i]
#define Cin(T, ...) T __VA_ARGS__; _cin(__VA_ARGS__)
#define Cins(T, n, xs) vector<T> xs(n); For(i, n) cin >> xs[i]
#define Cins2(T, n, xs, ys) vector<T> xs(n), ys(n); For(i, n) cin >> xs[i] >> ys[i]
#define Cins3(T, n, xs, ys, zs) vector<T> xs(n), ys(n), zs(n); For(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinm(T, n, map) unordered_map<T, int> map; Rep(n){ Cin(T, x); map[x] ++; }
#define Cout(...) _cout(__VA_ARGS__)
#define Couts(xs) { for(const auto &e : xs) cout << e << " "; cout << "\n"; }
#define Coutyn(cond) Cout((cond) ? "yes" : "no")
#define CoutYn(cond) Cout((cond) ? "Yes" : "No")
#define CoutYN(cond) Cout((cond) ? "YES" : "NO")
#define vc vector
#define Mini(a, x) a = min(a, x)
#define Maxi(a, x) a = max(a, x)
#define Return(x) { Cout(x); return 0; }
int main(void){
Cin(int, n);
Cins(int, n, a);
ll ans = 0;
int lb = 1;
For(i, n){
int k = (a[i]-1) / lb;
ans += k;
if(k > 0) a[i] = 1;
lb = max(lb-1, a[i]) + 1;
}
Cout(ans);
}
| 0
| 17,018,176
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
string s;
cin >> a >> b >> s;
if(s[a] == '-'){
for(int i = 0; i < s.size(); i++){
if(i != a){
if(!(s[i] >= 48 && s[i] <= 57)){
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
}else{
cout << "No" << endl;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<double,int> pp;
int main() {
int n;
cin >> n;
vector<int> a(n);
for(int i=0; i<n; ++i) cin >> a[i];
sort(a.begin(), a.end());
int p = a[n-1];
int q = 0;
int m = min(a[0], a[n-1] - a[0]);
for(int i=1; i + 1 < n; ++i) {
if(min(a[i], a[n-1]-a[i]) > m) {
m = min(a[i], a[n-1]-a[i]);
q = i;
}
}
cout << p << ' ' << a[q] << endl;
}
| 0
| 71,202,833
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<(int)(n); i++)
int main() {
string S;
cin >> S;
rep(i, S.size()){
if(i % 2 == 0) cout << S.at(i);
}
cout << endl;
}
|
#include <bits/stdc++.h>
#define rep3(i, s, n, a) for (int i = (s); i < (int)(n); i += a)
#define rep2(i, s, n) rep3(i, s, n, 1)
#define rep(i, n) rep2(i, 0, n)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
int main(){
string s, t;
cin >> s >> t;
int a, b;
cin >> a >> b;
string u;
cin >> u;
if(s==u){
cout << a-1 << " " << b << endl;
}else{
if(t==u){
cout << a << " " << b-1 << endl;
}else{
cout << a << " " << b << endl;
}
}
return 0;
}
| 0
| 93,929,339
|
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <math.h>
#include <string>
#include <numeric>
#include <queue>
#include <cstdio>
#include <cstring>
#define ll long long
#define rep(i,n) for(ll i=0;i<n;++i)
#define rep1(i,n) for(ll i=1;i<n;++i)
#define mrep(i,n) for(ll i=n;i>=0;--i)
#define all(a) (a).begin(),(a).end()
#define vl vector<ll>
#define vvl vector<vector<ll> >
#define vb vector<bool>
#define vvb vector<vector<bool> >
#define pl pair<ll,ll>
#define inf 1001001001001001000
#define mod 998244353
#define pi 3.1415926535
using namespace std;
struct __INIT {
__INIT() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
}__init;
int main(void) {
string s, t;
cin >> s >> t;
cout << t << s << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;
int main() {
string s;
cin >> s;
long long int k;
cin >> k;
for (int i = 0; i < s.size(); i++) {
if (k == 1) {
cout << s[i] << endl;
return 0;
}
if (s[i] == '1') {
k--;
} else {
cout << s[i] << endl;
return 0;
}
}
}
| 0
| 66,704,696
|
#include <iostream>
#include <vector>
#include <utility>
#include <set>
using namespace std;
typedef pair<int, int> P;
int main(){
int N, K;
cin >> N >> K;
int cnt = 0;
if(K > (N - 1) * (N - 2) / 2){
cout << -1 << endl;
return 0;
}
set<P> s;
for(int i = 1; i < N; i++){
cnt++;
s.insert(P(1, i + 1));
}
int cntp = (N - 1) * (N - 2) / 2;
int flag = 0;
for(int i = 2; i <= N; i++){
if(flag == 1) break;
for(int j = i + 1; j <= N; j++){
if(cntp == K){
flag = 1;
break;
}
s.insert(P(i, j));
cnt++;
cntp--;
}
}
cout << cnt << endl;
for(auto p: s){
cout << p.first << ' ' << p.second << endl;
}
}
|
#include<iostream>
using namespace std;
int main() {
int line[101] = { 0 };
int code;
while (cin >> code) {
++line[code];
}
int max = 0;
for (int i = 1; i <= 100; ++i) {
if (max < line[i])max = line[i];
}
for (int i = 1; i <= 100; ++i) {
if (line[i] == max)cout << i << endl;
}
return 0;
}
| 0
| 89,599,789
|
#include <bits/stdc++.h>
#define append push_back
using namespace std;
using ll = long long;
const int N = 1e5 + 3;
const int M = 1e6 + 7;
const long long MOD = 1e9 + 7;
const long long INF = 1e18 + 9;
const int SM = 1e3 + 5;
const int logN = 22, BL = 400;
const double EPS = 1e-9, PI = acos(-1);
const int dx[] = {1, 0, 0, -1, -1, 1, -1, 1};
const int dy[] = {0, 1, -1, 0, -1, 1, 1, -1};
void debug() {
cerr << "\n";
}
template<typename Type1, typename... Type2>
void debug(Type1 a, Type2... b) {
cerr << a << " ";
debug(b...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long n; cin >> n;
vector<long double> v(n);
for(long long i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
for(long long i = 1; i < n; i++){
v[i] = (v[i] + v[i - 1]) / 2.0;
}
cout << fixed << setprecision(7) << v[n - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define prec(n) fixed << setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int>>
#define PI 3.14159265
#define pb push_back
#define bits(n) __builtin_popcount(n)
#define ll long long int
void solve()
{
int n,k;
cin>>n>>k;
maxpq s;
for(int i=0;i<n;i++)
{
int temp;
cin>>temp;
s.push(temp);
}
if(k>=n)
cout<<"0";
else{
while(k--)
{
s.pop();
}
ll sum=0;
while(!s.empty())
{
sum+=s.top();
s.pop();
}
cout<<sum;
}
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
int t=1;
while(t--)
{
solve();
}
return 0;
}
| 0
| 79,246,611
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string alphabet = "abcdefghijklmnopqrstuvwxyz";
string S;
cin >> S;
vector<bool>al(26, false);
for (char s : S) al[s-'a'] = true;
if (S.size() == 26) {
int i = S.size()-1;
while (S[i-1] > S[i]) {
if (i == 1) {
cout << -1 << endl;
return 0;
}
al[S[i]-'a'] = false;
i--;
}
al[S[i]-'a'] = false;
while (al[S[i-1]-'a']) S[i-1]++;
S.erase(i);
cout << S << endl;
return 0;
}
int i = 0;
while (al[i]) i++;
S += alphabet[i];
cout << S << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i, a, b) for(ll i = (a); i < (b); ++i)
#define REP(i, n) for(ll i = 0; i < (n); ++i)
#define ARRAY_LENGTH(array) sizeof(array)/sizeof(*array)
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 ll INF = 1e13;
vector<ll> fact(9);
void init_fact() {
fact[0] = fact[1] = 1;
for(ll i = 2; i < fact.size(); ++i) {
fact[i] = i * fact[i - 1];
}
}
ll N;
vector<ll> P, Q;
ll od(vector<ll> num, ll i, ll bit_flag) {
if(i == N - 1) {
return 1;
}
ll s_od = num[i];
REP(j, num[i]) {
if(bit_flag & (1 << j)) {
--s_od;
}
}
ll ans = (s_od - 1) * fact[N - i - 1];
bit_flag |= 1 << num[i];
return ans + od(num, i + 1, bit_flag);
}
int main() {
init_fact();
cin >> N;
P.resize(N);
Q.resize(N);
REP(i, N) {
cin >> P[i];
}
REP(i, N) {
cin >> Q[i];
}
ll resP = od(P, 0, 0);
ll resQ = od(Q, 0, 0);
cout << abs(resP - resQ) << endl;
return 0;
}
| 0
| 33,553,021
|
#include <iostream>
int main()
{
int n;
std::cin >> n;
unsigned long long int s = 1;
for(std::size_t i = 2; i <= n; ++i){
s *= i;
}
std::cout << s << std::endl;
return 0;
}
|
# pragma GCC target("avx")
# pragma GCC optimize("O3")
# pragma GCC optimize("unroll-loops")
# include <iostream>
# include <vector>
# include <algorithm>
# include <string>
# include <sstream>
# include <cmath>
# include <queue>
# include <stack>
# include <map>
# include <iomanip>
# include <stdexcept>
# include <functional>
# include <tuple>
# include <set>
# include <bitset>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pll = pair<long long, long long>;
template<class T> using vec = vector<T>;
template<class T> using grapth = vec<vec<T>>;
#define rep(i, n) for(ll i=0, i##_len=(n); i<i##_len; ++i)
#define rep1(i, n) for(ll i=1, i##_len=(n); i<=i##_len; ++i)
#define rrep(i, n) for(ll i=(n)-1; i >= 0; --i)
#define rrep1(i, n) for(ll i=(n); i > 0; --i)
#define step(i, a, n) for(ll i=(a), i##_len=(a)+(n); i<i##_len; ++i)
#define rstep(i, a, n) for(ll i=(a)+(n)-1, i##_len=(a); i>=i##_len; --i)
#define range(i, a, b) for(ll i=(a), i##_len=(b); i<i##_len; ++i)
#define rrange(i, a, b) for(ll i=(b)-1, i##_len=(a); i>=i##_len; --i)
constexpr int INF = numeric_limits<int>::max();
constexpr ll INFL = numeric_limits<ll>::max();
constexpr ll INFUL = numeric_limits<ull>::max();
std::string strMulti(const char c, const int n) {
std::string out = "";
for (int i = 0; i < n; i++) { out += c; }
return out;
}
std::string strMulti(const std::string t, const int n) {
std::string out = "";
for (int i = 0; i < n; i++) { out += t; }
return out;
}
std::string tab(const int n)
{
return strMulti('\t', n);
}
std::string join(const std::vector<std::string>& v, const char* delim = 0) {
std::string s;
if (!v.empty()) {
s += v[0];
for (decltype(v.size()) i = 1, c = v.size(); i < c; ++i) {
if (delim) s += delim;
s += v[i];
}
}
return s;
}
string to_string(string& s) {
return '"' + s + '"';
}
string to_string(char& c) {
string out = { '\'', c, '\'' };
return out;
}
template<class T1, class T2> string to_string(pair<T1, T2> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template<class Tuple, size_t ...I> string _to_string_tuple(Tuple&& t, std::index_sequence<I...>) {
vector<string> texts = { to_string(std::get<I>(t))... };
return "(" + join(texts, ", ") + ")";
}
template<class ...Args> string to_string(tuple<Args...> t) {
using Tuple = tuple<Args...>;
return _to_string_tuple(std::forward<Tuple>(t),
std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{});
}
template<class T> string to_string(vector<T> ar) {
vector<string> texts(ar.size());
for (size_t i = 0; i < ar.size(); ++i)
{
texts[i] = to_string(ar[i]);
}
return "{" + join(texts, ", ") + "}";
}
template<class T> string to_string(initializer_list<T> il) {
vector<string> texts(il.size());
size_t i = 0;
for (T v : il)
{
texts[i] = to_string(v);
i++;
}
return "{" + join(texts, ", ") + "}";
}
#define debugvar(x) debugln(#x, (x))
#define debugvartab(x, t) debugln(tab(t) + #x, (x))
void debug(string name) {
std::cerr << name;
}
void debugln(string name) {
std::cerr << name << '\n';
}
template<class T> void debug(string name, T v) {
std::cerr << name << " = " << to_string(v);
}
template<class T> void debugln(string name, T v) {
std::cerr << name << " = " << to_string(v) << '\n';
}
template<class T> void debug(string name, initializer_list<T> il) {
std::cerr << name << " = " << to_string(il);
}
template<class T> void debugln(string name, initializer_list<T> il) {
std::cerr << name << " = " << to_string(il) << '\n';
}
template<class ...Args> void debug(string name, Args ...args) {
std::cerr << name << " = " << to_string(tuple<Args...>(args...));
}
template<class ...Args> void debugln(string name, Args ...args) {
std::cerr << name << " = " << to_string(tuple<Args...>(args...)) << '\n';
}
#define all(x) (x).begin(), (x).end()
#define pair(a, b) make_pair(a, b)
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 divup(const T a, const T b) { if (a % b == 0) { return a / b; } return a / b + 1; }
template<class T> bool cmp_2nd(pair<T, T> a, pair<T, T> b) { if (a.second != b.second) { return a.second < b.second; } return a.first < b.first; }
ll mod_pow(ll x, ll n, const ll& p) { ll ret = 1; while (n > 0) { if (n & 1) { (ret *= x) %= p; } (x *= x) %= p; n >>= 1; } return ret; }
template<class T> T modinv(T a, const T& p) { T b = p, u = 1, v = 0; while (b) { T t = a / b; a -= t * b; swap(a, b); u -= t * v; swap(u, v); } u %= p; if (u < 0) { u += p; } return u; }
template<class T> T math_P(T m, T n) { T ret = 1; for (T i = m; i > m - n; i--) { ret *= i; } return ret; }
template<class T> T math_C(T m, T n) { T ret = math_P(m, n); for (T i = 2; i <= n; i++) { ret /= i; } return ret; }
ll extended_euclidean(ll u, ll v) { ll r0 = u; ll r1 = v; ll s0 = 1; ll s1 = 0; ll t0 = 0; ll t1 = 1; while (r1 != 0) { ll q = r0 / r1; ll r = r0 - q * r1; ll s = s0 - q * s1; ll t = t0 - q * t1; r0 = r1; s0 = s1; t0 = t1; r1 = r; s1 = s; t1 = t; } if (t0 < 0) { return t0 + u; } else { return t0; } }
ll math_C_mod(ll n, ll c, const ll& p) { ll upe = 1; ll dow = 1; for (ll i = 1; i < c + 1; ++i) { upe = upe * n % p; dow = dow * i % p; n -= 1; } return (upe * extended_euclidean(p, dow)) % p; }
template<class T> T math_gcd(T a, T b) { if (b == 0) { return a; } else { return math_gcd(b, a % b); } }
template<class T> T SumStep(T a, T n, T d) { return n * (2 * a + (n - 1) * d) / 2; }
template<class T> T SumRange(T a, T b, T d) { return SumStep(a, (b - a) / d, d); }
constexpr ll MOD = 1000000007;
void Main()
{
string l;
cin >> l;
int ls = l.size();
vec<vec<ll>> dp(ls + 1, vec<ll>(2));
dp[0][0] = 1;
rep(i, ls)
{
if (l[i] == '1')
{
dp[i + 1][0] = (dp[i][0] * 2) % MOD;
dp[i + 1][1] = (dp[i][0] + 3 * dp[i][1]) % MOD;
}
else
{
dp[i + 1][0] = dp[i][0];
dp[i + 1][1] = (3 * dp[i][1]) % MOD;
}
}
cout << (dp[ls][0] + dp[ls][1]) % MOD << endl;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed << std::setprecision(10);
Main();
std::cerr << flush;
std::cout << endl;
return 0;
}
| 0
| 5,878,936
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1e9;
const ll LINF = ll(1e18) + 1;
const int MOD = 1000000007;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1}, Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) \
{ \
cout << x << ' '; \
} \
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;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
string s;
vector<int> a;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> s;
map<char,int>m;
for (int i = 0; i <s.size(); i++)
{
m[s[i]]++;
}
for(char c='a';c<='z';c++){
if(m[c]==0){
s+=c;
break;
}
if(c=='z'){
map<char,int>m1;
char temp=s[s.size()-1];
m1[s[s.size()-1]]++;
for (int i =s.size()-2; i >=0; i--)
{
m1[s[i]]++;
if(temp>s[i]){
s[i]++;
while(m1[s[i]]==0){
s[i]++;
}
cout<<s.substr(0,i+1)<<"\n";
return 0;
}
temp=s[i];
}
return cout<<-1<<"\n",0;
}
}
cout << s<< "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i < (b); ++i)
#define all(x) begin(x), end(x)
typedef long long ll;
typedef pair<int, int> pii;
const int inf=1010001000;
const ll INF=1001000100010001000;
const int mod=(int)1e9+7;
int main(){
int n;
cin>>n;
vector<int>h(n);
rep(i,0,n){
cin>>h.at(i);
}
int c=0;
rep(i,0,n-1){
if(h.at(i)-h.at(i+1)>0){
c+=h.at(i)-h.at(i+1);
}
}
cout<<c+h.at(n-1)<<endl;
return 0;
}
| 0
| 75,399,737
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
int main() {
int A, B;
cin >> A >> B;
string S;
cin >> S;
bool flag = true;
for(int i = 0; i < A; i++) {
if(S[i] >= '0' && S[i] <= '9') continue;
else { flag = false; }
}
if(S[A] != '-') {
flag = false;
}
for(int i = A + 1; i < A + B + 1; i++) {
if(S[i] >= '0' && S[i] <= '9') continue;
else { flag = false; }
}
if(flag)
cout << "Yes";
else
{
cout << "No";
}
return 0;
}
|
#include <iostream>
#include <string.h>
int main()
{
char main_string[1000], sub_string[1000];
std::cin >> main_string;
std::cin >> sub_string;
int difference = strlen(main_string) - strlen(sub_string) + 1;
int max_same_char[difference];
for (int i = 0; i < difference; i++)
{
max_same_char[i] = 0;
for (int j = i; j < i + strlen(sub_string); j++)
{
if (strncmp(&main_string[j], &sub_string[j - i], 1) == 0)
{
max_same_char[i]++;
}
}
}
int max_num = 0;
for (int i = 0; i < difference; i++)
{
if (max_same_char[i] > max_num)
{
max_num = max_same_char[i];
}
}
std::cout << strlen(sub_string) - max_num << std::endl;
return 0;
}
| 0
| 62,620,977
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
int main() {
int N;
cin >> N;
vector<ll> A(N);
rep(i, N) cin >> A[i];
sort(all(A));
vector<ll> use;
vector<ll> tmp;
rep(i, N) {
if (tmp.empty() || tmp.back() != A[i]) {
tmp.push_back(A[i]);
} else {
tmp.pop_back();
use.push_back(A[i]);
}
}
sort(all(use));
ll ans = 0;
if (use.size() >= 2) {
ll a = use[use.size()-1];
ll b = use[use.size()-2];
ans = a * b;
}
cout << ans << endl;
}
|
#include <iostream>
#include <iomanip>
#include <string>
#include <stack>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <regex>
using namespace std;
using pii = pair<int,int>;
using ll=long long;
using ld=long double;
#define pb push_back
#define mp make_pair
#define stpr setprecision
#define cYES cout<<"YES"<<endl
#define cNO cout<<"NO"<<endl
#define cYes cout<<"Yes"<<endl
#define cNo cout<<"No"<<endl
#define rep(i,n) for(ll i=0;i<(n);++i)
#define Rep(i,a,b) for(ll i=(a);i<(b);++i)
#define rrep(i,n) for(int i=n-1;i>=0;i--)
#define rRep(i,a,b) for(int i=a;i>=b;i--)
#define crep(i) for(char i='a';i<='z';++i)
#define psortsecond(A,N) sort(A,A+N,[](const pii &a, const pii &b){return a.second<b.second;});
#define ALL(x) (x).begin(),(x).end()
#define debug(v) cout<<#v<<":";for(auto x:v){cout<<x<<' ';}cout<<endl;
#define endl '\n'
int ctoi(const char c){
if('0' <= c && c <= '9') return (c-'0');
return -1;
}
ll gcd(ll a,ll b){return (b == 0 ? a : gcd(b, a%b));}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
constexpr ll MOD=1000000007;
constexpr ll INF=1000000011;
constexpr ll MOD2=998244353;
constexpr ll LINF = 1001002003004005006ll;
constexpr ld EPS=10e-8;
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<typename T> istream& operator>>(istream& is,vector<T>& v){for(auto&& x:v)is >> x;return is;}
template<typename T,typename U> istream& operator>>(istream& is, pair<T,U>& p){ is >> p.first; is >> p.second; return is;}
template<typename T,typename U> ostream& operator>>(ostream& os, const pair<T,U>& p){ os << p.first << ' ' << p.second; return os;}
template<class T> ostream& operator<<(ostream& os, vector<T>& v){
for(auto i=begin(v); i != end(v); ++i){
if(i !=begin(v)) os << ' ';
os << *i;
}
return os;
}
int main(){
ll K,N;
string S;
cin >> N >> S >> K;
rep(i,N){
if(S[i]!=S[K-1]){
cout << "*";
}
else{
cout << S[i];
}
}
cout << endl;
}
| 0
| 82,392,043
|
#include <iostream>
using namespace std;
int main(){
int N;
cin >> N;
int a[N+1];
for(int i=0; i<N; i++)
cin >> a[i+1];
bool pushed[N+1];
for(int i=0; i<N+1; i++)
pushed[i] = false;
int count = 0;
int now = 1;
pushed[now] = true;
while(1){
if(a[now] == 2){
cout << count+1 << endl;
return 0;
}
if(pushed[a[now] ] == false){
pushed[a[now] ] = true;
now = a[now];
count++;
}
else{
cout << -1 << endl;
return 0;
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ldb long double
#define rep(i, x, n, j) for(int i=x;i<(int)n;i+=j)
#define F first
#define S second
#define per(i, x, n, j) for(int i=(int)n-1;i>=0;i-=j)
#define all(v) v.begin(),v.end()
#define sz(a) (int)a.size()
const int N = 2000100;
const ll MOD = 1e9+7;
const ll inf = 1e18+5;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<ll> vl;
typedef pair<ll, ll> pll;
int _;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, k; cin >> n >> k;
string s; cin >> s;
if (10%k == 0) {
ll ans = 0;
rep(r,0,n,1) {
if ((s[r]-'0') % k == 0) {
ans += r+1;
}
}
cout << ans << endl;
return 0;
}
else{
vector<ll> d(n+1, 0ll);
ll mul = 1ll;
map<ll, ll> mp;
mp[0]++;
for(int i=n-1; i>=0; --i){
ll h = (s[i]-'0');
d[i] = ((h*mul)+d[i+1])%k;
mp[d[i]]++;
mul*=10ll; mul%=k;
}
vector<int> cnt(k);
ll ans = 0;
for (int i = n; i >= 0; --i) {
ans += cnt[d[i]];
cnt[d[i]]++;
}
cout << ans << endl;
}
return 0;
}
| 0
| 60,881,463
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) \
for (int i = 0; i < (int)(n); i++) \
;
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
int main() {
string s;
cin >> s;
int ans = 0;
if (s.find("RRR") == 0) {
ans = 3;
} else if (s.find("RR") == 0 || s.find("RR") == 1) {
ans = 2;
} else if (s.find("R") <= 2) {
ans = 1;
} else {
ans = 0;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int x;
cin>>x;
for(int i=1;i<100000;i++)
{
if(i*x%360==0)
{
cout<<i<<endl;
break;
}
}
}
| 0
| 80,561,864
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define mod 998244353
#define INF 1 << 30
#define MAX 1 << 18
int solve(int src, int count, vector<vector<int>>& adj, vector<bool>& color, int* dp) {
if(dp[src] != -1) {
return dp[src];
}
int ans = MAX;
bool flag = false;
int tmp;
for(auto node: adj[src]) {
flag = true;
if(color[node]) {
tmp = solve(node, 0, adj, color, dp);
} else {
tmp = solve(node, 0, adj, color, dp);
}
if(color[node] || (color[node] == color[src])) {
ans = min(ans, (count + tmp));
} else {
ans = min(ans, (count + tmp + 1));
}
}
if(flag)
return dp[src] = ans;
return dp[src] = count;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h, w;
cin >> h >> w;
int n = h*w;
vector<vector<int>> adj(n);
vector<bool> color(n);
char ch;
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
cin >> ch;
int node = i*w + j;
if(ch == '#') {
color[node] = false;
} else {
color[node] = true;
}
if((node + 1) < n && (j+1) < w) {
adj[node].push_back(node+1);
}
if((node + w) < n && (i+1) < h) {
adj[node].push_back(node+w);
}
}
}
int dp[n];
for(int i = 0; i < n; i++) {
dp[i] = -1;
}
int ans;
if(color[0]) {
ans = solve(0, 0, adj, color, dp);
} else {
ans = solve(0, 1, adj, color, dp);
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
int main(void) {
double T, X;
cin >> T >> X;
printf("%.4f\n", T / X);
return 0;
}
| 0
| 14,555,748
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define IFOR(i, m, n) for (ll i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto&(x) : (a))
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) ll(x.size())
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll n, k;
cin >> n >> k;
vector<ll> a(n);
ll g = 0;
REP(i, n) {
cin >> a[i];
g = gcd(g, a[i]);
}
REP(i, n) {
ll t = a[i] - k;
if (t >= 0 && t % g == 0) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
}
|
#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 int long long
#define mp make_pair
const int MOD=1e9+7;
const int INF=1e15;
int myf(int x,int d){
if(x%d==0)return x/d;
else return x/d+1;
}
signed main(){
int N,H;cin>>N>>H;
vector<pair<int,int>>A(2*N);
REP(i,2*N){
int a;cin>>a;
if(i%2==0)A[i]=mp(a,0);
else A[i]=mp(a,1);
}
sort(A.rbegin(),A.rend());
int ans=0;
int i=0;
while(H>0){
if(A[i].second==0){
ans+=myf(H,A[i].first);
break;
}
else{
H-=A[i].first;
ans++;
i++;
}
}
cout<<ans<<endl;
}
| 0
| 13,118,053
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
typedef pair<ll,ll> pi;
typedef pair<ll,pi> pii;
typedef vector<pi> vpi;
typedef set<ll> si;
typedef long double ld;
#define mp make_pair
#define pb push_back
#define f first
#define s second
ll INF = 1e9;
ll MOD = 1e9;
#define lb lower_bound
#define ub upper_bound
#define SZ(x) (ll)x.size()
#define ALL(x) x.begin(),x.end()
int N,a,L,b,Q;
vi V;
int dst[100100][18];
int query(int x, int y){
int ans = 0;
for (int i=17;i>=0;--i){
if (dst[x][i] == -1 || dst[x][i] > y)continue;
x = dst[x][i];
ans += (1<<i);
if (x == y)return ans;
}
return ans + 1;
}
int main(){
cin >> N;
for (int i=0;i<N;++i){
cin >>a ;
V.pb(a);
}
V.pb(INF);
cin >> L;
memset(dst, -1, sizeof(dst));
for (int i=0;i<N;++i){
int t = V[i]+L;
int x = ub(ALL(V), t) - V.begin() - 1;
if (i != x)dst[i][0] = x;
}
for (int i=1;i<18;++i){
for (int j=0;j<N;++j){
if (dst[j][i-1] != -1)dst[j][i] = dst[ dst[j][i-1] ][i-1];
}
}
cin >> Q;
while (Q--){
cin >>a >> b;
--a;--b;
if (a > b)swap(a,b);
cout<<query(a,b)<<'\n';
}
}
|
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;++i)
#include<string>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<int, int>P;
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 g[15][15];
const int INF = 1001001001;
const int dx[4] = { -1,0,1,0 };
const int dy[4] = { 0,-1,0,1 };
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)return 0;
return (x / gcd(x, y) * y);
}
vector<pair<ll, int>>factorize(ll n) {
vector<pair<ll, int>>res;
for (ll i = 2;i * i <= n;++i) {
if (n % i)continue;
res.emplace_back(i, 0);
while (n % i == 0) {
n /= i;
res.back().second++;
}
}
if (n != 1)res.emplace_back(n, 1);
return res;
}
int bingo[3][3];
bool flag[3][3];
int cnt[2][105];
int h, w;
int choco[1010][1010];
int s[11][11];
int main() {
int n;
cin >> n;
vector<ll>a(n);
rep(i, n) {
cin >> a[i];
}
sort(a.rbegin(), a.rend());
int res = 0;
ll ans = 1;
for (int i = 1;i < n;++i) {
if (a[i - 1] == a[i]) {
ans *= a[i];
i++;
res++;
if (res == 2)break;
}
}
if (res == 2)cout << ans << endl;
else cout << 0 << endl;
return 0;
}
| 0
| 69,681,478
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <math.h>
#include <assert.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <iostream>
#include <functional>
#include <unordered_set>
#include <bitset>
#include <time.h>
#include <limits.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define Fi first
#define Se second
#define pb(x) push_back(x)
#define szz(x) (int)x.size()
#define rep(i,n) for(int i=0;i<n;i++)
#define all(x) x.begin(),x.end()
typedef tuple<int, int, int> t3;
ll X[1010], Y[1010];
int main() {
int N; scanf("%d", &N);
for(int i=0;i<N;i++) scanf("%lld%lld", X+i, Y+i);
for(int i=1;i<N;i++) {
ll t = (X[i] + Y[i] - X[0] - Y[0]) & 1;
if(t) {
puts("-1");
return 0;
}
}
ll t = (X[0] + Y[0]) & 1;
int R = 34;
if(!t) {
printf("%d\n", R + 1);
for(int i=0;i<R;i++) printf("%lld ", 1LL<<i); puts("1");
}
else {
printf("%d\n", R);
for(int i=0;i<R;i++) printf("%lld ", 1LL<<i); puts("");
}
for(int i=0;i<N;i++) {
if(!t) ++X[i];
ll a = (X[i] + Y[i] + (1LL << R) - 1) / 2;
ll b = (X[i] - Y[i] + (1LL << R) - 1) / 2;
for(int j=0;j<R;j++) {
int ta = !!(1LL << j & a);
int tb = !!(1LL << j & b);
printf("%c", "LDUR"[ta*2+tb]);
}
if(!t) puts("L");
else puts("");
}
return 0;
}
|
#include<cstdio>
#include<iostream>
#include<vector>
using namespace std;
int main(void) {
int N, M, X;
scanf("%d %d %d", &N, &M, &X);
int C[12];
int A[12][12];
for (int i = 0; i < N; i++) {
scanf("%d", &C[i]);
for (int j = 0; j < M; j++) {
scanf("%d", &A[i][j]);
}
}
int ans = 1<<30;
bool ansFound = false;
for (int bit = 0; bit < (1 << N); bit++) {
int sum = 0;
int skill[12] = {0};
for (int i = 0; i < N; i++) {
if (bit & (1 << i)) {
sum += C[i];
for (int j = 0; j < M; j++) {
skill[j] += A[i][j];
}
}
}
bool flag = true;
for (int j = 0; j < M; j++) {
if (skill[j] < X) {
flag = false;
break;
}
}
if (flag) {
ans = min(ans, sum);
ansFound = true;
}
}
if (ansFound) printf("%d\n", ans);
else printf("-1\n");
return 0;
}
| 0
| 91,112,895
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pair<int, int>> vpi;
#define pb push_back
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define ff first
#define ss second
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define tcase() int t; cin >> t; while(t--)
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const ll INF = 1e18;
const ld PI = acos((ld) -1);
void setIO(string name = "") {
ios_base::sync_with_stdio(0); cin.tie(0);
if(sz(name)){
freopen((name+".in").c_str(), "r", stdin);
freopen((name+".out").c_str(), "w", stdout);
}
}
vi adj[MX];
int Ans[MX];
bool visited[MX];
queue<int> q;
int dis[MX];
void bfs(int node){
visited[node] = true;
dis[node] = 0;
q.push(node);
while(!q.empty()){
int s = q.front(); q.pop();
for(auto u : adj[s]){
if(visited[u]) continue;
visited[u] = true;
Ans[u] = s;
dis[u] = dis[s] + 1;
q.push(u);
}
}
}
int main(){
setIO();
int n, m;
cin >> n >> m;
while(m--){
int a, b;
cin >> a >> b;
adj[a].pb(b), adj[b].pb(a);
}
bfs(1);
for(int i = 1; i <= n; i++){
if(!visited[i]){
cout << "No";
return 0;
}
}
cout << "Yes\n";
for(int i = 2; i <= n; i++) cout << Ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ull=unsigned long long;
using pii=pair<int,int>;
#define INF LONG_MAX
#define MOD 1000000007
#define rng(a) a.begin(),a.end()
#define rrng(a) a.end(),a.begin()
#define endl "\n"
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll N,L;
cin>>N>>L;
vector<ll>a(N);
for(int i=0;i<N;i++)cin>>a[i];
vector<int>ans;
bool ok=false;
for(int i=0;i<N-1;i++){
if(a[i]+a[i+1]>=L){
ok=true;
for(int j=1;j<i+1;j++)ans.push_back(j);
for(int j=N-1;j>=i+1;j--)ans.push_back(j);
break;
}
}
if(ok){
cout<<"Possible"<<endl;
for(auto it:ans)cout<<it<<endl;
}
else cout<<"Impossible"<<endl;
return 0;
}
| 0
| 41,035,320
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<double, double> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
double equal(double a, double b) {
return fabs(a - b) < DBL_EPSILON;
}
std::istream &operator>>(std::istream &in, set<string> &o) {
string a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
typedef priority_queue<ll, vector<ll>, greater<ll> > PQ_ASK;
int main() {
string s;
cin >> s;
string ans = (s.substr(0, 4) == "YAKI") ? "Yes" : "No";
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define MOD 1000000007
#define ALL(obj) (obj).begin(),(obj).end()
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 long long INF = 1LL << 60;
bool pairCompare(const pair<double,ll>& firstElof, const pair<double,ll>& secondElof){
return firstElof.first < secondElof.first;
}
bool pairCompareSecond(const pair<double,ll>& firstElof, const pair<double,ll>& secondElof){
return firstElof.second < secondElof.second;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct edge{
ll from,to,cost;
};
typedef vector<vector<edge> > G;
ll gcd(ll a,ll b){
if (a%b==0)return(b);
else return(gcd(b,a%b));
}
ll x[1010000];
ll fib(ll b){
if (b==1)return 0;
if (b==2)return 0;
if (b==3)return 1;
if (x[b]!=-1)return x[b];
x[b]=(fib(b-1)+fib(b-2)+fib(b-3))%10007;
return x[b];
}
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i=0;i<n;i++)cin >> a[i];
sort(a,a+n);
ll ans=1,c=0;
for (ll i=1;i<n;i++){
if (a[i-1]!=a[i])ans++;
else{
c++;
}
}
if (c%2)ans--;
cout << ans << endl;
return 0;
}
| 0
| 42,140,064
|
#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 x; cin >> x;
if(x >= 2000){
cout << 1 << endl;
return 0;
}
else{
rep(i,21){
rep(j,21){
rep(k,21){
rep(l,21){
rep(m,21){
rep(n,21){
if(100*i+101*j+102*k+103*l+104*m+105*n == x){
cout << 1 << endl;
return 0;
}
}
}
}
}
}
}
}
cout << 0 << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main() {
int x[12];
int y[12];
scanf("%d %d %d",&x[0],&x[1],&x[2]);
scanf("%d %d %d",&x[3],&x[4],&x[5]);
scanf("%d %d %d",&x[6],&x[7],&x[8]);
int n;
scanf("%d",&n);
for(int i = 1 ; i <= n ; i++)
scanf("%d",&y[i]);
for(int i = 0 ; i < 9 ; i++){
for(int j = 1 ; j <= n ; j++){
if(x[i] == y[j])
x[i] = 0;
}
}
if(x[0] == x[1] && x[1] == x[2])
cout << "Yes" << endl;
else if(x[3] == x[4] && x[4] == x[5])
cout << "Yes" << endl;
else if(x[6] == x[7] && x[7] == x[8])
cout << "Yes" << endl;
else if(x[0] == x[4] && x[4] == x[8])
cout << "Yes" << endl;
else if(x[2] == x[4] && x[4] == x[6])
cout << "Yes" << endl;
else if(x[0] == x[3] && x[3] == x[6])
cout << "Yes" << endl;
else if(x[1] == x[4] && x[4] == x[7])
cout << "Yes" << endl;
else if(x[2] == x[5] && x[5] == x[8])
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 0
| 67,099,335
|
#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;
using namespace atcoder;
int main(){
int n, q;
cin >> n >> q;
dsu d(n);
for(int i = 0; i < q; i++){
int t, u, v;
cin >> t >> u >> v;
if(t == 0){
d.merge(u, v);
}
else{
if(d.same(u, v)){
cout << 1 << endl;
}
else{
cout << 0 << endl;
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
static const ll MAX = 1000000000000000;
static const int NIL = -1;
using namespace std;
const long double EPS = 0.0000000001;
const long double PI = (acos(-1));
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
int main() {
vector<pair<int,int>>odd(100005);
vector<pair<int,int>>even(100005);
int N;
cin >> N;
for(int i=0;i<N;i++){
int x; cin >> x;
if(i%2 == 0){
even[x].first++;
even[x].second=x;
}else {
odd[x].first++;
odd[x].second = x;
}
}
sort(odd.begin(),odd.end());
reverse(odd.begin(),odd.end());
sort(even.begin(),even.end());
reverse(even.begin(),even.end());
if(odd[0].second == even[0].second){
if(odd[1].first + even[0].first > even[1].first+odd[0].first) cout << N-odd[1].first-even[0].first;
else cout << N-even[1].first-odd[0].first;
} else cout << N-odd[0].first-even[0].first;
return 0;
}
| 0
| 70,102,859
|
#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
#include<cstring>
#include<bitset>
#include<stack>
#include<time.h>
#define X first
#define Y second
#define PB push_back
#define MP make_pair
#define scd(a) scanf("%d",&a)
#define scdd(a,b) scanf("%d%d",&a,&b)
#define scddd(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define ALL(x) x.begin(),x.end()
#define sz(a) ((int)a.size())
#define getmid ((l+r)>>1)
#define mst(var,val) memset(var,val,sizeof(var))
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define lowbit(x) x&(-x)
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ls rt<<1
#define rs rt<<1|1
using namespace std;
#ifdef local
#define dbg(args...) cout << #args << " -> ", err(args);
void err(){ cout << endl; }
template<typename T, typename... Args>
void err(T a, Args... args){ cout << a << ' '; err(args...); }
#else
#define dbg(args...)
#endif
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <ll, int> pli;
typedef pair <double, double> pdd;
const int inf=0x3f3f3f3f;
const long long INF=0x3f3f3f3f3f3f3f3fLL;
const double PI=acos(-1.0);
const long double eps=1e-8;
const int mod=1e9+7;
const int maxn=3e5+100;
const int N=1e6+1000;
const int M=500+10;
const ll mm=(1LL<<32);
template <class T>
inline void read(T &x)
{
x = 0;
char c = getchar();
bool f = 0;
for (; !isdigit(c); c = getchar())
f ^= c == '-';
for (; isdigit(c); c = getchar())
x = x * 10 + (c ^ 48);
x = f ? -x : x;
}
template <class T>
inline void write(T x)
{
if (x < 0)
{
putchar('-');
x = -x;
}
T y = 1;
int len = 1;
for (; y <= x / 10; y *= 10)
++len;
for (; len; --len, x %= y, y /= 10)
putchar(x / y + 48);
}
ll qpow(ll a,ll b,ll mod)
{
ll ans=1;
while(b)
{
if(b&1)
ans=(ans*a)%mod;
b>>=1;
a=(a*a)%mod;
}
return ans;
}
int vis[N],a[N];
int tot,prime[N];
void init()
{
for(int i=2;i<N;++i)
{
if(!vis[i]) prime[tot++]=i;
for(int j=0;j<tot;++j)
{
if(i*prime[j]>N) break;
vis[i*prime[j]]=1;
}
}
}
int gcd(int a,int b)
{
return b?gcd(b,a%b):a;
}
int main()
{
#ifdef local
freopen("in.txt","r",stdin);
#endif
init();
int n;read(n);
rep1(i,n) read(a[i]);
int flag=1,tag=0;
for(int i=1;i<=n;++i)
{
if(a[i]==1)
{
tag=1;continue;
}
int x=a[i];
for(int j=0;j<tot&&prime[j]*prime[j]<=x;++j)
{
if(x%prime[j]==0)
{
while(x%prime[j]==0) x/=prime[j];
if(vis[prime[j]]!=0)
{
flag=0;break;
}
else vis[prime[j]]=1;
}
}
if(x!=1)
{
if(vis[x]==1) flag=0;
else vis[x]=1;
}
if(!flag) break;
}
if(flag)
{
puts("pairwise coprime");
return 0;
}
int ans=a[1];
for(int i=2;i<=n;++i) ans=gcd(ans,a[i]);
if(ans==1) puts("setwise coprime");
else puts("not coprime");
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
#define all(a) a.begin(),a.end()
#define o(a) cout<<a<<endl
#define int long long
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
signed main(){
int n;
string s;
while(1){
int l=0,r=0,ans=0,pre=0;
cin>>n;
if(n==0) break;
rep(i,0,n){
cin>>s;
if(s=="lu") l=1;
if(s=="ru") r=1;
if(s=="ld") l=0;
if(s=="rd") r=0;
if(l==r && l!=pre){
ans++;
pre=l;
}
}
o(ans);
}
}
| 0
| 70,791,164
|
#include<bits/stdc++.h>
using namespace std;
#define ll long
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
string s;
int a, b;
cin >> a >> s >> b;
if (s == "+") {
cout << a + b << endl;
} else {
cout << a - b << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define FOR(i,n,j) for(int i=(j);i<(n);++i)
#define ssort(n) sort((n).begin(),(n).end())
#define rsort(n) sort((n).begin(),(n).end(),greater<ll>())
using ll=long long;
using ld=long double;
typedef pair<int,int> P;
typedef pair<P,int> COST;
#define repl(i,n) for(ll i=0;i<(n);++i)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
using Graf_char=vector<vector<char>>;
using Graf_int=vector<vector<int>>;
#define MAX 100000
int main()
{
int x,y;
cin >> x >> y;
int a,b,c;
cin >> a >> b >> c;
vector<ll> p(a),q(b),r(c);
rep(i,a)cin >> p[i];
rep(i,b)cin >> q[i];
rep(i,c)cin >> r[i];
int j,k,l;
j=0;k=0;l=0;
ll ans=0;
ll tmp;
int x_lim,y_lim;
x_lim=x;y_lim=y;
int flag=0;
rsort(p);rsort(q);rsort(r);
rep(i,x+y){
if(flag==0){
if(p[j]>=q[k]&&p[j]>=r[l]){
ans+=p[j];
++j;
if(j==x){
flag=1;
}
}else if(q[k]>=p[j]&&q[k]>=r[l]){
ans+=q[k];
++k;
if(k==y){
flag=2;
}
}else{
ans+=r[l];
l++;
if(l==c){
flag=3;
}
}
}else if(flag==1){
if(q[k]<r[l]){
ans+=r[l];
++l;
if(l==c){
flag=3;
}
}else{
ans+=q[k];
k++;
if(k==y){
flag=4;
}
}
}else if(flag==2){
if(p[j]<r[l]){
ans+=r[l];
++l;
if(l==c){
flag=3;
}
}else{
ans+=p[j];
j++;
if(j==x){
flag=4;
}
}
}else if(flag==3){
if(j<x||k<y){
if(p[j]<q[k]){
ans+=q[k];
++k;
}else{
ans+=p[j];
++j;
}
}else if(j<x){
ans+=p[j];
++j;
}else if(k<y){
ans+=q[k];
++k;
}
}
else if(flag==4){
ans+=r[l];
++l;
}
}
cout << ans << endl;
}
| 0
| 75,280,864
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define FOR(i,a,b) for(int i=(a); i<=(b); i++)
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define chmin(a,b) if((a)>(b)) (a)=(b);
#define chmax(a,b) if((a)<(b)) (a)=(b);
#define vi vector<int>
#define pii pair<int,int>
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define pb push_back
#define pf push_front
int gcd(int a,int b){
while(min(a,b)>0){if(a<b)swap(a,b);a%=b;}return max(a,b);
}
int dx[]={1,0,-1,0,1,-1,-1,1};
int dy[]={0,1,0,-1,1,1,-1,-1};
const int MOD = 1e9+7;
const long long INF = 1e18+10;
signed main(){
int n,m;
cin>>n>>m;
string a[50],b[50];
rep(i,n)cin>>a[i];
rep(i,m)cin>>b[i];
rep(i,n-m+1){
rep(j,n-m+1){
bool ok=1;
rep(k,m)rep(l,m){
if(a[i+k][j+l]!=b[k][l]) ok=0;
}
if(ok){
cout<<"Yes"<<endl;
return 0;
}
}
}
cout<<"No"<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<int, int> P;
const int MAX = 1e5 + 5;
const int INF = 1001001001;
const int MOD = 1e9 + 7;
int main(){
int N, K;
cin >> N >> K;
vector<int> A(N);
rep(i, N) cin >> A[i];
vector<ll> sum(N + 1);
rep(i, N) sum[i + 1] = sum[i] + A[i];
vector<ll> B;
rep(i, N + 1) {
rep(j, i) {
B.push_back(sum[i] - sum[j]);
}
}
sort(B.begin(), B.end(), greater<int>());
ll ans = 0;
int M = B.size();
vector<bool> available(M, true);
for (int i = 60; i >= 0; --i) {
int cnt = 0;
rep(j, M) if (available[j] && B[j] >> i & 1) cnt++;
if (K <= cnt) {
ans += 1L << i;
rep(j, M) {
if (!(B[j] >> i & 1)) available[j] = false;
}
}
}
cout << ans << endl;
}
| 0
| 49,319,437
|
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main(){
string s, str1, str2;
int maxn = 0, maxl = 0;
map<string, int> mp;
while(cin >> s){
mp[s]++;
if(mp[s] > maxn){maxn = mp[s];str1 = s;}
int si1 = s.size();int si2 = str2.size();
if(si1 > si2){str2 = s;}
}
cout << str1 << " " << str2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll a[10000000];
int main() {
ll i, j, k, l, test, n;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
a[i] -= (i + 1);
}
ll sum = 0;
sort(a, a + n);
for (i = 0; i < n; i++) {
sum += abs(a[i] - a[n / 2]);
}
cout << sum;
}
| 0
| 40,441,387
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define req(i,n) for(int i = 1;i <=n;i++)
#define pai 3.14159265358979323846
const int INF = 1001001001;
typedef long long ll;
int A[3][3], N;
bool punched[3][3];
bool ok[3][3];
using Graph = vector<vector<int>>;
vector<vector<int>> field;
vector<bool> seen;
const int MOD = 1000000007;
typedef pair<int,int> P;
int gcd(int a,int b){
if (a%b == 0){
return b;
}
else{
return gcd(b,a%b);
}
}
int lcm(int a,int b){
return a /gcd(a,b) * b;
}
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long 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 binary(int bina){
int ans = 0;
for (int i = 0; bina>0 ; i++)
{
ans = ans+(bina%2)*pow(10,i);
bina = bina/2;
}
return ans;
}
int main() {
int k,x;
cin >> k >> x;
if (500*k >= x) cout << "Yes" << endl;
else cout << "No" << endl;
}
|
#include <bits/stdc++.h>
#define INF 1e18
#define int long long
#define Rep(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) Rep(i, 0, n)
#define all(a) (a).begin(), (a).end()
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> PP;
const int mod = 1000000007;
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int k = -1;
for (int i = 1; i * (i - 1) / 2 <= n; i++)
{
if (i * (i - 1) / 2 == n)
k = i;
}
if (k == -1)
{
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
cout << k << endl;
vector<vector<int>> s(k);
int num = 1;
for (int i = 0; i < k; i++)
{
for (int j = i + 1; j < k; j++)
{
s[i].push_back(num);
s[j].push_back(num);
num++;
}
}
rep(i, k)
{
cout << s[i].size() << " ";
rep(j, s[i].size()) cout << s[i][j] << " ";
cout << endl;
}
}
| 0
| 9,606,752
|
#include <bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int x, n, ans = 0, best = 1e9;
cin >> x >> n;
vector<bool> vis(101);
for (int i = 0; i < n; ++i){
int foo;
cin >> foo;
vis[foo] = 1;
}
for (int i = 0; i <= 101; ++i){
if (!vis[i] && abs(i - x) < best){
best = abs(i - x);
ans = i;
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> vec(N);
rep(i, N) vec.at(i) = i + 1;
for (int i = 0; i < K; i++) {
int d;
cin >> d;
for (int j = 0; j < d; j++) {
int x;
cin >> x;
rep(i, N) {
if (x == vec.at(i)) {
vec.at(i) = 0;
}
}
}
}
int ans = 0;
rep(i, N) {
if (vec.at(i) != 0) ans++;
}
cout << ans << endl;
}
| 0
| 9,095,487
|
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
int left = 0;
int right = n - 1;
int sum = 0;
while(1) {
int lCount = left;
int rCount = right;
while(left < n && s[left] == 'x')left++;
while(right >= 0 && s[right] == 'x')right--;
if(s[left] != s[right]) {
cout << -1 << endl;
return 0;
}
sum += abs((left - lCount) - (rCount - right));
left++;
right--;
if(left >= right)
break;
}
cout << sum << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main(){
string s;cin >> s;
ll bc=0,res=0;
rep(i,s.size()){
if(s[i]=='B')bc++;
else res+=bc;
}
cout << res <<endl;
}
| 0
| 61,096,312
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string S, T;
cin >> S >> T;
int a = 0;
for (int i = 0; i < S.size() - T.size() + 1; i++) {
int count = 0;
for (int j = 0; j < T.size(); j++) {
if (T.at(j) == S.at(j + i)) {
count++;
}
if (j == T.size() - 1) {
if (a <= count) {
a = count;
}
}
}
}cout << T.size() - a;
}
|
#include <stdio.h>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <iterator>
#include <assert.h>
#pragma warning(disable:4996)
typedef long long ll;
#define MIN(a, b) ((a)>(b)? (b): (a))
#define MAX(a, b) ((a)<(b)? (b): (a))
#define LINF 9223300000000000000
#define INF 2140000000
const long long MOD = 1000000007;
using namespace std;
int main(int argc, char* argv[])
{
int n;
scanf("%d", &n);
vector<pair<double, pair<int,int> > > z;
int i,j;
for(i=0; i<n; i++) {
int x,y;
scanf("%d%d", &x, &y);
double t=0;
if(x!=0 || y!=0) {
t = atan2((double)y, (double)x);
}
z.push_back(make_pair(t, make_pair(x,y)));
}
sort(z.begin(), z.end());
int k;
double sx0=0, sy0=0;
for(k=0; k<n; k++) {
sx0+=z[k].second.first;
sy0+=z[k].second.second;
}
double maxval=0;
for(i=0; i<n; i++) {
for(j=i; j<n; j++) {
double sx=0, sy=0;
for(k=0; k<n; k++) {
if(k>=i && k<=j) {
sx+=z[k].second.first;
sy+=z[k].second.second;
}
}
double val=(sx*sx+sy*sy);
maxval=MAX(maxval,val);
sx=sx0-sx; sy=sy0-sy;
val=(sx*sx+sy*sy);
maxval=MAX(maxval,val);
}
}
maxval=sqrt(maxval);
printf("%.10lf\n", maxval);
return 0;
}
| 0
| 6,090,445
|
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<n;++i)
#define all_map(itr,mp) for(auto itr=mp.begin();itr!=mp.end();itr++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll LINF = 1LL << 62;
const int INF = 1e9 + 7;
int main(){
ll l, r;
cin >> l >> r;
if(r-l >= 2018){
cout << 0 << endl;
}
else {
ll ans = 2019;
ll low = min(l%2019, r%2019);
ll high = max(l%2019, r%2019);
for(ll i = low; i < high; ++i){
for(ll j = i+1; j <= high; ++j){
ans = min(ans, (i*j)%2019);
}
}
cout << ans << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const long long int m=pow(10,9)+7;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,ans=0;
cin>>n;
int a[n+1],b[n];
for(int i=0;i<n+1;i++)
cin>>a[i];
for(int i=0;i<n;i++)
cin>>b[i];
for(int i=0;i<n;i++)
{
if(a[i]<b[i])
{
ans+=a[i];
b[i]-=a[i];
a[i]=0;
}
else
{
ans+=b[i];
a[i]-=b[i];
b[i]=0;
}
if(a[i+1]<b[i])
{
ans+=a[i+1];
b[i]-=a[i+1];
a[i+1]=0;
}
else
{
ans+=b[i];
a[i+1]-=b[i];
b[i]=0;
}
}
cout<<ans<<endl;
return 0;
}
| 0
| 51,444,561
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
cout << (double)a / b << endl;
}
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
ll gcd(ll a, ll b)
{
if (a % b == 0)
{
return(b);
}
else
{
return(gcd(b, a % b));
}
}
ll lcm(ll a, ll b)
{
return a * b / gcd(a, b);
}
ll box(double a)
{
ll b = a;
return b;
}
ll fff(double a)
{
ll b = a + 0.5;
return b;
}
ll sum(ll n) {
if (n == 0) {
return 0;
}
int s = sum(n - 1);
return s + n;
}
bool prime(ll num)
{
if (num < 2) return false;
else if (num == 2) return true;
else if (num % 2 == 0) return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
{
return false;
}
}
return true;
}
int main() {
ll n, m;
cin >> n >> m;
vector < pair < ll, ll>> data(n);
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
data[i] = make_pair(a, b);
}
sort(data.begin(), data.end());
ll ans;
ans = 0;
for (int i = 0; i < n; i++) {
if (m > data[i].second) {
m -= data[i].second;
ans += data[i].first * data[i].second;
}
else {
ans += data[i].first * m;
m = 0;
}
if (m == 0) {
break;
}
}
cout << ans << endl;
}
| 0
| 24,629,371
|
#include<bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; i++)
#define repo(i, n) for(int i=1; i<=n; i++)
#define ssort(a) sort(a.begin(), a.end())
#define INF 1001001001
#define INFll 100100100100100
#define PrintVec(x) for (auto elementPrintVec: x) { cout << elementPrintVec << " "; } cout << endl;
using namespace std;
using ull = unsigned long long;
using ll = long long;
using P = pair<int, int>;
const int mod = 1000000007;
ll f(ll n){
if(n<=0)return 0;
ll num1=n/2;
ll num2=n%2;
if(num2==0){
return (num1%2)^n;
} else {
return (num1+1)%2;
}
}
int main(){
ll a, b;
cin >> a >> b;
ll ans=f(a-1)^f(b);
cout << ans << endl;
return 0;
}
|
#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
#define endl "\n"
#define sz(x) ((ll)(x).size())
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define prt(x) cout << (x)
#define prtl(x) cout << (x) << endl
#define rep(i,a,b) for(ll i=a; i<b; i++)
#define rrep(i,a,b) for(ll i=a; i>b; i--)
#define mp(a, b) make_pair(a, b)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define debug(v) cout << #v<< ": " << v <<endl;
using namespace std;
using vi = vector<int>;
using vll = vector<long long int>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long int>>;
using vvc = vector<vector<char>>;
using ll = long long int;
using P = pair<long long int, long long int>;
using Map = map<long long int, long long int>;
ll INF = 1LL<<60;
ll M = 1000000007;
class Radix {
private:
const char* s;
int a[128];
public:
Radix(const char* s = "0123456789ABCDEF") : s(s) {
int i;
for(i = 0; s[i]; ++i)
a[(int)s[i]] = i;
}
std::string to(long long p, int q) {
int i;
if(!p)
return "0";
char t[64] = { };
for(i = 62; p; --i) {
t[i] = s[p % q];
p /= q;
}
return std::string(t + i + 1);
}
std::string to(const std::string& t, int p, int q) {
return to(to(t, p), q);
}
long long to(const std::string& t, int p) {
int i;
long long sm = a[(int)t[0]];
for(i = 1; i < (int)t.length(); ++i)
sm = sm * p + a[(int)t[i]];
return sm;
}
};
string bist(ll n, ll dig){
Radix r;
string p = r.to(n, 2);
string q = "";
if(p.size() < dig){
for(int i=0; i<dig - p.size(); i++){
q += '0';
}
p = q + p;
}
return p;
}
int main(){
ll n; string s; cin >> n >> s;
map<char, ll> m;
rep(i, 0, n){
m[s[i]]++;
}
ll f = sz(m);
ll ans = 1;
for(auto x: m){
ans *= x.second+1;
ans %= M;
}
prtl(ans - 1);
}
| 0
| 27,803,139
|
#include<iostream>
#include<cstdio>
#include <stdio.h>
#include<algorithm>
#include<cstring>
#include <string>
#include<cmath>
#include<cstdlib>
#include<queue>
#include<map>
#include<vector>
#include<bits/stdc++.h>
#include <set>
#define ll long long
#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#define inf 0x3f3f3f
#define pi 3.1415926535898
using namespace std;
int main()
{
int h,w,a,b;
cin>>h>>w>>a>>b;
for(int i=1;i<=b;i++)
{
for(int j=1;j<=w;j++)
{
if(j<=a)
{
cout<<1;
}
else
{
cout<<0;
}
}
cout<<endl;
}
for(int i=b+1;i<=h;i++)
{
for(int j=1;j<=w;j++)
{
if(j>a)
{
cout<<1;
}
else
{
cout<<0;
}
}
cout<<endl;
}
return 0;
}
|
#include <iostream>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const string YES = "Yes";
const string NO = "No";
void solve(std::string S, std::string T){
bool ans = false;
REP(i, S.size()) {
string s1 = S.substr(0, i);
string s2 = S.substr(i);
if (s2 + s1 == T) {
ans = true;
break ;
}
}
if (ans) cout << YES << '\n';
else cout << NO << '\n';
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
std::string S;
std::cin >> S;
std::string T;
std::cin >> T;
solve(S, T);
return 0;
}
| 0
| 40,041,949
|
#include <bits/stdc++.h>
#include <iostream>
#define ll long long
#define map unordered_map
#define set unordered_set
#define pll pair<ll, ll>
#define vll vector<ll>
using namespace std;
const ll MOD = 1000000007LL;
const ll INF = (1LL << 60LL);
int main() {
string str;
cin >> str;
ll ans = INF;
for (ll i = 0; i < str.length() - 2; i++) {
string s = str.substr(i, 3);
ll v = stoll(s);
v = abs(753 - v);
ans = min(ans, v);
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define lli long long int
# define rep(i,n) for(int i=0;i<n;i++)
void solve(){
int n;
cin>>n;
int a[n];
rep(i,n)
cin>>a[i];
lli sum=0;
for(int i=1;i<n;i++){
if(a[i-1]>a[i]){
sum+=(a[i-1]-a[i]);
a[i]=a[i-1];
}
}
cout<<sum<<endl;
}
int main()
{
int t;
t=1;
while(t--){
solve();
}
}
| 0
| 34,116,082
|
#include <iostream>
using namespace std;
int main()
{
int x, y;
cin >> x >> y;
if(x % y == 0)
cout << -1;
else
cout << x;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <functional>
#include <ctime>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll ll_gcd(ll a, ll b) {
if (a < b) return ll_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
struct UnionFind {
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
vector<int> tpsort(vector<vector<int>>& G) {
int V = G.size();
vector<int> sorted_vertices;
queue<int> que;
vector<int> indegree(V);
for (int i = 0; i < V; i++) {
for (int j = 0; j < G[i].size(); j++) {
indegree[G[i][j]]++;
}
}
for (int i = 0; i < V; i++) {
if (indegree[i] == 0) {
que.push(i);
}
}
while (que.empty() == false) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
indegree[u] -= 1;
if (indegree[u] == 0) que.push(u);
}
sorted_vertices.push_back(v);
}
return sorted_vertices;
}
struct Point
{
double x;
double y;
};
struct LineSegment
{
Point start;
Point end;
};
double tenkyori(const LineSegment& line, const Point& point)
{
double x0 = point.x, y0 = point.y;
double x1 = line.start.x, y1 = line.start.y;
double x2 = line.end.x, y2 = line.end.y;
double a = x2 - x1;
double b = y2 - y1;
double a2 = a * a;
double b2 = b * b;
double r2 = a2 + b2;
double tt = -(a * (x1 - x0) + b * (y1 - y0));
if (tt < 0)
return sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
else if (tt > r2)
return sqrt((x2 - x0) * (x2 - x0) + (y2 - y0) * (y2 - y0));
double f1 = a * (y1 - y0) - b * (x1 - x0);
return sqrt((f1 * f1) / r2);
}
int main() {
ll n, k;
cin >> n >> k;
vector<pair<ll, ll>>z(n);
vector<ll> x(n);
vector<ll> y(n);
for (int i = 0; i < n; i++) {
cin >> z[i].first >> z[i].second;
x[i] = z[i].first;
y[i] = z[i].second;
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
ll ans = 4023456789123456789;
for (int i = 0; i < n; i++) {
for (int j = i+1; j < n; j++) {
ll a = 0;
ll b = 1;
while (b < n) {
ll mn = 0;
for (int k = 0; k < n; k++) {
if (z[k].first >= x[i] && z[k].first <= x[j] && z[k].second >= y[a] && z[k].second <= y[b])mn++;
}
if (k <= mn) {
ans = min(ans, (x[j] - x[i]) * (y[b] - y[a]));
a++;
}
else {
b++;
}
}
}
}
cout << ans << endl;
}
| 0
| 60,673,503
|
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <math.h>
#include <iostream>
#include <random>
#include<map>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <cassert>
#include<fstream>
#include <unordered_map>
#include <cstdlib>
using namespace std;
#define Ma_PI 3.141592653589793
#define eps 0.00000001
#define LONG_INF 2000000000000000000
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define REP(i,n) for(long long i = 0;i < n;++i)
#define seg_size 524288
int dp[67108864] = {};
int main() {
for (int i = 1;i < 67108864;++i) {
dp[i] = 300000;
}
string s;
cin >> s;
long long hashing = 0;
int ans = 300000;
for (int i = 0;i < s.length();++i) {
hashing ^= (1 << (s[i] - 'a'));
for (int q = 0;q < 27;++q) {
long long mew = (1 << (q-1));
if (q == 0) {
mew = 0;
}
if (i == s.length() - 1) {
ans = min(ans, dp[mew^hashing] + 1);
}
dp[hashing] = min(dp[(mew ^ hashing)]+1, dp[hashing]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+100;
bool check(string s)
{
if(s[0]==s[1]||s[1]==s[2]||s[0]==s[2]) return true;
return false;
}
int main()
{
ios::sync_with_stdio(0);cin.tie(0);
string s;cin>>s;
if(s.size()<2) cout<<-1<<" "<<-1;
else if(s.size()==2){
if(s[0]==s[1]) cout<<1<<" "<<2;
else cout<<-1<<" "<<-1;
}
else{
for(int i=0;i<s.size()-2;i++){
string ss=s.substr(i,3);
if(check(ss)){
cout<<i+1<<" "<<i+1+2;
return 0;
}
}
cout<<-1<<" "<<-1;
}
return 0;
}
| 0
| 47,440,269
|
#include <bits/stdc++.h>
#define mp make_pair
#define eb emplace_back
#define ff first
#define ss second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#ifdef ONPC
mt19937 rnd(228);
#else
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#endif
const int MAXN = 100;
const int INF = 1e9;
void solve(){
int n, m;
cin >> n >> m;
vector<pair<int, int>> a(n + m);
for (int i = 0; i < n; i++) {
cin >> a[i].ff;
a[i].ss = 1;
}
for (int i = 0; i < m; i++) {
cin >> a[n+i].ff;
a[n+i].ss = 2;
}
sort(a.begin(), a.end());
int cur = 0;
ll ans = 0;
n++, m++;
while (cur < (int)a.size()){
if (a[cur].ss == 1){
ans += (ll)a[cur].ff * (ll)m;
n--;
} else {
ans += (ll)a[cur].ff * (ll)n;
m--;
}
cur++;
}
cout << ans << '\n';
}
signed main()
{
#ifdef FILEIO
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#define TASK "Yet Another Palindrome Partitioning"
using namespace std;
const int maxn = 2e5 + 1;
string s;
int n,f[(1<<26)],x;
void OpenFile()
{
}
void Enter()
{
cin >> s;
}
void Init()
{
}
void Solve()
{
fill(f+1,f+(1<<26),s.size());
for (auto c : s) {
x ^= 1 << (c - 'a');
for (int i=0;i<26;++i)
f[x] = min(f[x],f[x^(1<<i)]+1);
}
if (f[x] == 0) f[x] = 1;
cout << f[x];
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Enter();
Init();
Solve();
}
| 0
| 70,384,664
|
#include"bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using pi = pair<int, int>;
const ll INF = 1LL << 60;
int main() {
string s;
ll sum=0, wcnt = 0;
cin >> s;
map<char, int>mp;
rep(i, s.size()) {
if (s[i] == 'W') {
sum += (ll)i - wcnt;
wcnt++;
}
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int main(){
int n; cin>>n;
vector<int> p(n,0),a(n,0),b(n,0);
rep(i,n){
cin>>p[i]; p[i]--;
}
rep(i,n) a[i]=i*20000+1;
for(int i=n-1;i>=0;i--) b[i]=(n-i)*20000+a.back();
rep(i,n) b[p[i]]+=i;
rep(i,n){
cout<<a[i];
if(i<n-1) cout<<" ";
}
cout<<endl;
rep(i,n){
cout<<b[i];
if(i<n-1) cout<<" ";
}
cout<<endl;
}
| 0
| 74,528,209
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0;i<n;i++)
#define erep(i,n) for(int i = 0;i<=n;i++)
#define rep1(i,n) for(int i = 1;i<n;i++)
typedef long long ll;
#define vint vector<int>
#define vstring vector<string>
#define vll vector<ll>
#define vbool vector<bool>
#define INF 100000000
ll gcm(ll a,ll b);
int main(){
int n;
cin >> n;
vint A(n);
rep(i,n) cin >> A[i];
vint dist(n);
rep(i,n) dist[i] = A[i]-(i+1);
sort(dist.begin(),dist.end());
ll judge = dist[n/2];
ll ans = 0;
rep(i,n) ans += (ll)abs((dist[i] - judge));
cout << ans << endl;
}
|
#include<iostream>
int main(){
int i,n,m;
for(i=0;i<3000;i++){
std::cin>> n>> m;
if(n==0&&m==0) break;
if(n>=m){
std::cout<< m<< " "<< n<< std::endl;
}else{
std::cout<< n<< " "<< m<< std::endl;
}
}
return 0;
}
| 0
| 33,670,767
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
int N, Dist[int(1e5+5)];
vector <int> Graph[int(1e5+5)];
ll DP[int(1e5+5)][2];
bool checked[int(1e5+5)][2];
ll Solve(int num, int color){
if (checked[num][color]) return DP[num][color];
checked[num][color] = true;
ll ans = 1;
for (int next : Graph[num]){
if (Dist[num] > Dist[next]) continue;
if (color == 0){
ans *= (Solve(next, 0) + Solve(next, 1)) % MOD;
}else{
ans *= Solve(next, 0);
}
ans %= MOD;
}
return DP[num][color] = ans;
}
int main(){
cin >> N;
fill(Dist, Dist + N + 1, -1);
for (int i = 0; i < N - 1; i++){
int X, Y; cin >> X >> Y;
Graph[X].push_back(Y);
Graph[Y].push_back(X);
}
queue <int> que; que.push(1);
Dist[1] = 0;
while (!que.empty()){
int Q = que.front(); que.pop();
for (int next : Graph[Q]){
if (Dist[next] != -1) continue;
que.push(next);
Dist[next] = Dist[Q] + 1;
}
}
cout << (Solve(1, 0) + Solve(1, 1)) % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
using Graph = vector<vector<int>>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, k, n) for (int i = k; i < (int)(n); i++)
#define RRep(i, k, n) for (int i = k; i > (int)(n); i--)
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define ALL(a) (a).begin(),(a).end()
#define rALL(a) (a).rbegin(),(a).rend()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T> void PrintVector(const vector<T> &vec) {for (auto val : vec) cout << val << " "; cout << endl;}
const long long INF = 1LL << 60;
const int MOD = 1000000007;
const double PI = acos(-1);
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main()
{
int n; cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int ans = 0;
while(1)
{
if (*max_element(ALL(h)) == 0) break;
int i = 0;
while(i < n)
{
if (h[i] == 0) i++;
else
{
ans++;
while(i < n && h[i] > 0)
{
h[i]--;
i++;
}
}
}
}
cout << ans << endl;
}
| 0
| 95,111,017
|
#include <bits/stdc++.h>
#include <algorithm>
#include <math.h>
using namespace std;
int CalcSumOfDigit(int n);
int getDigit(int n);
string upper(string str);
string lower(string str);
class Combi
{
public:
Combi();
long long Combination(long long n, long long k);
private:
vector<vector<long long>> memo;
long long n_num;
long long k_num;
void Resize(long long n, long long k);
};
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define sz(a) int((a).size())
#define rep(i,n) for(int(i)=0;(i)<(n);(i)++)
#define repe(i,n) for(int(i)=0;(i)<=(n);(i)++)
#define vsort(v) sort((v).begin(),(v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a,b) __gcd((a),(b))
#define LCM(a,b) (a)/GCD((a),(b))*(b)
#define kiriage(a,b) ((a)+(b)-1)/(b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long> vll;
int main() {
ll x,y;
cin >> x >> y;
ll ans = 0;
if(x * y > 0)
{
ans = abs(y-x) + ( x < y ? 0 : 2);
}
else if(x == 0)
{
ans = abs(y) + ( y < 0 ? 1 : 0);
}
else if(y == 0)
{
ans = abs(x) + ( x < 0 ? 0 : 1);
}
else
{
ans = abs( y + x ) + 1;
}
cout << ans << endl;
return 0;
}
int getDigit(int n)
{
int i = 1;
while(1)
{
n = n / 10;
if(n == 1)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n)
{
int s = 0;
while(n)
{
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str)
{
for(auto itr = str.begin();itr != str.end() ; itr++)
{
if(97 <= *itr && *itr <= 122)
{
*itr = *itr - 32;
}
}
return str;
}
string lower(string str)
{
for(auto itr = str.begin();itr != str.end() ; itr++)
{
if(65 <= *itr && *itr <= 90)
{
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi(){
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k)
{
Resize(n,k);
ll ret;
if(memo[n][k] != 0)
{
ret = memo[n][k];
}
else if(n == k || k == 0)
{
memo[n][k] = 1;
ret = 1;
}
else
{
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
void Combi::Resize(ll n, ll k)
{
if(n_num <= n || k_num <= k)
{
n_num = (n + 1) * 2;
k_num = (k + 1) * 2;
memo.resize(n_num);
for(auto itr = memo.begin(); itr != memo.end(); ++itr)
{
itr->resize(k_num);
}
}
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<cmath>
#include<cstdio>
#include<queue>
#include<deque>
#include<map>
#include<stack>
#include<set>
#include<utility>
using namespace std;
typedef pair<int,int> ii;
typedef long long ll;
typedef pair<ll,ii> P;
typedef unsigned long long int ull;
const int MOD=1e9+7;
int dy[]={1,0,-1,0};
int dx[]={0,1,0,-1};
const int MAXN=100000;
const int MAXE=100000;
const int MAXV=10000;
const ll INF=2e9;
int main(){
int n;cin>>n;
int dp[n+1];
for(int i=0;i<=n;i++) dp[i]=INF;
dp[0]=0;
for(int i=0;i<=n;i++){
for(int j=1;i+j<=n;j*=6){
dp[i+j]=min(dp[i+j],dp[i]+1);
}
for(int j=1;i+j<=n;j*=9){
dp[i+j]=min(dp[i+j],dp[i]+1);
}
}
cout<<dp[n]<<endl;
return 0;
}
| 0
| 95,177,857
|
#include<bits/stdc++.h>
#include<algorithm>
#include<math.h>
#include<string>
#include<iostream>
#include<vector>
#include<cstdlib>
#include<stdio.h>
#include<cmath>
#include<limits>
#include<iomanip>
#include<cstdlib>
#include<ctime>
#include<random>
using namespace std;
template <class T> using V = vector<T>;
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 long long INF = 1LL << 60;
using ll = long long;
using db = long double;
using st = string;
using ch = char;
using bl = bool;
using vll = V<ll>;
using vpll =V<pair<ll,ll>>;
using vst = V<st>;
using vdb = V<db>;
using vch = V<ch>;
using vbl = V<bl>;
using graph = V<V<int>>;
using pq = priority_queue<ll>;
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define rFOR(i,a,b) for(ll i=(a);i>=(b);i--)
#define oFOR(i,a,b) for(ll i=(a);i<(b);i+=2)
#define bgn begin()
#define en end()
#define SORT(a) sort((a).bgn,(a).en)
#define REV(a) reverse((a).bgn,(a).en)
#define M(a,b) max(a,b)
#define rM(a,b) min(a,b)
#define fi first
#define se second
#define sz size()
#define gcd(a,b) __gcd(a,b)
#define co(a) cout<<a<<endl;
#define pb(a) push_back(a);
#define ALL(a) (a).begin(),(a).end()
ll Sum(ll n) {
ll m=0;
while(n){
m+=n%10;
n/=10;
}
return m;
}
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void Comuse() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
#define comuse Comuse()
ll combi(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll perm(int n,int k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * (finv[k] % MOD) % MOD;
}
ll modpow(ll a,ll n,ll mod){
ll ans=1;
while(n>0){
if(n&1){
ans=ans*a%mod;
}
a=a*a%mod;
n>>=1;
}
return ans;
}
ll modinv(ll a, ll mod) {
return modpow(a, mod - 2, mod);
}
ll modcombi(int n,int k,int mod){
ll ans=1;
for(ll i=n;i>n-k;i--){
ans*=i;
ans%=mod;
}
for(ll i=1;i<=k;i++){
ans*=modinv(i,mod);
ans%=mod;
}
return ans;
}
ll lcm(ll a,ll b){
ll n;
n=a/gcd(a,b)*b;
return n;
}
vll div(ll n){
vll ret;
for(ll i=1;i*i<=n;i++){
if(n%i==0){
ret.push_back(i);
if(i*i!=n){
ret.push_back(n/i);
}
}
}
SORT(ret);
return (ret);
}
vector<bool> isprime(MAX+100,true);
void primeuse(){
isprime[0]=false;
isprime[1]=false;
for(int i=2;i<MAX+50;i++){
int up=sqrt(i)+1;
for(int j=2;j<up;j++){
if(i%j==0){
isprime[i]=false;
}
}
}
}
void Solve();
const int MAX_N = 131072;
int NN;
int seg[MAX_N*2-1];
void seguse(){
for(int i=0;i<2*NN-1;i++){
seg[i]=INT_MAX;
}
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<setprecision(20)<<fixed;
Solve();
}
void Solve(){
ll n;
cin>>n;
string s;
cin>>s;
ll ans=1;
vll A(26);
FOR(i,0,n){
ll a=s[i]-'a';
A[a]++;
}
FOR(i,0,26){
ans*=(A[i]+1);
ans%=MOD;
}
cout<<ans-1<<"\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
void solve(long long N, long long Z, long long W, std::vector<long long> a){
if(N==1){
cout << abs(W-a[N-1]) << endl;
return;
}
cout << max(abs(a[N-1]-a[N-2]),abs(W-a[N-1])) << endl;
}
int main(){
long long N;
scanf("%lld",&N);
long long Z;
scanf("%lld",&Z);
long long W;
scanf("%lld",&W);
std::vector<long long> a(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&a[i]);
}
solve(N, Z, W, std::move(a));
return 0;
}
| 0
| 68,823,416
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
long long N, L, T;
cin >> N >> L >> T;
vector<long long> X;
int c = 0;
for(int i = 0; i < N; ++i){
long long x, w, x_;
cin >> x >> w;
if(w == 1) x_ = x+T;
else x_ = x-T;
c += x_/L;
x_ %= L;
if(x_ < 0) --c, x_ += L;
X.push_back((L+x_%L)%L);
}
sort(X.begin(), X.end());
for(int i = 0; i < N; ++i){
cout << X[(i+N+c%N)%N] << endl;
}
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i,n) for(int i=0, i##_len=(int)(n); i<i##_len; i++)
#define reps(i,n) for(int i=1 , i##_len=(int)(n);i<=i##_len;i++)
#define rrep(i,n) for(int i=((int)(n)-1);i>=0;i--)
#define rreps(i,n) for(int i=((int)(n));i>0;i--)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define solve(a) ((a)?"Yes":"No")
typedef vector<long long> V;
typedef vector<V> VV;
typedef pair<long long , long long> P;
typedef vector<P> VP;
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 long long INFLL = 1LL<<62;
const int INF = 1<<30;
const double PI=acos(-1);
int trans(char s){
return (s-'0');
}
int main(){
int n;
int ans=0;
vector<pair<string,string>>data;
vector<int>table;
pair<int,int> hash;
while(1){
cin >>n;
data.clear();
table.clear();
if(n==0){
break;
}
ans=0;
table.resize(86410);
table.assign(86410,0);
data.resize(n);
rep(i,n){
hash=mp(0,0);
cin>>data[i].F>>data[i].S;
hash.F+=trans(data[i].F[7]);
hash.F += 10*trans(data[i].F[6]);
hash.F += 60*trans(data[i].F[4]);
hash.F += 600*trans(data[i].F[3]);
hash.F += 3600*trans(data[i].F[1]);
hash.F += 36000*trans(data[i].F[0]);
hash.S += trans(data[i].S[7]);
hash.S += 10 * trans(data[i].S[6]);
hash.S += 60 * trans(data[i].S[4]);
hash.S += 600 * trans(data[i].S[3]);
hash.S += 3600 * trans(data[i].S[1]);
hash.S += 36000 * trans(data[i].S[0]);
table[hash.F]++;
table[hash.S]--;
}
rep(i,86402){
table[i+1]+=table[i];
chmax(ans,table[i]);
}
cout<<ans<<endl;
}
}
| 0
| 76,117,174
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using namespace std;
using P = pair<int, int>;
using ll = long long;
int main()
{
string s, t;
cin >> s >> t;
string ans = "";
rep(i, t.size()) {
ans += s[i];
ans += t[i];
}
if(s.size() > t.size()) ans+= s[s.size() - 1];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 26];
int main()
{
int bit = 0;
string S;
fill_n(dp, 1 << 26, 1 << 27);
dp[0] = 0;
cin >> S;
for(int i = 0; i < S.size(); i++) {
bit ^= (1 << (S[i] - 'a'));
for(int j = 0; j < 26; j++) {
dp[bit] = min(dp[bit], dp[bit ^ (1 << j)] + 1);
}
}
cout << dp[bit] + (dp[bit] == 0) << endl;
return (0);
}
| 0
| 11,307,577
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.