code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 2
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
vector<l_l> D;
ll SIZE[100500];
map<ll, ll> mp;
ll dist[100050];
vector<ll> pathes[100050];
ll ONED;
void dfs(int now, int from) {
for(auto to : pathes[now]) {
if(to == from) continue;
dist[to] = dist[now] + 1;
dfs(to, now);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
D.resize(N);
for(int i = 1; i <= N; i++) {
cin >> D[i-1].first;
D[i-1].second = i;
SIZE[i] = 1;
mp[D[i-1].first] = i;
}
ONED = D[0].first;
sort(D.begin(), D.end(), greater<l_l>());
vector<l_l> ans;
for(int i = 0; i < N - 1; i++) {
int index = D[i].second;
ll val = D[i].first;
val += SIZE[index] - (N - SIZE[index]);
if(SIZE[index] * 2 >= N) {
cout << -1 << endl;
return 0;
}
if(mp[val] == 0) {
cout << -1 << endl;
return 0;
}
SIZE[mp[val]] += SIZE[index];
ans.push_back({index, mp[val]});
pathes[index].push_back(mp[val]);
pathes[mp[val]].push_back(index);
}
dfs(1, -1);
ll distsum = 0;
for(int i = 1; i <= N; i++) distsum += dist[i];
if(distsum != ONED) {
cout << -1 << endl;
return 0;
}
for(auto e : ans) cout << e.first << " " << e.second << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
int n,k;
cin >> n>>k;
vector<int> ni(21);
ni.at(0)=1;
int x=1;
for(int i=1;i<21;i++){
x=x*2;
ni.at(i)=x;
}
double ans=0;
for(int i=1;i<=n;i++){
double p=(double)k/i;
double ke=1;
if(i>=k){
ans++;
continue;
}
for(int j=0;j<21;j++){
if(ni.at(j)>=p){
ans+=ke;
break;
}
ke/=2;
}
}
ans/=n;
printf("%.10lf\n",ans);
} | 0 | 38,759,576 |
#include<algorithm>
#include<bitset>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<iterator>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a,i,j,v) for(ll k=i;k<=j;k++){a[k]=v;}
ll gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
int main() {
int n; cin >> n;
ll t[101]; INITA(t, 0, 100, 0);
ll res = 1;
REP(i, n) {
cin >> t[i];
res = res / gcd(res, t[i]) * t[i];
}
cout << res << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
using i64 = long long int;
const int INF = 1e9;
int edit_distance(string s1, string s2) {
vector<vector<int>> dp(s1.size()+1, vector<int>(s2.size()+1, INF));
for(int i=0;i<=s1.size();++i)dp[i][0] = i;
for(int j=0;j<=s2.size();++j)dp[0][j] = j;
for(int i=1;i<=s1.size();++i){
for(int j=1;j<=s2.size();++j){
dp[i][j] = min({
dp[i-1][j] + 1,
dp[i][j-1] + 1,
dp[i-1][j-1] + !!(s1[i-1] != s2[j-1])
});
}
}
return dp[s1.size()][s2.size()];
}
int main(){
string s1, s2;
cin >> s1 >> s2;
cout << edit_distance(s1, s2) << endl;
return 0;
} | 0 | 83,976,834 |
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
#include<cmath>
#include<algorithm>
#include<ctime>
using namespace std;
typedef long long ll;
const int MAX=1e5+10;
const int mod=1e9+7;
const int inf=0x3f3f3f3f;
const int d[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
const string mode[4]={"dream","dreamer","erase","eraser"};
bool Match(const string&mo,const char* s,const int&k){
int l=mo.length();
for(int i=0;i<l;i++){
if(mo[i]!=s[i+k]) return false;
}
return true;
}
void DFS(const int&k,const char* s,bool &F){
if(k==strlen(s)){
F=true;
return;
}
for(int i=0;i<4;i++){
if(Match(mode[i],s,k)){
DFS(k+mode[i].length(),s,F);
if(F) return;
}
}
}
int main(){
char s[MAX];
while(~scanf("%s",s)){
bool F=false;
DFS(0,s,F);
if(F) puts("YES");
else puts("NO");
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
ll mm=1000000000;ll MM=mm+7;
#define rep(i, n) for(int i=0;i<n;i++)
int main(){
string s;
string target="keyence";
cin >>s;
int n=s.size();
bool a=false;
int cnnt=0;
if(s==target)a=true;
rep(i,n){
for(int j=i; j<n; j++){
string S="";
for(int k=0;k<n;k++){
if(i<=k && k<=j)continue;
else{
S.push_back(s.at(k));
}
}
if(S==target){
a=true;
break;
}
}
if(a)break;
}
if(a) cout <<"YES" << endl;
else cout << "NO" <<endl;
} | 0 | 44,205,968 |
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
ll const INF = 1LL << 60;
vector<ll> divisor(ll n) {
vector<ll> res;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i) res.push_back(n / i);
}
}
return res;
}
int main() {
ll N;
cin >> N;
auto divs = divisor(N);
ll ans = 0;
for (int i = 0; i < divs.size(); i++) {
ll x = N / divs[i] - 1;
if (x != 0 && N / x == N % x) ans += x;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll N, k = 0, a, n = 1;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a;
if (a == n) {
n++;
} else {
k++;
}
}
cout << (k == N ? -1 : k) << endl;
} | 0 | 27,088,334 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1000000000000
#define MOD 1000000007
int main(void){
ios::sync_with_stdio(false);
cin.tie(0);
cout<<fixed<<setprecision(15);
ll h,w;
cin>>h>>w;
if(h==1 || w==1){
cout<<1<<endl;
}else{
cout<<(h*w+1)/2<<endl;
}
return 0;
} | #include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <utility>
#include <tuple>
#include <algorithm>
#include <numeric>
#include <cstdio>
#include <cmath>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
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() {
int H, W;
cin >> H >> W;
string s;
rep(i, H) rep(j, W) {
cin >> s;
if (s == "snuke") {
cout << char('A'+j) << i+1 << endl;
return 0;
}
}
return 0;
} | 0 | 90,097,149 |
#include <bits/stdc++.h>
using namespace std;
typedef long long intl;
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin>>n;
vector <int> v(2*n);
for(int i=0;i<2*n;i++){
cin>>v[i];
}
sort(v.begin(),v.end());
int sum=0;
for(int i=0;i<n;i++){
sum+=v[i*2];
}
cout<<sum<<endl;
} | #include "bits/stdc++.h"
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define vi vector<int>
#define all(a) a.begin(),a.end()
typedef pair<int,int> P;
const long long mod=1000000007;
const long long inf=1ll<<61;
int a[100006],b[100006];
P ab[100006];
signed main(){
int n,m;cin>>n>>m;
rep(i,n){
cin>>a[i]>>b[i];
ab[i]=P(a[i],b[i]);
}
sort(ab,ab+n);
int ans=0,rs=0;
rep(i,n){
if(rs+ab[i].second<m){
ans+=ab[i].first*ab[i].second;
rs+=ab[i].second;
}
else{
ans+=ab[i].first*(m-rs);
break;
}
}
cout<<ans<<endl;
} | 0 | 66,062,716 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
int main()
{
int N, M, X, Y;
cin >> N >> M >> X >> Y;
int mx = -100;
rep(i, N)
{
int x;
cin >> x;
mx = std::max(mx, x);
}
int mn = 100;
rep(i, M)
{
int y;
cin >> y;
mn = std::min(mn, y);
}
if (mx >= mn || mx >= Y || mn <= X)
{
cout << "War" << endl;
}
else
{
cout << "No War" << endl;
}
return 0;
} | #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
ll N, K;
cin>>N>>K;
ll A[N+1];
A[0] = 0;
for(ll i=1;i<=N;++i) cin>>A[i];
for(ll i=1;i<=N;++i) A[i] += A[i-1];
vector<ll> arr;
for(ll i=0;i<=N;++i) {
for(ll j=i+1;j<=N;++j) {
arr.push_back(A[j]-A[i]);
}
}
vector<ll> newarr;
for(ll i=42;i>=0;--i) {
newarr.clear();
for(ll j=0;j<arr.size();++j) {
if((arr[j]&(1ull<<i))!=0) newarr.push_back(arr[j]);
}
if(newarr.size()>=K) arr = newarr;
}
ll ans = arr[0];
for(ll i=1;i<K;++i) ans &= arr[i];
cout<<ans<<endl;
} | 0 | 18,734,475 |
#include <iostream>
using namespace std;
int x, y, smaller, bigger;
int main(){
while (true){
cin >> x >> y;
if (x == 0 & y == 0){
break;
}
if (x > y){
bigger = x;
smaller = y;
}
else{
bigger = y;
smaller = x;
}
cout << smaller << " " << bigger << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
#ifdef __LOCAL
#define debug(x) cerr << __LINE__ << ": " << #x << " = " << x << endl
#define debugArray(x, n) \
cerr << __LINE__ << ": " << #x << " = {"; \
for (long long hoge = 0; (hoge) < (n); ++(hoge)) \
cerr << ((hoge) ? "," : "") << x[hoge]; \
cerr << "}" << endl
#else
#define debug(x) (void(0))
#define debugArray(x, n) (void(0))
#endif
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int K;
string S;
cin >> K >> S;
if (K < S.length()) S = S.substr(0, K) + "...";
cout << S << endl;
return 0;
} | 0 | 47,896,187 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
a = a + b - c - d;
if (a > 0) cout << "Left";
if (a < 0) cout << "Right";
if (a == 0) cout << "Balanced";
} | #include <cstdio>
#include <iostream>
#include <algorithm>
#define rep(i,n) for(int i=0; i<(n); ++i)
#define outl(x) cout<< (x) << '\n'
using namespace std;
bool G[105][105];
signed main()
{
cin.tie(0), ios::sync_with_stdio(false);
int N;
cin >> N;
rep(i, N){
int k, u, p;
cin >> u >> k;
--u;
rep(j, k){
cin >> p;
--p;
G[u][p] = true;
}
}
rep(i, N){
rep(j, N){
cout << G[i][j] << ((j+1 < N)? ' ' : '\n') ;
}
}
} | 0 | 68,802,313 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using V = vector<int>;
using VV = vector<vector<int>>;
using VVV = vector<vector<vector<int>>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VVVL = vector<vector<vector<ll>>>;
using pq = priority_queue<int>;
template<class T>
using P = pair<T, T>;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define REP(i,k,n) for(int i=(k);i<(n);i++)
#define all(a) (a).begin(),(a).end()
#define output(x,y) cout << fixed << setprecision(y) << x << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
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; }
int under = (1 << 31);
int upper = under - 1;
ll UNDER = (1LL << 63);
ll UPPER = UNDER - 1;
const int MOD = 1e9 + 7;
const long double pi = 3.141592653589793;
int main() {
int n;
cin >> n;
V a(n + 1);
rep1(i, n) {
cin >> a[i];
}
sort(all(a));
VL sum(n + 1, 0);
rep1(i, n) {
sum[i] = sum[i - 1] + a[i];
}
int streak = 1;
rep1(i, n - 1) {
if (sum[i] * 2 >= a[i + 1]) streak++;
else streak = 1;
}
cout << streak << endl;
return 0;
} | #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<unordered_map>
#include<utility>
#include<cmath>
#include<random>
#include<cstring>
#include<queue>
#include<stack>
#include<bitset>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#include<typeinfo>
#define loop(i,a,b) for(long long i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define FOR(i,a) for(auto i:a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define show1d(v) {rep(_,v.size())cout<<" "<<v[_];cout<<endl;}
#define show2d(v) {rep(__,v.size())show1d(v[__]);}
using namespace std;
typedef long long ll;
#define int ll
typedef int Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
#define mt make_tuple
typedef tuple<int,int,int,int> tp;
typedef vector<tp> vt;
template<typename A,typename B>bool cmin(A &a,const B &b){return a>b?(a=b,true):false;}
template<typename A,typename B>bool cmax(A &a,const B &b){return a<b?(a=b,true):false;}
const double PI=acos(-1);
const double EPS=1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9+10;
#define yes cout<<"Yes\n"
#define no cout<<"No\n"
int dp[10][60][10];
int co[10][60][10];
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
rep(i,10)rep(j,60)rep(k,10)dp[i][j][k]=co[i][j][k]=0;
rep(i,10)rep(j,10){
int a=i+j;
if(a<10){
dp[i][0][j]=a;
co[i][0][j]=1;
}else{
dp[i][0][j]=a/10+a%10;
co[i][0][j]=2;
}
if(i==0)co[i][0][j]--;
}
rep(j,59)rep(i,10)rep(k,10){
int a=dp[i][j][k];
int c=co[i][j][k]+co[a][j][k];
a=dp[a][j][k];
dp[i][j+1][k]=a;
co[i][j+1][k]=c;
}
int n;
cin>>n;
int out=0,t=0;
while(n--){
int a,b;
cin>>a>>b;
rep(i,60)if(1ll<<i&b){
out+=co[t][i][a];
t=dp[t][i][a];
}
}
cout<<out<<endl;
} | 0 | 5,760,158 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)
#define gnr(i,a,b) for(int i=int(b)-1;i>=int(a);i--)
#define per(i,b) gnr(i,0,b)
#define pb push_back
#define eb emplace_back
#define a first
#define b second
#define bg begin()
#define ed end()
#define all(x) x.bg,x.ed
const ll MOD = 998244353;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vp;
unordered_map<int, vector<int>> mp;
rep(i, m) {
int p, y;
cin >> p >> y;
vp.emplace_back(p, y);
mp[p].push_back(y);
}
for (auto& v : mp) sort(all(v.second));
rep(i, m) {
auto pi = vp[i];
int p = pi.first; int y = pi.second;
int idx = lower_bound(mp[p].begin(), mp[p].end(), y) - mp[p].begin();
cout << setfill('0') << right << setw(6) << p;
cout << setfill('0') << right << setw(6) << idx+1;
cout << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#include <string.h>
#include <limits.h>
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;
}
const vector<int> ms = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const string NA = "$";
vector<int> as;
vector<string> dp;
inline int match_for(int x) {
return ms[x];
}
int cmp(const string &a, const string &b) {
if ((int) a.size() != (int) b.size()) {
return ((int) a.size() > (int) b.size()) ? 1 : -1;
}
return strncmp(a.c_str(), b.c_str(), (int) a.size());
}
string solve(const int N, const vector<int> &as) {
for (int i = 1; i <= N; i++) {
for (auto a : as) {
int req_match = match_for(a);
if (i - req_match >= 0 && dp[i - req_match] != NA) {
string cand = dp[i - req_match] + to_string(a);
if (cmp(cand, dp[i]) > 0) {
dp[i] = move(cand);
}
}
}
}
return dp[N];
}
int main(void) {
int N, M;
cin >> N >> M;
as.resize(M);
for (int i = 0; i < M; i++) {
cin >> as[i];
}
sort(as.begin(), as.end());
reverse(as.begin(), as.end());
dp.resize(N + 1, NA);
dp[0] = "";
string ans = solve(N, as);
cout << ans << endl;
return 0;
} | 0 | 23,282,773 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int i, j, t, n, a, b, c, d, m, k;
cin>>a>>b;
cout<<a*b-a-b+1<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll (i) = 0 ; (i) < (ll)(n) ; ++(i))
#define REPN(i, m, n) for (ll (i) = m ; (i) < (ll)(n) ; ++(i))
#define REP_REV(i, n) for (ll (i) = (ll)(n) - 1 ; (i) >= 0 ; --(i))
#define REPN_REV(i, m, n) for (ll (i) = (ll)(n) - 1 ; (i) >= m ; --(i))
#define INF 2e9
#define INF_LL 1LL<<60
#define ll long long
#define MAX_V 105
#define MAX_N 100
#define MAX_M 100
int main(){
int n, m;
cin >> n >> m;
vector<int> ans(n, 0);
REP(i, m) {
int a, b;
cin >> a >> b;
a--, b--;
ans[a]++, ans[b]++;
}
REP(i, n) {
if(ans[i] % 2 != 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | 0 | 47,116,929 |
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long q,h,s,d,n;
long long cost,min2,min1,min05,min025;
cin>>q>>h>>s>>d>>n;
min025=q;
min05=min(h,2*min025);
min1=min(s,min05*2);
min2=min(d,min1*2);
cost=0;
while(n>0)
{
if(n>=2)
{
cost+=(n/2*min2);
n=n%2;
}
else if (n==1)
{
cost+=min1;
n--;
}
}
cout<<cost<<"\n";
return 0;
} | #include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>
using namespace std;
int main(){
int n;
scanf ("%d",&n);
while(n){
int k;
vector<int> p(n);
for(int t=0;t<n;t++){
scanf ("%d",&p[t]);
}
sort(p.begin(),p.end());
k=p[1]-p[0];
for(int t=1;t<n-1;t++){
if(k>(p[t+1]-p[t])){
k=(p[t+1]-p[t]);
}
}
printf("%d\n",k);
scanf ("%d",&n);
}
} | 0 | 39,372,256 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
vector<string> rec;
int m, f, r;
while (cin >> m >> f >> r) {
if (m == -1 && f == -1 && r == -1) {
break;
}
if (m == -1 || f == -1) {
rec.push_back(string("F"));
}
else if (m + f >= 80) {
rec.push_back(string("A"));
}
else if (m + f >= 65 && m + f < 80) {
rec.push_back(string("B"));
}
else if (m + f >= 50 && m + f < 65) {
rec.push_back(string("C"));
}
else if(m + f >= 30 && m + f < 50){
if (r >= 50) {
rec.push_back(string("C"));
}
else {
rec.push_back(string("D"));
}
}
else if(m + f < 30) {
rec.push_back(string("F"));
}
}
for (int i = 0; i < rec.size(); i++) {
cout << rec[i] << endl;
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
void Main() {
int N;
cin >> N;
map<int, int> factorization;
for (int i = 2; i <= N; ++i) {
int n = i;
for (int j = 2; j * j <= i; ++j) {
while (n % j == 0) {
if (factorization.count(j) == 0) {
factorization.insert(make_pair(j, 0));
}
factorization[j] += 1;
n /= j;
}
}
if (n != 1) {
if (factorization.count(n) == 0) {
factorization.insert(make_pair(n, 0));
}
factorization[n] += 1;
}
}
int more75 = 0;
int more25 = 0;
int more15 = 0;
int more5 = 0;
int more3 = 0;
for (auto e : factorization) {
if (e.second + 1 >= 75) {
++more75;
}
if (e.second + 1 >= 25) {
++more25;
}
if (e.second + 1 >= 15) {
++more15;
}
if (e.second + 1 >= 5) {
++more5;
}
if (e.second + 1 >= 3) {
++more3;
}
}
int ans = 0;
if (more75 > 0) {
ans += more75;
}
if (more25 > 0 && more3 > 0) {
ans += more25 * (more3 - 1);
}
if (more15 > 0 && more5 > 0) {
ans += more15 * (more5 - 1);
}
if (more5 > 1 && more3 > 2) {
ans += (more5 * (more5 - 1) / 2) * (more3 - 2);
}
cout << ans << endl;
}
int main() {
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
} | 0 | 50,922,543 |
#include<iostream>
#include<cstdio>
#include<vector>
#include<set>
#include<map>
#include<algorithm>
#include<string.h>
#define fornt(k,n) for(int i=k; i<n; ++i)
#define fornt2(p,n) for(int j=p; j<n; ++j)
#define pb push_back
#define ll long long
#define sc(n) scanf("%d",&n)
#define sc2(x,y) scanf("%d %d",&x,&y)
#define scl(n) scanf("%lld",&n)
#define scl2(x,y) scanf("%lld %lld",&x,&y)
#define pr(n) printf("%d\n",n)
#define prl(n) printf("%lld\n",n)
#define pry printf("YES\n")
#define prn printf("NO\n")
using namespace std;
int main ()
{
int n,m,k,ans(0);
sc2(n,m);
sc(k);
char a[n][m];
fornt(0,n)
{
fornt2(0,m)
{
cin>>a[i][j];
}
}
fornt(0,(1 << n))
{
fornt2(0,(1 << m))
{
int c=0;
for(int c1 = 0; c1<n; c1++)
{
for(int c2 = 0; c2<m; c2++)
{
if((i & (1 << c1)) && (j & (1 << c2)))
{
if(a[c1][c2]=='#')
++c;
}
}
}
if(c==k)
++ans;
}
}
pr(ans);
} | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout <<(#x)<<" is "<<(x)<<endl
#define debug cout <<"hi"<<endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
const int MOD=1e9+7;
const int INF32=1<<30;
const ll INF64=1LL<<60;
void solve(){
int n; cin >>n;
vector<ll>a(n); ll p[60],t=1,ans=0;
for(int i=0; i<n; i++) cin >>a[i];
for(int i=0; i<60; i++){
p[i]=t;
t=(t*2)%MOD;
}
for(int i=0; i<60; i++){
ll odd=0,even=0;
for(int j=0; j<n; j++){
if(a[j]%2) odd++;
else even++;
a[j]/=2;
}
ll cnt=(odd*even)%MOD;
ans+=cnt*p[i]; ans%=MOD;
}
cout <<ans;
}
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
solve();
return 0;} | 0 | 55,857,751 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define all(x) (x).begin(),(x).end()
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
using Graph = vector<vector<int>>;
double nCk(int n, int k) {
double res=1.0;
for(int i=0; i<n; i++){
res*=0.5;}
for(int i=0; i<k; i++){
res*=(double)(n-i);
res/=(double)(k-i);
}
return res;}
struct edge{ll to, cost;};
typedef pair<ll,ll> P;
struct graph{
ll V;
vector<vector<edge> > G;
vector<ll> d;
graph(ll n){
init(n);
}
void init(ll n){
V = n;
G.resize(V);
d.resize(V);
rep(i,V){
d[i] = INF;
}
}
void add_edge(ll s, ll t, ll cost){
edge e;
e.to = t, e.cost = cost;
G[s].push_back(e);
}
void dijkstra(ll s){
rep(i,V){
d[i] = INF;
}
d[s] = 0;
priority_queue<P,vector<P>, greater<P> > que;
que.push(P(0,s));
while(!que.empty()){
P p = que.top(); que.pop();
ll v = p.second;
if(d[v]<p.first) continue;
for(auto e : G[v]){
if(d[e.to]>d[v]+e.cost){
d[e.to] = d[v]+e.cost;
que.push(P(d[e.to],e.to));
}
}
}
}
};
int main(){
ll n,m,r;
cin>>n>>m>>r;
ll c[r]={};
rep(i,r){
cin>>c[i];
c[i]--;}
sort(c,c+r);
vvl dist(n, vl(n,INF));
for(ll i=0; i<m; i++){
ll a,b,c; cin>>a>>b>>c;
dist[a-1][b-1]=c;
dist[b-1][a-1]=c;}
for (ll k = 0; k < n; k++){
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
ll ca = 1;
for(ll i=1; i<=r; i++){
ca*=i;}
ll ans = INF;
ll cb = 0;
for(ll i=0; i<ca; i++){
next_permutation(c,c+r);
cb = 0;
for(ll j=0; j<r-1; j++){
cb += dist[c[j]][c[j+1]];}
ans = min(ans,cb);
}
cout << ans << endl;} | #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 <iomanip>
#include<math.h>
#include <functional>
#include<climits>
using namespace std;
template <typename T> bool chmax(T &u, const T z) { if (u < z) {u = z; return true;} else return false; }
template <typename T> bool chmin(T &u, const T z) { if (u > z) {u = z; return true;} else return false; }
const int INF=10000000;
#define ll long long
#define rep(i, n) for(ll i=0; i<(ll)(n); ++i)
int main(){
int h,w,n;cin>>h>>w>>n;
map<int,int>mph,mpw;
set<pair<int,int>>zahyou;
rep(i,n){
ll r,c;
cin>>r>>c;
zahyou.insert({r,c});
mph[r]++;
mpw[c]++;
}
int maxh=0,maxw=0;
for(auto p:mph)chmax(maxh,p.second);
for(auto p:mpw)chmax(maxw,p.second);
vector<int>numh,numw;
for(auto p:mph)if(p.second==maxh)numh.push_back(p.first);
for(auto p:mpw)if(p.second==maxw)numw.push_back(p.first);
rep(i,numh.size())rep(o,numw.size()){
if(!zahyou.count({numh[i],numw[o]})){
cout<<maxh+maxw<<endl;
return 0;
}
}
cout<<maxh+maxw-1<<endl;
} | 0 | 88,428,243 |
#include <iostream>
#define REP(i, a, n) for(int i = (a); i < (n); i++)
using namespace std;
int past(int Y, int M, int D) {
int day = 0;
REP(i, 1, Y) {
if(i % 3 == 0) day += 10 * 20;
else day += 19 * 5 + 20 * 5;
}
REP(i, 1, M) {
if(Y % 3 == 0) {
day += 20;
} else {
if(i % 2 == 1) day += 20;
else day += 19;
}
}
day += D;
return day;
}
int main(void) {
int N; cin >> N;
int m = past(1000, 1, 1);
REP(i, 0, N) {
int Y, M, D; cin >> Y >> M >> D;
cout << (m - past(Y, M, D)) << endl;
}
return 0;
} | #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
using ll=long long;
using ld=long double;
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define ordered_set tree<pll, null_type,less<pll>, rb_tree_tag,tree_order_statistics_node_update>
#define endl "\n"
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define int long long int
#define pll pair<int , int>
#define ALL(v) v.begin(),v.end()
#define ALLR(v) v.rbegin(),v.rend()
#define pii 3.14159265358979323
#define inf LLONG_MAX
#define ones(x) __builtin_popcount(x)
#define fill(a,b) memset(a,b,sizeof(a))
#define mod 1000000007
#define hell 998244353
ll mod_pow(ll a,ll b,ll m)
{
ll res = 1;
while(b)
{
if(b&1)
{
res=(res*a) % m;
}
a=(a*a) % m;
b>>=1;
}
return res;
}
ll mod_inverse(ll a)
{
return mod_pow(a , mod-2 , mod);
}
void solve()
{
int r , d , x;
cin >> r >> d >> x;
for(int i = 1; i <= 10 ; ++i) {
cout << r*x - d << endl;
x = r*x - d;
}
}
signed main() {
fast;
int t = 1;
while(t--) {
solve();
}
return 0;
} | 0 | 21,387,963 |
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <algorithm>
#include <set>
#include <vector>
#include <queue>
#define pb push_back
using namespace std;
typedef pair<int,int> pii;
int main(){
int N;
cin>>N;
set<int> ss[1000];
bool flag=false;
int n,m;
for(int i=2;i*(i-1)<=2*N;i++){
if(i*(i-1)==2*N){
flag=true;
n=i;m=i-1;
}
}
if(!flag){
cout<<"No"<<endl;
return 0;
}
cout<<"Yes"<<endl;
int tmp=1;
for(int i=1;i<=m;i++){
for(int j=1;j<=i;j++){
ss[j].insert(tmp++);
}
}
tmp=1;
for(int i=2;i<=n;i++){
for(int j=2;j<=i;j++){
ss[i].insert(tmp++);
}
}
cout<<n<<endl;
for(int i=1;i<=n;i++){
cout<<m<<" ";
for(auto itr=ss[i].begin();itr!=ss[i].end();++itr){
cout<<*itr<<" ";
}
cout<<endl;
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
int main()
{
int n,d,ans;
ans=0;
cin>>n>>d;
vector<vector<int>> x(n,vector<int>(d));
for(int i=0;i<n;i++)
{
for(int j=0;j<d;j++)
{
cin>>x.at(i).at(j);
}
}
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
int disdis=0;
int han;
double dis;
for(int k=0;k<d;k++)
{
disdis+=(x.at(i).at(k)-x.at(j).at(k))*(x.at(i).at(k)-x.at(j).at(k));
}
dis=sqrt(disdis);
han=dis;
if(dis==han)
ans++;
}
}
cout<<ans<<endl;
} | 0 | 56,551,726 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, ai;
cin >> N;
map <int,int> A;
for(int i=0;i<N;i++){
cin >> ai;
if(A.count(ai) > 0){ cout << "NO" << endl; return 0;}
else A[ai] = 1;
}
cout << "YES" << endl;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define eps 1e-10
#define MAXN 200005
using namespace std;
typedef long long int64;
typedef unsigned int u32;
typedef double db;
template<class T>
void read(T &res) {
res = 0;T f = 1;char c = getchar();
while(c < '0' || c > '9') {
if(c == '-') f = -1;
c = getchar();
}
while(c >= '0' && c <= '9') {
res = res * 10 +c - '0';
c = getchar();
}
res *= f;
}
template<class T>
void out(T x) {
if(x < 0) {x = -x;putchar('-');}
if(x >= 10) {
out(x / 10);
}
putchar('0' + x % 10);
}
int D,N,a[MAXN],cnt[MAXN];
void Solve() {
read(N);
for(int i = 1 ; i <= N ; ++i) {read(a[i]);cnt[a[i]]++;}
for(int i = 1 ; i <= N ; ++i) D = max(D,a[i]);
if(D & 1) {
if(cnt[D / 2 + 1] != 2) {puts("Impossible");return;}
int res = 0;
for(int i = D / 2 + 1 ; i <= D ; ++i) {
res += cnt[i];
if(cnt[i] < 2) {puts("Impossible");return;}
}
if(res != N) {puts("Impossible");return;}
}
else {
if(cnt[D / 2] != 1) {puts("Impossible");return;}
int res = 1;
for(int i = D / 2 + 1 ; i <= D ; ++i) {
res += cnt[i];
if(cnt[i] < 2) {puts("Impossible");return;}
}
if(res != N) {puts("Impossible");return;}
}
puts("Possible");return;
}
int main() {
#ifdef ivorysi
freopen("f1.in","r",stdin);
#endif
Solve();
return 0;
} | 0 | 77,637,985 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int H, W, K;
cin >> H >> W >> K;
char C[H][W];
for(int i=0; i<H; i++){
for(int j=0; j<W; j++){
cin >> C[i][j];
}
}
int ans=0;
int count;
for (int ibit = 0; ibit < (1 << H); ++ibit){
for (int jbit = 0; jbit < (1 << W); ++jbit){
count = 0;
for(int i=0; i<H; i++){
for(int j=0; j<W; j++){
if( ( ibit & (1<<i) ) || ( jbit & (1<<j) ) ) continue;
if( C[i][j]=='#' ) count++;
}
}
if( count == K ) ans++;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> iint;
typedef pair<ll,ll> llll;
#define ALL(x) (x).begin(),(x).end()
const ll zero = 0;
const ll INF = 3000000000000000000;
const int inINF = 1000000000;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
int main(){
int N, M;
cin >> N >> M;
vector<ll> x(N), y(N), z(N);
for (int i = 0; i < N; i++) {
cin >> x[i] >> y[i] >> z[i];
}
vector<vector<ll>> W(8, vector<ll> (N));
for (int i = 0; i < 8; i++) {
if(i & 1){
for (int j = 0; j < N; j++) {
W[i][j] = x[j];
}
}
else{
for (int j = 0; j < N; j++) {
W[i][j] = -x[j];
}
}
if(i & 2){
for (int j = 0; j < N; j++) {
W[i][j] += y[j];
}
}
else{
for (int j = 0; j < N; j++) {
W[i][j] -= y[j];
}
}
if(i & 4){
for (int j = 0; j < N; j++) {
W[i][j] += z[j];
}
}
else{
for (int j = 0; j < N; j++) {
W[i][j] -= z[j];
}
}
}
for (int i = 0; i < 8; i++) {
sort(ALL(W[i]), greater<ll> ());
}
ll tmp;
ll ans = 0;
for (int i = 0; i < 8; i++) {
tmp = 0;
for (int j = 0; j < M; j++) {
tmp += W[i][j];
}
ans = max(ans, tmp);
}
printf("%lld\n", ans);
} | 0 | 91,661,395 |
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, r;
cin >> n >> m >> r;
vector<int> rv(r);
rep(i, 0, r) {
cin >> rv[i];
rv[i]--;
}
vector<vector<ll>> d(n, vector<ll>(n, 1e18));
rep(i, 0, m) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
d[a][b] = c;
d[b][a] = c;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
sort(rv.begin(), rv.end());
ll ans = 1e18;
do {
ll x = 0, from = rv[0];
rep(to, 1, r) {
x += d[from][rv[to]];
from = rv[to];
}
chmin(ans, x);
} while (next_permutation(rv.begin(), rv.end()));
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define x first
#define y second
#define mk(a,b) make_pair(a,b)
#define rr return 0
#define sqr(a) ((a)*(a))
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class value, class cmp = less<value> >
using ordered_set = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class value, class cmp = less_equal<value> >
using ordered_multiset = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class key, class value, class cmp = less<key> >
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int randll(int l = INT_MIN, int r = INT_MAX) {
return uniform_int_distribution<int>(l, r)(rng);
}
const int INF = 1e9, MOD = 1e9 + 7;
const ll LINF = 1e18;
const int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
inline bool inside (int x, int y, int n, int m) {
return 0 <= x && 0 <= y && x < n && y < m;
}
template<class T> bool umin (T &a, T b) {return a > b ? (a = b, true) : false; }
template<class T> bool umax (T &a, T b) {return a < b ? (a = b, true) : false; }
inline int mul (int a, int b, int m = MOD) {
return ((ll)a * b) % m;
}
inline int binpow (int a, int n, int m = MOD) {
int ans = 1;
for (; n; n >>= 1) {
if (n & 1) ans = mul(ans, a, m);
a = mul(a, a, m);
}
return ans;
}
inline void add (int &a, int x, int m = MOD) {
a += x;
if (a >= m) a -= m;
if (a < 0) a += m;
}
inline int sum (int a, int b, int m = MOD) {
a += b;
if (a >= m) a -= m;
if (a < 0) a += m;
return a;
}
main()
{
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
++n;
int ans = 0, mn = 0, mx = 0;
for (int i = 0; i < k; i++) {
add(mn, i + 1);
add(mx, n - i);
}
for (int i = k; i <= n; i++) {
add(ans, mx + 1);
add(ans, -mn);
add(mn, i + 1);
add(mx, n - i);
}
cout << ans << '\n';
} | 0 | 93,312,983 |
#include <bits/stdc++.h>
#include <stdio.h>
#include <math.h>
using namespace std;
using vi = vector<int>;
using vll = vector<long long int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long int>>;
using ll = long long int;
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;
}
};
int main(){
ll N, A, B, C; cin >> N >> A >> B >> C ;
vll l(N);
for(int i=0; i<N; i++){
cin >> l[i];
}
ll min = 10000000000000;
for(int i=0; i<pow(4,N); i++){
vll a(0), b(0), c(0), d(0);
Radix r;
string k = r.to(i, 4);
if(k.size() == N){
for(int j=0; j<N; j++){
if(k[j] == '0'){
a.emplace_back(l[j]);
}else if(k[j] == '1'){
b.emplace_back(l[j]);
}else if(k[j] == '2'){
c.emplace_back(l[j]);
}else{
d.emplace_back(l[j]);
}
}
}else{
int p = k.size();
string m = "";
for(int j=0; j<N-p; j++){
m.push_back('0');
}
string h = m + k;
for(int j=0; j<N; j++){
if(h[j] == '0'){
a.emplace_back(l[j]);
}else if(h[j] == '1'){
b.emplace_back(l[j]);
}else if(h[j] == '2'){
c.emplace_back(l[j]);
}else{
d.emplace_back(l[j]);
}
}
}
ll res = 0;
ll s=0, t=0, u=0, v=0;
for(auto x: a){s+=x;}
for(auto x: b){t+=x;}
for(auto x: c){u+=x;}
for(auto x: d){v+=x;}
if(s==0||t==0||u==0){
continue;
}
res += abs(A-s);
res += abs(B-t);
res += abs(C-u);
res += (a.size()-1)*10;
res += (b.size()-1)*10;
res += (c.size()-1)*10;
if(res < min){min = res;}
}
cout << min;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, D;
cin >> H >> W >> D;
vector<int> X(H * W + 1), Y(H * W + 1);
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
int A;
cin >> A;
X.at(A) = i;
Y.at(A) = j;
}
}
vector<int> d(H * W + 1);
for (int i = 1; i <= H * W; i++) {
if (i <= D) d.at(i) = 0;
else d.at(i) = d.at(i - D) + abs(X.at(i) - X.at(i - D)) + abs(Y.at(i) - Y.at(i - D));
}
int Q;
cin >> Q;
for (int i = 0; i < Q; i++) {
int L, R;
cin >> L >> R;
cout << d.at(R) - d.at(L) << endl;
}
} | 0 | 15,112,174 |
#include <bits/stdc++.h>
using namespace std;
typedef int64_t i64;
int main()
{
int p,q,r;
cin >> p >> q >> r;
int ans = p+q+r - max({p,q,r});
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
using vll = vector<vl>;
using Pll = pair<ll, ll>;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(v) v.begin(), v.end()
#define sz(x) ((int) x.size())
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
const int MOD = 1e9+7;
const ll INF = 2e15;
template<class T> void print(const T& t){ cout << t << endl; }
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; }
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
int main(){
string s;
cin >> s;
ll k;
cin >> k;
bool z = true;
rep(i, sz(s) - 1){
if(s[i]!=s[i+1]){
z = false;
}
}
if(z){
print(k * sz(s) / 2);
return 0;
}
string ss = s + s;
string sss = s + s + s;
string ssss = s + s + s + s;
string sssss = s + s + s + s + s;
ll n = 0, m = 0, o = 0, u = 0, a = 0;
for (ll i = 1; i < sz(s); i++){
if(s[i]==s[i-1]){
s[i] = '*';
n++;
}
}
for (ll i = 1; i < sz(ss);i++){
if(ss[i]==ss[i-1]){
ss[i] = '*';
m++;
}
}
for (ll i = 1; i < sz(sss);i++){
if(sss[i]==sss[i-1]){
sss[i] = '*';
o++;
}
}
for (ll i = 1; i < sz(ssss);i++){
if(ssss[i]==ssss[i-1]){
ssss[i] = '*';
u++;
}
}
for (ll i = 1; i < sz(sssss);i++){
if(sssss[i]==sssss[i-1]){
sssss[i] = '*';
a++;
}
}
ll l = m - n;
ll p = o - m;
ll q = u - o;
ll b = a - u;
ll ans;
if(k==1){
ans = n;
}
else if(k==2){
ans = m;
}
else if(k==3){
ans = o;
}
else if(k==4){
ans = a;
}
else{
ans = a + b * (k - 5);
}
print(ans);
} | 0 | 25,956,232 |
#include<cstdio>
const static int H_MAX = 2000;
const static int W_MAX = 2000;
bool grid[H_MAX + 2][W_MAX + 2];
unsigned vertical[H_MAX + 1][W_MAX + 1], horizontal[H_MAX + 1][W_MAX + 1];
int main(){
int H, W;
scanf("%d %d", &H, &W);
for (int i = 0; i <= W + 1; ++i){
grid[0][i] = grid[H + 1][i] = false;
}
for (int i = 1; i <= H; ++i){
grid[i][0] = grid[i][W + 1] = false;
}
for (int i = 1; i <= H; ++i){
scanf("\n");
for (int j = 1; j <= W; ++j){
char tmp;
scanf("%c", &tmp);
grid[i][j] = tmp == '.';
}
}
for (int i = 1; i <= H; ++i){
unsigned left;
for (int j = 1; j <= W; ++j){
if(grid[i][j] && !grid[i][j - 1]) left = j;
if(grid[i][j] && !grid[i][j + 1]){
for (int k = left; k <= j; ++k){
horizontal[i][k] = j + 1 - left;
}
}
}
}
for (int i = 1; i <= W; ++i){
unsigned top;
for (int j = 1; j <= H; ++j){
if(grid[j][i] && !grid[j - 1][i]) top = j;
if(grid[j][i] && !grid[j + 1][i]){
for (int k = top; k <= j; ++k){
vertical[k][i] = j + 1 - top;
}
}
}
}
unsigned ans = 0;
for (int i = 1; i <= H; ++i){
for (int j = 1; j <= W; ++j){
if(grid[i][j] && ans < horizontal[i][j] + vertical[i][j] - 1) ans = horizontal[i][j] + vertical[i][j] - 1;
}
}
printf("%u\n", ans);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using LL = long long;
using P = pair<int,int>;
int main(){
char b;
cin >> b;
if(b=='A') cout << 'T' << endl;
if(b=='T') cout << 'A' << endl;
if(b=='C') cout << 'G' << endl;
if(b=='G') cout << 'C' << endl;
return 0;
} | 0 | 70,248,910 |
#include<iostream>
using namespace std;
int main(){
int n;
cin >> n;
cout << (n / 2) - (n % 2 == 0) << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int mod = 1e9+7;
string solve(int n){
string s;
s = "000000";
for(int i = 0; i < 6; i++){
s[5-i] = '0'+n%10;
n /= 10;
}
return s;
}
int main(){
int n,m;
cin >> n >> m;
vector<map<int,int>> mp(n+1);
for(int i = 0; i < m; i++){
int p,y;
cin >> p >> y;
mp[p][y] = i;
}
vector<string> ans(m);
for(int i = 1; i <= n; i++){
int j = 1;
for(auto r:mp[i]){
string ken = solve(i);
string num = solve(j);
ans[r.second] = ken+num;
j++;
}
}
for(int i = 0; i < m; i++){
cout << ans[i] << endl;
}
} | 0 | 62,771,534 |
#include<iostream>
#include<queue>
using namespace std;
int data[20][20];
int dp[20][20];
int w,h,n;
int main(){
int i,j;
int x,y;
while(1){
cin >> w >> h;
if( !w )break;
cin >> n;
for( i = 0; i < 20; i++ ){
for( j = 0; j < 20; j++ ){
data[i][j] = 0;
dp[i][j] = 0;
}
}
for( i = 0; i < n; i++ ){
cin >> x >> y;
x--;y--;
data[y][x] = 1;
}
dp[0][0] = 1;
for( i = 0; i < h; i++ ){
for( j = 0; j < w; j++ ){
if( i+1 < h && !data[i+1][j] )
dp[i+1][j] += dp[i][j];
if( j+1 < w && !data[i][j+1] )
dp[i][j+1] += dp[i][j];
}
}
cout << dp[h-1][w-1] << endl;
}
return 0;
} | #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[200010];
rep(i, N) cin >> a[i];
int cnt = 0;
rep(i, N) {
if(a[i] == cnt + 1) cnt++;
}
if(cnt == 0) {
cout << -1 << endl;
} else {
cout << N - cnt << endl;
}
return 0;
} | 0 | 73,955,129 |
#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>;
const int INF = 1 << 29;
int main() {
string s;
cin >> s;
int x = INF;
for (int i = 0; i < s.size()-2; i++) {
string sub = s.substr(i, 3);
int now = stoi(sub);
x = min(x, abs(753-now));
}
cout << x << endl;
return 0;
} | #include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define rSort(v) sort(v.rbegin(), v.rend())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
int main() {
cout << fixed << setprecision(15);
ll n, m;
cin >> n >> m;
set<ll> ac;
map<ll, ll> pn;
rep(i, m) {
ll x;
string s;
cin >> x >> s;
if (ac.find(x) != ac.end()) continue;
if (s == "AC")
ac.insert(x);
else
pn[x]++;
}
ll sacon = 0;
for (auto& x : pn)
if(ac.find(x.first) != ac.end()) sacon += x.second;
cout << ac.size() << " " << sacon << endl;
return 0;
} | 0 | 43,518,808 |
#include "bits/stdc++.h"
#define _USE_MATH_DEFINES
#include <math.h>
using namespace std;
using LL = long long;
using VLL = std::vector<LL>;
using VVLL = std::vector<VLL>;
using VVVLL = std::vector<VVLL>;
using LD = long double;
using VLD = std::vector<LD>;
using VVLD = std::vector<VLD>;
using VVVLD = std::vector<VVLD>;
using BL = bool;
using VBL = std::vector<BL>;
using VVBL = std::vector<VBL>;
using VVVBL = std::vector<VVBL>;
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return true; }return false; }
template<class T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return true; }return false; }
#define REP(i,n) for(LL (i)=0;(i)<(n);(i)++)
#define REPM(i,n,m) for(LL (i)=m;(i)<(n);(i)++)
#define ALL(v) v.begin(), v.end()
#define PRINTLN(v) {LL i=0; for(auto (a): v ){ cerr <<i << " : "<< a << endl; i++;}}
template<class T>
void PRINTSP(vector<T> v, size_t w=3){
for(auto (a): v ) {cerr <<setw(w)<< a << " ";} cerr << endl;
}
template<typename TTT>
vector<LL> arg_sort(vector<TTT> A, bool ascend = true) {
vector<LL> index(A.size());
iota(index.begin(), index.end(), 0);
if (ascend) {
std::sort(index.begin(), index.end(), [&A](TTT i1, TTT i2) {
return A[i1] < A[i2];
});
}
else {
std::sort(index.begin(), index.end(), [&A](TTT i1, TTT i2) {
return A[i1] > A[i2];
});
}
return index;
}
struct UinonFindTree {
private:
vector<LL> UFT;
public:
UinonFindTree(LL N) {
UFT.resize(N);
for (LL i = 0; i < N; i++) {
UFT[i] = -1;
}
}
LL root(LL i) {
if (UFT[i] < 0) {
return i;
}
else {
LL j = root(UFT[i]);
UFT[i] = j;
return j;
}
}
bool same(LL i, LL j) {
return (root(i) == root(j));
}
void unite(LL i, LL j)
{
LL root_i = root(i);
LL root_j = root(j);
if (root_i != root_j) {
if (size(root_i) < size(root_j)) {
swap(root_i, root_j);
}
UFT[root_i] += UFT[root_j];
UFT[root_j] = root_i;
}
}
LL size(LL i) {
return -UFT[root(i)];
}
LL get_root_num() {
set<LL> roots;
for (LL i = 0; i < UFT.size(); ++i) {
roots.insert(root(i));
}
return (LL)roots.size();
}
map<LL, vector<LL>> get_root_child() {
map<LL, vector<LL>> a;
for (LL i = 0; i < UFT.size(); ++i) {
LL j = root(i);
a[j].push_back(i);
}
return a;
}
void print() {
for (LL i = 0; i < UFT.size(); ++i) {
cerr << root(i) << " ";
}
cerr << endl;
}
};
#define cmax(a,b) {if(a<b){a=b;}}
#define cmin(a,b) {if(a>b){a=b;}}
#define EACH(a,A) for(auto a: A)
inline VLL cinvll(LL N, LL minus = 0){
VLL A(N);
REP(i,N){
cin >> A[i];
A[i] -= minus;
}
return move(A);
}
inline VVLL zerosll(LL H, LL W, LL val=0){
VVLL A(H,VLL(W,val));
return move(A);
}
struct Fast{
Fast(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
}
} fast;
LL GCD(LL m, LL n) {
if (m < n) {
swap(m, n);
}
while (n != 0) {
LL n_new = m % n;
m = n;
n = n_new;
}
return m;
}
VLL B;
VVLL T;
LL cnt=0;
void dfs(LL me,LL oya){
for(LL i=0;i<T[me].size();i++){
LL ko = T[me][i];
if(ko==oya){
continue;
}
cnt += min(B[me],B[ko]);
dfs(ko,me);
}
}
void func(){
LL N;
cin >> N;
vector<string> S(N);
REP(i,N){
cin >> S[i];
}
LL cnt=0;
vector<string> T = S;
REP(k,N){
REP(r,N){
S[r] = T[(k+r)%N];
}
REP(r,N){
}
bool flag = true;
REP(i,N){
REPM(j,N,i){
if(S[i][j]!=S[j][i]){
flag=false;
break;
}
}
}
if(flag){
cnt++;
}
}
cout << cnt*N;
}
int main()
{
func();
return 0;
} | #include<bits/stdc++.h>
typedef long long ll;
#define pb push_back
#define mod 1000000007ll
const ll maxn = 9e18;
using namespace std;
const ll maxsize = 100000009;
void solve() {
int a, b;
cin >> a >> b;
if(a > b) swap(a, b);
string t(b, a + '0');
cout << t << endl;
}
int main() {
ios_base :: sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(35);
solve();
return 0;
} | 0 | 63,102,368 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <string>
#include <set>
#include <math.h>
#include <map>
#include <stack>
using namespace std;
static const int INF = 1e9+7;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, a, b) for (int i =a; i < b; i++)
#define all(a) a.begin(), a.end()
#define PI 3.14159265359
int main(){
string s; cin >> s;
stack<char> result;
rep(i,s.size()){
if(s[i] == '0' || s[i] =='1'){
result.push(s[i]);
}else if(!result.empty()){
result.pop();
}
}
string ans = "";
int len = result.size();
rep(i,len){
ans += result.top();
result.pop();
}
reverse(all(ans));
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define PI 3.141592653589793
using namespace std;
using ll = long long;
using v1 = vector<int>;
using v2 = vector<vector<int>>;
using v3 = vector<vector<char>>;
struct point{
double x;
double y;
};
void coho(int d, point a, point b){
double p6 = 60 * PI /180.0;
if(d == 0) return;
double x1 = (b.x -a.x)/3;
double y1 = (b.y -a.y)/3;
point s, t, u;
s.x = x1 +a.x;
s.y = y1 + a.y;
u.x = x1*2 + a.x;
u.y = y1*2 + a.y;
t.x = (u.x - s.x)*cos(p6) - (u.y - s.y)*sin(p6) + s.x;
t.y = (u.x - s.x)*sin(p6) + (u.y - s.y)*cos(p6) + s.y;
coho(d-1, a, s);
cout << s.x <<" "<< s.y << endl;
coho(d-1, s, t);
cout << t.x <<" "<< t.y << endl;
coho(d-1, t, u);
cout << u.x << " " << u.y << endl;
coho(d-1, u, b);
}
int main(){
int n;
cin >> n;
point a, b;
a.x = 0;
a.y = 0;
b.x = 100;
b.y = 0;
cout << a.x << " " << a.y << endl;
coho(n, a, b);
cout << b.x << " " << b.y << endl;
} | 0 | 61,309,171 |
#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>
using namespace std;
#define i64 long long
#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 << std::endl;}
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> void DEBUG(string str, T e){if(DEBUG_OUT == false)return;std::cout <<str<<" ";DEBUG(e);};
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; exit(0);}}
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 A,B,X;
cin>>A>>B>>X;
if( A <= X && X <= A+B)
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<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 <bits/stdc++.h>
#define N 200005
using namespace std;
int n;
int a[N];
map < int , int > b;
bool ok(int mij)
{
int i , k;
b.clear();
for(i = 2 ; i <= n ; i++)
if(a[i] <= a[i - 1])
{
b.erase(b.upper_bound(a[i]) , b.end());
k = a[i];
++b[k];
while(k > 0 && b[k] == mij)
{
b.erase(k);
++b[--k];
}
if(!k)
return false;
}
return true;
}
int main()
{
int check = 0 , i;
cin >> n;
for(i = 1 ; i <= n ; i++)
{
cin>>a[i];
check |= (a[i] <= a[i - 1]);
}
if(!check)
{
cout<<1;
return 0;
}
int st = 2 , dr = n , mij = 0 , ans = 0;
while(st <= dr)
{
mij = (dr - st) / 2 + st;
if(ok(mij) == true)
{
ans = mij;
dr = mij - 1;
}
else st = mij + 1;
}
cout<<ans;
return 0;
} | 0 | 44,139,108 |
#include<iostream>
#include<map>
#include<string>
using namespace std;
int main() {
map<string, int> M;
string word, fword, lword = "";
int s = 0;
while(cin >> word) {
M[word]++;
if(M[word] > s) {
s = M[word];
fword = word;
}
if(word.size() > lword.size()) lword = word;
}
cout << fword << " " << lword << 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>;
ll dp[1010][10010];
const ll INF=1e18;
int main(){
int h,n;
cin>>h>>n;
vector<int>a(n),b(n);
rep(i,n)cin>>a[i]>>b[i];
rep(i,1010)rep(j,10010)dp[i][j]=INF;
rep(i,1010)dp[i][0]=0;
for(int i=0; i<n; ++i){
for(int j=0; j<=h; ++j){
dp[i+1][j]=min(dp[i+1][j],dp[i][j]);
dp[i+1][min(j+a[i],h)]=min(dp[i+1][min(j+a[i],h)],dp[i+1][j]+b[i]);
}
}
cout<<dp[n][h]<<endl;
} | 0 | 51,412,241 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define S second
#define F first
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
#define lb lower_bound
#define si(c) (int)((c).size())
#define lcm(a, b) (a * (b / __gcd(a,b)))
#define inf (int)(1e18)
#define endl '\n'
#define mp make_pair
#define time(s) (double(clock()-s)/double(CLOCKS_PER_SEC))
#define debug(args...) _F(#args, args)
#define vi std::vector<int>
#define pii pair<int, int>
#define vpi vector<pii>
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template<typename T> void _F(const char *name, T arg1){ cerr << name << " = " << arg1 << endl;}
template<typename T, typename... Args> void _F(const char *names, T arg1, Args... args)
{ const char *name = strchr(names, ',');cerr.write(names, name-names) << " = " << arg1 << endl;_F(name+2, args...);}
template< typename T1, typename T2 > istream& operator>>(istream& in, pair<T1, T2> &q){ in >> q.F >> q.S; return in;}
template< typename T1, typename T2 > ostream& operator<<(ostream& out, pair<T1, T2> &q){ out << q.F << " " << q.S; return out;}
template< typename T1, typename T2 > pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2){ return {p1.F+p2.F, p1.S+p2.S};}
template< typename T1, typename T2 > pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2){ return {p1.F-p2.F, p1.S-p2.S};}
template< typename T1, typename T2 > bool operator<(pair<T1, T2> p1, pair<T1, T2> p2){ return p1 < p2 ;}
template<typename T> void Unique(vector<T> &v){
sort(all(v)), v.resize(distance(v.begin(), unique(all(v))));
}
void solve(int &test) {
int h, w, m;
cin >> h >> w >> m;
int row[h+1], col[w+1];
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
vi r[h+1];
for(int i = 0; i < m; i++) {
int hh, ww;
cin >> hh >> ww;
row[hh]++, col[ww]++;
r[hh].pb(ww);
}
set<pair<int, int> > s;
for(int i = 1; i <= w; i++)
s.insert(mp(col[i], i));
int ans = 0;
for(int i = 1; i <= h; i++) {
for(auto u : r[i]) {
ans = max(ans, col[u]+row[i]-1);
s.erase(mp(col[u], u));
}
if(si(s))ans = max(ans, row[i]+(*rbegin(s)).F);
for(auto u : r[i]) {
s.insert(mp(col[u], u));
}
}
cout << ans << endl;
}
signed main(){
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
start = clock();
int t = 1;
cout << fixed << setprecision(2);
for(int i = 1; i <= t; ++i){
solve(i);
}
cerr << time(start);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N,M;
cin>>N>>M;
vector<bool> isAC(N, false);
vector<int> check(N,0);
int wans=0, cans=0;
int p;
string s;
for(int i=0; i<M; i++){
cin>>p>>s;
if(isAC.at(p-1)) continue;
else{
if(s=="AC"){
isAC.at(p-1) = true;
cans++;
wans+=check.at(p-1);
}
else{
check.at(p-1)++;
}
}
}
cout<<cans<<" "<<wans<<"\n";
} | 0 | 49,749,849 |
#include <stdio.h>
#include <iostream>
#include <vector>
#define ll long long
#define rep(i,n) for(ll i=0;i<n;i++)
#define vecll vector<ll>
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
string strin(){string s;cin>>s;return s;}
bool func(ll n){
ll sum=0,cnt=0,p=n*(n+1)/2;
vecll a(n),b(n);
rep(i,n) sum+=a[i]=lin();
if(sum%p!=0)return false;
ll num=sum/p;
rep(i,n){
b[i]=a[(i+1)%n]-a[i]-num;
if(b[i]>0||b[i]%n!=0)return false;
cnt-=b[i]/n;
}
if(cnt!=num)return false;
return true;
}
int main(){
string ans=func(in())?"YES":"NO";
cout<<ans<<endl;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long
#define all(v) v.begin(), v.end()
int main()
{
int n,m;
cin>>n>>m;
vector<int> a(n);
int i;
rep(i,n)cin>>a[i];
vector<int> sum(n+1,0);
rep(i,n)sum[i+1]=(sum[i]+a[i])%m;
map<int,int> maps;
ll ans=0;
maps.insert(make_pair(0,1));
rep(i,n)
{
auto it = maps.find(sum[i+1]);
if(it!=maps.end())
{
int ch=maps[sum[i+1]];
ans+=ch;
maps[sum[i+1]]=ch+1;
}
else
{
maps.insert(make_pair(sum[i+1],1));
}
}
cout<<ans<<endl;
} | 0 | 40,092,418 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
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 ll INF = 1LL << 60;
const int MAX = 1000000010;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
string a, b, c; cin >> a >> b >> c;
if (a.back() == b.front() && b.back() == c.front()) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i < n; i++)
#define elif else if
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9+7;
const ll MOD2 = 998244353;
const ll INF = 1e15;
int main(){
string yes = "YES", no = "NO";
ll N;
cin >> N;
ll A[N], cnt[N], sum = 0, K, n = N*(N+1)/2;
rep(i, N){
cin >> A[i];
sum += A[i];
}
if(sum%n != 0){
cout << no << endl;
exit(0);
}
K = sum/n;
rep(i, N){
ll j = (i+1)%N;
ll s = A[i]-A[j]+K;
if(s < 0){
cout << no << endl;
exit(0);
}
elif(s%N != 0){
cout << no << endl;
exit(0);
}
else cnt[i] = s/N;
}
ll S = 0;
rep(i, N) S += cnt[i];
if(S == K) cout << yes << endl;
else cout << no << endl;
} | 0 | 99,659,373 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) int(x.size())
#define get_unique(x) x.erase(unique(all(x)), x.end());
typedef long long ll;
typedef complex<double> Complex;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll LINF = 1e18;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T>
vector<T> make_vec(size_t a) {
return vector<T>(a);
}
template <class T, class... Ts>
auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
int main() {
int n, m;
cin >> n >> m;
vector<ll> x(n), y(m);
rep(i, n) cin >> x[i];
rep(i, m) cin >> y[i];
ll tate = 0;
rep(i, n - 1) {
ll now = x[i + 1] - x[i];
(now *= (ll)(i + 1)) %= MOD;
(now *= (ll)(n - i - 1)) %= MOD;
(tate += now) %= MOD;
}
ll yoko = 0;
rep(i, m - 1) {
ll now = y[i + 1] - y[i];
(now *= (ll)(i + 1)) %= MOD;
(now *= (ll)(m - i - 1)) %= MOD;
(yoko += now) %= MOD;
}
cout << tate * yoko % MOD << endl;
} | #include <stdio.h>
main(){
int h,w;
int i,j;
scanf("%d %d",&h,&w);
while(h||w){
for(i=0;i<h;i++){
for(j=0;j<w;j++){
printf((!i||!j||i==h-1||j==w-1) ? "#" : ".");
}
printf("\n");
}
printf("\n");
scanf("%d %d",&h,&w);
}
} | 0 | 19,416,310 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
int l;
cin >> l;
double ans = 0;
ans = (double)l/3;
cout << fixed << setprecision(9) << ans*ans*ans;
} | #include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#include <limits.h>
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;
}
vector<int> as;
ll solve(const int N) {
ll ans = 0;
int acc = 0;
int end = 0;
for (int begin = 0; begin < N; begin++) {
while (end < N && (acc + as[end]) == (acc ^ as[end])) {
acc += as[end];
end++;
}
ans += end - begin;
acc -= as[begin];
}
return ans;
}
int main(void) {
int N;
cin >> N;
as.resize(N);
for (int i = 0; i < N; i++) {
cin >> as[i];
}
cout << solve(N) << endl;
return 0;
} | 0 | 4,305,825 |
#include <iostream>
using namespace std;
int main(){
int money;
while(cin >> money && money !=0){
int count =0;
int res = 1000 - money;
for(int i=0;i<3;i++){
count +=res %10;
if(res % 10 >4){ count -= 4;}
res /=10;
}
cout << count << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(j, m) for (int j = 0; j < (int)(m); j++)
#define rep2(i, l, n) for (int i = l; i < (int)(n); i++)
int main() {
int A,B,C;
cin >> A >> B >> C;
vector<int> V(100);
rep(i,100) {
V[i] = A*(i + 1)%B;
}
int flag = 0;
rep(j,100) {
if (V[j] == C) {
cout << "YES" << endl;
flag++;
break;
}
}
if (flag == 0) {
cout << "NO" << endl;
}
} | 0 | 78,871,252 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin >> n >> k;
int s=n-k;
if(s%(k-1)==0){
cout << s/(k-1)+1 << endl;
}
else{
cout << s/(k-1)+2 << endl;
}
} | #include <stdio.h>
int main(void){
int a,b;
a = 1;
b = 1;
while(a != 10 && b != 11){
if(b != 10){
printf("%dx%d=%d\n",a,b,a * b);
b ++;
}
else{
b = 1;
a++;
}
}
return 0;
} | 0 | 37,554,901 |
#include"bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using pi = pair<int, int>;
const ll INF = 1LL << 60;
int main() {
ll l, r;
cin >> l >> r;
if (r - l > 2019)r = l + 2019;
int ans = ((l % 2019LL) * (l + 1) % 2019LL) % 2019LL;
for (int i = l; i < r; i++) {
for (int j = i + 1; j <= r; j++) {
ans = min(ans, ((i % 2019) * (j % 2019)) % 2019);
}
}
cout << ans << endl;
return 0;
} | #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>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main()
{
string s;
cin>>s;
int n=s.size();
set<P> st;
st.insert(P(0, 0));
int dp[200001];
int a[200001];
dp[0]=0;
a[0]=0;
for(int i=1; i<=n; i++){
a[i]=a[i-1]^(1<<(s[i-1]-'a'));
if(a[i]==0){
dp[i]=1;
st.insert(P(a[i], i));
continue;
}
dp[i]=dp[i-1]+1;
auto itr=st.upper_bound(P(a[i], 1e9));
itr--;
if((*itr).first==a[i]){
int i0=(*itr).second;
dp[i]=min(dp[i], dp[i0]+1);
}
for(int j=0; j<26; j++){
int a0=a[i]^(1<<j);
if(a0==0){
dp[i]=1;
break;
}
auto itr=st.upper_bound(P(a0, 1e9));
itr--;
if((*itr).first==a0){
int i0=(*itr).second;
dp[i]=min(dp[i], dp[i0]+1);
}
}
st.insert(P(a[i], i));
}
cout<<dp[n]<<endl;
return 0;
} | 0 | 55,420,902 |
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define rep(s,t) for (int s = 0; s < t; ++s);
using ll = long long;
int main() {
int k,x;
cin >> k >> x;
if (500 * k >= x){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
} | #include <cstdio>
#include <algorithm>
#include <string>
#include <iostream>
#define MAXN 150
#define MAXLEN 1000
using namespace std;
int c[MAXLEN+1][MAXLEN+1];
int getSubsequence(string x, string y){
int i = 0, j = 0;
while (i <= x.length()){
while (j <= y.length()){
if (i == 0 || j ==0){
c[i][j] = 0;
} else if (x[i-1] == y[j-1]){
c[i][j] = c[i-1][j-1] + 1;
} else if (x[i-1] != y[j-1]){
c[i][j] = max(c[i-1][j], c[i][j-1]);
}
++j;
}
++i;
j = 0;
}
return c[x.length()][y.length()];
}
int main(){
int n;
scanf("%d", &n);
string x, y;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
printf("%d\n", getSubsequence(x, y));
}
} | 0 | 36,739,174 |
#include<bits/stdc++.h>
using namespace std;
#define fast() ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define test() ll t; cin>>t; while(t--)
#define lp0(i,begin,end) for(ll i=begin;i<end;i++)
#define lp1(i,begin,end) for(ll i=begin;i<=end;i++)
#define rlp(i,begin,end) for(ll i=end;i>=begin;i--)
#define prec(n) fixed<<setprecision(n)
#define initial(a,i) memset(a,i,sizeof(a))
#define pb push_back
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define F first
#define S second
#define all(a) (a).begin(),(a).end()
#define BPC(x) __builtin_popcountll(x)
#define gcd(a,b) __gcd(a,b)
ll gcd(ll a,ll b) {if (a==0) return b;return gcd(b%a,a);}
ll power(ll x,ll n)
{
ll result = 1;
while (n)
{
if (n & 1)
result = result * x;
n = n / 2;
x = x * x;
}
return result;
}
void solution(ll compte)
{
ll n,m;
cin>>n>>m;
ll ans= ((n*(n-1))/2) + ((m*(m-1))/2);
cout<<ans<<"\n";
}
int main()
{
ll compte = 1;
solution(compte);
compte++;
return 0;
} | #include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#define ll long long
using namespace std;
int main(){
ll s,tmp;
ll x1,x2,y1,y2,x3,y3;
scanf("%lld",&s);
tmp=(ll)ceil(sqrt(s));
if(tmp*tmp==s){
printf("0 0 %lld 0 0 %lld\n",tmp,tmp);
return 0;
}
x2=tmp; y3=tmp;
tmp=tmp*tmp-s;
for(x3=1;;x3++){
if(tmp%x3==0&&tmp/x3<=1000000000LL){
y2=tmp/x3;
break;
}
}
printf("0 0 %lld %lld %lld %lld\n",x2,y2,x3,y3);
return 0;
} | 0 | 84,269,854 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long int;
int main () {
int N;
cin >> N;
int M = 0;
vector<int> h(N, 0);
rep(i, N) {
cin >> h[i];
M = max(h[i], M);
}
int ans = 0;
for (int i = 1; i <= M ; i++) {
bool flag = false;
for (int j = 0; j < N; j++) {
if (h[j] >= i) {
flag = true;
}
if ((h[j] < i || j == N - 1) && flag == true) {
ans++;
flag = false;
}
}
}
cout << ans;
} | #include <bits/stdc++.h>
#define PI acos(-1.0)
#define eps 1e-9
#define ll long long
#define ull unsigned long long
#define nl printf("\n")
#define sf scanf
#define pf printf
#define INF (ll)1e15
#define mod 1000000007
using namespace std;
const int S=123456;
int main()
{
#ifndef ONLINE_JUDGE
#endif
int n;
while(sf("%d",&n)==1)
{
int ara[n+5];
ara[0]=0;
for(int i=1;i<=n;i++)sf("%d",&ara[i]);
ara[n+1]=0;
int tot=0;
for(int i=1;i<=n+1;i++)
{
tot+=abs(ara[i]-ara[i-1]);
}
for(int i=1;i<=n;i++)
{
int cur=tot;
cur-=abs(ara[i]-ara[i-1]);
cur-=abs(ara[i]-ara[i+1]);
cur+=abs(ara[i-1]-ara[i+1]);
pf("%d\n",cur);
}
}
return 0;
} | 0 | 55,908,518 |
#include<iostream>
#include<vector>
#include<string>
#include<math.h>
#include<algorithm>
#include<cstring>
using namespace std;
int canReach[2][16001];
bool DP(vector<int> v,int t,int start){
memset(canReach,0,sizeof(canReach));
canReach[0][8000+start]=1;
if(v.size()==0)
return canReach[0][8000+t];
int i;
for(i=1;i<=v.size();i++){
for(int j=0;j<=16000;j++){
canReach[i%2][j]=((j+v[i-1])>16000?0:canReach[(i-1)%2][j+v[i-1]])||((j-v[i-1])<0?0:canReach[(i-1)%2][j-v[i-1]]);
}
}
return canReach[(i-1)%2][8000+t];
}
int main(){
string S;
int tx,ty;
cin>>S>>tx>>ty;
bool whichAxis=0;
vector<int> vx;
vector<int> vy;
int count=0;
int len=S.size();
char c;
for(int i=0; i<len; i++){
c=S[i];
if(c=='T'){
((whichAxis==0)?vx:vy).push_back(count);
count=0;
whichAxis=!whichAxis;
}
else{
count++;
}
}
((whichAxis==0)?vx:vy).push_back(count);
int start=vx[0];
vx.erase(vx.begin());
if(DP(vx,tx,start)&&DP(vy,ty,0))
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
string s;
cin >> s;
vector<char> v;
for (int i=0; i<4; i++) {
v.push_back(s[i]);
}
sort(v.begin(), v.end());
if (count(v.begin(), v.end(), v[0]) == 2 && count(v.begin(), v.end(), v[2]) == 2) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | 0 | 86,791,705 |
#include <stdio.h>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iomanip>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)n; i++)
#define ll long long
int main() {
int N, M;
cin >> N >> M;
vector<int> a(M),b(M),v(N-1);
rep(i,M){
cin >> a.at(i) >> b.at(i);
}
rep(i,N-1){
v.push_back(i+2);
}
bool flg;
int left, right, cnt=0;
while(1){
for(int i=0; i<N-1; i++){
flg = false;
if(i==0) left = 1;
else left = v.at(i-1);
right = v.at(i);
for(int j=0; j<M; j++){
if((left == a.at(j) && right == b.at(j))
|| (left == b.at(j) && right == a.at(j))){
flg = true;
break;
}
}
if(!flg) break;
}
if(flg) cnt++;
if(!next_permutation(v.begin(), v.end())) break;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ll n, X;
cin >> n >> X;
vector<ll> x(n), sa(n);
for (int i = 0; i < n; i++)
{
cin >> x[i];
sa[i] = abs(X - x[i]);
}
int r = accumulate(sa.begin(), sa.end(), 0, [](int m, int n) {
return gcd(m, n);
});
cout << r << endl;
return 0;
} | 0 | 54,687,028 |
# include <bits/stdc++.h>
typedef long long lint;
using namespace std;
lint gcd(lint x, lint y) {
if(x == 0) { return y; }
else { return gcd(y%x,x); }
}
lint lcm(lint x, lint y) { return x/gcd(x,y)*y; }
lint C(lint n, lint k) {
if(n == k) { return 1; }
else if(n < k) { return 0; }
else if(k == 0) { return 1; }
else if(k == 1) { return n; }
else return C(n-1,k-1) + C(n-1,k);
}
lint P(lint n, lint k) {
if(k == 1) { return n; }
return (n*(P(n-1,k-1)%1000000007)%1000000007);
}
int main() {
lint n,k; cin >> n >> k;
map<lint,lint> mp;
set<lint> st;
for(lint i=0;i<n;i++) {
lint a,b; cin >> a >> b;
mp[a] += b;
st.insert(a);
}
lint cnt=0, ans;
for(set<lint>::iterator itr=st.begin();itr!=st.end();itr++) {
cnt += mp[*itr];
if(cnt >= k) {
ans = *itr;
break;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<string> vs;
typedef pair<int, int> P;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
void YN(bool flg){if(flg) cout << "YES" << endl; else cout << "NO" << endl;}
void Yn(bool flg){if(flg) cout << "Yes" << endl; else cout << "No" << endl;}
void yn(bool flg){if(flg) cout << "yes" << endl; else cout << "no" << endl;}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main()
{
int x, n;
cin >> x >> n;
set<int> s;
rep(i, n) {
int a;
cin >> a;
s.insert(a);
}
int mi = 114514;
int ans = 114514;
rep(i, 102) {
if(s.find(i) != s.end()) continue;
if(mi > abs(x-i)) {
mi = abs(x-i);
ans = i;
}
}
cout << ans << endl;
return 0;
} | 0 | 6,920,112 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> p(51), b(51);
ll f(ll n, ll x) {
if (n >= x)
return 0;
if (n == 0) {
return 1;
}
if (x <= 1 + b[n-1])
return f(n-1, x-1);
if (x == (2 + b[n-1]))
return p[n-1] + 1;
if (x <= 2 + 2 * b[n-1])
return p[n-1] + 1 + f(n-1, x-2-b[n-1]);
return 2 * p[n-1] + 1;
}
int main() {
ll n; cin >> n;
ll x; cin >> x;
p[0] = b[0] = 1;
for (int i = 0; i < 50; i++) {
b[i+1] = b[i] * 2 + 3;
p[i+1] = p[i] * 2 + 1;
}
cout << f(n, x) << '\n';
return 0;
} | #include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <limits>
#include <random>
#include <complex>
#include <cmath>
#include <cstdio>
#include <cstdlib>
using namespace std;
typedef long long ll;
#define REP(i,n) for (int i = 0; i < n; i++)
template <class T> using reversed_priority_queue = priority_queue<T, vector<T>, greater<T> >;
struct Edge {
int to;
int dist;
Edge (int _t, int _d) {
to = _t;
dist = _d;
}
};
int N,M;
vector < Edge > G[100010];
map < int, ll > dist;
bool flag;
void dfs (int v, ll depth)
{
if (!flag) return;
if (dist.find(v) != dist.end() && dist[v] != depth) {
flag = false;
return;
}
if (dist.find(v) != dist.end() && dist[v] == depth) {
return;
}
dist[v] = depth;
REP(i,G[v].size()) {
dfs(G[v][i].to, G[v][i].dist + depth);
}
}
int main ()
{
cin >> N >> M;
REP(i,M) {
int L,R,D;
cin >> L >> R >> D;
G[L].push_back(Edge(R, D));
G[R].push_back(Edge(L, -D));
}
flag = true;
for (int i = 1; i <= N; i++) {
if (dist.find(i) == dist.end()) {
dfs(i, 0);
} else {
dfs(i, dist[i]);
}
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | 0 | 73,753,969 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FORR(i, a, b) for (int i = b - 1; i >= a; --i)
#define SORT(v) sort(v.begin(), v.end())
#define SORTR(v) sort(v.rbegin(), v.rend())
#define REV(v) reverse(v.begin(), v.end())
#define ITER(itr, v) for (auto itr = v.begin(); itr != v.end(); ++itr)
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define SZ(v) (int)v.size()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<vector<int>> s(M);
REP(i, M) {
int k;
cin >> k;
s[i].resize(k);
REP(j, k) {
cin >> s[i][j];
s[i][j]--;
}
}
vector<int> p(M);
REP(i, M) {
cin >> p[i];
}
int res = 0;
REP(bit, 1 << N) {
auto ok = [&]() {
REP(i, M) {
int sum = 0;
for (auto &k : s[i]) {
sum += (bit >> k & 1);
}
if (sum % 2 != p[i]) {
return 0;
}
}
return 1;
};
res += ok();
}
cout << res << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
bool judge (char c)
{
if (c=='y' || c=='u' || c=='i' || c=='o' || c=='p' || c=='h' || c=='j' || c=='k' || c=='l' || c=='n' || c=='m') return true;
else return false;
}
int main()
{
while (1)
{
int ans=0; bool hand;
string s; char c;
cin>>s;
if (s=="#") break;
c=s[0];
hand=judge(c);
for (int i=1; i<s.size(); i++)
{
c=s[i];
if (judge(c)!=hand) { ans++; hand=!hand; }
}
cout<<ans<<'\n';
}
return 0;
} | 0 | 43,639,604 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long m,n;
cin>>m>>n;
if(n==1 || m==1)
if(n*m>=2)
cout<<n*m-2;
else
cout<<'1';
else
cout<<(n-2)*(m-2);
} | #include <cstdio>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
using Weight=int;
using DArray=vector<Weight>;
using DMatrix=vector<DArray>;
static const Weight INF=1<<29;
struct Edge {
size_t src, dst;
Weight weight;
Edge() {}
Edge(size_t src, size_t dst, Weight weight=1):
src(src), dst(dst), weight(weight)
{}
};
bool operator<(const Edge &e, const Edge &f) {
if (e.weight != f.weight) {
return e.weight > f.weight;
} else {
return e.src!=f.src? e.src<f.src : e.dst<f.dst;
}
}
using Edges=vector<Edge>;
using Vertex=vector<Edge>;
using Graph=vector<Vertex>;
void join(Graph &g, size_t s, size_t d, Weight w=1) {
g[s].push_back(Edge(s, d, w));
g[d].push_back(Edge(d, s, w));
}
void connect(Graph &g, size_t s, size_t d, Weight w=1) {
g[s].push_back(Edge(s, d, w));
}
int main() {
size_t n;
scanf("%zu", &n);
Graph g(n);
for (size_t i=0; i<n; ++i) {
size_t k;
scanf("%*d %zu", &k);
for (size_t j=0; j<k; ++j) {
size_t v;
scanf("%zu", &v);
--v;
connect(g, i, v);
}
}
queue<size_t> q; q.push(0);
vector<size_t> d(n, -1); d[0]=0;
while (!q.empty()) {
size_t v=q.front(); q.pop();
for (Edge &e: g[v]) {
if (d[e.dst] > d[v] + 1) {
d[e.dst] = d[v] + 1;
q.push(e.dst);
}
}
}
for (size_t i=0; i<n; ++i)
printf("%zu %zd\n", i+1, d[i]);
return 0;
} | 0 | 17,760,516 |
#include<iostream>
using namespace std;
int main() {
string s;
int i;
int counter1 = 0, counter2 = 0;
cin >> s;
for (i = 0; i < s.size(); i++) {
if (i % 2 == 0) {
if (s[i] == '1') {
counter1++;
}
else {
counter2++;
}
}
else {
if (s[i] == '0') {
counter1++;
}
else {
counter2++;
}
}
}
if (counter1 < counter2) {
cout << counter1 << endl;
}
else {
cout << counter2 << endl;
}
return 0;
} | #include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <unordered_map>
#include <set>
typedef long long ll;
typedef long double ld;
#define FASTIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define PRECISION std::cout << std::fixed << std::setprecision(20);
using namespace std;
const ll inf = 1e18;
const ll N = 3e5;
const ll bits = 20;
const ld pi = 3.14159265358979323846;
const ll mod = 1e9+7;
const ll p = 29;
int main(){
FASTIO;
PRECISION;
int n,k;
cin>>n>>k;
if(n==0){
if(k==0)
cout<<0<<" "<<0<<"\n";
else
{
cout<<-1<<"\n";
}
}else if(n==1){
if(k==0){
cout<<0<<" "<<0<<" "<<1<<" "<<1<<"\n";
}else{
cout<<-1<<"\n";
}
}else{
if(k>=(1<<n)){
cout<<-1<<"\n";
return 0;
}
vector<int>b;
for(int i=0;i<(1<<n);i++){
if(i!=k)
b.push_back(i);
}
for(auto x: b){
cout<<x<<" ";
}
cout<<k<<" ";
reverse(b.begin(),b.end());
for(auto x: b){
cout<<x<<" ";
}
cout<<k<<" ";
}
} | 0 | 62,965,049 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
#define ll long long
#define ld long double
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
#define sz(x) ((int)(x).size())
#define chmin(x,y) x = min(x,y)
#define chmax(x,y) x = max(x,y)
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
int main()
{
int n,k;
cin >> n >> k;
if (k>(n-1)*(n-2)/2)
{
cout << -1 << endl;
return 0;
}
vector<P> vc;
for (int i = 2; i < n+1; i++)
{
vc.push_back(P{1,i});
}
int add = (n-1)*(n-2)/2-k;
for (int i = 2; i < n+1; i++)
{
for (int j = i+1; j < n+1; j++)
{
if (add==0)
{
break;
}
vc.push_back(P{i, j});
add--;
}
if (add == 0)
{
break;
}
}
cout << sz(vc) << endl;
rep(i,sz(vc))
{
cout << vc[i].first << " " << vc[i].second << endl;
}
} | #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <climits>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <algorithm>
#include <iostream>
#include <string>
#define REP(i,n) for(long long i=0;i<n;++i)
#define REPR(i,n) for(long long i=n;i>=0;--i)
#define REPI(itr,v) for(auto itr=v.begin();itr!=v.end();++itr)
#define REPIR(itr,v) for(auto itr=v.rbegin();itr!=v.rend();++itr)
#define FOR(i,a,b) for(long long i=a;i<b;++i)
#define SORT(v,n) sort(v, v+n)
#define SORTV(v) sort(v.begin(), v.end())
#define ALL(v) v.begin(),v.end()
#define llong long long
#define INF 999999999
#define MOD 1000000007
#define pb push_back
#define pf push_front
#define MP make_pair
#define SV(v) {for(long long sitr=0;sitr<v.size();++sitr){cin>>v[sitr];}}
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
using namespace std;
typedef pair<int,int> pii;
int main(){
llong n;
cin >> n;
map<int, int> mp;
for(llong i= 2; i * i <= n; ++i){
while(n % i == 0){
mp[i]++;
n /= i;
}
}
if(n != 1){
mp[n]++;
}
llong ans = 0;
REPI(itr, mp){
int cnt = 1;
while(cnt <= itr->second){
itr->second -= cnt;
cnt++;
ans++;
}
}
cout << ans << endl;
return 0;
} | 0 | 85,005,594 |
#pragma GCC optimize ("O3")
#include <iostream>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <queue>
#include <deque>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <utility>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <string>
#include <ctime>
#include <cctype>
#include <cstdlib>
#define INF 10e16
#define MOD 1000000007
#define mod 1000000007
#define rep(i, a, n) for (ll i = a; i < (ll)(n); i++)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define mmax(x,y)(x>y?x:y)
#define mmin(x,y)(x<y?x:y)
#define chmax(x,y) x=mmax(x,y)
#define chmin(x,y) x=mmin(x,y)
#define all(x) (x).begin(),(x).end()
#define siz(x) (ll)(x).size()
#define PI acos(-1.0)
using namespace std;
typedef long long int ll;
typedef pair<ll,ll>Pll;
typedef pair<int,int>Pin;
long long GCD(long long a, long long b) { return b ? GCD(b, a%b) : a; }
long long LCM(long long a, long long b) {return a/GCD(a,b)*b;}
int dx[8]={-1,0,1,0,1,1,-1,-1};
int dy[8]={0,-1,0,1,1,-1,1,-1};
char dir[4]={'u','l','d','r'};
ll cmp1(pair<ll,string>a,pair<ll,string> b){
if(a.fi!=b.fi)
return a.fi<b.fi;
else
return a.se<b.se;
}
vector<int>G[100001];
list<int> out;
bool V[100001];
int N;
int indeg[100001];
void bfs(int s){
queue<int>q;
q.push(s);
V[s]=1;
while(!q.empty()){
int u=q.front();q.pop();
out.pb(u);
for(int i=0;i<G[u].size();i++){
int v=G[u][i];
indeg[v]--;
if(indeg[v]==0&&!V[v]){
V[v]=1;
q.push(v);
}
}
}
}
void tsort(){
for(int i=0;i<N;i++){
indeg[i]=0;
}
for(int u=0;u<N;u++){
for(int i=0;i<G[u].size();i++){
indeg[G[u][i]]++;
}
}
for(int u=0;u<N;u++){
if(indeg[u]==0&&!V[u])bfs(u);
}
for(list<int>::iterator it=out.begin();it!=out.end();it++){
cout<<*it<<endl;
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int s,t,M;
cin>>N>>M;
for(int i=0;i<N;i++)V[i]=0;
for(int i=0;i<M;i++){
cin>>s>>t;
G[s].pb(t);
}
tsort();
return 0;
} | #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int road[16][16], a, b, point[16][16];
int main(){
while(scanf("%d%d", &a, &b) && a+b){
memset(road, 0, sizeof(road));
memset(point, 0, sizeof(point));
int n, x, y;
scanf("%d", &n);
rep(i, n){
scanf("%d%d", &x, &y); --x; --y;
point[y][x] = 1;
}
road[0][0] = 1;
REP(i, 1, a) if(!point[0][i]) road[0][i] = road[0][i-1];
REP(i, 1, b) if(!point[i][0]) road[i][0] = road[i-1][0];
REP(i, 1, b) REP(j, 1, a) if(!point[i][j]) road[i][j] = road[i-1][j] + road[i][j-1];
printf("%d\n", road[b-1][a-1]);
}
return 0;
} | 0 | 32,750,171 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int,int> ,null_type,less<pair<int,int>>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
typedef long long ll;
const int N = 1e5+10 , OO = 0x3f3f3f3f , mod = 1e9 + 7;
#define PI acos(-1)
#define clr(arr,val) memset(arr , val , sizeof (arr))
#define loop(i,n) for(int i = 0;i < int(n);i++)
#define rloop(i,n) for(int i = int(n)-1;i >= 0;i--)
#define xloop(i,a,b) for(int i = int(a);i <= int(b);i++)
#define range(vec) for(auto &x : vec) cin >> x;
#define ALL(v) ((v).begin()) , ((v).end())
#define SZ(v) ((int)((v).size()))
int dx[]={1,0,-1,0};int dy[]={0,1,0,-1};
int a,b,c,k;
int main()
{
scanf("%d %d %d %d", &a , &b , &c , &k);
ll sum = 0;
if(a >= k)
printf("%d\n", k);
else{
sum = a;
k -= a;
if(b >= k)
printf("%lld\n", sum);
else{
k -= b;
sum -= min(c , k);
printf("%lld\n", sum);
}
}
return 0;
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define cinf(n,x) for(int i=0;i<(n);i++)cin>>x[i];
#define ft first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(),(v).end()
#define mod 1000000007
using namespace std;
typedef long long ll;
template<class T> using V=vector<T>;
using Graph = vector<vector<int>>;
using P=pair<ll,ll>;
typedef unsigned long long ull;
typedef long double ldouble;
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=1e18;
signed main(){
ll n,k;
cin>>n>>k;
V<ll> a(n),s(n+1,0);
cinf(n,a);
rep(i,n) s[i+1]=s[i]+a[i];
map<ll,V<ll>> mp;
for(ll i=0;i<=n;i++) mp[(s[i]-i)%k].push_back(i);
ll ans=0;
for(auto p:mp){
ll m=p.sc.size();
for(int i=0;i<p.sc.size();i++){
ll now=p.sc[i];
ll x=ub(all(p.sc),now+k-1)-p.sc.begin();
ans+=x-i-1;
}
}
cout<<ans<<endl;
} | 0 | 86,296,376 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll = long long;
const int INF = 1001001001;
const ll INF_LL = 1001001001001001001LL;
int main(void){
int n,k; cin >> n >> k;
vector<int> l(n); rep(i,n) cin >> l[i];
sort(l.begin(),l.end());
reverse(l.begin(),l.end());
int ans = 0;
rep(i,k) ans += l[i];
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
vector<int> ve[N];
priority_queue<int> qe;
int n,m;
int main()
{
cin>>n>>m;
int x,y;
for(int i=0;i<n;i++)
{
cin>>x>>y;
if(m-x+1<1)
continue;
ve[m-x+1].push_back(y);
}
int sum=0;
for(int i=m;i>=1;i--)
{
for(int j=0;j<ve[i].size();j++)
qe.push(ve[i][j]);
if(!qe.empty())
sum+=qe.top(),qe.pop();
}
cout<<sum<<"\n";
} | 0 | 99,278,868 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n=0;
cin>>n;
for(long long i=0;i<n;i++){
long long test=n-i*100;
if(0<=test&&test<=5*i){
cout<<"1"<< endl;
return 0;
}
}
cout<<"0"<< endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int dp[67200000];
ll Hash[200002];
string S;
ll beki[28];
int moji(char in){
return (int)in - (int)'a';
}
int main() {
cin >> S;
S = "#" + S;
beki[0] = 1;
for(int i = 1; i < 28; i++){
beki[i] = beki[i - 1] * 2;
}
Hash[0] = 0;
for(int i = 1; i < S.size(); i++){
Hash[i] = Hash[i - 1] ^ beki[moji(S[i])];
}
for(int i = 0; i < 67200000; i++){
dp[i] = INF;
}
dp[0] = 0;
for(int i = 1; i < S.size(); i++){
int opt = dp[Hash[i]] + 1;
for(int j = 0; j < 26; j++){
opt = min(opt, dp[(Hash[i] ^ beki[j])] + 1);
}
dp[Hash[i]] = min(dp[Hash[i]], opt);
if(i + 1 == S.size()){
cout << opt << endl;
return 0;
}
}
return 0;
} | 0 | 35,499,044 |
#ifdef LOCAL_JUDGE
#define _GLIBCXX_DEBUG
#endif
#define WOULD
#define YOU
#define PLEASE
#define ACCEPT
#define MY
#define SUBMISSION
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <iomanip>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <math.h>
#include <cmath>
#include <bitset>
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; }
const long long INF = 100100100100;
const long long MOD = 1000000007;
typedef pair<double,int> P;
long long mod_pow(long long N, long long M) {
if (M == 0) return 1;
long long res = mod_pow((N * N) % MOD, M / 2);
if (M & 1) res = (res * N) % MOD;
return res %= MOD;
}
long long nCr(long long n, long long r) {
long long A = 1, B = 1;
for (long long i = n - r + 1; i <= n; i++) {
A = A * i % MOD;
}
for (long long i = 1; i <= r; i++) {
B = B * i % MOD;
}
B = mod_pow(B, MOD - 2);
B %= MOD;
return (A * B) % MOD;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
else return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
return a * b / gcd(a, b);
}
bool ok(long long key,long long index){
if(index > key) return true;
else if(index <= key) return false;
}
long long binary_search(long long key,long long size){
long long left = -1,right = size;
while(right - left > 1){
long long mid = left + (right-left)/2;
long long hantei = ok(key,mid);
if(hantei) right = mid;
else left = mid;
}
if(left == -1)return 0;
return left;
}
int main() {
int x,y,X,Y;cin >> x >> y >> X >> Y;
int a = X - x;int b = Y - y;
cout << X - b << " " << Y + a << " " << x - b << " " << y + a << endl;
} | #include <bits/stdc++.h>
using namespace std;
bool prime[1000005];
int dp[100][100];
int f(int a, int b) {
if (a == 0) {
return 0;
}
if (b > a)
return 0;
if (dp[a][b] != -1) return dp[a][b];
return dp[a][b] = max(f(a,b+1), f(a-b, b+1)+1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int64_t N;
cin >> N;
fill(prime, prime+1000005, 1);
prime[0] = prime[1] = 0;
for (int64_t p = 2; p <= 1000000; ++p) if (prime[p]) {
for (int64_t m = p*p; m <= 1000000; m += p) {
prime[m] = 0;
}
}
memset(dp, -1, sizeof dp);
map<int, int> facts;
int64_t num = N;
for (int64_t p = 2; p*p <= N; ++p) if (prime[p]) {
while (num%p == 0) {
num /= p;
facts[p]++;
}
}
if (num > 1) {
facts[num]++;
}
int64_t ans = 0;
for (auto kv : facts) {
ans += f(kv.second, 1);
}
cout << ans << endl;
} | 0 | 65,231,472 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
#include <queue>
using namespace std;
int main(){
int V, E;
cin >> V >> E;
vector<vector<int>> edge(V);
vector<int> count_in(V);
for(int i = 0; i < V; i++){
count_in[i] = 0;
}
int s, t;
for(int i = 0; i < E; i++){
cin >> s >> t;
edge[s].emplace_back(t);
count_in[t]++;
}
queue<int> q;
for(int i = 0; i < V; i++){
if(count_in[i] == 0){
q.push(i);
}
}
vector<int> ans;
while(!q.empty()){
int temp = q.front();
q.pop();
if(count_in[temp] == 0){
ans.emplace_back(temp);
for(int i = 0; i < (int)edge[temp].size(); i++){
int to = edge[temp][i];
count_in[to]--;
if(count_in[to] == 0){
q.push(to);
}
}
}
}
for(int i = 0; i < V; i++){
cout << ans[i] << "\n";
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define in(a) ll a; cin>>a;
#define in2(a,b) ll a,b; cin>>a>>b;
#define in3(a,b,c) ll a,b,c; cin>>a>>b>>c;
#define in4(a,b,c,d) ll a,b,c,d; cin>>a>>b>>c>>d;
#define in5(a,b,c,d,e) ll a,b,c,d,e; cin>>a>>b>>c>>d>>e;
#define lelo(b) for(auto &i:b)cin>>i;
#define ff first
#define ss second
#define call(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define show(x) for(auto t:x)cout<<t<<" ";
#define pb push_back
#define bhar(s,v) memset(s,v,sizeof(s))
#define endl "\n"
#define ce(x) cout<<x<<"\n";
#define nl cout<<endl;
#define jaldi ios_base::sync_with_stdio(false);cin.tie(NULL);
#define dekh_lo ce("dekh_lo");
#define sz(x) (ll)x.size()
#define re return
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
typedef pair<ll,ll> pii;
typedef vector<pii> vii;
typedef vector<ll> vi;
const ll mod=1e9+7;
const ll N=4e5+5;
ll i,j;
void solve(){
in2(n,k);
vi a(n+1);
for(i=1;i<=n;i++){
cin>>a[i];
}
ll dp[n+1][k+1];
dp[0][0]=1;
for(i=1;i<=k;i++){
dp[0][i]=0;
}
for(i=1;i<=n;i++){
vi sum(k+1);
sum[0]=dp[i-1][0];
for(j=1;j<=k;j++){
sum[j]=(sum[j-1]+dp[i-1][j])%mod;
}
for(j=0;j<=k;j++){
if(j<=a[i]){
dp[i][j]=sum[j];
}
else{
ll non=j-a[i]-1;
dp[i][j]=(sum[j]-sum[non]+mod)%mod;
}
}
sum.clear();
}
ce(dp[n][k]);
}
int32_t main(){
ll t;
t=1;
while(t--){
solve();
}
} | 0 | 93,393,737 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int p = 1;
long long cnt = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a == p) p++;
else if (p < a) {
cnt += (long long)(a - 1) / p;
if (p == 1) p++;
}
}
cout << cnt << endl;
} | #include<iostream>
using namespace std;
int main(){
string s,t;
cin >> s;
cin >> t;
if(s.size() != t.size()){
return 0;
}else{
int cnt = 0;
for(int i = 0;i < s.size();i++){
if(s[i] != t[i]){
cnt++;
}
}
cout << cnt << endl;
}
} | 0 | 77,296,257 |
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<map>
#include<tuple>
#define rep(index,num) for(int index=0;index<num;index++)
#define rep1(index,num) for(int index=1;index<=num;index++)
#define scan(argument) cin>>argument
#define prin(argument) cout<<argument<<endl
#define kaigyo cout<<endl
#define eps 1e-15
#define mp(a1,a2) make_pair(a1,a2)
#define YMAX 250001
typedef long long ll;
using namespace std;
typedef pair<ll,ll> pll;
typedef pair<int,int> pint;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<pint> vpint;
typedef vector<pll> vpll;
ll INFl=1e+18+1;
int INF=1e+9+1;
int main(){
string S;
scan(S);
if(S[0]=='Y'&&S[1]=='A'&&S[2]=='K'&&S[3]=='I'){
prin("Yes");
}
else{
prin("No");
}
return 0;
} | #include <iostream>
#include <vector>
#include <cmath>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define FOR(i, m, n) for(int i = m; i < n; 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))
typedef long long ll;
int main(){
int n;
cin>>n;
vector<int> d(n);
REP(i,n){
cin>>d[i];
}
int sum=0;
REP(i,n-1){
FOR(j,i+1,n){
sum+=d[i]*d[j];
}
}
cout<<sum;
return 0;
} | 0 | 8,388,332 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
cout<<(t)*(t+1)/2<<"\n";
} | #include<bits/stdc++.h>
using namespace std;
int LevenshteinDistance(string s1, string s2){
int d[s1.length() + 1][s2.length() + 1];
for(int i = 0; i <= s1.length(); i++) d[i][0] = i;
for(int i = 0; i <= s2.length(); i++) d[0][i] = i;
for(int i = 1; i <= s1.length(); i++){
for(int j = 1; j <= s2.length(); j++){
int cost;
if(s1[i - 1] == s2[j - 1]) cost = 0;
else cost = 1;
d[i][j] = min(d[i - 1][j] + 1, min(d[i][j - 1] + 1, d[i - 1][j - 1] + cost));
}
}
return d[s1.length()][s2.length()];
}
int main(){
string s1, s2;
cin >> s1 >> s2;
cout << LevenshteinDistance(s1, s2) << endl;
return 0;
} | 0 | 19,020,592 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(m);
for (int i = 0; i < m; i++)
cin >> a[i];
vector<int> dp(n+1, -1);
for (int i = 0; i < m; i++)
dp[a[i]] = 0;
if(dp[0]!=0)
dp[0] = 1;
if(dp[1]!=0)
dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (dp[i] != 0) {
dp[i] = dp[i - 1] + dp[i - 2];
if (dp[i] > 1000000007)
dp[i] %= 1000000007;
}
}
cout << dp[n] << endl;
} | #include<iostream>
using namespace std;
typedef struct DICE{
int s[6];
}dice;
dice dice_rotate(dice d, char rotate){
int swap;
if(rotate == 'E'){
swap = d.s[2];
d.s[2] = d.s[0];
d.s[0] = d.s[3];
d.s[3] = d.s[5];
d.s[5] = swap;
}else if(rotate == 'N'){
swap = d.s[4];
d.s[4] = d.s[0];
d.s[0] = d.s[1];
d.s[1] = d.s[5];
d.s[5] = swap;
}else if(rotate == 'S'){
swap = d.s[1];
d.s[1] = d.s[0];
d.s[0] = d.s[4];
d.s[4] = d.s[5];
d.s[5] = swap;
}else if(rotate == 'W'){
swap = d.s[3];
d.s[3] = d.s[0];
d.s[0] = d.s[2];
d.s[2] = d.s[5];
d.s[5] = swap;
}
return d;
}
int main(){
dice d,proto;
char rotate;
int i,j,q,top,flont;
for(i=0;i<6;i++){
cin >> d.s[i];
}
proto = d;
cin >> q;
for(j=0;j<q;j++){
d = proto;
cin >> top;
cin >> flont;
i=0;
while(d.s[0] != flont){
if(i%2==0){
d = dice_rotate(d, 'S');
}else if(i%2==1){
d = dice_rotate(d, 'E');
}
i++;
}
d = dice_rotate(d, 'S');
while(d.s[0] != top){
d = dice_rotate(d, 'E');
}
cout << d.s[2] << endl;
}
return 0;
} | 0 | 58,984,288 |
#include <bits/stdc++.h>
using namespace std;
struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define VV(type, c, m, n, i) vector<vector<type>> c(m, vector<type>(n, i));
#define rep(i,a,n) for(int i=(a), i##_len=(n); i<i##_len; ++i)
#define rrep(i,a,n) for(int i=(a); i>n; --i)
#define len(x) ((int)(x).size())
#define mp make_pair
#define eb emplace_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long long> vll;
typedef vector<string> vs;
typedef vector<bool> vb;
int main() {
int H, W;
while(true) {
cin >> H >> W;
if (H == 0 && W == 0) break;
string fl = "", ne = "#";
rep(i, 0, W) fl += "#";
rep(i, 0, W - 2) ne += ".";
ne += "#";
P(fl);
rep(i, 0, H - 2) P(ne);
P(fl);
P("");
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
if (s[0] == 'S') {
if (s[1] == 'S') {
if (s[2] == 'S') cout << 0;
else cout << 1;
} else {
if (s[2] == 'S') cout << 1;
else cout << 2;
}
} else {
if (s[1] == 'S') {
if (s[2] == 'S') cout << 1;
else cout << 1;
} else {
if (s[2] == 'S') cout << 2;
else cout << 3;
}
}
} | 0 | 63,715,493 |
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define BIL ((ll)1e9)
#define MOD ((ll)1e9+7)
#define INF (1LL<<60)
#define inf (1<<29)
int main(int argc,char* argv[]){
int n;
cin >> n;
vector<pii> at(n);
for(int i=0;i<n;i++){
int j;
cin >> j;
at[i].first=j;
at[i].second=i+1;
}
sort(at.begin(),at.end());
for(auto x:at){
cout << x.second << " ";
}
cout << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define inf INT_MAX
#define INF LLONG_MAX
#define ll long long
#define ull unsigned long long
#define M (int)(1e9+7)
#define P pair<int,int>
#define PLL pair<ll,ll>
#define FOR(i,m,n) for(int i=(int)m;i<(int)n;i++)
#define RFOR(i,m,n) for(int i=(int)m;i>=(int)n;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n,0)
#define all(a) a.begin(),a.end()
#define IN(a,n) rep(i,n){ cin>>a[i]; }
const int vx[4] = {0,1,0,-1};
const int vy[4] = {1,0,-1,0};
#define PI 3.14159265
#define F first
#define S second
#define PB push_back
#define EB emplace_back
#define int ll
#define vi vector<int>
#define IP pair<int,P>
#define PP pair<P,P>
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(20);
int n;
cin>>n;
int l=0,r=n;
string sl,sr;
cout<<0<<endl;
cin>>sl;
if(sl=="Vacant"){
return 0;
}
cout<<n-1<<endl;
cin>>sr;
if(sr=="Vacant"){
return 0;
}
while(true){
int m=(r+l)/2;
string s;
cout<<m<<endl;
cin>>s;
if(s=="Vacant"){
return 0;
}
if((m-l)%2==0&&sl!=s||(m-l)%2&&sl==s){
sr=s;
r=m;
}else{
sl=s;
l=m;
}
}
} | 0 | 80,314,462 |
#include <bits/stdc++.h>
#define REP(i, n) for (int (i) = 0; (i) < (int)(n); i++)
#define FOR(i, a, b) for(int (i) = a; (i) < (int)b; i++)
#define RREP(i, n) for(int (i)=((int)(n)-1); (i)>=0; i--)
#define RFOR(i, a, b) for(int (i) =((int)(b)-1); (i)>=(int)a; i--)
#define ALL(v) (v).begin(),(v).end()
#define MOD 1000000007
#define FI first
#define SE second
#define MP make_pair
#define PB push_back
#define SZ(x) (int)x.size()
#define SP(x) setprecision((int)x)
using namespace std ;
typedef long long ll;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<string> vstr;
typedef pair<int, int> pii;
const int INF = 1e9;
const ll LINF = 1e18;
const double EPS = 1e-9;
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;}
int main()
{
ll n, k ;
cin >> n >> k ;
ll cnt1 = 0 ;
ll cnt2 = 0 ;
ll mod = 1000000007 ;
ll ans ;
vector<int> vec(n) ;
REP(i,n){
cin >> vec.at(i) ;
}
REP(i,n-1){
FOR(j,i+1,n){
if(vec.at(i)>vec.at(j)){
cnt1++ ;
}
}
}
for(int i=n-1; i>=1; i--){
for(int j=i-1; j>=0; j--){
if(vec.at(i)>vec.at(j)){
cnt2++ ;
}
}
}
ans = (k*(k+1)/2%mod*cnt1%mod+k*(k-1)/2%mod*cnt2%mod)%mod ;
cout << ans <<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>;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
long long res = 0;
int right = 0;
int sum = 0;
for (int left = 0; left < n; ++left) {
while (right < n && (sum ^ a[right]) == (sum + a[right])) {
sum += a[right];
++right;
}
res += right - left;
sum -= a[left];
}
cout << res << endl;
} | 0 | 42,434,346 |
#include <stdio.h>
int main(){
int X;
int Y;
scanf("%d %d",&X,&Y);
printf("%d\n",6-X-Y);
return 0;
} | #include<iostream>
#include<iomanip>
#include<algorithm>
#include<bitset>
#include<cstdio>
#include<cmath>
#include<deque>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<sstream>
#include<stack>
#include<string>
#include<tuple>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<vector<long long>> vvll;
typedef vector<vector<int>> vvi;
#define rep(i, a, n) for(int i=a; i<n; i++)
#define REP(i, n) for(int i=0; i<(int)(n); i++)
#define REPS(i, n) for(int i=1; i<=(int)(n); i++)
#define PER(i, n) for(int i=(int)(n)-1; i>= 0; i--)
#define PERS(i, n) for(int i=(int)(n); i>0; i--)
#define FOR(i, c) for(__typeof((c).begin()) i = (c).begin(); i!=(c).end(); i++)
#define RFOR(i, c) for(__typeof((c).rbegin()) i=(c).rbegin(); i!=(c).end(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) (container).size()
#define FILL0(n) setfill('0') << right << setw(n)
#define mp(a, b) make_pair(a, b)
#define toLower(c) c+0x20
#define toUpper(c) c-0x20
#define pb push_back
#define eb emplace_back
const int INF = 1e9;
const long long LLINF = 1e18;
const ull MOD = 998244353;
const int MSIZE = 100007;
const double Pi = 3.14159265358979323146;
int main(){
int match[10] = {6,2,5,5,4,5,6,3,7,6};
int n, m; cin >> n >> m;
vector<int> num(m), dp(n+100, -INF);
REP(i, m){
cin >> num[i];
}
dp[0]=0;
sort(RALL(num));
string ans = "";
for(int i=1; i<=n; i++){
REP(j, m){
if(i-match[num[j]]<0) continue;
dp[i] = max(dp[i], dp[i-match[num[j]]]+1);
}
}
while(n>0){
REP(j, m){
if(n-match[num[j]]<0) continue;
if(dp[n-match[num[j]]]==dp[n]-1){
ans += ('0'+num[j]);
n-=match[num[j]];
break;
}
}
}
cout << ans << endl;
} | 0 | 20,309,416 |
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define codefor int test;scanf("%d",&test);while(test--)
#define yn(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YN(ans) if(ans)printf("YES\n");else printf("NO\n")
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
const int MOD=1000000007;
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
vector<long long int> fibo(100001,-1);
long long int fibonatti(long long int n){
if(fibo[n]!=-1){
return fibo[n];
}else if(n==0){
fibo[0]=1;
return 1;
}else if(n==1){
fibo[1]=1;
return 1;
}else if(n>=2){
fibo[n]=(fibonatti(n-1)+fibonatti(n-2))%MOD;
return fibo[n];
}
}
int main(){
ll n,m;
in(n,m);
vector<int> vec(m);
in(vec);
fibonatti(100000);
vec.push_back(n+1);
ll target=0,ans=1,d=0;
rep(i,m+1){
if(i==0)target=vec[i]-1;
else target=vec[i]-vec[i-1]-2;
if(target==-1){
ans=0;
break;
}
d=0;
if(target==0)d=1;
else if(target==1)d=1;
else if(target==2)d=2;
else if(target>=3){
d=fibo[target];
}
ans*=d;
if(ans>MOD)ans%=(ll)MOD;
}
out(ans);
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
const int nmax=1000010;
ll fact[nmax],finv[nmax],inv[nmax];
void inicom(){
fact[0]=fact[1]=1;
finv[0]=finv[1]=1;
inv[1]=1;
for (int i = 2; i < nmax; i++){
fact[i]=fact[i-1]*i%mod;
inv[i]=mod-inv[mod%i]*(mod/i)%mod;
finv[i]=finv[i-1]*inv[i]%mod;
}
}
ll com(int n,int k){
if(n<k||n<0||k<0) return 0;
return fact[n]*(finv[k]*finv[n-k]%mod)%mod;
}
int main(){
inicom();
int X,Y; cin>>X>>Y;
if((X+Y)%3!=0){
cout<<0<<endl;
return 0;
}
ll n=(2*Y-X)/3,m=(2*X-Y)/3;
cout<<com(n+m,n)<<endl;
} | 0 | 62,589,238 |
#include<cstdio>
long long a[100005];
long long upper[100005], lower[100005];
long long power[100005];
long long count[100005];
long long min(long long a,long long b){ return a>b?b:a; }
int main(){
int n;
scanf("%d",&n);
for(int i = 0; i <= n; i++) scanf("%lld",&a[i]);
upper[n] = 0;
for(int i = n-1; i >= 0; i--){
upper[i] = upper[i+1]+a[i+1];
}
count[0] = 1-a[0];
int ok = 1; long long ans = 1;
if(count[0]>upper[0] || a[0]>1) ok = 0;
for(int i = 1; i <= n; i++){
if(2*count[i-1]<a[i]){
ok = 0;
break;
}
else{
count[i] = min(upper[i],2*count[i-1]-a[i]);
ans += count[i]+a[i];
}
}
if(!ok) printf("-1\n");
else printf("%lld\n",ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int arr[3] = {0};
string s;
cin >> s;
for (char t : s){
if (t == 'a')
arr[0] ++;
if (t == 'b')
arr[1] ++;
if (t == 'c')
arr[2] ++;
}
int pr = 1;
for (int i = 0; i < 3; i ++)
pr *= arr[i];
if (pr == 1)
cout << "Yes";
else
cout << "No";
return 0;
} | 0 | 17,216,363 |
#include <bits/stdc++.h>
#define GET_REP(_1, _2, _3, NAME, ...) NAME
#define rep(...) GET_REP(__VA_ARGS__, irep, _rep)(__VA_ARGS__)
#define rep1(...) GET_REP(__VA_ARGS__, irep1, _rep1)(__VA_ARGS__)
#define _rep(i, n) irep (i, 0, n)
#define _rep1(i, n) irep1(i, 1, n)
#define irep(i, a, n) for (int i = a; i < (int)(n); ++i)
#define irep1(i, a, n) for (int i = a; i <= (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define rrep1(i, n) for (int i = (int)(n); i >= 1; --i)
#define allrep(X, x) for (auto &&X : x)
#define all(x) begin(x), end(x)
#ifdef LOCAL
#include "../../Lib/cout_container.hpp"
#define debug(x) cout << #x " => " << (x) << endl
#else
#define debug(x) 0
#endif
using lint = long long;
constexpr int INF = 1 << 28;
constexpr lint INFL = 1LL << 60;
constexpr int MOD = (int)1e9 + 7;
constexpr double EPS = 1e-9;
using namespace std;
namespace { struct INIT { INIT() { cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(15); } } INIT; }
int main(void) {
int n, k;
cin >> n >> k;
vector<pair<int, int>> td(n);
rep (i, n) cin >> td[i].first >> td[i].second;
unordered_map<int, int> neta_max;
rep (i, n) neta_max[td[i].first] = max(neta_max[td[i].first], td[i].second);
sort(all(td), [](pair<int, int> &a, pair<int, int> &b) { return a.second > b.second; });
unordered_map<int, int> neta_num;
lint sum = 0;
rep (i, k) {
sum += td[i].second;
++neta_num[td[i].first];
}
lint num = neta_num.size();
lint maxi = sum + num * num;
allrep (p, neta_num) neta_max.erase(p.first);
vector<int> left(neta_max.size());
auto itr = neta_max.begin();
rep (i, left.size()) {
left[i] = itr->second;
++itr;
}
sort(all(left), greater<int>());
int now = k - 1;
rep (i, left.size()) {
while (now >= 0 && neta_num[td[now].first] <= 1) --now;
if (now < 0) break;
sum = sum - td[now].second + left[i];
++num;
maxi = max(maxi, sum + num * num);
--neta_num[td[now].first];
--now;
}
cout << maxi << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <unordered_map>
#include <vector>
const int mod = 1e9 + 7;
const int kmax = 510000;
const int last_days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
long long fact[kmax], fact_inv[kmax], inv[kmax];
void init_comb()
{
fact[0] = fact[1] = 1;
fact_inv[0] = fact_inv[1] = 1;
inv[1] = 1;
for (int i = 2; i < kmax; i++) {
fact[i] = fact[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fact_inv[i] = fact_inv[i - 1] * inv[i] % mod;
}
}
long long comb(int n, int r)
{
if (n < r) {
return 0;
}
if (n < 0 || r < 0) {
return 0;
}
return fact[n] * (fact_inv[r] * fact_inv[n - r] % mod) % mod;
}
template <typename T, T N>
class UnionFind {
T parent_[N];
T rank_[N];
T size_[N];
public:
UnionFind();
T Root(T idx);
bool IsSame(T x, T y);
void Unite(T x, T y);
T GetSize(T idx);
};
template <typename T, T N>
UnionFind<T, N>::UnionFind()
{
for (T i = 0; i < N; i++) {
parent_[i] = i;
rank_[i] = 0;
size_[i] = 1;
}
}
template <typename T, T N>
T UnionFind<T, N>::Root(T idx)
{
return parent_[idx] == idx ? idx : parent_[idx] = Root(parent_[idx]);
}
template <typename T, T N>
bool UnionFind<T, N>::IsSame(T x, T y)
{
return Root(x) == Root(y);
}
template <typename T, T N>
void UnionFind<T, N>::Unite(T x, T y)
{
x = Root(x);
y = Root(y);
if (x == y) {
return;
}
if (rank_[x] < rank_[y]) {
parent_[x] = y;
size_[y] += size_[x];
} else {
parent_[y] = x;
size_[x] += size_[y];
if (rank_[x] == rank_[y]) {
rank_[x]++;
}
}
}
template <typename T, T N>
T UnionFind<T, N>::GetSize(T idx)
{
return size_[Root(idx)];
}
long long pow_mod(long long n, long long p, long long m)
{
if (p == 0) {
return 1;
}
if (p % 2 == 0) {
long long t = pow_mod(n, p / 2, m);
return t * t % m;
}
return n * pow_mod(n, p - 1, m) % mod;
}
long long nCr_mod(long long n, long long r)
{
long long x = 1;
for (long long i = n - r + 1; i <= n; i++) {
x *= i;
x %= mod;
}
long long a = 1;
for (long long i = 1; i <= r; i++) {
a *= i;
a %= mod;
}
long long y = pow_mod(a, mod - 2, mod) % mod;
return x * y % mod;
}
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;
}
bool is_leap(long long y)
{
return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}
void next_day(long long& y, long long& m, long long& d)
{
d++;
if (d > last_days[m - 1] + (m == 2 && is_leap(y) ? 1 : 0)) {
d = 1;
m++;
}
if (m > 12) {
y++;
m = 1;
}
}
long long fib(long long n)
{
long long a = 0, b = 1;
for (int i = 0; i < n; i++) {
long long t = a;
a = b;
b = a + t;
}
return a;
}
int main()
{
long long n;
std::cin >> n;
std::vector<long long> a(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
std::vector<long long> b(n);
for (int i = 0; i < n; i++) {
std::cin >> b[i];
}
std::priority_queue<long long> q;
long long s = 0;
long long q_sum = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] - b[i] >= 0) {
q.push(a[i] - b[i]);
q_sum += a[i] - b[i];
} else {
s += b[i] - a[i];
ans++;
}
}
if (s > q_sum) {
std::cout << -1 << std::endl;
return 0;
}
while (s > 0) {
s -= q.top();
q.pop();
ans++;
}
std::cout << ans << std::endl;
} | 0 | 87,640,918 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i, n) FOR(i,0,n)
int main(void){
ll N,M;
cin >> N >> M;
vector<ll> H(N+10);
vector<ll> ma(N+10);
FOR(i,1,N+1){
cin >> H[i];
ma[i] = 0;
}
ll ans = 0;
REP(i,M){
ll A,B;
cin >> A >> B;
ma[A] = max(ma[A],H[B]);
ma[B] = max(ma[B],H[A]);
}
FOR(i,1,N+1) if(H[i] > ma[i]) ans++;
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int N,sum,var;
sum=0;
var=0;
cin>>N;
int Wgt[N];
if(N>=2&&N<=100){
for(int i=0;i<N;i++)
{
cin>>Wgt[i];
sum=sum+Wgt[i];
}
int tot=sum;
for(int i=0;i<N;i++)
{
var=var+Wgt[i];
tot=min(tot,abs(var-(sum-var)));
}
cout<<tot;
}
return 0;
} | 0 | 87,780,157 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int INF = 1000000009;
int main()
{
int h,w,a,b;
std::cin >> h >> w >> a >> b;
int v[h][w];
rep(i,h){
rep(j,w){
v[i][j] = ((i < b && j < a) || (i >= b && j >= a)) ? 0 :1;
}
}
rep(i,h){
rep(j,w){
std::cout << v[i][j];
}
std::cout << std::endl;
}
} | #include<iostream>
#include<iomanip>
#include<cstdio>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<string>
#include<algorithm>
#include<cmath>
#include<numeric>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return 1;} return 0;}
template <class T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return 1;} return 0;}
int main() {
int N, K; cin >> N >> K;
vector<ll> x(N), y(N);
for (int i = 0; i < N; i++) cin >> x[i] >> y[i];
ll res = 5e18;
for (int i = 0; i < N; i++) {
for (int j = i+1; j < N; j++) {
int s = min(x[i],x[j]), t = max(x[i],x[j]);
vector<ll> z = {};
for (int k = 0; k < N; k++) {
if (s <= x[k] && x[k] <= t) z.push_back(y[k]);
}
if (z.size() < K) continue;
sort(z.begin(),z.end());
for (int k = 0; k < z.size()-K+1; k++) {
chmin(res, (t-s)*(z[k+K-1]-z[k]));
}
}
}
cout << res << endl;
} | 0 | 85,300,697 |
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long ll;
const int MOD = 1000000007;
const int INF_32 = 1LL << 30;
const int64_t INF_64 = 1LL << 60;
int main()
{
int N, K;
cin >> N >> K;
vector<int> h(N + 200);
vector<int> dp(N + 200, INF_32);
for (int i = 0; i < N; i++) {
cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < N - 1; i++) {
for (int j = 1; j <= K; j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i + j] - h[i]));
}
}
cout << dp[N - 1] << endl;
return 0;
} | #include <iostream>
#include <string>
#include <sstream>
#include <queue>
using namespace std;
struct dot{
long long int k,p,l,r;
};
int main(int argc, char** argv) {
int n;
while(cin>>n){
dot p[n+100];
for(int i=1;i<=n;i++){
cin>>p[i].k;
if(i/2)
p[i].p=i/2;
else
p[i].p=0;
if(i*2<=n)
p[i].l=i*2;
else
p[i].l=0;
if(i*2+1<=n)
p[i].r=i*2+1;
else
p[i].r=0;
}
for(int i=1;i<=n;i++){
cout<<"node "<<i<<": key = "<<p[i].k<<", ";
if(p[i].p>0)
cout<<"parent key = "<<p[p[i].p].k<<", ";
if(p[i].l>0)
cout<<"left key = "<<p[p[i].l].k<<", ";
if(p[i].r>0)
cout<<"right key = "<<p[p[i].r].k<<", ";
cout<<endl;
}
}
return 0;
} | 0 | 95,421,169 |
#include<iostream>
#include<iomanip>
using namespace std;
int main(){
int a,b;
double f;
cin >> a >> b;
f=1.0*a/b;
cout << a/b << " " << a%b << " " << fixed << setprecision(10) << f << endl;
} | #include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
struct DATA{
int time;
int log;
};
int GetTime(const string);
int AtoiString(const string);
bool Compare(const DATA&, const DATA&);
int main(){
int i, n, count, _count;
string s, t;
DATA _data;
vector<DATA> data;
while(1){
cin >> n;
if(n == 0) break;
for(i=0; i<n; ++i){
cin >> s >> t;
_data.time = GetTime(s);
_data.log = 1;
data.push_back(_data);
_data.time = GetTime(t);
_data.log = -1;
data.push_back(_data);
}
sort(data.begin(), data.end(), Compare);
for(i=0, count=0, _count=0; i<data.size(); ++i){
_count += data[i].log;
if(count < _count) count = _count;
}
cout << count << endl;
data.clear();
}
return 0;
}
int GetTime(const string str){
string s, t, u;
copy(str.begin(), str.begin()+2, back_inserter(s));
copy(str.begin()+3, str.begin()+5, back_inserter(t));
copy(str.begin()+6, str.end(), back_inserter(u));
return AtoiString(s) * 3600 + AtoiString(t) * 60 + AtoiString(u);
}
int AtoiString(const string s){
int i, x, d;
for(i=s.size()-1, x=0, d=1; i>=0; --i, d*=10)
x += ((s[i] - 48) * d);
return x;
}
bool Compare(const DATA& x, const DATA& y){
if(x.time == y.time)
return x.log < y.log;
else
return x.time < y.time;
} | 0 | 85,997,495 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int u32;
typedef pair<int, int> p;
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 Inf = (1<<30);
ll inf = (1LL<<60);
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; }
int main() {
ll n, m;
cin >> n >> m;
ll ans = 0;
ll T = min(n, m / 2);
ans += T;
n -= T;
m -= T * 2;
ans += m / 4;
cout << ans;
return 0;
} | #include<iostream>
using namespace std;
int main(){
int a,b;
int count;
while(1){
count = 0;
cin >> a;
if( a == 0) break;
b = 1000 - a;
a = b%500;
count = count + b/500;
b= a%100;
count = count + a/100;
a = b%50;
count = count + b/50;
b = a%10;
count = count + a/10;
a = b%5;
count = count + b/5;
b = a%1;
count = count + a/1;
cout << count <<endl;
}
return 0;
} | 0 | 25,775,199 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vl vector<ll>
#define vi vector<int>
#define pi pair<int,int>
#define pl pair<ll,ll>
#define all(a) a.begin(),a.end()
#define mem(a,x) memset(a,x,sizeof(a))
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define endl "\n"
#define rep(i,a,b) for(int i=a;i<b;i++)
#define fast_io std::ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
#define trace(...) ZZ(#__VA_ARGS__, __VA_ARGS__);
template <typename Arg1> void ZZ(const char* name, Arg1&& arg1) {std::cerr << name << " = " << arg1 << endl;}
template <typename Arg1, typename... Args>void ZZ(const char* names, Arg1&& arg1, Args&&... args)
{
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1;
ZZ(comma, args...);
}
const ll MOD = 1e9 + 7;
void solve() {
int n;
cin >> n;
vl a(n + 1);
rep(i, 1, n + 1)cin >> a[i];
ll ans = 0ll;
for (ll i = 0; i < 61; i++) {
ll z = 0ll, o = 0ll;
ll k = (1ll << i);
rep(j, 1, n + 1) {
if (k & a[j])o++;
else z++;
}
ll kk = k;
k %= MOD;
k = (((k * z) % MOD) * o) % MOD;
ans = (ans + k) % MOD;
ans %= MOD;
}
cout << ans << endl;
}
int main() {
fast_io;
int t = 1;
while (t--) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using piii = pair<int, pair<int, int>>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
template <typename T>
using Graph = vector<vector<T>>;
const int MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int M, K;
cin >> M >> K;
int ma = 1 << M;
vector<int> ans;
vector<bool> isused(ma);
for (int i = 0; i < ma; ++i) {
if (isused[i])
continue;
int tmp = K ^ i;
if (tmp < ma) {
ans.push_back(i);
ans.push_back(tmp);
isused[i] = isused[tmp] = true;
}
}
if (K == 0) {
for (int i = 0; i < ma * 2; ++i)
cout << ans[i] << " ";
cout << endl;
return 0;
}
if (ma != ans.size() || ((ans.size() >> 1) & 1)) {
cout << -1 << '\n';
return 0;
}
for (int i = 0; i < ma; i += 2)
cout << ans[i + 1] << " " << ans[i] << " ";
for (int i = 0; i < ma; ++i)
cout << ans[i] << " ";
cout << endl;
return 0;
} | 0 | 14,210,336 |
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef long double ld;
const ll mod = 1000000007;
const ll INF = mod * mod;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<int, int> P;
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
typedef vector<int> vec;
typedef vector<string> svec;
#define fr first
#define sc second
#define all(c) c.begin(),c.end()
#define pb push_back
void solve() {
int N; cin >> N;
ll A[200200], B[200200];
ll sum = 0;
bool flag = true;
ll mini = INF;
rep(i, N) {
cin >> A[i] >> B[i];
if(A[i] > B[i]) mini = min(mini, B[i]);
if(A[i] != B[i]) flag = false;
sum += A[i];
}
if(flag) {
cout << 0 << endl;
} else {
cout << sum - mini << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
} | #include<iostream>
#include<cstring>
typedef long long ll;
using namespace std;
char str[10000000];
int main(void){
ll n;
char before[1000];
char after[1000];
while(cin>>n,n){
for(int i=0;i<n;i++){
cin >> before[i];
cin >> after[i];
}
ll m;
cin >> m;
for(int i=0;i<m;i++){
cin >> str[i];
}
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(str[i]==before[j]){
str[i]=after[j];
break;
}
}
}
cout<<str<<endl;
}
return 0;
} | 0 | 83,610,163 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using P = pair<string,int>;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a.at(i);
sort(a.begin(),a.end());
int ans = a.at(n/2) - a.at(n/2-1);
cout << ans << 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>
using namespace std;
using ll=long long;
using ld=long double;
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
#define ALL(x) (x).begin(), (x).end()
const int MOD = 1e9 + 7;
const int INF = 1e18 + 9;
constexpr long double pi = 3.141592653589793238462643383279;
int fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int keta(int n) {
if (n == 0) return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
int ketasum(int n) {
int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
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;
}
char toSmall(char c) {
return (c + 0x20);
}
char toLarge(char c) {
return (c - 0x20);
}
float myPower(int a, int n) {
float x = 1;
while (n > 0) {
if (n & 1) {
x *= a;
}
a *= a;
n >>= 1;
}
return x;
}
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;
}
int main(void){
string s; cin >> s;
vector<int> vec(30);
rep(i, s.size()) {
++vec[s[i] - 'a'];
}
rep(i, 26) {
if (vec[i] == 0) {
cout << (char)(i + 'a') << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
} | 0 | 53,269,868 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
string A, B;
for (int i = 0; i < b; i++) {
A += char('0' + a);
}
for (int i = 0; i < a; i++) {
B += char('0' + b);
}
cout << ((A < B) ? A : B) << "\n";
} | #include <iostream>
#include <string>
int main(int argc, char** argv)
{
std::string s;
std::getline(std::cin, s);
std::string p;
std::getline(std::cin, p);
for (int si = 0; si < (int)s.size(); ++si)
{
if (s[si] == p[0])
{
bool match = true;
for (int pi = 0; pi < (int)p.size() && match; ++pi)
{
match = (s[(si + pi) % (int)s.size()] == p[pi]);
}
if (match)
{
std::cout << "Yes" << std::endl;
return 0;
}
}
}
std::cout << "No" << std::endl;
return 0;
} | 0 | 7,141,442 |
#include <bits/stdc++.h>
const int INF=1e9;
const int MOD=1e9+7;
const long long LINF=1e18;
using namespace std;
#define int long long
int c[3000][3000];
typedef pair<int,int> P;
std::vector<P> num(2000000,P(0,0));
int wa[3000][3000];
int d;
P grd,gld,brd,bld,ord,old,rrd,rld,rt,rb,gt,gb,ot,ob,bb,bt;
int po=0;
void draw(int y,int x,int color){
for(int i=y;i<y+d;i++){c[i][x]=color;num[++po]=P(i,x);}
if(color==1)rt=P(y,x);
if(color==2)bt=P(y,x);
if(color==3)ot=P(y,x);
if(color==4)gt=P(y,x);
if(color==1)rb=P(y+d-1,x);
if(color==2)bb=P(y+d-1,x);
if(color==3)ob=P(y+d-1,x);
if(color==4)gb=P(y+d-1,x);
for(int j=1;j<=(d-1)/2;j++){
for(int i=y+j;i<y+d-j;i++){
c[i][x+j]=c[i][x-j]=color;
num[++po]=P(i,x+j);
num[++po]=P(i,x-j);
}
}
int j=(d-1)/2;
if(color==1)rrd=P(y+d-j-1,x+j);
if(color==2)brd=P(y+d-j-1,x+j);
if(color==3)ord=P(y+d-j-1,x+j);
if(color==4)grd=P(y+d-j-1,x+j);
if(color==1)rld=P(y+d-j-1,x-j);
if(color==2)bld=P(y+d-j-1,x-j);
if(color==3)old=P(y+d-j-1,x-j);
if(color==4)gld=P(y+d-j-1,x-j);
}
void warp(int y,int x){
for(int i=y;i<y+d;i++){
po++;
if(i<0||x<0)continue;
wa[i][x]=po;
}
for(int j=1;j<=(d-1)/2;j++){
for(int i=y+j;i<y+d-j;i++){
po++;
if(i>=0&&x+j>=0)wa[i][x+j]=po;
po++;
if(i>=0&&x-j>=0)wa[i][x-j]=po;
}
}
}
signed main(){
int o=0;
memset(c,0,sizeof(c));
memset(wa,0,sizeof(wa));
int H,W;cin>>H>>W>>d;
string s="WRGBY";
int sw=(d%2==0);
int width=d-sw;
draw(0,width,1);
draw(d/2,(d-1)/2,2);
int a=(d+1)/2,b=a-(d&1);
draw(d/2+a,(d-1)/2+b,3);
draw(a,width+b,4);
po=0;
int tmp;
if(d%2){
warp(grd.first+1,grd.second);
warp(rrd.first-(d-1),rrd.second+1);
warp(bld.first-d,bld.second);
warp(rld.first-d,rld.second);
po=0;
warp(bld.first,bld.second-1);
warp(ord.first+1,ord.second);
warp(grd.first-(d-1),grd.second+1);
warp(old.first,old.second-1);
}
else{
warp(grd.first,grd.second+1);
po=0;
warp(ob.first+1,ob.second);
warp(ord.first,ord.second+1);
tmp=po;
warp(rt.first-d,rt.second);
po=tmp;
warp(bld.first-d,bld.second-1);
warp(old.first,old.second-1);
po=0;
warp(bld.first,bld.second-1);
warp(rrd.first-d,rrd.second+1);
warp(grd.first-d,grd.second+1);
warp(rld.first-d,rld.second-1);
}
P memo;
int nowh=0,noww=width;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++,noww++){
if(i&&j==0){nowh=memo.first+1,noww=memo.second;}
if(c[nowh][noww]==0){
int hh=nowh,ww=noww;
nowh=num[wa[hh][ww]].first;
noww=num[wa[hh][ww]].second;
}
if(j==0)memo=P(nowh,noww);
cout<<s[c[nowh][noww]];
}
cout<<endl;
}
} | #include<stdio.h>
int main(void) {
int d, t, s;
scanf("%d%d%d", &d, &t, &s);
if (d <= t * s) {
printf("Yes");
}
else printf("No");
return 0;
} | 0 | 42,250,633 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> V;
#define rep(i,e) for(ll i=0;i<e;i++ )
typedef pair<ll,ll> P;
const ll mod = 1e9+7;
const ll INF = INT64_MAX;
ll i;
int main(){
string A,B,C;
cin>>A>>B>>C;
if(A.at(A.length()-1)==B.at(0)&&B.at(B.length()-1)==C.at(0))cout<<"YES";
else cout<<"NO";
cout<<endl;
} | #include<bits/stdc++.h>
using namespace std;
#define mod 1000000009
#define ll long long
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define set0(a) memset ((a), 0 , sizeof(a))
#define set1(a) memset((a),-1,sizeof (a))
#define pi pair<int, int>
#define ps pair<string, string>
#define pl pair<long, long>
#define pll pair<long long, long long>
#define vll vector<long long>
#define vl vector<long>
#define vi vector<int>
#define vs vector<string>
#define vps vector< ps >
#define vpi vector< pi >
#define vpl vector< pl >
#define vpll vector< pll >
#define flash ios_base::sync_with_stdio(false); cin.tie(NULL);
#define tc(t,T) for(long long t=0;t<T;t++)
#define rep(i,s,n,d) for(long long i=s;i<n;i=i+d)
bool sortbysec(const pll &a,
const pll &b)
{
return (a.second < b.second);
}
void func(void)
{
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
}
ll gcd(ll a,ll b){
if(b==0)return a;
else return gcd(b,a%b);
}
void printStack(stack<string> s){
if(s.empty())return;
string x=s.top();
s.pop();
printStack(s);
cout<<x;
s.push(x);
}
ll binaryexp(ll n,ll p){
if(p==0) return 1;
if(p%2==0) return binaryexp((n%mod)*(n%mod),p/2);
else return ((n%mod)*binaryexp(((n%mod)*(n%mod))%mod,(p-1)/2)%mod);
}
#define meax 10000001
vll spf(meax,0);
void siv(){
spf[1]=1;
for(ll i=2;i<meax;i++)spf[i]=i;
for(ll i=4;i<meax;i+=2){
spf[i]=2;
}
for(ll i=3;i*i<meax;i++){
if(spf[i]==i){
for(ll j=i*i;j<meax;j+=i){
if(spf[j]==j){
spf[j]=i;
}
}
}
}
}
int main(){
ll n,h;
cin>>n>>h;
vpll a(n),b(n);
rep(i,0,n,1){
ll x,y;
cin>>x>>y;
a[i]=mp(x,i);
b[i]=mp(y,i);
}
sort(a.rbegin(),a.rend());
sort(b.rbegin(),b.rend());
ll mx=a[0].ff;
ll mxi=a[0].ss;
ll moves=0;
ll mxb;
for(ll i=0;i<n;i++){
if(h<=0)break;
if(b[i].ss==mxi){
mxb=b[i].ss;
}
if(b[i].ff<mx)break;
moves++;
h=h-b[i].ff;
}
if(h>0){
ll x=(h/mx);
moves=moves+x;
if(x*mx<h)moves++;
}
cout<<moves<<endl;
} | 0 | 47,785,212 |
#include <iostream>
#include <cmath>
using namespace std;
int main(void){
double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << fixed << sqrt(pow(fabs(x1-x2),2)+pow(fabs(y1-y2),2)) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
const long long INF = 1e15;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
int n,k;
cin >> n >> k;
int g;
cin >> g;
int mx = g;
if(k == g){
cout << "POSSIBLE" << endl;
return 0;
}
for(int i = 0; i < n-1; i++){
int a; cin >> a;
mx = max(mx,a);
g = __gcd(g,a);
if(k == a){
cout << "POSSIBLE" << endl;
return 0;
}
}
if(g == 1 && mx > k) cout << "POSSIBLE" << endl;
else if(k%g == 0 && mx > k) cout << "POSSIBLE" << endl;
else cout << "IMPOSSIBLE" << endl;
return 0;
} | 0 | 53,885,246 |
#include<bits/stdc++.h>
using namespace std;
long long n,q,m,k,t,l;
int main(){
cin>>n>>m;
vector<string>v(n);
for (int i=0; i<n; i++){
cin>>v[i];
}
sort(v.begin(), v.end());
for (int i=0; i<n; i++){
cout<<v[i];
}
} | #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;
vector<int> s;
for(int i=0;i<n;i++)
{
int temp;
cin>>temp;
s.push_back(temp);
}
if(k>=n)
cout<<"0";
else{
sort(s.begin(),s.end());
while(k--)
{
s.pop_back();
}
ll sum=0;
for(auto i:s)
{
sum+=i;
}
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 | 93,216,315 |
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long LL;
#define y0 Sword_Art_Online
#define y1 Your_lie_in_April
#define yn Darling_in_the_Franxx
#define tm Plastic_Memories
#define lr Charlotte
#define norm Weathering_with_you
#define left Violet_Evergarden
#define have Date_a_live
#define ends Your_name
#define prev Five_centimeters_per_second
#define hash Silent_voice
#define endl "\n"
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
LL Rand(LL l, LL h){
return uniform_int_distribution<LL>(l, h)(rng);
}
template <typename T> void read(T &t){
t = 0; char ch = getchar(); int f = 1;
while (!isdigit(ch)) { if (ch == '-') f = -1; ch = getchar(); }
do { (t *= 10) += ch - '0'; ch = getchar(); } while (isdigit(ch)); t *= f;
}
const LL MaxN = 1 + 2e5;
LL nLamp, nStep, lamps[MaxN], temp[MaxN];
void InOut(){
#define TASK "ABC"
freopen(TASK".inp","r",stdin);
freopen(TASK".out","w",stdout);
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> nLamp >> nStep;
for(int iLamp = 0 ; iLamp < nLamp ; ++iLamp) cin >> lamps[iLamp];
while(nStep--){
bool isChanged = 0;
memset(temp, 0, sizeof temp);
for(int iLamp = 0 ; iLamp < nLamp ; ++iLamp){
LL lo = max(0LL, iLamp - lamps[iLamp]);
LL hi = min(nLamp - 1, iLamp + lamps[iLamp]);
temp[lo]++;
temp[hi + 1]--;
}
for(int iLamp = 0 ; iLamp < nLamp ; ++iLamp){
if(iLamp != 0) temp[iLamp] += temp[iLamp - 1];
if(!isChanged && temp[iLamp] != lamps[iLamp]) isChanged = 1;
}
if(!isChanged) break;
memcpy(lamps, temp, sizeof temp);
}
for(int iLamp = 0 ; iLamp < nLamp ; ++iLamp) cout << lamps[iLamp] << " ";
return 0;
} | #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<deque>
#include<functional>
#include<iterator>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<utility>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
#define a first
#define b second
#define sz(x) (ll)((x).size())
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(x) (x).bg,(x).ed
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(n);i>=1;i--)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
const ll MOD=1000000007;
const ll INF=1000000000000000;
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 maxx(ll x,ll y,ll z){return max(max(x,y),z);}
ll minn(ll x,ll y,ll z){return min(min(x,y),z);}
ll gcd(ll x,ll y){if(x%y==0) return y;else return gcd(y,x%y);}
ll lcm(ll x,ll y){return x*(y/gcd(x,y));}
ll digsz(ll x){if(x==0) return 1;else{ll ans=0;while(x){x/=10;ans++;}return ans;}}
ll digsum(ll x){ll sum=0;while(x){sum+=x%10;x/=10;}return sum;}
vector<ll> pw2(62,1);vector<ll> pw10(19,1);
int main(){
{rep1(i,61) pw2[i]=2*pw2[i-1];}
{rep1(i,18) pw10[i]=10*pw10[i-1];}
ll N; cin>>N;
ll ans=1;
rep(i,N){
ll x; cin>>x;
ans=lcm(ans,x);
}
cout<<ans<<endl;
} | 0 | 28,575,090 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
const ll mod = 1000000007;
int main() {
int x,a;
cin >> x >> a;
if(x < a){
cout << 0 << endl;
} else {
cout << 10 << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
if(a!=b||a!=c||b!=c){
cout<<"No";
return 0;
}
cout<<"Yes";
return 0;
} | 0 | 83,542,061 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 100005;
bool res[maxn];
int n;
string str;
bool check() {
bool flag = false;
for (int i = 0; i < n; i++) {
int l = ((i-1)+n)%n;
int r = (i+1)%n;
if (res[i]) {
if (str[i] == 'x' && res[l] == res[r]) flag = true;
if (str[i] == 'o' && res[l] != res[r]) flag = true;
}
if (!res[i]) {
if (str[i] == 'x' && res[l] != res[r]) flag = true;
if (str[i] == 'o' && res[l] == res[r]) flag = true;
}
}
return !flag;
}
void attempt() {
for (int i = 1; i < n; i++) {
int l = ((i-1)+n)%n;
int r = (i+1)%n;
if (res[i]) {
if (str[i] == 'o') res[r] = res[l];
if (str[i] == 'x') res[r] = !res[l];
} else {
if (str[i] == 'o') res[r] = !res[l];
if (str[i] == 'x') res[r] = res[l];
}
}
}
void print() {
for (int i = 0; i < n; i++) {
if (res[i]) cout << "S";
else cout << "W";
}
cout << '\n';
exit(0);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
cin >> str;
res[0] = true;
res[1] = true;
attempt();
if (check()) print();
res[0] = true;
res[1] = false;
attempt();
if (check()) print();
res[0] = false;
res[1] = false;
attempt();
if (check()) print();
res[0] = false;
res[1] = true;
attempt();
if (check()) print();
cout << "-1\n";
} | #include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < n; i++)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ll long long
#define MOD 1000000007
#define MAX 100010
#define aout(a) REP(i,sizeof(a)) cout << a[i] << " "; cout << endl;
#define vout(v) REP(i,v,size()) cout << v[i] << " "; cout << endl;
using namespace std;
using Graph = vector<vector<int>>;
#define PI 3.1415926535897932384
int N;
ll ans = 0;
bool flag = false;
int main(){
cin >> N;
int MA = 1000001;
int A[201010];
int cnt[1010101];
bool ok[1010101];
FOR(i, 0, N) cin >> A[i];
FOR(i, 0, N) cnt[A[i]]++;
FOR(x, 1, MA) ok[x] = true;
FOR(x, 1, MA) if(0 < cnt[x]) {
if (1 < cnt[x]) ok[x] = false;
for (int x2 = x * 2; x2 < MA; x2 += x) ok[x2] = false;
}
int ans = 0;
FOR(i, 0, N) if (ok[A[i]]) ans++;
cout << ans << endl;
} | 0 | 95,473,448 |
#include <stdio.h>
const int N=110;
const int INF=1<<30;
int min(int a,int b){
return a>b?b:a;
}
int main(){
int n,dp[N][N],a[N];
scanf("%d%d%d",&n,&a[0],&a[1]);
for(int i=1;i<n;i++)scanf("%d%d",&a[i],&a[i+1]);
for(int k=1;k<n;k++){
for(int i=0;i<n-k;i++){
dp[i][i+k]=INF;
for(int j=i;j<i+k;j++)dp[i][i+k]=min(dp[i][i+k],dp[i][j]+dp[j+1][i+k]+a[i]*a[j+1]*a[i+k+1]);
}
}
printf("%d\n",dp[0][n-1]);
} | #include <iostream>
using namespace std;
#define MAX_V 11
#define INF 1e9
int min(int a, int b){
return a < b ? a : b;
}
int main(void){
int n, a, b, c;
int dp[MAX_V][MAX_V];
while(true){
cin >> n;
if(n == 0) break;
for(int i = 0; i < MAX_V; i++)
for(int j = 0; j < MAX_V; j++)
dp[i][j] = INF;
for(int i = 0; i < MAX_V; i++)
dp[i][i] = 0;
for(int i = 0; i < n; i++){
cin >> a >> b >> c;
dp[a][b] = c;
dp[b][a] = c;
}
for(int k = 0; k < MAX_V; k++)
for(int i = 0; i < MAX_V; i++)
for(int j = 0; j < MAX_V; j++)
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
int minpoint, mincost = INF;
for(int i = 0; i < MAX_V; i++){
int nowcost = 0;
for(int j = 0; j < MAX_V; j++){
if(dp[i][j] != INF){ nowcost += dp[i][j]; }
}
if(nowcost != 0 && mincost > nowcost){
mincost = nowcost;
minpoint = i;
}
}
cout << minpoint << " " << mincost << endl;
}
return 0;
} | 0 | 59,214,497 |
#include<iostream>
#include<bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#define vi vector<int>
#define lvi vector<long long>
#define pi pair<int,int>
#define lpi pair<long long ,long long>
#define mp make_pair
#define pb push_back
#define ll long long
#define N 100005
#define faltu ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define mod 1000000007
#define mod1 1000000000000000007
using namespace std;
using namespace __gnu_pbds;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;
typedef tree<int,null_type,less_equal<int>,rb_tree_tag,tree_order_statistics_node_update>multiordered_set;
ll int pw(ll int a, ll int b,ll md) {
if (b == 0) return 1;
ll int t = pw(a, b / 2,md);
if (b % 2 == 0) return (t * t)%mod;
else return ((t * t)%mod * a)%mod;
}
vector<int> pm;
void prm(int n)
{
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
for (int p=2; p<=n; p++)
if (prime[p]) pm.push_back(p);
}
bool cmp(const pair<ll int,ll int> &a,const pair<ll int,ll int> &b)
{
if(a.first==b.first)return a.second<b.second;
return a.first<b.first;
}
ll int gcd(ll int a,ll int b)
{
if(!a)return b;
return gcd(b%a,a);
}
bool isPrime(int n)
{
if (n <= 1)
return false;
for (int i = 2; i < n; i++)
if (n % i == 0)
return false;
return true;
}
map<int,int>pa;
int find(int i){
if(pa[i]==i)return i;
return pa[i]=find(pa[i]);
}
void join(int i,int j){
int a=find(i);
int b=find(j);
if(b>=a)pa[b]=a;
else pa[a]=b;
}
int ddx[]={-1,-1,-1,0,1,1,1,0};
int ddy[]={-1,0,1,1,1,0,-1,-1};
int dx[]={-1,0,1,0};
int dy[]={0,-1,0,1};
int main()
{
faltu;
int t=1;
while(t--)
{
int n,cnt=0;
cin>>n;
string s;
cin>>s;
for(int i=0;i<n;)
{
cnt++;
int j=i;
while(s[i]==s[j])j++;
i=j;
}
cout<<cnt<<endl;
}
} | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORL(i,a,b) for(LL i=(a);i<(b);++i)
#define REPL(i,n) FORL(i,0,n)
#define SIZE(a) int((a).size())
#define ALL(a) (a).begin(),(a).end()
const double EPS = 1e-10;
const double PI = acos(-1.0);
template<typename T>
void vprint(vector<T> v) {
for(auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template<typename T>
void vvprint(vector<vector<T>> vv) {
REP(i, SIZE(vv)) {
REP(j, SIZE(vv[i])) {
cerr << vv[i][j] << " ";
}
cerr << endl;
}
}
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k, const Iterator last)
{
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1)
{
if (*--itr1 < *itr2)
{
Iterator j = k;
while (!(*itr1 < *j)) ++j;
iter_swap(itr1,j);
++itr1;
++j;
itr2 = k;
rotate(itr1,j,last);
while (last != j)
{
++j;
++itr2;
}
rotate(k,itr2,last);
return true;
}
}
rotate(first,k,last);
return false;
}
inline double get_time_sec(void){
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count())/1000000000;
}
template<typename T>
T gcd(T a, T b) {
if(a > b) swap(a, b);
if(a == 0) return b;
else return gcd(b%a, a);
}
template<typename T>
T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template<typename T>
map<T, T> prime_list(T n) {
map<T, T> ret;
for(T i = 2; i*i <= n; i++) {
if(n % i == 0) {
ret[i] = 0;
while(n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if(n != 1) ret[n]++;
return ret;
}
#define MOD 1000000007
LL mypow(LL a, LL n) {
if(n == 1) return a % MOD;
if(n % 2 == 1) return (a * mypow(a, n-1)) % MOD;
LL t = mypow(a, n/2);
return (t * t) % MOD;
}
int main(void) {
int n;
cin >> n;
VI a(n);
REP(i, n) cin >> a[i];
LL ans = LLONG_MAX;
FOR(i, -100, 101) {
LL tmp = 0;
REP(j, n) tmp += (a[j] - i) * (a[j] - i);
ans = min(ans, tmp);
}
cout << ans << endl;
} | 0 | 78,842,425 |
#include <iostream>
using namespace std;
int main(void){
int a, b;
cin >> a >> b;
int num = (a + b + 1) / 2.0;
cout << num <<endl;
} | #include <iostream>
#include <string>
#include <vector>
#include <set>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <queue>
#include <map>
#include <numeric>
#include <unordered_map>
#include <iomanip>
#include <functional>
#include <bitset>
#include <complex>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define all(x) (x).begin(),(x).end()
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
typedef long long ll;
using namespace std;
struct ConvexHull{
using cd=complex<double> ;
vector<cd> ps,qs;
int sz;
ConvexHull(vector<cd> v){
ps=v;
sz=ps.size();
qs.resize(sz*2);
sort(ps.begin(),ps.end(),[](cd a,cd b){if(a.real()!=b.real()){return a.real()<b.real();}return a.imag()<b.imag();});
calc();
}
void calc(){
int k=0;
for(int i=0;i<sz;i++){
while(k>1 && ((qs[k-1]-ps[i])/(qs[k-2]-ps[i])).imag()<=0)k--;
qs[k++]=ps[i];
}
int t=k;
for(int i=sz-2;i>=0;i--){
while(k>t && ((qs[k-1]-ps[i])/(qs[k-2]-ps[i])).imag()<=0)k--;
qs[k++]=ps[i];
}
qs.resize(k-1);
}
};
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
vector<complex<double>>conv;
int n;
cin>>n;
conv.push_back({0,0});
rep(i,n)
{
double x,y;
cin>>x>>y;
complex<double>vec(x,y);
auto tv=conv;
for(auto j:tv)conv.push_back(j+vec);
ConvexHull ch(conv);
ch.calc();
conv=ch.qs;
conv.erase(unique(all(conv)),conv.end());
}
double res=0;
rep(i,conv.size())
{
chmax(res,abs(conv[i]));
}
cout<<setprecision(12)<<res<<endl;
return 0;
} | 0 | 92,472,076 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define IOS ios::sync_with_stdio(false); cin.tie(0)
#define ll long long
#define ld long double
#define rep(i,a,n) for (int i=(int)(a);i<(int)(n);i++)
#define per(i,a,n) for (int i=(int)(n-1);i>=(int)(a);i--)
#define mp(a, b) make_pair(a, b)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pil pair<int, ll>
#define pli pair<ll, int>
#define fi first
#define se second
const int MOD = 1e9+7;
const int MX = 2e5+5;
const ll INF = 1e18;
const ld PI = 4*atan((ld)1);
const int xd[4] = {1,0,-1,0}, yd[4] = {0,1,0,-1};
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
int main() {
long long n, sum = 0;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
if (sum % (n * (n + 1) / 2)) {
cout << "NO\n";
return 0;
}
long long cnt = sum / (n * (n + 1) / 2);
long long sum_b = 0;
for (int i = 0; i < n; ++i) {
long long dif = a[i] - a[(i + 1) % n];
dif += cnt;
if (dif < 0 || dif % n != 0) {
cout << "NO\n";
return 0;
}
sum_b += dif / n;
}
if (sum_b == cnt) {
cout << "YES\n";
}
else {
cout << "NO\n";
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
double solve() {
ll N, M, D;
cin >> N >> M >> D;
ll c;
if ( D > 0 ) {
ll w = max(N-2*D, 0LL);
c = (N-w) + w*2;
} else {
c = N;
}
double ans = c * (M-1) / (double)(N*N);
return ans;
}
int main() {
cout.setf(ios::fixed);
cout.precision(16);
auto ans = solve();
cout << ans << "\n";
return 0;
} | 0 | 94,652,737 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define mx *max_element
#define mn *min_element
#define fo(i,n) for(ll i=0;i<n;i++)
#define loop(i,a,b) for(ll i=a;i<=b;i++)
#define rfo(i,n) for(ll i=n-1;i>=0;i--)
#define rloop(i,a,b) for(ll i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define sortall(x) sort(all(x))
#define precision cout<<fixed<<setprecision(10)
#define mem(x,p) memset(x,p,sizeof(x))
#define w(t) ll t;cin>>t;while(t--)
#define kk "\n"
#define setbits(x) __builtin_popcountll(x)
const double pi=3.1415926535897932384626;
const ll mod=1e9+7;
int main()
{
IOS
ll n;
cin>>n;
n--;
ll p=(n*(n+1))/2;
cout<<p;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main () {
long long N;
cin >> N;
if (N % 2 == 1){
cout << 0 << endl;
return 0;
}
long long ans = 0;
N /= 10;
ans += N;
for (int i = 0; i < 30; i++) {
N /= 5;
ans += N;
if (N == 0){
cout << ans << endl;
return 0;
}
}
} | 0 | 89,863,042 |
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
ll a[300000], mx[300000][2], ans[300000];
int main() {
int N;
cin >> N;
int m=(1<<N);
vector<vector<int>> v(N+1);
for(int i=0; i<m; ++i){
cin >> a[i];
int cnt=0;
for(int j=0; j<N; ++j){
if(i&(1<<j)) ++cnt;
}
v[cnt].push_back(i);
}
for(int i=0; i<v[1].size(); ++i){
if(a[v[1][i]]<a[0]) mx[v[1][i]][1]=v[1][i];
else mx[v[1][i]][0]=v[1][i];
}
for(int i=2; i<=N; ++i){
for(int j=0; j<v[i].size(); ++j){
if(a[v[i][j]]<a[0]) mx[v[i][j]][1]=v[i][j];
else mx[v[i][j]][0]=v[i][j];
for(int k=0; k<N; ++k){
if((v[i][j])&(1<<k)){
int g=v[i][j]-(1<<k);
for(int p=0; p<2; ++p){
if(a[mx[g][p]]>a[mx[v[i][j]][0]]){
mx[v[i][j]][1]=mx[v[i][j]][0];
mx[v[i][j]][0]=mx[g][p];
}
else if(mx[g][p]!=mx[v[i][j]][0] && a[mx[g][p]]>a[mx[v[i][j]][1]]){
mx[v[i][j]][1]=mx[g][p];
}
}
}
}
}
}
for(int i=1; i<m; ++i){
ans[i]=max(ans[i-1], a[mx[i][0]]+a[mx[i][1]]);
cout << ans[i] << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#include <limits.h>
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;
}
const int INF = INT_MAX / 2;
vector<int> dp;
int main(void) {
ll N;
cin >> N;
dp.resize(N + 1, INF);
dp[0] = 0;
for (int i = 0; i < N; i++) {
if (dp[i] == INF) {
continue;
}
for (ll x = 1; i + x <= N; x *= 6) {
chmin(dp[i + x], dp[i] + 1);
}
for (ll x = 1; i + x <= N; x *= 9) {
chmin(dp[i + x], dp[i] + 1);
}
}
cout << dp[N] << endl;
return 0;
} | 0 | 31,763,285 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> pll;
const ll mod=1e9+7;
const ll inf=1LL<<61;
int main() {
ll a,b,k;
cin >> a >> b >> k;
for(ll i=0;i<k;i++) {
if(i%2) {
b-=b%2;
a+=b/2;
b/=2;
}
else {
a-=a%2;
b+=a/2;
a/=2;
}
}
cout << a << " " << b << endl;
} | bool DBG = false;
#include<bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
using ll = long long;
using ld = long double;
using bint = boost::multiprecision::cpp_int;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define IFOR(i,a,b) for(int i=((b)-1);i>=(a);--i)
#define RPT(i,a,b) for(int i=(a);i<((a)+(b));++i)
#define IRPT(i,a,b) for(int i=((a)+(b)-1);i>=(a);--i)
#define ALL(x) x.begin(),x.end()
#define RALL(x) x.rbegin(),x.rend()
#define fs first
#define sd second
#define couts(x) cout << (x) << (" ")
#define coutn(x) cout << (x) << ("\n")
#define ncouts(x) numout(x),outst[outst_N++] = ' '
#define ncoutn(x) numout(x),outst[outst_N++] = '\n'
#define scouts(x) strout(x),outst[outst_N++] = ' '
#define scoutn(x) strout(x),outst[outst_N++] = '\n'
#define dcouts(x) if(DBG) couts(x)
#define dcoutn(x) if(DBG) coutn(x)
#define endl "\n"
#define psb push_back
#define ppb pop_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define LBIT(x,a) (((x)>>(a))&1LL)
#define IBIT(x,a) (((x)>>(a))&1)
#define BCOUNT(x) (__builtin_popcount(x))
template<typename T> std::istream &operator>>(std::istream &is, std::vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T1, typename T2> std::istream &operator>>(std::istream &is, std::pair<T1,T2> &p){is >> p.first >> p.second; return is; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::deque<T> &vec){ os << "deque["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> std::ostream &operator<<(std::ostream &os, const std::map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> std::ostream &operator<<(std::ostream &os, const std::unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<class T> using V = vector<T>;
template<class T> using V2 = V<V<T>>;
template<class T> using V3 = V<V2<T>>;
template<class T> using V4 = V<V3<T>>;
char outst[20'000'000]; int outst_N = 0;
char outst_tmp[200];
template<class NUM >
void numout(NUM n){
if(n<0) { n*=-1; outst[outst_N++] = '-';}
if(n==0){ outst[outst_N++] = '0'; return;}
int cnt = 0;
while(n>0){
outst_tmp[cnt++] = '0' + (n % 10);
n /= 10;
}
IFOR(i,0,cnt){
outst[outst_N++] = outst_tmp[i];
}
}
void strout(std::string s){
for(auto x: s){
outst[outst_N++] = x;
}
}
constexpr ll LINF = 1LL << 60;
constexpr int IINF = 1 << 28;
constexpr ll mod = 1'000'000'007;
int dx[] = {1,-1,0, 0};
int dy[] = {0,0,1,-1};
int dx2[] = {0,2,0, 2};
int dy2[] = {0,0,2,2};
int MH = 100, MW = 100;
void solve(){
int a, b; cin >> a >> b;
int t = (a<b);
if(t) swap(a, b);
couts(MH); coutn(MW);
V2<int> c(MH, V<int>(MW));
V2<int> used(MH, V<int>(MW));
--b;
used[0][0] = 1;
FOR(i,0,MH/2){
FOR(j,0,MW/2){
c[2*i][2*j] = 1;
--a;
}
}
if(b>0){
FOR(i,0,MH/2-1){
FOR(j,0,MW/2-1){
if(b>0){
{
int unuse = 0;
FOR(k,0,4) unuse += (used[2*i+dx2[k] ][2*j+dy2[k] ]==0);
a += unuse;
}
b--;
FOR(k,0,4){
c[2*i+1+dx[k] ][2*j+1+dy[k] ] = 1;
used[2*i+1+dx[k] ][2*j+1+dy[k] ] = 1;
}
FOR(k,0,4){
c[2*i+dx2[k] ][2*j+dy2[k] ] = 1;
used[2*i+dx2[k] ][2*j+dy2[k] ] = 1;
}
}
else break;
}
if(b<=0) break;
}
}
if(a<0 ){
IFOR(i,0,MH/2){
IFOR(j,0,MW/2){
if(a<0){
if(!used[2*i][2*j] ) c[2*i][2*j] = 0, ++a;
}
else break;
}
if(a>=0) break;
}
}
FOR(i,0,MH){
FOR(j,0,MW){
if( c[i][j]^t ){
cout << '.';
}else{
cout << '#';
}
}
cout << '\n';
}
}
int main(void){
cin.tie(0);
solve();
return 0;
} | 0 | 92,640,244 |
#include <iostream>
#include <string>
#include <algorithm>
#include <utility>
#include <unordered_set>
#include <vector>
#include <list>
#include <string>
#include <iterator>
#include <deque>
#include <array>
#include <forward_list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <climits>
#include <bitset>
#include <numeric>
using namespace std;
const long double PI = 3.14159265358979323846264338327950;
const int N = 2 * 1e5;
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
string s;
bool isPalindrome(int lo, int hi) {
while (lo < hi) {
if (s[lo] != s[hi])
return false;
++lo;
--hi;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> s;
n = s.length();
if (isPalindrome(0, n - 1) &&
isPalindrome(0, (n - 1) / 2 - 1) &&
isPalindrome((n + 3) / 2 - 1, n - 1) )
cout << "Yes" << '\n';
else
cout << "No" << '\n';
} | #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;
} | 0 | 234,077 |
#include<iostream>
#include<cstring>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
int wa[n+1]={0};
int ac[n+1]={0};
int c=0,w=0;
while(m--){
int q;
string s;
cin>>q>>s;
if(s=="WA")wa[q]++;
else if(s=="AC" && ac[q]==0){
ac[q]++;
c++;
w+=wa[q];
}
}
cout<<c<<" "<<w;
return 0;
} | #include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;
int main() {
string S; cin>>S;
long long counter=0;
long long counter1=0;
long long counter2=0;
long long answer=0;
if(S.at(0)=='<'){
counter++;}
else
counter1++;
for(long long i=1; i<S.size(); i++){
if(counter>0&&counter2==0){
if(S.at(i)=='<'){
counter++;
continue;}
else{
answer+=counter*(counter+1)/2;
counter1++;
counter2=counter;
counter=0;
continue;}}
else {
if(S.at(i)=='>'){
counter1++;
continue;}
else{
answer+=counter1*(counter1-1)/2+max((counter1-counter2),0LL);
counter++;
counter2=0;
counter1=0;
continue;}}}
answer+=counter*(counter+1)/2;
answer+=counter1*(counter1-1)/2+max((counter1-counter2),0LL);
cout<<answer<<endl;} | 0 | 91,150,227 |
#include <iostream>
#include <algorithm>
#include <string>
#define REP(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int n;
long long sum=0,max,min,a;
cin >> n;
REP(i,n){
cin >> a;
sum+=a;
if(i==0){
max=a;
min=a;
}
if(max<a)
max=a;
if(min>a)
min=a;
}
cout << min <<' '<< max <<' '<< sum << endl;
} | #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>
#define _GLIBCXX_DEBUG
#define DIVISOR 1000000007
using namespace std;
typedef pair<int,int> pii;
typedef pair<int64_t, int64_t> pII;
template<typename T>
void cins(vector<T>& arr) { for(T& e: arr) cin >> e; }
#ifdef DEBUG
#define debug(fmt, ...) \
printf("[debug: %s] " fmt, __func__, __VA_ARGS__)
#define ps(arr) \
debug("size %ld: ", arr.size()); \
for(auto e: arr) cout << e << " "; \
cout << endl;
#else
#define debug(fmt, ...)
#define ps(arr)
#endif
#define INF (1e+9)
int main(void) {
int num, cap, limit;
cin >> num >> cap >> limit;
vector<pii> ranges(num);
for(int i = 0; i < num; i++) {
int time;
cin >> time;
ranges[i] = make_pair(time, time+limit+1);
}
auto comp = [](pii a, pii b) {
return a.second < b.second;
};
sort(ranges.begin(), ranges.end(), comp);
int ans = 0;
int time = 0;
int ps = 0;
for(int i = 0; i < num; i++) {
pii r = ranges[i];
if(ps == cap) {
time = 0;
}
if(r.first < time) {
ps++;
} else {
ans++;
time = r.second;
ps = 1;
}
debug("[time: %d] %d\n", time, ans);
}
cout << ans << endl;
return 0;
} | 0 | 91,112,018 |
#include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long M, std::vector<long long> H, std::vector<long long> A, std::vector<long long> B){
vector<vector<long long> > HH(N+1, vector<long long>(1));
for(int i = 0; i < M; ++i){
HH[A[i]].push_back(B[i]);
HH[B[i]].push_back(A[i]);
}
long long ans = 0;
for(int i = 1; i <= N; ++i){
long long maxval = 0;
for(auto j : HH[i]){
maxval = max(maxval, H[j]);
}
if(H[i] > maxval) ans++;
}
cout << ans << endl;
return;
}
int main(){
long long N;
scanf("%lld",&N);
long long M;
scanf("%lld",&M);
std::vector<long long> H(N+1);
H[0] = 0;
for(int i = 1 ; i <= N ; i++){
scanf("%lld",&H[i]);
}
std::vector<long long> A(M);
std::vector<long long> B(M);
for(int i = 0 ; i < M ; i++){
scanf("%lld",&A[i]);
scanf("%lld",&B[i]);
}
solve(N, M, std::move(H), std::move(A), std::move(B));
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, H);
IN(ll, N);
A2IN(ll, A, ll, B, N);
vi dp(H + 1, INF);
dp[0] = 0;
REP(i, N)
{
REP(j, H + 1)
{
CH(min, dp[min(H, j + A[i])], dp[j] + B[i]);
}
}
OUT(dp[H]);
} | 0 | 73,680,619 |
#include<bits/stdc++.h>
using namespace std;
int x;
int main()
{
scanf("%d",&x);
printf("%d\n",x/__gcd(x,360)*360/x);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define vi vector<int>
#define vvi vector<vector<int>>
#define pi pair<int, int>
#define ALL(a) (a).begin(), (a).end()
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
constexpr ll MOD = 1e9 + 7;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
signed main() {
cin >> N;
vi a(N);
cin >> a;
REP(i, N)
a[i]++;
int mx = *max_element(ALL(a));
vi mem(mx + 1);
REP(i, N) {
mem[a[i] + 1]++;
mem[a[i] + 0]++;
mem[a[i] - 1]++;
}
REP(i, mem.size())
ans = max(ans, (ll)mem[i]);
cout << ans << endl;
} | 0 | 25,709,407 |
#include<stdio.h>
int main(){
int n;
int r;
int inr;
scanf("%d %d", &n,&r);
inr=100*(10-n)+r;
if (n<10){
printf("%d", inr);
}
else {
printf("%d", r);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define forn(i, a, b) for (int i = a; i < b; ++i)
#define SZ(x) int(x.size())
#define pb push_back
#define F first
#define S second
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
int main() {
#ifdef LOCAL
freopen("b.txt", "r", stdin);
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
ios::sync_with_stdio(0);
cin.tie(0);
#define endl '\n'
#define dbg(...) 18
#endif
int n, i;
string a, b;
double ans = 0, da, x;
cin >> n;
cout << fixed << setprecision(9);
while (n--) {
cin >> a >> b;
da = i = x = 0;
while (a[i] != '.' && i < SZ(a)) i++;
da = stoi(a.substr(0, i));
if (i != SZ(a)) {
x = stoi(a.substr(i + 1, SZ(a)));
da += (x / pow(10, SZ(a) - i - 1));
}
if (b == "BTC")
ans += (da * 380000);
else
ans += da;
}
cout << ans << endl;
return 0;
} | 0 | 1,245,709 |
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
typedef long long llint;
const int MAXN = 1e5 + 10;
int x, y, a, b, c;
int p[MAXN], q[MAXN], r[MAXN];
int main(void) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &c);
for (int i = 0; i < a; ++i) scanf("%d", &p[i]);
for (int i = 0; i < b; ++i) scanf("%d", &q[i]);
for (int i = 0; i < c; ++i) scanf("%d", &r[i]);
sort(p, p + a); reverse(p, p + a);
sort(q, q + b); reverse(q, q + b);
sort(r, r + c); reverse(r, r + c);
vector<int> v;
for (int i = 0; i < x; ++i) v.push_back(p[i]);
for (int i = 0; i < y; ++i) v.push_back(q[i]);
for (int i = 0; i < c; ++i) v.push_back(r[i]);
sort(v.begin(), v.end()); reverse(v.begin(), v.end());
llint sol = 0;
for (int i = 0; i < x + y; ++i) sol += (llint) v[i];
printf("%lld\n", sol);
return 0;
} | #include <bits/stdc++.h>
#define arep(a,i,n) for(int i=(a);i<(n);i++)
#define rep(i,n) for(int i=0;i<(n);i++)
#define cinf(x,n) for(int i=0;i<(n);i++)cin>>x[i];
#define coutf(x,n) for(int i=0;i<(n);i++)cout<<x[i]<<endl;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
using namespace std;
class STACK{
private:
string s;
public:
void push(char num){
s+=num;
}
void pop(){
if(!s.empty())
s.pop_back();
}
bool isempty(){
if(s.length()==0)
return true;
else
return false;
}
int size(){
return s.length();
}
void list(){
cout << s << endl;
}
};
int main(){
STACK data;
string s;
cin >> s;
rep(i,s.length()){
if(s[i]=='0')
data.push('0');
else if(s[i]=='1')
data.push('1');
else if(s[i]=='B')
data.pop();
}
data.list();
} | 0 | 75,158,539 |
#include<iostream>
#include<vector>
#include<map>
using namespace std;
using ll = long long;
vector<int>v;
map<int, int>mp;
int main() {
bool visited[110];
int m, k; cin >> m >> k;
int x_or = 0;
for (int i = 0; i < (1 << m); i++) {
v.push_back(i); v.push_back(i);
if (i != k) x_or ^= i;
}
if (k == 0) {
for (auto&& x : v)cout << x << ' ';
return 0;
}
if (x_or == k) {
int n = (1 << (m + 1));
v[n / 2 - 1] = k;
int j = 0;
for (int i = 0; i < n / 2 - 1; i++) {
if (j == k)j++;
v[i] = j;
v[n - 2 - i] = j;
j++;
}
v[n - 1] = k;
for (auto&& x : v)cout << x << ' ';
return 0;
}
cout << -1;
return 0;
} | #define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <algorithm>
#include <iomanip>
#include <climits>
using namespace std;
#define MOD int(1e9 + 7)
#define INF (long long)(1e18)
int main()
{
long long N;
vector<long long> c(26, 1);
cin >> N;
for(long long i = 0; i < N; i++){
char t;
cin >> t;
c[t - 'a']++;
}
long long total = 1;
for(long long i = 0; i < 26; i++){
total *= c[i];
total %= MOD;
}
cout << total - 1 << endl;
} | 0 | 34,925,070 |
#include <bits/stdc++.h>
#include <cmath>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define sz(x) ll(x.size())
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 10e10;
const ll MINF = -10e10;
#define mins(x, y) x = min(x, y)
#define maxs(x, y) x = max(x, y)
typedef priority_queue<P, vector<P>, greater<P> > PQ_ASK;
const int mod = 1000000007;
int main() {
ll n, k;
cin >> n >> k;
vector<P> all_neta(n);
rep(i, n) {
ll t, d;
cin >> t >> d;
P p(d, t);
all_neta[i] = p;
}
ll neta_count = 0;
{
set<ll> neta_set;
for (auto a : all_neta) {
neta_set.insert(a.second);
}
neta_count = neta_set.size();
ll i = 0;
map<ll, ll> neta_id_map;
for (ll neta_id : neta_set) {
neta_id_map[neta_id] = i;
i++;
}
for (ll i = 0; i < n; i++) {
all_neta[i].second = neta_id_map[all_neta[i].second];
}
}
vector<P> kakuneta_sai_oishi_sort = vector<P>(neta_count, P(0, 0));
{
for (auto a : all_neta) {
ll neta = a.second;
ll oishisa = a.first;
if (kakuneta_sai_oishi_sort[neta].first < oishisa) {
kakuneta_sai_oishi_sort[neta] = P(oishisa, neta);
}
}
}
sort(all_neta.rbegin(), all_neta.rend());
sort(kakuneta_sai_oishi_sort.rbegin(), kakuneta_sai_oishi_sort.rend());
vector<ll> neta_saiyou_count = vector<ll>(neta_count, 0);
ll saiyo_su = 0;
ll oishisa_sum = 0;
for (ll i = 0; i < k; i++) {
P p = all_neta[i];
if (neta_saiyou_count[p.second] == 0) {
saiyo_su++;
}
oishisa_sum += p.first;
neta_saiyou_count[p.second]++;
}
ll ans = oishisa_sum + (saiyo_su * saiyo_su);
vector<PQ_ASK> netagoto_senkouochi_queue(neta_count, PQ_ASK());
for (ll i = 0; i < k; i++) {
P p = all_neta[i];
if (neta_saiyou_count[p.second] >= 2) {
netagoto_senkouochi_queue[p.second].push(p);
}
}
priority_queue<P> fukkatsu_list;
for (ll i = 0; i < neta_count; i++) {
P neta_daihyo = kakuneta_sai_oishi_sort[i];
if (neta_saiyou_count[neta_daihyo.second] == 0) {
fukkatsu_list.push(neta_daihyo);
}
}
PQ_ASK daihyo_senkouochi_queue;
for (ll i = 0; i < neta_count; i++) {
if (!netagoto_senkouochi_queue[i].empty()) {
P p = netagoto_senkouochi_queue[i].top();
daihyo_senkouochi_queue.push(p);
netagoto_senkouochi_queue[i].pop();
}
}
while (!daihyo_senkouochi_queue.empty() && !fukkatsu_list.empty()) {
P daihyo_ochi = daihyo_senkouochi_queue.top();
daihyo_senkouochi_queue.pop();
if (netagoto_senkouochi_queue[daihyo_ochi.second].size() > 1) {
P next_staging = netagoto_senkouochi_queue[daihyo_ochi.second].top();
daihyo_senkouochi_queue.push(next_staging);
}
P fukkatsu = fukkatsu_list.top();
fukkatsu_list.pop();
saiyo_su++;
oishisa_sum -= daihyo_ochi.first;
oishisa_sum += fukkatsu.first;
ll now = oishisa_sum + (saiyo_su * saiyo_su);
ans = max(now, ans);
}
cout << ans << endl;
} | #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(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define vout(x) rep(i,x.size()) cout << x[i] << " "
template<class T> bool chmin(T &a, T b) {if(a>b) {a=b;return 1;}return 0;}
template<class T> bool chmax(T &a, T b) {if(a<b) {a=b;return 1;}return 0;}
using namespace std;
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll,ll>;
const int inf = 1e9;
const ll inf_l = 1e18;
const int MAX = 2*1e5;
const int mod = 1e9+7;
template<class T>
struct BIT {
vector<T> bit;
int n;
BIT(int n): n(n), bit(n+1){}
void add(int i, T x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
T sum(int i) {
T s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
T sum(int l, int r) {
return sum(r-1) - sum(l-1);
}
};
int main() {
int n;
ll d, a;
cin >> n >> d >> a;
vector<P> data(n);
rep(i,n) {
ll x, h; cin >> x >> h;
data[i] = P(x,h);
}
sort(all(data));
vll x(n), h(n);
rep(i,n) {
x[i] = data[i].first;
h[i] = data[i].second;
}
BIT<ll> bit(n+1);
ll ct = 0;
REP(i,n+1) {
h[i-1] -= bit.sum(i);
if (h[i-1] <= 0) continue;
ll n_attack = (h[i-1]+a-1)/a;
ll damage = n_attack * a;
ct += n_attack;
bit.add(i,damage);
int rx = upper_bound(all(x),x[i-1]+2*d)-x.begin();
if (rx != n) bit.add(rx+1,-damage);
}
cout << ct << endl;
} | 0 | 96,990,053 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int A;
cin >> A;
cout << A*800-((A/15)*200) << endl;
} | #include<vector>
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int,int> P;
const ll MOD=1000000007LL;
const ll INF=1000000000LL;
const int MAX=100001;
int ch(char c){
if(c=='m'){
return 1000;
}else if(c=='c'){
return 100;
}else if(c=='x'){
return 10;
}else{
return 1;
}
}
int mcxi(string s){
int ret=0;
stack<int> st;
for(int i=0;i<s.length();i++){
if(isalpha(s[i])){
if(st.empty()){
ret+=ch(s[i]);
}else{
int a=st.top();st.pop();
ret+=a*ch(s[i]);
}
}else{
st.push(s[i]-'0');
}
}
return ret;
}
string tomcxi(int s,int w){
string ret="";
if(s/w){
if(s/w>1){
char p='0'+(s/w);
ret.push_back(p);
}
char c;
switch(w){
case 1000:c='m';break;
case 100:c='c';break;
case 10:c='x';break;
case 1:c='i';break;
}
ret.push_back(c);
}
return ret;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin>>n;
for(int i=0;i<n;i++){
string s1,s2;
cin>>s1>>s2;
int sum=mcxi(s1)+mcxi(s2);
cout<<tomcxi(sum,1000);sum%=1000;
cout<<tomcxi(sum,100);sum%=100;
cout<<tomcxi(sum,10);sum%=10;
cout<<tomcxi(sum,1);
cout<<endl;
}
} | 0 | 77,984,852 |