code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 2
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int X;
cin >> X;
int A = 0;
for(int i = 0; i < X; i++) {
int l, r;
cin >> l >> r;
A += 1;
A += r;
A -= l;
}
cout << A << endl;
} | #include <iostream>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
const double pi = acos(-1);
typedef long long ll;
int main()
{
ll a,b,c,d;
cin>>a>>b>>c>>d;
cout<<min(a,b)+min(c,d);
} | 0 | 39,634,733 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
int N;
ll sum = 0, m = 1e18;
bool flag = false;
int main(){
cin >> N;
for (int i = 0; i < N; i++){
ll A, B; cin >> A >> B;
if (A != B) flag = true;
sum += A;
if (A > B) m = min(m, B);
}
if (!flag) cout << 0 << endl;
else cout << sum - m << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1e9;
const ll LINF = ll(1e18);
const int MOD = 1000000007;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1}, Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) \
{ \
cout << x << ' '; \
} \
cout << endl;
template <class T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
if (b < a)
{
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll n,m,x;
cin>>n;
cout<<n/3<<"\n";
} | 0 | 100,602,474 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
int N, D[int(1e5 + 5)];
int main(){
cin >> N;
for (int i = 0; i < N; i++) cin >> D[i];
sort(D, D + N);
cout << D[N/2] - D[N/2 - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define INF 1e12
#define PB push_back
#define PF push_front
#define fi first
#define se second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vpi vector<pii>
#define vll vector<ll>
#define vpl vector<pll>
#define vvi vector<vector<int>>
#define vvl vector<vector<ll>>
#define mii map<int, int>
#define mci map<char, int>
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define pr_d(x) cout << fixed << setprecision(15) << x << endl
#define ud(c, x) distance(c.begin(), upper_bound(all(c), x))
#define ld(c, x) distance(c.begin(), lower_bound(all(c), x))
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define rep3(i, n) for (int i = (n - 1); i >= 0; --i)
#define rep4(i, a, b) for (int i = (a); i > (b); --i)
#define pb push_back
#define out(x) cout << x << "\n"
bool odd(int i) { return i % 2; }
#define all(v) v.begin(), v.end()
#define size(x) int(x.size())
int gcd(int a, int b) { return __gcd(a, b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
void Yes_No(bool f) {
if (f)
printf("Yes\n");
else
printf("No\n");
}
void YES_NO(bool f) {
if (f)
printf("YES\n");
else
printf("NO\n");
}
template <typename T>
void deb1(T x) {
cout << "debug: " << x << "\n";
}
template <typename T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void solve(void) {
int n;
cin >> n;
map<int, int> mp;
rep(i, n) {
int tmp;
cin >> tmp;
mp[tmp]++;
}
int ans = mp.begin()->se;
if (abs(next(mp.begin(), 1)->fi - mp.begin()->fi) < 2)
ans += next(mp.begin(), 1)->se;
if (abs(mp.end()->fi - next(mp.end(), -1)->fi < 2))
chmax(ans, mp.end()->se + next(mp.end(), -1)->se);
for (auto i = mp.begin(); i != mp.end(); ++i) {
if (i == mp.begin() || i == mp.end())
continue;
else if (abs(i->fi - next(i, -1)->fi) < 2 &&
abs(i->fi - next(i, 1)->fi) < 2)
chmax(ans, next(i, -1)->se + i->se + next(i, 1)->se);
}
out(ans);
}
int main(void) { solve(); } | 0 | 81,424,591 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
int x3,y3,x4,y4;
int len=0;
int dx=x2-x1;
int dy=y2-y1;
x3=x2-dy;
y3=y2+dx;
x4=x3-dx;
y4=y3-dy;
printf("%d %d %d %d",x3,y3,x4,y4);
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#define ll long long int
#define pb push_back
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
using namespace std;
int mx8[] = {0,0,1,-1,-1,1,-1,1};
int my8[] = {-1,1,0,0,-1,-1,1,1};
int mx4[] = {1,-1,0,0};
int my4[] = {0,0,-1,1};
const int MOD = 1000000007;
int main() {
string s; cin >> s;
int n = s.size();
map<char,int> mp;
rep(i,n){
if(mp[s[i]]){
cout << "no" << endl;
return 0;
}
mp[s[i]]++;
}
cout << "yes" << endl;
} | 0 | 26,535,423 |
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <regex>
#include <locale>
#include <iomanip>
using namespace std;
using ll = long long;
#define OVERLOAD3(_1,_2,_3,name,...) name
#define REP(i,n) REPI(i,0,n)
#define REPI(i,a,b) for(int i=int(a),i##_Len=int(b);i<i##_Len;++i)
#define rep(...) OVERLOAD3(__VA_ARGS__,REPI,REP,)(__VA_ARGS__)
#define ALL(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
int main () {
int a, b; cin >> a >> b;
cout << ((a+b)%2 == 0 ? (a+b)/2 : (a+b+1)/2) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0, i##_len = (n); i < i##_len; i++)
#define reps(i, s, n) for(int i = (s), i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for(int i = (n) - 1; i >= 0; i--)
#define rreps(i, e, n) for(int i = (n) - 1; i >= (e); i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define uniq(x) (x).erase(unique((x).begin(), (x).end()), (x).end())
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, d;
cin >> n >> m >> d;
double b = (double)(n - d) / (n * n);
if (d != 0) b *= 2.0;
double ans = b * (m - 1);
printf("%.10f\n", ans);
return 0;
} | 0 | 19,385,960 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll,ll>;
using pi = pair<int,int>;
#define all(x) x.begin(),x.end()
#define rep(i,j,n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
const ll MOD = 1000000007;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
bool check(ll a, ll b){
rep(i,0,21){
if((a>>i&1) && (b>>i&1))return false;
}
return true;
}
signed main(){
int n; cin >> n;
vl a(n+1);
rep(i,0,n)cin >> a[i];
ll ans = 0;
ll l = 0 , r = 0;
ll now = 0;
rep(i,1,n+1){
while(r < n && check(now , a[r])){
now ^= a[r++];
}
ans += (r - l);
now ^= a[l++];
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
long calc(long n,vector<long>&dp,long mod){
if(n<3)return 0;
if(dp[n]!=0)return dp[n];
for(int i=3;i<=n;i++){
if(n!=i)dp[n] += calc(n-i,dp,mod);
else dp[n]++;
dp[n] %= mod;
}
dp[n]%=mod;
return dp[n];
}
int main(){
long s;
cin >> s;
long const mod = 1e9+7;
vector<long>dp(s+1);
if(s>=3)dp[3] = 1;
cout << calc(s,dp,mod)<<endl;
} | 0 | 84,902,009 |
#include<bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
using namespace std;
int a,b,x;
int main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
cin>>a>>b>>x;
if(x<a||x>=(a+b))cout<<"NO\n";
else
cout<<"YES\n";
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,k;
cin>>a>>b>>c>>k;
while(b<=a)
{
b*=2;
k--;
}
while(c<=b)
{
c*=2;
k--;
}
if(k<0)cout<<"No";
else cout<<"Yes";
} | 0 | 86,573,131 |
#include <bits/stdc++.h>
#include <vector>
#define rep(i, n) for(int i = 0; i < n; ++i)
#define ll long long
using namespace std;
int main() {
int mod = 1000000007;
int s;
cin >> s;
vector<int> dp(s+1, 0);
dp[0] = 1;
for(int i = 3; i <= s; ++i) {
for(int j = 0; j <= i-3; ++j) {
dp.at(i) += dp.at(j);
dp.at(i) %= mod;
}
}
cout << dp.at(s) << 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() {
ll n, h;
cin >> n >> h;
vector<ll> a(n);
vector<ll> b(n);
rep(i,n) {
cin >> a[i] >> b[i];
}
sort(a.begin(), a.end(), greater<ll>());
sort(b.begin(), b.end(), greater<ll>());
ll a_attack = a[0];
bool is_a = false;
int cnt = 0;
int cur_h = 0;
int cur_b = 0;
while(cur_h < h) {
if(!is_a && a_attack < b[cur_b]) {
cur_h += b[cur_b];
cur_b++;
cnt++;
if(cur_b > n) {
is_a = true;
}
} else {
is_a = true;
}
if(is_a) {
ll res = h - cur_h;
ll res_cnt = res / a_attack;
if(res % a_attack != 0) {
res_cnt++;
}
cnt += res_cnt;
break;
}
}
cout << cnt << endl;
return 0;
} | 0 | 65,209,462 |
#include<bits/stdc++.h>
#define ll long long int
#define vec vector<ll>
#define mat vector<vec>
using namespace std;
const ll mod=1000000007;
ll dx4[4]={1,0,-1,0};
ll dy4[4]={0,-1,0,1};
ll dx8[8]={1,0,-1,1,-1,1,0,-1};
ll dy8[8]={1,1,1,0,0,-1,-1,-1};
int main() {
ll K,S; cin>>K>>S;
ll cnt=0;
for(ll i=K; i>=0; i--){
if(S-i<0) continue;
if(S-i>2*K) break;
for(ll j=i; j>=0; j--){
ll x=S-i-j;
if(x>j) break;
if(x<0) continue;
if(i==j&&i==x) cnt++;
else if(i!=j&&i!=x&&j!=x) cnt+=6;
else cnt+=3;
}
}
cout<<cnt<<endl;
} | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
#define fi first
#define se second
#define debug(x) cout << #x << ": " << x << '\n';
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
template<typename T1, typename T2> inline void chmin(T1& a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
template<class T> void Print(vector<T> v) {
F0R(i, v.size()) {
cout << v[i] << ' ';
}
cout << newl;
}
#if 1
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N;
cin >> N;
set<int> as;
F0R(i, N) {
int a;
cin >> a;
as.insert(a);
}
while (as.size() > 1) {
set<int> bs;
int a = -1;
for (auto n : as) {
if (a < 0) a = n;
else {
int b = n % a;
if (b) bs.insert(b);
}
}
bs.insert(a);
as = move(bs);
}
cout << *as.begin();
}
#endif | 0 | 75,155,911 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n; cin >>n;
int dai=0;
int shou=INT_MAX;
for(int i=0;i<n;i++){
int x;
cin>>x;
dai=max(dai,x);
shou=min(shou,x);
}
cout<<dai-shou<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1 << 29)
#define LLINF (1LL << 60)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
using Pi = pair<int, int>;
using ll = long long;
string to_string(string s) { return s; }
template <class S>
string to_string(unordered_set<S> s);
template <class S>
string to_string(set<S> s);
template <class S, class T>
string to_string(map<S, T> m);
template <class T>
string to_string(vector<T> v);
template <class S, class T>
string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
template <class S>
string to_string(unordered_set<S> s) {
string ret = "{";
for (S x : s) ret += to_string(x) + ",";
return ret + "}";
}
template <class S>
string to_string(set<S> s) {
string ret = "{";
for (S x : s) ret += to_string(x) + ",";
return ret + "}";
}
template <class S, class T>
string to_string(map<S, T> m) {
string ret = "{";
for (pair<S, T> x : m) ret += to_string(x) + ",";
return ret + "}";
}
template <class T>
string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < (int)v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail>
void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail>
void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
struct fastIO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
template <class T>
inline void read(T &x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && c < '0' && '9' < c);
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus) x = -x;
}
inline void read(string &x) {
char c;
x = "";
do {
c = getchar_unlocked();
x += c;
} while (c != ' ' && c != '\n');
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &... tail) {
read(head);
read(tail...);
}
template <class T>
inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(string x) {
for (char c : x) putchar_unlocked(c);
}
template <class Head, class... Tail>
inline void write(Head &head, Tail &... tail) {
write(head);
write(tail...);
}
} io;
int main() {
int M;
io.read(M);
ll sum = 0, ans = 0;
FOR(i, M) {
ll d, c;
io.read(d, c);
sum += d * c;
ans += c;
}
ans--;
while (sum >= 10) {
ans += sum / 10;
sum = sum % 10 + sum / 10;
}
io.write(ans);
return 0;
} | 0 | 97,676,096 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < (n); i++)
#define REPS(i, n) for(int i = 1; i <= (n); i++)
#define RREP(i, n) for(int i = (n)-1; i >= 0; i--)
#define RREPS(i, n) for(int i = (n); i > 0; i--)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define mt make_tuple
#define pb push_back
using ll = long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const ll INFL = 1e18;
const double PI = 3.141592653589793;
const double EPS = 1e-9;
template<class T> bool chmax(T &a, const T &b) { if(a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if(a > b) { a = b; return true; } return false; }
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N; cin >> N;
cout << N*800 - N/15*200 << endl;
} | #include <bits/stdc++.h>
using namespace std;
struct edge {
int to;
int weight;
edge(int t, int w) : to(t), weight(w) { }
};
using Graph = vector<vector<int>>;
using dou =long double;
string Yes="Yes";
string YES="YES";
string NO="NO";
string No="No";
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(int i = 0; i < (int)(n); i++)
#define brep(n) for(int bit=0;bit<(1<<n);bit++)
#define erep(i,container) for (auto i : container)
#define irep(i, n) for(int i = n-1; i >= (int)0; i--)
#define rrep(i,m,n) for(int i = m; i < (int)(n); i++)
#define reprep(i,j,h,w) rep(i,h)rep(j,w)
#define all(x) (x).begin(),(x).end()
#define aall(x,n) (x).begin(),(x).begin()+(n)
#define VEC(type,name,n) std::vector<type> name(n);rep(i,n)std::cin >> name[i];
#define pb push_back
#define pf push_front
#define lb lower_bound
#define ub upper_bound
#define res resize
#define as assign
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum(a) accumulate(all(a),0ll)
#define keta fixed<<setprecision
#define vvector(name,typ,m,n,a)vector<vector<typ> > name(m,vector<typ> (n,a))
#define vvvector(name,t,l,m,n,a) vector<vector<vector<t> > > name(l, vector<vector<t> >(m, vector<t>(n,a)));
#define vvvvector(name,t,k,l,m,n,a) vector<vector<vector<vector<t> > > > name(k,vector<vector<vector<t> > >(l, vector<vector<t> >(m, vector<t>(n,a)) ));
typedef long long ll;
const int INF = 2000000000;
const ll INF64 = 922337203685477580ll;
const int mod = 1000000007ll;
const ll MOD = 1000000007LL;
struct LazySegmentTree {
private:
int n;
vector<ll> node, lazy;
public:
LazySegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1; while(n < sz) n *= 2;
node.resize(2*n-1);
lazy.resize(2*n-1, 0);
for(int i=0; i<sz; i++) node[i+n-1] = v[i];
for(int i=n-2; i>=0; i--) node[i] = node[i*2+1] + node[i*2+2];
}
void eval(int k, int l, int r) {
if(lazy[k] != 0) {
node[k] += lazy[k];
if(r - l > 1) {
lazy[2*k+1] += lazy[k] / 2;
lazy[2*k+2] += lazy[k] / 2;
}
lazy[k] = 0;
}
}
void add(int a, int b, ll x, int k=0, int l=0, int r=-1) {
if(r < 0) r = n;
eval(k, l, r);
if(b <= l || r <= a) return;
if(a <= l && r <= b) {
lazy[k] += (r - l) * x;
eval(k, l, r);
}
else {
add(a, b, x, 2*k+1, l, (l+r)/2);
add(a, b, x, 2*k+2, (l+r)/2, r);
node[k] = node[2*k+1] + node[2*k+2];
}
}
ll getsum(int a, int b, int k=0, int l=0, int r=-1) {
if(r < 0) r = n;
eval(k, l, r);
if(b <= l || r <= a) return 0;
if(a <= l && r <= b) return node[k];
ll vl = getsum(a, b, 2*k+1, l, (l+r)/2);
ll vr = getsum(a, b, 2*k+2, (l+r)/2, r);
return vl + vr;
}
};
int main(){
int n;
ll d,a;
std::cin >> n>>d>>a;
std::vector<ll> x(n),h(n),p(n);
rep(i,n){
std::cin >> x[i]>>h[i];
}
std::vector<pair<ll,ll>>pai(n) ;
rep(i,n){
pai[i].fi=x[i];
pai[i].se=h[i];
}
sort(all(pai));
rep(i,n){
x[i]=pai[i].fi;
h[i]=pai[i].se;
}
LazySegmentTree s(std::vector<ll>(n,0));
rep(i,n){
s.add(i,i+1,h[i]);
}
ll ans=0;
rep(i,n){
p[i]=int(ub(all(x),x[i]+2*d)-x.begin());
}
rep(i,n){
if(s.getsum(i,i+1)>0){
ll cnt=ceil(double(s.getsum(i,i+1))/a);
ll da=cnt*a;
s.add(i,p[i],-da);
ans+=cnt;
}
}
std::cout << ans << std::endl;
} | 0 | 45,297,612 |
#include <stdio.h>
#define MAX 26
int main(void)
{
char c;
while ((c=getchar()) != '\n') {
if ((c>='A') && (c<='Z')) {
c += ' ';
}
else if ((c>='a') && (c<='z')) {
c -= ' ';
}
else {
;
}
printf("%c",c);
}
printf("\n");
return 0;
} | #include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
typedef long long ll;
#define FAST ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define mp make_pair
#define pb push_back
#define lp(i,s,f) for(ll i = s; i < ll(f); i++)
#define inF freopen("input.in", "r", stdin);
#define outF freopen("output.in", "w", stdout);
#define MOD ll(1000000007)
#define debug(x) cout << '[' << #x << " is: " << x << "] " <<endl;
#define decimalpoint cout << std::fixed << setprecision(5)
int h,n;
int yes[1003], no[1003];
int dp[10005];
long long calc(int now){
if (now <= 0)return 0;
if (dp[now] != -1)return dp[now];
long long ans = 2e9;
for (int i = 0 ; i < n ; i++){
ans = min(ans, calc(now - yes[i]) + no[i]);
}
return dp[now] = ans;
}
void solve(){
cin >> h >> n;
for (int i = 0 ; i < n ; i++){
cin >> yes[i] >> no[i];
}
memset(dp, -1 , sizeof dp);
cout << calc(h) << endl;
}
int main()
{
FAST;
int t;
t = 1;
while(t--){
solve();
}
return 0;
} | 0 | 62,253,766 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using P = pair<lint, lint>;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
constexpr int MOD = 1000000007;
constexpr int INF = 2147483647;
void yes(bool expr) {
cout << (expr ? "Yes" : "No") << "\n";
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int N, K;
cin >> N >> K;
vector<lint> a(N);
REP(i, N) cin >> a[i];
vector<lint> S(N+1);
REP(i, N) S[i+1] += S[i] + a[i];
vector<lint> Splus(N+1);
REP(i, N) Splus[i+1] += Splus[i] + (a[i]>0 ? a[i] : 0);
lint ans = 0;
REP(i, N) {
if(i+K > N) break;
if(Splus[i] + S[i+K]-S[i] + Splus[N]-Splus[i+K]> ans) ans = Splus[i] + S[i+K]-S[i] + Splus[N]-Splus[i+K];
if(Splus[i] + Splus[N]-Splus[i+K] > ans) ans = Splus[i] + Splus[N]-Splus[i+K];
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main(void){
while(true){
int n=0, min = 10000000, dif=0, score[1010];
cin >> n;
if(n==0) break;
for(int i=0;i<n;++i) cin >> score[i];
for(int i=0;i<n;++i){
for(int j=i+1;j<n;++j){
int dif = abs(score[i]-score[j]);
if(min > dif) min = dif;
}
}
cout << min << endl;
}
} | 0 | 81,480,990 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<n; i++)
#define PI 3.14159265359
#define INF 1000100100
#define MOD 1000000007
#define all(x) (x).begin(),(x).end()
typedef long long ll;
#define P pair<int, int>
#define PP pair<P,P>
#define T tuple<int,int,int>
using namespace std;
int main(){
string s; cin >> s;
int sl=s.length();
ll ans=((ll)sl*(ll)(sl-1))/2;
map<char,int> m;
rep(i,sl) m[s[i]]++;
for(auto x : m) ans-=((ll)(x.second)*(ll)(x.second-1))/2;
cout << ans+1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define per(i, n) for (int i = (int)(n-1); i >= 0; i--)
#define sz(x) int(x.size())
#define all(x) (x).begin(), (x).end()
#define INF 2e9
#define LINF 1e18
template<class T> inline bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b) { if (a > b) { a = b; return 1; } return 0; }
typedef long long ll;
typedef pair<int, int> P;
int main() {
int n, k; cin >> n >> k;
vector<vector<int> > tmp(n);
rep(i, n) {
int t0, d0;
cin >> t0 >> d0;
t0--;
tmp[t0].push_back(d0);
}
rep(i, n) sort(all(tmp[i]), greater<int>());
vector<int> y1, y0;
rep(i, n) {
if (sz(tmp[i]) == 0) continue;
y1.push_back(tmp[i][0]);
for (int j=1; j<sz(tmp[i]); j++) {
y0.push_back(tmp[i][j]);
}
}
sort(all(y1), greater<int>());
sort(all(y0), greater<int>());
ll ans = 0;
for (int i=1; i<=min(sz(y1), k); i++) {
ll tmp = (ll)i*i;
rep(j, i) tmp += y1[j];
int m = k-i;
if (sz(y0) < m) continue;
rep(j, m) {
tmp += y0[j];
}
chmax(ans, tmp);
}
cout << ans << endl;
} | 0 | 14,008,843 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main()
{
string s;
cin >> s;
int n = s.size();
int num = 753;
int ans = 1e9;
rep(i, n - 2)
{
int x = 0;
rep(j, 3)
{
x *= 10;
x += s[i + j] - '0';
}
ans = min(ans, abs(num - x));
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
void dfs(const vector<vector<int>> &tree, vector<ll> &q, int now, int bf){
if(now != 0) q.at(now) += q.at(bf);
for(auto nx : tree.at(now)){
if(nx == bf) continue;
dfs(tree, q, nx, now);
}
}
int main(){
int n, qe;
cin >> n >> qe;
vector<vector<int>> tree(n, vector<int>());
rep(i, n-1){
int a, b;
cin >> a >> b;
a--; b--;
tree.at(a).push_back(b);
tree.at(b).push_back(a);
}
vector<ll> q(n, 0);
rep(i, qe){
int qin, x;
cin >> qin >> x;
qin--;
q.at(qin) += x;
}
dfs(tree, q, 0, -1);
rep(i, n){
if(i != 0) cout << " ";
cout << q.at(i);
}
cout << endl;
return 0;
} | 0 | 33,333,775 |
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#include <cstring>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define irep(it, stl) for (auto it = stl.begin(); it != stl.end(); it++)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << '\n'
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return 1;
}
return 0;
}
struct io
{
io()
{
ios::sync_with_stdio(false);
cin.tie(0);
}
};
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
const double EPS = 1e-9;
int main(){
int l;
cin >> l;
double x = 0.0;
x = (double)l / 3;
printf("%lf", x*x*x);
return 0;
} | #include <iostream>
using namespace std;
int main() {
string stra;
int x;
bool r=false;
cin >> stra;
for(int i=97;i<=122;i++){
if(stra.find((char)i)==-1){
cout << (char)i << endl;
r=true;
break;
}
}
if(r==false){
cout << "None" << endl;
}
} | 0 | 72,801,531 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(void){
int n, m, total = 0, ok = 0;
cin >> n >> m;
vector<int> a(n);
for(int i = 0; i < n; i++) cin >> a[i];
for(int i = 0; i < n; i++) total += a[i];
for(int i = 0; i < n; i++){
if(4*a[i]*m >= total) ok++;
}
if(ok >= m) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define FastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define reset(x) memset(x,-1,sizeof(x))
#define CheckBit(a,b) (a&(1ll<<b))
#define SetBit(a,b) a=(a|(1ll<<b))
#define UnSetBit(a,b) a=(a&(~(1ll<<b)))
#define maxx 10000006
#define PI 2*acos(0.0)
const long long INF = 2000000000000000000LL;
const int inf = 0x3f3f3f3f;
const long double EPS = 1e-9;
inline ll mulmod(ll a, ll b, ll c) {
ll ret = 0 , cur = a % c ;
while(b) { if(b%2) ret=(ret+cur)%c; cur=(cur<<1)%c; b=b>>1; }
return ret%c;
}
inline ll bigmod(ll b, ll p, ll m){
ll ret = 1, cur = b % m;
while(p) { if(p&1) ret=(ret*cur)%m; cur=(cur*cur)%m; p=p>>1; }
return ret;
}
inline ll modulo(ll a,ll b,ll c) {
ll ret = 1 , cur = a%c ;
while(b) { if(b%2) ret=mulmod(ret,cur,c); cur=mulmod(cur,cur,c); b=b>>1; }
return ret%c ;
}
inline ll power(ll b, ll p){
ll ret = 1, cur = b;
while(p) { if(p&1) ret=(ret*cur); cur=(cur*cur); p=p>>1; }
return ret;
}
ll lcm(ll a,ll b)
{
return (a/__gcd(a,b))*b;
}
ll gcd(ll a,ll b)
{
return __gcd(a,b);
}
void Dufaux()
{
set<char>st;
string s;
cin>>s;
for(int i=0;i<s.size();i++){
st.insert(s[i]);
}
ll m=st.size();
ll n=s.size();
if(m==n){
cout<<"yes"<<endl;
}
else{
cout<<"no"<<endl;
}
}
int main()
{
FastIO;
int test=1;
while(test--){
Dufaux();
}
return 0;
} | 0 | 96,406,360 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define REP(i, n) for (LL i = 0; i < (LL)(n); i++)
#define REP2(i, n) for (LL i = 1; i <= (LL)(n); i++)
#define FOR(i, m, n) for (LL i = m; i < n; i++)
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define ALL(x) (x).begin(), (x).end()
#define SUM(x) accumulate(x.begin(), x.end(),0)
#define vLL(v,n) vector<LL> v(n); REP(i,n)cin>>v[i];
#define vstr(v,n) vector<string> v(n); REP(i,n)REP(i,n)cin>>v[i];
LL INF = 1e9 + 1;
LL MOD = 1e9+7;
LL a,b,c,d,e,n,m,l,k,r,x,y,z,ans=0,ans2=0,h,w;
string s,S,t;
int main() {
ios_base::sync_with_stdio(false);
vector<LL>L(87);
L[0]=2;
L[1]=1;
cin >> n;
FOR(i,2,87){
L[i]=L[i-2]+L[i-1];
}
cout <<L[n];
} | #include <bits/stdc++.h>
using namespace std;
using pll=pair<long long,long long>;
const long double pi=atan2l(0,-1);
int N;
pair<long long,long long> operator+(pair<long long,long long> &a,pair<long long,long long> &b) {
return make_pair(a.first+b.first,a.second+b.second);
}
int main() {
cin >> N;
vector<pll> A(N);
for (int i=0;i<N;i++) {
cin >> A[i].first >> A[i].second;
}
vector<pair<long double,int>> arg(2*N);
for (int i=0;i<N;i++) {
arg[i]=make_pair(atan2(A[i].second,A[i].first),i);
arg[i+N]=make_pair(atan2(A[i].second,A[i].first)+2*pi,i);
}
sort(arg.begin(),arg.end());
long double ans=0;
for (int i=0;i<N;i++) {
int j=i;pair<long long,long long> X=make_pair(A[arg[i].second].first,A[arg[i].second].second);
while (((X.first+A[arg[j+1].second].first)*A[arg[j+1].second].first+(X.second+A[arg[j+1].second].second)*A[arg[j+1].second].second>=
-1*X.first*A[arg[j+1].second].first-X.second*A[arg[j+1].second].second && arg[j+1].first-atan2(X.second,X.first)<pi)
|| X.first*A[arg[j+1].second].first+X.second*A[arg[j+1].second].second>=0 && j+1<i+N) {
j++;
X=X+A[arg[j].second];
}
long long x=0LL,y=0LL;
for (int k=i;k<=j;k++) {
x+=A[arg[k].second].first;
y+=A[arg[k].second].second;
}
long double d=sqrt(x*x+y*y);
ans=max(ans,d);
}
cout << setprecision(20) << ans << endl;
} | 0 | 49,482,431 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<set>
#include<map>
#include<queue>
#include<cmath>
#define REP(i,a) for (int i = 0;i < (a);++i)
#define FOR(i,a,b) for (int i = (a);i < (b); ++i)
#define FORR(i,a,b) for (int i = (a);i >= (b); --i)
#define ALL(obj) (obj).begin(),(obj).end()
#define SORT(list) sort(ALL((list)));
#define MOD 1000000007
using namespace std;
using ll = long long;
int main(){
string s;
cin >> s;
string key = "keyence";
REP(i,7){
string a = s.substr(0,7-i);
string b = s.substr(s.length()-i,i);
if(a+b==key){
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(i = 0;i < n;++i)
#define all(v) v.begin(), v.end()
using ll = long long;
int main()
{
ll i,j;
ll n;
cin >> n;
vector<pair<ll,ll>> a(n);
for(i = 0;i < n;++i){
cin >> a.at(i).first;
a.at(i).second = i;
}
sort(all(a));
ll ans = 0;
for(i = 0;i < n;++i){
ll ind = a.at(i).second;
if((ind-i)%2) ++ans;
}
cout << ans/2 << endl;
return 0;
} | 0 | 6,658,660 |
#include<bits/stdc++.h>
using namespace std;
struct point{
double x, y;
};
void koch(int n, point p1, point p2){
point p3, p4, p5;
double rad60=M_PI*60.0/180.0;
if(n==0) return;
p3.x=(2.0*p1.x+p2.x)/3.0;
p3.y=(2.0*p1.y+p2.y)/3.0;
p4.x=(p1.x+2.0*p2.x)/3.0;
p4.y=(p1.y+2.0*p2.y)/3.0;
p5.x=(p4.x-p3.x)*cos(rad60)-(p4.y-p3.y)*sin(rad60)+p3.x;
p5.y=(p4.x-p3.x)*sin(rad60)+(p4.y-p3.y)*cos(rad60)+p3.y;
koch(n-1, p1, p3);
printf("%.8f %.8f\n", p3.x, p3.y);
koch(n-1, p3, p5);
printf("%.8f %.8f\n", p5.x, p5.y);
koch(n-1, p5, p4);
printf("%.8f %.8f\n", p4.x, p4.y);
koch(n-1, p4, p2);
}
int main(void){
int n;
point p1, p2;
scanf("%d", &n);
p1.x=0.0; p1.y=0.0;
p2.x=100.0; p2.y=0;
printf("%.8f %.8f\n", p1.x, p1.y);
koch(n, p1, p2);
printf("%.8f %.8f\n", p2.x, p2.y);
return 0;
} | #include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<numeric>
#include<vector>
#include<cstdio>
#include<climits>
#include<cfloat>
#include<cstring>
#define rforeach(t,p) for(t::reverse_iterator it=p.rbegin();it!=p.rend();++it)
#define all(p) p.begin(),p.end()
#define REP(i,n) for(int i=0;i<n;i++)
#define foreach(t,p,tit) for(t::iterator tit=p.begin();tit!=p.end();++tit)
using namespace std;
int main()
{
int n=0,maxn=0,maxlen=0;
string ss,maxs="",maxns;
map<string,int > tango;
map<string,int>::iterator it;
while(cin>>ss)
{
if(maxlen <ss.size())
{
maxlen = ss.size();
maxs = ss;
}
it = tango.find(ss);
if(it==tango.end())
{
tango.insert(map<string,int>::value_type(ss,1));
}
else
{
n = (*it).second+ 1;
tango.erase(it);
tango.insert(map<string,int>::value_type(ss,n));
maxn = max(n,maxn);
}
}
for(map<string,int>::iterator it2=tango.begin();it2!=tango.end(); ++it2)
if( (*it2).second == maxn){cout << (*it2).first; break;}
cout << " " << maxs << endl;
return 0;
} | 0 | 19,132,604 |
#include <bits/stdc++.h>
#define PI 3.141592653
#define rep(i,a,n) for(int i=a;i<(int)n;++i)
#define SZ(x) ((int)(x).size())
#define descSort(a) sort(a.begin(),a.end(),std::greater<int>())
using namespace std;
typedef long long ll;
const ll INF = 1e9 + 7;
ll gcd(ll x,ll y){
if(x%y==0)return y;
return gcd(y,x%y);
}
int main(void){
int n;
cin>>n;
vector<int> a(n);
rep(i,0,n)cin>>a[i];
vector<int> dp(n,INF);
rep(i,0,n){
*lower_bound(dp.begin(),dp.end(),a[i])=a[i];
}
cout<<lower_bound(dp.begin(),dp.end(),INF)-dp.begin()<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
typedef int64_t Int;
int N;
vector<int> A(200010);
int main(){
cin >> N;
rep(i,N) cin >> A[i];
int l = 0, r = 0; Int ans = 0;
bitset<22> bit(A[0]);
while(l < N){
while(true){
if(r == N-1) break;
int nr = r+1;
bitset<22> cur_bit(A[nr]);
if((bit | cur_bit) == (bit ^ cur_bit)){
bit |= cur_bit;
} else {
break;
}
r++;
}
ans += r-l+1;
bitset<22> bit_l(A[l]);
bit ^= bit_l;
l++;
}
cout << ans << endl;
} | 0 | 9,771,340 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y;
cin >> x >> y;
if(x % y == 0){
cout << -1 << endl;
return 0;
}
long long k = 1;
while(1){
long long ans = k * x;
if(ans % y == 0){
k++;
continue;
}
cout << ans << endl;
return 0;
}
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i,n) for(long long i = 0; i < (n); ++i)
#define ll long long
#define P pair<ll,ll>
#define all(v) (v).begin(),(v).end()
const ll mod = 1e9+7;
const ll INF = 1e18;
const double pi = acos(-1.0);
int main(void)
{
ll a, b;
cin >> a >> b;
for(int i=1;i<=1009;i++){
if(i*8/100==a && i*10/100==b){
cout<<i<<endl;
return 0;
}
}
cout<<-1<<endl;
return 0;
} | 0 | 61,600,545 |
#include <bits/stdc++.h>
#include <algorithm>
#include <queue>
using namespace std;
int main() {
int N;
cin >> N;
int T[110] = {};
int V[110] = {};
int S[110] = {};
for(int i = 1; i <= N; i++){
cin >> T[i];
S[i] = S[i-1] + T[i] * 2;
}
for(int i = 1; i <= N; i++){
cin >> V[i];
}
int A[40010] = {};
for(int t = 0; t <= S[N]; t++){
A[t] = min(t, S[N] - t);
}
for(int i = 1; i <= N; i++){
for(int t = 0; t <= S[N]; t++){
if(t < S[i-1]){A[t] = min(A[t], V[i] * 2 - t + S[i-1]);}
else if(t >= S[i-1] && t <= S[i]){A[t] = min(A[t], V[i] * 2);}
else if(t > S[i]){A[t] = min(A[t], V[i] * 2 + t - S[i]);}
}
}
int ans = 0;
for(int i = 1; i < S[N]; i++){
ans += A[i];
}
cout.precision(10);
cout << (double) ans * 0.25 << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main() {
int N, K; cin >> N >> K;
vector<int> A(N);
for (auto& a: A) cin >> a;
for (int i = 0; i < K; i++) {
vector<int> B(N+1);
for (int j = 0; j < N; j++) {
B[max(j - A[j], 0)]++;
B[min(j + A[j] + 1, N)]--;
}
for (int j = 1; j <= N; j++) {
B[j] += B[j-1];
}
B.pop_back();
swap(A, B);
if (*min_element(A.begin(), A.end()) == N) break;
}
for (int i = 0; i < N; i++) {
cout << A[i] << " \n"[i==N-1];
}
} | 0 | 38,754 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, A;
int chk;
cin >> N >> A;
chk = N % 500;
if(chk == 0){
cout << "Yes" << endl;
}else if((A - chk) > 0){
cout << "Yes" << endl;
}else {
cout << "No" << 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 <functional>
#include <ctime>
#include <fstream>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll ll_gcd(ll a, ll b) {
if (a < b) return ll_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
struct UnionFind {
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
vector<int> tpsort(vector<vector<int>>& G) {
int V = G.size();
vector<int> sorted_vertices;
queue<int> que;
vector<int> indegree(V);
for (int i = 0; i < V; i++) {
for (int j = 0; j < G[i].size(); j++) {
indegree[G[i][j]]++;
}
}
for (int i = 0; i < V; i++) {
if (indegree[i] == 0) {
que.push(i);
}
}
while (que.empty() == false) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
indegree[u] -= 1;
if (indegree[u] == 0) que.push(u);
}
sorted_vertices.push_back(v);
}
return sorted_vertices;
}
struct Point
{
double x;
double y;
};
struct LineSegment
{
Point start;
Point end;
};
double tenkyori(const LineSegment& line, const Point& point)
{
double x0 = point.x, y0 = point.y;
double x1 = line.start.x, y1 = line.start.y;
double x2 = line.end.x, y2 = line.end.y;
double a = x2 - x1;
double b = y2 - y1;
double a2 = a * a;
double b2 = b * b;
double r2 = a2 + b2;
double tt = -(a * (x1 - x0) + b * (y1 - y0));
if (tt < 0)
return sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
else if (tt > r2)
return sqrt((x2 - x0) * (x2 - x0) + (y2 - y0) * (y2 - y0));
double f1 = a * (y1 - y0) - b * (x1 - x0);
return sqrt((f1 * f1) / r2);
}
void dfs1(vector<vector<ll>>& z, ll k, ll oya, ll& ans, vector<ll>& b) {
for (auto m : z[k]) {
if (m != oya)dfs1(z, m, k, ans, b);
}
vector<ll> s;
for (auto m : z[k]) {
if (m != oya)s.push_back(b[m]);
}
ll m = b.size() - 1;
for (auto d : s) {
m -= d;
}
b[k] = b.size() - m;
if (m != 0)s.push_back(m);
ll a = modinv(2, 1000000007);
for (auto d : s) {
a += 1000000007 - modinv(modpow(2, b.size() - d, 1000000007), 1000000007);
}
a += modinv(modpow(2, b.size(), 1000000007), 1000000007) * (z[k].size() - 1);
ans += a;
ans %= 1000000007;
return;
}
ll merge_cnt(vector<int>& a) {
int n = a.size();
if (n <= 1) { return 0; }
ll cnt = 0;
vector<int> b(a.begin(), a.begin() + n / 2);
vector<int> c(a.begin() + n / 2, a.end());
cnt += merge_cnt(b);
cnt += merge_cnt(c);
int ai = 0, bi = 0, ci = 0;
while (ai < n) {
if (bi < b.size() && (ci == c.size() || b[bi] <= c[ci])) {
a[ai++] = b[bi++];
}
else {
cnt += n / 2 - bi;
a[ai++] = c[ci++];
}
}
return cnt;
}
int main() {
ll n;
cin >> n;
ll m;
cin >> m;
UnionFind z(n);
UnionFind x(2*n);
ll zz = n;
ll xx = 2*n;
set<ll> d;
for (int i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
a--;
b--;
d.insert(a);
d.insert(b);
if (!z.issame(a, b)) {
z.merge(a, b);
zz--;
}
if (!x.issame(a+n, b)) {
x.merge(a+n, b);
xx--;
}
if (!x.issame(a, b+n)) {
x.merge(a, b+n);
xx--;
}
}
zz -= n - d.size();
xx -= 2*(n - d.size());
ll ans = n * n - (ll)d.size() * (ll)d.size();
ans += zz * zz;
ans += (xx - zz) * (xx - zz);
cout << ans << endl;
} | 0 | 12,809,856 |
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, n) for (ll i = 1; i < (ll)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
vector<pair<ll, ll> > prime_factorize(ll N) {
vector<pair<ll, ll> > res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
ll ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1) res.push_back({N, 1});
return res;
}
ll C2(ll n) {
if (n < 0) {
return 0;
}
return n * (n - 1) / 2;
}
void Main()
{
ll n;
cin >> n;
vector<ll> primeCnt(101);
for (ll i = 2; i <= n; i++) {
auto primes = prime_factorize(i);
for(auto p: primes) {
primeCnt[p.first] += p.second;
}
}
vector<ll> d(101);
rep(i, primeCnt.size()) {
if (primeCnt[i] <= 0) {
continue;
}
ll num = primeCnt[i];
rep(i, num + 1) {
d[i]++;
}
}
ll res = d[74];
res += C2(d[4]) * (d[2] - 2);
res += d[14] * (d[4] - 1);
res += d[24] * (d[2] - 1);
put(res);
}
signed main(){ Main();return 0;} | #if !defined(__clang__) && defined(__GNUC__)
#include <bits/stdc++.h>
#else
#include <cstdlib>
#include <climits>
#include <iostream>
#include <cstdint>
#include <vector>
#include <string>
#include <complex>
#include <bitset>
#include <queue>
#include <deque>
#include <stack>
#include <utility>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <regex>
#endif
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/multi_array.hpp>
#include <boost/optional.hpp>
#include <boost/math/common_factor_rt.hpp>
#include <boost/dynamic_bitset.hpp>
constexpr int64_t DIV1097 = 1000000007LL;
using namespace std;
int main()
{
int64_t N;
std::cin >> N;
std::vector<int64_t> A;
std::vector<int64_t> S;
int64_t sum = 0;
for (decltype(N) i = 0; i < N; ++i) {
int64_t t;
std::cin >> t;
A.push_back(t);
sum += t;
S.push_back(sum);
}
int64_t ans = INT64_MAX;
for (int64_t i = 0; i < N - 1; ++i) {
auto sunu = S[i];
auto kuma = S[N-1] - S[i];
auto diff = std::abs(sunu - kuma);
ans = std::min(ans, diff);
}
std::cout << ans << std::endl;
return 0;
} | 0 | 91,283,797 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<vector<int>> v(n, vector<int>(4, 0));
for (int i = 0; i < n; ++i)
cin >> v[i][1] >> v[i][2] >> v[i][3];
int dp[n][4];
memset(dp, -1, sizeof dp);
function<int(int, int)> calc_dp = [&] (int i, int j) {
if (dp[i][j] != -1) {
return dp[i][j];
}
if (i == 0) {
int best = -1;
for (int k = 1; k <= 3; ++k) {
if (k != j) {
best = max(best, v[0][k]);
}
}
return best;
}
int best = -1;
for (int k = 1; k <= 3; ++k) {
if (k != j) {
best = max(best, v[i][k] + calc_dp(i-1, k));
}
}
dp[i][j] = best;
return dp[i][j];
};
cout << max(max(calc_dp(n-1, 1), calc_dp(n-1, 2)), calc_dp(n-1, 3)) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t = 1;
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define printl(s) cout << s << endl;
#define rep(i,n) for(int i=0;i<(n);i++)
using ll = long long;
using vvi = vector<vector<int>>;
using pii = pair<int,int>;
const ll modSeed = pow(10,9) + 7;
const int INF = 1'000'000'000;
template <typename T>
vector<T> getVector(ll num){
vector<T> values(num);
for(ll i=0;i<num;i++){
cin >> values.at(i);
}
return values;
}
ll calculateDivNums(ll tg){
ll ans = 0;
for(ll a=1;a*a<=tg;a++){
if(tg%a!=0){
continue;
}
ans++;
if(tg!=a*a){
ans++;
}
}
return ans;
}
string S;
ll N,ans;
int main(){
ans = 0;
cin >> N;
for(ll a=1;a*a<=N;a++){
if(N%a!=0) continue;
ll b = N /a;
ll dig = max(log10(a)+1,log10(b)+1);
if(ans==0){
ans = dig;
} else{
ans = min(dig,ans);
}
}
printl(ans);
} | 0 | 48,607,434 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define F first
#define S second
#define FOR(i,a,b) for(int (i)=(a);(i)<(b);(i)++)
#define rep(i,n) FOR(i,0,n)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define ve vector
#define vi vector<int>
#define vp vector<pair<int,int>>
#define vvi vector<vector<int>>
template<typename T> using pq = priority_queue<T,vector<T>,greater<T>>;
using ll = long long;
ll INF = LLONG_MAX / 40 - 100;
ll mod = 1e9 + 7;
int dx[] = {-1,0,1,0}, dy[] = {0,1,0,-1};
vector<ll> prime;
class fact {
public:
int fmod = 1e9+7;
vector<int> fac, inv;
fact (int n, int Mod = 1e9+7) {
fmod = Mod;
fac = vector<int>(n,0);
inv = vector<int>(n,0);
fac[0] = 1; for (int i = 1; i < n; i++) fac[i] = fac[i-1] * i % fmod;
for (int i = 0;i < n;i++) inv[i] = fact::POW(fac[i],fmod-2);
}
ll nCr(ll n, ll r) {if(n < r) return 0; return (fac[n] * inv[r] % fmod) * inv[n-r] % fmod;}
ll POW(ll a, ll b) {ll c = 1; while (b > 0) {if (b & 1) {c = a * c%fmod;}a = a * a%fmod; b >>= 1;}return c;}
inline int operator [] (int i) {return fac[i];}
};
template <class T = ll> T in() {T x; cin >> x; return (x);}
void DEBUG(vector<int> a) {for(int i=0;i<a.size();i++)cout<<a[i]<<" ";cout<<endl;}
void EMP(int x) {cout<<"!!!"<<x<<"!!!"<<endl;}
ll GCD(ll a, ll b) {ll c; while (b != 0) {c = a % b; a = b; b = c;}return a;}
ll LCM(ll a, ll b) {return (a / GCD(a, b)) * (b / GCD(a, b)) * GCD(a, b);}
ll POW(ll a, ll b) {ll c = 1; while (b > 0) {if (b & 1) {c = a * c%mod;}a = a * a%mod; b >>= 1;}return c;}
void PRI(ll n) {bool a[n + 1LL]; for (int i = 0; i < n + 1LL; i++) {a[i] = 1LL;}for (int i = 2; i < n + 1LL; i++) {if (a[i]) {prime.pb(i); ll b = i; while (b <= n) {a[b] = 0; b += i;}}}}
template <typename T> T chmin(T& a, T b) {if(a>b)a=b;return a;}
template <typename T> T chmax(T& a, T b) {if(a<b)a=b;return b;}
bool isSqrt(ll a) {return pow(sqrt(a),2) == a ? 1 : 0;}
void YesNo(bool a) {if (a) cout << "Yes"; else cout << "No"; cout << endl;}
void yesno(bool a) {if (a) cout << "yes"; else cout << "no"; cout << endl;}
void YESNO(bool a) {if (a) cout << "YES"; else cout << "NO"; cout << endl;}
double dis(int x1, int x2, int y1, int y2) {
return sqrt((double)abs(x1-x2)*(double)abs(x1-x2)+(double)abs(y1-y2)*(double)abs(y1-y2));
}
bool solve() {
int n; cin >> n;
vi A(n); rep (i, n) cin >> A[i];
int ans = 0;
int ma = 0;
rep (i, n) {
if (i == 0) {
ans += A[i] - 1;
ma = 1;
} else {
if (A[i] > ma) {
if (A[i] == ma + 1) {
++ma;
} else {
if (A[i] % (ma + 1)) ans += A[i] / (ma + 1);
else ans += (A[i] / (ma + 1)) - 1;
}
}
}
}
cout << ans << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
} | #include<iostream>
#include <math.h>
using namespace std;
struct Vector2D{
double x;
double y;
};
#define Vertex2D Vector2D
Vector2D sub_vector(const Vector2D& a, const Vector2D& b)
{
Vector2D ret;
ret.x = a.x - b.x;
ret.y = a.y - b.y;
return ret;
}
int hittest_point_polygon_2d(Vertex2D A, Vertex2D B, Vertex2D C, Vertex2D P) {
Vector2D AB = sub_vector(B, A);
Vector2D BP = sub_vector(P, B);
Vector2D BC = sub_vector(C, B);
Vector2D CP = sub_vector(P, C);
Vector2D CA = sub_vector(A, C);
Vector2D AP = sub_vector(P, A);
double c1 = AB.x * BP.y - AB.y * BP.x;
double c2 = BC.x * CP.y - BC.y * CP.x;
double c3 = CA.x * AP.y - CA.y * AP.x;
if ((c1 > 0 && c2 > 0 && c3 > 0) || (c1 < 0 && c2 < 0 && c3 < 0)) {
return 0;
}
return 1;
}
int main(){
Vector2D A;
Vector2D B;
Vector2D C;
Vector2D P;
while (cin >> A.x >> A.y >> B.x >> B.y >> C.x >> C.y >> P.x >> P.y)
{
if (hittest_point_polygon_2d(A, B, C, P) == 0){
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
}
return 0;
} | 0 | 99,418,415 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define 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>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int main() {
int a,b,c;
cin >> a >> b >> c;
vector<int>vec = {a,b,c};
sort(vec.begin(), vec.end());
cout << vec[1] - vec[0] + vec[2] - vec[1] << endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
int pt1 = 0;
int pt2 = 0;
rep(i, s.size()) {
if(i % 2 == 0) {
if(s.at(i) == '0') pt1++;
if(s.at(i) == '1') pt2++;
}
else {
if(s.at(i) == '1') pt1++;
if(s.at(i) == '0') pt2++;
}
}
cout << min(pt1, pt2) << endl;
return 0;
} | 0 | 37,369,789 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using namespace std;
using P = pair<int, int>;
using ll = long long;
using M = map<int, int>;
int main()
{
int n, m;
cin >> n;
m = n + 1;
int a[m], b[n];
rep(i, m) cin >> a[i];
rep(i, n) cin >> b[i];
ll ans = 0;
rep(i, n) {
if(b[i] <= a[i]){
ans += b[i];
}
else{
ans += a[i];
b[i] -= a[i];
if(b[i] <= a[i + 1]){
ans += b[i];
a[i + 1] -= b[i];
}
else{
ans += a[i + 1];
a[i + 1] = 0;
}
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
long long int N, norma = 0, ans = 0, ans2 = 0;
cin >> N;
vector<int> A(N), B(N), sabun(N);
for (int i = 0; i < N; i++){
cin >> A.at(i);
}
for (int i = 0; i < N; i++){
cin >> B.at(i);
}
for (int i = 0; i < N; i++){
sabun.at(i) = B.at(i) - A.at(i);
if (B.at(i) - A.at(i) > 0){
norma += B.at(i) - A.at(i);
ans++;
}
}
sort(sabun.begin(), sabun.end());
while (norma > 0 && ans2 < N){
norma += sabun.at(ans2);
ans2++;
}
if (norma > 0){
cout << "-1" << endl;
}
else{
cout << ans + ans2 << endl;
}
} | 0 | 86,667,655 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX_N = 5e6+10;
string s;
int le[MAX_N], ri[MAX_N];
void solve()
{
const int n = s.length();
for(int i=0;i<n;++i){
if(s[i] == '<') le[i+1]=max(le[i+1], le[i]+1);
else le[i+1] = 0;
}
for(int i=n-1;i>=0;--i){
if(s[i] == '>') ri[i]=max(ri[i],ri[i+1]+1);
else ri[i] = 0;
}
ll ans = 0;
for(int i=0;i<=n;++i) ans+=max(le[i],ri[i]);
cout<<ans;
}
int main()
{
cin >> s;
solve();
return 0;
} | #include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
#define initdp(a, b) for (int i = 0; i <= a; i++) for (int j = 0; j <= b; j++) dp[i][j] = -1;
#define pb push_back
#define mpr make_pair
#define pii pair<int, int>
#define ll long long
#define pll pair<ll, ll>
#define all(arr) arr.begin(), arr.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define fo(i, l, r) for (int i = l; i <= r; i++)
#define inf 1000000001
#define inf1 1000000000000000001
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define N 1000005
#define mid(l, r) l + (r - l) / 2
#define vec vector<int>
#define vecl vector<ll>
#define umap unordered_map<int,int>
#define yes cout << "Yes" << endl;
#define no cout << "No" << endl;
#define endl "\n"
using namespace std;
void solve(){
ll a , b ,c , k;
cin>>a>>b>>c>>k;
ll ans = 0;
a = min(a,k);
ans = a;
k = k-a-b;
if(k>0) {
ans = ans - k;
}
cout<<ans;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed<<setprecision(20);
int t = 1;
while (t--)
{
solve();
}
} | 0 | 24,724,754 |
#include<iostream>
#include<cstdio>
#include<vector>
#include<map>
#include<string>
#include<sstream>
#include<cmath>
#include<climits>
#include<algorithm>
#include<bitset>
#include<set>
#include<stack>
#include<queue>
#include<iomanip>
#include<memory.h>
#include<complex>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef tuple<int,int> tii;
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define mt make_tuple
#define ALL(a) (a).begin(),(a).end()
#define FST first
#define SEC second
const int INF = (INT_MAX/2);
const ll LLINF = (LLONG_MAX/2);
const double eps = 1e-8;
const double PI = M_PI;
#define DEB cerr<<"!"<<endl
#define SHOW(a,b) cerr<<(a)<<" "<<(b)<<endl
#define SHOWARRAY(ar,i,j) REP(a,i)REP(b,j)cerr<<ar[a][b]<<((b==j-1)?((a==i-1)?("\n\n"):("\n")):(" "))
#define DIV int(1e9+7)
inline ll pow(ll x,ll n,ll m){ll r=1;while(n>0){if((n&1)==1)r=r*x%m;x=x*x%m;n>>=1;}return r%m;}
inline ll lcm(ll d1, ll d2){return d1 / __gcd(d1, d2) * d2;}
int main(){
ll n,m; cin >> n >> m;
ll ans = 0;
vector<ll> x(n+1),y(m+1);
rep(i,n) cin >> x[i+1];
rep(i,m) cin >> y[i+1];
ll xx=0,yy=0;
for(int i = 1; i <= n; i++){
xx += (i-1)*x[i] - (n-i)*x[i];
xx %= DIV;
}
for(int i = 1; i <= m; i++){
yy += (i-1)*y[i] - (m-i)*y[i];
yy %= DIV;
}
cout << (xx*yy)%DIV << endl;
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
# define M_PI 3.14159265358979323846
const int M=1e9+7;
long long mod(long long x){
return ((x%M + M)%M);
}
long long add(long long a, long long b){
return mod(mod(a)+mod(b));
}
long long mul(long long a, long long b){
return mod(mod(a)*mod(b));
}
ll modPow(ll a, ll b){
if(b==0)
return 1LL;
if(b==1)
return a%M;
ll res=1;
while(b){
if(b%2==1)
res=mul(res,a);
a=mul(a,a);
b=b/2;
}
return res;
}
void solve (){
int n;
n=5;
vector<int>a(n);
vector<int>b(n);
for(int i=0;i<n;i++){
cin>>a[i];
b[i]=i;
}
int mini=1e9;
while(next_permutation(b.begin(),b.end())){
vector<int>order(n);
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(i==b[j])
order[i]=a[j];
}
}
int total=0;
for(int i=0;i<n;i++){
if(i==0)
total+=order[i];
else{
while(total%10!=0)
total++;
total+=order[i];
}
}
mini=min(mini,total);
}
cout<<mini;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed;
cout<<setprecision(10);
int t=1;
for(int i=1;i<=t;i++){
solve();
}
return 0;
} | 0 | 36,029,686 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i, s, n) for (int i = (s); i < (n); i++)
#ifdef LOCAL
#define INPUT_FILE \
ifstream in("atcoder-problems/arc063_a.txt"); \
cin.rdbuf(in.rdbuf());
#define print_vec(v) \
rep(l, v.size()) { cout << v[l] << " "; } \
cout << endl;
#else
#define INPUT_FILE
#define print_vec(v)
#endif
#define CIN_OPTIMIZE \
cin.tie(0); \
ios::sync_with_stdio(false);
typedef pair<int, int> P;
typedef long long ll;
typedef pair<ll, ll> pl;
const int INF = 100100100;
const ll LINF = 1e18+100;
const int MOD = 1e9 + 7;
int main() {
INPUT_FILE CIN_OPTIMIZE;
string S;
cin >> S;
int N = S.size();
ll ans = 0;
rep(i, N - 1) {
if (S[i] != S[i + 1]) ans++;
}
cout << ans << endl;
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <iomanip>
#include <limits>
using namespace std;
typedef pair<long long, long long> P;
vector<P> prime_factorize(long long n)
{
vector<P> res;
for (long long p = 2; p * p <= n; ++p)
{
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0)
{
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
long long gcd(long long x, long long y)
{
if (y == 0)
{
return x;
}
else
{
return gcd(y, x % y);
}
}
const int MOD = 1000000007;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define rep(i, n) for (int i = 0; i < (n); 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; }
int main()
{
ll A, B;
cin >> A >> B;
for (int i = 1;i<=B; i++)
{
if((A*i)%B==0){
cout << A * i << endl;
return 0;
}
}
return 0;
} | 0 | 73,263,940 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define REPR(i,n) for(int i=n; i>-1; --i)
#define ALL(a) (a).begin(),(a).end()
#define FILL(a,n,x); REP(i,(n)){ (a)[i]=(x); }
#define CINA(a,n); REP(i,(n)){ cin >> (a)[i]; }
#define FILL2(a,n,m,x); REP(i,(n)){ REP(j,(m)){(a)[i][j]=(x);} }
#define CINA2(a,n,m); REP(i,(n)){ REP(j,(m)){cin >> (a)[i][j];} }
#define Liny "Yes\n"
#define Linn "No\n"
#define LINY "YES\n"
#define LINN "NO\n"
int keta(ll x){ if(x<10){return 1;} else{return keta(x/10) + 1;}}
int keta_wa(ll x){ if(x<10){return x;} else{return keta_wa(x/10) + x%10;} }
int ctoi(char c){ return ( (c>='0' && c<='9')? c - '0': 0 );}
int __stoi(string s){ return atoi(s.c_str()); }
ll sum(ll a[],ll N){ return accumulate(a,a+N,0LL);}
ll gcd(ll a,ll b){if(a<b)swap(a,b); return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){if(a<b){swap(a,b);} return a/gcd(a,b)*b;}
template<class T> void chmax(T& a, T b){ if(a<b){a=b;} }
template<class T> void chmin(T& a, T b){ if(a>b){a=b;} }
template<class T> bool isIn(T a,vector<T> v){ for(T x:v){ if(a==x){return true;}} return false;}
string strReplace(string s,string target, string replacement){
if (!target.empty()) {
std::string::size_type pos = 0;
while ((pos = s.find(target, pos)) != std::string::npos) {
s.replace(pos, target.length(), replacement);
pos += replacement.length();
}
}
return s;
}
const ll MOD = 998244353;
#define pii pair<int,int>
#define pll pair<ll,ll>
#define MP make_pair
int main(){
ll ans = 1;
int N; cin>>N;
map<int, int> mp;
int d[N]; CINA(d,N);
sort(d+1,d+N);
REP(i,N){
if(i==0){
if(d[i]==0){
++mp[d[i]];
}else{
ans = 0;
break;
}
}else if(mp[d[i]-1]>0){
ans *= mp[d[i]-1];
ans %= MOD;
++mp[d[i]];
}else{
ans = 0;
break;
}
}
cout << ans << "\n";
} | #include <cstdio>
#include <algorithm>
int a, b, n, map[17][17];
int search(int x, int y)
{
if (x == 1 && y == 1)
{
map[1][1] = 1;
return 1;
}
int left = 0, down = 0;
if (map[y][x - 1] != -1)
{
left = search(x - 1, y);
}
if (map[y - 1][x] != -1)
{
down = search(x, y - 1);
}
map[y][x] = left + down;
return map[y][x];
}
int main()
{
while (true)
{
for (int i = 0; i <= b; ++i)
{
std::fill(map[i], map[i] + a + 1, 0);
}
scanf("%d %d", &a, &b);
if (a == 0 || b == 0)
{
break;
}
scanf("%d", &n);
for (int i = 0; i < n; ++i)
{
int x, y;
scanf("%d %d", &x, &y);
map[y][x] = -1;
}
std::fill(map[0], map[0] + a + 1, -1);
for (int i = 0; i <= b; ++i)
{
map[i][0] = -1;
}
printf("%d\n", search(a, b));
}
} | 0 | 43,951,847 |
#include <iostream>
int main(void){
int N, tmp=200001, ans=0;
std::cin >> N;
for (int i=0; i<N; ++i){
int a;
std::cin >> a;
if (a < tmp){
++ans;
tmp = a;
}
}
std::cout << ans << std::endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
int n;
cin >> n;
int ans = 0;
int count = 0;
for(int i = 1; i <= n; i++){
if(i % 2 == 1){
for(int j = 1; j <= i; j++){
if(i % j == 0){
count++;
}
}
if(count == 8){
ans++;
}
}
count = 0;
}
cout << ans << endl;
} | 0 | 84,659,407 |
#include "bits/stdc++.h"
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b){
ll g = gcd(a, b);
return a / g * b;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b, c, d;
cin >> a >> b >> c >> d;
--a;
ll ac = a / c;
ll ad = a / d;
ll acd = a / lcm(c, d);
ll bc = b / c;
ll bd = b / d;
ll bcd = b / lcm(c, d);
ll ans = (b - bc - bd + bcd) - (a - ac - ad + acd);
cout << ans << endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <numeric>
#include <ctime>
#include <complex>
#include <bitset>
#include <random>
#include <stack>
using namespace std;
typedef long long ll;
typedef long double ld;
#define int ll
#define double ld
#define loop(i, n) for(int i = 0; i < (int)n; ++i)
#define loop1(i, n) for(int i = 1; i <= (int)n; ++i)
#define F first
#define S second
#define pb push_back
#define pi pair <int, int>
#define all(x) begin(x), end(x)
#define ti tuple <int, int, int>
#define Point Vect
#define mkt make_tuple
#define no {cout << -1; return;}
const int MOD = 1e9 + 7, N = 1e5 + 7;
int two[N] = { 1 }, three[N] = { 1 };
void solve() {
loop1(i, N - 1) {
two[i] = two[i - 1] * 2 % MOD;
three[i] = three[i - 1] * 3 % MOD;
}
string s; cin >> s;
int ans = 1;
loop(i, s.size() - 1)
ans = (ans + 2 * three[i]) % MOD;
int cnt = 1;
for (int i = 1; i < s.size(); ++i)
if (s[i] == '1')
ans = (ans + two[cnt++] * three[s.size() - 1 - i]) % MOD;
ans = (ans + two[cnt]) % MOD;
cout << ans;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
} | 0 | 81,137,191 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MOD1 1000000007
#define MOD2 1000000009
#define FOR(a,b) for(int i=a;i<b;i++)
#define nl "\n"
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll d, t, s;
cin >> d >> t >> s;
if (t * s >= d)
cout << "Yes";
else
cout << "No";
return 0;
} | #define rep(i, n) for (int i = 0; i < (n); i++)
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1000000007;
int main() {
int n;
cin >> n;
vector<int> p(n), q(n);
rep(i, n) cin >> p.at(i);
rep(i, n) cin >> q.at(i);
vector<int> oneCase(0);
rep(i, n) oneCase.push_back(i + 1);
int a, b, index = 1;
do {
if (equal(begin(oneCase), end(oneCase), begin(p), end(p))) {
a = index;
}
if (equal(begin(oneCase), end(oneCase), begin(q), end(q))) {
b = index;
}
index++;
} while (next_permutation(oneCase.begin(), oneCase.end()));
int ans = abs(a - b);
cout << ans << endl;
return 0;
} | 0 | 66,473,119 |
#include <bits/stdc++.h>
#define ALL(a) (a).begin(),(a).end()
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<vector<long long>> vvll;
template <typename T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template <typename T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const long long INF = 1LL << 60;
const int INT_INF = 1LL << 30;
ll N, M;
vi dx = {1, 1, 1, 0, 0, -1, -1, -1};
vi dy = {1, 0, -1, 1, -1, 1, 0, -1};
ll func(int y, int x){
int counter = 0;
for(int i = 0; i < 8; i++){
int yy = y + dy.at(i);
int xx = x + dx.at(i);
if(xx >= 0 && xx < M && yy >= 0 && yy < N) counter++;
}
if(counter % 2 == 0) return 1LL;
else return 0LL;
}
int main(){
cin >> N >> M;
ll ans = func(0, 0);
if(M >= 2){
ans += func(0, M-1);
if(M > 2){
ans += func(0, 1) * (M - 2);
}
}
if(N >= 2){
ans *= 2;
if(N > 2){
if(M>=2)ans += 2 * func(1, 0) * (N - 2);
else ans += func(1, 0) * (N - 2LL);
}
}
if(N > 2 && M > 2) ans += (N-2LL) * (M-2LL);
cout << ans << endl;
} | # include <iostream>
# include <queue>
# include <climits>
using namespace std;
int H;
int W;
char A[1005][1005];
int counter=0;
int shortestpath[1005][1005];
bool visited[1005][1005];
int maximum=INT_MIN;
int dr[4]={1, -1, 0, 0};
int dc[4]={0, 0, -1, 1};
queue< pair<int, int> > starting;
bool inside (int row, int column)
{
if (row<0 || row>H || column<0 || column>W)
{
return false;
}
return true;
}
void bfs (queue< pair<int, int> > starting)
{
queue< pair<int, int> > q;
while (!starting.empty())
{
q.push(make_pair(starting.front().first, starting.front().second));
visited[starting.front().first][starting.front().second]=true;
starting.pop();
}
while (!q.empty())
{
pair<int, int> u=q.front();
q.pop();
for (int i=0; i<4; i++)
{
int nextrow=u.first+dr[i];
int nextcolumn=u.second+dc[i];
if (inside(nextrow, nextcolumn) && !visited[nextrow][nextcolumn])
{
shortestpath[nextrow][nextcolumn]=shortestpath[u.first][u.second]+1;
q.push(make_pair(nextrow, nextcolumn));
visited[nextrow][nextcolumn]=true;
}
}
}
}
int main()
{
cin>>H>>W;
for (int i=1; i<=H; i++)
{
for (int j=1; j<=W; j++)
{
cin>>A[i][j];
if (A[i][j]=='#')
{
starting.push(make_pair(i, j));
}
}
}
bfs(starting);
for (int i=1; i<=H; i++)
{
for (int j=1; j<=W; j++)
{
if (shortestpath[i][j]>maximum)
{
maximum=shortestpath[i][j];
}
}
}
cout<<maximum<<endl;
} | 0 | 40,741,001 |
#include<bits/stdc++.h>
#define rep(i,j,n) for(int i=(j);i<(n);i++)
#define per(i,n,j) for(int i=(n)-1;i>=(j);i--)
using ll=long long;
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF=1LL<<60;
int h,w;
vector<vector<char>> a(110,vector<char>(110));
int main(){
cin>>h>>w;
rep(i,0,h) rep(j,0,w) cin>>a[i][j];
rep(i,0,h){
int cnt=0;
rep(j,0,w){
if(a[i][j]=='.') cnt++;
}
if(cnt==w){
rep(j,0,w) a[i][j]='F';
}
}
rep(i,0,w){
int cnt=0;
rep(j,0,h){
if(a[j][i]=='.' || a[j][i]=='F') cnt++;
}
if(cnt==h){
rep(j,0,h) a[j][i]='F';
}
}
rep(i,0,h){
int cnt=0;
rep(j,0,w){
if(a[i][j]!='F') cout<<a[i][j];
else cnt++;
}
if(cnt!=w) cout<<"\n";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define fi first
#define se second
long long mo = 1000000007;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
typedef pair<ll,Pll> PlP;
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
template<class A>void PR(A a,ll n){rep(i,n){if(i)cout<<' ';cout<<a[i];}cout << "\n";}
ld PI=3.14159265358979323846;
int main(){
ll N, K;
cin >> N >> K;
vector<ll> P(N), C(N);
rep(i,N){
cin >> P[i];
P[i]--;
}
rep(i,N){
cin >> C[i];
}
ll ans = -1e18;
rep(i,N){
ll cur = P[i];
ll cnt = 0;
ll sum = 0;
vector<ll> memo(N);
vector<ll> S(N+10);
while(1){
if(memo[cur] > 0){
break;
}
memo[cur] = 1;
sum += C[cur];
cur = P[cur];
cnt++;
}
ll t = 0;
cur = P[i];
rep(j,cnt){
t += C[cur];
if(j+1 > K)break;
ll now = t;
if(sum > 0){
ll e = (K-(j+1))/cnt;
now += sum*e;
}
cur = P[cur];
cmax(ans,now);
}
}
cout << ans << endl;
} | 0 | 77,032,635 |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define INIT \
cin.tie(0); \
ios::sync_with_stdio(false);
template <class T>
inline bool chmax(T& a, T b) {
return a = (a < b) ? b : a;
}
template <class T>
inline bool chmin(T& a, T b) {
return a = (a > b) ? b : a;
}
ll const INF = 1LL << 60;
ll const MOD = 1000000007;
int main() {
INIT;
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
ll ans = 0;
bool flg = true;
while (1) {
flg = false;
ll l = -1, r = -1;
rep(i, N) {
if (h[i] > 0) {
flg = true;
l = i;
}
reps(j, i, N) {
if (h[j] > 0) {
r = j;
} else
break;
}
if (flg) break;
}
if (!flg) break;
reps(i, l, r + 1) { h[i]--; }
ans++;
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(void) {
long n;
cin >> n;
vector<pair<long,long>> a(n);
for(long i=0; i<n; i++)
cin >> a[i].first, a[i].second = -i;
sort(a.begin(), a.end(), greater<>());
map<long, long> res;
long top, cur;
tie(top, cur) = a[0];
cur = -cur;
for(long i=1; i<n; i++) {
res[cur] += i*(top - a[i].first);
top = a[i].first;
cur = min(cur, -a[i].second);
}
res[cur] += n*top;
for(long i=0; i<n; i++)
cout << res[i] << endl;
} | 0 | 36,611,291 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;
const ll MOD = 1e9 + 7;
const ll INF = 1e16;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
void init() {cin.tie(0);ios::sync_with_stdio(false);cout << fixed << setprecision(15);}
int main() {
init();
ll N;
cin >> N;
vl A(N);
rep(i, N) cin >> A[i];
ll ans = N;
ll x = 0, sum = 0, ri = 0;
rep(i,N){
while(ri<N&&(x^A[ri])==(sum+A[ri])){
x ^= A[ri];
sum += A[ri];
ri++;
}
ans += ri - i - 1;
sum -= A[i], x ^= A[i];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
typedef pair<int,int> P;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
priority_queue<ll> a;
rep(i,n) {
ll x;
cin >> x;
a.push(x);
}
rep(i,m) {
ll x = a.top();
a.pop();
a.push(x / 2);
}
ll ans = 0;
rep(i,n) {
ans += a.top();
a.pop();
}
cout << ans << endl;
return 0;
} | 0 | 42,097,084 |
#include <bits/stdc++.h>
#define ll long long int
#define uu first
#define vv second
#define pii pair<int,int>
#define pll pair<ll,ll>
#define INF 1e9
#define fastRead ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
using namespace std;
const int MAX = 1e6 + 6;
int n;
int main()
{
fastRead;
int n;
cin>>n;
vector<ll>vec(n+1) ;
ll ans = 0;
for(int i = 0 ; i < n ; i++ ) {
cin>>vec[i];
}
ll sum = 0;
for(int i =0 ; i <=n ; i++ ) {
if(vec[i] == 0 ) {
ans += sum/2;
sum = 0;
}
else sum += vec[i];
}
cout<<ans<<'\n';
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
const int MOD = 1000000007;
const ll INF = 1e18;
const int MX = 100001;
int H,W,N;
set<pi> tri,z;
ll ans[10];
bool valid(pi x) {
return 1 <= x.f && x.f <= H-2 && 1 <= x.s && x.s <= W-2;
}
int co(pi a) {
int ans = 0;
F0R(i,3) F0R(j,3) if (z.count({a.f+i,a.s+j})) ans ++;
return ans;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
cin >> H >> W >> N;
F0R(i,N) {
int a,b; cin >> a >> b;
F0R(j,3) F0R(k,3) tri.insert({a-j,b-k});
z.insert({a,b});
}
for (auto a: tri) if (valid(a)) ans[co(a)] ++;
ll tot = (ll)(H-2)*(W-2);
FOR(i,1,10) tot -= ans[i];
ans[0] = tot;
F0R(i,10) cout << ans[i] << "\n";
} | 0 | 69,197,588 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++)
{
cin >> A[i];
}
map<int, int> p;
for (int i = 0; i < N; i++)
{
p[A[i] - 1] += 1;
p[A[i] + 1] += 1;
p[A[i]] += 1;
}
int max = 0;
for(auto i : p) {
if (max < i.second)
{
max = i.second;
}
}
cout << max << endl;
return 0;
} | #include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
ll mod=1000000007;
using namespace std;
bool Factorial(ll x, vector<ll>&f){
f[0]=1;
for(int i=1; i<=x; i++){
f[i]=(f[i-1]*i)%mod;
}
return true;
}
int main() {
int x,y,n;
cin >> x >> y;
if(x>y) swap(x,y);
ll ans=0;
if((x+y)%3==0){
if(2*x>=y && x<=2*y){
n=(x+y)/3;
vector<ll> f(n+1);
Factorial(n,f);
ans=f[n];
ll bit=mod-2;
ll k=f[x-n];
while(bit>0){
if((bit&1)==1) ans=(ans*k)%mod;
k=(k*k)%mod;
bit>>=1;
}
bit=mod-2;
k=f[2*n-x];
while(bit>0){
if((bit&1)==1) ans=(ans*k)%mod;
k=(k*k)%mod;
bit>>=1;
}
}
}
cout << ans << endl;
return 0;
} | 0 | 60,871,436 |
#include<stdio.h>
#include<iostream>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<algorithm>
#include<string.h>
#include<functional>
#include<limits.h>
#include<stdlib.h>
#include<string>
#include<unordered_map>
using namespace std;
#define intmax INT_MAX
#define lmax LONG_MAX
#define uintmax UINT_MAX
#define ulmax ULONG_MAX
#define llmax LLONG_MAX
#define ll long long
#define rep(i,a,N) for((i)=(a);(i)<(N);(i)++)
#define rrp(i,N,a) for((i)=(N)-1;(i)>=(a);(i)--)
#define llfor ll i,j,k
#define sc(a) cin>>a
#define pr(a) cout<<a<<endl
#define pY puts("YES")
#define pN puts("NO")
#define py puts("Yes")
#define pn puts("No")
#define pnn printf("\n")
#define sort(a) sort(a.begin(),a.end())
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define sizeoof(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
ll cei(ll x,ll y){ll ans=x/y;if(x%y!=0)ans++;return ans;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
ll lcm(ll x,ll y){return x/gcd(x,y)*y;}
ll llpow(ll x,ll n){ll i,ans=1;rep(i,0,n)ans*=x;return ans;}
ll fact(ll x){ll i,ans=1;rep(i,0,x)ans*=(x-i);return ans;}
ll ncr(ll n,ll r){return fact(n)/fact(r)/fact(n-r);}
ll npr(ll n,ll r){return fact(n)/fact(n-r);}
bool prime(ll a){if(a<=1)return false;ll i;for(i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
ll ans=0;llfor;
int main(){
string S,T,U;
cin>>S>>T>>U;
int A=S.size();
int B=T.size();
string X="NO";
if(S[A-1]==T[0]&&T[B-1]==U[0]) X="YES";
cout<<X;
return 0;} | #include<bits/stdc++.h>
using namespace std;
#define INFTY 1<<20
#define rep(i,n) for (int i = 0; i < (n); ++i)
typedef long long int ll;
using ipair = pair<int,int>;
bool operator< (const ipair a, const ipair b){return a.first < b.first;};
const int MOD=1000000007;
int main(){
int n;cin>>n;
priority_queue<ipair,vector<ipair>,greater<ipair>>b,cp;
vector<ipair> r;
ll x,y;
rep(i,n){
cin>>x>>y;
r.push_back(make_pair(x,y));
}
rep(i,n){
cin>>x>>y;
b.push(make_pair(x,y));
}
sort(r.begin(),r.end());
int cnt = 0,mx = -1,mxx=0;
rep(i,n){
int ok = 0;
ipair ba = b.top();b.pop();
mx = -1;mxx=0;
for (int i = 0; i < r.size(); i++)
{
if(ba.first<r[i].first)break;
if(ba.second>r[i].second&&mx<r[i].second){
ok = 1;
mx =r[i].second;
mxx = i;
}
}
if(ok){cnt++;
r.erase(r.begin()+mxx);}
}
cout<<cnt<<endl;
return 0;
} | 0 | 18,677,834 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin>>N;
int sum=0;
for(int i=0;i<N;i++){
int a;
int b;
cin>>a>>b;
sum+=b-a+1;
}
cout<<sum<<endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll L, R;
int main(){
cin >> L >> R;
ll result = 2019;
for ( ll i = L; i < R && i < L+2019; i++ ){
for ( ll j = i+1; j <= R && j < i+1+2019; j++ ){
result = min( result, (i*j) % 2019 );
}
}
cout << result << endl;
return 0;
} | 0 | 1,729,364 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r;
int g;
double p;
cin >> r;
cin >> g;
p = 2 * g - r;
cout << p << endl;
} | #include "bits/stdc++.h"
using namespace std;
#define INF (1LL<<60)
#define int long long
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) FOR(i,0,(n))
typedef vector<int> vec;
typedef vector< vector<int> > mat;
class ECrestedIbisVsMonster {
public:
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void solve(std::istream& in, std::ostream& out) {
int h,n;
in >> h >> n;
vector<int> a(n), b(n);
REP(i,n) in >> a[i] >> b[i];
mat dp(n + 1, vec(h + 1, INF));
dp[0][0] = 0;
REP(i, n) REP(j, h + 1){
chmin(dp[i + 1][j], dp[i][j]);
chmin(dp[i + 1][min(j + a[i], h)], dp[i + 1][j] + b[i]);
}
out << dp[n][h] << endl;
}
};
signed main() {
ios::sync_with_stdio(false);
cout.tie(0);
cout << fixed;
ECrestedIbisVsMonster solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
} | 0 | 77,257,079 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int A, B, K;
cin >> A >> B >> K;
int result = 1;
int count = K;
for (int i=max(A, B); i>1; i--)
{
if (A%i==0 && B%i==0)
{
count -= 1;
if (count==0)
{
result = i;
break;
}
}
}
cout << result << endl;
} | #include<iostream>
#include<math.h>
#include<vector>
#include<algorithm>
#include<numeric>
#include<map>
#include<queue>
#include<deque>
#include<set>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
typedef long long ll;
typedef vector<int> vec;
typedef vector<vector<int>> mat;
int main(){
priority_queue<int> pq;
map<int,int> mp;
pair<ll,int>p[100010];
int N,K;cin>>N>>K;
int t;ll d;
for(int i=0;i<N;i++){
cin>>t>>d;
p[i]={-d,t};
}
sort(p,p+N);
ll sum=0,kind=0;
for(int i=0;i<K;i++){
sum-=p[i].first;
mp[p[i].second]++;
if(mp[p[i].second]==1)kind++;
if(mp[p[i].second]>=2)pq.push(i);
}
sum+=(ll)pow(kind,2);
ll ans=sum;
int i=K;
while(!pq.empty() && i<N){
if(mp[p[i].second]==0){
int m=pq.top();
ll k=kind;
kind++;
sum+=(ll)pow(kind,2)-(ll)pow(k,2)+p[m].first-p[i].first;
ans=max(ans,sum);
mp[p[i].second]++;
pq.pop();
}
i++;
}
cout<<ans<<endl;
return 0;
} | 0 | 26,360,417 |
#include<iostream>
using namespace std;
int main()
{
int x,y;
while( cin >> x >> y )
{
if( x == 0 && y == 0 )
break;
else
if( x > y )
{
int tmp = x;
x = y;
y = tmp;
}
cout << x << " " << y << endl;
}
return 0;
} | #include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int C[m], T[m][n + 1];
for(int i = 0; i < m; i++) {
cin >> C[i];
T[i][0] = 0;
}
sort(C, C + m);
for(int i = 0; i < m; i++) {
if(i == 0) {
for(int j = 1; j < n + 1; j++) {
T[i][j] = j / C[i];
}
}
else {
for(int j = 1; j < n + 1; j++) {
if(j < C[i]) {
T[i][j] = T[i - 1][j];
} else {
T[i][j] = min(T[i - 1][j], T[i][j - C[i]] + 1);
}
}
}
}
cout << T[m - 1][n] << endl;
} | 0 | 13,948,762 |
#include <cstdio>
#include <cmath>
#include <limits>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cstdint>
#include <functional>
#define rep(i, s, g) for (i = s; i < g; i++)
using namespace std;
using ll = long long;
const ll mod = 1000000000 + 7;
int main() {
ll N, A, B;
cin >> N >> A >> B;
ll b_c = 0;
b_c = N / (A + B);
N -= b_c * (A + B);
ll ans = 0;
if(N > A) {
ans += A;
}else{
ans += N;
}
ans += b_c * A;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repn(i,n) for(int i = 0; i <= (int)(n); i++)
#define srep(i,l,n) for(int i = l; i < (int)(n); i++)
#define srepn(i,l,n) for(int i = l; i <= (int)(n); i++)
#define drep(i,n) for(int i = (int)(n-1); i >= 0; i--)
#define drepn(i,n) for(int i = (int)(n); i >= 0; i--)
#define size(s) (int)s.size()
#define debug(var) do{std::cout << #var << " : ";view(var);}while(0)
template<typename T> void view(T e){std::cout << e << std::endl;}
template<typename T> void view(const std::vector<T>& v){for(const auto& e : v){ std::cout << e << " "; } std::cout << std::endl;}
template<typename T> void view(const std::vector<std::vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
template<typename T> inline istream& operator>>(istream &i, vector<T> &v) {rep(j, size(v)) i >> v[j]; return i;}
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<class T> T gcd(T a, T b) {if(b==0)return a; else return gcd(b,a%b);}
template<class T> T lcm(T a, T b) {return a/gcd(a,b)*b;}
template<class T = int> using V = vector<T>;
template<class T = int> using VV = vector<V<T>>;
bool isIn(int i, int j, int h, int w) {return i >= 0 && i < h && j >= 0 && j < w;}
void Yes(){cout << "Yes" << endl;}
void No(){cout << "No" << endl;}
void YES(){cout << "YES" << endl;}
void NO(){cout << "NO" << endl;}
void err() {cout << -1 << endl;}
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pb push_back
#define ep emplace_back
const int MOD = 1000000007;
const int INF = 1e9;
#define PI acos(-1);
int dx[4] = {1,-1,0,0};
int dy[4] = {0,0,1,-1};
int ddx[8] = {1,1,1,-1,-1,-1,0,0};
int ddy[8] = {0,1,-1,0,1,-1,1,-1};
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c, d;
cin >> a >> b >> c >> d;
int x = c - a, y = d - b;
printf("%d %d %d %d\n", c - y, d + x, a - y, b + x);
} | 0 | 78,426,919 |
#include <bits/stdc++.h>
using namespace std;
int main(){
char a, b;
cin >> a >> b;
bool judge;
if(a=='H'){
if(b=='H') judge=true;
if(b=='D') judge=false;
}
if(a=='D'){
if(b=='H') judge=false;
if(b=='D') judge=true;
}
if(judge) cout << 'H' << endl;
else cout << 'D' << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rrep(i, n) for(int i = 1; i <= (int)(n); i++)
#define drep(i, n) for(int i = (n)-1; i >= 0; i--)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int mod = 1000000007;
struct mint {
ll x;
mint():x(0){}
mint(ll x):x((x%mod+mod)%mod){}
mint& fix() { x = (x%mod+mod)%mod; return *this;}
mint operator-() const { return mint(0) - *this;}
mint& operator+=(const mint& a){ if((x+=a.x)>=mod) x-=mod; return *this;}
mint& operator-=(const mint& a){ if((x+=mod-a.x)>=mod) x-=mod; return *this;}
mint& operator*=(const mint& a){ (x*=a.x)%=mod; return *this;}
mint operator+(const mint& a)const{ return mint(*this) += a;}
mint operator-(const mint& a)const{ return mint(*this) -= a;}
mint operator*(const mint& a)const{ return mint(*this) *= a;}
bool operator<(const mint& a)const{ return x < a.x;}
bool operator==(const mint& a)const{ return x == a.x;}
};
istream& operator>>(istream&i,mint&a){i>>a.x;return i;}
ostream& operator<<(ostream&o,const mint&a){o<<a.x;return o;}
int main() {
int x, y, z, k;
cin >> x >> y >> z >> k;
vector<ll> a(x), b(y), c(z);
rep(i, x) cin >> a[i];
rep(i, y) cin >> b[i];
rep(i, z) cin >> c[i];
vector<ll> ab;
rep(i, x) rep(j, y) ab.push_back(a[i] + b[j]);
sort(ALL(ab), greater<ll>());
ab.resize(k);
vector<ll> abc;
rep(i, ab.size()) rep(j, z) abc.push_back(ab[i] + c[j]);
sort(ALL(abc), greater<ll>());
rep(i, k) cout << abc[i] << endl;
} | 0 | 12,044,772 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
using namespace std;
#define rad_to_deg(rad) (((rad)/2/M_PI)*360)
int main(){
double a,b,x,y;
cin>>a>>b>>x;
if(x>=b*a*a/2){
y=a*a*a/(2*a*a*b-2*x);
}
else{
y=2*x/(a*b*b);
}
cout << fixed << setprecision(15);
cout<<90.0-rad_to_deg(atan(y));
} | #include <bits/stdc++.h>
#define rep3(i, s, n, a) for (int i = (s); i < (int)(n); i += a)
#define rep2(i, s, n) rep3(i, s, n, 1)
#define rep(i, n) rep2(i, 0, n)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
int main(){
int n;
cin >> n;
vector<int> a, b(n);
rep(i, n){
int x;
cin >> x;
a.push_back(x);
}
int start = n/2;
b[start] = a[0];
if(n%2){
rep2(i, 1, start+1){
b[start+i] = a[i*2-1];
b[start-i] = a[i*2];
}
}else{
rep2(i, 1, start){
b[start-i] = a[i*2-1];
b[start+i] = a[i*2];
}
b[0] = a[n-1];
}
rep(i, n){
cout << b[i] << " ";
}
cout << endl;
return 0;
} | 0 | 36,624,055 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define ALL(c) (c).begin(), (c).end()
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v, x) (std::find(v.begin(), v.end(), x) != v.end())
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; }
template<class T> inline void dump(vector<T> v) { for (auto& x : v) cerr << x << " "; cerr << endl; }
template<class T> inline void dump(vector<pair<T, T>> v) { for (auto& p : v) cerr << p.first << " " << p.second << endl; }
template<class T> inline void dump(vector<vector<T>> vv) { for (auto& v : vv) {for (auto& x : v) cerr << x << " "; cerr << endl;} }
constexpr int INF = 1e9 + 5;
constexpr long long INFLL = 1LL << 62;
constexpr double eps = (1e-9);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(ALL(a));
vector<ll> cs(n, 0);
cs[0] = a[0];
for (int i = 1; i < n; i++) {
cs[i] = cs[i-1] + a[i];
}
int ans = 1;
for (int i = n-2; i >= 0; i--) {
if (cs[i] * 2 >= a[i+1]) ans++;
else break;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(false);cin.tie(0)
#define endl "\n";
#define pb push_back
#define ff first
#define ss second
#define all(a) a.begin(),a.end()
#define int long long
const int MOD=1e9+7;
const int N=3e5+10;
int a[N];
int pow(int a, int b, int m)
{
int ans=1;
while(b)
{
if(b&1)
ans=(ans*a)%m;
b/=2;
a=(a*a)%m;
}
return ans;
}
int modinv(int k)
{
return pow(k, MOD-2, MOD);
}
int ans[N];
int32_t main()
{
IOS;
int n,k;
cin>>n>>k;
for(int i=k;i>=1;i--)
{
int ans1=pow(k/i,n,MOD);
for(int j=2*i;j<=k;j+=i)
{
ans1-=ans[j];
ans1+=MOD;
ans1%=MOD;
}
ans[i]=ans1;
}
int sum=0;
for(int i=1;i<=k;i++)
{
sum+=(ans[i]*i)%MOD;
sum%=MOD;
}
cout<<sum<<endl;
} | 0 | 76,343,015 |
#include<stdio.h>
#include<stdlib.h>
#define N 2000000
#define MAX 10000
void CountingSort(int *,int *,int);
int main(){
int n,i;
int *A,*B;
scanf("%d",&n);
A = (int *)malloc(n * sizeof(int));
B = (int *)malloc(n * sizeof(int));
for(i=0; i<n; i++) scanf("%d",&A[i]);
CountingSort(A,B,n);
for(i=0; i<n-1; i++) printf("%d ",B[i]);
printf("%d\n",B[i]);
free(A);
free(B);
return 0;
}
void CountingSort(int *A,int *B,int k){
int i;
int C[MAX];
for(i=0; i<MAX; i++) C[i]=0;
for(i=0; i<k; i++) C[A[i]]++;
for(i=1; i<MAX; i++) C[i]+=C[i-1];
for(i=k-1; i>=0; i--){
C[A[i]]--;
B[C[A[i]]] = A[i];
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define ff first
#define ss second
#define rsz resize
#define ins insert
#define mp make_pair
#define pf push_front
#define pb push_back
#define eb emplace_back
#define ft front()
#define bk back()
#define sz(x) (int)(x).size()
#define all(x) begin(x), end(x)
#define deb(x) cout<<#x<<" "<<x<<'\n';
#define rep(i,a,b) for (int i = (a); i < (b); ++i)
const ll mod = 1e9+7;
const ll inf = 1e18;
const ld pie = acos((ld)-1);
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int main(){
int a[3];
for(int i=0;i<3;++i){
scanf("%d",&a[i]);
}
sort(a,a+3,greater<int>());
int ans = a[0]*10 + a[1] + a[2];
printf("%d\n",ans);
return 0;
} | 0 | 27,923,879 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#define rep(i,n) for(int i = 0; i , (n); ++i)
using ll = long long;
using namespace std;
int sum(int n) {
if (n == 0) {
return 0;
}
int s = sum(n - 1);
return s + n;
}
int main() {
int N, K, sum=0;
cin >> N >> K;
vector<int>p(N);
for (int i = 0;i < N;i++) {
cin >> p.at(i);
}
sort(p.begin(), p.end());
for (int i = 0;i < K;i++) {
sum+=p.at(i);
}
cout << sum;
} | #include<iostream>
using namespace std;
int main(void){
int A, B, K;
bool result{false};
cin >> K >> A >> B;
if(A%K == 0){
result = true;
}
else if((A/K+1)*K<=B){
result = true;
}
if(result){
cout << "OK" << endl;
}
else{
cout << "NG" << endl;
}
} | 0 | 43,731,972 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define MOD 1000000007
ll recurse(ll i, bool color, vector<vector<ll>>& adj, vector<vector<ll>>& dp, ll from) {
if (dp[i][color] != -1) {
return dp[i][color];
}
ll ans = 1;
for (auto v: adj[i]) {
if (v != from) {
ll temp = recurse(v, true, adj, dp, i);
if (color) {
temp = (temp + recurse(v, false, adj, dp, i)) % MOD;
}
ans = (ans * temp) %MOD;
}
}
return dp[i][color] = ans;
}
int main(void) {
ll n;
cin >> n;
vector<vector<ll>> adj (n+1);
for (ll i = 0; i < n-1; i++) {
ll a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<vector<ll>> dp (n+1, vector<ll> (2, -1));
cout << (recurse(1, true, adj, dp, 0) + recurse(1, false, adj, dp, 0))%MOD << endl;
return 0;
} | #include <iostream>
#include <algorithm>
#include <cstdio>
#define INF 200000
using namespace std;
const int MAX=11;
int d[MAX][MAX];
int V;
int main()
{
int n;
while(~scanf("%d", &n) && n)
{
for(int i=0; i<MAX; i++)
{
for(int j=0; j<MAX; j++)
{
if(i!=j)
d[i][j]=INF;
}
}
V=0;
for(int i=0; i<n; i++)
{
int x,y,m;
scanf("%d %d %d", &x, &y, &m);
d[x][y]=m;
d[y][x]=m;
V = max(V, max(x+1, y+1));
}
for(int k=0; k<V; k++)
{
for(int i=0; i<V; i++)
{
for(int j=0; j<V; j++)
d[i][j]=min(d[i][j], d[i][k]+d[k][j]);
}
}
int u=0;
for(int i=0; i<V; i++)
{
for(int j=1; j<V; j++)
{
if(d[i][j] != INF && i!=j)
d[i][0]+=d[i][j];
}
if(d[i][0]<d[u][0])
u=i;
}
printf("%d %d\n", u, d[u][0]);
}
return 0;
} | 0 | 28,374,375 |
#include <bits/stdc++.h>
#define int long long int
#define MOD(x) ((x % MOD_N) + MOD_N) % MOD_N
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define RFOR(i,a,b) for(int i=(b)-1;i>=(a);--i)
#define RFORE(i,a,b) for(int i=(b);i>=(a);--i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define ALL(c) (c).begin(),(c).end()
#define RALL(c) (c).rbegin(),(c).rend()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SZ(c) (int)((c).size())
#define EACH(i,v) for(auto i=v.begin();i!=v.end();++i)
#define REACH(i,v) for(auto i=v.rbegin();i!=v.rend();++i)
#define LB(c,x) distance((c).begin(),lower_bound(ALL(c),x))
#define UB(c,x) distance((c).begin(),upper_bound(ALL(c),x))
#define COUNT(c,x) (lower_bound(ALL(c),x)-upper_bound(ALL(c),x))
#define UNIQUE(c) SORT(c); (c).erase(unique(ALL(c)),(c).end());
#define COPY(c1,c2) copy(ALL(c1),(c2).begin())
#define EXIST(s,e) (bool)((s).find(e)!=(s).end())
#define PB push_back
#define MP make_pair
#define DUMP(x) cerr<<#x<<" = "<<(x)<<endl;
#define NL cerr<<endl;
using namespace std;
template<typename T,typename U> using P=pair<T,U>;
template<typename T> using V=vector<T>;
template<typename T>bool chmax(T&a,T b){if(a<b){a=b;return true;}return false;}
template<typename T>bool chmin(T&a,T b){if(a>b){a=b;return true;}return false;}
template<typename T>T sum(vector<T>&v){return accumulate(ALL(v),T());}
template<typename T>T sum(vector<T>&v,int a,int b){return accumulate(v.begin()+a,v.begin()+b,T());}
template<typename T>T max(vector<T>&v){return *max_element(ALL(v));}
template<typename T>T min(vector<T>&v){return *max_element(ALL(v));}
template<typename T>T max_index(vector<T>&v){return distance((v).begin(),max_element(ALL(v)));}
template<typename T>T min_index(vector<T>&v){return distance((v).begin(),min_element(ALL(v)));}
struct edge { int to, cost; };
template<typename T>auto&operator<<(ostream&s,const vector<T>&v){s<<"[";bool a=1;for(auto e:v){s<<(a?"":" ")<<e;a=0;}s<<"]";return s;}
template<typename T,typename U>auto&operator<<(ostream&s,const pair<T,U>&p){s<<"("<<p.first<<","<<p.second<<")";return s;}
template<typename T>auto&operator<<(ostream&s,const set<T>&st){s<<"{";bool a=1;for(auto e:st){s<<(a?"":" ")<<e;a=0;}s<<"}";return s;}
template<typename T,typename U>auto&operator<<(ostream&s,const map<T,U>&m){s<<"{";bool a=1;for(auto e:m){s<<(a?"":" ")<<e.first<<":"<<e.second;a=0;}s<<"}";return s;}
const int INF = 1e18;
const int MOD_N = 1e9+7;
signed main()
{
int n, m; cin >> n >> m;
V<int> c(m);
REP(i, m) {
cin >> c[i];
}
V<int> num(n+1, INF);
num[0] = 0;
REP(i, n) REP(j, m) if (i + c[j] <= n) {
chmin(num[i + c[j]], num[i] + 1);
}
cout << num[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define fi first
#define se second
#define rep(i,s,n) for(int i = s;i<n;i++)
#define rrep(i,s,n) for(int i = (n)-1;i>=(s);i--)
#define all(v) (v).begin(),(v).end()
#define chmin(a,b) a=min((a),(b))
#define chmax(a,b) a=max((a),(b))
#define endl '\n'
#define IOS() ios_base::sync_with_stdio(0);cin.tie(0)
typedef long long ll;
typedef pair<int,int>pint;
typedef vector<int>vint;
typedef vector<pint>vpint;
const ll MOD=1000000007,INF=1ll<<60;
int dx[]={0,0,1,-1};
int dy[]={-1,1,0,0};
typedef pair<int,pint>P2;
typedef vector<vint>vvint;
int N,ma=-1;
int a[101];
int cnt[101];
signed main() {
IOS();
cin>>N;
rep(i,0,N){
cin>>a[i];
cnt[a[i]]++;
chmax(ma,a[i]);
}
if(ma==1){
if(N!=2){
cout<<"Impossible"<<endl;
}else if(a[0]!=1||a[1]!=1){
cout<<"Impossible"<<endl;
}else{
cout<<"Possible"<<endl;
}
return 0;
}
for(int i=ma;i>=(ma+1)/2;i--){
if(i==(ma+1)/2&&ma%2==0){
if(cnt[i]!=1){
cout<<"Impossible"<<endl;
return 0;
}
}else if(i==(ma+1)/2&&ma%2){
if(cnt[i]!=2){
cout<<"Impossible"<<endl;
return 0;
}
}else{
if(cnt[i]<2){
cout<<"Impossible"<<endl;
return 0;
}
}
}
for(int i=(ma+1)/2-1;i>=0;i--){
if(cnt[i]){
cout<<"Impossible"<<endl;
return 0;
}
}
cout<<"Possible"<<endl;
return 0;
} | 0 | 98,242,617 |
#include <bits/stdc++.h>
using namespace std;
typedef long long Int;
int main()
{
int n;
set<int> p;
vector< pair<int, int> > v;
scanf("%d", &n);
p.insert(0);
p.insert(n + 1);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
v.emplace_back(x, i);
}
sort(v.rbegin(), v.rend());
Int ans = 0;
for (int i = 0; i < n; i++) {
if (i) {
auto it = p.lower_bound(v[i].second);
auto it2 = it; --it2;
auto it3 = it; ++it3;
int prv = *it2;
int cur = v[i].second;
int nxt = *it;
if (it2 != p.begin()) {
--it2;
ans += (Int)(n - i) * (nxt - cur) * (prv - *it2);
}
if (it3 != p.end()) {
ans += (Int)(n - i) * (cur - prv) * (*it3 - nxt);
}
}
p.insert(v[i].second);
}
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using Bint = boost::multiprecision::cpp_int;
using namespace std;
typedef long long ll;
typedef pair<int, ll> Pil;
int N;
const int MAX_N = 1.0e5 + 10;
Bint A[MAX_N];
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
bool is_over = false;
Bint mul_A = 1;
for (int i = 0; i < N; i++) {
if (A[i] == 0) {
is_over = false;
mul_A = 0;
break;
}
}
if (mul_A != 0) {
for (int i = 0; i < N; i++) {
mul_A *= A[i];
if (mul_A > (Bint)1.0e18) {
is_over = true;
break;
}
}
}
cout << (is_over ? -1 : mul_A) << endl;
return 0;
} | 0 | 84,336,648 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int,int>
#define fi first
#define sc second
signed main() {
#ifdef _DEBUG
#endif
ios::sync_with_stdio(0); cin.tie(0);
int a, b;
cin >> a >> b;
int ans = 0;
while (a <= b) ans++, a *= 2;
cout << ans << '\n';
return 0;
} | #include <iostream>
#include <utility>
int main() {
int a , b ;
for( int i = 0 ; i <= 3000 ; i++ ) {
std::cin >> a >> b ;
if( a == 0 && b == 0 ) {
break ;
} else if( a > b ) {
std::swap( a , b ) ;
}
std::cout << a << " " << b << std::endl ;
}
} | 0 | 83,027,083 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, k;
cin >> a >> b >> c >> k;
if (a + b >= k) {
cout << min(a, k) << endl;
} else {
cout << a - (k - a - b) << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
#define lli long long int
#define pb push_back
#define fi first
#define se second
#define MOD 1000000007
const int maxn= 100010;
lli modexp(lli x, lli y)
{
x%=MOD;
lli ans=1ll;
while(y>0ll)
{
if(y&1ll)
ans=(ans*x)%MOD;
x=(x*x)%MOD;
y>>=1ll;
}
return ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin>>s;
int n=s.length();
lli x=0ll,res=0ll;
for(int i=0;i<n;++i)
{
int len=n-i-1;
if(s[i]=='1')
{
res+=(modexp(2ll,x)*modexp(3ll,len))%MOD;
++x;
}
}
res+=modexp(2ll,x);
cout<<res%MOD<<endl;
} | 0 | 29,782,366 |
#include "iostream"
#include "cmath"
#include "iomanip"
using namespace std;
int main(int argc, char const *argv[])
{
double x1, y1, x2, y2=0;
cin >> x1 >> y1 >> x2 >> y2;
cout << setprecision(10) << sqrt( pow(x1 - x2, 2) + pow(y1 - y2, 2) ) <<endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int t = 1;
while(t--)
{
int n;
cin >> n;
int h[n];
for(int &val : h)
cin >> val;
int dp[n] = {0};
for(int i = 1; i < n; i++)
{
int op1, op2;
op1 = op2 = 1e9;
if(i-2 >= 0)
op1 = dp[i-2] + abs(h[i]-h[i-2]);
if(i-1 >= 0)
op2 = dp[i-1] + abs(h[i]-h[i-1]);
dp[i] = min(op1, op2);
}
cout << dp[n-1];
}
return 0;
} | 0 | 48,222,212 |
#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#define rep(i,x) for(int i = 0; i < x; i++)
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> ivec;
const ll N = 1e9+7;
int main(){
string s1,s2;cin >> s1 >> s2;
int olen = s1.size(),tlen = s2.size();
int dp[1010][1010] = {};
rep(i,olen+1){
rep(j,tlen+1){
if(!i){
dp[i][j] = j;
continue;
}
if(!j){
dp[i][j] = i;
continue;
}
if(s1[i-1] == s2[j-1]) dp[i][j] = dp[i-1][j-1];
else{
dp[i][j] = min(dp[i-1][j],min(dp[i][j-1],dp[i-1][j-1])) + 1;
}
}
}
cout << dp[olen][tlen] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {
if(a==1 || b==1){
return max(a,b);
}
return a/gcd(a,b)*b;
}
void solve(long long N, long long M, std::vector<long long> a){
ll num = a[0]/2;
for(int i=0;i<N;i++){
ll t = a[i];
t/=2;
ll old = num;
num = lcm(num,t);
(num/old)%2;
if(num>M){
cout << 0<<endl;
return;
}
if((num/t)%2==0|| (num/old) %2 ==0 ){
cout << 0 <<endl;
return;
}
}
cout << 1 + (M-num)/(2*num) << endl;
}
int main(){
long long N;
scanf("%lld",&N);
long long M;
scanf("%lld",&M);
std::vector<long long> a(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&a[i]);
}
solve(N, M, std::move(a));
return 0;
} | 0 | 48,450,494 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for(int i=0; i<N; i++)
typedef long long ll;
#define dump(x) cerr<<#x<<"="<<x<<endl
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int res, ans;
res = min(a, b);
ans = min(c, d);
ans += res;
cout << ans << endl;
} | #include <iostream>
#include <iomanip>
#include <string>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <vector>
#include <cassert>
#include <fstream>
#include <algorithm>
#include <list>
#include <random>
#include <ctime>
#include <cmath>
#include <random>
#include <bitset>
#include <complex>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector< vi > vvi;
typedef vector< vvi > vvvi;
typedef vector<short> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef pair<ld, ld> pld;
typedef complex<double> base;
#define mmin(a, b) a = min(a, (b))
#define mmax(a, b) a = max(a, (b))
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define ALL(a) a.begin(),a.end()
#define sqr(x) (x) * (x)
#define fori(i, n) for(int i = 0; i < int(n); ++i)
#define cint const int &
#define SZ(a) ((int)(a.size()))
#define watch(x) cout << (#x) << " = " << x << endl;
const double PI = 2 * acos(0.0);
template<class T>
void show(const vector<T> &a) {
for (T x : a)
cout << x << " ";
cout << endl;
}
const int N = 1e5 + 9;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#define int ll
int n;
cin >> n;
vi a(n);
fori(i, n) {
cin >> a[i];
a[i] *= 2;
}
sort(ALL(a));
int dist = 2e9;
int sec = -1;
for (int i = 0; i < n - 1; ++i) {
if (a[i] == a[n - 1]) break;
int cur = abs(a[n - 1] / 2 - a[i]);
if (cur < dist) {
dist = cur;
sec = a[i];
}
}
cout << a[n - 1] / 2 << " " << sec / 2 << endl;
} | 0 | 49,950,413 |
#include <stdio.h>
int main (){
char s[4];
scanf("%s",s);
if( s[0] == s[1] && s[1] == s[2]){
printf("No\n");
}
else {
printf("Yes\n");
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <math.h>
#include <vector>
#include <string>
#include <queue>
#include <map>
#include <utility>
#include <iomanip>
#include <set>
using namespace std;
using ll = long long;
#define rep(i,a,b) for(ll i=(a); i<(b); i++)
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define yes cout << "Yes" << endl;
#define no cout << "No" << endl;
#define pai 3.14159265358979323846
ll gcd(ll a, ll b){if (a%b == 0) return(b);else return(gcd(b, a%b));}
ll lcm(ll a, ll b){return a * b / gcd(a, b);}
int main() {
int n;
cin >> n;
int i = n;
while (1) {
if (i < 10) {
cout << i << endl;
return 0;
}
else if (i < 100) {
if (i /10 == i %10) {
cout << i << endl;
return 0;
}
} else if (i < 1000) {
if (i % 10 == (i /10) % 10 && i%10 == (i/10) /10) {
cout << i << endl;
return 0;
}
}
++i;
}
} | 0 | 35,857,586 |
#include<cstdio>
using namespace std;
int main(){
int a,b,c,d;
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
scanf("%d", &d);
int ans = 0;
if (a > b) ans += b;
else ans += a;
if (c > d) ans += d;
else ans += c;
printf("%d\n", ans);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
ll gcd (ll a, ll b) {
if (b > a) {
ll tmp = b;
b = a;
a = tmp;
}
if (b == 0) return a;
return gcd(b, a % b);
}
int main(){
int N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) cin >> A.at(i);
sort(A.begin(), A.end());
ll a = A.at(0);
for (int i = 1; i < N; i++) {
a = gcd(a, A.at(i));
}
cout << a << endl;
return 0;
} | 0 | 33,134,115 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, n;
cin >> x >> n;
unordered_set<int> hashset;
for (int i = 0; i < n; ++i) {
int p;
cin >> p;
hashset.insert(p);
}
int min_diff = 100;
int min_val = 100;
for (int val = 101; val >= 0; val--) {
if (hashset.find(val) == hashset.end()) {
int diff = abs(x - val);
if (diff <= min_diff) {
min_diff = diff;
min_val = val;
}
}
}
cout << min_val << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
string strs;
cin >> strs;
for (auto &s: strs) {
if (s == '1') cout << '9';
else if (s == '9') cout << '1';
else cout << s;
}
cout << endl;
return 0;
} | 0 | 64,699,596 |
bool DBG = false;
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#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 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>>;
constexpr ll LINF = 1LL << 55;
int n, k;
void solve(){
cin >> n >> k;
if(k > (n-1)*(n-2)/2){ coutn(-1); return;}
int m = n-1; k = (n-1)*(n-2)/2 - k;
coutn(m+k);
FOR(i,1,n) { couts(1); coutn(i+1);}
int l=1, r=1;
while(k){
--k;
++r;
if(r>=n){
++l;
r = l+1;
}
couts(l+1); coutn(r+1);
}
}
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define sd(x) scanf("%lf", &x)
#define l0(i,n) for(ll i=0; i<n; i++)
#define MAX 100005
#define maxn 200002
#define pb push_back
#define mk make_pair
#define endl "\n"
#define INF 1000000000
#define MOD 1000000007
#define imie(...) "[" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
int main ()
{
ios::sync_with_stdio(0);
cin.tie(0);
string s1,s2;
cin >> s1 >> s2;
cout << s2+s1 << endl;
return 0;
} | 0 | 58,469,926 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string A, B;
cin >> A >> B;
if (A.size() < B.size()) {
cout << "LESS" << endl;
}
else if (A.size() > B.size()) {
cout << "GREATER" << endl;
}
else {
for (int i = 0; i < A.size(); i++) {
if (A.at(i) == B.at(i) && i < A.size() - 1) {
continue;
}
else if (A.at(i) == B.at(i) && i == A.size() - 1) {
cout << "EQUAL" << endl;
}
else if (A.at(i) < B.at(i)) {
cout << "LESS" << endl;
break;
}
else {
cout << "GREATER" << endl;
break;
}
}
}
} | #include <bits/stdc++.h>
#define f(i,j,k) for(int i=j;i<k;i++)
#define f2(i,j,k) for(int i=j;i>k;i--)
using namespace std;
int main(){
long long k;
double n;
cin>>n>>k;
double ans=0;
f(i,1,n+1){
long double a=1/n;
long long now=i;
while(now<k){
now*=2;
a/=2;
}
ans+=a;
}
cout<<fixed<<setprecision(10)<<ans<<endl;
return 0;
} | 0 | 65,066,757 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int a12 = a/1000;
int a21 = a12/10 + a12%10*10;
int b12 = b/1000;
int b21 = b12/10 + b12%10*10;
int count_less_than_a = 0;
for (int i = 0; i <= 9; i++) {
if (a12*1000 + i*100 + a21 < a){
count_less_than_a++;
}
else {
break;
}
}
int count_more_than_b = 0;
for (int i = 9; i >= 0; i--) {
if (b12*1000 + i*100 + b21 > b){
count_more_than_b++;
}
else {
break;
}
}
int result = (b12 - a12 +1) * 10
- count_less_than_a - count_more_than_b;
cout << result << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAX = 510000;
const int MOD = 998244353;
const int Inv2 = (MOD+1)/2;
signed main(){
int n;
cin>>n;
int a[(1<<n)],b[(1<<n)]={},c[(1<<n)]={},p[4];
for(int i=0;i<(1<<n);i++)cin>>a[i];
for(int i=0;i<(1<<n);i++){
b[i]=i;c[i]=-1;
for(int j=0;j<n;j++){
if(i&(1<<j)){
if(b[i]!=b[i^(1<<j)]&&c[i]!=b[i^(1<<j)]){
if(a[b[i]]<a[b[i^(1<<j)]]){
c[i]=b[i];
b[i]=b[i^(1<<j)];
}else{
if(c[i]==-1||a[c[i]]<a[b[i^(1<<j)]])c[i]=b[i^(1<<j)];
}
}
if(c[i^(1<<j)]==-1||c[i]==c[i^(1<<j)]||b[i]==c[i^(1<<j)])continue;
if(a[b[i]]<a[c[i^(1<<j)]]){
c[i]=b[i];
b[i]=c[i^(1<<j)];
}else{
if(c[i]==-1||a[c[i]]<a[c[i^(1<<j)]])c[i]=c[i^(1<<j)];
}
}
}
}
int ans=0;
for(int i=1;i<(1<<n);i++){
ans=max(ans,a[b[i]]+a[c[i]]);
cout<<ans<<endl;
}
} | 0 | 72,765,497 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
int main() {
int n;
cin>>n;
map<string, int> mp;
long long ans=0;
rep(i,n){
string s;
cin>>s;
sort(s.begin(),s.end());
if(mp[s]>0) ans+=mp[s];
mp[s]++;
}
cout<<ans<<endl;
} | #pragma gcc optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define PER(i, n) for (int i = (n-1); i >= 0; --i)
#define ALL(V) (V).begin(),(V).end()
#define SORT(V) sort(ALL(V))
#define REV(V) reverse(ALL(V))
#define RSORT(V) SORT(V);REV(V)
#define NEXP(V) next_permutation(ALL(V))
#define pb(n) push_back(n)
#define popb(n) pop_back(n)
#define endl '\n'
#define Endl '\n'
#define DUMP(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
#define yes(n) cout << ((n) ? "yes" : "no" ) << endl
#define Yay(n) cout << ((n) ? "Yay!": ":(") << endl
#define VSUM(V) accumulate(ALL(V), 0)
#define MID(a,b,c) (a) < (b) && (b) < (c)
#define MIDe(a,b,c) (a) <= (b) && (b) <= (c)
#define IN(n) cin >> n
#define IN2(a,b) cin >> a >> b
#define IN3(a,b,c) cin >> a >> b >> c
#define IN4(a,b,c,d) cin >> a >> b >> c >> d
#define VIN(V) for(int i = 0; i < (V).size(); i++) {cin >> (V).at(i);}
#define OUT(n) cout << n << endl
#define VOUT(V) REP(i, (V).size()) {cout << (V)[i] << endl;}
#define VOUT2(V) REP(i, (V).size()) {if((V).size()-1!=i){cout << (V)[i] << " ";}else{cout << (V)[i] << endl;}}
#define int long long
#define P pair<ll,ll>
#define Vi vector<ll>
#define VVi vector<vector<ll>>
#define Vd vector<double>
#define Vb vector<bool>
#define Vs vector<string>
#define Vc vector<char>
#define M map<ll,ll>
#define S set<ll>
#define PQ priority_queue<ll>
#define PQG priority_queue<ll,V,greater<ll>
using ll = long long;
using Graph = vector<vector<int>>;
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n) {
for(int i = 0; i < n; ++i) par[i] = i;
}
int root(int x) {
if(par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if(rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int gcd(int a, int b) {
return b != 0 ? gcd(b, a % b) : a;
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
string toStrUp(string str) {
char diff = 'A'-'a';
REP(i,str.size()) str[i] += diff;
return str;
}
string get1ch(string str, int key) {
return str.substr(key,1);
}
map<int,int> prime_factor(int n) {
map<int,int> ret;
for(int i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
bool is_prime(int x) {
for(int i = 2; i * i <= x; i++) {
if(x % i == 0) return false;
}
return true;
}
template<typename T>
vector<T> convert_base(T x, T b) {
vector< T > ret;
T t = 1, k = abs(b);
while(x) {
ret.emplace_back((x * t) % k);
if(ret.back() < 0) ret.back() += k;
x -= ret.back() * t;
x /= k;
t *= b / k;
}
if(ret.empty()) ret.emplace_back(0);
reverse(begin(ret), end(ret));
return ret;
}
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;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n=0,m=0,a=0,b=0,c=0,d=0,x=0,y=0,z=0;
string s="",t="";
int k;
IN2(n,k);
Vi A(n);
VIN(A)
Vi cnt(n);
int ans = 0;
REP(i,n){
int cnt1=0,cnt2=0;
REP(j,i){
if(A[j]>A[i]) cnt1++;
}
REP(j,n){
if(A[j]>A[i]) cnt2++;
}
ans+=cnt1*k+(cnt2%MOD)*((k*(k-1)/2)%MOD);
ans%=MOD;
}
OUT(ans);
} | 0 | 43,453,842 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl '\n'
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
using ll = long long;
using P = pair<ll, ll>;
int main() {
FASTIO;
int a, b, c, d; cin >> a >> b >> c >> d;
cout << ((a + b) > (c + d) ? "Left" : (a + b) == (c + d) ? "Balanced" : "Right") << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for(int (i)=0;(i)<(n);++(i))
#define MOD 1000000007
using namespace std;
typedef long long ll;
int main()
{
int N;
cin >> N;
vector<int> primes;
map<int, int> primeFact;
for (int i = 2; i <= N; ++i)
{
bool isPrime = true;
for (int j = 2; j * j <= i; ++j)
{
if (i % j == 0)
{
isPrime = false;
break;
}
}
if (isPrime) primes.push_back(i);
}
for (auto iter = primes.begin(); iter != primes.end(); ++iter)
{
primeFact[*iter] = 0;
}
for (int i = 2; i <= N; ++i)
{
int n = i;
for (auto iter = primes.begin(); iter != primes.end(); ++iter)
{
while(n % *iter == 0)
{
primeFact[*iter]++;
n /= *iter;
}
if (n == 1) break;
}
}
map<int, int> count;
count[74] = 0;
count[24] = 0;
count[14] = 0;
count[4] = 0;
count[2] = 0;
for (auto iter = primes.begin(); iter != primes.end(); ++iter)
{
if (primeFact[*iter] >= 2) count[2]++;
if (primeFact[*iter] >= 4) count[4]++;
if (primeFact[*iter] >= 14) count[14]++;
if (primeFact[*iter] >= 24) count[24]++;
if (primeFact[*iter] >= 74) count[74]++;
}
int ans = count[74]
+ count[24] * max(count[2] - 1, 0)
+ count[14] * max(count[4] - 1, 0)
+ (count[4] * (count[4] - 1) / 2) * max(count[2] - 2, 0);
cout << ans << endl;
} | 0 | 84,186,905 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(ll i=a;i<b;++i)
#define rrep(i,a,b) for(ll i=a;i>b;--i)
#define FOR(i,n) for(ll i=0;i<n;i++)
#define vi vector<int>
#define vl vector<ll>
#define ld long double
#define vvi vector<vector<int>>
#define vvl vector<vector<long long>>
#define pii pair<int,int>
#define pll pair<long,long>
#define vpii vector<pii>
#define vpll vector<pll>
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define bs binary_search
#define d1(x) cout<<(x)<<endl
#define d2(x,y) cout<<(x)<<" "<<(y)<<endl
#define d3(x,y,z) cout<<(x)<<" "<<(y)<<" "<<(z)<<endl
#define d4(a,b,c,d) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<endl
#define PI 3.1415926535897932384626433832795
#define fix(f,n) fixed<<setprecision(n)<<f
#define all(x) x.begin(),x.end()
#define rev(p) reverse(p.begin(),p.end());
#define endl "\n"
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define popcount(x) __builtin_popcountll(x)
#define sz(x) ((ll)x.size())
const ll M=1000000007;
const ll MM=998244353;
ll begtime = clock();
#define end_routine() cout << "\n\nTime elapsed: " << (clock() - begtime)*1000/CLOCKS_PER_SEC << " ms\n\n";
ll newmod(ll a,ll b)
{
return ((a%b)+b)%b;
}
ll powM(ll a,ll b,ll m )
{
if(a<=0)return 0;
a%=m;
if(!b)return 1;
ll ans=1LL;
while(b)
{
if(b&1)ans=ans*a%m;
a=a*a%m;
b>>=1;
}
return ans;
}
ll poww(ll a,ll b)
{
ll ans=1;
while(b)
{
if(b&1)ans=ans*a;
a=a*a;
b>>=1;
}
return ans;
}
template<typename T,typename F>
void chmax( T &a,F b){
if(b>a)a=b;
}
template<typename T,typename F>
void chmin( T &a,F b){
if(b<a)a=b;
}
const ll N=2e5+5;
ll b[N];
struct cmp{
bool operator()(ll i,ll j)const
{
return b[i]>b[j];
}
};
int main()
{
IOS;
ll n;cin>>n;
ll m;cin>>m;
vl a(n+1);
multiset<ll,cmp>s;
FOR(i,n)cin>>a[i+1]>>b[i+1];
vl lim[m+1];
ll ans=0;
for(int i=1;i<=n;i++){
ll temp=m-a[i];
if(temp<0)continue;
lim[temp].pb(i);
}
for(int x=m-1;x>=0;x--){
for(auto d:lim[x]){
s.insert(d);
}
if(s.empty())continue;
auto it=s.begin();
ans+=b[(*it)];
s.erase(it);
}
cout<<ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define ll long long int
#define mod 1000000007
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define prec(n) fixed << setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int>>
#define PI 3.1415926535897932384626
#define INF 1000000000
#define bits(n) __builtin_popcount(n)
void solve()
{
int n,k;
cin>>n>>k;
int h[n];
for(int i=0;i<n;i++)
{
cin>>h[i];
}
vector<int> v(n,INF);
v[0]=0;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<=i+k;j++)
{
if(j<n)
v[j]=min(v[j],v[i]+abs(h[i]-h[j]));
}
}
cout<<v[n-1];
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
int t = 1;
while (t--)
{
solve();
}
return 0;
} | 0 | 7,784,001 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,a,b;
ll i,j,k;
ll x[100005];
bool solve(){
cin >> n >> a >> b;
if(n + a + b == 0){
return false;
}
for(i=0;i<n;i++){
cin >> x[i];
}
ll num = -100;;
ll ansind = -1;
for(i=a-1;i<b;i++){
ll sa = x[i] - x[i+1];
if(sa >= num){
num = sa;
ansind = i;
}
}
cout << ansind + 1<< endl;
return true;
}
int main(){
while(solve());
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
sort(s.begin(), s.end());
sort(t.begin(), t.end());
reverse(t.begin(), t.end());
bool flag = false;
for (int i = 0; i < 100; i++) {
if (s[i] < t[i]) {
flag = true;
break;
}
else if (s[i] > t[i]) break;
}
if (flag) cout << "Yes" << endl;
else cout << "No" << endl;
} | 0 | 53,781,013 |
#include <iostream>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
for(int a = n / 2, b = a + 1, c = 1; c <= m; a--, b++, c++)
{
if(n % 2 == 0 && (b - a == n / 2 || b - a == n / 2 + 1))
{
b++;
}
cout << a << ' ' << b << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define M 100007
#define INF 1e9
#define INFL 1e18
#define PI acos(-1)
#define mp make_pair
int n;
int dp[100100];
int arr[100100];
int mydp(int i)
{
if(i>=n)
{
return 0;
}
if(dp[i]!=-1)
{
return dp[i];
}
int ret1=INF,ret2=INF;
if(i+2<=n)
{
ret1=abs(arr[i+2]-arr[i])+mydp(i+2);
}
if(i+1<=n)
{
ret2=abs(arr[i+1]-arr[i])+mydp(i+1);
}
dp[i]=min(ret1,ret2);
return dp[i];
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>arr[i];
}
dp[0]=0;
dp[1]=0;
arr[0]=arr[1];
dp[0]=0;
dp[1]=0;
for(int i=2;i<=n;i++)
{
dp[i]=dp[i-1]+abs(arr[i]-arr[i-1]);
if(i-2>=1)
{
dp[i]=min(dp[i],dp[i-2]+abs(arr[i]-arr[i-2]));
}
}
cout<<dp[n]<<endl;
} | 0 | 13,746,766 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int MAX_XYZ = 1005;
ll A[MAX_XYZ],B[MAX_XYZ],C[MAX_XYZ],ans[MAX_XYZ*3];
ll X,Y,Z,K;
bool f(ll x)
{
ll cnt = 0;
rep(i,X)
{
rep(j,Y)
{
ll s = A[i]+B[j];
int l = -1, r = Z;
while(l+1 < r)
{
int m = (l+r)/2;
if (s+C[m] >= x) l = m;
else r = m;
}
cnt += l+1;
}
}
if (cnt >= K) return true;
else return false;
}
int main()
{
cin >> X >> Y >> Z >> K;
rep(i,X)
{
cin >> A[i];
}
sort(A,A+X);
reverse(A,A+X);
rep(i,Y)
{
cin >> B[i];
}
sort(B,B+Y);
reverse(B,B+Y);
rep(i,Z)
{
cin >> C[i];
}
sort(C,C+Z);
reverse(C,C+Z);
ll l = 0, r = ll(1e11);
while(l+1 < r)
{
ll m = (l+r)/2;
if (f(m)) l = m;
else r = m;
}
ll cnt = 0;
bool flag;
rep(i,X)
{
rep(j,Y)
{
flag = false;
rep(k,Z)
{
if (A[i]+B[j]+C[k] > l)
{
ans[cnt] = A[i]+B[j]+C[k];
cnt++;
}
else break;
}
}
}
while(cnt < K)
{
ans[cnt] = l;
cnt++;
}
sort(ans,ans+cnt);
reverse(ans,ans+cnt);
rep(i,cnt)
{
cout << ans[i] << endl;
}
return 0;
} | #include <iostream>
#include <algorithm>
using namespace std;
int main( void )
{
char s[ 4 ];
char t[ 4 ];
cin >> s >> t;
int ans = 0;
for ( int i = 0; i < 3; i++ )
{
if ( s[ i ] == t[ i ] )
{
ans++;
}
}
cout << ans << endl;
return 0;
} | 0 | 9,590,781 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
typedef vector<int> vec;
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%m;
a = a * a%m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
void solve() {
int n; cin >> n;
vec a(n), idx(n);
rep(i, n) cin >> a[i], a[i]--;
rep(i, n) idx[a[i]] = i;
ll ans = 0;
set<int> s;
per(x, n){
ll c = 0;
int i = idx[x];
s.insert(i);
auto it = s.find(i);
vector<ll> l(2, -1), r(2, n);
rep(j, 2){
if(it == s.begin()) break;
it--;
l[j] = *it;
}
it = s.find(i);
rep(j, 2){
it++;
if(it == s.end()) break;
r[j] = *it;
}
vector<ll> ls(2), rs(2);
ls[0] = i-l[0]; ls[1] = l[0]-l[1];
rs[0] = r[0]-i; rs[1] = r[1]-r[0];
c = ls[0]*rs[1] + ls[1]*rs[0];
ans += c*(x+1);
}
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
} | #pragma GCC diagnostic ignored "-Wunused-variable"
#include <bits/stdc++.h>
using namespace std;
#define BOOST
#ifdef BOOST
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/range/adaptor/reversed.hpp>
using namespace boost;
using ml = boost::multiprecision::cpp_int;
using md = boost::multiprecision::cpp_dec_float_100;
#define forir(i, ...) if(ll i=(ll)v.size())for(__VA_ARGS__)if(i--,1)
#define eachr(i, e, c) forir(i, auto &&e: adaptors::reverse(c))
#endif
using ll = long long;
using ld = long double;
using pll = pair<long long, long long>;
template <class T> using vt = vector<T>;
template <class T> using vvt = vector<vector<T>>;
template <class T> using vvvt = vector<vector<vector<T>>>;
#define all(c) (c).begin(), (c).end()
#define coutld cout << fixed << setprecision(10)
#define output(x) do{cout<<x<<endl;exit(0);}while(0)
#define rep(i, b, e) for (ll i = b; i < e; i++)
#define repr(i, b, e) for (ll i = b; e < i; i--)
#define fori(i, ...) if (ll i = -1) for(__VA_ARGS__) if (i++, 1)
#define each(i, e, c) fori (i, auto&& e: c)
#define llong_max 9223372036854775807
#define ldbl_max 1.79769e+308
#define pi 3.1415926535897932
auto Ceil = []
(auto x) { return (ll)ceil(x); };
auto Count = []
(auto b, auto e, auto x) { return (ll)count(b, e, x); };
auto CtoL = []
(auto c) { return (ll)c - (ll)'0'; };
auto LtoC = []
(auto n) { return (char)('0' + n); };
auto Pow = []
(auto a, auto b) { return (ll)pow(a, b); };
auto Pow2 = []
(auto n) { return (1LL << n); };
auto Pow10 = []
(auto n) { return (ll)pow(10, n); };
auto Size = []
(auto& c) { return (ll)(c).size(); };
auto Sum = []
(auto b, auto e) { return accumulate(b, e, 0LL); };
template <class T> void MakeVVT
(ll ys, ll xs, vvt<T>& v, T fill = T())
{
v.resize(ys); rep(y, 0, ys) v[y].resize(xs, fill);
}
template <class T> void MakeVVVT
(ll zs, ll ys, ll xs, vvvt<T>& v, T fill = T())
{
v.resize(zs); rep(z, 0, zs) MakeVVT(ys, xs, v[z], fill);
}
template <class T> void InputVT
(ll xs, vt<T>& v, T fix = T())
{
v.resize(xs); rep(i, 0, xs) { cin >> v[i]; v[i] += fix; }
}
template <class T> void InputVVT
(ll ys, ll xs, vvt<T>& v, T fix = T())
{
MakeVVT(ys, xs, v, fix);
rep(y, 0, ys) rep(x, 0, xs) { cin >> v[y][x]; v[y][x] += fix; }
}
template <class T> void InputVVVT
(ll zs, ll ys, ll xs, vvvt<T>& v, T fix = T())
{
v.resize(zs); rep(z, 0, zs) InputVVT(ys, xs, v[z], fix);
}
namespace NyaGadget {}
using namespace NyaGadget;
int main(void)
{
ll N, X; cin >> N >> X;
vt<ll> x(N); each(i, e, x) cin >> e;
each(i, e, x) e = abs(e - X);
ll ans = x[0];
each(i, e, x) ans = min(ans, gcd(ans, e));
cout << ans;
return 0;
} | 0 | 13,457,230 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll=long long;
int main(){
ll n;
cin>>n;
ll ans=1LL<<60;
ll tmp;
for(ll i=1;i*i<=n;i++){
if(n%i==0){
tmp=i+n/i-2;
ans=min(ans,tmp);
}
}
cout<<ans<<endl;
} | #include<iostream>
using namespace std;
int main(){
int number;
int i=1;
while(1<3){
cin >> number;
if(number == 0){
break;
}
cout << "Case " << i << ": " << number << endl;
i++;
}
return 0;
} | 0 | 65,212,183 |
#include<iostream>
#include<algorithm>
#include<functional>
#include<cmath>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<deque>
using namespace std;
#define ll long long
const int mod = 1000000007;
const ll INF = 1000000000000000000;
int cnt[3];
int main()
{
int N, A, B;
cin >> N >> A >> B;
for (int i = 0; i < N; i++) {
int p;
cin >> p;
if (p <= A) cnt[0]++;
else if (p >= B + 1) cnt[2]++;
else cnt[1]++;
}
cout << min({ cnt[0],cnt[1],cnt[2] }) << endl;
} | #include<stdio.h>
#include<string.h>
int main(){
int k, l;
char str[105];
scanf("%d%s", &k, str);
l = strlen(str);
for (int i=0 ; i<k ; i++){
if (str[i]=='\0'){
break;
}
printf("%c", str[i]);
}
if (l>k){
printf("...");
}
puts("");
return 0;
} | 0 | 76,448,844 |
#include<bits/stdc++.h>
using namespace std;
int n;
int a,b,c;
vector<int> l;
int ans=1000000000;
void dfs(int i,int A,int B,int C,int cal){
if(i==n){
if(A>0 && B>0 && C>0){
ans=min(ans,abs(A-a)+abs(B-b)+abs(C-c)+cal);
}
return;
}
if(A>0 && B>0 && C>0) ans=min(ans,abs(A-a)+abs(B-b)+abs(C-c)+cal);
dfs(i+1,A,B,C,cal);
dfs(i+1,A+l[i],B,C,(A>0 ? cal+10 : cal));
dfs(i+1,A,B+l[i],C,(B>0 ? cal+10 : cal));
dfs(i+1,A,B,C+l[i],(C>0 ? cal+10 : cal));
}
int main(){
cin >> n >> a >> b >> c;
l=vector<int>(n);
for(int i=0;i<n;++i){
cin >> l[i];
}
dfs(0,0,0,0,0);
cout << ans << endl;
return 0;
} | #include<iostream>
#include<cstdio>
using namespace std;
class Dice_c{
private:
int me[4];
int topbot[2];
public:
void Input();
void Roll(int top, int front);
void Output();
};
int main(){
Dice_c dice;
int m;
int top,front;
dice.Input();
cin >> m;
for(int i=0; i<m; i++){
cin >> top >> front;
dice.Roll(top,front);
dice.Output();
}
return 0;
}
void Dice_c::Input(){
cin >> me[1] >> topbot[1] >> me[2] >> me[0] >> topbot[0] >> me[3];
getchar();
}
void Dice_c::Roll(int top,int front){
int tmp;
if(me[1]!=top){
if(me[0]==top){
tmp=me[3];
me[3]=me[2] , me[2]=me[1] , me[1]=me[0] , me[0]=tmp;
}
else if(me[2]==top){
tmp=me[0];
me[0]=me[1] , me[1]=me[2] , me[2]=me[3] , me[3]=tmp;
}
else{
while(me[1]!=top){
tmp = topbot[0];
topbot[0]=me[1] , me[1]=topbot[1] , topbot[1]=me[3] , me[3]=tmp;
}
}
}
while(topbot[1]!=front){
tmp=topbot[1];
topbot[1]=me[2] , me[2]=topbot[0] , topbot[0]=me[0] , me[0]=tmp;
}
}
void Dice_c::Output(){
cout << me[2] << endl;
} | 0 | 46,348,341 |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
using namespace std;
int main() {
int a,b,c,d;
string s,ss;
long long ans = 0;
cin >> s >> ss;
if(s == "H" && ss == "H" || s == "D" && ss == "D") s = "H";
else s = "D";
cout << s << 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;
}
inline int inv (int x, int m = MOD) {
return binpow(x, m - 2, m);
}
vector <int> f, fi;
inline void precalc_f (int n, int m = MOD) {
f.resize(n);
fi.resize(n);
f[0] = 1;
for (int i = 1; i < n; i++) {
f[i] = mul(f[i - 1], i, m);
}
fi[n - 1] = inv(f[n - 1], m);
for (int i = n - 2; i >= 0; i--) {
fi[i] = mul(fi[i + 1], i + 1, m);
}
}
inline int A (int n, int k, int m = MOD) {
return mul(f[n], fi[n - k], m);
}
inline int C (int n, int k, int m = MOD) {
return mul(A(n, k), fi[k], m);
}
main()
{
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
ll x;
vector <int> cnt1(61);
vector <int> cnt0(61);
for (int i = 0; i < n; i++) {
cin >> x;
for (int j = 0; j < 60; j++) {
if (x & (1ll << j)) {
++cnt1[j];
}
else {
++cnt0[j];
}
}
}
int ans = 0;
for (int i = 0; i < 60; i++) {
add(ans, mul(binpow(2, i), mul(cnt1[i], cnt0[i])));
}
cout << ans << '\n';
} | 0 | 90,680,597 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
using p = pair<int,int>;
const long long inf = 1000000001;
const double PI = 3.14159265358979323846;
int main(void){
int bingo[3][3];
rep(i,3){
rep(j,3){
cin >> bingo[i][j];
}
}
int n;
cin >> n;
int b[n];
rep(i,n){
cin >> b[i];
}
bool appear[3][3];
rep(i,n){
rep(j,n){
appear[i][j] = false;
rep(k,n){
if(bingo[i][j] == b[k]){
appear[i][j] = true;
}
}
}
}
string ans = "No";
rep(i,3){
if(appear[0][i] && appear[1][i] && appear[2][i]){
ans = "Yes";
}
}
rep(i,3){
if(appear[i][0] && appear[i][1] && appear[i][2]){
ans = "Yes";
}
}
if(appear[0][0] && appear[1][1] && appear[2][2]){
ans = "Yes";
}
if(appear[0][2] && appear[1][1] && appear[2][0]){
ans = "Yes";
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define pb push_back
#define fst first
#define snd second
#define sz(x) int(x.size())
#define fill(x,v) memset(x,v,sizeof(x))
#define REP(i,a,b) for(int i = int(a); i < int(b); ++i)
#define trace(x) cout << #x << " = " << x << endl
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
const int N = 1e5+20, MOD = 1e9+7;
int gg[N];
int main(){
fastio;
int n,m;
cin >> n >> m;
fill(gg,0);
REP(i,0,m){
int x;
cin >> x;
gg[x] = 1;
}
vector<int> dp(n+1,1);
for(int i = 1; i <= n; ++i){
if(gg[i]){
dp[i] = 0;
continue;
}
dp[i] = dp[i-1];
if(i-2 >= 0) dp[i] = (dp[i] + dp[i-2]) % MOD;
}
cout << dp[n] << endl;
return 0;
} | 0 | 79,034,826 |
#include <iostream>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#define int long long
typedef long long ll;
using namespace std;
ll N, K, A[15], M[16], mincount=100000000000;
void dfs(ll id, ll k, vector<ll> v){
if(k>K) return;
if(id==N){
if(k!=K) return;
ll ms[N+1];
ll count=0;
for(ll i=0;i<N+1;i++) ms[i] = M[i];
for(ll i=0;i<v.size();i++) {
if(v[i]==1) {
if(A[i]-ms[i]-1<0) {
count+= ms[i]+1-A[i];
for(ll j=i+1;j<N+1;j++) ms[j] = max(ms[i]+1, ms[j]);
}
}
}
mincount = min(mincount, count);
return;
}
v[id] = 0;
dfs(id+1, k, v);
v[id] = 1;
dfs(id+1, k+1, v);
}
signed main(){
cin >> N >> K;
ll mh = 0;
for(ll i=0;i<N;i++) {
M[i] = mh;
cin >> A[i];
mh = max(mh, A[i]);
}
vector<ll> vemp;
vemp.resize(N);
dfs(0, 0, vemp);
cout << mincount << endl;
return 0;
} | #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...);
}
void solve() {
ll n;
cin >> n;
ll ans = (n * (n - 1)) / 2;
cout << ans;
}
int main() {
fast_io;
int t = 1;
while (t--) {
solve();
}
return 0;
} | 0 | 73,090,802 |
#include <bits/stdc++.h>
#define ALL(A) (A).begin(),(A).end()
#define ll long long
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
int N,K;
cin >> N >> K;
long long ans = 1LL<<62;
vector<ll> x(N),y(N);
rep(i,N)cin >> x[i] >> y[i];
rep(a,N)rep(b,N)rep(c,N)rep(d,N){
ll left = min(x[a],x[b]);
ll right= max(x[a],x[b]);
ll up = max(y[c],y[d]);
ll down = min(y[c],y[d]);
int cnt = 0;
rep(e,N)if(left<=x[e] && x[e] <= right && down <= y[e] && y[e] <= up)cnt++;
if(cnt>=K)ans = min(ans,abs(left-right)*abs(up-down));
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <numeric>
#include <cstdint>
#include <iomanip>
using ll = long long;
int main(){
ll H, W; std::cin >> H >> W;
std::string temp(W+2,'.');
std::vector<std::string> s(H+2, temp);
for(int i=0; i<H; i++){
std::string b; std::cin >> b;
for(int j=0; j<W; j++){
s[i+1][j+1] = b[j];
}
}
for(int i=1; i<=H; i++){
for(int j=1; j<=W; j++){
if(s[i][j]=='#'){
if(s[i][j+1]=='#'){
;
}else if(s[i][j-1]=='#'){
;
}else if(s[i+1][j]=='#'){
;
}else if(s[i-1][j]=='#'){
;
}else{
std::cout << "No";
return 0;
}
}
}
}
std::cout << "Yes";
return 0;
} | 0 | 36,572,426 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
int N=(a+b)/2;
if ((a+b)%2==1){
N++;
}
cout<<N<<endl;
} | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
bool field[20][20];
int cnt;
int dx[] = {1,0};
int dy[] = {0,1};
int h,w;
void dfs(int x,int y){
for(int i = 0; i < 2; i++){
int px = x + dx[i];
int py = y + dy[i];
if(px >= 0 && px < w && py >= 0 && py < h){
if(py == h-1 && px == w - 1){
cnt++;
return;
}
if(field[py][px] == true){
dfs(px,py);
}
}
}
}
int main(){
int n;
while(cin >> w >> h && !(w == 0 && h == 0)){
for(int i = 0; i < 20; i++)
fill(field[i],field[i]+20,true);
cin >> n;
cnt =0;
for(int i = 0; i < n; i++){
int xx,yy;
cin >> xx >> yy;
xx--;
yy--;
field[yy][xx] = false;
}
dfs(0,0);
cout << cnt << endl;
}
return 0;
} | 0 | 18,888,611 |
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
#define endl "\n"
#define ALL(x) begin(x),end(x)
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
const int MOD = 1e9 + 7;
constexpr long double pi = 3.141592653589793238462643383279;
int fact(int i) {
if (i == 0) return 1;
return ((fact(i - 1)) * i) % MOD;
}
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) {
ll n, h, w;
ll ans = 0;
cin >> n >> h >> w;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
if (h <= a && w <= b) ++ans;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define REP(i,n) for(int i=0; i<(n); i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define ALL(n) begin(n),end(n)
#define IN(a, x, b) (a<=x && x<b)
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
template<class T> inline T CHMAX(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T CHMIN(T & a, const T b) { return a = (a > b) ? b : a; }
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
int main()
{
INIT;
int n;
cin >> n;
int count = 0;
vector<int> h(n);
REP(i,n){
cin >> h.at(i);
}
for(int i = 1; i < n; i++){
int ma = h.at(i-1);
for(int j = 0; j < i; j++){
ma = max(ma, h.at(j));
}
if(ma <= h.at(i)) count++;
}
cout << count + 1 << endl;
return 0;
} | 0 | 82,876,270 |
#pragma GCC optimize("Ofast", "unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
const auto half = [](int a) {return a >> 1; };
const auto halfl = [](ll a) { return a >> 1; };
string s; cin >> s;
int k; cin >> k;
bool all_same = true;
for (int i = 0; i < s.length() - 1; ++i)
all_same &= s[i] == s[i + 1];
if (all_same)
cout << halfl((ll)(s.length()) * k) << endl;
else {
vector<int> separate;
int l = 0, ptr = 1;
while (l < s.length()) {
if (ptr == s.length() || s[ptr] != s[ptr - 1]) {
separate.push_back(ptr - l);
l = ptr;
}
++ptr;
}
ll res = 0;
if (s[0] != s[s.length() - 1]) {
for (auto i : separate)
res += (ll)k * half(i);
cout << res << endl;
}
else {
int sz = separate.size();
res += half(separate[0]);
res += half(separate[sz - 1]);
for (int i = 1; i < sz - 1; ++i)
res += (ll)k * half(separate[i]);
int b = separate[0] + separate[sz - 1];
res += (k - 1LL) * half(b);
cout << res << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define ll long long int
#define mod 1000000007
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define prec(n) fixed << setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int>>
#define PI 3.1415926535897932384626
#define bits(n) __builtin_popcount(n)
void solve()
{
string s,t;
cin>>s>>t;
bool ok=true;
if(s.length()==t.length()-1)
{
for(int i=0;i<s.length();i++)
{
if(s[i]!=t[i])
{
cout<<"No";
ok=false;
break;
}
}
if(ok)
cout<<"Yes";
}
else
{
cout<<"No";
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
int t = 1;
while (t--)
{
solve();
}
return 0;
} | 0 | 23,999,412 |
#include<bits/stdc++.h>
using namespace std;
int a,b,n,x,y;
int memo[19][19]={0},check[19][19]={0};
int saiki(int x,int y){
if(check[x][y]==1)return(memo[x][y]);
else{
memo[x][y]=saiki(x,y-1)+saiki(x-1,y);
check[x][y]=1;
return memo[x][y];
}
}
int main(){
while(1){
cin>>a>>b;
if(a==0 && b==0)break;
cin>>n;
for(int i=0;i<=a;i++){
for(int j=0;j<=b;j++){
memo[i][j]=0;
check[i][j]=0;
}
}
for(int i=0;i<=a;i++){
check[i][0]=1;
}
for(int i=0;i<=b;i++){
check[0][i]=1;
}
memo[0][1]=1;
for(int i=0;i<n;i++){
cin>>x>>y;
check[x][y]=1;
}
memo[0][1]=1;
saiki(a,b);
cout<<memo[a][b]<<endl;
}
} | #include <iostream>
#include <map>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <sstream>
#include <cmath>
#include <math.h>
#include <string>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll h , w , x = 1e10;
cin >> h >> w;
if ( w % 3 == 0 ) x = min( x , 0ll );
else x = min( x , h );
if ( h % 3 == 0 ) x = min( x , 0ll );
else x = min( x , w );
for ( int i = 1 ; i < w ; i++ ) {
ll a = i * h , b , c;
if ( h % 2 == 1 ) {
b = ( h / 2 ) * ( w - i );
c = b + w - i;
} else {
b = ( h / 2 ) * ( w - i );
c = b;
}
x = min( x , max( { a , b , c } ) - min( { a , b , c } ) );
}
for ( int i = 1 ; i < h ; i++ ) {
ll a = i * w , b , c;
if ( w % 2 == 1 ) {
b = ( w / 2 ) * ( h - i );
c = b + h - i;
} else {
b = ( w / 2 ) * ( h - i );
c = b;
}
x = min( x , max( { a , b , c } ) - min( { a , b , c } ) );
}
cout << x;
} | 0 | 41,779,687 |
#include <bits/stdc++.h>
#define ALL(obj) begin(obj), end(obj)
#define debug(x) cerr << #x << ": " << x << '\n'
using namespace std;
template <class T>
vector<T> make_vec(size_t a) {
return vector<T>(a);
}
template <class T, class... Ts>
auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <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;
}
using ll = long long;
using ull = unsigned long long;
const int INF = 1e9;
int main() {
int N;
cin >> N;
vector<int> p(N);
for (int i = 0; i < N; i++) {
cin >> p.at(i);
}
vector<int> a(N), b(N);
int M = 30000;
for (int i = 0; i < N; i++) {
a[i] = (i * M + 1);
}
for (int i = 0; i < N; i++) {
a[p[i] - 1] += i;
}
for (int i = 0; i < N; i++) {
b[i] = (N - i - 1) * M + 1;
}
for (int i = 0; i < N; i++) {
cout << a[i];
if (i != N - 1) cout << " ";
}
cout << endl;
for (int i = 0; i < N; i++) {
cout << b[i];
if (i != N - 1) cout << " ";
}
cout << endl;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
int mod=1e9+7;
int fac[100005];
int modInverse(int a, int m)
{
int m0 = m;
int y = 0, x = 1;
if (m == 1)
return 0;
while (a > 1)
{
int q = a / m;
int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0)
x += m0;
return x;
}
int compute(int a,int b)
{
if(a<b)
return 0;
int z=(fac[b]*fac[a-b])%mod;
z=modInverse(z,mod);
z=fac[a]*z;
z%=mod;
return z;
}
signed main()
{
int n;
cin>>n;
fac[0]=1;
for (int i = 1; i <=n+1 ; ++i) {
fac[i]=(fac[i-1]*i)%mod;
}
int a[n+2];
int mm[n+2]={0};
int ind1,ind2;
n++;
for (int i = 1; i <=n ; ++i) {
cin>>a[i];
if(mm[a[i]])
{
ind1=mm[a[i]];
ind2=i;
}
mm[a[i]]=i;
}
for (int j = 1; j <=n ; ++j) {
int ans=(compute(n,j)-compute(n-(ind2-ind1+1),j-1)+mod)%mod;
cout<<ans<<"\n";
}
} | 0 | 33,316,317 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
int main(){
ll n,m;
cin >> n >> m;
ll a[n],b[n];
vector<ll> t[100005];
for(ll i=0;i<n;i++){
cin >> a[i] >> b[i];
t[a[i]].push_back(b[i]);
}
priority_queue<ll> pq;
ll res=0;
for(ll i=1;i<=m;i++){
for(auto p:t[i]){
pq.push(p);
}
if(!pq.empty()){
res+=pq.top();
pq.pop();
}
}
cout << res << endl;
} | #pragma GCC diagnostic ignored "-Wunused-variable"
#include <bits/stdc++.h>
using namespace std;
#define BOOST
#ifdef BOOST
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/range/adaptor/reversed.hpp>
using namespace boost;
using ml = boost::multiprecision::cpp_int;
using md = boost::multiprecision::cpp_dec_float_100;
#define forir(i, ...) if(ll i=(ll)v.size())for(__VA_ARGS__)if(i--,1)
#define eachr(i, e, c) forir(i, auto &&e: adaptors::reverse(c))
#endif
using ll = long long;
using ld = long double;
using pll = pair<long long, long long>;
template <class T> using vt = vector<T>;
template <class T> using vvt = vector<vector<T>>;
template <class T> using vvvt = vector<vector<vector<T>>>;
#define all(c) (c).begin(), (c).end()
#define coutd cout << fixed << setprecision(10)
#define output(x) do{cout<<x;return 0;}while(0)
#define rep(i, b, e) for (ll i = b; i < e; i++)
#define repr(i, b, e) for (ll i = b; e < i; i--)
#define fori(i, ...) if (ll i = -1) for(__VA_ARGS__) if (i++, 1)
#define each(i, e, c) fori (i, auto&& e: c)
#define llong_max 9223372036854775807
#define ldbl_max 1.79769e+308
#define pi 3.1415926535897932
auto Ceil = []
(auto x) { return (ll)ceil(x); };
auto Count = []
(auto b, auto e, auto x) { return (ll)count(b, e, x); };
auto CtoL = []
(auto c) { return (ll)c - (ll)'0'; };
auto LtoC = []
(auto n) { return (char)('0' + n); };
auto Pow = []
(auto a, auto b) { return (ll)pow(a, b); };
auto Pow2 = []
(auto n) { return (1LL << n); };
auto Pow10 = []
(auto n) { return (ll)pow(10, n); };
auto Size = []
(auto& c) { return (ll)(c).size(); };
auto Sum = []
(auto b, auto e) { return accumulate(b, e, 0LL); };
template <class T> void MakeVVT
(ll ys, ll xs, vvt<T>& v, T fill = T())
{
v.resize(ys); rep(y, 0, ys) v[y].resize(xs, fill);
}
template <class T> void MakeVVVT
(ll zs, ll ys, ll xs, vvvt<T>& v, T fill = T())
{
v.resize(zs); rep(z, 0, zs) MakeVVT(ys, xs, v[z], fill);
}
template <class T> void InputVVT
(ll ys, ll xs, vvt<T>& v, T fix = T())
{
MakeVVT(ys, xs, v, fix);
rep(y, 0, ys) rep(x, 0, xs) { cin >> v[y][x]; v[y][x] += fix; }
}
template <class T> void InputVVVT
(ll zs, ll ys, ll xs, vvvt<T>& v, T fix = T())
{
v.resize(zs); rep(z, 0, zs) InputVVT(ys, xs, v[z], fix);
}
namespace NyaGadget {}
using namespace NyaGadget;
int main(void)
{
string N; cin >> N; N.insert(N.begin(), ' ');
ll K; cin >> K;
vvvt<ll> dp; MakeVVVT(Size(N), K + 1, 2, dp);
enum state { EQ, LT };
dp[0][0][state::EQ] = 1;
rep(j, 1, Size(N)) rep(k, 0, K + 1)
{
if (CtoL(N[j]) == 0)
{
dp[j][k][state::LT] += dp[j - 1][k][state::LT];
if (k + 1 <= K) dp[j][k + 1][state::LT] += dp[j - 1][k][state::LT] * 9;
dp[j][k][state::EQ] += dp[j - 1][k][state::EQ];
}
else
{
dp[j][k][state::LT] += dp[j - 1][k][state::LT];
if (k + 1 <= K) dp[j][k + 1][state::LT] += dp[j - 1][k][state::LT] * 9;
if (k + 1 <= K) dp[j][k + 1][state::LT] += dp[j - 1][k][state::EQ] * (CtoL(N[j]) - 1);
dp[j][k][state::LT] += dp[j - 1][k][state::EQ];
if (k + 1 <= K) dp[j][k + 1][state::EQ] += dp[j - 1][k][state::EQ];
}
}
cout << dp.back()[K][state::EQ] + dp.back()[K][state::LT];
return 0;
} | 0 | 47,234,935 |
#include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
int n, m;
unordered_map<string, int> mp;
int main(void){
cin >> n;
rep(i, n){
string s;
cin >> s;
mp[s]++;
}
cin >> m;
rep(i, m){
string t;
cin >> t;
mp[t]--;
}
int ans = -INT_MAX;
for(auto i : mp){
ans = max(ans, i.second);
}
cout << max(ans, 0) << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <stack>
#include <set>
#include <queue>
#include <iomanip>
#include <math.h>
#include <fstream>
using namespace std;
class pqComp
{
public:
bool operator()(pair<int, int> &a, pair<int, int> &b)
{
return a.second < b.second;
}
};
bool sorting(pair<int, int> a, pair<int, int> b)
{
return a.second < b.second;
}
int main()
{
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
cin.tie();
cout.tie();
int n, m;
cin >> n >> m;
vector<vector<int>> v(n);
for (int i = 0; i < m; i++)
{
int x, y;
cin >> x >> y;
v[x - 1].push_back(y - 1);
v[y - 1].push_back(x - 1);
}
vector<bool> visited(n, false);
vector<int> rez(n);
queue<int> q;
q.push(0);
int cnt = n;
while (!q.empty())
{
int curr = q.front();
q.pop();
for (int i = 0; i < v[curr].size(); i++)
{
if (visited[v[curr][i]])
{
continue;
}
visited[v[curr][i]] = true;
rez[v[curr][i]] = curr;
cnt--;
q.push(v[curr][i]);
}
}
if (cnt != 0)
{
cout << "No\n";
return 0;
}
cout << "Yes\n";
for (int i = 1; i < n; i++)
{
cout << rez[i] + 1 << '\n';
}
return 0;
} | 0 | 84,795,580 |
#include <iostream>
using namespace std;
int main()
{
long long ans,cnt,i,j,g;
string s,t;
ans=1000000;
cin>>s>>t;
for(i=0;i<s.length();i++)
{
cnt=0;g=5;
for(j=0;j<t.length();j++)
{
if(i+j>=s.length()){g=0;break;}
if(s[i+j]!=t[j]){cnt++;}
}
if(g==0){continue;}
ans=min(ans,cnt);
}
cout<<ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin>>n>>k;
vector<int> data(n);
for (int i=0;i<n;i++){
int tmp;
cin>>tmp;
data.at(i)=tmp;
}
vector<int> count(200001,0);
for (int i=0;i<n;i++){
count.at(data.at(i))++;
}
sort(count.begin(),count.end());
int plusindex;
for (int i=0;i<=200000;i++){
if (count.at(i)>0){
plusindex=i;
break;
}
}
int kinds=200000-plusindex+1;
int answer=0;
if (kinds<=k){
answer=0;
}
else {
for (int i=plusindex;i<=200000-k;i++){
answer+=count.at(i);
}
}
cout<<answer<<endl;
} | 0 | 64,055,242 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for (ll i = 0; i < (n); i++)
typedef pair<ll,ll> P;
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;
cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a[i];
sort(a.begin(), a.end(), less<ll>());
vector<ll> l;
vector<ll> r;
l.push_back(a[0]);
r.push_back(a[n-1]);
rep(i,n-2){
if(a[i+1]>0){
r.push_back(a[i+1]);
}else{
l.push_back(a[i+1]);
}
}
vector<P> ans;
ll x = l[l.size()-1];
ll y;
rep(i,r.size()-1){
y = r[i];
P p = {x,y};
ans.push_back(p);
x = x-y;
}
y = x;
x = r[r.size()-1];
P p = {x,y};
ans.push_back(p);
x = x-y;
rep(i,l.size()-1){
y = l[i];
P p = {x,y};
ans.push_back(p);
x = x-y;
}
cout << x << endl;
rep(i,n-1){
cout << ans[i].first << " " << ans[i].second << endl;
}
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 | 44,844,782 |
#include <bits/stdc++.h>
using namespace std;
#define println(msg) cout << msg << endl
int main() {
int N, D;
cin >> N >> D;
vector<vector<int>> vvi(N);
for (int i = 0; i < N; i++) {
for (int j = 0; j < D; j++) {
int x;
cin >> x;
vvi.at(i).push_back(x);
}
}
set<int> table;
{
int max = D * (40 * 40);
int c = 1;
while (true) {
if ((c * c) > max) break;
table.insert(c * c);
c++;
}
}
int count = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (i == j) continue;
if (i >= j) continue;
auto p1 = vvi.at(i);
auto p2 = vvi.at(j);
int sum = 0;
for (int k = 0; k < D; k++) {
sum += ((p1.at(k) - p2.at(k)) * (p1.at(k) - p2.at(k)));
}
if (table.find(sum) != table.end()) {
count++;
}
}
}
println(count);
} | #include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef long long ll;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INT_INF = 2147483647;
const long long LL_INF = 1LL<<60;
const long long MOD = 1000000007;
#define CLR(a) memset((a), 0 ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << 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; }
int main(void){
ll N,K; cin >> N >> K;
vector<ll> A(N); REP(i,N) cin >> A[i];
vector<ll> S1(N+1), S2(N+1); S1[0] = 0; S2[0] = 0;
REP(i,N){
S1[i+1] = S1[i] + A[i];
S2[i+1] = (S1[i+1] - (i+1)) % K;
}
map<ll,ll> m;
REP(i,min(N+1,K)){
if(m.find(S2[i]) == m.end()) m[S2[i]] = 1;
else m[S2[i]]++;
}
ll ans = 0;
for(auto p : m){
ans += p.second * (p.second-1) / 2;
}
FOR(i,K,N+1){
if(m[S2[i-K]]) m[S2[i-K]]--;
else m.erase(m[S2[i-K]]);
if(m.find(S2[i]) != m.end()) ans += m[S2[i]]++;
else m[S2[i]] = 1;
}
cout << ans << endl;
return 0;
} | 0 | 30,947,168 |
#define rep(i,n) for (int i=0;i<n;i++)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int N,R;
cin>> N >> R;
if(N>=10)
cout << R << endl;
else
cout << R + 100*(10-N) <<endl;
} | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define repr(i,a,b) for(ll i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define invrepr(i,a,b) for(int i=b-1;i>=a;i--)
#define invrep(i,n) invrepr(i,0,n)
#define repitr(itr,a) for(auto itr=a.begin();itr!=a.end();++itr)
const int MOD=1e9+7;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
ll ans=0;
rep(i,n) {
ans+=a[i]/2;
if (a[i+1]>0) a[i+1]+=a[i]%2;
}
cout << ans << endl;
return 0;
} | 0 | 56,135,731 |
#include <bits/stdc++.h>
#include <math.h>
#define REP(i, n) for(int i = 0; i < (n); i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
const int mINF = -1001001001;
int main() {
int x,y;
cin >> x >> y;
cout << x+ y/2 << endl;
return 0;
} | #include <bits/stdc++.h>
#include <fstream>
#include<string>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
typedef long long ll;
typedef long double ld;
using namespace std;
using namespace __gnu_pbds;
#define endl "\n"
#define FIO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const int N=3e5+5;
ll mod=998244353 ;
ll mul (ll a, ll b)
{
a%=mod;
b%=mod;
return (a*b)%mod;
}
ll add (ll a, ll b)
{
a%=mod;
b%=mod;
return (a+b+mod)%mod;
}
ll fastpow(ll b, ll p)
{
if(p==0)
return 1;
ll ans=fastpow(b,p/2);
ans=mul(ans,ans);
if(p%2)ans=mul(ans,b);
return ans;
}
int main()
{
FIO
string s;
cin>>s;
int co1=0,co2=0;
for(int i=0;i<s.size();i++)
{
if(i%2==0)
{
if(s[i]=='1')
co2++;
else
co1++;
}
else
{
if(s[i]=='1')
co1++;
else
co2++;
}
}
cout<<min(co1,co2);
return 0;
} | 0 | 74,627,309 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
int main(){
ll l, r;
cin >> l >> r;
ll ans = 10000;
for(ll i=l; i <= l+2020; i++){
if(i==r) break;
for(ll j=l+1; j <= l+2021; j++){
ans = min(ans, (i*j)%2019);
if(j == r) break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define repex(i, a, b, c) for(int i = a; i < b; i += c)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
LL a[101010], b[101010];
int main(){
int N;
scanf("%d", &N);
rep(i, N) scanf("%lld %lld", &a[i], &b[i]);
LL ans = 0;
repr(i, N - 1, 0){
LL o = a[i] + ans;
LL q = o / b[i];
LL r = o % b[i];
if(r) ans += (q + 1) * b[i] - o;
}
printf("%lld\n", ans);
return 0;
} | 0 | 67,020,428 |
#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(){
int N;
cin >> N;
vector<int> v(N);
for(int i = 0; i < N; ++i) {
cin >> v[i];
}
sort(v.begin(),v.end());
double ans = v[0];
for (int i = 1; i < N; ++i) {
ans += v[i];
ans /= 2;
}
cout << ans << endl;
} | #pragma region header
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr ll inf = INT32_MAX/2;
constexpr ll INF = LLONG_MAX/2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a <= b) {
a = b;
return true;
}
return false;
}
ll fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) {
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
int keta(ll n) {
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
#pragma endregion
signed main() {
int a,b;cin >>a >> b;
cout << (a-1)*(b-1) << "\n";
return 0;
} | 0 | 24,869,790 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rep2(i,s,n) for(int i = (s); i < (n); ++i)
#define ll long long
#define ld long double
#define P pair<ll,ll>
#define all(v) v.begin(),v.end()
const ll mod = 1e9+7;
const ll INF = 1e18;
const double pi = acos(-1.0);
int main(void)
{
ll w,h,n; cin>>w>>h>>n;
ll ans,x1=0,x2=w,y1=0,y2=h;
rep(i,n){
ll x,y,a;
cin>>x>>y>>a;
if(a==1) x1=max(x1,x);
if(a==2) x2=min(x2,x);
if(a==3) y1=max(y1,y);
if(a==4) y2=min(y2,y);
}
if(x1>=x2||y1>=y2) ans=0;
else ans=(x2-x1)*(y2-y1);
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int h, w;
cin >> h;
cin >> w;
vector<vector<char>> c(h+2,vector<char>(w+2));
rep(i, h+2) {
rep(j, w+2) {
if (i == 0 || j == 0 || i == h+1 || j == w+1) {
c[i][j] == '.';
} else {
cin >> c[i][j];
}
}
}
bool flag = true;
rep(i, h+1) {
rep(j, w+1) {
if (i == 0 || j == 0) continue;
if (c[i][j] == '#') {
if (c[i-1][j] == '.' && c[i+1][j] == '.' && c[i][j-1] == '.' && c[i][j+1] == '.') {
flag = false;
break;
}
}
}
if (!flag) break;
}
if (flag) cout << "Yes" << endl;
else cout << "No" << endl;
} | 0 | 98,168,611 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
#define rrep(i,n) for(int i=1;i<(n);++i)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define dunk(a) cout << (a) << "\n"
using namespace std;
typedef long long ll;
const int inf = 1001001001;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll x, y;
cin >> x >> y;
if (x % y == 0) {
dunk(-1);
return 0;
}
ll time = 1;
while (x * time <= 1e18) {
x *= time;
if (x % y != 0) {
dunk(x);
return 0;
}
time++;
}
dunk(-1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> data(N);
for(int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
data.at(i) = make_pair(a, b);
}
sort(data.begin(), data.end());
int ans = 0;
priority_queue<int> keep;
int start = 0;
for(int i = 0; i < M; i++) {
if(start <= N - 1) {
for(int j = start; j < N && data.at(j).first <= i + 1; j++) {
keep.push(data.at(j).second);
start++;
}
}
if(!keep.empty()) {
ans += keep.top();
keep.pop();
}
}
cout << ans << endl;
} | 0 | 9,159,740 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
ll combination(ll n, ll r) {
if (n / 2 <= r) {
r = n - r;
}
ll res = 1;
for (ll i = 0; i < r; ++i) {
res *= (n - i);
}
for (ll i = r; i > 0; --i) {
res /= i;
}
return res;
}
int main() {
ll n, p; cin >> n >> p;
vector<ll> a(n);
for (ll i = 0; i < n; ++i) {
cin >> a[i];
}
ll even = 0;
ll odd = 0;
for (ll i = 0; i < n; ++i) {
if (a[i] % 2 == 0) {
++even;
} else {
++odd;
}
}
ll sum = 0;
for (ll i = 1; i <= odd; i += 2) {
ll com = combination(odd, i);
com *= (ll)pow(2, even);
sum += com;
}
if (p == 1) {
cout << sum << endl;
} else {
cout << (ll)pow(2, n) - sum << endl;
}
} | #include <iostream>
#include <vector>
using namespace std;
int findRoot(int* parent, int x) {
if (parent[x] == x) {
return x;
}
parent[x] = findRoot(parent, parent[x]);
return parent[x];
}
bool isSame(int* parent, int x, int y) {
return findRoot(parent, x) == findRoot(parent, y);
}
void unite(int* parent, int x, int y) {
x = findRoot(parent, parent[x]);
parent[x] = findRoot(parent, y);
}
int main() {
int n, m;
cin >> n >> m;
vector<int> nums;
nums.reserve(n+1);
nums.emplace_back(0);
for (int i = 0; i < n; ++i) {
int num;
cin >> num;
nums.emplace_back(num);
}
int parent[n+1];
for (int i = 0; i <= n; ++i) {
parent[i] = i;
}
for (int i = 0; i < m; ++i) {
int num1, num2;
cin >> num1 >> num2;
unite(parent, num1, num2);
}
int res = 0;
for (int i = 1; i <= n; ++i) {
if (isSame(parent, i, nums.at(i))) {
++res;
}
}
cout << res << endl;
return 0;
} | 0 | 34,220,962 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e16;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < (ll)(n); i++)
int main() {
string s; cin >> s;
stack <ll> st;
rep(i, s.size()) {
if (s.at(i) == '0') st.push(0);
else if (s.at(i) == '1') st.push(1);
else if (st.size()) st.pop();
}
vector <ll> v;
ll n = st.size();
rep(i, n) {
v.push_back(st.top()); st.pop();
}
rep(i, v.size()) cout << v.at(v.size()-1-i);
cout << endl;
} | #include<bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for(int i=(l), i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
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;}
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;
}
char alpha[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int main(){
int n, x, t; cin >> n >> x >> t;
int sum = 0;
while(1){
sum += t;
n -= x;
if(n <= 0){
cout << sum << endl;
return 0;
}
}
} | 0 | 75,987,476 |
#include <cstdio>
#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#define rep(i,n) for (int i=0;i<n;i++)
using ll = long long;
using namespace std;
void solve(){
}
int main (){
ios::sync_with_stdio(0);
cin.tie(0);
int n,m;
cin >> n >> m;
vector<pair<ll,ll>> a(n);
rep(i,n){
cin >> a[i].first >> a[i].second;
}
sort(a.begin(),a.end());
ll cost=0;
ll num=0;
ll i=0;
while(num<m){
if(a[i].second<=m-num){
cost+=(a[i].first)*a[i].second;
num+=a[i].second;
}
else{
cost+=(a[i].first)*(m-num);
num = m;
}
i++;
}
cout << cost << endl;
return 0;
} | #include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <deque>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <chrono>
#include <random>
#include <time.h>
#include <fstream>
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep3(i,a,b) for(ll i=a;i>=b;i--)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define vec vector<int>
#define vecll vector<ll>
#define vecpii vector<pii>
#define endl "\n"
#define all(c) begin(c),end(c)
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
void print(vec v){for(auto e:v)cout<<e<<" ";cout<<endl;}
void print(vecll v){for(auto e:v)cout<<e<<" ";cout<<endl;}
void print(map<int,int> mp){for(auto e:mp)cout<<e.first<<" "<<e.second<<endl;cout<<endl;}
#define INF 1e9+7
#define LLINF 1e18+7
#define N 250000
const ll MOD=998244353;
main(){
int n=in(),k=in();
vecll a;
rep(i,n){
a.pb(in());
}
ll ans=0;
vecll l,r;
l.pb(0);
rep(i,n){
l.pb(l.back()+max(0ll,a[i]));
}
r.pb(0);
rep3(i,n-1,0)r.pb(r.back()+max(0ll,a[i]));
reverse(all(r));
ll tmp=0;
rep(i,k)tmp+=a[i];
rep(i,n-k+1){
ans=max(ans,max(0ll,tmp)+l[i]+r[i+k]);
tmp-=a[i];
tmp+=a[i+k];
}
cout<<ans;
} | 0 | 2,779,707 |