code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 45
101M
|
|---|---|---|---|
#pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0; i < ll(n); i++)
#define REPD(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < ll(b); i++)
#define FORD(i, a, b) for (int i = a; i > ll(b); i--)
#define ALL(x) x.begin(), x.end()
#define SIZE(x) ll(x.size())
const long long INF = 1e12;
const int MOD = 1e9 + 7;
#define MAXR 100000
#define Umap unordered_map
#define Uset unordered_set
#define int long long
#define P pair<int, int>
#define MP make_pair
const unsigned int BIT_FLAG_0 = (1 << 0);
const unsigned int BIT_FLAG_1 = (1 << 1);
const unsigned int BIT_FLAG_2 = (1 << 2);
const unsigned int BIT_FLAG_3 = (1 << 3);
const unsigned int BIT_FLAG_4 = (1 << 4);
const unsigned int BIT_FLAG_5 = (1 << 5);
const unsigned int BIT_FLAG_6 = (1 << 6);
const unsigned int BIT_FLAG_7 = (1 << 7);
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};
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&... tail) {
cout << head;
if (sizeof...(tail) != 0)
cout << " ";
print(forward<Tail>(tail)...);
}
template <class T> void print(vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back())
cout << " ";
}
cout << endl;
}
template <class T> void print(vector<vector<T>> &df) {
for (auto &vec : df) {
print(vec);
}
}
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
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() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
int maxans = 0;
REP(i, n+1) {
if (s.substr(n - i, i) == t.substr(0, i)) {
chmax(maxans, i);
}
}
print(n * 2 - maxans);
}
|
#include <bits/stdc++.h>
#define PI 3.14159265359
#define INF 1e9
#define LINF 1e18
#define IMOD 1000000007
#define irep(i,n) for(int i = 0; i < (int)(n); i++)
#define irep2(i,a,n) for(int i = (int)(a); i <= (int)(n); i++)
#define lrep(i,n) for(long long i = 0; i < (long long)(n); i++)
#define lrep2(i,a,n) for(long long i = (long long)(a); i <= (long long)(n); i++)
#define irrep(i,n) for(int i = (int)(n); i > -1; i--)
#define irrep2(i,a,n) for(int i = (int)(n); i >= (int)(a); i--)
typedef long long ll;
typedef std::vector<char> v_char;
typedef std::vector<v_char > v2_char;
typedef std::vector<double> v_double;
typedef std::vector<v_double > v2_double;
typedef std::vector<int> v_int;
typedef std::vector<v_int > v2_int;
typedef std::vector<ll> v_ll;
typedef std::vector<v_ll > v2_ll;
typedef std::vector<std::string> v_string;
typedef std::vector<v_string > v2_string;
typedef std::vector<bool> v_bool;
typedef std::vector<v_bool > v2_bool;
typedef std::pair<ll, ll> pll;
typedef std::pair<int, int> pii;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
int main(void)
{
int a, b;
cin >> a >> b;
if(a % 3 == 0 || b % 3 == 0 || (a+b) % 3 == 0) {
cout << "Possible";
} else {
cout << "Impossible";
}
return 0;
}
| 0
| 89,564,589
|
#include<iostream>
#include<vector>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
using ll = long long;
using P = pair<int, int>;
#include<algorithm>
#include<math.h>
#include<map>
#include<queue>
#include<set>
#include<iomanip>
int main() {
int w, h,x,y;
cin >> w >> h>>x>>y;
double men = double(w) * double(h) / 2.0;
cout <<fixed<< setprecision(12)<<men<<" ";
int w2 = w / 2;
int h2 = h / 2;
if (2*x == w && h == 2*y) {
cout << 1;
}
else {
cout << 0;
}
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define ff first
#define ss second
#define setbits(x) __builtin_popcountll(x)
#define lp(a,n) for(ll i=a; i<n; i++)
#define lpi(a,n) for(int i=a; i<n; i++)
#define w(t) int t; cin>>t; while(t--)
#define vi vector<int>
#define vll vector<ll>
#define pll pair<ll, ll>
#define pii pair<int, int>
#define inf 1e9
#define LB lower_bound
#define UB upper_bound
const int mod = 1000000007;
using namespace std;
ll gcd(ll a,ll b){
if(a==0)return b;
return gcd(b%a,a);
}
ll lcm(ll a, ll b){
return (a*b)/gcd(a,b);
}
int prime[100007];
void SieveOfEratosthenes(int n)
{
memset(prime, -1, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
if (prime[p] == -1)
{
for (int i=p*p; i<=n; i += p)
prime[i] = p;
}
}
}
int lps(string s){
int len = 0;
int n = s.length();
int dp[n];
dp[0] = 0;
for(int i=1; i<n; i++){
if(s[i] == s[len]){
len++;
dp[i] = len;
continue;
}
if(len!=0){
len = dp[len-1];
i--;
continue;
}
dp[i]=0;
}
return dp[n-1];
}
ll power(unsigned ll x,unsigned ll y)
{
ll res = 1;
while (y > 0)
{
if (y & 1)
res = res*x;
y = y>>1;
x = x*x;
}
return res;
}
vector<pair<ll, ll>> pFactor;
void factorize(long long n)
{
int count = 0;
while (!(n % 2)) {
n >>= 1;
count++;
}
if (count)
pFactor.pb({2,count});
for (long long i = 3; i <= sqrt(n); i += 2) {
count = 0;
while (n % i == 0) {
count++;
n = n / i;
}
if (count)
pFactor.pb({i,count});
}
if (n > 2)
pFactor.pb({n,1});
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a,b;
cin>>a>>b;
ll w[b];
ll sum=0;
lp(0,b){
cin>>w[i];
sum+=w[i];
}
if(sum>a){
cout<<-1<<endl;
return 0;
}
cout<<a-sum<<endl;
}
| 0
| 92,095,332
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define INF 1000000001
int main() {
ll n,k;cin >> n >> k;
ll ans=k;
for(int i = 0; i < n-1; i++) {
ans *= k-1;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i,to) for(li i=0;i<((li)(to));i++)
#define repp(i,start,to) for(li i=(li)(start);i<((li)(to));i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v,n) memset(v,(li)n,sizeof(v))
#define bit(n) (1ll<<(li)(n))
#define mp(a,b) make_pair(a,b)
#define rin rep(i,n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if(DBGP)
#define F first
#define S second
#define p2(a,b) idp cout<<a<<"\t"<<b<<endl
#define p3(a,b,c) idp cout<<a<<"\t"<<b<<"\t"<<c<<endl
#define p4(a,b,c,d) idp cout<<a<<"\t"<<b<<"\t"<<c<<"\t"<<d<<endl
#define p5(a,b,c,d,e) idp cout<<a<<"\t"<<b<<"\t"<<c<<"\t"<<d<<"\t"<<e<<endl
#define p6(a,b,c,d,e,f) idp cout<<a<<"\t"<<b<<"\t"<<c<<"\t"<<d<<"\t"<<e<<"\t"<<f<<endl
#define p7(a,b,c,d,e,f,g) idp cout<<a<<"\t"<<b<<"\t"<<c<<"\t"<<d<<"\t"<<e<<"\t"<<f<<"\t"<<g<<endl
#define p8(a,b,c,d,e,f,g,h) idp cout<<a<<"\t"<<b<<"\t"<<c<<"\t"<<d<<"\t"<<e<<"\t"<<f<<"\t"<<g<<"\t"<<h<<endl
#define p9(a,b,c,d,e,f,g,h,i) idp cout<<a<<"\t"<<b<<"\t"<<c<<"\t"<<d<<"\t"<<e<<"\t"<<f<<"\t"<<g<<"\t"<<h<<"\t"<<i<<endl
#define p10(a,b,c,d,e,f,g,h,i,j) idp cout<<a<<"\t"<<b<<"\t"<<c<<"\t"<<d<<"\t"<<e<<"\t"<<f<<"\t"<<g<<"\t"<<h<<"\t"<<i<<"\t"<<j<<endl
#define foreach(it,v) for(__typeof((v).begin()) it=(v).begin(); it!=(v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x,n) idp{rep(i,n){cout<<x[i]<<" ";}puts("");}
#define dump2(x,n) idp{rep(i,n){cout<<"["<<x[i].F<<" , "<<x[i].S<<"] ";}puts("");}
#define dumpi(x) idp{foreach(it, x){cout<<(*it)<<" ";}puts("");}
#define dumpi2(x) idp{foreach(it, x){cout<<"["<<(it)->F<<" , "<<(it)->S<<"] ";}puts("");}
#define read2d(a,w,h) rep(i,h)rep(j,w)cin>>a[i][j]
#define dump2d(a,w,h) rep(i,h){rep(j,w)cout<<a[i][j]<<" ";puts("");}
typedef pair<li, li> PI;
li n, k;
li a[100100];
inline bool solve() {
li ggcd = a[0];
li ma = a[0];
repp(i, 1, n) {
ggcd = __gcd(ggcd, a[i]);
ma = max(ma, a[i]);
}
if (k > ma) {
return false;
}
if (ggcd == 1) {
return true;
}
if (k % ggcd > 0) {
return false;
}
rin{
a[i] /= ggcd;
}
k /= ggcd;
return solve();
}
int main() {
cin >> n >> k;
rin{
cin >> a[i];
}
cout << (solve() ? "POSSIBLE" : "IMPOSSIBLE") << endl;
return 0;
}
| 0
| 62,993,655
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
using namespace std;
#define ABS(a) (((a) >= 0) ? (a) : -(a))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RFOR(i, a, b) for (int i = a; i > b; --i)
#define REP(i, n) for (int i = 0; i < n; ++i)
#define int long long
typedef long long ll;
typedef pair<int, int> Pair;
const int kMaxH = 1000;
const int kMaxW = 1000;
const int kInf = 1000000000;
int H, W, N;
string maze[kMaxH];
int ans = 0;
int d[kMaxH][kMaxW];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, -1, 0, 1};
int Bfs(char s, char g) {
int sx, sy, gx, gy;
REP(i, H) {
REP(j, W) {
if (maze[i][j] == s) { sx = i; sy = j; }
if (maze[i][j] == g) { gx = i; gy = j; }
}
}
queue<Pair> que;
REP(i, H) { REP(j, W) { d[i][j] = kInf; } }
que.push(Pair(sx, sy));
d[sx][sy] = 0;
while (que.size()) {
Pair p = que.front(); que.pop();
int x = p.first; int y = p.second;
if (x == gx && y == gy) { break; }
REP(i, 4) {
int nx = x+dx[i]; int ny = y+dy[i];
if (0 <= nx && nx < H && 0 <= ny && ny < W) {
if (maze[nx][ny] != 'X' && d[nx][ny] == kInf) {
que.push(Pair(nx, ny));
d[nx][ny] = d[x][y]+1;
}
}
}
}
return d[gx][gy];
}
signed main() {
cin >> H >> W >> N;
REP(i, H) { cin >> maze[i]; }
ans += Bfs('S', '1');
REP(i, N-1) { ans += Bfs('1'+i, '2'+i); }
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
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;
}
void debug() { cerr << "\n"; }
template <class T> void debug(const T &x) { cerr << x << "\n"; }
template <class T, class... Args> void debug(const T &x, const Args &... args) {
cerr << x << " ";
debug(args...);
}
template <class T> void debugVector(const vector<T> &v) {
for(const T &x : v) {
cerr << x << " ";
}
cerr << "\n";
}
using ll = long long;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
constexpr int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
ll ans = 0;
for(int i = 0; i < N; i++) {
ans += (ll)(i + 1) * (N - i);
}
for(int i = 0; i < N - 1; i++) {
ll u, v;
cin >> u >> v;
if(u > v) {
swap(u, v);
}
ans -= u * (N - v + 1);
}
cout << ans << endl;
}
| 0
| 53,643,366
|
#include <bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<(b);i++)
#define erep(i,a,b) for(int i=a;i<=(int)(b);i++)
#define per(i,a,b) for(int i=(b)-1;i>(a);i--)
#define eper(i,a,b) for(int i=((int)(a));i>=b;i--)
#define pb push_back
#define mp make_pair
#define INF (1<<30)-1
#define MOD 1000000007
using namespace std;
typedef long long ll;
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int n, dp[1000];
int main() {
ios::sync_with_stdio ( false );
cin.tie ( 0 );
cin >> n;
dp[0] = dp[1] = 1;
erep(i, 2, n) { dp[i] = dp[i - 1] + dp[i - 2]; }
cout << dp[n] << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long int
#define MAXK 200000
int main() {
int N, K, cnt[MAXK + 3];
cin >> N >> K;
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= N; i++)
cnt[i%K] += 1;
LL answer = 0;
for (int i = 0; i < K; i++) {
if ((2 * i)%K == 0) {
LL temp = (LL) cnt[i] * cnt[i] * cnt[i];
answer += temp;
}
}
cout << answer << endl;
}
| 0
| 54,481,578
|
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
int main()
{
int a, b;
cin >> a >> b;
if (a <= b)
cout << "unsafe" << endl;
else
cout << "safe" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
long long sum = accumulate(A.begin(), A.end(), 0LL);
long long m = N * (N + 1) / 2;
if (sum % m != 0) {
cout << "NO" << endl;
return 0;
}
long long num = sum / m;
for (int i = 0; i < N; i++) {
long long gap = 0;
if (i != N - 1) {
gap = A[i + 1] - A[i] - num;
} else {
gap = A[0] - A[N - 1] - num;
}
if (gap % N != 0 || gap > 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 0
| 96,305,655
|
#include <iostream>
using namespace std;
int n, a, b, c, x;
int next_rand() {
x = (a * x + b) % c;
return x;
}
int main() {
while (cin >> n >> a >> b >> c >> x) {
if ((n || a || b || c || x) == 0) break;
int slot[n];
for (int i = 0; i < n; i++) cin >> slot[i];
int frame = 0;
int next = x;
for (int i = 0; i < n; i++) {
while (frame <= 10000) {
if (next == slot[i]) {
next = next_rand();
if (i == n-1) break;
else {
frame++;
break;
}
}
next = next_rand();
frame++;
}
}
if (frame > 10000) cout << -1 << endl;
else cout << frame << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint MOD = 1e9+7;
signed main(){
lint n; cin >> n ;
vector<lint> a(n), b(n);
for(int i = 0; i < n; i++) cin >> a[i];
for(int i = 0; i < n; i++) cin >> b[i];
vector<pair<bool, int> > data1(n), data2(n);
data1[0] = make_pair(true, a[0]);
data2[n - 1] = make_pair(true, b[n - 1]);
for(int i = 1; i < n; i++){
if(a[i] == a[i - 1]) data1[i] = make_pair(false, a[i]);
else data1[i] = make_pair(true, a[i]);
}
for(int i = n -2; i >= 0; i--){
if(b[i] == b[i + 1]) data2[i] = make_pair(false, b[i]);
else data2[i] = make_pair(true, b[i]);
}
bool ok = true;
lint ans = 1;
if(a[n - 1] != b[0]) ok = false;
for(int i = 0; i < n; i++){
bool a = data1[i].first, b = data2[i].first;
lint c = data1[i].second, d = data2[i].second;
if(a && b) if(c != d) ok = false;
if(a && !b) if(c > d) ok = false;
if(!a && b) if(c < d) ok = false;
if(!a && !b) ans *= min(c, d), ans %= MOD;
}
if(ok) cout << ans << endl;
else cout << 0 << endl;
}
| 0
| 75,912,789
|
#include <bits/stdc++.h>
using namespace std;
using Pair = pair<int64_t, int64_t>;
constexpr int64_t kInf = INT64_MAX / 2L;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int64_t H, W, A_row, B_col;
cin >> H >> W >> A_row >> B_col;
vector<vector<int64_t>> result(H, vector<int64_t>(W, 0));
for (int64_t r = B_col; r < H; ++r) {
for (int64_t c = 0; c < A_row; ++c) {
result[r][c] = 1;
}
}
for (int64_t r = 0; r < B_col; ++r) {
for (int64_t c = A_row; c < W; ++c) {
result[r][c] = 1;
}
}
for (int64_t r = 0; r < H; ++r) {
int64_t zero = 0;
int64_t one = 0;
for (int64_t c = 0; c < W; ++c) {
if (result[r][c] == 0) {
++zero;
} else {
++one;
}
}
if (min(zero, one) != A_row) {
cout << "No" << endl;
}
}
for (int64_t c = 0; c < W; ++c) {
int64_t zero = 0;
int64_t one = 0;
for (int64_t r = 0; r < H; ++r) {
if (result[r][c] == 0) {
++zero;
} else {
++one;
}
}
if (min(zero, one) != B_col) {
cout << "No" << endl;
}
}
for (int64_t r = 0; r < H; ++r) {
for (int64_t c = 0; c < W; ++c) {
cout << result[r][c];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL<<60;
int main()
{
int H,W; cin>>H>>W;
string board[H];
rep(i,H) cin>>board[i];
string ans = "Yes";
rep(i, H) {
rep(j, W) {
if (board[i][j] == '#') {
bool can = false;
for (int dy = -1; dy < 2; dy++) {
int ny = i + dy;
if (ny >= 0 && ny < H) {
if (i != ny && board[ny][j] == '#') can = true;
}
}
for (int dx = -1; dx < 2; dx++) {
int nx = j + dx;
if (nx >= 0 && nx < W) {
if (j != nx && board[i][nx] == '#') can = true;
}
}
if (can == false) {
ans = "No";
}
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 20,811,853
|
#include <bits/stdc++.h>
#define rep(i, n) \
for (int64_t i = 0; i < (int64_t)(n); i++) \
;
using namespace std;
using vi = vector<int64_t>;
using vvi = vector<vi>;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int64_t n, i;
cin >> n >> i;
cout << n - i + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define rep2(i,x,n) for(int i=x; i<(n); i++)
#define all(n) begin(n),end(n)
struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;
const long long INF = numeric_limits<long long>::max();
int main(){
long long N,K;
cin>>N>>K;
long long ans=0;
ans=(N/K)*(N/K)*(N/K);
long long p=0;
if(2*N<K){
cout << 0<< endl;
return 0;
}
if(K%2==0){
p=(2*N-K)/(2*K);
p++;
}
ans=ans+(p*p*p);
cout << ans << endl;
return 0;
}
| 0
| 72,862,010
|
#include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i <(n); ++i)
#define REP2(i,x,n) for (int i = x; i <(n); ++i)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int,int>;
static const double PI = acos(-1);
static const int INF = 1e9+7;
#ifdef _DEBUG
#define debug(var) do{cout << #var << " :";view(var);}while(0)
#else
#define debug(...)
#endif
template<typename T> void view(T e){cout << e << endl;}
template<typename T> void view(const vector<T>& v){for(const auto& e : v){ cout << e << " "; } cout << endl;}
template<typename T> void view(const vector<vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
int main(){
vector<int> a(3);
REP(i,3) cin >> a[i];
sort(ALL(a));
int cnt = 0;
while(1){
if(a[1] == a[2]) break;
else {
a[0]++;
a[1]++;
}
cnt++;
}
while(1){
if(a[0] == a[1]) break;
if(a[0] == a[1]+ 1){
cnt++;
break;
}
a[0] += 2;
cnt++;
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int k,score;
cin >> n >> k;
double ans=0;
for(int i=1;i<=n;i++){
score = i;
double temp=(double)1/(double)n;
while(true){
if(score>=k){
ans += temp;
break;
}else{
temp *= 0.5;
score *= 2;
}
}
}
printf("%.12f\n", ans);
}
| 0
| 28,105,863
|
#include <algorithm>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <time.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <numeric>
#include <limits>
#include <type_traits>
#include <locale>
using namespace std;
#define SAY_YES cout << "YES" << endl;
#define SAY_Yes cout << "Yes" << endl;
#define SAY_NO cout << "NO" << endl;
#define SAY_No cout << "No" << endl;
#define IFYES(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "YES" << endl; \
} \
else \
{ \
cout << "NO" << endl; \
}
#define IFYes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "Yes" << endl; \
} \
else \
{ \
cout << "No" << endl; \
}
#define IFyes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "yes" << endl; \
} \
else \
{ \
cout << "no" << endl; \
}
#define DEBUG_OUTPUT_ARRAY(XXX, ONE) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "DEBUG: i = " << i << " -> " << XXX[i] << endl; \
}
#define DEBUG_OUTPUT_ARRAY2(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "<<< i = " << i << " >>>" << endl; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << "DEBUG: j = " << j << " -> " << XXX[i][j] << endl; \
} \
}
#define DEBUG_OUTPUT_ARRAY2_BOX(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << i << " "; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << XXX[i][j] << " "; \
} \
cout << endl; \
}
typedef pair<long long int, long long int> pll;
typedef pair<long long int, pll> lpll;
const long long int mod = 1000000007;
const long long int INF = 1e18;
const long double PI=3.14159265358979323;
long long int K,M,x,y,res=0,tmp=0,dp[200][5][2]={};
pll ba[200200];
string N;
int main(){
cout << fixed << setprecision(18);
cin>>N>>K;
dp[0][1][0]=1;
dp[0][1][1]=N[0]-'1';
for(long long int i = 1; i < N.size(); i++){
dp[i][1][1]+=9;
if(N[i]=='0'){
dp[i][1][0]+=dp[i-1][1][0];
dp[i][1][1]+=dp[i-1][1][1];
dp[i][2][0]+=dp[i-1][2][0];
dp[i][2][1]+=dp[i-1][2][1];
dp[i][3][0]+=dp[i-1][3][0];
dp[i][3][1]+=dp[i-1][3][1];
dp[i][2][1]+=9*dp[i-1][1][1];
dp[i][3][1]+=9*dp[i-1][2][1];
}else{
dp[i][1][1]+=dp[i-1][1][0];
dp[i][1][1]+=dp[i-1][1][1];
dp[i][2][1]+=dp[i-1][2][0];
dp[i][2][1]+=dp[i-1][2][1];
dp[i][3][1]+=dp[i-1][3][0];
dp[i][3][1]+=dp[i-1][3][1];
dp[i][2][0]+=dp[i-1][1][0];
dp[i][3][0]+=dp[i-1][2][0];
dp[i][2][1]+=(N[i]-'1')*dp[i-1][1][0];
dp[i][3][1]+=(N[i]-'1')*dp[i-1][2][0];
dp[i][2][1]+=9*dp[i-1][1][1];
dp[i][3][1]+=9*dp[i-1][2][1];
}
}
cout<<dp[N.size()-1][K][1]+dp[N.size()-1][K][0]<<endl;
}
|
#include<stdio.h>
int main()
{
int numA, numB;
scanf("%d", &numA);
scanf("%d", &numB);
printf("%d\n", 6-numA-numB);
return 0;
}
| 0
| 41,649,417
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
ll const INF = 1LL << 60;
int main() {
ll N;
cin >> N;
vector<ll> A(N), B(N);
priority_queue<ll> q;
ll res = 0, sum_A = 0, sum_B = 0, x;
for (int i = 0; i < N; i++) {
cin >> A[i];
sum_A += A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
sum_B += B[i];
}
if (sum_A < sum_B) {
cout << -1 << endl;
return 0;
}
ll ans = 0;
for (int i = 0; i < N; i++) {
x = B[i] - A[i];
res += max(0LL, x);
if (x < 0) q.push(A[i] - B[i]);
if (x > 0) ans++;
}
if (res == 0) {
cout << 0 << endl;
return 0;
}
while (!q.empty() && res > 0) {
x = q.top();
q.pop();
res -= x;
ans++;
}
if (res > 0) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5+9;
int A[maxn];
int main()
{
int n,k;
cin>>n>>k;
for(int i=1;i<=n;i++) scanf("%d",&A[i]);
while(k--)
{
int B[maxn];
memset(B,0,sizeof(B));
for(int i=1;i<=n;i++)
{
int l = max(1,i-A[i]);
int r = min(n,i+A[i]);
B[l]++;
B[r+1]--;
}
for(int i=1;i<=n;i++)
{
A[i] = A[i-1] + B[i];
}
if(A[n]==n) break;
}
for(int i=1;i<=n;i++)
{
printf("%d ",A[i]);
}
return 0;
}
| 0
| 30,201,141
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int INF=1e9;
const int MOD=1e9+7;
int main(){
int N,K; cin >> N >> K;
ll a[N];
for(int i=0;i<N;i++){
cin >> a[i];
}
ll sum[N+1]={};
vector<ll> su;
for(int i=0;i<N;i++){
sum[i+1]=sum[i]+a[i];
}
for(int i=1;i<=N;i++){
for(int j=i;j<=N;j++){
su.push_back(sum[j]-sum[i-1]);
}
}
for(int i=45;i>=0;i--){
vector<ll> tmp;
for(int j=0;j<su.size();j++){
if(su[j]&(1LL<<i)) tmp.push_back(su[j]);
}
if(tmp.size()>=K){
su=tmp;
}
}
ll ans=su[0];
for(int i=1;i<K;i++){
ans=ans&su[i];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
int v;
cin >> v;
a[i] = (v-1+k)%k;
}
map<int, int> cnt;
cnt[0] = 1;
int s = 0;
long long ans = 0;
vector<int> pref = {0};
for (int i = 0; i < n; i++) {
int v = a[i];
s = (s+v)%k;
pref.push_back(s);
int j = i + 1 - k;
if (j >= 0) {
cnt[pref[j]]--;
}
ans += cnt[s];
cnt[s]++;
}
cout << ans << endl;
}
| 0
| 82,585,457
|
#include <stdio.h>
#include <string.h>
int main(){
char a[11], b[11], c[11];
scanf("%s %s %s", a,b,c);
int d=strlen(a)-1,e=strlen(b)-1;
if(a[d]==b[0] && b[e]==c[0]){
puts("YES");
}else{
puts("NO");
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <cmath>
#include <string>
using namespace std;
using Int = long long;
int main()
{
int a, b;
cin >> a >> b;
a--, b--;
vector<string> vs;
if (a == 0) {
string s;
for (int i = 0; i < 100; i++) s += "#";
vs.push_back(s);
}
while (a) {
string s;
for (int i = 0; i < 50; i++) {
if (a > 0) {
s += ".#";
a--;
} else {
s += "##";
}
}
vs.push_back(s);
s = "";
for (int i = 0; i < 100; i++) s += "#";
vs.push_back(s);
}
if (b == 0) {
string s;
for (int i = 0; i < 100; i++) s += ".";
vs.push_back(s);
}
while (b) {
string s;
for (int i = 0; i < 100; i++) s += ".";
vs.push_back(s);
s = "";
for (int i = 0; i < 50; i++) {
if (b > 0) {
s += "#.";
b--;
} else {
s += "..";
}
}
vs.push_back(s);
}
cout << vs.size() << " " << 100 << endl;
for (auto& line : vs) cout << line << endl;
return 0;
}
| 0
| 21,124,156
|
#include<bits/stdc++.h>
#define endl "\n"
using namespace std;
#define debug(x) cout<<"The value of "<<#x<<" is "<<x<<endl;
typedef long long ll;
typedef unsigned long long ull;
bool is_palin(string s){
string a=s;
reverse(a.begin(),a.end());
return a==s;
}
int main()
{
cin.sync_with_stdio(0); cin.tie(0);
string s;
cin>>s;
if(!is_palin(s)){
cout<<"No"<<endl;
return 0;
}
int n=s.size();
string a=s.substr(0,(s.size()-1)/2);
string b=s.substr(((n+3)/2)-1,s.size());
if(is_palin(a)&&is_palin(b)){
cout<<"Yes"<<endl;
return 0;
}
cout<<"No"<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=998244353,MAX=100005,INF=1<<28;
int main(){
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
while(1){
int N;cin>>N;
if(N==0) break;
vector<int> A(N);
for(int i=0;i<N;i++) cin>>A[i];
sort(all(A));
int ans=INF;
for(int i=1;i<N;i++) ans=min(ans,A[i]-A[i-1]);
cout<<ans<<endl;
}
}
| 0
| 18,403,834
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,n,counter=0;
cin>>N;
vector<int>vec(N);
for(int i=0;i<N;i++){
cin>>vec.at(i);
}
for(int i=0;i<N;i++){
if(i==0){
if(vec.at(i)==2)
break;
n=vec.at(i);
counter++;
}
else if(i<N-1){
if(vec.at(n-1)==2){
break;
}
else{
n=vec.at(n-1);
counter++;
}
}
else if(i==N-1)
counter = -2;
}
cout<<counter+1<<endl;
}
|
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
vector<int> a(n);
vector<int> b(n);
vector<int> c(m);
vector<int> d(m);
rep(i,n) cin >> a[i] >> b[i];
rep(i,m) cin >> c[i] >> d[i];
rep(i,n){
int num = 0;
int ps = 1000000000;
rep(j,m){
int s = abs(a[i]-c[j])+abs(b[i]-d[j]);
if(s < ps){
num = j+1;
ps = s;
}
}
cout << num << endl;
ps = 1000000000;
}
}
| 0
| 36,014,029
|
#include <bits/stdc++.h>
#define rep(l, r) for (int i = (l); i < (r); i++)
typedef long long ll;
using namespace std;
void solve() {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
int x_diff = x2 - x1;
int y_diff = y2 - y1;
int x3 = x2 - y_diff;
int y3 = y2 + x_diff;
int x4 = x1 - y_diff;
int y4 = y1 + x_diff;
printf("%d %d %d %d\n", x3, y3, x4, y4);
}
int main() {
solve();
return 0;
}
|
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
int tx[] = {0,1,0,-1};
int ty[] = {-1,0,1,0};
static const double EPS = 1e-8;
class Point{
public:
double x;
double y;
Point(double _x, double _y) : x(_x), y(_y) {}
};
bool isInterSect(const Point& p1,const Point& p2,const Point& p3,const Point& p4){
if (((p1.x - p2.x) * (p3.y - p1.y) + (p1.y - p2.y) * (p1.x - p3.x)) *
((p1.x - p2.x) * (p4.y - p1.y) + (p1.y - p2.y) * (p1.x - p4.x)) < 0){
if (((p3.x - p4.x) * (p1.y - p3.y) + (p3.y - p4.y) * (p3.x - p1.x)) *
((p3.x - p4.x) * (p2.y - p3.y) + (p3.y - p4.y) * (p3.x - p2.x)) < 0){
return true;
}
}
return false;
}
double getArea(const Point& p1, const Point& p2,const Point& p3){
double a = hypot(p1.x-p2.x,p1.y-p2.y);
double b = hypot(p2.x-p3.x,p2.y-p3.y);
double c = hypot(p3.x-p1.x,p3.y-p1.y);
double s = (a+b+c)/2.0;
return sqrt(s*(s-a)*(s-b)*(s-c));
}
int main(){
double x1,y1,x2,y2,x3,y3;
double xp,yp;
while(~scanf("%lf %lf %lf %lf %lf %lf %lf %lf",&x1,&y1,&x2,&y2,&x3,&y3,&xp,&yp)){
double S1 = getArea(Point(x1,y1),Point(x2,y2),Point(x3,y3));
double S2 = getArea(Point(xp,yp),Point(x2,y2),Point(x3,y3));
double S3 = getArea(Point(x1,y1),Point(xp,yp),Point(x3,y3));
double S4 = getArea(Point(x1,y1),Point(x2,y2),Point(xp,yp));
if(S1 - EPS <= S2+S3+S4 && S2+S3+S4 <= S1 + EPS){
printf("YES\n");
}
else{
printf("NO\n");
}
}
}
| 0
| 30,220,300
|
#include <stdio.h>
int main(void)
{
int i, j;
for (i = 1; i < 10001; i++){
scanf("%d",&j);
if (j == 0)
break;
printf("Case %d: %d\n", i, j);
}
return 0;
}
|
#include <iostream>
#include <string>
#include <list>
using namespace std;
int main()
{
list<int> ltiNumber;
list<int>::iterator itlti;
list<int>::iterator itltEND = ltiNumber.end();
string sCommand;
int iMaxCommand, iNumber;
cin.tie(0);
ios::sync_with_stdio(false);
cin >> iMaxCommand;
for (int i = 0; i < iMaxCommand; i++)
{
cin >> sCommand;
if (sCommand == "insert")
{
cin >> iNumber;
ltiNumber.push_front(iNumber);
}
else if (sCommand == "deleteFirst")
ltiNumber.pop_front();
else if (sCommand == "deleteLast")
ltiNumber.pop_back();
else if (sCommand == "delete")
{
cin >> iNumber;
for (itlti = ltiNumber.begin(); itlti != itltEND; ++itlti)
if (*itlti == iNumber)
{
ltiNumber.erase(itlti);
break;
}
}
}
int i = 0;
for (itlti = ltiNumber.begin(); itlti != itltEND; ++itlti)
{
if (i++) cout << " ";
cout << *itlti;
}
cout << endl;
return 0;
}
| 0
| 27,253,450
|
#include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
int main(){
int n,k;
cin >> n >> k;
vector<int> v(n);
rep(i,n){
cin >> v.at(i);
}
vector<int> fr(n+1),fl(n+1);
fl.at(0) = 0;
fr.at(0) = 0;
rep(i,n){
fl.at(i+1) = fl.at(i) + v.at(i);
fr.at(i+1) = fr.at(i) + v.at(n-1-i);
}
vector<pair<int,int>> vp;
rep(i,n){
if(v.at(i) < 0) vp.push_back({v.at(i), i});
}
sort(vp.begin(), vp.end());
int res = 0;
for(int i=0;i<=n;i++){
for(int j=0;j<=n && i+j<=k && i+j<=n;j++){
int kmx = k-i-j;
int kcr=0;
int tot=0;
tot += fl.at(i);
tot += fr.at(j);
for(auto p:vp){
if(kcr>=kmx) break;
if(p.second < i || p.second > n-1-j){
kcr++;
tot -= p.first;
}
}
res = max(res,tot);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
int main() {
in(ll, n, m);
vector<ll> a(n);
rep(i, n) cin >> a[i];
vector<ll> s(n + 1);
rep(i, n) s[i + 1] = s[i] + a[i];
ll ans = 0;
map<ll, ll> seen;
rep(i, n + 1) {
ans += seen[s[i] % m];
++seen[s[i] % m];
}
out(ans);
}
| 0
| 44,276,093
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
ld w,h,x,y;
cin>>w>>h>>x>>y;
cout<<fixed<<setprecision(9)<<w*h/2;
if(x==w/2&&y==h/2) cout<<" "<<1;
else cout<<" "<<0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long bigmod(long long a, long long p){
if(p == 0){
return 1;
}
long long ans = bigmod(a, p/2);
ans = (ans * ans) % mod;
if(p % 2 == 1){
ans = (ans * a) % mod;
}
return ans;
}
int main(){
long long n, k;
cin >> n >> k;
vector<long long>gcd(k + 3);
long long ans = 0;
for(long long i = k; i >= 1; i--){
gcd[i] = bigmod(k / i, n);
for(int j = 2 * i; j <= k; j = j + i){
gcd[i] = (gcd[i] - gcd[j] + mod) % mod;
}
ans = (ans + i * gcd[i]) % mod;
}
cout << ans;
return 0;
}
| 0
| 81,402,803
|
#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;
cin >> n;
ll a, b;
cin >> a >> b;
cout << n/(a+b)*a + min(n%(a+b), a) << endl;
return 0;
}
|
#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>>;
#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
#define 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; }
signed main(){
ll n; cin>>n;
if(n%2==1){
cout<<0<<endl;
return 0;
}
ll cnt=10;
ll ans=0;
while(cnt<=n){
ans+=n/cnt;
cnt*=5;
}
cout<<ans<<endl;
return 0;
}
| 0
| 9,642,884
|
#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 maxs(a, b) a = max(a, b)
#define mins(a, b) a = min(a, b)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll linf = 1001002003004005006ll;
const int inf = 1001001001;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c;
cin >> a >> b >> c;
if (c >= a && c <= b) puts("Yes");
else puts("No");
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < (n); i++)
#define REP1(i, n) for(int i = 1; i <= (n); i++)
#define REPD(i,a,b) for (int i=(a);i<=(b);i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef set<int> si;
typedef vector<si> vsi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<int, int> pi;
typedef queue<int> qi;
typedef queue<pi> qpi;
typedef pair<ll, ll> pll;
typedef queue<pll> qpll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
const int mod = 1000000007;
const int INF = 1001001001;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
struct edge {
int from;
int to;
int cost;
};
typedef struct edge se;
typedef vector<edge> ve;
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;
}
int digit_sum(int n) {
int sum=n%10;
while(n!=0) {
n/=10;
sum+=n%10;
}
return sum;
}
vpll PrimeFactorization(ll n) {
vpll res;
for (ll i=2; i*i<=n; i++) {
if(n%i!=0) continue;
ll ex=0;
while(n%i==0) {
ex++;
n/=i;
}
res.push_back(pll(i,ex));
}
if(n!=1) res.push_back(pll(n,1));
return res;
}
int main() {
int n,k;
cin >> n >> k;
int num=1;
REP(i,n) {
if(num<k) num*=2;
else num+=k;
}
cout << num << endl;
return 0;
}
| 0
| 29,196,372
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long int n;
cin >> n;
vector<int> a(n);
for(int i = 0; i < n; i++){
cin >> a.at(i);
}
long long int step = 0;
for(int i = 1; i < n; i++){
if(a.at(i - 1) > a.at(i)){
step += a.at(i - 1) - a.at(i);
a.at(i) = a.at(i - 1);
}
}
cout << step << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int,int> root (int x, vector<int> &g, int t) {
if (x == g.at(x)) {
return pair<int,int>(x,t);
}
else {
pair<int,int> k = root(g.at(x),g,t+1);
g.at(x) = k.first;
return k;
}
}
void connect(int a, int b, vector<int> &g) {
pair<int,int> m = root(a,g,0);
pair<int,int> n = root(b,g,0);
if (m.first != n.first) {
if (m.second > n.second) {
g.at(n.first) = m.first;
}
else {
g.at(m.first) = n.first;
}
}
return;
}
int main() {
int N, M;
cin >> N >> M;
vector<int> G(N);
for (int i = 0; i < N; i++) {
G.at(i) = i;
}
int A, B;
for (int i = 0; i < M; i++) {
cin >> A >> B;
connect(A-1,B-1,G);
}
vector<int> G2(N,0);
for (int i = 0; i < N; i++) {
G2.at(root(i,G,0).first)++;
}
int X = 0;
for (int i = 0; i < N; i++) {
X = max(X,G2.at(i));
}
cout << X << endl;
return 0;
}
| 0
| 72,214,077
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
void solve() {
int n;
cin >> n;
int arr[n];
for(int i = 0; i < n; i++) {
cin >> arr[i];
}
ll sum = 0;
for(int i = 0; i < n; i++) {
for(int j = i + 1; j < n; j++) {
sum += arr[i] * arr[j];
}
}
cout << sum << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
int main() {
int n, m; cin >> n >> m;
vector<ll>x(n), y(m); for (auto&& xx : x)cin >> xx;for (auto&& yy : y)cin >> yy;
sort(x.begin(), x.end());sort(y.begin(), y.end());
ll a = 0, b = 0;
for (int i = 0; i < n; i++)a -= x[i] * (n - 1 - i - i);
for (int i = 0; i < m; i++)b -= y[i] * (m - 1 - i - i);
cout << (a % mod) * (b % mod) % mod << endl;
return 0;
}
| 0
| 96,766,611
|
#include <bits/stdc++.h>
using namespace std;
struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define vv(type, c, m, n, i) vector<vector<type>> c(m, vector<type>(n, i));
#define rep(i,a,n) for(int i=(a), i##_len=(n); i<i##_len; ++i)
#define rrep(i,a,n) for(int i=(a); i>n; --i)
#define len(x) ((int)(x).size())
#define mp make_pair
#define eb emplace_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long long> vll;
typedef vector<string> vs;
typedef vector<bool> vb;
int main() {
string s; cin >> s;
int n; cin >> n;
int a, b;
string t, ss;
rep(i, 0, n) {
cin >> t >> a >> b;
if(t == "replace"){
cin >> ss;
s.replace(a, b - a + 1, ss);
} else if (t == "reverse") {
reverse(s.begin() + a, s.begin() + b + 1);
} else {
P(s.substr(a, b - a + 1));
}
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <string.h>
#include <string>
#include <vector>
#include <limits.h>
#include <stack>
#include <queue>
#include<cstdlib>
#define maxn 10000000
#define pi acos(-1)
using namespace std;
struct node{
unsigned int key;
struct node *next;
struct node *prev;
};
typedef struct node * NodePointer;
NodePointer nil;
NodePointer listSearch(int key){
node *cur = nil->next;
while (cur!=nil&&cur->key!=key) {
cur=cur->next;
}
return cur;
}
void init(){
nil =(node*) malloc(sizeof(struct node));
nil->next = nil;
nil->prev = nil;
}
void printList(){
NodePointer cur = nil->next;
int isf = 0;
while(1){
if ( cur == nil ) break;
if ( isf++ > 0) printf(" ");
printf("%d", cur->key);
cur = cur->next;
}
printf("\n");
}
void deleteNode(NodePointer t){
if(t==nil)return;
t->prev->next=t->next;
t->next->prev=t->prev;
free(t);
}
void deleteFirst(){
deleteNode(nil->next);
}
void deleteLast(){
deleteNode(nil->prev);
}
void deleteKey(int key){
deleteNode(listSearch(key));
}
void insert(int key){
NodePointer x;
x = (node*)malloc(sizeof(struct node));
x->key = key;
x->next=nil->next;
nil->next->prev=x;
nil->next=x;
x->prev=nil;
}
int main(){
int key, n, i;
int size = 0;
char com[20];
int np = 0, nd = 0;
scanf("%d", &n);
init();
for ( i = 0; i < n; i++ ){
scanf("%s%d", com, &key);
if ( com[0] == 'i' ) {insert(key); np++; size++;}
else if ( com[0] == 'd' ) {
if (strlen(com) > 6){
if ( com[6] == 'F' ) deleteFirst();
else if ( com[6] == 'L' ) deleteLast();
} else {
deleteKey(key); nd++;
}
size--;
}
}
printList();
return 0;
}
| 0
| 12,035,017
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
using ll = long long;
using ld = long double;
ll INF = LLONG_MAX;
using vi = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;
namespace output {
void pr(int x) { cout << x; }
void pr(long x) { cout << x; }
void pr(ll x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(unsigned long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(float x) { cout << x; }
void pr(double x) { cout << x; }
void pr(ld x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char* x) { cout << x; }
void pr(const string& x) { cout << x; }
void pr(bool x) { pr(x ? "true" : "false"); }
template<class T> void pr(const complex<T>& x) { cout << x; }
template<class T1, class T2> void pr(const pair<T1,T2>& x);
template<class T> void pr(const T& x);
template<class T, class... Ts> void pr(const T& t, const Ts&... ts) {
pr(t); pr(ts...);
}
template<class T1, class T2> void pr(const pair<T1,T2>& x) {
pr("{",x.f,", ",x.s,"}");
}
template<class T> void pr(const T& x) {
pr("{");
bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0;
pr("}");
}
void print() { pr("\n"); }
template<class T, class... Ts> void print(const T& t, const Ts&... ts) {
pr(t); if (sizeof...(ts)) pr(" "); print(ts...);
}
}
using namespace output;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int N; cin >> N;
vi arr (N);
F0R(i, N) cin >> arr[i];
vi AS (N);
vi BS (N);
F0R(i, N) {
AS[i] = 1 + i * N;
BS[N-i-1] = 1 + i * N;
}
F0R(i, N) AS[arr[i]-1] += i;
for (int x : AS) cout << x << " "; cout << endl;
for (int x : BS) cout << x << " "; cout << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long
#define ld long double
#define pb push_back
#define mp3 make_pair
#define rep1(i,a,b) for(ll i=a;i<=b;i++)
#define rep2(i,a,b) for(ll i=a;i<b;i++)
const ll mod=1e9+7;
const ll INF=1e18;
template<typename T> T pow(T a,T b, long long m){T ans=1; while(b>0){ if(b%2==1) ans=(ans*a)%m; b/=2; a=(a*a)%m; } return ans%m; }
template<typename T> T add(T a,T b,ll m){a+=b;while(a>=0)a-=m;while(a<0)a+=m; return a;}
template<typename T> T mul(T a,T b,ll m){return (a*1ll*b)%m;}
ll sum;
ll dp[1000000];
ll rec(ll x){
if(x==0)
return 1;
if(x<0)
return 0;
if(dp[x]!=-1)
return dp[x];
ll ans=0;
for(ll i=3;i<=x;i++){
ans=add(ans,rec(x-i)%mod,mod);
}
return dp[x]=ans;
}
int main(){
IOS;
cin>>sum;
memset(dp,-1,sizeof(dp));
cout<<rec(sum);
}
| 0
| 71,602,376
|
#include <iostream>
#include <map>
using namespace std;
#define MAX 100005
#define NIL -1
struct Node {
int parent, left, right; };
struct Node T[MAX];
int d[MAX];
Node gNode[MAX];
int gDepth[MAX];
int getDepth(int u) {
int d = 0;
while (T[u].parent != -1) {
u = T[u].parent;
d++;
}
return d;
}
void print(int node){
cout << "node " << node << ": ";
cout << "parent = " << gNode[node].parent << ", ";
cout << "depth = " << gDepth[node] << ", ";
if(gNode[node].parent == NIL) cout << "root, ";
else if(gNode[node].left == NIL)cout << "leaf, ";
else cout << "internal node, ";
cout << "[";
for(int i = 0,left = gNode[node].left;left != NIL;++i,left = gNode[left].right){
if(i) cout << ", ";
cout << left;
}
cout << "]" << endl;
}
void rec(int node ,int parent){
gDepth[node] = parent;
if(gNode[node].right != NIL){
rec(gNode[node].right,parent);
}
if(gNode[node].left != NIL){
rec(gNode[node].left,parent + 1);
}
}
int main(){
int nodeNum,nodeIndex,node,left,root,n;
cin >> n;
for(int i = 0;i < n;++i){
gNode[i].parent = gNode[i].left = gNode[i].right = NIL;
}
for(int i = 0;i < n;++i){
cin >> nodeIndex >> nodeNum;
for(int j = 0;j < nodeNum;++j){
cin >> node;
if(j == 0){
gNode[nodeIndex].left = node;
}
else{
gNode[left].right = node;
}
left = node;
gNode[node].parent = nodeIndex;
}
}
for(int i = 0;i < n;++i){
if(gNode[i].parent == NIL){
root = i;
}
}
rec(root,0);
for(int i = 0;i < n;++i){
print(i);
}
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
while(1){
int n;
cin >> n;
if(n==0)break;
n = 1000 - n;
int ans=0;
if(n >= 500){
n -= 500;
ans++;
}
while(n >= 100){
n-=100;
ans++;
}
if(n >= 50){
n-=50;
ans++;
}
while(n >= 10){
n-=10;
ans++;
}
if(n >= 5){
n-=5;
ans++;
}
ans += n;
cout << ans <<endl;
}
}
| 0
| 59,226,876
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll n,x;
scanf("%lld %lld",&n,&x);
ll ans=n;
ll a=x,b=n-x;
while(1){
if(a>b)swap(a,b);
if(b%a==0){ans+=b*2-a;break;}
ans+=2*(b-(b%a));
b%=a;
}
printf("%lld\n",ans);
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <map>
#include <numeric>
#include <cmath>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <complex>
#include <string.h>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <iomanip>
#include <sys/time.h>
#include <tuple>
#include <random>
using namespace std;
#define endl '\n'
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define UNIQ(v) (v).erase(unique((v).begin(), (v).end()), (v).end())
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef complex<double> comp;
typedef vector< vector<ld> > matrix;
struct pairhash {
public:
template<typename T, typename U>
size_t operator()(const pair<T, U> &x) const {
size_t seed = hash<T>()(x.first);
return hash<U>()(x.second) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}
};
const int inf = 1e9 + 9;
const ll mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1);
int n, h, w;
int a[1010], b[1010];
int solve() {
int res = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= h && b[i] >= w)
res++;
}
return res;
}
void input() {
cin >> n >> h >> w;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
input();
cout << solve() << endl;
}
| 0
| 96,087,096
|
#include<bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define N 100005
#define ll long long
#define ull unsigned long long
#define loop1(i, j, k, step) for (int i=j; i<k; i+=step)
#define loop(i, j, k) for (int i=j; i<k; i++)
#define rloop1(i, j, k, step) for (int i=j; i>=k; i-=step)
#define rloop(i, j, k) for(int i=j; i>=k; i--)
#define rep(i, k) for(int i = (0); i < (k); i++ )
#define rrep(i, k) for(int i = k-1; i >= 0; i-- )
#define forall(it, l) for(auto it=l.begin(); it != l.end(); it++)
#define mp make_pair
#define pb push_back
#define pop pop_back
#define F first
#define S second
#define sz(x) (int)(x).size()
#define endl "\n"
#define Max (int)INT_MAX
#define Min (int)INT_MIN
#define MEM(a, b) memset(a, (b), sizeof(a))
#define fast_io ios_base::sync_with_stdio(0), cin.tie(NULL)
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<ll> vl;
typedef pair<ll,ll> pll;
void solve()
{
int n,k,l;
cin>>n;
vi a;
rep(i,n){
cin>>k;
a.pb(k);
}
l = a[0];
ll z =0;
loop(i,1,n){
if(a[i]<l){
z += abs(l-a[i]);
}
else
l = a[i];
}
cout<<z<<endl;
}
int main()
{
auto start=clock();
fast_io;
int t=1;
while(t--){
solve();
}
auto stop =clock();
cerr<<"time taken:"<<double(stop-start)/double(CLOCKS_PER_SEC)<<" s"<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> as(n);
vector<int> bs(n);
int t;
long long sum = 0;
long long minus = 0;
int count = 0;
for (int &a : as) cin >> a;
for (int i = 0; i < n; ++i) {
cin >> t;
bs[i] = as[i] - t;
sum += bs[i];
if (bs[i] < 0) {
minus -= bs[i];
++count;
}
}
if (sum < 0) {
cout << -1 << endl;
return 0;
}
sort(bs.begin(), bs.end());
int c = n;
while (minus > 0) {
--c;
minus -= bs[c];
++count;
}
cout << count << endl;
return 0;
}
| 0
| 46,127,261
|
#include<bits/stdc++.h>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define int long long int
#define mod 1000000007
#define out1(a) cout<<#a<<" "<<a<<endl
#define out2(a,b) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<endl
#define out3(a,b,c) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<" "<<#c<<" "<<c<<endl
#define ft first
#define sd second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
using namespace std;
signed main()
{
fast;
int a[32] = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
int k;
cin>>k;
cout<<a[k-1]<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
vector<int> p(n), c(n);
for (int i = 0; i < n; i++) { cin >> p.at(i); }
for (int i = 0; i < n; i++) { cin >> c.at(i); }
for (int i = 0; i < n; i++) { p.at(i)--; }
ll ans = -1e18;
for (int si = 0; si < n; si++) {
int x = si;
vector<int> s;
ll total = 0;
while (1) {
x = p.at(x);
s.push_back(c.at(x));
total += c.at(x);
if (x == si) { break; }
}
int loop = s.size();
ll t = 0;
for (int i = 0; i < loop; i++) {
t += s.at(i);
if (i+1 > k) { break; }
ll now = t;
if (total > 0) {
ll e = (k-(i+1)) / loop;
now += total * e;
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| 0
| 84,542,641
|
#include <bits/stdc++.h>
using namespace std;
void printVector(const vector<int>& vec) {
for (int value : vec) {
cout << value << " ";
}
cout << endl;
}
int main() {
int N;
cin >> N;
vector<int> P(N);
vector<int> Q(N);
vector<int> nums(N);
int a=0,b=0,j=0;
for(int i=0;i<N;i++) {
cin >> P.at(i);
}
for(int i=0;i<N;i++) {
cin >> Q.at(i);
}
for(int i=0;i<N;i++) {
nums.at(i) = i+1;
}
do{
j++;
if(nums == P) {
a = j;
}
if(nums == Q) {
b = j;
}
}while(next_permutation(nums.begin(), nums.end()));
cout << abs(b-a) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define INF 1e9+7
#define cases int t;cin>>t;while(t--)
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define per(i,a,b) for(ll i=a;i>=b;i--)
#define ff first
#define ss second
#define test4(x,y,z,a) cout<<"x is "<<x<<" y is "<<y<<" z is "<<z<<" a is "<<a<<endl;
#define test3(x,y,z) cout<<"x is "<<x<<" y is "<<y<<" z is "<<z<<endl;
#define test2(x,y) cout<<"x is "<<x<<" y is "<<y<<endl;
#define test1(x) cout<<"x is "<<x<<endl;
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
string s;
cin>>s;
ll cnto=0,cnte=0;
rep(i,0,s.size()){
if(i%2){
if(s[i]=='1')
cnte++;
}
else{
if(s[i]=='0')
cnte++;
}
}
rep(i,0,s.size()){
if(i%2&&s[i]=='0'){
cnto++;
}
else if(i%2==0&&s[i]=='1'){
cnto++;
}
}
ll p=min(cnto,cnte);
cout<<p;
return 0;
}
| 0
| 79,699,600
|
#include <stdio.h>
int main(){
int n;
scanf("%d",&n);
char string[n];
scanf("%s",string);
int flag = 1;
if (n%2 == 1){
printf("No");
return 0;
} else{
for (int i=0 ; i < n/2 ; i++){
if (string[i] == string[i+n/2]){
}
else {
flag = 0;
}
}
}
(flag==1)?printf("Yes"):printf("No");
return 0;
}
|
#include <bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
#define pb push_back
#define pii pair < ll , ll >
#define F first
#define S second
#define int long long
#define sync ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#pragma GCC optimize ("Ofast")
#pragma GCC optimize ("unroll-loops")
using namespace std;
const int N=2e5+100;
vector <int> g[N];
ll ans[N];
ll dfs(ll v,ll p){
ll cnt=0;
for (int i=0;i<g[v].size();i++){
ll u=g[v][i];
if (u==p){
continue;
}
dfs(u,v);
cnt^=ans[u]+1;
}
ans[v]=cnt;
}
int32_t main(){
ll n;
cin >> n;
for (int i=0;i<n-1;i++){
ll u,v;
cin >> u >> v;
g[u].pb(v);
g[v].pb(u);
}
dfs(1,1);
if (ans[1]){
cout << "Alice" << endl;
}
else{
cout << "Bob" << endl;
}
}
| 0
| 94,460,955
|
#include <bits/stdc++.h>
using namespace std;
#define loop(i,n) for (int i =0;i<(n);i++)
typedef long long ll;
int main(){
int n,r;
cin >> n>>r;
int ans = r+100*max(0,10-n);
cout<<ans<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int h,w; cin >> h >> w;
vector<vector<char>> s(h,vector<char>(w));
for(int i=0; i<h; i++) {
for(int j=0; j<w; j++) {
cin >> s[i][j];
}
}
for(int i=0; i<h; i++) {
for(int j=0; j<w; j++) {
if((s[i][j]=='#')
&&(i==0||s[i-1][j]=='.')
&&(i==h-1||s[i+1][j]=='.')
&&(j==0||s[i][j-1]=='.')
&&(j==w-1||s[i][j+1]=='.')) {
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
}
| 0
| 20,644,107
|
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll=long long;
vector<ll> t[200005];
vector<ll> v(200005,0);
void dfs(ll i,ll j){
for(int k:t[i]){
if(k==j) continue;
v[k]+=v[i];
dfs(k,i);
}
}
int main(){
int N,Q,A,B,P,X; cin>>N>>Q;
REP(i,N-1){
cin>>A>>B;
t[A].push_back(B);
t[B].push_back(A);
}
REP(i,Q){
cin>>P>>X;
v[P]+=X;
}
dfs(1,0);
REP(i,N) cout<<v[i+1]<<" ";
}
|
#include <iostream>
using namespace std;
int main (){
while (1){
int map[17][17]={0},a,b,n,an,bn;
cin>>a>>b;
if (a==0&&b==0)break;
cin>>n;
for (int i=0;i<n;i++){
cin>>an>>bn;
map[bn][an]=-1;
}
map[1][1]=1;
for (int i=1;i<=b;i++){
for (int j=1;j<=a;j++){
if (map[i][j]!=-1){
if (map[i+1][j]!=-1&&i+1<=b){
map[i+1][j]+=map[i][j];
}
if (map[i][j+1]!=-1&&j+1<=a){
map[i][j+1]+=map[i][j];
}
}
}
}
cout<<map[b][a]<<endl;
}
return 0;
}
| 0
| 93,669,808
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define INF 1<<30
#define LINF 1LL<<60
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
ll N; cin >> N;
vector<ll> a(N);
for(auto& in:a) cin >> in;
vector<ll> cusum(N+1,0);
for(int i = 1; i <= N;i++){
cusum[i] = cusum[i-1] + a[i-1];
}
ll res = LINF;
for(int i = 1; i < N;i++){
res = min(res,abs(cusum[i] - (cusum[N] - cusum[i])));
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, M;
cin >> N >> M;
priority_queue<long long> que;
for( int i = 0; i < N; i++ ) {
long long A;
cin >> A;
que.push( A );
}
for( int i = 0; i < M; i++ ) {
long long A = que.top();
que.pop();
que.push( A / 2 );
}
long long ans = 0;
while( !que.empty() ) {
long long A = que.top();
que.pop();
ans += A;
}
cout << ans << endl;
}
| 0
| 17,729,401
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define MOD 998244353
#define mod9 1000000009
#define fast ios_base :: sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
#define mp make_pair
#define pb push_back
#define ct ll t;cin>>t;while(t--)
#define bi begin()
#define ei end()
#define fi first
#define se second
#define foe(i,a,b) for(ll i=a;i<b;i++)
#define sz(s) s.size()
#define mem(a,s) memset(a,s,sizeof(a))
#define MAX 8000000000000000064LL
#define MIN -8000000000000000064LL
ll add(ll a, ll b){return (a%MOD + b%MOD + ((MAX)/MOD)*MOD)%MOD;}
ll sub(ll a, ll b){return (a%MOD - b%MOD + ((MAX)/MOD)*MOD)%MOD;}
ll mul(ll a, ll b){return ((a%MOD)*(b%MOD) + ((MAX)/MOD)*MOD)%MOD;}
bool isPrime(ll n)
{
if (n <= 1)
return false;
for (ll i = 2; i*i <= n; i++)
if (n % i == 0)
return false;
return true;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1)
res = mul(res,a);
a = mul(a,a);
b >>= 1;
}
return res%MOD;
}
bool compare(const pair<ll,ll>&a,const pair<ll,ll>&b)
{
return (a.se>b.se);
}
ll lcm(ll a,ll b)
{
return(a*b)/__gcd(a,b);
}
ll fact[2000007]={0};
ll expo(ll x, ll y) {ll res=1;x=x%MOD;while(y>0){if(y&1)res=(1ll*res*x)%MOD;
y=y>>1;x=(1ll*x*x)%MOD;} return res;}
void facto() {fact[0]=1;fact[1]=1;for(ll i=2;i<1000007;i++)fact[i]=(fact[i-1]*i)%MOD;}
ll ncr(ll n,ll r) {ll res=1; res=fact[n]; res=(res*(expo(fact[r],MOD-2)))%MOD; res=(res*(expo(fact[n-r],MOD-2)))%MOD; return res;}
ll npr(ll n,ll r) {facto(); ll res=1; res=fact[n]; res=(res*(expo(fact[n-r],MOD-2)))%MOD; return res; }
int const N=2e5+9;
int const inf = 1e9+5;
void solve()
{
string s;
cin>>s;
if(s[2]==s[3]&&s[4]==s[5])
{
cout<<"Yes\n";
}
else
{
cout<<"No\n";
}
}
int main()
{
fast
{
solve();
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n;
cin>>n;
vector<int> a(n);
priority_queue<int> q;
ll extra=0,ans=0;
for(int i=0;i<n;i++) cin>>a[i];
for(int i=0;i<n;i++){
int b;
cin>>b;
if(a[i]<b) ans++,extra+=b-a[i];
else q.push(a[i]-b);
}
while(extra>0){
if(q.empty()){
cout<<-1<<endl;
return 0;
}
int x=q.top();
q.pop();
extra-=x;
if(x!=0) ans++;
}
cout<<ans<<endl;
}
| 0
| 68,427,727
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,cr,cl,ct=0;
cin>>N;
cin>>cl;
for(int i=0;i<N-1;i++){
cin>>cr;
if(cl==cr){cl=-1*cr;ct++;}
else cl=cr;
}
cout<<ct<<endl;
}
|
#include <iostream>
using namespace std;
class Solve{
private:
int n_ = 0;
int s_ = 0;
int result = 0;
void dfs(int num, int sum, int cnt);
public:
Solve(int num, int sum);
int getSolve();
};
Solve::Solve(int num, int sum){
n_ = num;
s_ = sum;
Solve::dfs(0,0,0);
}
void Solve::dfs(int num, int sum, int cnt){
if(sum == s_ && cnt == n_){
result++;
return;
}
if(num == 10 || cnt == n_){
return;
}
Solve::dfs(num+1, sum+num, cnt+1);
Solve::dfs(num+1, sum, cnt);
}
int Solve::getSolve(){
return result;
}
int main(){
int n, s = 0;
while(cin >> n >> s){
if(n == 0 && s == 0){
break;
}else{
Solve solve(n, s);
cout << solve.getSolve() << endl;
}
}
return 0;
}
| 0
| 31,895,532
|
#include <iostream>
#include <math.h>
#include <algorithm>
#include <string>
#include <stack>
#include <queue>
#include <set>
#include <cstdio>
#include <string.h>
using namespace std;
#define FOR(i, n) for(int i = 0; i < n; i++)
#define bit(i) static_cast<bitset<8> >(i)
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> VI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<long long, long long>PLL;
typedef queue<int> QI;
typedef priority_queue<int> maxpq;
typedef priority_queue<int, vector<int>, greater<int> > minpq;
struct edge{int to, cost;};
void begin(){cin.tie(0); ios::sync_with_stdio(false);};
int gcd(int a, int b){if(a%b==0){return(b);}else{return(gcd(b,a%b));}};
int lcm(int m, int n){if((0 == m)||(0 == n)){return 0;} return ((m / gcd(m, n)) * n);};
unsigned long long comb(long n, long m){unsigned long long c = 1; m = (n - m < m ? n - m : m);
for(long ns = n - m + 1, ms = 1; ms <= m; ns ++, ms ++){c *= ns; c /= ms;} return c;};
void warshallFloyd(int d[100][100], int n){
for(int k = 0; k < n; ++k)
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)
if(d[i][k] != -1 && d[k][j] != -1){
if(d[i][j] == -1){
d[i][j] = d[i][k] + d[k][j];
}else{
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
};
void dijkstra(int d[1000][1000], int n, int s, int dist[1000]){
FOR(i, n) dist[i] = -1;
dist[s] = 0;
priority_queue<PII, vector<PII>, greater<PII> > q;
q.push(PII(0, s));
while (!q.empty()) {
PII p = q.top(); q.pop();
int i = p.second;
if(dist[i] < p.first) continue;
for(int j = 0; j < n; j++){
if(d[i][j] == -1) continue;
if(dist[j] == -1){
dist[j] = dist[i] + d[i][j];
q.push(PII(dist[j], j));
}else if(dist[j] > dist[i] + d[i][j]){
dist[j] = dist[i] + d[i][j];
q.push(PII(dist[j], j));
}
}
}
};
bool isCross(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4){
int m = (x2-x1)*(y4-y3)-(y2-y1)*(x4-x3);
if(m == 0) return false;
double r =(double)((y4-y3)*(x3-x1)-(x4-x3)*(y3-y1))/m;
double s =(double)((y2-y1)*(x3-x1)-(x2-x1)*(y3-y1))/m;
return (0 < r && r <= 1 && 0 < s && s <= 1);
};
int crossProdct(int ax, int ay, int bx, int by, int cx, int cy, int dx, int dy){
int abx = bx - ax;
int aby = by - ay;
int cdx = cx - dx;
int cdy = cy - dy;
return abx * cdy - cdx - aby;
};
double crossProdct(double ax, double ay, double bx, double by, double cx, double cy, double dx, double dy){
double abx = bx - ax;
double aby = by - ay;
double cdx = dx - cx;
double cdy = dy - cy;
return abx * cdy - cdx * aby;
};
bool inTriangle(int ax, int ay, int bx, int by, int cx, int cy, int px, int py){
int abx = bx - ax;
int aby = by - ay;
int bcx = cx - bx;
int bcy = cy - by;
int cax = ax - cx;
int cay = ay - cy;
int apx = px - ax;
int apy = py - ay;
int bpx = px - bx;
int bpy = py - by;
int cpx = px - cx;
int cpy = py - cy;
int c1 = abx * bpy - aby * bpx;
int c2 = bcx * cpy - bcy * cpx;
int c3 = cax * apy - cay * apx;
return (c1 > 0 && c2 > 0 && c3 > 0) || (c1 < 0 && c2 < 0 && c3 < 0);
};
bool inTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py){
double c1 = crossProdct(ax, ay, bx, by, bx, by, px, py);
double c2 = crossProdct(bx, by, cx, cy, cx, cy, px, py);
double c3 = crossProdct(cx, cy, ax, ay, ax, ay, px, py);
return (c1 > 0 && c2 > 0 && c3 > 0) || (c1 < 0 && c2 < 0 && c3 < 0);
};
void cp(int a1[], int a2[], int l){FOR(i, l) a2[i] = a1[i];};
int main(int argc, const char * argv[]){
begin();
double ax, ay, bx, by, cx, cy, px, py;
while(cin >> ax >> ay >> bx >> by >> cx >> cy >> px >> py){
if(inTriangle(ax, ay, bx, by, cx, cy, px, py)){
cout << "YES" << endl;
}else{
cout << "NO" << endl;
}
}
}
|
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include<bits/stdc++.h>
using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define pb push_back
#define vi vector<int>
#define rep0(a,b) for(int a=0;a<b;a++)
#define rep1(a,b) for(int a=1;a<=b;a++)
#define repp(a,b,c) for(int a=b;a<c;a++)
#define in insert
#define len length()
#define si size()
#define lb lower_bound
#define ub upper_bound
#define beg begin()
#define en end()
#define f first
#define s second
#define pr(a) cout<<a
#define pr2(a,b) cout<<a<<" "<<b<<"\n"
#define nx cout<<"\n"
#define int long long
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]"<<endl;}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define deb(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define deb(x...)
#endif
const ll mod = 1000000007;
const ll N = 200005;
const ll mm = 1e+18;
void solve()
{
string s;
cin>>s;
int n=s.len;
rep0(i,n-1){
if(s[i]==s[i+1]){
cout<<i+1<<" "<<i+2;
return;
}
}
rep0(i,n-2){
if(s[i]==s[i+2]){
cout<<i+1<<" "<<i+3;
return;
}
}
cout<<"-1 -1";
}
signed main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t=1;
rep1(_i,t){
solve();
}
return 0;
}
| 0
| 16,678,926
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <set>
#include <string>
#include <vector>
#include <iomanip>
#include <map>
using namespace std;
#define fastInp cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);
typedef long long ll;
typedef long double ld;
const ll SIZE = 1e5 + 10, S2 = 1e7 * 2;
vector<pair<ll, ll>> vec;
vector<ll> cnt, pref;
vector<ll> add[SIZE];
int main() {
fastInp;
ll n;
cin >> n;
cnt.resize(n);
pref.resize(n);
ll curMx = -1, ind = -1;
vector<ll> k(n);
for (int i = 0; i < n; i++) {
ll a;
cin >> a;
k[i] = a;
if (curMx < a) {
vec.push_back({ a, i });
}
else {
}
if (curMx < a) {
ind = i;
}
curMx = max(curMx, a);
}
sort(vec.rbegin(), vec.rend());
curMx = -1, ind = -1;
for (int i = 0; i < n; i++) {
ll a;
a = k[i];
if (curMx < a) {
}
else {
int l = -1, r = vec.size();
while (r - l > 1) {
int mid = (l + r) / 2;
if (vec[mid].first >= a) {
l = mid;
}
else {
r = mid;
}
}
add[l].push_back(a);
}
if (curMx < a) {
ind = i;
}
curMx = max(curMx, a);
}
ll curAdd = 0; vec.push_back({ 0, 0 });
for (int i = 0; i < vec.size() - 1; i++) {
ll s = 0;
for (auto cur : add[i]) {
s += abs(vec[i + 1].first - cur);
}
cnt[vec[i].second] += (i + 1 + curAdd) * abs(vec[i].first - vec[i + 1].first) + s;
curAdd += add[i].size();
}
for (int i = 0; i < n; i++) {
cout << cnt[i] << "\n";
}
return 0;
}
|
#include <iostream>
#include <string>
#include <array>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <cctype>
#include <map>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <stack>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
using namespace std;
bool is_integer( float x ){
return floor(x)==x;
}
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
vector<long long> enum_divisors(long long N) {
vector<long long> res;
for (long long i = 1; i * i <= N; ++i) {
if (N % i == 0) {
res.push_back(i);
if (N/i != i) res.push_back(N/i);
}
}
sort(res.begin(), res.end());
return res;
}
vector<pair<long long, long long> > prime_factorize(long long N) {
vector<pair<long long, long long> > res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1) res.push_back({N, 1});
return res;
}
int main() {
string s;cin >> s;
stack<char> tmp;
int ans = 0;
rep(i,s.length()){
if(tmp.empty()) tmp.push(s[i]);
else{
if(tmp.top() != s[i]){
ans ++;
tmp.pop();
}else{
tmp.push(s[i]);
}
}
}
cout << ans*2;
return 0;
}
| 0
| 27,148,257
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
bool cmp(int &a,int &b) {
int c = a%10,d=b%10;
if(c==0)return false;
if(d==0)return true;
return c<d;
}
void solve(int test_case) {
vi arr(5);
for(int &i:arr)cin>>i;
sort(arr.rbegin(),arr.rend(),cmp);
int sum = 0;
REP(i,0,3) {
if(arr[i]%10==0)sum+=arr[i];
else {
arr[i]+=10-arr[i]%10;
sum+=arr[i];
}
}
sum+=arr[4];
cout<<sum;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
REP(i,1,t) {
solve(i);
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
#define reps(i,s,n) for(int (i) = (s); (i) < (n); (i)++)
#define rep(i,n) reps(i,0,n)
using namespace std;
using ll = long long;
int main(){
ll n;
cin >> n;
ll ans = 0;
if( n % 2 == 1){
cout << 0 << endl;
return 0;
}else{
ll tmp = 5;
while(tmp <= n){
ans += ((n/2)/tmp);
tmp *= 5;
}
}
cout << ans << endl;
return 0;
}
| 0
| 42,872,846
|
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#define EPS 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LL long long
const int MOD = 1E9+7;
const int N = 8000+5;
const int dx[] = {-1,1,0,0,-1,-1,1,1};
const int dy[] = {0,0,-1,1,-1,1,-1,1};
using namespace std;
int x,y;
string str;
bitset<N*2> bs[2];
int main(){
cin>>str;
scanf("%d%d",&x,&y);
int i=0;
while(str[i]=='F')
i++;
bs[0][i+N]=1;
bs[1][N]=1;
int num=0;
int pos=0;
while(i<=str.size()){
if(str[i]=='F')
num++;
else{
bs[pos]=(bs[pos]<<num) | (bs[pos]>>num);
pos=!pos;
num=0;
}
i++;
}
if(bs[0][x+N] & bs[1][y+N])
printf("Yes\n");
else
printf("No\n");
return 0;
}
|
#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
while(1){
int m,n;
cin>>m>>n;
if(m==0&&n==0)break;
long long int fie[20][20]={0};
int ko[20][20]={0};
fie[1][1]=1;
int p;
cin>>p;
for(int i=0;i<p;i++){
int a,b;
cin>>a>>b;
ko[a][b]=1;
}
for(int i=1;i<19;i++){
for(int j=1;j<19;j++){
if(!ko[i][j+1])fie[i][j+1]+=fie[i][j];
if(!ko[i+1][j])fie[i+1][j]+=fie[i][j];
}
}
cout<<fie[m][n]<<endl;
}
return 0;
}
| 0
| 81,085,772
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <bitset>
#include <time.h>
#include <tuple>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e12;
const ll MOD = 1e9 + 7;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,N) for(int i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
ll sq(ll num) { return num*num; }
ll mod_pow(ll x, ll n) {
if (n == 0)return 1;
if (n == 1)return x%MOD;
ll res = sq(mod_pow(x, n / 2));
res %= MOD;
if (n % 2 == 1) {
res *= x;
res %= MOD;
}
return res;
}
ll mod_add(ll a, ll b) { return (a + b) % MOD; }
ll mod_sub(ll a, ll b) { return (a - b + MOD) % MOD; }
ll mod_mul(ll a, ll b) { return a*b % MOD; }
int h,w;
int main(){
cin >> h >> w;
vector<P> p;
rep(i,h){
ll num;
cin >> num;
p.push_back(P(num,0));
}
rep(i,w){
ll num;
cin >> num;
p.push_back(P(num,1));
}
sort(ALL(p));
ll cnt[2] = {};
ll def = 0;
ll prev = p[0].second;
ll ans = 0;
rep(i,p.size()){
ll num = p[i].first;
bool now = p[i].second;
if(prev != now)def = cnt[prev];
cnt[now]++;
prev = now;
if(now == 0)num *= (w+1-def);
else num *= (h+1-def);
ans += num;
prev = now;
}
cout << ans << endl;
}
|
#include <stdio.h>
using namespace std;
int main(){
int C[10001];
for(int i = 0; i < 10001; i++) C[i] = 0;
int n;
scanf("%d",&n);
int* A = new int[n];
int* B = new int[n];
for(int i = 0; i < n; i++){
scanf("%d",&A[i]);
C[A[i]]++;
}
for(int i = 0,j=0; i < 10001; i++){
if(C[i] != 0){
for(int k = 0; k < C[i]; k++){
B[j++] = i;
}
}
}
for(int i = 0; i < n-1; i++) printf("%d ",B[i]);
printf("%d\n",B[n-1]);
delete[] A;
delete[] B;
return 0;
}
| 0
| 52,888,510
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
const ll mod = 1000000007;
#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 _GLIBCXX_DEBUG
int main(){
int n,k;
cin>>n>>k;
ll ans;
if(n==1) ans=k;
if(n>=2) ans=k*pow(k-1,n-1);
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int64_t INF = (1LL << 62);
int64_t N, K, MAXN = 100010;
vector<vector<pair<int, int>>> Graph(MAXN);
int64_t dijkstra(int64_t start, int64_t goal)
{
priority_queue<pair<int64_t, int64_t>, vector<pair<int64_t, int64_t>>, greater<pair<int64_t, int64_t>>> PQ;
vector<int64_t> Color(MAXN, 0), D(MAXN, INF);
D.at(start) = 0;
PQ.push(make_pair(0, start));
Color.at(start) = 1;
while (!PQ.empty())
{
pair<int64_t, int64_t> f = PQ.top();
PQ.pop();
int64_t u = f.second;
Color.at(u) = 2;
if (D.at(u) < f.first)
continue;
for (int i = 0; i < Graph.at(u).size(); i++)
{
int64_t v = Graph.at(u).at(i).first;
if (Color.at(v) == 2)
continue;
if (D.at(v) > D.at(u) + Graph.at(u).at(i).second)
{
D.at(v) = D.at(u) + Graph.at(u).at(i).second;
PQ.push(make_pair(D.at(v), v));
Color.at(v) = 1;
}
}
}
return D.at(goal);
}
int main()
{
cin >> K;
for (int i = 0; i < K; i++)
{
Graph.at(i).push_back(make_pair((i + 1) % K, 1));
Graph.at(i).push_back(make_pair((i * 10) % K, 0));
}
cout << dijkstra(1, 0) + 1 << endl;
}
| 0
| 47,551,512
|
#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, k;
cin >> n >> k;
if(n%k == 0){
cout << 0 << endl;
}else{
cout << 1 << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#define ALL(obj) (obj).begin(),(obj).end()
#define RALL(obj) (obj).rbegin(),(obj).rend()
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define REPR(i, n) for(int i = (int)(n); i >= 0; i--)
#define FOR(i,n,m) for(int i = (int)(n); i < int(m); i++)
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 6;
const ll LLINF = 4e18;
int main() {
int n; cin >> n;
vector<vector<char>> s(2 * n, vector<char>(2 * n));
REP(i, n) {
REP(j, n) {
cin >> s[i][j];
s[i][j + n] = s[i][j];
s[i + n][j] = s[i][j];
s[i + n][j + n] = s[i][j];
}
}
ll ans = 0;
REP(k, n) {
bool b = false;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (s[j + k][i] != s[i + k][j]) {
b = true;
}
}
}
if (!b) {
ans += n;
}
}
cout << ans << endl;
getchar(); getchar();
}
| 0
| 58,565,201
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i< (n); i++)
using ll = long long;
using namespace std;
int main(void){
int N;
cin >> N;
int v[N];
rep(i,N) cin >> v[i];
sort(v,v+N);
double ans = v[0];
for (int i = 1; i <= N-1; i++) {
ans = 0.5*(ans + v[i]);
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;cin>>s;
vector<int >nos(26,-1);
for(int i=0;i<s.size();i++){
nos[s[i]-'a']=i;
}
int repl=-1;
for(int i=0;i<26;i++)if(nos[i]==-1){repl=i;break;}
if(repl!=-1){cout<<s;cout<<(char)('a'+repl);}
else{
for(int i=s.size()-1;i>0;i--){
if(s[i]>s[i-1]){
for(int j=0;j<i-1;j++)cout<<s[j];
repl=-1;
for(int j=0;j<26;j++){
if(('a'+j > s[i-1] ) && nos[j]>=i){repl=j;break;}
}
if(repl==-1)break;
cout<<(char)('a'+repl);
return 0;
}
}
cout<<-1;
}
}
| 0
| 31,808,274
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,A;
cin >> N >> A;
vector<int>x(N);
for (int i = 0; i < N; i++) {
cin >> x.at(i);
x.at(i) = abs(x.at(i)-A);
}
if (N == 1){
cout << x.at(0) << endl;
return 0;
}
int X = x.at(0);
int Y = x.at(1);
int Z = X % Y;
int count;
for (int i = 1; i < N; i++) {
count = 0;
while (count == 0){
if (Z == 0){
if (i != N-1){
X = x.at(i+1);
Z = X % Y;
}
count++;
}
else {
X = Y;
Y = Z;
Z = X % Y;
}
}
}
cout << Y << endl;
}
|
#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 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 << 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) {
string s;
cin >> s;
rep(i, size(s)) if (odd(i + 1)) cout << s[i];
cout << endl;
}
int main(void) { solve(); }
| 0
| 58,075,063
|
#include <iostream>
#include <string>
using namespace std;
int main(){
std::string str;
while(cin >> str) {
for(int i = (int)str.length() - 1; i >= 0; i--) {
cout << str[i];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL<<60;
int main()
{
int H,W; cin>>H>>W;
string board[H];
rep(i,H) cin>>board[i];
string ans = "Yes";
rep(i, H) {
rep(j, W) {
if (board[i][j] == '#') {
bool can = false;
for (int dy = -1; dy < 2; dy++) {
int ny = i + dy;
if (ny >= 0 && ny < H) {
if (i != ny && board[ny][j] == '#') can = true;
}
}
for (int dx = -1; dx < 2; dx++) {
int nx = j + dx;
if (nx >= 0 && nx < W) {
if (j != nx && board[i][nx] == '#') can = true;
}
}
if (can == false) {
ans = "No";
}
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 65,141,872
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int ans;
ans = n*(n+1);
cout<<ans/2<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#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(obj) (obj).begin(), (obj).end()
#define INF 1e9
typedef long long ll;
int main() {
string S; cin >> S;
ll K; cin >> K;
ll count = 0;
char next;
REP(i,S.size()){
if(S[i] == '1'){
count ++;
}else{
next = S[i];
break;
}
}
if(count >= K){
cout << 1 << endl;
}else{
cout << next << endl;
}
return 0;
}
| 0
| 72,939,627
|
#include<iostream>
using namespace std;
int main(){
int a,b,c,i,ans=0;
cin>>a>>b>>c;
for(i=0;i<=10000;i++){
if(c%a==0)ans++;
if(a==b)break;
a++;
}
cout<<ans<<endl;
return 0;
}
|
#include<iostream>
#include<queue>
#include<bitset>
#include<algorithm>
#include<climits>
#include<deque>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define fill(x,y) memset(x,y,sizeof(x))
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define dump(a) rep(i,a.size()){ cout<<a[i]<<" "; } cout<<endl;
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define INF INT_MAX/3
#define EPS 1e-7
int digitsum(ll n) {
ll t = n;
ll s = 0;
while(t>0){
s += t % 10;
t = t / 10;
}
return s;
}
int main(){
ll k;
cin>>k;
deque<P> d;
d.push_front(P(1,1));
vector<bool> visited(k,false);
while(!d.empty()){
P p = d.front(); d.pop_front();
int i=p.first, score=p.second;
if(i==0) {
cout<<score<<endl;
break;
}
visited[i]=true;
ll n0 = (i*10)%k;
ll n1 = (i+1)%k;
if(!visited[n0]) d.push_front(P(n0, score));
if(!visited[n1]) d.push_back(P(n1, score+1));
}
return 0;
}
| 0
| 79,933,373
|
#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
#define pi 3.141592653589793
int main(){
int a, b;
double theta;
cin >> a >> b >> theta;
theta =pi*theta/180;
double S = a * b * sin(theta)/2;
double c = sqrt(a*a + b*b - 2*a*b*cos(theta));
double L = a + b + c;
double h = S*2/a;
printf("%.8lf \n", S);
printf("%.8lf \n", L);
printf("%.8lf \n", h);
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <queue>
#include <utility>
#include <map>
#include <bitset>
#define ll long long
using namespace std;
using p = pair<ll, ll>;
ll dx[4] = {-1, 0, 1, 0};
ll dy[4] = {0, 1, 0, -1};
int main(void){
ll n;
cin >> n;
string s[n];
for(ll i = 0; i < n; i++)
cin >> s[i];
ll a = 0, b = 0, ab = 0;
ll same = 0;
for(ll i = 0; i < n; i++){
for(ll j = 0; j < s[i].length()-1; j++){
if(s[i][j]=='A' && s[i][j+1]=='B') ab++;
}
if(s[i][s[i].length()-1]=='A') a++;
if(s[i][0]=='B') b++;
if(s[i][0]=='B'&&s[i][s[i].length()-1]=='A')
same++;
}
ll ans = ab+min(a, b);
if(same==a&&same==b&&same!=0) ans--;
cout << ans << endl;
return 0;
}
| 0
| 84,805,323
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
ll gcd(ll a, ll b) {
ll v0=a, v1=b, v2=v0%v1;
while(v2>0) {
v0 = v1;
v1 = v2;
v2 = v0%v1;
}
return v1;
}
int main() {
int N;
cin>>N;
ll ans;
ll tmp;
for(int i=0;i<N;++i) {
cin>>tmp;
if(i==0) ans = tmp;
else ans = gcd(ans, tmp);
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using plong=pair<long,long>;
int main(){
int N;cin>>N;
long K;cin>>K;
vector<plong> A(N);
for(int i=0;i<N;i++){
long X,Y;cin>>X>>Y;
A.at(i)=make_pair(X,Y);
}
sort(A.begin(),A.end());
int X=0;
long count=0;
int ans=1;
while(true){
while(true){
if(A.at(X).first!=ans) break;
count+=A.at(X).second;
if(count>=K) break;
X++;
}
if(count>=K) break;
ans++;
}
cout<<ans<<endl;
}
| 0
| 76,178,657
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
string A;
cin >> A;
int sz1 = A.size();
string B;
cin >> B;
int sz2 = B.size();
string C;
cin >> C;
if (A[sz1 -1] == B[0] && B[sz2-1] == C[0])
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <map>
int main(){
std::string s;
int n;
std::cin >> s >> n;
for (int i = 0; i < n; i++) {
std::string op;
int a, b;
std::cin >> op >> a >> b;
if (op == "print") {
std::cout << s.substr(a, b - a + 1) << std::endl;
} else if (op == "reverse") {
for (int j = a; j < (b - a + 1) / 2 + a; j++) {
std::swap(s[j], s[b - (j - a)]);
}
} else {
std::string p;
std::cin >> p;
for (int j = a; j <= b; j++) {
s[j] = p[j - a];
}
}
}
return 0;
}
| 0
| 63,745,958
|
#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(){
ll n,a,b;
cin >> n >> a >> b;
ll c = a+b;
ll ans = a * (n/c);
ans += min(n%c, a);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define vsort(vec) sort(vec.begin(), vec.end())
#define vreverse(vec) reverse(vec.begin(), vec.end())
using ll =long long;
const ll INF =999999999;
ll gcd(ll a, ll b){
if (a%b==0){
return(b);
}else{
return(gcd(b,a%b));
}
}
ll lcm(ll a, ll b){
return a*b/gcd(a,b);
}
ll isprime(ll n){
bool prime=true;
for(int i=2;i<n;i++){
if(n%i==0){
prime=false; break;
}
}
if(prime){cout<<n<<" is prime"<<endl;
}else{cout<<n<<" is not prime"<<endl;}
}
ll factorial(ll n){
ll a=1;ll b=n;
for(int i=0;i<n;i++){
a*=b;
b--;
}
return a;
}
ll comb(ll a,ll b){
ll c;
c=factorial(a)/(factorial(a-b)*factorial(b));
return c;
}
int main(){
cout<<fixed<<setprecision(10);
int X,Y;cin>>X>>Y;
cout<<X+Y/2<<endl;
}
| 0
| 62,432,439
|
#include <iostream>
#include <algorithm>
using namespace std;
struct Card
{
char value;
char suit;
};
void trace(Card A[], int n)
{
cout << A[0].suit << A[0].value;
for(int i=1; i < n; i++)
{
cout << " " << A[i].suit << A[i].value;
}
cout << endl;
return;
}
bool isStable(Card C1[], Card C2[], int n)
{
for(int i = 0; i < n; i++)
{
if(C1[i].suit != C2[i].suit)
return false;
}
return true;
}
void bubbleSort(Card C[], int n)
{
for(int i = 0; i < n; i++)
{
for(int j = n-1; j >= i; j--)
{
if(C[j].value < C[j-1].value)
swap(C[j], C[j-1]);
}
}
return;
}
void selectionSort(Card C[], int n)
{
for(int i = 0; i < n; i++)
{
int minj = i;
for(int j = i; j < n; j++)
{
if(C[j].value < C[minj].value)
minj = j;
}
swap(C[i], C[minj]);
}
return;
}
int main(void)
{
int n;
Card C1[36], C2[36];
cin >> n;
for(int i = 0; i < n; i++)
cin >> C1[i].suit >> C1[i].value;
for(int i = 0; i < n; i++)
C2[i] = C1[i];
bubbleSort(C1, n);
selectionSort(C2, n);
trace(C1, n);
cout << "Stable" << endl;
trace(C2, n);
if(isStable(C1, C2, n))
cout << "Stable" << endl;
else
cout << "Not stable" << 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++)
#define all(x) (x).begin(),(x).end()
const ll INF = 1LL << 60;
int main(){
string s;
cin >> s;
int size=s.size();
string rev =s;
reverse(all(rev));
if(s != rev){
cout << "No" << endl;
return 0;
}
string front = s.substr(0,size/2);
string revfro = front;
reverse(all(revfro));
if(front != revfro){
cout << "No" << endl;
return 0;
}
string back = s.substr(size/2+1,size/2);
string revback = back;
reverse(all(revback));
if(back != revback){
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
}
| 0
| 31,411,425
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define FOR(i,a,b) for(int i=(a); i<=(b); i++)
#define rep(i,n) for(int i = 0; i < (n); i++)
#define loop(k) rep(author_is_masa,k)
#define chmin(a,b) if((a)>(b)) (a)=(b);
#define chmax(a,b) if((a)<(b)) (a)=(b);
#define vi vector<int>
#define pii pair<int,int>
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define pb push_back
#define pf push_front
int gcd(int a,int b){
while(min(a,b)>0){if(a<b)swap(a,b);a%=b;}return max(a,b);
}
int dx[]={1,0,-1,0,1,-1,-1,1};
int dy[]={0,1,0,-1,1,1,-1,-1};
const int MOD = 1e9+7;
const long long INF = 1e18;
signed main(){
int n;cin>>n;
vi a(n);
rep(i,n)cin>>a[i];
sort(all(a));
if(a[0]==0){
cout<<0<<endl;
return 0;
}
int pro=1;
rep(i,n){
if(INF/pro+1<a[i]){
cout<<-1<<endl;
return 0;
}
pro*=a[i];
}
if(pro>INF) cout<<-1<<endl;
else cout<<pro<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
int main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout<<setprecision(32);
int n; ll t, x;
cin>>n>>t;
ll ans = 0, cur = 0;
for(int i = 0; i < n; i++){
cin>>x;
if(x <= cur){
ans += x + t - cur;
}else{
ans += t;
}
cur = x + t;
}
cout<<ans<<endl;
return 0;
}
| 0
| 67,287,232
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
string s;
cin>>n>>s;
if(n%2==0&&s.substr(0,n/2)==s.substr(n/2,n/2))
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
}
|
#pragma target("avx")
#pragma target("O3")
#include<bits/stdc++.h>
using ll = int_fast64_t;
using P = std::pair<ll,ll>;
using PP = std::pair<ll,P>;
using V = std::vector<ll>;
template<typename T> using pq = std::priority_queue<T>;
template<typename T> using rpq = std::priority_queue<T, std::vector<T>, std::greater<T>>;
#define rep(i,b,e) for(ll i=b; i<e; i++)
#define be(vec) vec.begin(),vec.end()
#define print(vec) printf("[ ");for(auto &i:vec)printf("%ld ",i);puts("]");
#define scan(vec) for(auto &i:vec)scanf("%ld",&i)
#define fi first
#define se second
const int MOD = 1e9+7;
const ll INF = 1e18;
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
int main(){
int h, w;
scanf("%d %d", &h, &w);
std::vector<V> a(h+2, V(w+2, 1));
rep(i, 1, h+1){
char s[w+1];
scanf("%s", s);
rep(j, 1, w+1) a[i][j] = (s[j-1]=='#');
}
std::queue<PP> que;
rep(i, 1, h+1) rep(j, 1, w+1) {
if(a[i][j]){
rep(I, 0, 4){
que.emplace(1, P(i+dx[I], j+dy[I]));
}
}
}
int ans = 0;
while(!que.empty()){
P p;
int d;
std::tie(d, p) = que.front();
que.pop();
if(a[p.fi][p.se]) continue;
a[p.fi][p.se] = 1;
ans = std::max(ans, d);
rep(i, 0, 4){
int nx=p.fi+dx[i], ny=p.se+dy[i];
if(!a[nx][ny]) que.emplace(d+1, P(nx, ny));
}
}
printf("%d\n", ans);
return 0;
}
| 0
| 20,346,636
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define MAX 200003
#define MOD 1000000007
typedef int FLOW;
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);
for(int i=0;i<N;i++){
a.at(i)=30000*(i+1);
b.at(i)=30000*(N-i);
}
for(int i=0;i<N;i++){
a.at(p.at(i)-1)+=i;
b.at(p.at(i)-1)+=i;
}
for(int i=0;i<N;i++){
cout<<a.at(i)<<" ";
}
cout<<endl;
for(int i=0;i<N;i++){
cout<<b.at(i)<<" ";
}
cout<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rrep(i,n) for (int i = (int)(n)-1; i>=0; --i)
#define For(i,a,b) for(auto i=(a);i<=(b);++i)
#define rFor(i,a,b) for(auto i=(b);i>=(a);--i)
#define call(var) cerr<<#var<<"="<<var<<"\n";
#define dup(x,y) (((x)+(y)-1)/(y))
#define all(x) (x).begin(),(x).end()
using ll=long long;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using Graph = vector<vi>;
using P = pair<int,int>;
const int MOD=(int)1e9+7;
const int INF=(int)1e9;
const ll LINF=(ll)1e18;
const double pi = acos(-1);
template<class t,class u> inline bool chmax(t&a,u b){if(a<b){a=b;return true;}return false;}
template<class t,class u> inline bool chmin(t&a,u b){if(b<a){a=b;return true;}return false;}
template<class T> istream& operator>>(istream& is, vector<T>& a){rep(i,a.size()) is >> a[i]; return is;}
template<class T> ostream& operator<<(ostream& os, vector<T>& a){rep(i,a.size()) os << a[i] << " "; return os;}
template<class T, class U> istream& operator>>(istream& is, pair<T,U>& p){is >> p.first >> p.second; return is;}
template<class T, class U> ostream& operator<<(ostream& os, const pair<T,U>& p){os << "("<< p.first << "," << p.second << ")"; return os;}
template<class T, class U> ostream& operator<<(ostream& os, const map<T,U>& mp){for(auto& t : mp) os << t.first << " " << t.second << "\n"; return os;}
int main(){
int n;cin >> n;
vi d(n);
cin >> d;
int ans = 0;
rep(i,n){
for(int j=i+1;j<n;++j){
ans += d[i] * d[j];
}
}
cout << ans << "\n";
}
| 0
| 14,689,872
|
#include<bits/stdc++.h>
#include<algorithm>
using namespace std;
int n,m;
const int max_size_n=50050;
const int max_size_m=22;
int d[max_size_m]={0};
int t[max_size_n];
int INF = (1<<30)-1;
int main()
{
cin >> n >> m;
for(int i=0;i<m;i++)
cin >> d[i];
for(int j=0;j<=n;j++)
{
t[j]=INF;
}
t[0]=0;
for(int i=0;i<m;i++)
for(int j=d[i];j<=n;j++){
t[j]=min(t[j],t[j-d[i]]+1);
}
cout << t[n] <<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i=0; i<(int)(n); i++)
#define all(x) x.begin(), x.end()
#define mod 1000000007
typedef long long ll;
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) { ++num; n /= p; }
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
int main() {
ll n;
cin >> n;
auto pf = prime_factorize(n);
ll res = 0;
for(auto p : pf){
ll prime = p.first;
ll kazu = p.second;
ll check = 1;
while(kazu >= check){
kazu -= check;
check++;
res++;
}
}
cout << res << endl;
return 0;
}
| 0
| 18,059,057
|
#include<iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main()
{
double a,b,c,d;
double tmp,e;
cin>>a>>b>>c>>d;
tmp=(c-a)*(c-a)+(d-b)*(d-b);
e=sqrt(tmp);
cout<<fixed<<setprecision(15)<<e<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <vector>
#include <queue>
#include <cmath>
#include <bitset>
#include <complex>
#include <functional>
#include <numeric>
#include <iomanip>
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for(int i=(a);i<(n);++i)
#define RFOR(i, a, n) for(int i=(n)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
#define OUT(a, x, b) (x<a || b<=x)
template<class T> inline 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; }
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
struct INIT { INIT(){
cin.tie(0); ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
}}INIT;
signed main() {
int M, K;
cin >> M >> K;
if((1 << M) <= K){
cout << -1 << "\n";
return 0;
}
if(M == 0){
cout << "0 0" << "\n";
return 0;
}
if(M == 1){
if(K == 0) cout << "0 0 1 1" << "\n";
else cout << -1 << "\n";
return 0;
}
REP(i, (1<<M)){
if(i != K) cout << i << " ";
}
cout << K << " ";
RREP(i, (1<<M)){
if(i != K) cout << i << " ";
}
cout << K << "\n";
return 0;
}
| 0
| 79,991,756
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9;
int main() {
int ans = -INF;
int ans_ret = 0;
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int cnt = 0;
int a = i;
while (true) {
if (a % 2 == 0) {
a /= 2;
++cnt;
} else {
break;
}
}
ans = max(ans, cnt);
if (cnt >= ans) {
ans = cnt;
ans_ret = i;
}
}
cout << ans_ret << endl;
}
|
#include <stdio.h>
int main (){
long long int N;
long long int total=1;
scanf("%lld",&N);
long long int A[N];
for(int i=0;i<N;i++){
scanf("%lld", &A[i]);
}
for(int r=0;r<N;r++){
if(A[r] == 0){
printf("0");
return 0;
}
}
for(int k=0;k<N;k++){
if(A[k]<=1000000000000000000/total){
total = total*A[k];
} else {
printf("-1");
return 0;
}
}
printf("%lld", total);
return 0;
}
| 0
| 48,892,490
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define int ll
using namespace std;
typedef long long ll;
signed main(){
string s;
int k;
cin >> s >> k;
int size = s.size();
string check;
rep(i,size) check += s[0];
if(check == s){ cout << size*k/2 << endl; return 0; }
int mae = 1, usiro = 1;
if(s[0] == s[size-1]){
int i = 1;
while(s[0] == s[i]){
mae++; i++;
}
i = size -2;
while(s[size-1] == s[i]){
usiro++; i--;
}
}
int ans = 0, temp = 1;
rep(i,size-1){
if(s[i] == s[i+1]) temp++;
else{ ans += temp/2; temp = 1; }
}
ans += temp/2;
ans *= k;
if(mae != 1 || usiro != 1){
ans = ans - (mae/2)*(k-1) -(usiro/2)*(k-1) + ((mae+usiro)/2)*(k-1);
}
cout << ans << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define int long long
int mod=1e9+7;
signed main(){
string s;
cin>>s;
int n;
cin>>n;
for(int i=0;i<n;i++){
string t;
cin>>t;
int a,b;
cin>>a>>b;
if(t=="reverse")reverse(s.begin()+a,s.begin()+b+1);
if(t=="replace"){
string p;
cin>>p;
for(int j=a;j<=b;j++)s[j]=p[j-a];
}
if(t=="print"){
for(int j=a;j<=b;j++)cout<<s[j];
cout<<endl;
}
}
}
| 0
| 63,420,694
|
#include <bits/stdc++.h>
using namespace std;
int64_t mod = 1000000007;
int64_t large = 9223372036854775807;
double PI = 3.141592653589793;
int main()
{
int N, D, ans, tmp;
cin >> N >> D >> ans;
for (int i = 0; i < N; i++)
{
cin >> tmp;
ans += (D - 1) / tmp + 1;
}
cout << ans;
}
|
#pragma region header
#include <bits/stdc++.h>
#define int long long
#define all(a) begin(a), end(a)
#define rall(a) rbegin(a), rend(a)
#define mp make_pair
#define mt make_tuple
#define rep1(i, n) for (decltype(+n) i = 0; i < (n); i++)
#define rrep1(i, n) for (auto i = n - 1; i > static_cast<decltype(i)>(-1); i--)
#define rep2(i, a, b) for (auto i = (a); i < (b); i++)
#define rrep2(i, a, b) for (auto i = b - 1; i >= a; i--)
#define GET_MACRO(_1, _2, _3, NAME, ...) NAME
#define rep(...) GET_MACRO(__VA_ARGS__, rep2, rep1) (__VA_ARGS__)
#define rrep(...) GET_MACRO(__VA_ARGS__, rrep2, rrep1) (__VA_ARGS__)
#define each(i, a) for (auto &&i : (a))
using namespace std;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vs = vector<string>;
using vvs = vector<vs>;
using vd = vector<ld>;
using vvd = vector<vd>;
using vb = vector<bool>;
using vvb = vector<vb>;
using pii = pair<int, int>;
using vp = vector<pii>;
using vvp = vector<vp>;
using mii = map<int, int>;
using vm = vector<mii>;
using vvm = vector<vm>;
template <class T>
using less_queue = priority_queue<T>;
template <class T>
using greater_queue = priority_queue<T, vector<T>, greater<T>>;
constexpr int INF = 1e18;
template <class T>
void SORT(T &a) { stable_sort(all(a)); }
template <class T>
void RSORT(T &a) { stable_sort(rall(a)); }
template <class T>
void rev(T &a) { reverse(rall(a)); }
template <class T>
void uniq(T &a) { a.erase(unique(all(a)), end(a)); }
template <class T>
auto min_of(T a) { return *min_element(all(a)); }
template <class T>
auto max_of(T a) { return *max_element(all(a)); }
template <class T>
int sum_of(T a) { return accumulate(all(a), 0ll); }
template <class T, class U>
auto sum_of(T a, U init) { return accumulate(all(a), init); }
template <class T, class U>
int count_of(T a, U i) { return count(all(a), i); }
template <class T, class U>
bool has(T a, U i) { return find(all(a), i) != end(a); }
template <class T>
int sz(T a) { return a.size(); };
template <class T>
void COUT(T x) { cout << x << endl; }
template <class T, class U>
void COUT(T x, U y) { cout << x << ' ' << y << endl; }
template <class T, class U, class V>
void COUT(T x, U y, V z) { cout << x << ' ' << y << ' ' << z << endl; }
template <class T>
void CSP(T x) { cout << x << ' '; }
template <class T>
void CVEC(T v) {
int c = v.size() - 1;
for (size_t i = 0; i < c; i++) cout << v[i] << ' ';
if (c > -1) cout << v[c];
cout << endl;
}
template <class T>
bool amin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int ceil_div(int x, int y) { return (x - 1) / y + 1; }
#pragma endregion header
void solve(int a, int b, int c, int d) {
function<int(int)> f = [&](int m) {
return b / m - ceil_div(a, m) + 1;
};
COUT(b - a + 1 - (f(c) + f(d) - f(lcm(c, d))));
}
#pragma region main
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
int a;
cin >> a;
int b;
cin >> b;
int c;
cin >> c;
int d;
cin >> d;
solve(a, b, c, d);
}
#pragma endregion main
| 0
| 59,835,330
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(int)(n); i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
double n, k; cin >> n >> k;
int c = 1;
double ans = 0;
for (int i = n; i>0; i--) {
while (i*c<k) {
c*=2;
}
ans += 1.0 / (n*c);
}
cout << fixed << setprecision(10);
cout << ans << 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 FS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define ld long double
#define pb push_back
#define bp __builtin_popcount
#define sz size()
#define ff first
#define ss second
#define vll vector<ll>
#define vbool vector<bool>
#define vpll vector<pair<ll,ll>>
#define pll pair<ll,ll>
#define vllv vector<vector<ll>>
#define setpri(x) cout<<setprecision(x)<<fixed;
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
#define yesr {cout<<"YES"<<endl;return;}
#define nor {cout<<"NO"<<endl;return;}
ll MOD=1e9+7;
ll ceil1(ll n,ll x){return (n-1)/x+(n>0);}
ll gcd(ll a,ll b){return __gcd(a,b);}
ll lcm(ll a,ll b){return (max(a,b)/gcd(a,b))*min(a,b);}
ll pow1(ll n,ll m ,ll mod=MOD );
ll pow2(ll n,ll k);
ll modinv(ll n,ll mod=MOD){ return pow1(n,mod-2,mod);}
bool func(pair<ll,ll> &a,pair<ll,ll> &b ){
if(a.ff != b.ff)return a.ff < b.ff;
return a.ss > b.ss;
}
ll const N=(ll)3e2+11;
ll const LG=(ll)log2(N)+1;
void solve(){
ll i,j,k,l,n,m,x,y,z,r;
cin>>n>>m;
if(n<m){
cout<<0<<endl;
}else cout<<10<<endl;
}
int main(){
FS;
ll i,j,k,n,m,x,y,z,q;
q=1;
while(q--){
solve();
}
return 0;
}
ll pow1(ll n,ll m,ll mod){
if(m==0)return 1;
if(m%2==0)return pow1((n*n)%mod,m/2,mod);
return (pow1((n*n)%mod,m/2,mod)*n)%mod;
}
ll pow2(ll n,ll k){
ll ans=1;
while(k>0){
if(k%2==1)ans=ans*n;
n=n*n;
k/=2;
}
return ans;
}
| 0
| 40,538,454
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
ll N;
ll dp[100100];
int main() {
cin >> N;
vector<ll> v;
v.push_back(1);
int tmp = 6;
while (tmp <= N) {
v.push_back(tmp);
tmp *= 6;
}
tmp = 9;
while (tmp <= N) {
v.push_back(tmp);
tmp *= 9;
}
sort(v.begin(), v.end());
rep(i, 100100) dp[i] = INF;
dp[0] = 0;
rep(i, v.size()) {
for (int j = v[i]; j <= N; j++) {
dp[j] = min(dp[j], dp[j - v[i]] + 1);
}
}
cout << dp[N] << endl;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int n, m, e[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6}, le[10005], a[15];
bool v[10005];
string d[10005];
bool f(int p, int q) {
int i, t1, t2;
for (i = 0; i < d[p].size(); i++) {
t1 = d[p][i] - '0';
t2 = d[q][i] - '0';
if (t1 > t2) return 1;
if (t1 < t2) return 0;
}
return 1;
}
int main()
{
int i, j, z;
cin >> n >> m;
for (i = 0; i < m; i++) scanf ("%d", &a[i]);
sort(a, a + m);
v[0] = 1;
for (i = 1; i <= n; i++) {
for (j = 0; j < m; j++) {
z = i - e[a[j]];
if (z < 0 || !v[z]) continue;
if (le[i] < le[z] + 1 || le[i] == le[z] + 1 && f(z, i)) {
v[i] = 1;
d[i] = d[z];
le[i] = le[z] + 1;
d[i].push_back((char)(a[j] + '0'));
}
}
}
cout << d[n];
return 0;
}
| 0
| 9,925,769
|
#include <iostream>
#include <string.h>
using namespace std;
int main() {
char str1[101], str2[101];
int n, tp = 0, hp = 0;
cin >> n;
while (n--) {
cin >> str1 >> str2;
if (strcmp(str1, str2) > 0) {
tp += 3;
} else if (strcmp(str1, str2) < 0) {
hp += 3;
} else {
tp++; hp++;
}
}
cout << tp << ' ' << hp << endl;
return 0;
}
|
#include <iostream>
using namespace std;
void solve(std::string S){
bool ans = true;
int count = 0;
while (true) {
S.erase(S.end() - 1);
count++;
if (S.size() % 2) continue ;
int mid = S.size() / 2;
if (S.substr(0, mid) == S.substr(mid))
break ;
}
cout << S.size() << '\n';
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
std::string S;
std::cin >> S;
solve(S);
return 0;
}
| 0
| 85,251,128
|
#include <bits/stdc++.h>
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
int main() {
in(int, n, X);
vector<int> x(n);
rep(i, n) cin >> x[i];
int ans = abs(x[0] - X);
rep(i, n - 1) ans = gcd(ans, abs(x[i + 1] - X));
out(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<int, int> P;
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define Z class
template <typename T>
T square(T x) { return x * x; }
template <class T>
T GCD(T a, T b)
{
T r;
while (a)
r = b, b = a, a = r % a;
return b;
}
template <class T>
T LCM(T a, T b) { return a / GCD(a, b) * b; }
#define chmax(x, y) (x = max(x, y))
#define chmin(x, y) (x = min(x, y))
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repd(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (b); i--)
#define FORA(i, I) for (const auto &i : I)
#define ALL(x) x.begin(), x.end()
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<ll> vl;
#define ERASE(x) x.erase(unique(ALL(x)), x.end());
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T>
void MACRO_OUT(const T t) { std::cout << t; }
#define OUT(...) MACRO_OUT(__VA_ARGS__);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define ENDL std::cout << std::endl;
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define isYES(x) printf("%s\n", (x) ? "YES" : "NO")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define ln cout << '\n'
template <Z A>
void pr(A a)
{
cout << a;
ln;
}
template <Z A, Z B>
void pr(A a, B b)
{
cout << a << ' ';
}
int ans = 0;
bool check = 0;
string s, t;
int N = 3;
vector<int> v(N);
int a, b, c, d, n;
int x, y;
int sum;
char ch;
int main()
{
cin >> n >> y;
vs ss(n);
rep(i, n) cin >> ss[i];
sort(ALL(ss));
rep(i, n) cout << (ss[i]);
BR;
return 0;
}
| 0
| 24,070,058
|
#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)
#define all(a) (a).begin(),(a).end()
typedef long long ll;
typedef vector<int> vi;
typedef set<int> seti;
typedef vector<string> vs;
const int MOD = 1e9+7;
const int INF = 1e9;
int main() {
string S;
cin>>S;
int w;
cin>>w;
rep(i,S.size()){
if(i*w<=S.size()-1){
cout<<S[i*w];
}
}
cout<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100100100;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
struct Edge {
ll to;
ll cost;
};
int main() {
string S, T;
cin >> S >> T;
reverse(S.begin(), S.end());
reverse(T.begin(), T.end());
REP(i, S.size() - T.size() + 1) {
bool b = true;
REP(j, T.size()) {
if (S[i + j] == '?') continue;
if (S[i + j] != T[j]) b = false;
}
if (!b) continue;
string st = S;
REP(j, T.size()) { st[i + j] = T[j]; }
REP(j, st.size()) {
if (st[j] == '?') st[j] = 'a';
}
reverse(st.begin(), st.end());
cout << st << endl;
return 0;
}
cout << "UNRESTORABLE " << endl;
}
| 0
| 85,879,694
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
#define rep(i,N) for(int i=0;i<(int)(N);++i)
#define rrep(i,N) for(int i=(int)(N)-1;i>=0;--i)
#define debug(x) cout<<#x<<"="<<x<<endl;
constexpr ll MOD=1000000007;
constexpr ll INF=1LL<<60;
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return true;}return false;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return true;}return false;}
template<typename T> void fail(T v){cout << v << endl;exit(0);}
void solve(){
int N;
while((scanf("%d",&N),N)){
vector<int> imos(101010);
rep(i,N){
int a,b,c;
scanf("%d:%d:%d",&a,&b,&c);
imos[a*3600+b*60+c]++;
scanf("%d:%d:%d",&a,&b,&c);
imos[a*3600+b*60+c]--;
}
rep(i,101001)imos[i+1]+=imos[i];
printf("%d\n",*max_element(imos.begin(),imos.end()));
}
}
int main(){
solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
inline int read() {
int x(0),neg(1);char ch(getchar());
while(!isdigit(ch)) {
if (ch=='-') neg=-1;
ch=getchar();
}
while(isdigit(ch)) {
x=(x<<1)+(x<<3)+(ch^48);
ch=getchar();
}
return x*neg;
}
int vis[100005];
int n;
deque<pair<int,int> > q;
signed main() {
n=read();
q.push_front(make_pair(1,1));
while(!q.empty()) {
pair<int,int> p=q.front();
q.pop_front();
if(!vis[p.first]) {
vis[p.first]=1;
if(p.first==0) {
printf("%lld\n",p.second);
break;
}
q.push_front(make_pair((p.first*10)%n,p.second));
q.push_back(make_pair((p.first+1)%n,p.second+1));
}
}
return 0;
}
| 0
| 35,220,702
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
int ans = n * 800 - n / 15 * 200;
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <complex>
using namespace std;
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
#define REP(i,n) for(int i=0;i<n;i++)
#define pb push_back
template <class T>
ostream &operator<<(ostream &o, const vector<T> &v)
{
o << "{";
for (int i = 0; i < (int)v.size(); i++) o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
typedef complex<double> xy_t;
const double eps = 1e-11;
double cross_product(xy_t a, xy_t b) { return (conj(a)*b).imag(); }
double signed_area(xy_t v1, xy_t v2) {
return cross_product(v1, v2) / 2;
}
bool is_pararell(xy_t a, xy_t b, xy_t c, xy_t d) {
xy_t v1 = xy_t(b.real()-a.real(), b.imag()-a.imag());
xy_t v2 = xy_t(d.real()-c.real(), d.imag()-c.imag());
if (abs(signed_area(v1, v2)) < eps) return true;
else return false;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
vector<string> vs;
while(n--) {
double x1, x2, x3, x4;
double y1, y2, y3, y4;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
xy_t a = xy_t(x1, y1);
xy_t b = xy_t(x2, y2);
xy_t c = xy_t(x3, y3);
xy_t d = xy_t(x4, y4);
if (is_pararell(a, b, c, d)) vs.pb("YES");
else vs.pb("NO");
}
for (auto v:vs) {
if (v == "YES") YES;
else NO;
}
}
| 0
| 86,778,164
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long long n,b=0,c=0;
cin>>n;
long long a[n];
for(int i=0;i<n;i++) cin>>a[i];
for(int i=0;i<n-1;i++){
if(a[i]>a[i+1] || a[i]==a[i+1]){
b++;
c=max(b,c);
}
else b=0;
}
cout<<c<<endl;
}
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define res(i,n) for(int i=n;;i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define req(i,n,m) for(int i=n;i<m;i++)
#define REQ(i,n,m,l) for(int i=n;i<m;i+=l)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
signed gcd(long long x, long long y) {
if (y == 0)return x;
return gcd(y, x % y);
}
signed lcm(long long x, long long y) {
return x / gcd(x, y) * y;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main() {
int A, B, C, D; cin >> A >> B >> C >> D;
int ans = 0;
rep(i, 101)if (A <= i && B >= i && C <= i && D >= i)ans++;
cout << (ans!=0? ans-1:0) << endl;
}
| 0
| 12,415,782
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define FOR(i,a,b) for(int i=(a); i<=(b); i++)
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define chmin(a,b) if((a)>(b)) (a)=(b);
#define chmax(a,b) if((a)<(b)) (a)=(b);
#define vi vector<int>
#define pii pair<int,int>
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define pb push_back
#define pf push_front
int gcd(int a,int b){
while(min(a,b)>0){if(a<b)swap(a,b);a%=b;}return max(a,b);
}
int dx[]={1,0,-1,0,1,-1,-1,1};
int dy[]={0,1,0,-1,1,1,-1,-1};
const int MOD = 1e9+7;
const long long INF = 1e18+10;
signed main(){
int n;cin>>n;
int ans=0;
FOR(j,1,n){
int a=n/j;
ans+=a*(a+1)/2*j;
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define forn(i, a, b) for (int i = a; i <= b; ++i)
#define forr(i, a, b) for (int i = a; i >= b; --i)
using namespace std;
const int N = (int)2e5 + 7;
const long long INF = 1e15 + 7;
typedef long long ll;
typedef long double ld;
typedef pair < int, int > pii;
typedef pair < ll, ll > pll;
int n, a[N];
ll t[N * 4];
void build (int v, int tl, int tr){
if (tl == tr) t[v] = a[tl];
else {
int tm = tl + tr >> 1;
build (v * 2, tl, tm);
build (v * 2 + 1, tm + 1, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
}
}
ll get (int v, int tl, int tr, int l, int r){
if (tl > r || tr < l) return 0;
if (l <= tl && tr <= r) return t[v];
int mid = tl + tr >> 1;
return get (v + v, tl, mid, l, r) + get (v + v + 1, mid + 1, tr, l, r);
}
int main (){
scanf ("%d", &n);
forn (i, 1, n) scanf ("%d", a + i);
build (1, 1, n);
ll mn = INF;
forn (i, 1, n - 1){
ll cur = abs(get (1, 1, n, 1, i) - get (1, 1, n, i + 1, n));
mn = min(mn, cur);
}
printf ("%lld\n", mn);
return 0;
}
| 0
| 60,307,352
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
string S, T;
cin >> S >> T;
for (int i = 0; i < S.size(); i++)
{
if (S.at(i) != T.at(i))
{
cout << "No" << endl;
break;
}
else if (i < S.size() - 1)
{
continue;
}
else if (i == S.size() - 1)
{
cout << "Yes" << endl;
}
}
}
|
#include <vector>
#include <set>
#include <map>
#include <array>
#include <iostream>
#include <cstdio>
#include <cstdint>
#include <algorithm>
#include <numeric>
#include <bitset>
#include <iomanip>
using ll = long long;
using namespace std;
#define rep(i,n) for(ll i=0;i<(n);++i)
#define outD(fpv) cout << setprecision(20) << fpv << endl;
inline void yes(bool cond) { cond ? puts("Yes") : puts("No"); }
inline void YES(bool cond) { cond ? puts("YES") : puts("NO"); }
template<typename Type> inline void chmin(Type& a, Type b) { if (a > b) a = b; }
template<typename Type> inline void chmax(Type& a, Type b) { if (a < b) a = b; }
template<typename Arr, typename Type> inline void fill(Arr& arr, Type v) { fill(arr.begin(), arr.end(), v); }
template<typename Type> inline void sort(Type& arr){ sort(arr.begin(), arr.end()); }
template<typename Type> inline void reverse(Type& arr) { reverse(arr.begin(), arr.end()); }
template<typename Type> inline Type nth(vector<Type>& arr, size_t pos) { nth_element(arr.begin(), arr.begin() + pos, arr.end()); return arr[pos]; }
template<typename Type> inline void unique(Type& arr) { sort(arr); arr.erase(unique(arr.begin(), arr.end()), arr.end()); }
constexpr ll INF_I = numeric_limits<ll>::max();
constexpr ll BIGP = 1000000007L;
constexpr double INF_F = numeric_limits<float>::infinity();
constexpr double PI = 3.14159265358979323846L;
using P = pair<ll, ll>;
int main()
{
cin.tie(0); ios::sync_with_stdio(false);
ll N;
string S;
cin >> N >> S;
char pre = '_';
auto ite = remove_if(S.begin(), S.end(), [&](char ch)
{
bool r = (pre == ch);
pre = ch;
return r;
});
S.erase(ite, S.end());
cout << S.size();
return 0;
}
| 0
| 76,362,912
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
int h,w;
cin >> h >> w;
rep(i, h){
string c;
cin >> c;
cout << c << endl;
cout << c << endl;
}
}
|
#include <bits/stdc++.h>
#define uint uint64_t
#define mx 100001
#define ll long long int
#define ull unsigned long long int
#define pii pair<int, int>
#define pll pair<long long int, long long int>
#define mp make_pair
#define pb push_back
#define inf INT_MAX
#define pi acos(-1)
#define eps 1e-8
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a * b) / __gcd(a, b)
#define input(ara, n) \
for (int i = 0; i < n; i++) \
scanf("%d", &ara[i])
#define inputl(ara, n) \
for (long long int i = 0; i < n; i++) \
scanf("%lld", &ara[i])
#define pf(a) printf("%d\n", a);
#define pfl(a) printf("%lld\n", a);
#define pfi(a) printf("%d ", a);
#define pfll(a) printf("%lld ", a);
#define sc(a) scanf("%d", &a)
#define scc(a, b) scanf("%d %d", &a, &b)
#define sccdbl(a, b) scanf("%lf %lf", &a, &b)
#define sccc(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define scccdbl(a, b, c) scanf("%lf %lf %lf", &a, &b, &c)
#define scl(a) scanf("%lld", &a)
#define sccl(a, b) scanf("%lld %lld", &a, &b)
#define scccl(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
using namespace std;
int main()
{
int n;
sc(n);
int ara[n - 1], ar[n] = {0};
input(ara, n - 1);
ar[0] = ara[0];
ll sum = ara[0];
for (int i = 2; i < n; i++)
{
ar[i - 1] = min(ara[i - 2], ara[i - 1]);
sum += ar[i - 1];
}
sum += ara[n - 2];
pfl(sum);
return 0;
}
| 0
| 43,356,282
|
#include<iostream>
#include<string>
using namespace std;
int main(){
string S,T,S1;
int i,j,k,t=0;
cin>>S>>T;
S1=S;
for(i=0;i<S.size();i++){
for(j=0;j<S.size()-1;j++){
S1[j+1]=S[j];
}
S1[0]=S[S.size()-1];
S=S1;
if(S==T){
cout<<"Yes";
t=1;
break;
}
}
if(i==S.size()){
cout<<"No";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef vector<vector<long long>> VVL;
typedef pair<int,int> P;
typedef tuple<int,int,int> tpl;
#define ALL(a) (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define EXIST(m,v) (m).find((v)) != (m).end()
#define LB(a,x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a,x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)
#define en "\n"
constexpr double EPS = 1e-9;
constexpr double PI = 3.1415926535897932;
constexpr int INF = 2147483647;
constexpr long long LINF = 1LL<<60;
constexpr long long MOD = 1000000007;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
void Main(){
int N; cin >> N;
VI m(300000,0);
REP(_,N){
int a; cin >> a; a--;
m[a]++;
}
VI C;
for(int i : m){
if(i>0) C.push_back(i);
}
SORT(C);
int K = C.size();
VI D(C[K-1]);
for(int i : C){
REP(j,i) D[j]++;
}
REVERSE(D);
VL SC(K+1,0), SD(C[K-1]+1,0);
REP(i,K) SC[i+1] = SC[i] + C[i];
REP(i,C[K-1]) SD[i+1] = SD[i] + D[i]; REVERSE(SD);
int maxA = C[K-1];
for(ll i=1; i<N+1; i++){
while(i*maxA > SC[K]-SD[maxA]) maxA--;
int ans = (SC[K]-SD[maxA]) / i;
cout << ans << en;
}
return;
}
int main(void){
cin.tie(0);cout.tie(0);ios_base::sync_with_stdio(0);cout<<fixed<<setprecision(15);
int t=1;
REP(_,t) Main();
return 0;
}
| 0
| 80,024,756
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define rep2(i,a,n) for(int i=(a); i<(n); i++)
#define all(vec) vec.begin(),vec.end()
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
int main() {
string a,b,c; cin>>a>>b>>c;
if(a[a.size()-1] == b[0] && b[b.size()-1] == c[0]){
cout << "YES" << endl;
}
else cout << "NO" << endl;
}
|
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <climits>
using namespace std;
int main(){
int entr[6], i, count, menor = INT_MAX;
for(i = 0; i < 5; i++)cin >> entr[i];
sort(entr, entr+5);
do{
count = 0;
for(i = 0; i < 5; i++){
while(count%10 != 0)count++;
count += entr[i];
}
menor = min(menor, count);
}while(next_permutation(entr, entr+5));
cout << menor;
return 0;
}
| 0
| 21,539,887
|
#pragma region
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <list>
#include <iomanip>
#include <cstdint>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s) - 1; (i) >= 0; --(i))
#define all(x) x.begin(),x.end()
#pragma region UnionFind
struct UnionFind
{
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x)
{
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y)
{
return root(x) == root(y);
}
bool merge(int x, int y)
{
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x)
{
return -par[root(x)];
}
};
#pragma endregion
#pragma region GCD
ll gcd(ll a, ll b)
{
if (b == 0)return a;
return gcd(b, a%b);
}
#pragma endregion
#pragma region LCM
ll lcm(ll a, ll b)
{
return a / gcd(a, b) * b;
}
#pragma endregion
#pragma region chmin
template<class T> inline bool chmin(T& a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma region chmax
template<class T> inline bool chmax(T& a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma endregion
int main()
{
ll n; cin >> n;
vector<ll> div;
for (ll i = 2; i*i <= n; ++i)
{
if (n%i != 0)continue;
div.push_back(i);
if (n / i != i)div.push_back(n / i);
}
if (n != 1)div.push_back(n);
ll res = 0;
for (ll m : div)
{
--m;
if (n / m == n % m)res += m;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
#define ll long long int
#define MOD 1000000007
#define INF 1000000000000000000
using namespace std;
int main(void){
ll h, w;
cin >> h >> w;
vector<string> a(h);
for (int i = 0; i < h; i++){
cin >> a[i];
}
for (int i = 0; i < 201; i++){
for (int j = 0; j < h; j++){
int ok = 1;
for (int k = 0; k < w; k++){
if (a[j][k] == '#')
ok = 0;
}
if (ok){
h--;
for (int k = j; k < h; k++){
a[k] = a[k+1];
}
}
}
for (int j = 0; j < w; j++){
int ok = 1;
for (int k = 0; k < h; k++){
if (a[k][j] == '#')
ok = 0;
}
if (ok){
w--;
for (int k = j; k < w; k++){
for (int l = 0; l < h; l++){
a[l][k] = a[l][k+1];
}
}
}
}
}
for (int i = 0; i < h; i++){
for (int j = 0; j < w; j++){
cout << a[i][j];
}
cout << endl;
}
return 0;
}
| 0
| 925,819
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
while(true) {
int n;
scanf("%d", &n);
if (!n) break;
int m=0x7fffffff;
int M=-0x7fffffff;
int sum=0;
rep(i, n) {
int t;
scanf("%d",&t);
sum+=t;
if(m>t)m=t;
if(M<t)M=t;
}
sum-=m;
sum-=M;
printf("%d\n",sum/(n-2));
}
}
|
#include <bits/stdc++.h>
#include <vector>
#include <algorithm>
#include <math.h>
using namespace std;
int CalcSumOfDigit(int n);
string upper(string str);
string lower(string str);
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define pb push_back
#define sz(a) int((a).size())
#define rep(i,n) for(int(i)=0;(i)<(n);(i)++)
#define repe(i,n) for(int(i)=0;(i)<=(n);(i)++)
#define vsort(v) sort((v).begin(),(v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a,b) __gcd((a),(b))
#define LCM(a,b) (a)/GCD((a),(b))*(b)
const int INF = 1e9;
int main() {
int n,i;
cin >> n >> i;
cout << n - i + 1;
return 0;
}
int CalcSumOfDigit(int n)
{
int s = 0;
while(n)
{
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str)
{
for(auto itr = str.begin();itr != str.end() ; itr++)
{
if(97 <= *itr && *itr <= 122)
{
*itr = *itr - 32;
}
}
return str;
}
string lower(string str)
{
for(auto itr = str.begin();itr != str.end() ; itr++)
{
if(65 <= *itr && *itr <= 90)
{
*itr = *itr + 32;
}
}
return str;
}
| 0
| 56,913,011
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cassert>
#include <climits>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <fstream>
using namespace std;
#define SZ(x) (int)(x).size()
#define REP(i,n) for(int i=0;i<(n);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REPR(i,n) for(int i=(n)-1;i>=0;i--)
#define ALL(s) (s).begin(), (s).end()
#define so(V) sort(ALL(V))
#define rev(V) reverse(ALL(V))
#define uni(v) v.erase( unique(ALL(v)) , v.end());
typedef long long unsigned int llu;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<bool> vb;
const double EPS = 1e-9;
const int MOD = 1e9 + 7;
const int INF = (1 << 29);
const ll LINF = 1e18;
const double PI = acos(-1);
template<typename T>vector<T> make_v(size_t a) { return vector<T>(a); }
template<typename T, typename... Ts>auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...)); }
template<typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type
fill_v(U & u, const V... v) { u = U(v...); }
template<typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type
fill_v(U & u, const V... v) { for (auto& e : u) fill_v<T>(e, v...); }
template<class T> bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T& a, const T& b) { if (a > b) { a = b; return 1; } return 0; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<vector<char> > C;
C.push_back({ '.',',','!','?',' ' });
C.push_back({ 'a','b','c' });
C.push_back({ 'd','e','f' });
C.push_back({ 'g','h','i' });
C.push_back({ 'j','k','l' });
C.push_back({ 'm','n','o' });
C.push_back({ 'p','q','r','s' });
C.push_back({ 't','u','v' });
C.push_back({ 'w','x','y','z' });
int N;
cin >> N;
REP(i, N) {
string S;
cin >> S;
int ind = 0;
string ans = "";
while (ind < SZ(S)) {
char c = S[ind];
ind++;
if (c == '0') {
continue;
}
int cnt = 0;
while (S[ind] != '0') {
ind++;
cnt++;
}
ans += C[c - '1'][cnt % SZ(C[c-'1'])];
}
cout << ans << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long int;
#define rep(i,n) for(int i=0;i<(n);i++)
int main(){
string s;
string t;
cin>>s>>t;
map<char,set<char>>mps;
map<char,set<char>>mpt;
rep(i,s.size()){
mps[s[i]].insert(t[i]);
mpt[t[i]].insert(s[i]);
}
for(auto p: mps){
if(p.second.size()>1){
cout<<"No"<<endl;
return 0;
}
}
for(auto p: mpt){
if(p.second.size()>1){
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
}
| 0
| 25,087,901
|
#include<bits/stdc++.h>
#define mod 1000000007
#define ll long long int
#define ar array
#define mp make_pair
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin>>n;
int a[100001]={0};
multiset< int,greater<int > >s;
for(int i = 0 , j; i<n; i++)
{
cin>>j;
a[j]++;
}
for(int i =1;i<100001; i++)
if(a[i])
s.insert(a[i]);
sort(a, a+100001, greater<int>());
int up = 0, down =0;
for(int i = 0;i <100001;i++)
{
if(!a[i]) break;
up = a[i]/3+a[i]%3;
while(up>=3)
up = up/3+ up%3;
a[i]= up;
}
sort(a, a+100001, greater<int>());
int y = count(a,a+100001,2);
int h = count(a,a+100001,1);
if(y&1)
h--;
cout<<y+h<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long k;
cin >> n >> k;
vector<int> p(n);
vector<long> c(n);
for(int i=0;i<n;i++){
cin >> p[i];
}
for(int i=0;i<n;i++){
cin >> c[i];
}
long long ans = -10000000000;
for(int i=0;i<n;i++){
int now = p[i] -1;
long long l_s = 0;
long long tmp = 0;
vector<int> t;
t.push_back(c[now]);
l_s += c[now];
while(now !=i){
now = p[now]-1;
t.push_back(c[now]);
l_s += c[now];
}
for (int j=0;j<t.size();j++){
tmp += t[j];
if(j+1>k) break;
long long hoge = tmp;
if(l_s > 0){
long long e = (k-(j+1))/t.size();
hoge += l_s * e;
}
ans = max(ans,hoge);
}
}
cout << ans << endl;
return 0;
}
| 0
| 48,875,532
|
#include<bits/stdc++.h>
#ifdef LOCAL
#include "lib/debug.hpp"
#else
#define debug(...) 1
#endif
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define rep(i, n) REP(i, 0, (n))
#define repc(i, n) REPC(i, 0, (n))
#define REP(i, n, m) for (int i = (int)(n); i < (int)(m); i++)
#define REPC(i, n, m) for (int i = (int)(n); i <= (int)(m); i++)
#define REPCM(i, n, m) for (int i = (int)(n); i >= (int)(m); i--)
using namespace std;
using ll = long long;
using ld = long double;
using pr = pair<ll, ll>;
using vll = vector<ll>;
using vpr = vector<pr>;
using P = pair<int, int>;
template<class T> inline bool chmin(T& a, const T& b) { if (a > b) { a = b; return true; } else return false; }
template<class T> inline bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; } else return false; }
void answer() {
int w, h;
cin >> w >> h;
vector<ll> p(w + 1), q(h);
int pz, qz;
{
rep(i, w) cin >> p[i];
rep(i, h) cin >> q[i];
p[w] = 1e9;
sort(ALL(p));
sort(ALL(q));
pz = p.size();
qz = q.size();
}
ll ans = 0;
{
ll cur = 0;
int pi = 0;
rep(qi, qz) {
while (p[pi] < q[qi]) {
cur += p[pi++];
}
ans += cur + q[qi] * (w - pi + 1);
}
}
rep(pi, pz - 1) ans += p[pi];
cout << ans << '\n';
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
answer();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
using Graph = vector<vector<int>>;
using Edge = map<pair<int,int>,int>;
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
ll gcd(ll a,ll b){
if (a%b == 0) return(b);
else return(gcd(b, a%b));
}
ll lcm(ll a, ll b){
return a*b/gcd(a, b);
}
int main()
{
cout << fixed << setprecision(15);
ll N;
cin >> N;
ll ans = 0;
REP(i, N){
ll l,r;
cin >> l >> r;
ans += r-l+1;
}
cout << ans << endl;
return 0;
}
| 0
| 96,034,847
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
constexpr ll mod=1e9+7;
int main()
{
int a,b,c;
cin>>a>>b>>c;
cout<<(a+b>=c?"Yes":"No")<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define MOD 998244353
template<class T>inline bool chmax(T& a,T b){if (a<b){a=b;return 1;}return 0;}
template<class T>inline bool chmin(T& a,T b){if (a>b){a=b;return 1;}return 0;}
const long long INF = 1LL << 60;
bool pairCompare(const pair<double,ll>& firstElof, const pair<double,ll>& secondElof){
return firstElof.first < secondElof.first;
}
bool pairCompareSecond(const pair<double,ll>& firstElof, const pair<double,ll>& secondElof){
return firstElof.second < secondElof.second;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct edge{
ll from,to,cost;
};
typedef vector<vector<edge> > G;
ll gcd(ll a,ll b){
if (a%b==0)return(b);
else return(gcd(b,a%b));
}
ll n,m;
vector<vector<edge> > graph;
ll dp[105][105];
bool used[105][105];
void warshall_floyd(){
for (ll k=0;k<n;k++){
for (ll i=0;i<n;i++){
for (ll j=0;j<n;j++){
if (dp[i][j]>dp[i][k]+dp[k][j]){
dp[i][j]=dp[i][k]+dp[k][j];
}
}
}
}
}
vector<edge> dist;
int main() {
cin >> n >> m;
graph=G(n);
for (ll i=0;i<n;i++){
for (ll j=0;j<n;j++){
if (i==j){
dp[i][j]=0;
}else{
dp[i][j]=INF;
}
}
}
for (ll i=0;i<m;i++){
ll a,b,c;
cin >> a >> b >> c;
a--;
b--;
dp[a][b]=c;
dp[b][a]=c;
edge e;
e.from=a;
e.to=b;
e.cost=c;
dist.push_back(e);
e.from=b;
e.to=a;
e.cost=c;
dist.push_back(e);
}
warshall_floyd();
ll ans=0;
for (ll i=0;i<dist.size();i++){
bool flag=false;
for (ll j=0;j<n;j++){
for (ll k=0;k<n;k++){
if (dp[j][dist[i].from]+dist[i].cost+dp[dist[i].to][k]==dp[j][k]){
flag=true;
}
}
}
if (!(flag)){
ans++;
}
}
cout << ans/2 << endl;
return 0;
}
| 0
| 29,314,556
|
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <math.h>
#include <iomanip>
#include <bitset>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <utility>
#include <set>
#include <map>
using namespace std;
typedef long long int ll;
typedef long double ld;
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;
#define MOD 1000000007
#define MAX_V 100010
#define MAX_N 1000100
bool x[MAX_N];
ll num[MAX_N];
ll fibl[MAX_N]={0};
ll fib(ll a){
if (fibl[a]!=0)return fibl[a];
if (a==0){
return 0;
}else if (a==1){
return 1;
}
return fibl[a]=fib(a-1)+fib(a-2);
}
ll eratosthenes(ll n) {
int p = 0;
for (ll i=0; i<=n; ++i) x[i] = true;
x[0] = x[1] = false;
for(int i=2; i<=n; ++i) {
if(x[i]) {
p++;
for(int j=2*i; j<=n; j+=i) x[j] = false;
}
num[i] = p;
}
return p;
}
bool pairCompare(const pair<double,ll>& firstElof, const pair<double,ll>& secondElof){
return firstElof.second < secondElof.second;
}
ll gcd(ll a,ll b){
if (a%b==0)return(b);
else return(gcd(b,a%b));
}
ll junnretu(ll n){
ll ans=1;
for (ll i=1;i<=n;i++){
ans*=i;
}
return ans;
}
map<ll,ll> prime_factor(ll n){
map<ll,ll> mp;
for(ll i=2; i*i<=n; i++){
while(n % i == 0){
mp[i]++;
n /= i;
}
}
if(n != 1) mp[n] = 1;
return mp;
}
ll keta(ll N){
int tmp{};
while( N > 0 ){
tmp += ( N % 10 );
N /= 10;
}
N = tmp;
return N;
}
int main(){
ll a,b,c;
cin >> a >> b >> c;
if (c>=a && c<=b){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define f first
#define s second
#define endl '\n'
#define LL long long
#define pb push_back
#define sz(a) (int)a.size()
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define debug(x) cerr << #x << " is " << x << endl;
using namespace std;
int const MAXN = 2e6 + 9;
int main(){
ios_base::sync_with_stdio (0),cin.tie(0);
LL n;
cin >> n;
LL ans = 0;
vector<LL> div;
for (LL i = 1; i * i <= n; i++){
if (n % i == 0){
div.pb(i);
LL x = n / i;
if (x != i) div.pb(x);
}
}
for (auto c : div){
LL m = (n - c) / c;
if (m && n/m == n % m) ans+= m;
}
cout << ans;
}
| 0
| 20,405,353
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define fs first
#define fst first
#define sc second
#define snd second
#define sz(X) (int)(X).size()
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define fornr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define forab(i, a, b) for(int i = int(a); i < int(b); i++)
#define forabr(i, a, b) for(int i = int(b)-1; i >= int(a); i--)
#define all(X) X.begin(), X.end()
typedef long long ll;
typedef pair<int, int> pii;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef double dbl;
typedef long double ld;
typedef vector<int> vi;
const int N = 310;
const ll INF = 1e18;
ll dp[N][N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
n++;
vector<ll> a(n + 1);
forab(i, 1, n) cin >> a[i];
forn(i, N) forn(j, N) forn(l, N) dp[i][j][l] = INF;
dp[1][0][0] = 0;
forab(i, 1, n) {
forn(j, k + 1) {
forn(l, i) {
dp[i + 1][j][i] = min(dp[i + 1][j][i], dp[i][j][l] + max(a[i] - a[l], 0ll));
if (j < k) {
dp[i + 1][j + 1][l] = min(dp[i + 1][j + 1][l], dp[i][j][l]);
}
}
}
}
ll ans = INF;
forn(j, k + 1) forn(l, n) ans = min(ans, dp[n][j][l]);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#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 FORR(i, m, n) for (int i = (m); i >= (n); --i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const ll mod = 1000000007;
const ll mod2 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 1e18;
const ld EPS = 1e-10;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
int main() {
int n, k;
cin >> n >> k;
cout << n - k + 1 << endl;
return 0;
}
| 0
| 82,947,137
|
#include <bits/stdc++.h>
using namespace std;
#define ln '\n'
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (a); i <= (int)(b); ++i)
#define FORR(i, a, b) for (int i = (a); i >= (int)(b); --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
typedef vector<P> VP;
typedef vector<PL> VPL;
typedef vector<string> VS;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
map<string, ll> anal_cnt;
REP(i, n) {
string s;
cin >> s;
sort(ALL(s));
anal_cnt[s]++;
}
ll ans = 0;
for (auto& ac : anal_cnt) {
ans += ac.second * (ac.second - 1) / 2;
}
cout << ans << ln;
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <sstream>
#include <map>
#include <set>
#define REP(i,k,n) for(int i=k;i<n;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1<<30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main() {
int n, k;
while(cin >> n >> k) {
if(n == 0 && k == 0) break;
vector<int> v(n);
rep(i, n) cin >> v[i];
int l = v[0], a = 0;
rep(i, k) a += v[i];
ll ans = a;
REP(i, k, n) {
a -= l;
a += v[i];
ans = max(ans, (ll)a);
l = v[i - k + 1];
}
cout << ans << endl;
}
return 0;
}
| 0
| 74,653,267
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>
#include<complex>
#include<cfloat>
#include<cassert>
#define f first
#define s second
#define mp make_pair
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
#define EPS (1e-10)
using namespace std;
typedef unsigned int uint;
typedef long long ll;
typedef complex<double> P;
#define PI (3.1415926535)
#define EPS (1e-10)
int main(){
int n;
while(cin>>n){
ll f = 1ll;
do{
f *= n;
}while(--n!=0);
cout << f << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
vector<ll> a, p;
ll dfs(ll n, ll x) {
if (n == 0)
return x <= 0 ? 0 : 1;
else if (x <= a[n - 1] + 1)
return dfs(n - 1, x - 1);
else
return p[n - 1] + 1 + dfs(n - 1, x - 2 - a[n - 1]);
}
int main() {
ll n, x;
cin >> n >> x;
a.push_back(1), p.push_back(1);
rep(i, n) {
a.push_back(a[i] * 2 + 3);
p.push_back(p[i] * 2 + 1);
}
cout << dfs(n, x) << endl;
return 0;
}
| 0
| 92,935,820
|
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
int main() {
string S;
cin >> S;
string _S = "keyence";
int N = S.size();
int _N = _S.size();
for (int i = 0; i <= _N; ++i) {
if (_S.substr(0, i) == S.substr(0, i) && _S.substr(i) == S.substr(N - _N + i)) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
}
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
ll n;
cin >> n;
ll a;
vector<ll> b(100010);
for (int i=0;i<n;i++) {
cin >> a;
b[a]++;
}
ll k=0;
int r=0;
for (int i=0;i<100010;i++) {
if (b[i]>1) {
if (r==1) b[i]--;
k+=b[i]/2;
r=(b[i]+1)%2;
}
}
cout << n-2*k << endl;
}
| 0
| 71,722,464
|
#include <bits/stdc++.h>
using namespace std;
const int64_t INF=999999999;
int main() {
string s,t;
cin>>s>>t;
reverse(s.begin(),s.end());
if(s==t){cout<<"YES"<<endl;}
else{cout<<"NO"<<endl;}
return 0;}
|
#include<cstdio>
#include<iostream>
using namespace std;
int main(void){
long double x1,y1,x2,y2,x3,y3,x4,y4;
int n;
cin>>n;
for(int i=0;i<n;i++){
cin>>x1>>y1>>x2>>y2>>x3>>y3>>x4>>y4;
if(y2-y1==0){
if(y4-y3==0) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
else if((x2-x1)/(y2-y1)==(x4-x3)/(y4-y3)) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
}
| 0
| 19,920,467
|
#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int main(){
double x1,x2,y1,y2,d;
cin >> x1 >> y1 >> x2 >> y2;
d = sqrt(pow(x1-x2, 2) + pow(y1-y2, 2));
printf("%lf\n", d);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long n,k;
cin >> n >> k;
int a[n];
int i,j;
for(i=0;i<n;i++)cin>>a[i];
long ans = 0;
long const mod = 1e9+7;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
if(a[i]>a[j]){
if(i>j){
ans += k*(k-1)/2;
}else if(i<j){
ans += k*(k+1)/2;
}
}
ans %= mod;
}
}
cout<<ans<<endl;
}
| 0
| 39,432,518
|
#include <iostream>
using namespace std;
void test();
int interest(int debt, double interest_rate,int n);
int main(void)
{
test();
return 0;
}
void test()
{
long long debt;
int n;
debt = 100000;
cin >> n;
debt = interest(debt, 1.05, n) ;
cout << debt << endl;
}
int interest(int debt, double interest_rate,int n)
{
if (n == 1)
{
int intedebt = debt*interest_rate;
if((intedebt%1000) != 0)
return intedebt - intedebt%1000 + 1000;
else
{
return intedebt;
}
}
else
{
int func_intedebt = interest(debt, interest_rate, n - 1) * interest_rate;
if ((func_intedebt % 1000) != 0)
return func_intedebt - func_intedebt % 1000 + 1000;
else
return func_intedebt;
}
}
|
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<string>
#include<functional>
#include<queue>
#include<stack>
#include<math.h>
#define INF 999999
#define EPS 1.0e-6
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main()
{
int n, m;
int k = 0;
while (1) {
cin >> n;
if (n == 0)break;
char a, b;
map<char, char> mp;
for (int i = 0; i < n; i++) {
cin >> a >> b;
mp[a] = b;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a;
auto itr = mp.find(a);
if (itr != mp.end()) {
cout << mp[a];
}
else cout << a;
}
cout << endl;
}
return 0;
}
| 0
| 21,915,733
|
#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
int G[100][100] = {0};
queue<int> v;
void adjacent(int u, int k){
int j;
for(int i=0; i<k; i++){
j = v.front(); v.pop();
G[u-1][j-1] = 1;
}
}
int main(){
int n; cin >> n;
int u, k, num;
for(int i=0; i<n; i++){
cin >> u >> k;
for(int i=0; i<k; i++){
cin >> num;
v.push(num);
}
adjacent(u, k);
}
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(j != n-1){
cout << G[i][j] << " ";
}else{
cout << G[i][j];
}
}
cout << endl;
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define int long long
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define _GLIBCXX_DEBUG
int INF = 1e9+7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if(dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main(){
int N,M; cin>>N>>M;
vector<int>A(M);
vector<char>B(M);
vector<int>AC(N+1);
vector<int>WA(N+1);
rep(i,M){
string C;
cin>>A[i]>>C;
B[i]=C.at(0);
if(AC[A[i]]==1)continue;
if(B[i]=='A'){
AC[A[i]]++;
}
else{
WA[A[i]]++;
}
}
int ac=0;
int wa=0;
rep(i,N+1){
if(AC[i]){
ac+=AC[i];
wa+=WA[i];
}
}
cout<<ac<<" "<<wa<<endl;
}
| 0
| 56,978,097
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int,int>
#define fi first
#define sc second
#define all(x) (x).begin(),(x).end()
signed main() {
#ifdef _DEBUG
#endif
ios::sync_with_stdio(0); cin.tie(0);
int n;
cin >> n;
string o;
set<string> d;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
if ((i > 1 && o.back() != s.front()) || d.count(s)) {
cout << "No" << '\n';
return 0;
}
o = s;
d.insert(s);
}
cout << "Yes" << '\n';
}
|
#include <iostream>
using namespace std;
int main()
{
int a,n,b,c;
cin>>n>>a;
if(a*1>n)
{
cout<<"Yes";
}
else
{
if(n%500==0)
{
cout<<"Yes";
}
else if(n%500!=0&&a==0)
{
cout<<"No";
}
else if(n%500!=0)
{
b=n%500;
if(b*1<=a*1)
{
cout<<"Yes";
}
else if(b*1!=a*1)
{
cout<<"No";
}
}
}
}
| 0
| 69,589,642
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
template <class T>
using Graph = vector<vector<T>>;
const int MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string L;
cin >> L;
int len = L.length();
vector<vector<ll>> dp(len + 2, vector<ll>(2));
dp[0][1] = 1;
for (int i = 0; i <= len; ++i) {
bool n = L[i] - '0';
dp[i + 1][1] = (dp[i][1] * (n + 1)) % MOD;
dp[i + 1][0] = (dp[i][0] * 3 + dp[i][1] * n) % MOD;
}
cout << (dp[len][0] + dp[len][1]) % MOD << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mxn= 5e5+5;
#define mod 1000000007
#define endl '\n'
void rishabh(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main(){
rishabh();
int n;
cin>>n;
int arr[n],brr[n];
for(int i=0;i<n;i++){
cin>>arr[i];
brr[i]=arr[i];
}
sort(brr,brr+n);
for(int i=0;i<n;i++){
if(arr[i]==brr[n-1]){
cout<<brr[n-2]<<endl;
}
else cout<<brr[n-1]<<endl;
}
}
| 0
| 73,909,251
|
#include <iostream>
#include <string>
#include <stdio.h>
#include <cmath>
#include <cfloat>
#include <algorithm>
#include <functional>
#include <numeric>
#include <vector>
using namespace std;
const double PI=acos(-1);
int main(){
int a, b, m;
cin >> a >> b >> m;
vector<int> aa(a), bb(b);
int am = 999999, bm = 999999;
for(int i = 0; i < a; i++){
cin >> aa[i];
am = min(am, aa[i]);
}
for(int i = 0; i < b; i++){
cin >> bb[i];
bm = min(bm, bb[i]);
}
int mi = am + bm;
for(int i = 0; i < m; i++){
int xx, yy, c;
cin >> xx >> yy >> c;
mi = min(mi, aa[xx-1]+bb[yy-1]-c);
}
cout << mi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> ii;
typedef tuple<ll, ll, ll> iii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<iii> viii;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
#define REP(i,n) for (ll i = 0; i < n; ++i)
#define REPR(i,n) for (ll i = n-1; i >= 0; --i)
#define FOR(i,m,n) for (ll i = m; i < n; ++i)
#define FORR(i,m,n) for (ll i = n-1; i >= m; --i)
#define FORE(x,xs) for (const auto& x : xs)
#define ALL(v) v.begin(), v.end()
#define CHMIN(x,y) x = min(x, y)
#define CHMAX(x,y) x = max(x, y)
const char VACANT = 'V';
const char MALE = 'M';
const char FEMALE = 'F';
int ask(int n) {
cout << n << endl;
string s;
cin >> s;
if (s[0] == VACANT) exit(0);
if (s[0] == MALE) return 0;
return 1;
}
int N;
int solve() {
int edge_left, edge_right;
edge_left = edge_right = ask(N-1);
int left = 0, right = N-2;
while (right - left > 1) {
int mid = (left + right) / 2;
int res = ask(mid);
if (((edge_left^res)) ^ ((mid^left) & 1)) {
left = mid+1;
edge_left = res;
} else {
right = mid-1;
edge_right = res;
}
}
ask(left);
ask(right);
if (left > 0) ask(left-1);
ask(right+1);
}
int main() {
cin >> N;
cout << solve();
}
| 0
| 41,893,383
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for(int i = 0; i < n; i++)
#define all(a) a.begin(), a.end()
#define mod 1000000007
#define MOD 998244353
#define INF 40000000000000000
int dx8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
int dy8[8] = {1, 1, 1, 0, -1, -1, -1, 0};
int dx4[4] = {-1, 0, 1, 0};
int dy4[4] = {0, -1, 0, 1};
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;
}
signed main() {
char X, Y;
cin >> X >> Y;
if(X > Y)
cout << '>' << endl;
else if(X == Y)
cout << '=' << endl;
else
cout << '<' << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
int main(void){
int n,a,b; cin>>n>>a>>b;
int k;
int ans=0;
for(int i=1;i<=n;i++){
k=0;
int m=i;
while(m>0){
k+=m%10;
m=m/10;
}
if(a<=k&&k<=b){
ans+=i;
}
}
cout<<ans<<endl;
}
| 0
| 9,285,183
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <numeric>
using namespace std;
using ll = long long;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define input(...) __VA_ARGS__; in(__VA_ARGS__)
template<class T>
void print(vector<T> a) {
cout << "[ ";
REP(i, a.size()) cout << a[i] << " ";
cout << "]" << endl;
}
void print() {
std::cout << std::endl;
}
template <class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
std::cout << head << " ";
print(std::forward<Tail>(tail)...);
}
void in() { }
template <class Head, class... Tail>
void in(Head&& head, Tail&&... tail) {
cin >> head;
in(std::forward<Tail>(tail)...);
}
ll MOD = 1000000000 + 7;
int main() {
ll input(n, k);
vector<ll> a(n + 1);
REP(i, n + 1) a[i] = i;
vector<ll> cumsum(a.size() + 1, 0);
partial_sum(a.begin(), a.end(), cumsum.begin() + 1);
ll ans = 0;
FOR(i, k, n + 1) {
(ans += (cumsum[n + 1] - cumsum[n + 1 - i]) - cumsum[i] + 1) %= MOD;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1000000007;
typedef long long ll;
typedef unsigned long long ull;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
void primeFactorization(uint64_t a, list<uint64_t> &factors){
long i,sq;
if(a%2==0){
factors.push_back(2);
primeFactorization(a/2,factors);
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors);
return;
}
}
if(a!=1){
factors.push_back(a);
}
}
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
signed main() {
int n;
cin >> n;
ull a;
cin >> a;
ull gc = a;
for(int i=1;i<n;i++){
cin >> a;
gc = gcd(a,gc);
}
cout << gc << endl;
return 0;
}
| 0
| 24,466,288
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int> P;
int INF = 1e18;
int mod = 1e9+7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main() {
int N,K;
cin >> N >> K;
vector<int>V(N);
for(int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for(int i = 0; i <= min(N,K); i++) {
for(int j = 0; i+j <= min(N,K); j++) {
int cnt = 0;
vector<int>res = {};
for(int k = 0; k < i; k++) {
cnt += V[k];
if(V[k] < 0) {
res.push_back(V[k]);
}
}
for(int k = N-1; k >= N-j; k--) {
cnt += V[k];
if(V[k] < 0) {
res.push_back(V[k]);
}
}
sort(res.begin(),res.end());
for(int k = 0; k < res.size() && k < K-i-j; k++) {
cnt += abs(res[k]);
}
ans = max(ans,cnt);
}
}
cout << ans << endl;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
static int H[310];
long long initial = 0;
for(int i = 1; i <= N; i++) {
cin >> H[i];
if(H[i - 1] < H[i]) {
initial += H[i] - H[i - 1];
}
}
static long long flat[310][310];
for(int b = N; b >= 1; b--) {
for(int a = b; a >= 1; a--) {
const auto left = H[a - 1];
const auto right = H[b + 1];
const auto x = H[a];
int d = 0;
if(left > x && x < right) {
d = min(left, right) - x;
}
else if(left < x && x > right) {
d = x - max(left, right);
}
flat[a][b] = d + flat[a + 1][b];
}
}
static long long ans[310][310];
for(int k = 1; k <= K; k++) {
for(int a = N; a >= 1; a--) {
ans[a][k] = max(ans[a][k], ans[a + 1][k]);
const auto kl = min(k, N - a + 1);
for(int i = 1; i <= kl; i++) {
ans[a][k] = max(ans[a][k], ans[a + i + 1][k - i] + flat[a][a + i - 1]);
}
}
}
const auto result = initial - ans[1][K];
cout << result << endl;
return 0;
}
| 0
| 93,091,550
|
#include<stdio.h>
int main(void){
char a[20]={0};
int i;
scanf("%s",a);
for(i=19;i>=0;i--){
if(a[i] != 0){
printf("%c",a[i]);
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long int;
using P = std::pair<int, int>;
#define rep(i, n) for (int i = 0; i < n; ++i)
ll n;
ll cnt(ll x)
{
ll res = 0;
for (ll y = 1; y <= n / x; y *= x)
{
res += n / (y * x);
}
return res;
}
int main()
{
std::cin >> n;
if (n % 2)
{
std::cout << 0 << std::endl;
return 0;
}
n /= 2;
std::cout << std::min(cnt(2) + n, cnt(5)) << std::endl;
return 0;
}
| 0
| 29,887,021
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (long long i = 0; i < N; i++)
using ll = long long;
void solve(std::string S, std::string T) { cout << T + S << endl; }
int main() {
std::string S;
std::cin >> S;
std::string T;
std::cin >> T;
solve(S, T);
return 0;
}
|
#include <iostream>
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n;
while(cin>>n){
int ans=0;
for(int a=0; a<=9; a++){
for(int b=0; b<=9; b++){
for(int c=0; c<=9; c++){
int d=n-a-b-c;
if(0<=d&&d<=9) ++ans;
}
}
}
cout<<ans<<'\n';
}
return 0;
}
| 0
| 29,802,603
|
#include <bits/stdc++.h>
#define rep2(x,fr,to) for(int x=(fr);x<(to);x++)
#define rep(x,to) for(int x=0;x<(to);x++)
#define repr(x,fr,to) for(int x=(fr);x>=(to);x--)
#define all(c) c.begin(),c.end()
#define sz(v) (int)v.size()
using namespace std;
typedef long long ll; typedef vector<int> VI; typedef pair<ll,int> pii;
typedef vector<ll> VL; const int MD = (int)1e9 + 7;
void dbg(){ cerr << "\n"; } template <typename T,typename ...T2> void dbg(const T& fst, const T2&...rst){ cerr << fst << ": "; dbg(rst...); }
template <class T, class T2> void amax(T& a,T2 b){ if(a < b) a = b;}
int main()
{
cin.tie(0); ios_base::sync_with_stdio(false);
int n; ll k;
cin >>n >>k;
vector<VL> z = {{1, 0}};
rep(i, 50){
z.push_back({z.back()[0]*2+1, z.back()[1]*2+2});
}
auto f=[&](auto f, int rn, ll rx)-> ll{
if(rn ==0) return rx<=0? 0LL: 1LL;
else if( rx<=1 + z[rn-1][0] + z[rn-1][1]) return f(f, rn-1, rx-1);
else return z[rn-1][0] + 1LL + f(f, rn-1, rx-2-z[rn-1][0] - z[rn-1][1]);
};
cout << f(f, n, k) <<"\n";;
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<map>
#include<queue>
#include<algorithm>
#include<deque>
#include<string.h>
#define ll long long
using namespace std;
int main()
{
int n;
while(~scanf("%d",&n))
{
ll num[200005];
for(int i=0; i<n; i++)
scanf("%lld",&num[i]);
int r=0;
ll sum0 = 0,sum1 = 0,ans = 0;
for(int l=0; l<n; l++)
{
while((sum0^num[r])==(sum1+num[r])&&r<n)
{
sum0 ^= num[r];
sum1 += num[r++];
}
ans+=(r-l);
sum0 ^= num[l];
sum1 -= num[l];
}
printf("%lld\n",ans);
}
return 0;
}
| 0
| 59,175,586
|
#include <bits/stdc++.h>
#define s second
#define f first
#define pb push_back
#define endl '\n'
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
const int MOD = 1e9 + 7;
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int H, W;
cin >> H >> W;
char mp[H][W];
vector<vector<int>> DP(H, vector<int>(W,0));
for(int i = 0; i < H; i++) for(int j = 0; j < W; j++) cin >> mp[i][j];
DP[0][0] = 1;
for(int i = 0; i < H; i++){
for(int j = 0; j < W; j++){
if(mp[i][j] == '#') continue;
if(i + 1 < H) DP[i+1][j] = (DP[i+1][j] + DP[i][j]) % MOD;
if(j + 1 < W) DP[i][j+1] = (DP[i][j+1] + DP[i][j]) % MOD;
}
}
if(mp[H-1][W-1] == '#') DP[H-1][W-1] = 0;
cout << DP[H-1][W-1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1LL<<60;
ll GCD(ll x,ll y){
if(y == 0) return x;
else return GCD(y,x%y);
}
ll LCM(ll a,ll b){
return a / GCD(a,b) * b;
}
const int MOD = 1000000007;
int main() {
int n, m; cin >> n >> m;
vector<int> P(m), Y(m);
for (int i = 0; i < m; ++i) {
cin >> P[i] >> Y[i]; --P[i];
}
vector<vector<int> > vals(n);
for (int i = 0; i < m; ++i){
vals[P[i]].push_back(Y[i]);
}
for (int v = 0; v < n; ++v) {
sort(vals[v].begin(), vals[v].end());
}
for (int i = 0; i < m; ++i) {
int v = P[i];
printf("%06d", v + 1);
int id = lower_bound(vals[v].begin(), vals[v].end(), Y[i]) - vals[v].begin();
printf("%06d\n", id + 1);
}
}
| 0
| 32,038,254
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.