code1
stringlengths 54
12k
| code2
stringlengths 66
12k
| similar
int64 0
1
| __index_level_0__
int64 24
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define codefor int test;scanf("%d",&test);while(test--)
#define yn(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YN(ans) if(ans)printf("YES\n");else printf("NO\n")
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
const int MOD=1000000007;
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
vector<long long int> fibo(100001,-1);
long long int fibonatti(long long int n){
if(fibo[n]!=-1){
return fibo[n];
}else if(n==0){
fibo[0]=1;
return 1;
}else if(n==1){
fibo[1]=1;
return 1;
}else if(n>=2){
fibo[n]=(fibonatti(n-1)+fibonatti(n-2))%MOD;
return fibo[n];
}
}
int main(){
ll n,m;
in(n,m);
vector<int> vec(m);
in(vec);
fibonatti(100000);
vec.push_back(n+1);
ll target=0,ans=1;
rep(i,m+1){
if(i==0)target=vec[i]-1;
else target=vec[i]-vec[i-1]-2;
if(target==-1){
ans=0;
break;
}
ans*=fibo[target];
if(ans>MOD)ans%=(ll)MOD;
}
out(ans);
}
|
#define _LIBCPP_DEBUG 0
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=int(a);i<int(b);i++)
typedef vector<int> vi;
typedef long long ll;
int main(){
string s;cin>>s;
if(s=="zyxwvutsrqponmlkjihgfedcba"){
cout<<-1<<endl;
return 0;
}
int N=s.size();
if(N!=26){
cout<<s;
map<char,int> m;
for(char i='a';i<='z';i++){
m[i]=0;
}
rep(i,0,N){
m[s.at(i)]++;
}
for(auto it:m){
if(it.second==0){
cout<<it.first;
return 0;
}
}
}
else{
map<char,int> m;
rep(i,0,N){
m[s.at(i)]=i;
}
for(int i=25;i>=0;i--){
char tmp=s.at(i);
while(tmp<='z'){
tmp++;
if(m[tmp]>=i){
rep(j,0,i){
cout<<s.at(j);
}
cout<<tmp;
return 0;
}
}
}
}
}
| 0
| 51,930,151
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = 100000000;
#define rep1(i, n) for (ll i=0; i<(n); i++)
#define rep2(i, k, n) for (ll i=k; i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main() {
ll n;
cin >> n;
vector<ll> a(n+1), b(n);
rep1(i, n+1) cin >> a[i];
rep1(i, n) cin >> b[i];
ll ans = 0, cnt = 0;
rep1(i, n){
ans += min(a[i], b[i]);
b[i] -= a[i];
if (b[i] < 0) b[i] = 0;
ans += min(a[i+1], b[i]);
a[i+1] -= b[i];
if (a[i+1] < 0) a[i+1] = 0;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> a(n + 1);
for(int i = 1; i <= n; i++)
cin >> a[i];
int ans = 0;
for(int i = 1; i <= n; i++)
if (a[a[i]] == i)
ans++;
ans /= 2;
cout << ans << '\n';
return 0;
}
| 0
| 18,262,100
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
using Graph = vector<vector<int>>;
const int INT_INF = 1001001001;
int main(){
int n,k;
cin >> n >> k;
vector<int> L(n);
for(int i=0;i<n;i++){
cin >> L[i];
}
sort(L.begin(),L.end(),greater<int>());
int ans = 0;
for(int i=0;i<k;i++){
ans += L[i];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define ll long long
#define scf(n) scanf("%d",&n)
#define lscf(n) scanf("%lld",&n)
#define lpri(n) printf("%lld ",n)
#define pri(n) printf("%d ",(int)n)
#define prin(n) printf("%d\n",(int)n)
#define lprin(n) printf("%lld\n",n)
#define rep(i,ini,n) for(int i=ini;i<(int)n;i++)
#define pb push_back
#define pf push_front
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(),x.end()
#define tc int tt; scf(tt); while(tt--)
#define inf INT_MAX
#define ninf INT_MIN
#define gcd __gcd
#define bitcount(n) __builtin_popcount(n)
typedef double dd;
using namespace std;
const ll mod =1e9+7;
const int N = 1e6+7;
void my_dbg() { cout << endl; }
template<typename Arg, typename... Args> void my_dbg(Arg A, Args... B)
{ cout << ' ' << A; my_dbg(B...); }
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", my_dbg(__VA_ARGS__)
int main()
{
int n;
cin>>n;
int ctr=n;
rep(i,0,n+1)
{
int l=0,x=i,y=n-i;
while(x>0)
l+=x%6,x/=6;
while(y)
l+=y%9,y/=9;
ctr=min(ctr,l);
}
prin(ctr);
}
| 0
| 62,166,473
|
#include <iostream>
using namespace std;
int main () {
int N;
cin >> N;
int ans = 0;
for (int i = 1; i <= N; i += 2) {
int k = 0;
for (int j = 1; j <= N; ++j) {
if (i % j == 0) { k++; }
}
if (k == 8) {
ans++;
}
}
cout << ans << "\n";
}
|
#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;
}
| 0
| 95,343,391
|
#include <algorithm>
#include <iostream>
#include <vector>
#include <functional>
#include <string>
#include <cmath>
#include <iomanip>
using namespace std;
bool routecheck(vector<int>& perm, vector<vector<int>>& G,int n){
for (int i = 0; i < n-1; i++)
{
int& j = perm[i];
if(find(G[j].begin(),G[j].end(),perm[i+1]) == G[j].end()) return false;
}
return true;
}
int main() {
int n,m; cin >> n >> m;
vector<vector<int>> G(n);
for (int i = 0; i < m; i++)
{
int b,a; cin >> b >> a;
b--; a--;
G[b].push_back(a);
G[a].push_back(b);
}
vector<int> perm(n);
for (int i = 0; i < n; i++)
{
perm[i] = i;
}
int count=0;
do
{
if(routecheck(perm,G,n)) count++;
} while (next_permutation(perm.begin()+1,perm.end()));
cout << count << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MP make_pair
#define PB push_back
#define ALL(x) (x).begin(),(x).end()
#define REP(i,n) for(int i=0;i<(n);i++)
#define REP1(i,n) for(int i=1;i<(n);i++)
#define REP2(i,d,n) for(int i=(d);i<(n);i++)
#define RREP(i,n) for(int i=(n);i>=0;i--)
#define CLR(a) memset((a),0,sizeof(a))
#define MCLR(a) memset((a),-1,sizeof(a))
#define RANGE(x,y,maxX,maxY) (0 <= (x) && 0 <= (y) && (x) < (maxX) && (y) < (maxY))
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef vector<VI > VVI;
typedef vector<string> VS;
typedef vector<LL> VLL;
typedef pair<int,int> PII;
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-9;
const int DX[]={1,0,-1,0},DY[]={0,-1,0,1};
int main(){
int H, W;
cin >> H >> W;
REP(i, H) {
string s;
cin >> s;
cout << s << endl;
cout << s << endl;
}
return 0;
}
| 0
| 48,465,970
|
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int a;
int b;
int c;
void input() {
cin >> a;
cin >> b;
cin >> c;
}
int main() {
input();
if(a < b && b < c){
cout << "Yes" << endl;
} else{
cout << "No" << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N=100005;
int n,p[N],sz[N],U[N],V[N];ll tot,d[N];
map<ll,int>mp;vector<int>G[N];
inline bool cmp(int x,int y){return d[x]>d[y];}
void dfs(int x,int d){tot+=d;for(int i=0;i<G[x].size();i++)dfs(G[x][i],d+1);}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%lld",&d[i]),mp[d[i]]=i,sz[i]=1,p[i]=i;
sort(p+1,p+n+1,cmp);
for(int i=1;i<n;i++)
{
int x=p[i];ll w=d[x]-(n-sz[x])+sz[x];
if(!mp[w]||w>=d[x]){puts("-1");return 0;}
int y=mp[w];U[i]=x;V[i]=y;
sz[y]+=sz[x];G[y].push_back(x);
}
dfs(p[n],0);
if(tot!=d[p[n]]){puts("-1");return 0;}
for(int i=1;i<n;i++)printf("%d %d\n",U[i],V[i]);
return 0;
}
| 0
| 10,289,101
|
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <sstream>
#include <numeric>
#include <map>
#include <set>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
struct UnionFind {
std::vector<int> _parent;
std::vector<int> _size;
UnionFind(int size) : _parent(size, -1), _size(size, 1) { }
void unite(int a, int b) {
int ra = root(a), rb = root(b); if (ra == rb) { return; }
if (_size[ra] >= _size[rb]) { _parent[rb] = ra, _size[ra] += _size[rb]; } else { _parent[ra] = rb, _size[rb] += _size[ra]; }
}
int root(int a) {
int p = _parent[a];
if (p < 0) { return a; }
while (_parent[p] >= 0) { p = _parent[p]; }
return _parent[a] = p;
}
int size(int a) { return _size[root(a)]; }
};
void solve(long long N, long long Q, std::vector<long long> &t, std::vector<long long> &u, std::vector<long long> &v) {
UnionFind uf(N);
for (LL i = 0; i < Q; ++i) {
if (t[i] == 0) {
uf.unite(u[i], v[i]);
} else {
cout << (uf.root(u[i]) == uf.root(v[i])) << endl;
}
}
}
int main() {
long long N;
std::cin >> N;
long long Q;
std::cin >> Q;
std::vector<long long> t(Q);
std::vector<long long> u(Q);
std::vector<long long> v(Q);
for (int i = 0; i < Q; i++) {
std::cin >> t[i];
std::cin >> u[i];
std::cin >> v[i];
}
solve(N, Q, t, u, v);
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
using namespace std;
string win = "Alice";
string lose = "Brown";
long long X, Y;
int issente[210][210];
int naive(int a, int b) {
if (a <= 1 && b <= 1) return issente[a][b] = 0;
if (issente[a][b] != -1) return issente[a][b];
issente[a][b] = 0;
for (int sa = 1; sa * 2 <= a; ++sa) {
if (naive(a - sa*2, b + sa) == 0) issente[a][b] = 1;
}
for (int sb = 1; sb * 2 <= b; ++sb) {
if (naive(a + sb, b - sb*2) == 0) issente[a][b] = 1;
}
return issente[a][b];
}
string solve() {
if (X <= 1 && Y <= 1) return lose;
if (abs(X - Y ) <= 1) return lose;
return win;
}
int main() {
while (cin >> X >> Y) {
cout << solve() << endl;
}
}
| 0
| 80,770,519
|
#include<bits/stdc++.h>
typedef long long int lli;
typedef long double lld;
typedef long long ll;
#define vi vector<int>
#define vlli vector<long long int>
#define vvi vector<vector<int>>
#define vvlli vector<vector<long long int>>
#define ppi pair<int, int>
#define rppi pair<int, pair<int, int>>
#define lppi pair<pair<int, int>, int>
#define vppi vector<pair<int, int>>
#define sppi stack<pair<int int>>
#define qppi queue<pair<int, int>>
#define f first
#define s second
#define pb(x) push_back(x)
#define mkp(i, j) make_pair(i, j)
#define lmkp(i,j,k) make_pair(make_pair(i,j),k)
#define rmkp(i,j,k) make_pair(i,make_pair(j,k))
#define loop(i,n) for (i = 0; i < n; ++i)
#define loops(i,k,n) for (i = k; i <= n; ++i)
#define looprev(i,k,n) for (i = k; i >= n; --i)
#define inf (int)1e9
#define eps 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define prd(n) printf("%d", n)
#define prl(n) printf("%lld", n)
#define prdn(n) printf("%d\n", n)
#define prln(n) printf("%lld\n", n)
#define prf(n) printf("%f", n)
#define scd(n) scanf("%d", &n)
#define scd2(a, b) scanf("%d %d", &a, &b)
#define scd3(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define scl(n) scanf("%lld", &n)
#define scl2(a, b) scanf("%lld %lld", &a, &b)
#define scl3(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define scf(n) scanf("%f", &n)
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
lli i, j, k, n;
cin>>n>>k;
vi A(n+1);
loops(i, 1, n){
cin>>A[i];
}
int dp[n+1][k+1];
dp[0][0] = 1;
loops(i, 1, k){
dp[0][i] = 0;
}
loops(i, 1, n){
vi sum(k+1);
sum[0] = dp[i-1][0];
loops(j, 1, k){
sum[j] = (sum[j-1] + dp[i-1][j])%MOD;
}
loops(j, 0, k){
if(j <= A[i]){
dp[i][j] = sum[j];
}
else{
int ne = j-A[i]-1;
dp[i][j] = (sum[j]-sum[ne]+MOD)%MOD;
}
}
sum.clear();
}
cout<<dp[n][k]<<endl;
return 0;
}
|
#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
typedef pair<int, int> P;
typedef unsigned int ui;
int main(){
int n;
while (cin >> n) {
if (n == 0)break;
int a[1000] = {};
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int mi = (int)MOD;
for (int i = 0; i < n-1; i++) {
mi = min(mi, a[i + 1] - a[i]);
}
cout << mi << endl;
}
return 0;
}
| 0
| 24,760,681
|
#include<bits/stdc++.h>
using namespace std;
int main(void){
string s1,s2,s3;
cin>>s1>>s2>>s3;
char s=toupper(s1[0]);
char t=toupper(s2[0]);
char u=toupper(s3[0]);
cout<<s<<t<<u<<endl;
return 0;
}
|
#include <cstdio>
int main () {
int m, f, r;
while(true) {
scanf("%d %d %d", &m, &f, &r);
char rank = 'F';
if (m == -1 && f == -1 && r == -1) break;
int sum = m + f;
if (m == -1 || f == -1) {
rank = 'F';
} else if (80 <= sum) {
rank = 'A';
} else if (65 <= sum && sum < 80) {
rank = 'B';
} else if (50 <= sum && sum < 65) {
rank = 'C';
} else if (30 <= sum && sum < 50) {
rank = 'D';
if (50 <= r) rank = 'C';
} else if (sum < 30) {
rank = 'F';
}
printf("%c\n", rank);
}
return 0;
}
| 0
| 62,475,498
|
#include <bits/stdc++.h>
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#define pb push_back
#define mpr make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
#define ll long long
#define ld long double
#define fi first
#define se second
#define all(arr) arr.begin(), arr.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define fo(i, l, r) for (int i = l; i <= r; i++)
#define INF 1000000001
#define inf1 1000000000000000001
#define MOD 1000000007
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define N 200009
#define M 1e6 + 9
#define mid(l, r) l + (r - l) / 2
#define vec vector<int>
#define vecl vector<ll>
#define umap unordered_map<ll, ll>
#define yes cout << "Yes" << endl;
#define no cout << "No" << endl;
#define endl "\n"
#define int long long
using namespace std;
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
int ddx[8]={1,1,0,-1,-1,-1,0,1},ddy[8]={0,1,1,1,0,-1,-1,-1};
ll gcd(ll a,ll b){ if(!a)return b;return gcd(b%a,a);}
ll lcm(ll a, ll b) { return (a*b)/ gcd(a,b);}
void test_case()
{
int a , b;
cin>>a>>b;
int sum = 6;
cout<<sum-a-b<<endl;
}
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
int t = 1;
while (t--)
{
test_case();
}
}
|
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define vi vector<int>
#define vvi vector<vector<int>>
#define pi pair<int, int>
#define ALL(a) (a).begin(), (a).end()
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
constexpr ll MOD = 1e9 + 7;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
signed main() {
cin >> N >> K;
vi x(N), y(N);
REP(i, N) {
cin >> x[i] >> y[i];
}
vi xx = x, yy = y;
sort(ALL(xx));
sort(ALL(yy));
UNIQUE(xx);
UNIQUE(yy);
map<int, int> mpx, mpy;
REP(i, xx.size()) {
mpx[xx[i]] = i + 1;
}
REP(i, yy.size()) {
mpy[yy[i]] = i + 1;
}
W = x.size() + 1;
H = y.size() + 1;
vvi dp(H, vi(W));
REP(i, N) {
dp[mpy[y[i]]][mpx[x[i]]]++;
}
REP(h, H) {
REP(w, W - 1) {
dp[h][w + 1] += dp[h][w];
}
}
REP(w, W) {
REP(h, H - 1) {
dp[h + 1][w] += dp[h][w];
}
}
ans = LLINF;
REP(uh, H) {
REP(uw, W) {
FOR(dh, 0, uh - 1) {
FOR(dw, 0, uw - 1) {
if (dp[uh][uw] - dp[uh][dw] - dp[dh][uw] + dp[dh][dw] >= K) {
Y = yy[uh - 1] - yy[dh];
X = xx[uw - 1] - xx[dw];
ans = min(X * Y, ans);
dump(yy[uh - 1], xx[uw - 1], yy[dh], xx[dw], X, Y);
}
}
}
}
}
cout << ans << endl;
}
| 0
| 75,664,994
|
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cmath>
#define int long long
#define mod 1000000007
#define for0(i, n) for(int i = 0; i < (n); i++)
#define for1(i, n) for(int i = 1; i <= (n);i++)
#define mp make_pair
#define all(x) x.begin(),x.end()
using namespace std;
int n, sum;
int a[123456], b[123456];
bool t[123456];
signed main() {
cin >> n;
for1(i, n) cin >> a[i];
for1(i, n) {
cin >> b[i];
a[i] -= b[i];
sum += a[i];
}
if (sum < 0) { cout << "-1\n"; return 0; }
sort(a + 1, a + n + 1);
int p = n;
for1(i, n) {
while (a[i] < 0) {
t[i] = 1;
if (abs(a[i]) < a[p]) {
a[p] += a[i]; a[i] = 0; t[p] = 1;
}
else {
a[i] += a[p]; a[p] = 0; t[p] = 1; p--;
}
}
}
int ans = 0; for1(i, n)ans += t[i];
cout << ans << endl;
}
|
#include<bits/stdc++.h>
#include<string>
#include<cmath>
using namespace std;
#define ll long long int
#define ld long double
#define loop(i, n) for (int i = 0; i < n; i++)
#define loops(i, s, n) for (int i = s; i < n; i++)
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
#define deb(x) cout<< #x << '=' << x <<endl
#define MOD 1000000007
const int N = 1e5 + 5;
int n,m;
vector<int> b;
vector<int> adj[N];
int a[N];
int vis[N];
map<int,int> cnt;
void dfs(int u){
vis[u] = 1;
cnt[u]++;
cnt[a[u]]++;
b.pb(u);
for(auto v : adj[u]){
if(!vis[v]){
dfs(v);
}
}
}
void init(){
for(auto x : b){
if(cnt[x] == 2){
a[x] = x;
}
}
cnt.clear();
b.clear();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>n>>m;
for(int i = 1; i <= n; i++){
cin>>a[i];
}
for(int i = 0; i < m; i++){
int x , y;
cin>>x>>y;
adj[x].pb(y);
adj[y].pb(x);
}
int ans = 0;
for(int i = 1; i <= n; i++){
if(!vis[i]){
dfs(i);
init();
}
}
for(int i = 1; i <= n; i++){
if(a[i] == i){
ans++;
}
}
cout<<ans;
}
| 0
| 732,039
|
#include<bits/stdc++.h>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;
struct UnionFind{
vector<int> data;
UnionFind(int size) : data(size,-1){}
bool unite(int x,int y){
x=root(x),y=root(y);
if(x!=y){
if(data[y]<data[x]){
swap(x,y);
}
data[x]+=data[y],data[y]=x;
}
return x!=y;
}
bool find(int x,int y){
return root(x)==root(y);
}
int root(int x){
return data[x]<0 ? x : data[x]=root(data[x]);
}
int size(int x){
return -data[root(x)];
}
};
int main(){
int n,q;
scanf("%d %d",&n,&q);
UnionFind uf(n);
for(int i=0;i<q;i++){
int c,x,y;
scanf("%d %d %d",&c,&x,&y);
if(c!=0){
if(uf.find(x,y)){
printf("%d\n",1);
}else{
printf("%d\n",0);
}
}else{
uf.unite(x,y);
}
}
return 0;
}
|
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <map>
#include <set>
#include <stack>
#include <queue>
using namespace std;
#define pb(n) push_back(n)
#define mp(n,m) make_pair(n,m)
#define fi first
#define se second
#define all(r) (r).begin(),(r).end()
#define REP(i,s,e) for(int i=(s); i<(e); i++)
#define rep(i,n) REP(i,0,n)
#define REPE(i,s,e) for(int i=s; i>e; i--)
#define repe(i,n) REPE(i,n,-1)
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<vi> vvi;
const int IMAX=((1<<30)-1)*2+1;
const int INF=100000000;
const double EPS=1e-10;
string mcxi="mcxi";
int dig[4]={1000,100,10,1};
string toMCXI(int n){
string ret="";
rep(i,4){
if(n%10!=0) ret+=mcxi[mcxi.size()-1-i];
if(n%10>1) ret+=(char)('0'+(n % 10));
n/=10;
}
reverse(all(ret));
return ret;
}
int fromMCXI(string s){
int ret=0;
rep(i,s.size()){
int t=1;
if(s[i]>='2'&&s[i]<='9') t+=s[i]-'1',i++;
rep(j,4) {
if(s[i]==mcxi[j]) {
t*=dig[j];
break;
}
}
ret+=t;
}
return ret;
}
int main(){
int n;
cin>>n;
string s,t;
rep(i,n){
cin>>s>>t;
cout<<toMCXI(fromMCXI(s)+fromMCXI(t))<<endl;
}
}
| 0
| 61,470,723
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
int main() {
int n;
cin >> n;
vs s(n);
rep(i, n) {
cin >> s[i];
}
int ans = 0;
rep(i_, n) {
bool x = true;
rep(i, n) {
rep(j, i) {
if(s[(i + i_)%n][j] != s[(j + i_)%n][i]) {
x = false;
break;
}
}
if(!x) break;
}
if(x) ++ans;
}
cout << ans*n << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, N) for (ll i = 0; i < N; i++)
#define rep1(i, N) for (ll i = 1; i <= N; i++)
#define repr(i, N) for (ll i = N-1; i >= 0; i--)
#define repr1(i, N) for (ll i = N; i > 0; i--)
#define INF 1000000007
using ll = long long;
using namespace std;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<P> vpi;
int main() {
ll N,M,ans = 0;
cin >> N >> M;
if(N >= M/2)
ans = M/2;
else{
ans = N;
M -= 2*N;
ans += M/4;
}
cout << ans;
cout << "\n";
return 0;
}
| 0
| 33,126,000
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define MAXN 1000001
ll spf[MAXN];
void sieve()
{
}
int main(){
ll n;
cin>>n;
ll ar[n];
ll *count = new ll[MAXN]();
for(int i=0;i<n;i++){
cin>>ar[i];
count[ar[i]]++;
}
int ans=0;
bool *visited = new bool[MAXN]();
for(int i=1;i<MAXN;i++){
if(count[i]==0||visited[i]){
continue;
}
if(count[i]==1&&!visited[i]){
ans++;
}
for(int j=i;j<MAXN;j+=i){
visited[j] = true;
}
}
cout<<ans;
return 0;
}
|
#include<bits/stdc++.h>
#ifdef _PRINTDEBUG
#include "lib/printdebug.hpp"
#else
#define printdebug(...) 1
#endif
#define MOD_1_000_000_007 (1000000007)
#define IINF (1<<28)
#define LINF (1LL<<60)
#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--)
#define yesno(cond) YESNO((cond), "Yes", "No")
#define YESNO(cond, a, b) cout << ((cond) ? (a) : (b)) << "\n"
namespace solver {
using namespace std;
typedef long long ll;
int N, M;
vector<tuple<int, int, int, int> > vec;
void init() {
cin >> N >> M;
int P, Y;
rep(i, M) {
cin >> P >> Y;
vec.push_back(make_tuple(P, Y, i, 0));
}
}
void solve() {
sort(vec.begin(), vec.end());
int past = 0, cur = 0;
for(auto& v : vec) {
if(past < get<0>(v)) {
past = get<0>(v);
cur = 1;
} else {
cur++;
}
get<3>(v) = cur;
}
sort(vec.begin(), vec.end(), [](const auto& lhs, const auto& rhs) { return get<2>(lhs) < get<2>(rhs); });
cout << setfill('0') << right;
for(auto& v : vec) {
cout << setw(6) << get<0>(v) << setw(6) << get<3>(v) << "\n";
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
solver::init();
solver::solve();
return 0;
}
| 0
| 78,663,285
|
#include <bits/stdc++.h>
#define F first
#define S second
#define MP make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define LCM(a, b) (a) / __gcd((a), (b)) * (b)
#define CEIL(a, b) (a)/(b)+(((a)%(b))?1:0)
#define log_2(a) (log((a)) / log(2))
#define ln '\n'
using namespace std;
using LL = long long;
using ldouble = long double;
using P = pair<int, int>;
using LP = pair<LL, LL>;
static const int INF = INT_MAX;
static const LL LINF = LLONG_MAX;
static const int MIN = INT_MIN;
static const LL LMIN = LLONG_MIN;
static const int MOD = 1e9 + 7;
static const int SIZE = 105;
const int dx[] = {0, -1, 1, 0};
const int dy[] = {-1, 0, 0, 1};
vector<LL> Div(LL n) {
vector<LL> ret;
for(LL i = 1; i * i <= n; ++i) {
if(n % i == 0) {
ret.pb(i);
if(i * i != n) ret.pb(n / i);
}
}
sort(all(ret));
return ret;
}
int graph[SIZE][SIZE];
void WarshallFloyd(int N) {
for( int k = 0; k < N; ++k ) {
for( int i = 0; i < N; ++i ) {
for( int j = 0; j < N; ++j ) {
if( graph[i][k] == INF || graph[k][j] == INF ) {
continue;
}
graph[i][j] = min( graph[i][j],
graph[i][k] + graph[k][j] );
}
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
for(int i = 0; i < N; ++i) {
for(int j = i + 1; j < N; ++j) {
graph[i][j] = graph[j][i] = INF;
}
}
vector<pair<P, int>> e(M);
for(int i = 0; i < M; ++i) {
cin >> e[i].F.F >> e[i].F.S >> e[i].S;
--e[i].F.F;
--e[i].F.S;
graph[e[i].F.F][e[i].F.S] = e[i].S;
graph[e[i].F.S][e[i].F.F] = e[i].S;
}
WarshallFloyd(N);
int res = 0;
for(pair<P, int> edge : e) {
if(graph[edge.F.F][edge.F.S] != edge.S) {
++res;
}
}
cout << res << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <cstring>
#include <unordered_map>
#include <queue>
#define mod 998244353
#define int long long
#define ld long double
#define pb push_back
#define vi vector<int>
#define dbg(x) cerr << #x << " = " << x << '\n'
#define sz(x) (int)x.size()
#define ff first
#define ss second
#define pii pair<int,int>
using namespace std;
inline void solve(){
int n,a=2,b=1,ans=2;
cin >> n;
for (int i=1;i<=n+1;i++){
if (i==1) ans=2;
else if (i==2) ans=1;
else {
ans = a+b;
a=b,b=ans;
}
}
cout << ans << endl;
}
signed main()
{
int n=1;
while (n--) solve();
return 0;
}
| 0
| 23,033,351
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
using namespace std;
using ll = long long;
using d = double;
int main(){
int n,k;
cin >> n >> k;
int a[n] = {0};
rep(i,k){
int d;
cin >> d;
rep(j,d){
int s;
cin >> s;
if(a[s-1]==0)++a[s-1];
}
}
int ans=0;
rep(i,n){
if(a[i]==0)++ans;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int c[20], dp[50001];
int main() {
scanf("%d%d",&n,&m);
for (int i=0; i<m; i++) scanf("%d", &c[i]);
sort(c, c+m);
for (int i=1; i<=n; i++) {
dp[i] = dp[i-c[0]]+1;
for (int j=1; j<m; j++) {
if (i < c[j]) break;
dp[i] = min(dp[i], dp[i-c[j]]+1);
}
}
printf("%d\n",dp[n]);
}
| 0
| 45,424,803
|
#include <bits/stdc++.h>
#define MODNum 1000000007
#define REP(type, i, a, b) for( type i = a; i < b; i++ )
typedef long long ll;
using namespace std;
int main (void) {
int N, R, ans;
cin >> N >> R;
if ( N < 10 ) cout << R + 100 * ( 10 - N ) << endl;
else cout << R << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int MAXN=2e4;
const int bias=1e4;
bool dp[2][MAXN];
char s[10000];
vector<int> h,v;
int main()
{
while(scanf("%s",s+1)!=EOF)
{
int x,y;
scanf("%d%d",&x,&y);
memset(dp,false,sizeof(dp));
int len=strlen(s+1);
h.clear();v.clear();
int first=0;
int p=1;
while(p<=len&&s[p]=='F') {first++;p++;}
dp[0][first+bias]=true;
p++;
bool horizontal=false;
int tmp=0;
for(;p<=len;p++)
{
tmp=0;
while(s[p]=='F'&&p<=len)
{
tmp++;
p++;
}
if(horizontal&&tmp) h.push_back(tmp);
else if(tmp) v.push_back(tmp);
horizontal=!horizontal;
}
int now=0;
for(auto i:h)
{
now^=1;
for(int j=0;j<=MAXN;j++)
{
if(dp[now^1][j])
{
dp[now][j+i]=true;
dp[now][j-i]=true;
}
}
for(int j=0;j<=MAXN;j++)
dp[now^1][j]=false;
}
if(!dp[now][bias+x])
{
cout<<"No"<<endl;
}else
{
memset(dp,false,sizeof(dp));
dp[0][0+bias]=true;
int now=0;
for(auto i:v)
{
now^=1;
for(int j=0;j<=MAXN;j++)
{
if(dp[now^1][j])
{
dp[now][j+i]=true;
dp[now][j-i]=true;
}
}
for(int j=0;j<=MAXN;j++)
dp[now^1][j]=false;
}
if(!dp[now][y+bias])
cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
}
return 0;
}
| 0
| 75,519,620
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define rrep(i,n) for(int (i)=((n)-1);(i)>=0;(i)--)
#define itn int
#define all(x) (x).begin(),(x).end()
const long long INF = 1LL << 60;
const int MOD = 1000000007;
#define F first
#define S second
signed main(void){
int h,w; cin>>w>>h;
priority_queue <pair <int,int>, vector <pair <int,int> >, greater<pair <int,int> >> pq;
int ver = h+1, hor = w+1;
int ans = 0;
rep(i,w){
int a; cin>>a;
pq.push({a,0});
}
rep(i,h){
int a; cin>>a;
pq.push({a,1});
}
while(!pq.empty()){
auto tmp = pq.top(); pq.pop();
if(tmp.S){
ans += hor*tmp.F; ver--;
}else{
ans += ver*tmp.F; hor--;
}
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <stdio.h>
#define MAX 100005
#define NIL -1
struct Node {
int parent, left, right;
};
Node T[MAX];
int n, D[MAX];
void rec(int u, int p) {
D[u] = p;
if (T[u].right != NIL) rec(T[u].right, p);
if (T[u].left != NIL) rec(T[u].left, p+1);
}
void printChildren (int id) {
printf("node %d: parent = %d, depth = %d, ", id, T[id].parent, D[id]);
if (T[id].left != NIL || T[id].parent == NIL) {
if (T[id].parent == NIL) printf("root, [");
else printf("internal node, [");
int pri_ch = T[id].left;
while (pri_ch != NIL) {
printf("%d", pri_ch);
pri_ch = T[pri_ch].right;
if (pri_ch != NIL) printf(", ");
}
printf("]");
} else {
printf("leaf, []");
}
printf("\n");
}
int main() {
int id;
int num_ch;
int ch_id;
int left = 0;
int root = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) T[i].parent = T[i].left = T[i].right = NIL;
for (int i = 0; i < n; i++) {
scanf("%d %d", &id, &num_ch);
for (int j = 0; j < num_ch; j++) {
scanf("%d", &ch_id);
if(j==0) T[id].left = ch_id;
else T[left].right = ch_id;
left = ch_id;
T[ch_id].parent = id;
}
}
for (int i = 0; i < n; i++) {
if (T[i].parent == NIL) root = i;
}
rec(root, 0);
for (int i = 0; i < n; i++) {
printChildren(i);
}
return 0;
}
| 0
| 25,869,762
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
int x, y, z;
x = y = z = 0;
for (int i = 0; i < N; i++) {
int p;
cin >> p;
if (p <= A) {
x++;
} else if (p <= B) {
y++;
} else {
z++;
}
}
int ans;
ans = min(x, min(y, z));
cout << ans << '\n';
return 0;
}
|
#include <iostream>
#include <map>
#include <unordered_map>
#include <set>
#include <utility>
#include <stack>
#include <cstdio>
#include <string>
#include <cmath>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
#include <iterator>
#include <sstream>
#define popcount(x) __builtin_popcount(x)
#define oddparity(x) __builtin_parity(x)
#define clz(x) __builtin_clz(x)
#define ctz(x) __builtin_ctz(x)
#define sf scanf
#define pf printf
#define ll long long int
using namespace std;
int i, a, b, c;
bool flag[101];
int main()
{
sf("%d%d%d", &a, &b, &c);
for (i = 0; ; i += a) {
if ( (a + i) % b == c) {
pf("YES\n");
return 0;
}
else if (flag[(a + i) % b] == false) {
flag[(a + i) % b] = true;
}
else {
pf("NO\n");
return 0;
}
}
return 0;
}
| 0
| 81,191,671
|
#include<bits/stdc++.h>
using namespace std;
int k,a[100001],a1,b[2000001],b1=1,b2=9;
int main()
{
memset(a,0x3f,sizeof(a));
scanf("%d",&k);
for(int i=1;i<10;i++)b[i]=a[i]=i;
while(b1<=b2)
{
for(int i=0;i<10;i++)if(a[(b[b1]*10+i)%k]>a[b[b1]]+i)a[b[++b2]=(b[b1]*10+i)%k]=a[b[b1]]+i;
++b1;
}
printf("%d",a[0]);
return 0;
}
|
#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;
vector<double> t;
vector<double> v;
vector<double> t_sum;
double ans;
int main() {
int N; cin >> N;
t.assign(N,0);
v.assign(N,0);
t_sum.assign(N+1,0);
REP(i,N) cin >> t[i];
REP(i,N) cin >> v[i];
REP(i,N) t_sum[i+1] += t_sum[i] + t[i];
ans = 0.0;
vector<double> dx;
for(double x = 0.0; x<=t_sum[N]; x+=0.5){
int itr = upper_bound(ALL(t_sum), x) - t_sum.begin()-1;
double num = INF;
REP(i,N){
if(i<itr){
num = min(num, v[i]-t_sum[i+1]+x);
}else if(i==itr){
num = min(num, v[i]);
}else{
num = min(num, v[i]+t_sum[i]-x);
}
num = min(num, x);
num = min(num, t_sum[N]-x);
}
dx.push_back(num);
}
REP(d,dx.size()-1){
ans += (dx[d] + dx[d+1])/4.0;
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 0
| 79,227,327
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
struct edge{long long to,cost;};
const int inf = 1 << 27;
const long long INF = 1LL << 60;
const int COMBMAX = 1001001;
const long long MOD = 1000000007;
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define eachdo(v, e) for(const auto& e : (v))
#define all(v) (v).begin(), (v).end()
#define lower_index(v, e) (long long)distance((v).begin(), lower_bound((v).begin(), (v).end(), e))
#define upper_index(v, e) (long long)distance((v).begin(), upper_bound((v).begin(), (v).end(), e))
long long mpow(long long a, long long n, long long mod = MOD){long long res = 1; while(n > 0){if(n & 1)res = res * a % mod; a = a * a % mod; n >>= 1;} return res;}
void yn(bool j){cout << (j ? "Yes" : "No") << endl; return;}
template<class Head> void pt(Head&& head){cout << head << endl; return;}
template<class Head, class... Tail> void pt(Head&& head, Tail&&... tail){cout << head << " "; pt(forward<Tail>(tail)...);}
template<class T> void debug(T v){rep(i, v.size()) cout << v[i] << " " ; cout << endl;}
template<class T> void debug2(T v){rep(i, v.size()){rep(j, v[i].size()) cout << v[i][j] << " " ; cout << endl;}}
template<class T1, class T2> long long bcount(T1 v, T2 a){return upper_index(v, a) - lower_index(v, a);}
template<class T1, class T2> inline bool chmin(T1 &a, T2 b){if(a > b){a = b; return true;} return false;}
template<class T1, class T2> inline bool chmax(T1 &a, T2 b){if(a < b){a = b; return true;} return false;}
template<class T1, class T2> void sortTwoVecter(vector<T1> &f, vector<T2> &s, bool isReverse = false){
vector<pair<T1, T2>> p;
rep(i, f.size()) p.emplace_back(make_pair(f[i], s[i]));
if (!isReverse) sort(p.begin(), p.end());
else sort(p.rbegin(), p.rend());
rep(i, f.size()) tie(f[i], s[i]) = p[i];
return;
}
int main(){
string S; cin >> S;
ll N = S.size();
ll ans = (N * (N + 1)) / 2 + 1;
vector<ll> cnt(26, 0);
rep(i, N) cnt[S[i] - 'a']++;
rep(i, 26) ans -= (cnt[i] * (cnt[i] + 1)) / 2;
pt(ans);
}
|
#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<vector>
#include<map>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
char A[60][60];
char B[60][60];
for(int i = 0; i < N; i++){
for(int j = 0; j < N; j++){
cin >> A[i][j];
}
}
for(int i = 0; i < M; i++){
for(int j = 0; j < M; j++){
cin >> B[i][j];
}
}
bool exist = false;
for(int ly = 0; ly < N; ++ly){
for(int lx = 0; lx < N; ++lx){
if(ly + M - 1 >= N || lx + M -1 >= N) continue;
bool match = true;
for(int y = 0; y < M; y++){
for(int x = 0; x < M; x++){
if(A[ly+y][lx+x] != B[y][x]) match = false;
}
}
if(match) exist = true;
}
}
if(exist)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 0
| 27,173,735
|
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
ll n, h, w, a, b, ans;
int main() {
cin >> n >> h >> w;
while(n--) {
cin >> a >> b;
ans += (a>=h && b>=w);
}
cout << ans;
return 0;
}
|
# include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn(1e5 + 5);
int n, a[maxn];
ll sum, cur, x, v[maxn];
int main() {
int i;
scanf("%d", &n);
if (n == 1) return puts("YES"), 0;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]), sum += a[i];
cur = (ll)n * (n + 1) / 2;
if (sum % cur) return puts("NO"), 0;
sum /= cur, a[0] = a[n], cur = 0;
for (i = 1; i <= n; ++i) {
if ((a[i - 1] + sum - a[i]) % n) return puts("NO"), 0;
x = (a[i - 1] + sum - a[i]) / n;
if (x < 0) return puts("NO"), 0;
cur += x;
}
if (cur != sum) return puts("NO"), 0;
return puts("YES"), 0;
}
| 0
| 45,206,944
|
#include<iostream>
#include<string.h>
#include<string>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<utility>
#include<set>
#define ll long long int
#define ld long double
#define INF 1000000000
#define EPS 0.0000000001
#define rep(i,n) for(i=0;i<n;i++)
using namespace std;
typedef pair<int, int> pii;
int main()
{
int m,nmin,nmax;
int i,j;
while(true){
cin>>m>>nmin>>nmax;
if(m==0 && nmin==0 && nmax==0)break;
int score[200]={};
rep(i,m)
cin>>score[i];
rep(i,m-1)
score[i]-=score[i+1];
pii p[200]={};
int n=0;
for(i=nmin-1;i<=nmax-1;i++){
p[n].first=score[i];
p[n].second=i+1;
n++;
}
int num=nmax-nmin+1;
sort(p,p+num);
cout<<p[num-1].second<<endl;
}
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<ll> Vl;
typedef vector<int> Vi;
typedef pair<int, int> Pi;
#define INF (1e9+7)
#define MAX_V (10)
#define MAX_E (45)
#define MAX_C (100)
int V, E;
int D[MAX_V][MAX_V];
void warshall_floyd() {
for (size_t u = 0; u < V; u++)
for (size_t v = 0; v < V; v++)
for (size_t w = 0; w < V; w++) D[u][v] = D[v][u] = min(D[u][v], D[u][w] + D[w][v]);
}
void solve() {
int ans_c, ans_d = INF;
warshall_floyd();
for (size_t v = 0; v < V; v++) {
int cost = 0;
for (size_t u = 0; u < V; u++) cost += (D[u][v] < INF)? D[u][v]: 0;
if (cost < ans_d) {
ans_c = v;
ans_d = cost;
}
}
printf("%d %d\n", ans_c, ans_d);
}
int main() {
while (true) {
scanf("%d", &E);
if (E == 0) break;
for (size_t u = 0; u < MAX_V; u++)
for (size_t v = 0; v < MAX_V; v++) D[u][v] = (u == v)? 0: INF;
V = 0;
for (size_t i = 0; i < E; i++) {
int v, u, cost;
scanf("%d %d %d", &u, &v, &cost);
D[u][v] = D[v][u] = cost;
V = max(V, (max(u, v)));
}
V++;
solve();
}
return 0;
}
| 0
| 97,256,916
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <utility>
#include <string>
using namespace std;
void show(vector< pair<char, int> > &a) {
int n = a.size();
for (int i = 0; i < n; i++) {
printf("%c%d%c", a[i].first, a[i].second, i == n - 1 ? '\n' : ' ');
}
}
void selection_sort(vector< pair<char, int> > &a) {
int n = a.size();
int pos;
for (int i = 0; i < n; i++) {
pos = i;
for (int j = i; j < n; j++) {
if (a[j].second < a[pos].second) {
pos = j;
}
}
swap(a[i], a[pos]);
}
}
void bubble_sort(vector< pair<char, int> > &a) {
int n = a.size();
bool hasNext = true;
while (hasNext) {
hasNext = false;
for (int i = n - 1; i >= 1; i--) {
if (a[i].second < a[i - 1].second) {
swap(a[i], a[i - 1]);
hasNext = true;
}
}
}
}
void stable_sort(vector< pair<char, int> > &a) {
auto tmp = a;
int n = a.size();
vector<bool> used(n, false);
for (int i = 0; i < n; i++) {
int pos = -1;
for (int j = 0; j < n; j++) {
if (used[j]) {
continue;
}
if (pos == -1) {
pos = j;
}
if (tmp[j].second < tmp[pos].second) {
pos = j;
}
}
used[pos] = true;
a[i] = tmp[pos];
}
}
int main() {
int n, num;
char suit;
string input;
cin >> n;
vector< pair<char, int> > cards(n), sort1, sort2, sort3;
for (int i = 0; i < n; i++) {
cin >> input;
suit = input[0];
num = input[1] - '0';
cards[i] = make_pair(suit, num);
}
sort1 = sort2 = sort3 = cards;
bubble_sort(sort1);
selection_sort(sort2);
stable_sort(sort3);
show(sort1);
printf("%s\n", sort1 == sort3 ? "Stable" : "Not stable");
show(sort2);
printf("%s\n", sort2 == sort3 ? "Stable" : "Not stable");
return 0;
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pll pair<ll,ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define lb(c,x) distance(c.begin(),lower_bound(all(c),x))
#define ub(c,x) distance(c.begin(),upper_bound(all(c),x))
using namespace std;
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
const ll INF=1e18;
int main(){
string a,b;
cin >> a >> b;
if(a.length()>b.length()){
cout << "GREATER" << endl;
return 0;
}
if(a.length()<b.length()){
cout << "LESS" << endl;
return 0;
}
ll n=a.length();
rep(i,n){
ll p=a[i]-'0';
ll q=b[i]-'0';
if(p>q){
cout << "GREATER" << endl;
return 0;
}
if(p<q){
cout << "LESS" << endl;
return 0;
}
}
cout << "EQUAL" << endl;
return 0;
}
| 0
| 79,088,106
|
#include <iostream>
#include <vector>
using namespace std;
int main(){
long long n;
long long max_a = 0;
long long tot = 0;
cin >> n;
for (int i=0;i<n;i++) {
long long a;
cin >> a;
if (max_a > a) {
tot += max_a - a;
} else {
max_a = a;
}
}
cout << tot << endl;
return(0);
}
|
#include<bits/stdc++.h>
#define ll long long
#define vll vector<ll>
#define umap unordered_map<ll, ll>
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, a, ans = 0;
cin >> n;
umap x;
for(ll i=0; i<n; i++){
cin >> a;
x[a]++;
}
a = 0;
for(auto i:x){
if(i.first > i.second){
ans += i.second;
}
if(i.first < i.second){
ans += (i.second - i.first);
}
}
cout << ans << endl;
return 0;
}
| 0
| 64,658,072
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << fixed << setprecision(10);
double a,b,x;cin>>a>>b>>x;
double pi=3.14159265359;
double ans;
if(x/a<=a*b/2) ans=a*b*b/(2*x);
else ans=2*b/a-2*x/(a*a*a);
cout<<atan(ans)*180/pi<<endl;
}
|
#include <bits/stdc++.h>
#include <x86intrin.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define V vector
template <typename T> bool chmin(T &a, const T &b) {if(a > b){a = b; return true;} return false;}
template <typename T> bool chmax(T &a, const T &b) {if(a < b){a = b; return true;} return false;}
template<typename A, size_t N, typename T> void Fill (A (&array)[N], const T & val) {fill ((T*)array, (T*)(array+N), val);}
V<int> dx = {-1, 1, 0, 0, -1, -1, 1, 1};
V<int> dy = { 0, 0, -1, 1, -1, 1, -1, 1};
int main () {
int n; cin >> n;
V<int> a(1e6+5, 0);
int g = 0;
rep(i, n) {
int x; cin >> x;
a[x]++;
g = __gcd(g, x);
}
for (int i = 1; i <= 1e6; i++) {
for (int j = 2; i*j <= 1e6; j++) {
a[i] += a[i*j];
}
}
bool ps = true;
for (int i = 2; i <= 1e6; i++) {
if (a[i] > 1) ps = false;
}
if (ps) {
puts("pairwise coprime");
return 0;
}
if (g == 1) puts("setwise coprime");
else puts("not coprime");
return 0;
}
| 0
| 23,058,566
|
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int mod=1e9+7;
const int INF=1001001001;
int main() {
int H,W;
cin>>H>>W;
vector<vector<char>>a(H+1,vector<char>(W+1));
for(int i=1;i<=H;i++){
for(int j=1;j<=W;j++){
cin>>a[i][j];
}
}
vector<vector<int>>dp(H+1,vector<int>(W+1));
dp[1][1]=1;
for(int i=1;i<=H;i++){
for(int j=1;j<=W;j++){
if(!(i==1&&j==1)){
if(a[i][j]=='#'){dp[i][j]=0;}
else{dp[i][j]=(dp[i-1][j]+dp[i][j-1])%mod;}
}
}
}
cout<<dp[H][W]<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
typedef vector<ll> vll ;
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define all(v) (v).begin(),(v).end()
#define precision(k) cout<<setprecision(k)<<fixed;
#define loop(i,a) for(int i=0; i<a;i++)
#define loop2(i,a,b) for(int i=(a);i<=(b);++i)
#define minv(v) *min_element(all(v))
#define maxv(v) *max_element(all(v))
#define getpos(v,x) (lower_bound(v.begin(),v.end(),x)-v.begin())
#define unq(v) sort(all(v)),(v).erase(unique((v).begin(),(v).end()),(v).end())
#define pb push_back
#define pi 3.14159265358979323
#define endl "\n"
int main()
{
IOS;
ll n, d, x, sum=0;
cin>>n>>d>>x;
while(n--){
ll a;
cin>>a;
if((d)%a == 0){
sum = sum + (d)/a;
}
else if((d)%a != 0){
sum = sum + (d)/a + 1;
}
}
cout<<sum+x;
}
| 0
| 93,579,253
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
string S; cin >> S;
int s = S.size();
int cnt0 = 0;
int cnt1 = 0;
rep(i, s){
if(S[i] == '0'){
cnt0++;
} else {
cnt1++;
}
}
int ans = min(cnt0, cnt1);
ans *= 2;
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n;
cin >> n;
vector<vector<int>>adj(n, vector<int>(n));
for (int i = 0;i < n;i++) {
int u, k;
cin >> u >> k;
for (int j = 0;j < k;j++) {
int v;
cin >> v;
adj[u - 1][v - 1] = 1;
}
}
for (int i = 0;i <n;i++) {
for (int j = 0;j <n;j++) {
if (j == 0) {
cout << adj[i][j];
}
else {
cout << " " << adj[i][j];
}
}
cout << endl;
}
}
| 0
| 34,445,771
|
#include <bits/stdc++.h>
#define int long long
using ll = long long;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for(ll i = ll(a); i < ll(b+a); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define all(a) (a).begin(), (a).end()
using namespace std;
using P = pair<int, int>;
#define SZ(x) ((int)(x).size())
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n; cin >> n;
string s; cin >> s;
int ac = 0,gc = 0,bc = 0;
rep(i,n) {
if (s[i] == 'R') {
ac += 1;
} else if (s[i] == 'G') {
gc += 1;
} else if (s[i] == 'B') {
bc += 1;
}
}
ll sum = ac*gc*bc;
ll minus = 0;
for (int i = 0; i < n; i++)
{
for (int j = i+1; j < n; j++)
{
int k = j + j - i;
if (k >= n) continue;
if (s[i] == s[j] || s[i] == s[k] || s[j] == s[k]) continue;
minus++;
}
}
cout << sum - minus << endl;
return 0;
}
|
#include <bits/stdc++.h>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (int)(n); i++ )
using namespace std;
int findSumOfDigits(int n) {
int sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
int main(){
string s;
cin >> s;
vector<int> num(26);
vector<int> counter(10000);
rep(i,26) num.at(i) = 'a' + i;
rep(i,s.size()) rep(j,26){
if(s.at(i) == num.at(j)) counter.at(num.at(j))++;
}
for(int i = 0;i<26;i++){
string ans = "None";
if(counter.at(num.at(i)) == 0){
ans = num.at(i);
cout << ans << endl;
break;
}
if(i == 25) cout << ans << endl;
}
}
| 0
| 44,670,795
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int Maxn=2010;
const int inf=2147483647;
const int mod=1000000007;
int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
return x*f;
}
int f[Maxn];
int main()
{
int S=read();
f[0]=1;f[1]=f[2]=0;
for(int i=3;i<=S;i++)
for(int j=3;j<=i;j++)
f[i]=(f[i]+f[i-j])%mod;
printf("%d",f[S]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
string s;
cin >> s;
int cnt1=0;
int cnt2=0;
stack<char> st;
for(int i=0;i<n;++i){
if(!st.empty()){
if(st.top()=='(' && s[i]==')')st.pop();
else st.push(s[i]);
}
else st.push(s[i]);
}
while(!st.empty()){
if(st.top()=='(')cnt1++;
else cnt2++;
st.pop();
}
cout << string(cnt2,'(') << s << string(cnt1,')');
}
| 0
| 71,738,240
|
#include<bits/stdc++.h>
using namespace std;
typedef struct{
double x,y;
}vec_t;
int main(){
double x1,y1,x2,y2,x3,y3,xp,yp;
vec_t AB,BC,CA,AP,BP,CP;
while(cin>>x1>>y1>>x2>>y2>>x3>>y3>>xp>>yp){
AB.x=x2-x1 , AB.y=y2-y1;
BC.x=x3-x2 , BC.y=y3-y2;
CA.x=x1-x3 , CA.y=y1-y3;
AP.x=xp-x1 , AP.y=yp-y1;
BP.x=xp-x2 , BP.y=yp-y2;
CP.x=xp-x3 , CP.y=yp-y3;
double c1=AB.x*BP.y - AB.y*BP.x;
double c2=BC.x*CP.y - BC.y*CP.x;
double c3=CA.x*AP.y - CA.y*AP.x;
if((c1<0&&c2<0&&c3<0) || (c1>0&&c2>0&&c3>0))cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
}
|
#include <vector>
#include <iostream>
#include <math.h>
using namespace std;
typedef long long int ll;
ll MOD = pow(10,9) + 7;
ll solve(vector<ll>& kids,ll K)
{
ll n = kids.size();
vector<vector<ll>> dp(n+1,vector<ll>(K+1));
vector<ll> rs(K+1,1);
vector<ll> nex_rs(K+1);
nex_rs[0] = 1;
for (int i=0;i<=n;++i)
{
dp[i][0] = 1;
}
for (int i=1;i<=n;++i)
{
vector<ll> rs(K+1);
rs[0] = 1;
for (int x=1;x<=K;++x)
{
rs[x] = rs[x-1] + dp[i-1][x];
}
for (int can=1;can<=K;++can)
{
ll upto = can - kids[i-1] - 1;
dp[i][can] = rs[can];
if (upto>=0) dp[i][can] -= rs[upto];
dp[i][can] %= MOD;
}
}
return dp[n][K];
}
int main()
{
int N,K;
cin>>N>>K;
vector<ll> kids(N);
for (int i=0;i<N;++i)
{
cin>>kids[i];
}
cout<<solve(kids,K)<<endl;
return 0;
}
| 0
| 72,143,020
|
#include <bits/stdc++.h>
#define rep(i,x,n) for(int i=x; i<(int)(n); i++)
#define rep_eq(i,x,n) for(int i=x; i<=(int)(n); i++)
using namespace std;
using ll=long long;
using vi=vector<int>;
using vll=vector<ll>;
using vvi=vector<vi>;
int main() {
ll X,Y; cin >>X >>Y;
cout <<(X%Y!=0 ? X:-1) <<endl;
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
const int A = 1000005;
int gcd(int x, int y){
int r;
if(x<y) swap(x,y);
while(y>0){
r = x % y;
x = y;
y = r;
}
return x;
}
int main(void){
int n;
cin >> n;
vector<int> a(n);
vector<int> c(A);
for(int i=0;i<n;i++){
cin >> a.at(i);
c[a[i]]++;
}
bool pairwise = true;
for(int i=2;i<A;i++){
int cnt = 0;
for(int j=i;j<A;j+=i){
cnt += c[j];
}
if(cnt>1){
pairwise = false;
}
}
if(pairwise){
cout << "pairwise coprime" << endl;
return 0;
}
int g = 0;
for(int i=0;i<n;i++){
g = gcd(g, a[i]);
}
if(g==1){
cout << "setwise coprime" << endl;
return 0;
}
cout << "not coprime" << endl;
return 0;
}
| 0
| 15,376,306
|
#include <iostream>
using namespace std;
int main() {
char a, b;
cin >> a >> b;
if((a == 'H' && b == 'H') || (a == 'D' && b == 'D')) cout << "H\n";
else cout << "D\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define INF 2100000000
#define MOD 1000000007
int main(){
ll N;
cin>>N;
vector<pair<ll,ll>> P(N);
for(ll i=0;i<N;i++){
cin>>P.at(i).first;
P.at(i).second=i;
}
sort(P.begin(),P.end());
reverse(P.begin(),P.end());
multiset<ll> S;
S.insert(-1);
S.insert(-1);
S.insert(N);
S.insert(N);
ll ans=0;
for(ll i=0;i<N;i++){
auto iter=S.upper_bound(P.at(i).second);
iter--;
iter--;
ll a1=*iter;
iter++;
ll a2=*iter;
iter++;
ll a3=*iter;
iter++;
ll a4=*iter;
ans+=(ll)P.at(i).first*(((ll)a2-(ll)a1)*((ll)a3-(ll)P.at(i).second)+((ll)a4-(ll)a3)*((ll)P.at(i).second-(ll)a2));
S.insert(P.at(i).second);
}
cout<<ans<<endl;
}
| 0
| 10,623,074
|
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define BIL ((ll)1e9)
#define MOD ((ll)1e9+7)
#define INF (1LL<<60)
#define inf (1<<29)
int main(int argc,char* argv[]){
int n;
cin >> n;
vector<int> x(n);
int sum=0;
for(auto &y:x){
cin >> y;
sum+=y;
}
int p=sum/n;
ll ansx=0;
for(int i=0;i<n;i++){
int diff=abs(x[i]-p);
ansx+=diff*diff;
}
p++;
ll ansy=0;
for(int i=0;i<n;i++){
int diff=abs(x[i]-p);
ansy+=diff*diff;
}
ll ans=min(ansx,ansy);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <bitset>
#include <math.h>
typedef long long ll;
typedef unsigned long long ull;
#define vi std::vector<int>
#define vl std::vector<ll>
#define floop(n) for(int i = 0; i < n; ++i)
#define print(x) std::cout << x << std::endl;
const ll INF = 1e18;
int main()
{
int N, K, X, Y;
std::cin >> N;
std::cin >> K;
std::cin >> X;
std::cin >> Y;
if(N <= K)
{
print((X*N));
}
else
{
print((X*K + Y*(N-K)));
}
return 0;
}
| 0
| 46,097,329
|
#include <bits/stdc++.h>
#define fast ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define int long long
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
int parent[N], siz[N];
void make_set(int v){
parent[v] = v;
}
int find_set(int v){
while(v!=parent[v])
v = parent[v];
return v;
}
void union_sets(int a, int b){
a = find_set(a);
b = find_set(b);
if(a!=b){
if(siz[a] < siz[b])
swap(a,b);
parent[b] = a;
siz[a] += siz[b];
}
}
int32_t main()
{
fast;
memset(siz, 0, sizeof siz);
int n,q;
cin>>n>>q;
for(int i=0; i<n; i++)
make_set(i);
while(q--){
int t, u, v;
cin>> t >> u >> v;
if(t==0)
union_sets(u,v);
else{
if(find_set(u) == find_set(v))
cout<< 1 <<endl;
else
cout<< 0 <<endl;
}
}
}
|
#include <iostream>
#include <array>
#include <algorithm>
#include <vector>
#include <set>
#include <unordered_set>
#include <cmath>
#include <complex>
#include <deque>
#include <iterator>
#include <numeric>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <limits>
#include <iomanip>
#include <functional>
#include <cassert>
using namespace std;
using ll=long long;
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)
#define REP(i, n) rep(i, 0, n)
#define ALL(v) v.begin(),v.end()
template < class T > inline bool chmax(T& a, T b) {if (a < b) { a=b; return true; } return false; }
template < class T > inline bool chmin(T& a, T b) {if (a > b) { a=b; return true; } return false; }
#define DEBUG_VLL(vec) REP(sz, vec.size()) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');
const ll MOD = 1000000007;
const ll HIGHINF = (ll)1e18;
int n;
V< V<int> > edges;
V<int> match;
void dfs(int i, int p) {
if (match[i] != -1) return;
for (int e: edges[i]) {
if (e != p) dfs(e, i);
}
if (match[i] == -1 && p != -1 && match[p] == -1) {
match[i] = p;
match[p] = i;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
edges.resize(n);
for (int i = 0; i < n - 1; i++) {
int a, b; cin >> a >> b;
a--, b--;
edges[a].emplace_back(b);
edges[b].emplace_back(a);
}
match.resize(n, -1);
dfs(0, -1);
for (int i = 0; i < n; i++) {
if (match[i] == -1) {
cout << "First\n";
return 0;
}
}
cout << "Second\n";
return 0;
}
| 0
| 26,386,390
|
#include <cstdio>
#include <map>
using namespace std;
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define FOR(i,b,e) for(int i=(b); i<=(int)(e); i++)
#define ITR(c,it) for(it = c.begin(); it != c.end(); it++)
const int N_MAX = 100000;
typedef long long ll;
int H, W, N;
int a[N_MAX];
int b[N_MAX];
map<pair<int, int>, int> sqs;
int cnts[10];
void solve() {
REP(k, N) {
FOR(i, -2, 0) FOR(j, -2, 0) {
int i2 = a[k] - 1 + i;
int j2 = b[k] - 1 + j;
if (i2 < 0 || i2 + 2 >= H || j2 < 0 || j2 + 2 >= W) continue;
sqs[make_pair(i2, j2)]++;
}
}
map<pair<int, int>, int>::iterator it;
ITR(sqs, it) cnts[it->second]++;
ll total = (ll) (H - 2) * (W - 2);
FOR(k, 1, 9) total -= cnts[k];
printf("%lld\n", total);
FOR(k, 1, 9) printf("%d\n", cnts[k]);
}
void input() {
scanf("%d%d%d", &H, &W, &N);
REP(i, N) scanf("%d%d", a + i, b + i);
}
int main() {
input();
solve();
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()
int main(){
int n, a, b;
cin >> n >> a >> b;
int ans=0;
for(int i=0; i<=n; i++){
int count=0,temp=i;
while(temp != 0){
count += temp % 10;
temp /= 10;
}
if(a <= count && count <= b){
ans += i;
}
}
cout << ans << endl;
}
| 0
| 68,046,588
|
#include <iostream>
using namespace std;
int dp[111111],a[111111];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++) {
if (dp[i - 1]+abs(a[i] - a[i - 1]) > dp[i - 2]+abs(a[i] - a[i - 2])) {
dp[i] = dp[i - 2] + abs(a[i] - a[i - 2]);
}
else {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
}
}
cout << dp[n];
}
|
#include <iostream>
#include <map>
#include <vector>
using namespace std;
constexpr int N_max = 2'000;
constexpr int M_max = 2'000;
constexpr int mod = 1'000'000'007;
#ifdef _MSC_VER
constexpr int debug = 1;
#else
constexpr int debug = 0;
#endif
static int dp0[2'005][2'005];
static int dp1[2'005][2'005];
int main() {
int n, m;
cin >> n >> m;
auto s = vector<int>(n + 5);
auto t = vector<int>(m + 5);
for (int i = 0; i < n; i++)
cin >> s[i];
for (int j = 0; j < m; j++)
cin >> t[j];
dp0[0][0] = 1;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
dp0[i + 1][j] = (dp0[i + 1][j] + dp0[i][j]) % mod;
dp1[i][j] = (dp1[i][j] + dp0[i][j]) % mod;
dp1[i][j + 1] = (dp1[i][j + 1] + dp1[i][j]) % mod;
if (s[i] == t[j]) {
dp0[i + 1][j + 1] = (dp0[i + 1][j + 1] + dp1[i][j]) % mod;
}
}
}
cout << dp1[n][m];
return 0;
}
| 0
| 21,708,732
|
#include <bits/stdc++.h>
#define be(v) (v).begin(),(v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod=1000000007;
#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll n;
cin>>n;
ll x[n],y[n];
bool maki=false;
for(int i=0;i<n;i++){
cin>>x[i]>>y[i];
if(i)if(((x[i]+y[i])&1)!=((x[i-1]+y[i-1])&1))maki=true;
}
if(maki){
cout <<-1 <<endl;
return 0;
}
vector<ll> d;
for(int i=30;i>=0;i--){
d.pb(1LL<<i);
}
if(((x[0]+y[0])&1)==0)d.pb(1);
cout<<d.size()<<endl;
for(auto& i:d)cout << i <<" ";
cout <<endl;
for(int i=0;i<n;i++){
ll a=0,b=0;
for(auto& j:d){
if(abs(a-x[i])>=abs(b-y[i])){
if(a>=x[i])a-=j,cout<<"L";
else a+=j,cout<<"R";
}else{
if(b>=y[i])b-=j,cout<<"D";
else b+=j,cout << "U";
}
}
cout << endl;
}
return 0;
}
|
#include <iostream>
#include<vector>
using namespace std;
int main() {
int k;cin>>k;
vector<int> list,next;
int ans=1;
int flag=0;
int used[k];
for(int i=0;i<k;i++){
used[i]=0;
}
list.push_back(1);
while(1){
while(list.size()){
int num=list.back();
if(num==0){
flag=1;
break;
}
list.pop_back();
if(used[num]==0){
used[num]=1;
next.push_back((num+1)%k);
list.push_back((num*10)%k);
}
}
if(flag){
break;
}
list=next;
next.clear();
ans++;
}
cout<<ans<<endl;
return 0;
}
| 0
| 56,474,353
|
#include <bits/stdc++.h>
#define int long long
#define endl "\n"
#define ALL(v) (v).begin(),(v).end()
#define COUNT(a,k) upper_bound(ALL(a),k)-lower_bound(ALL(a),k)
#define BIGGER(a,k) a.end()-upper_bound(ALL(a),k)
#define SMALLER(a,k) lower_bound(ALL(a),k)-a.begin()
#define Vi vector<int>
#define VVi vector<Vi>
#define Vs vector<string>
#define Pii pair<int,int>
#define VPii vector<Pii>
#define Tiii tuple<int,int,int>
#define VTiii vector<Tiii>
#define PQi priority_queue<int>
#define PQir priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define itos to_string
#define stoi stoll
#define FI first
#define SE second
#define cYES cout<<"YES"<<endl
#define cNO cout<<"NO"<<endl
#define cYes cout<<"Yes"<<endl
#define cNo cout<<"No"<<endl
#define cyes cout<<"yes"<<endl
#define cno cout<<"no"<<endl
#define _ <<' '<<
#define sortr(v) sort(v,greater<>())
#define rep(i,a,b) for(int i=a;i<b;i++)
#define repeq(i,a,b) for(int i=a;i<=b;i++)
#define repreq(i,a,b) for(int i=a;i>=b;i--)
#define leng(n) (int)(log10(n)+1)
#define dem(a,b) ((a+b-1)/(b))
#define Vin(a) rep(iI,0,a.size())cin>>a[iI]
#define Vout(a) rep(lZ,0,a.size()-1)cout<<a[lZ]<<' ';cout<<a.back()<<endl
#define VVout(a) rep(lY,0,a.size()){if(!a[lY].empty()){Vout(a[lY]);}else cout<<endl;}
#define VPout(a) rep(lX,0,a.size())cout<<a[lX].FI<<' '<<a[lX].SE<<endl
#define Verr(a) rep(iZ,0,a.size()-1)cerr<<a[iZ]<<' ';cerr<<a.back()<<endl
#define VVerr(a) rep(J,0,a.size()){if(!a[J].empty()){Verr(a[J]);}else cerr<<'.'<<endl;}
#define VPerr(a) rep(iX,0,a.size())cerr<<a[iX].FI<<' '<<a[iX].SE<<endl
#define INF 3000000000000000000
#define MAX LLONG_MAX
#define PI 3.141592653589793238462
#define MOD 1000000007
using namespace std;
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int lcm(int a,int b){return a/gcd(a,b)*b;}
int mypow(int x, int n, int m){
if(n==0)return 1;if(n%2==0)return mypow(x*x%m,n/2,m);else return x*mypow(x,n-1,m)%m;}
int scomb(int n, int r){if((n-r)<r)r=n-r;
int a=1;for(int i=n;i>n-r;--i){a=a*i;}for(int i=1;i<r+1;++i){a=a/i;}return a;}
int comb(int n, int r){if((n-r)<r)r=n-r;
int a=1;for(int i=n;i>n-r;--i){a=a*i%MOD;}for(int i=1;
i<r+1;++i){a=a*mypow(i,MOD-2,MOD)%MOD;}return a%MOD;}
Vi stpowV(){Vi a(100001);
a[0]=1;repeq(i,1,100000)a[i]=a[i-1]*i%MOD;return a;}
void press(auto &v){v.erase(unique(ALL(v)),v.end());}
Vi Vsum(Vi &v){Vi S(v.size()+1);rep(i,1,S.size())S[i]+=v[i-1]+S[i-1];return S;}
int keta(int k,int i){string s = itos(k);return s[s.size()-i]-'0';}
int v, e;
const int MAX_N = 100010;
vector<int> g[MAX_N];
bool used[MAX_N];
vector<int> ans;
void dfs(int u) {
if(used[u]) return;
used[u] = true;
for(auto& i: g[u]) dfs(i);
ans.push_back(u);
}
void tsort() {
for(int i=0; i<v; ++i) dfs(i);
reverse(ans.begin(), ans.end());
}
signed main() {
cin.tie(0);cout.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(12);
cin >> v >> e;
rep(i,0,e) {
int s, t;
cin >> s >> t;
g[s].push_back(t);
}
tsort();
rep(i,0,ans.size()){
cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b, a % b);
}
using Graph = vector<vector<int>>;
ll calc(ll a, ll b, ll p){
if(b == 0) return 1;
else if(b%2 == 0){
ll d = calc(a,b/2,p);
return (d*d)%p;
}
else if(b%2 == 1){
return (a * calc(a,b-1,p))%p;
}
}
typedef pair<int,int> P;
bool is_prime(int n){
if(n == 1) return false;
for(int i = 2;i*i <= n;i++){
if(n%i == 0) return false;
}
return true;
}
int factorial(int a){
int res = 1;
while(a){
res *= a;
a--;
}
return res;
}
int main(){
vector<int> v(4);
rep(i,4){
cin >> v[i];
}
string S;
rep(i,4){
S.push_back((char)(v[i]+48));
}
sort(S.begin(),S.end());
if(S == "1479") cout << "YES" << endl;
else cout << "NO" << endl;
}
| 0
| 63,798,716
|
#include<bits/stdc++.h>
using namespace std;
typedef vector<int>V;
void func(int node,int par,int rang);
bool flg[100000]={0};
int n,u,k,c;
V v[100000];
struct Node{
int parent,depth;
};
Node T[100000];
int main(void){
int i,j;
cin>>n;
for(i=0;i<n;i++){
cin>>u>>k;
T[i].parent=0;
T[i].depth=0;
for(j=0;j<k;j++){
cin>>c;
flg[c]=1;
v[u].push_back(c);
}
}
for(i=0;i<n;i++){
if(!flg[i]){
func(i,-1,0);
}
}
for(i=0;i<n;i++){
cout<<"node "<<i<<": parent = "<<T[i].parent<<", depth = "<<T[i].depth<<", ";
if(v[i].empty()){
if(T[i].parent==-1){
cout<<"root, []"<<endl;
}
else{
cout<<"leaf, []"<<endl;
}
}
else{
if(T[i].parent==-1){
cout<<"root, ["<<v[i][0];
for(j=1;j<v[i].size();j++){
cout<<", "<<v[i][j];
}
cout<<"]"<<endl;
}
else{
cout<<"internal node, ["<<v[i][0];
for(j=1;j<v[i].size();j++){
cout<<", "<<v[i][j];
}
cout<<"]"<<endl;
}
}
}
return 0;
}
void func(int node,int par,int rang){
int i;
T[node].parent=par;
T[node].depth=rang;
for(i=0;i<v[node].size();i++){
func(v[node][i],node,rang+1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
vector<char> a(s.size());
for(int i = 0; i < s.size(); i++) {
a[i]=s[i];
}
int b=0;
for(int i = 0; i < s.size(); i++) {
if(s[s.size()-1-i]=='B'){
b++;
}
else{
if(b>0){
a[s.size()-1-i]='A';
b--;
}
}
}
for(int i = 0; i < s.size(); i++) {
if(a[i]=='1') cout << 1;
if(a[i]=='0') cout << 0;
}
cout << endl;
return 0;
}
| 0
| 33,866,904
|
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define ALLv(a) (a).begin(),(a).end()
#define ALL(a,n) (a),(a)+n
#define vi vector<long long>
#define vd vector<long double>
#define vs vector<string>
#define dcml(n) fixed<<setprecision(n)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF=1010000000000000017LL;
const ll MOD=1000000007LL;
const ld EPS=1e-12;
const ld PI=3.14159265358979323846;
#define FOR(i,m,n) for(ll (i)=(m); (i)<(n); (i)++)
#define FORS(i,m,n) for(ll (i)=(m); (i)<=(n); (i)++)
#define RFOR(i,m,n) for(ll (i)=(n)-1; (i)>=(n); (i)--)
#define RFORS(i,m,n) for(ll (i)=(n); (i)>(n); (i)--)
#define REP(i,n) for(ll (i)=0; (i)<(n); (i)++)
#define REPS(i,x) for(ll (i)=1; (i)<=(x); (i)++)
#define RREP(i,x) for(ll (i)=(x)-1; (i)>=0; (i)--)
#define RREPS(i,x) for(ll (i)=(x); (i)> 0; (i)--)
#define WREP(i,in,j,jn) REP(i,in)REP(j,jn)
#define WREPS(i,in,j,jn) REPS(i,in)REPS(j,jn)
using namespace std;
class COM{
vi fact, inv;
ll N, mod;
public:
COM(ll n,ll m=MOD):N(n),mod(m){
fact.resize(N+1);inv.resize(N+1);
}
ll power(ll a, ll b){
ll res=1;
while(b>0){
if(b&1) res=res*a%mod;
a=a*a%mod;
b>>=1;
}
return res;
}
void __init__(){
fact[0]=1;
REPS(i,N){fact[i]=fact[i-1]*i%mod;}
inv[N]=power(fact[N],mod-2);
RREPS(i,N){inv[i-1]=inv[i]*i%mod;}
}
ll nCr(ll n,ll r){
return fact[n]*inv[n-r]%mod*inv[r]%mod;
}
};
int main(void){
ll X,Y;cin>>X>>Y;
ll d=abs(X-Y);
ll M,m;
ll a,b;
M=max(X,Y);
m=min(X,Y);
if((X+Y)%3!=0){
cout<<0<<"\n";
return 0;
}
if(d<=m){
M-=d*2;
m-=d;
a=d;
ll add=m/3;
a+=add;
b=add;
}else{
cout<<0<<"\n";
return 0;
}
COM com(2200000);
com.__init__();
cout<<com.nCr(a+b,b)<<"\n";
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e6 + 10;
signed main() {
ll a, c;
double b;
cin >> a >> b;
c = b * 100 + 0.1;
cout << (ll)(a * c / 100) << '\n';
return 0;
}
| 0
| 21,812,184
|
#include <iostream>
#include <cstdio>
using namespace std;
void print_array(int *x, int n)
{
for (int k = 0; k < n; ++k)
{
if (k == n- 1)
{
printf("%d\n", x[k]);
}
else
{
printf("%d ", x[k]);
}
}
}
int main(int argc, char const *argv[])
{
int input_size, min, count = 0;
cin >> input_size;
int array[input_size];
for (int i = 0; i < input_size; ++i)
{
cin >> array[i];
}
for (int i = 0; i < input_size; ++i)
{
min = i;
for (int j = i; j < input_size; ++j)
{
if(array[j] < array[min])
{
min = j;
}
}
if(min != i) count++;
int temp = array[min];
array[min] = array[i];
array[i] = temp;
}
print_array(array, input_size);
printf("%d\n", count);
return 0;
}
|
#include <algorithm>
#include <chrono>
#include <cmath>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vi2;
typedef vector<vi2> vi3;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<ll> vll;
typedef vector<vll> vll2;
typedef vector<vll2> vll3;
typedef vector<bool> vb;
#define el '\n'
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repi(i, a, b) for (int i = a; i >= b; i--)
#define repeat(n) for (int i = 0; i < n; i++)
#define umap unordered_map
#define uset unordered_set
#define vec vector
#define loop(a) for (auto &x : a)
#define all(a) a.begin(), a.end()
#define mp make_pair
#define pb push_back
template <typename T>
void debug0(const T &value) {
cerr << value << endl;
}
template <typename T, typename... Args>
void debug0(const T &value, const Args &... args) {
cerr << value << ' ';
debug0(args...);
}
#ifdef LOCAL
#define debug(...) debug0(__VA_ARGS__)
#else
#define debug(...)
#endif
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vi2 adj(n);
rep(i, 0, n - 1) {
int u, v;
cin >> u >> v;
--u, --v;
adj[u].pb(v);
adj[v].pb(u);
}
ll f1 = 0;
ll ans = 0;
repi(L, n - 1, 0) {
ll f2 = f1 + (n - L);
loop(adj[L]) {
if (L < x) {
f2 -= n - x;
}
}
f1 = f2;
debug("L", L, "f1", f1);
ans += f1;
}
cout << ans << el;
}
| 0
| 86,398,230
|
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <string>
#include <map>
#define pb push_back
#define mp make_pair
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef unsigned long long ull;
typedef long long ll;
int main() {
vi va;
int a, b, c;
cin >> a >> b >> c;
int d = max(a,max(b, c));
int x = 0;
if ((3*d % 2) == ((a+b+c) % 2)) {
x = d;
} else {
x = d+1;
}
cout << (3*x-(a+b+c))/2;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0;i < (n);i++)
using namespace std;
using ll = long long;
using pii = pair<int,int>;
int main(){
int n,k;
cin >> n >> k;
int r = 0;
vector<int> cnt(n+1);
rep(i,n){
int a;
cin >> a;
cnt[a]++;
if(cnt[a] == 1)r++;
}
int ans = 0;
if(r <= k){
cout << ans << endl;
return 0;
}
r -= k;
sort(cnt.begin(),cnt.end());
rep(i,n-k+1){
ans += cnt[i];
}
cout << ans << endl;
}
| 0
| 62,324,366
|
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 100005
using namespace std;
inline int read(){
int sum = 0, t = 1; char ch = getchar();
while(ch < '0' || ch > '9'){ if(ch == '-') t = -1; ch = getchar(); }
while(ch >= '0' && ch <= '9'){ sum = sum * 10 + ch - '0'; ch = getchar(); }
return sum * t;
}
int n, nxt[N<<1], fir[N], to[N<<1], cnt;
void add(int x, int y){
nxt[++cnt] = fir[x]; to[cnt] = y; fir[x] = cnt;
nxt[++cnt] = fir[y]; to[cnt] = x; fir[y] = cnt;
}
bool f[N][2];
void dfs(int x, int p){
f[x][0] = true;
for(int i = fir[x]; i ; i = nxt[i]) if(to[i] != p){
int y = to[i];
dfs(y, x);
f[x][1] = (f[x][1] & f[y][1]) | (f[x][0] & f[y][0]);
f[x][0] &= f[y][1];
}
}
int main(){
n = read();
for(int i = 1; i < n; i++) add(read(), read());
dfs(1, 0);
if(f[1][1]) puts("Second");
else puts("First");
}
|
#include<iostream>
using namespace std;
int n,i,k,val,V[2005][2005],j;
int main()
{
ios::sync_with_stdio(false);
cin>>n;
for(i=1; i*(i-1)<=2*n; i++)
k=i;
if(k*(k-1)!=2*n)
{
cout<<"No\n";
return 0;
}
cout<<"Yes\n";
cout<<k<<"\n";
val=1;
for(i=1; i<=k; i++)
{
cout<<k-1<<" ";
for(j=1; j<=V[i][0]; j++)
cout<<V[i][j]<<" ";
for(j=i+1; j<=k; j++)
{
cout<<val<<" ";
V[j][++V[j][0]]=val;
val++;
}
cout<<"\n";
}
return 0;
}
| 0
| 26,411,027
|
#include <iostream>
#include <algorithm>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main(void){
int N;
cin >> N;
int A=4,B=7,C=28;
string ans;
bool memo[101] = {false};
for(int i=0;i<=100;i+=A){
for(int j=i;j<=100;j+=B){
memo[j] = true;
}
}
if(memo[N]){
ans = "Yes";
}
else{
ans = "No";
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ordered_set tree<pair<int,int>, null_type,less<pair<int,int> >, rb_tree_tag,tree_order_statistics_node_update>
#define standardVar ll n,m,i,j,k,num,num1,num2,flag=0
#define nn <<"\n"
#define __ <<" "<<
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define ff first
#define ss second
#define all(v) v.begin(),v.end()
#define ittr(x,v) for(auto x=v.begin();x!=v.end();x++)
#define itr(x,n) for(x=0;x<n;x++)
#define itrab(x,a,b) for(x=a;x<b;x++)
#define itpr(v) ittr(x,v)cout<<*x<<" "; cout nn
#define itppr(v) ittr(x,v)cout<<(*x).ff<<" "<<(*x).ss<<" "; cout nn
#define size(x) (ll)x.size()
#define pi 3.14159265359
#define dTor(x) ((x)*pi)/180.0
#define INF 1000000100;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vl;
typedef map<ll,ll> ml;
typedef set<ll> sl;
typedef string str;
typedef pair<ll, ll> pl;
typedef vector< pl > vpl;
typedef map<pl,ll> mpl;
typedef set< pl > spl;
typedef vector<str> vst;
typedef vector<vl> vvl;
const ll M=1000000007;
const ll N=998244353;
ll power(ll x, ll y, ll p){
ll res=1;
x=x%p;
if(x==0)
return 0;
while(y>0){
if(y&1)
res=(res*x)%p;
y=y>>1;
x=(x*x)%p;
}
return res;
}
ll inv(ll x, ll m){
return power(x,m-2,m);
}
struct comp{
template<typename T>
bool operator()(const T &a, const T &b){
if (a.ff==b.ff)
return (a.ss<b.ss);
else
return (a.ff<b.ff);
}
};
bool mod(const pair<ll,ll> &a, const pair<ll,ll> &b){
if(a.ff!=b.ff)
return (a.ff>b.ff);
else
return (a.ss>b.ss);
}
vector<bool> pr(1000000+1,1);
void sieve(ll mn, ll mx){
for(ll i=mn;i*i<=mx;i++)
if(pr[i-mn]==1)
for(ll j=i*i;j<=mx;j+=i)
pr[j-mn]=0;
}
bool isValid(ll i, ll j, ll n, ll m){
if(i>=0&&i<n&&j>=0&&j<m){
return true;
}
return false;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
standardVar;
cin>>n;
vl v;
ll mx=-1;
itr(i,n){
cin>>num;
v.pb(num);
mx=max(num,mx);
}
sort(all(v));
vl a(mx+1,0);
itr(i,n){
for(j=v[i];j<=mx;j+=v[i]){
a[j]++;
}
}
ll c=0;
itr(i,n){
if(a[v[i]]==1){
c++;
}
}
cout<<c nn;
return 0;
}
| 0
| 30,178,973
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
priority_queue<int> q;
int a;
for(int i=1;i<=n;i++){
cin>>a;
q.push(a);
}
int temp;
for(int i=1;i<=m;i++){
temp=q.top();
temp/=2;
q.pop();
q.push(temp);
}
long long ans=0;
for(int i=1;i<=n;i++){
ans+=q.top();
q.pop();
}
cout<<ans<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#ifdef LOCAL
#include "/home/shahraaz/bin/debug.h"
#else
#define db(...)
#define pc(...)
#endif
#define f first
#define s second
#define pb push_back
#define all(v) v.begin(), v.end()
auto TimeStart = chrono::steady_clock::now();
auto seed = TimeStart.time_since_epoch().count();
std::mt19937 rng(seed);
using ll = long long;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using Random = std::uniform_int_distribution<T>;
const int NAX = 3e2 + 5, MOD = 1000000007;
int a[NAX];
ll dp[NAX][NAX][NAX];
class Solution
{
private:
int n, k;
ll solve(int idx, int rem, int prev)
{
if (rem < 0)
return 1e18;
if (idx > n)
return 0;
ll &ans = dp[idx][rem][prev];
if (ans >= 0)
return ans;
ans = 1e18;
ans = min(solve(idx + 1, rem - 1, prev), max(0, a[idx] - a[prev]) + solve(idx + 1, rem, idx));
return ans;
}
public:
Solution() {}
~Solution() {}
void solveCase()
{
cin >> n >> k;
for (size_t i = 0; i < n; i++)
cin >> a[i + 1];
memset(dp, -1, sizeof dp);
cout << solve(1, k, 0) << '\n';
}
};
int32_t main()
{
#ifndef LOCAL
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif
int t = 1;
#ifdef MULTI_TEST
cin >> t;
#endif
Solution mySolver;
for (int i = 1; i <= t; ++i)
{
mySolver.solveCase();
#ifdef TIME
cerr << "Case #" << i << ": Time " << chrono::duration<double>(chrono::steady_clock::now() - TimeStart).count() << " s.\n";
TimeStart = chrono::steady_clock::now();
#endif
}
return 0;
}
| 0
| 92,140,820
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t S;
cin>>S;
int64_t A=sqrt(S);
if(A*A>S){
A--;
}
if(A*A==S){
cout<<"0"<<" "<<"0"<<" "<<A<<" "<<"0"<<" "<<"0"<<" "<<A<<endl;
}
else if(A*(A+1)>=S){
cout<<"0"<<" "<<"0"<<" "<<A<<" "<<A*(A+1)-S<<" "<<"1"<<" "<<A+1<<endl;
}
else{
cout<<"0"<<" "<<"0"<<" "<<A+1<<" "<<(A+1)*(A+1)-S<<" "<<"1"<<" "<<A+1<<endl;
}
}
|
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, n) for (int i = 1; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
signed main()
{
int n;
ll Y;
cin >> n >> Y;
for (int i = n; i >= 0; i--) {
for (int j = 0; j <= n - i; j++) {
int k = n - j - i;
if (k < 0) {
continue;
}
if (Y == 10000 * i + 5000 * j + 1000 * k) {
cout << i << " " << j << " " << k << endl;
return 0;
}
}
}
put("-1 -1 -1");
return 0;
}
| 0
| 63,253,764
|
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);i++)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using namespace std;
template <typename T>
using vec = std::vector<T>;
int main() {
int A,B,C,D;
cin >> A >> B >> C >> D;
int left = A+B;
int right = C+D;
string ans = "";
if(left>right) ans = "Left";
else if(left<right) ans = "Right";
else ans = "Balanced";
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define endl "\n"
#define F first
#define S second
#define mod 1000000007
#define pb push_back
#define FOR(i,a,n) for(int i=a;i<n;i++)
#define aint(a) a.begin(),a.end()
#define UB upper_bound
#define LB lower_bound
const int NUM = 2e5 + 5;
int32_t main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int num_tests=1;
while(num_tests-->0){
int N, K; cin >> N >> K;
int pre = 0;
int suf = 0;
int ans = 0;
FOR(i, 1, N+2) {
pre += i-1;
suf += N+1-i;
pre %= mod; suf %= mod;
if (i >= K) {
ans += suf - pre + 1 + mod;
ans %= mod;
}
}
cout << ans;
}
}
| 0
| 54,164,699
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin >> N;
double t[200], v[200];
for (int i = 0;i < N;i++){
cin >> t[i];
}
for (int i = 0;i < N;i++){
cin >> v[i];
}
double sum[200];
sum[0] = 0;
for (int i = 1;i <= N;i++){
sum[i] = sum[i-1]+t[i-1];
}
v[N] = 0;
double dist = 0;
double speed = 0;
int idx = 0;
double d = 0.25;
for (double time = 0;time < sum[N];time += d){
if(time >= sum[idx+1]) idx++;
bool can_keep = true;
for (int j = idx+1;j <= N;j++){
if(speed-v[j] > sum[j]-(time+d)){ can_keep = false; break;}
}
if(!can_keep){ dist += speed*d - (d*d)/2; speed -= d; continue;}
bool can_acc = true;
if(speed+d > v[idx]){ dist += speed*d; continue;}
for (int j = idx+1;j <= N;j++){
if(speed+d-v[j] > sum[j]-(time+d)){ can_acc = false; break;}
}
if(!can_acc){dist += speed; continue;}
dist += speed*d+(d*d)/2; speed += d;
}
printf("%.10f\n", dist);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll , ll> pll;
typedef pair<ld, ld> pld;
typedef unordered_map<ll, ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5 + 7;
const ll MAX7 = 1e+7 + 7;
const ll MAXN = MAX7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e9 + 7;
ll T = 1;
ll n, x, k, p;
string s, t;
ld w;
void MAIN() {
cin>>s;
n = s.length();
ll cou = 1;
for(ll i=1;i<n;i++) {
while(i<n && s[i]==s[i-1]) i++;
if(i < n)
cou++;
}
cout<<cou-1;
}
int main() {
fastio; randomINT;
while (T--) {
MAIN();
}
return 0;
}
| 0
| 97,942,816
|
#include <bits/stdc++.h>
#define FASTIO ios::sync_with_stdio(false);cin.tie(0);
#define ADD +
#define SUBTRACT -
#define MULTIPLY *
#define DIVIDE /
#define MOD %
#define INCREMENT(x) ++x
#define DECREMENT(x) --x
#define in(a,b) cin>>a>>b;
#define out(a,b) cout<<a<<endl<<b<<endl;
#define scan(a) scanf("%d",&a);
#define print(a) printf("%d\n",a);
#define scanii(a,b) scanf("%d %d",&a,&b);
#define printii(a,b) printf("%d\n%d\n",a,b);
#define scaniii(a,b,c) scanf("%d %d %d",&a,&b,&c);
#define pub push_back
#define pob pop_back
#define puf push_front
#define pof pop_front
#define ll long long
#define ull unsigned long long
#define sll signed long long
#define pi acos(-1)
#define mod 1000000007
#define TRUE 1
#define FALSE 0
#define ZERO 0
#define MP make_pair
#define F first
#define S second
#define f1(i,a) for(int i=0;i<a;++i)
#define f2(i,a) for(int i=a-1;i>=0;--i)
#define en puts("");
#define elif else if
typedef ll int lli;
typedef sll int slli;
typedef ull int ulli;
const int sz=10000;
using namespace std;
int clue();
int result();
void show();
bool check();
bool cmp(int p,int q) {
return p>q;
}
int main() {
int t;
t=1;
while(t-->0) {
clue();
}
return 0;
}
int clue() {
lli a,b,n;
cin>>a>>b>>n;
lli x;
a-=n;
if(a<0) {
x=-a;
a=0;
b-=x;
}
if(b<0)
{
b=0;
}
cout<<a<<" "<<b<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define itn int
#define gI gi
using namespace std;
typedef long long ll;
inline int gi()
{
int f = 1, x = 0; char c = getchar();
while (c < '0' || c > '9') {if (c == '-') f = -1; c = getchar();}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
inline ll gl()
{
ll f = 1, x = 0; char c = getchar();
while (c < '0' || c > '9') {if (c == '-') f = -1; c = getchar();}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
int n, sum[55], v[55];
map <string, int> p;
string s[55];
int main()
{
n = gi();
for (int i = 1; i <= n; i+=1)
{
cin >> s[i];
v[i] = gi();
p[s[i]] = i;
}
for (int i = n - 1; i >= 1; i-=1)
{
sum[i] = sum[i + 1] + v[i + 1];
}
cin >> s[0];
cout << sum[p[s[0]]] << endl;
return 0;
}
| 0
| 18,461,805
|
#include <bits/stdc++.h>
#include <limits>
#include <math.h>
#include <cmath>
#include <cctype>
#include <cstdio>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pll = pair<ll, ll> ;
using vs = vector<string>;
using vb = vector<bool>;
using vll = vector<long long>;
using vvll = vector<vector<long long >>;
#define PI 3.1415926535
#define rep(i, k, n) for(ll i = k; i < n; i++)
int main(){
ll n; cin >> n;
ll ans = 10000000000000000;
rep(i, 1, pow(n, 0.5)+1){
ll res;
if(n % i == 0){res = i + n/i; ans = min(res, ans);}
}
cout << ans - 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<ll,ll>;
const ll mod = 1e9+7;
#define ALL(x) (x).begin(),(x).end()
#define pow(x,y) modpow(x,y)
#define REP(i,n) for(ll (i)=0;(i)<(n);(i)++)
#define REPS(i,n) for(ll (i)=1;(i)<=(n);(i)++)
#define RREP(i,n) for(ll (i)=(n-1);(i)>=0;(i)--)
#define RREPS(i,n) for(ll (i)=(n);(i)>0;(i)--)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end());
template<class T> inline void chmin(T& a, T b){
if (a > b){
a = b;
}
}
template<class T> inline void chmax(T& a, T b){
if (a < b){
a = b;
}
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
string S;
cin >> S;
reverse(ALL(S));
ll count = 0;
int where = 0;
REP(i,S.size()){
if(S[i] == 'B'){
count += i - where;
where++;
}
}
cout << count << "\n";
}
| 0
| 49,213,975
|
#include<iostream>
#include<algorithm>
#define INF 1000000009
using namespace std;
int main() {
int dp[100000];
int n;
int a[100000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
fill(dp, dp + n, INF);
for (int i = 0; i<n; i++) {
*lower_bound(dp, dp + n, a[i]) = a[i];
}
cout << lower_bound(dp, dp + n, INF) - dp << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll,ll>;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define rep2(i,m,n) for(int (i)=(m);(i)<(n);(i)++)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
const ll INF = 1LL<<60;
const ll MOD = 1e9+7;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
string s,t;cin>>s>>t;
vector<int> cha1(26, -1), cha2(26,-1);
bool ans = true;
for(int i=0; i<s.size(); i++){
int S = s[i] - 'a', T = t[i] - 'a';
if(cha1[S]==T&&cha2[T]==S)continue;
else if(cha1[S]==-1&&cha2[T]==-1){
cha1[S]=T, cha2[T]=S;
}else{
ans = false;
break;
}
}
cout<<(ans?"Yes":"No");
return 0;
}
| 0
| 9,489,497
|
#include<vector>
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#include<queue>
#include <sstream>
#include <set>
#include<stack>
#include <utility>
const long long MOD = 1000000007;
using namespace std;
typedef long long llong;
llong dfs(llong x, llong y, vector<string> &Map, vector<vector<llong> > &dp){
if(x<0 || y<0 || x>=Map[0].size() || y>=Map.size()){
return 0;
}
if(Map[y][x]=='#'){
return 0;
}
if(dp[y][x]!=-1){
return dp[y][x];
}
if(x==0 && y==0){
return 1;
}
llong ans=0;
ans = (dfs(x-1, y, Map, dp)%MOD + dfs(x, y-1, Map, dp)%MOD)%MOD;
dp[y][x] = ans;
return ans;
}
int main(){
llong H,W;
cin >> H >> W;
vector<string> Map(H);
for(int i=0; i<H; i++){
cin >> Map[i];
}
vector<vector<llong> > dp(H, vector<llong>(W, -1));
cout << dfs(W-1, H-1, Map, dp)%MOD << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(n); i++)
#define ll long long
using namespace std;
const int CountStop=245959;
int main() {
while (1) {
int n; cin>>n;
if (n==0) break;
vector<int> x(CountStop+1, 0);
rep(i, n) {
string S,G; cin>>S>>G;
int start=0;
start+=(int)(S[0]-'0')*100000;
start+=(int)(S[1]-'0')*10000;
start+=(int)(S[3]-'0')*1000;
start+=(int)(S[4]-'0')*100;
start+=(int)(S[6]-'0')*10;
start+=(int)(S[7]-'0')*1;
x[start]++;
int goal=0;
goal+=(int)(G[0]-'0')*100000;
goal+=(int)(G[1]-'0')*10000;
goal+=(int)(G[3]-'0')*1000;
goal+=(int)(G[4]-'0')*100;
goal+=(int)(G[6]-'0')*10;
goal+=(int)(G[7]-'0')*1;
x[goal]--;
}
rep(i, CountStop) x[i+1]+=x[i];
int res=0;
rep(i, CountStop+1) res=max(res, x[i]);
cout<<res<<endl;
}
}
| 0
| 16,032,149
|
#include<bits/stdc++.h>
using namespace std;
int main(){
char s[13];
cin >> s;
for(int i=0;i<12;i++){
cout << s[i];
if(i==3){
cout << " ";
}
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<bool> vb;
#define pb push_back
#define fi first
#define se second
#define in insert
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define speed ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
const int mod = 1e9 + 7;
void solve(){
int n;
cin >> n;
unordered_set<int> s;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
s.in(x);
}
if (s.size() % 2 == 0) cout << s.size() - 1;
else cout << s.size();
}
int main(){
speed;
int t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
}
| 0
| 44,717,476
|
#include<bits/stdc++.h>
using namespace std;
#define hackcyborg shresth_walia
#define ll long long
#define ld double
#define pb push_back
#define mod 998244353
#define IO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define int long long
#define ordered_set tree<int,null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
ll bp(ll a,ll b,ll m=mod)
{
ll res=1;
if(b<0)
return bp(bp(a,m-2),-b);
while(b>0)
{
if(b&1)
res=(a*res)%m;
a=(a*a)%m;
b/=2;
}
return res;
}
main()
{
IO
ll n,g,m;
cin>>n>>g>>m;
ll po[m+1];
memset(po,-1,sizeof(po));
vector<ll> as;
as.pb(0);
ll a=g;
as.pb(g);
ll l=g;
po[l%m]=1;
ll v=1;
for(int x=2;x<=n;x++)
{
ll e=((l%m)*(l%m))%m;
if(po[e]==-1 || v==0)
{a+=e;
l=e;
po[e]=x;
as.pb(e);
}
else
{
ll k=0;
v=0;
for(int y=po[e];y<x;y++)
{
k+=as[y];
}
ll h=((n-x+1)/(x-po[e]));
a+=(((n-x+1)/(x-po[e]))*k);
x+=(h*(x-po[e]))-1;
}
}
cout<<a;
}
|
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<cstdint>
#include<cstdlib>
template<typename T>
void fin(T const& t){ std::cout << t << std::endl; exit(0); }
template<int64_t Prime>
struct mod_int {
int64_t v_;
mod_int(int64_t x=0) : v_(x) { normalize(); }
void normalize() { ((v_ %= Prime) += Prime) %= Prime; }
mod_int operator+=(mod_int const& r){ (v_ += r.v_) %= Prime; return *this; }
mod_int operator-=(mod_int const& r){ (v_ += Prime - r.v_) %= Prime; return *this; }
mod_int operator*=(mod_int const& r){ (v_ *= r.v_) %= Prime; return *this; }
mod_int operator+(mod_int const& r) const { mod_int res(*this); return res += r; }
mod_int operator-(mod_int const& r) const { mod_int res(*this); return res -= r; }
mod_int operator*(mod_int const& r) { mod_int res(*this); return res *= r; }
mod_int pow(int x) const {
int64_t res = 1, v = v_;
while(x > 0) {
if(x&1) (res *= v) %= Prime;
x/=2; (v *= v) %= Prime;
}
return mod_int(res);
}
mod_int inv() const { return pow(Prime-2); }
};
int64_t const MOD = 1e9+7;
typedef mod_int<MOD> mint;
int main() {
std::cin.tie(0); std::ios::sync_with_stdio(false);
int N; std::string S; std::cin >> N >> S;
std::vector<int> v(1, 0);
if(S[0] == 'W') fin(0);
for(int i = 1; i < N+N; ++i) {
if((S[i] == S[i-1]) != (v.back() == i-1)) v.push_back(i);
}
if(v.size() != N) fin(0);
mint ans=1;
for(int i = 0; i < N; ++i) ans *= mint(i+1)*mint(i+i+1 - v[i]);
fin(ans.v_);
return 0;
}
| 0
| 55,410,805
|
#include <stdio.h>
main(){
int a,b;
scanf("%d%d",&a,&b);
if(-1000<=a&&b<=1000){
if(a<b){
printf("a < b\n");
}
else if(a>b){
printf("a > b\n");
}
else if(a==b){
printf("a == b\n");
}
}
return 0;
}
|
#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
int n,x,ans=0;
while (1) {
cin >> n >> x;
if (n==0 && x==0) {
break;
}
for (int i=1; i<n+1; i++) {
for (int j=i+1; j<n+1; j++) {
for (int k=j+1; k<n+1; k++) {
if (i+j+k == x) {
ans++;
}
}
}
}
cout << ans <<endl;
ans = 0;
}
return 0;
}
| 0
| 4,744,375
|
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (std::abs(a-c) <= d) {
cout << "Yes" << endl;
} else if (std::abs(a-b) <= d && std::abs(b-c) <= d) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD=1e9+7;
const int INF=1e9;
const long long LINF=1e18;
#define int long long
template <typename T>
void fin(T a){
cout<<a<<endl;
exit(0);
}
signed main(){
int N;cin>>N;
string s,t;
cout<<0<<endl;cin>>s;if(s=="Vacant")return 0;
cout<<N-1<<endl;cin>>t;if(t=="Vacant")return 0;
int l=0,r=N-1;
for(int i=0;i<25;i++){
int m=(r+l)>>1;
cout<<m<<endl;string u;cin>>u;if(u=="Vacant")return 0;
if(((m-l)&1)^(s!=u))r=m,t=u;
else l=m,s=u;
}
}
| 0
| 73,254,895
|
#include <bits/stdc++.h>
using namespace std;
bool IsPrime(long long num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (long long i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
return false;
}
}
return true;
}
long long decompositPrime(long long n) {
long long cnt = 0;
map<long long, long long> m;
for (long long p = 2; p * p <= n; p++) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) {
num++;
n /= p;
}
m[p] = num;
}
if (n != 1) m[n] = 1;
for (auto itr : m) {
long long index = 1;
while (itr.second >= index) {
cnt++;
itr.second -= index;
index ++;
}
}
return cnt;
}
int main() {
long long num;
int cnt = 0;
cin >> num;
if (IsPrime(num) == true) {
cout << 1;
return 0;
}
cnt = decompositPrime(num);
cout << cnt;
}
|
#include<bits/stdc++.h>
#define rep(i,N) for(int i=0;i<(N);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e12;
const int inf = 1e9;
const int mod = 1e9+7;
typedef long long ll;
typedef pair<ll,int> P;
typedef set<int> S;
vector<long long> calc_divisor(long long n) {
vector<long long> res;
for (long long i = 1LL; i*i <= n; ++i) {
if (n % i == 0) {
res.push_back(i);
long long j = n / i;
if (j != i) res.push_back(j);
}
}
sort(res.begin(), res.end());
return res;
}
int main(){
cout << fixed << setprecision(10);
int n;
cin >> n;
vector<int> v(n);
rep(i,n) cin >> v[i];
vector<int> div(1000100,0);
rep(i,n){
div[v[i]]++;
}
int ans = 0;
rep(i,n){
bool ok = 1;
for(auto u : calc_divisor(v[i])){
if(div[u]>0 && u != v[i]){
ok = 0;
break;
}
}
if(div[v[i]] > 1) ok = 0;
if(ok) ans++;
}
cout << ans << endl;
return 0;
}
| 0
| 65,558,560
|
#include <bits/stdc++.h>
#define rep(i, s, n) for (int i = (s); i < (int)(n); i++)
#define per(i, n, s) for (int i = (n-1); i >= (int)(s); i--)
#define all(x) (x).begin(),(x).end()
#define debug(x) cout<<#x<<": "<<x<<endl
using namespace std;
using ll = long long;
const ll MOD = 1e9+7;
const ll LINF = LLONG_MAX;
const int INF = INT_MAX;
int main(){
ll s; cin>>s;
if(s==(ll)1000000000000000000){
cout<<0<<" "<<0<<" "<<1000000000<<" "<<1<<" "<<0<<" "<<1000000000<<endl;
return 0;
}
cout<<0<<" "<<0<<" "<<1000000000<<" "<<1<<" "<<1000000000 - s%(ll)(1000000000)<<" "<<s/1000000000+1<<endl;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <climits>
#include <cmath>
#include <string>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep01(i, n) for(int i = 0; i < (n) + 1; i++)
#define rep10(i, n) for(int i = 1; i < (n); i++)
#define rep11(i, n) for(int i = 1; i < (n) + 1; i++)
#define all(a) (a).begin(), (a).end()
typedef long long int ll;
typedef struct { int x; int y; } Pos;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> A(N, vector<int>());
rep(i, M) {
int a, b;
cin >> a >> b;
A[a-1].push_back(b-1);
A[b-1].push_back(a-1);
}
vector<int> pattern;
int cnt = 0;
rep(i, N) pattern.push_back(i);
do {
if (pattern[0] != 0) continue;
bool success = true;
rep(i, N-1) {
if (A[pattern[i]].end() == find(all(A[pattern[i]]), pattern[i + 1])) {
success = false;
break;
}
}
if(success) cnt++;
} while (next_permutation(all(pattern)));
cout << cnt << endl;
return 0;
}
| 0
| 3,394,401
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
while(cin >> n && n){
int judge[4] = {0}, cnt = 1, step = 0;
string str;
for(int i = 0; i < n; i++){
cin >> str;
if(str == "lu"){
if(judge[0] == 0){
judge[0] = 1;
judge[2] = 0;
}
else{
judge[0] = 0;
judge[2] = 1;
}
}else if(str == "ru"){
if(judge[1] == 0){
judge[1] = 1;
judge[3] = 0;
}
else{
judge[1] = 0;
judge[3] = 1;
}
}else if(str == "ld"){
if(judge[2] == 0){
judge[2] = 1;
judge[0] = 0;
}
else{
judge[2] = 0;
judge[0] = 1;
}
}else if(str == "rd"){
if(judge[3] == 0){
judge[3] = 1;
judge[1] = 0;
}
else{
judge[3] = 0;
judge[1] = 1;
}
}
if(judge[0] == 1 && judge[1] == 1 && judge[2] == 0 && judge[3] == 0 && cnt % 2 == 1){
cnt++;
step++;
}else if(judge[0] == 0 && judge[1] == 0 && judge[2] == 1 && judge[3] == 1 && cnt % 2 == 0){
cnt++;
step++;
}
}
cout << step << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int index = -1;
int depth = -1;
int parent = -1;
int *child;
int ccnt = 0;
int type = 0;
};
void depth(Node *node, int x, int d) {
node[x].depth = d;
for (int i = 0; i < node[x].ccnt; ++i) {
depth(node, node[x].child[i], d+1);
}
}
int Root(Node *node, int x) {
if (node[x].parent > -1) {
Root(node, node[x].parent);
} else {
return x;
}
}
int main() {
int n, b, x, y, root;
string child;
string type[] = {"leaf", "internal node", "root"};
cin >> n;
Node a[n];
for (int i = 0; i < n; ++i) {
cin >> x >> y;
a[x].index = x;
a[x].child = new int[y];
a[x].ccnt = y;
for (int j = 0; j < y; ++j) {
cin >> b;
a[x].child[j] = b;
a[x].type = 1;
a[b].parent = x;
}
}
root = Root(a, 0);
a[root].type = 2;
depth(a, root, 0);
for (auto& i : a) {
cout << "node " << i.index << ": parent = " << i.parent << ", depth = " << i.depth << ", " << type[i.type] << ", ";
child = "[";
for (int j = 0; j < i.ccnt-1; ++j) {
child += to_string(i.child[j]) + ", ";
}
if (i.ccnt) {
child += to_string(i.child[i.ccnt-1]) + "]\n";
} else {
child += "]\n";
}
cout << child;
}
return 0;
}
| 0
| 51,851,084
|
#include<bits/stdc++.h>
using namespace std;
bool mysort(const pair<int, int> &s, const pair<int, int> &t){
if(s.second!=t.second)return s.second > t.second;
return s.first > t.first;
}
int main(){
while(true){
int N, M;
cin>>N>>M;
if(N==0&&M==0)break;
vector<pair<int, int> > v;
for(int i=0; i<N; i++){
int D, P;
cin>>D>>P;
v.push_back(pair<int, int>(D, P));
}
sort(v.begin(), v.end(), mysort);
int ans=0;
for(int i=0; i<N; i++){
if(M>=v[i].first){M-=v[i].first;}
else{
ans+=(v[i].first-M)*v[i].second;
M=0;
}
}
cout<<ans<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main(void){
int a[5],m=1000,i,j;
for(i=0;i<5;i++) cin >> a[i];
for(i=0;i<5;i++){
int tmp=a[i];
for(j=0;j<5;j++){
if(i!=j){
if(a[j]%10==0) tmp+=a[j];
else tmp+=(a[j]+10-a[j]%10);
}
}
m = min(m,tmp);
}
cout << m;
}
| 0
| 69,645,238
|
#include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define what_is(x) cerr << #x << " is " << x << endl;
#define MT make_tuple
#define eb emplace_back
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define REP(i,a,b) for (int i = a; i <= b; i++)
#define FOR(i,n) for (int i=0;i < n ; i++)
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int main(){
ll n,t,a;
cin >> n >> t;
ll time[n];
cin >> time[0];
ll sum=t;
for(ll i=1; i < n;i++){
cin >> time[i];
if(time[i]-time[i-1] < t) sum+=time[i]-time[i-1];
else sum+=t;
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, a, b) for(int i = a; i < b; i++)
#define all(x) (x).begin(),(x).end()
#define rall(v) (v).rbegin(), (v).rend()
#define FastIO ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
typedef long long ll;
using P = pair<int,int>;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return true; } return false; }
vector<pair<ll, int>> factorize(ll n){
vector<pair<ll, int>> res;
for (ll i = 2; i*i <= n; ++i){
if (n%i) continue;
res.emplace_back(i, 0);
while (n%i == 0){
n /= i;
res.back().second++;
}
}
if(n != 1) res.emplace_back(n, 1);
return res;
}
int main(){
ll n;
cin >> n;
vector<pair<ll, int>> res = factorize(n);
int ans = 0;
rep(i, res.size()){
int num = res[i].second;
int j = 1;
while(j <= num){
ans++;
num -= j;
j++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 38,269,220
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define printVec(v) printf("{"); for (const auto& i : v) { std::cout << i << ", "; } printf("}\n");
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<typename KeyType, typename ValueType>
std::pair<KeyType,ValueType> get_max( const std::map<KeyType,ValueType>& x ) {
using pairtype=std::pair<KeyType,ValueType>;
return *std::max_element(x.begin(), x.end(), [] (const pairtype & p1, const pairtype & p2) {
return p1.second < p2.second;
});
}
using namespace std;
using P = pair<int,int>;
using ll = long long;
const ll INF = 1LL<<60;
int main() {
int n;
cin >> n;
vector<int> dn(n);
rep(i, n) cin >> dn[i];
int cnt = 0;
sort(dn.begin(), dn.end());
for (int i = 1; i <= 1e5; i++) {
auto iter_upper = upper_bound(dn.begin(), dn.end(), i);
if (iter_upper == dn.end()) break;
if (iter_upper - dn.begin() == dn.end() - iter_upper) ++cnt;
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < n; ++i)
#define arep(x,n) for (int x: n)
using namespace std;
int main()
{
int n; cin >> n;
vector<int> x(n); rep(i,n) cin >> x[i];
int ans = 1000000;
for(int i = 1; i <= 100; i++) {
int tmp = 0;
rep(j,n) {
tmp += (x[j] - i)*(x[j] - i);
}
ans = min(ans,tmp);
}
cout << ans << endl;
}
| 0
| 54,532,948
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<string> s(n);
for(int i=0; i<n; i++){
cin >> s[i];
}
int ans = 0;
for(int k=0; k<n; k++){
bool flag = true;
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(s[i][(j+k)%n] != s[j][(i+k)%n]) flag = false;
}
}
if(flag == true) ans += n;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9+7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define REPR(i,n) for(int i=n;i>=0;i--)
#define FOREACH(x,a) for(auto& (x) : (a) )
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
template<typename T>
void print(vector<T> &x) {
int n = x.size();
REP(i,n) {
if (i != n-1) cout << x[i] << " ";
else cout << x[i] << endl;
}
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<ll> t(n+2,0), a(n+2,0), dp(n+2, -1);
for (int i = 1; i <= n; ++i) cin >> t[i];
for (int i = 1; i <= n; ++i) cin >> a[i];
if (n == 1) {
if (t[1] != a[1]) {
cout << 0 << endl;
return 0;
}
}
for (int i = 0; i <= n; ++i) {
if (t[i] != t[i+1]) {
if (t[i+1] <= a[i+1]) {
dp[i+1] = 1;
}
else dp[i+1] = 0;
}
}
for (int i = n+1; i >= 2; --i) {
if (a[i] != a[i-1]) {
if (a[i-1] <= t[i-1]) {
dp[i-1] = 1;
}
else dp[i-1] = 0;
}
}
for (int i = 1; i <= n; ++i) {
if (dp[i] == -1) {
dp[i] = min(a[i],t[i]);
}
}
ll ans = 1ll;
for (int i = 1; i <= n; ++i) {
ans *= dp[i];
ans %= MOD;
}
cout << ans << endl;
return 0;
}
| 0
| 1,111,171
|
#include <bits/stdc++.h>
#define REP(i, m, n) for(int (i) = (m); (i) < (n); ++i)
#define rep(i, n) REP(i, 0, n)
#define all(x) (x).begin(), (x).end()
using namespace std;
using Graph = vector<vector<int>>;
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; }
typedef long long ll;
typedef pair<ll, ll> P;
const int INF = 1e9+7;
const ll LINF = 1LL<<60;
int main()
{
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int sum = 0;
rep(i, n) {
int l, r;
cin >> l >> r;
sum += r - l + 1;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define req(i,n) for(int i = 1;i <=n;i++)
#define pai 3.14159265358979323846
const int INF = 1001001001;
typedef long long ll;
int A[3][3], N;
bool punched[3][3];
bool ok[3][3];
using Graph = vector<vector<int>>;
vector<vector<int>> field;
vector<bool> seen;
const int MOD = 1000000007;
typedef pair<int,int> P;
int gcd(int a,int b){
if (a%b == 0){
return b;
}
else{
return gcd(b,a%b);
}
}
int lcm(int a,int b){
return a /gcd(a,b) * b;
}
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int a,b,c,d,e;
cin >> a >> b >> c >> d >> e;
int t[5];
t[0]=a%10;
t[1]=b%10;
t[2]=c%10;
t[3]=d%10;
t[4]=e%10;
int mini=INF,cnt=0;
rep (i,5){
if (t[i]==0){
cnt++;
}
else mini=min(mini,t[i]);
}
if (mini>10) mini=0;
a-=t[0];
b-=t[1];
c-=t[2];
d-=t[3];
e-=t[4];
if (cnt!=5)
cout << a+b+c+d+e+((5-cnt-1)*10)+mini << endl;
else cout << a+b+c+d+e+((5-cnt)*10)+mini << endl;
}
| 0
| 58,652,819
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep2(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
typedef long long ll;
const int INF = 1e+9;
const int H_MAX=300;
const int W_MAX=300;
int H,W,D;
vector<pair<int,int>> V(H_MAX*W_MAX+1);
int solve(int s,int e,vector<vector<int>> &memo){
if(memo[s][e]<INF) return memo[s][e];
int res;
int x_cur,y_cur,x_next,y_next;
if(e==0) return memo[s][e]=0;
x_cur=V[s+D*(e-1)].first;
y_cur=V[s+D*(e-1)].second;
x_next=V[s+D*e].first;
y_next=V[s+D*e].second;
res=solve(s,e-1,memo)+abs(x_cur-x_next)+abs(y_cur-y_next);
return memo[s][e]=res;
}
int main(){
cin >> H >> W >> D;
vector<vector<int>> memo(D+1,vector<int>((H*W)/D+1,INF));
int a;
rep(i,H){
rep(j,W){
cin >> a;
V[a]={i,j};
}
}
int Q;
int ans;
cin >> Q;
vector<int> L(Q),R(Q);
rep(i,Q) cin >> L[i] >> R[i];
int start,true_end,nise_end;
rep(i,Q){
start=L[i]%D;
if(start==0) start+=D;
true_end=(R[i]-start)/D;
nise_end=(L[i]-start)/D;
cout << solve(start,true_end,memo)-solve(start,nise_end,memo) << endl;
}
return 0;
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define pcnt(bit) __builtin_popcount(bit)
#define mod 1000000007
#define pi acos(-1.0)
using namespace std;
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
map<string, int> mp;
string f;
rep(i,n) {
string w;
cin >> w;
if (mp[w] > 0) {
cout << "No" << endl;
return 0;
}
else if (i >= 1 && f[f.size()-1] != w[0]) {
cout << "No" << endl;
return 0;
}
else {
mp[w]++;
f = w;
}
}
cout << "Yes" << endl;
return 0;
}
| 0
| 19,349,294
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
const double PI = 3.14159265358979323846;
typedef vector<int> vint;
typedef pair<int, int> pint;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int extgcd(int a, int b, int& x, int& y) {
int d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
int mod_inverse(int a, int m) {
int x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
int fact[1100000], fact_inv[1100000];
int mod_fact(int n, int m) {
fact[0] = fact_inv[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i % m;
fact_inv[i] = mod_inverse(fact[i], m);
}
}
int n;
int a[110000], idx[110000];
int mod = 1e9 + 7;
signed main() {
cin >> n;
n++;
mod_fact(n, mod);
for (int i = 1; i <= n; i++)cin >> a[i];
int x;
for (int i = 1; i <= n; i++) {
if (idx[a[i]] != 0)x = i - idx[a[i]] + 1;
idx[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
int ans = fact[n] * fact_inv[i] % mod * fact_inv[n - i] % mod;
if (n - x >= i - 1)ans = (ans + mod - fact[n - x] * fact_inv[i - 1] % mod * fact_inv[n - x - (i - 1)] % mod) % mod;
cout << ans << endl;
}
}
|
#include <iostream>
#include <iomanip>
#include <cassert>
#include <cstring>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <limits>
#include <queue>
#include <unordered_map>
#include <list>
#include <set>
#include <numeric>
using namespace std;
using ll = long long;
#define rep_init(i, init, n) for(int i = (init); i < (n); ++i)
#define rep(i, n) rep_init(i, 0, n)
int main()
{
int N, A, B, C;
cin >> N >> A >> B >> C;
vector<int> l(N);
rep(i, N)
{
cin >> l[i];
}
auto ans = numeric_limits<int>::max();
rep(i, 1 << (N * 2))
{
vector<int> uA, uB, uC;
rep(j, N)
{
auto k = (i >> (j * 2)) % (1 << 2);
if (k == 0)
{
uA.push_back(l[j]);
}
else if (k == 1)
{
uB.push_back(l[j]);
}
else if (k == 2)
{
uC.push_back(l[j]);
}
}
if (uA.empty() || uB.empty() || uC.empty())
{
continue;
}
auto sumA = accumulate(uA.begin(), uA.end(), 0);
auto sumB = accumulate(uB.begin(), uB.end(), 0);
auto sumC = accumulate(uC.begin(), uC.end(), 0);
ans = min(ans, abs(sumA - A) + abs(sumB - B) + abs(sumC - C) + static_cast<int>(uA.size() + uB.size() + uC.size() - 3) * 10);
}
cout << ans << endl;
return 0;
}
| 0
| 5,053,288
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int64_t out=1;
for(int i=0;i<n;i++){
int64_t t;
cin>>t;
out=lcm(out,t);
}
cout<<out<<endl;
return 0;
}
|
#include<cstdlib>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<cstring>
using namespace std;
const int MAXN = (int) 105;
const int INF = (int) 0x3f3f3f3f;
typedef long long LL;
int m,n;
vector<pair<int,int> > g;
void work(){
while(~scanf("%d%d",&n,&m)){
if(m==0&&n==0) return;
int tot=0;
g.clear();
for(int i=1;i<=n;i++){
int d,p; scanf("%d%d",&d,&p);
tot+=d;
g.push_back(make_pair(p,d));
}
sort(g.begin(),g.end());
int ans=0;
tot-=m;
for(int i=0;tot>0&&i<g.size();i++){
int p=g[i].first;
int d=g[i].second;
if(tot>d){
tot-=d;
ans+=d*p;
}
else{
ans+=tot*p;
tot=0;
}
}
printf("%d\n",ans);
}
}
int main(){
#ifdef NNever
freopen("data.in","r",stdin);
freopen("out.txt","w",stdout);
#endif
work();
return 0;
}
| 0
| 77,309,852
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << ": " << x << '\n'
typedef long long int ll;
typedef pair<int, int> P;
const long long INF = 3e18 + 12;
const int inf = 1e9;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b;
cin >> a >> b;
if (a == 1) a += 13;
if (b == 1) b += 13;
if (a == b) {
cout << "Draw" << endl;
} else if (a > b) {
cout << "Alice" << endl;
} else {
cout << "Bob" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef pair<int, int> PII;
typedef long long LL;
typedef pair<LL, LL> PLL;
#define PB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define FOR(i,a,b) for(LL i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define SORT(c) sort((c).begin(),(c).end())
#define CLR(a) memset((a), 0 ,sizeof(a))
const LL INF=1e9;
int main(){
int Q;
cin>>Q;
vector<LL>res;
REP(i,Q){
LL A,B;
cin>>A>>B;
if (A>B)swap(A,B);
if(B-A<=1LL){
res.PB(2LL*(A-1LL));
}else{
LL C=sqrt(A*B);
if(C*C==A*B)C--;
if(C*(C+1LL)>=A*B){
res.PB(2LL*C-2LL);
}else{
res.PB(2LL*C-1LL);
}
}
}
REP(i,Q)cout<<res[i]<<endl;
return 0;
}
| 0
| 25,499,218
|
#include <iostream>
#include <cctype>
#include <string>
#include <string.h>
using namespace std;
int main(){
string a, b;
cin >> a >> b;
a = a + a ;
if(a.find(b) != std::string::npos){
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
string A;
cin>>A;
if(A=="RRR"){
cout<<3;
}
else if(A=="SSS"){
cout<<0;
}
else if(A=="SRR"||A=="RRS"){
cout<<2;
}
else if(A=="SRS"||A=="RSS"||A=="SSR"||A=="RSR"){
cout<<1;
}
return 0;
}
| 0
| 15,748,811
|
const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > G;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Ans[2] = {"No", "Yes"};
string ANS[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
vi ri(string s)
{
vi ans(s.size());
vi kek(26, -1);
int t = 0;
for (int i = 0; i < s.size(); i++)
{
if (kek[s[i] - 'a'] == -1)
{
kek[s[i] - 'a'] = t;
t++;
}
ans[i] = kek[s[i] - 'a'];
}
return ans;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
vector<int> a = ri(s), b = ri(t);
cout << Ans[a == b];
}
|
#include <iostream>
#include <bitset>
using namespace std;
int main() {
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int n, s, sum, cnt;
while (cin >> n >> s) {
if (!n && !s) { break; }
cnt = 0;
for (int i = 0; i < (1 << 10); i++) {
sum = 0;
for (int j = 0; j < 10; j++) {
if (i & (1 << j)) {
sum += a[j];
}
}
if (sum == s && bitset<10>(i).count() == n) { cnt++; }
}
cout << cnt << endl;
}
return 0;
}
| 0
| 25,986,514
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string str;
int m, h, i;
while (cin >> str, str != "-") {
cin >> m;
for (i = 0; i<m; i++) {
cin >> h;
str = str.substr(h, str.size() - h) + str.substr(0,h);
}
cout << str << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned ui;
typedef unsigned long long ul;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<int> vi;
#define pb push_back
#define fi first
#define se second
#define do(i, j, k) for(int i = j; i <= (k); i ++)
#define open(i, j, k) for(int i = j; i < (k); i ++)
#define dec(i, j, k) for(int i = j; i >= (k); i --)
#define mfil(x, k) memset(x, k, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
#define fio(x) freopen(x".in", "r", stdin); freopen(x".out", "w", stdout)
template <class T> bool chkmin(T &x, T y)
{ return y < x ? (x = y, true) : false; }
template <class T> bool chkmax(T &x, T y)
{ return y > x ? (x = y, true) : false; }
struct __init { __init()
{
ios::sync_with_stdio(false); cin.tie(0);
cout.precision(16); cout << fixed;
srand(time(0) ^ ul(new char));
} } static __init__;
const int maxn = 1e5 + 10;
int n;
vi h[maxn];
int du[maxn];
bool vis[maxn];
priority_queue<pii, vector<pii>, greater<pii>> pq;
void fir()
{
cout << "First\n";
exit(0);
}
void sec()
{
cout << "Second\n";
exit(0);
}
int find_head(int x)
{
if(du[x] > 1)
return x;
vis[x] = true;
int y = -1;
for(int v : h[x])
if(!vis[v])
y = v;
if(y == -1)
return -1;
du[y] --;
return find_head(y);
}
int main()
{
cin >> n;
for(int i = 1, u, v; i < n; i ++)
{
cin >> u >> v;
h[u].pb(v);
h[v].pb(u);
du[u] ++;
du[v] ++;
}
do(i, 1, n)
if(du[i] == 1)
pq.push({du[h[i][0]], i});
while(!pq.empty())
{
pii p = pq.top();
pq.pop();
int x = p.se;
if(vis[x])
continue;
vis[x] = true;
int y = -1;
for(int v : h[x])
if(!vis[v])
y = v;
if(y == -1 || du[y] >= 3)
fir();
vis[y] = true;
for(int v : h[y])
if(!vis[v])
{
du[v] --;
if(du[v] == 0)
fir();
else if(du[v] == 1)
{
for(int vv : h[v])
if(!vis[vv])
pq.push({du[vv], v});
}
else if(du[v] == 2)
{
for(int vv : h[v])
if(!vis[vv] && du[vv] == 1)
pq.push({du[v], vv});
}
}
}
sec();
return 0;
}
| 0
| 45,376,438
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9+7;
const long long INF = 9e15;
const double PI = 3.14159265358979323846;
using ll = long long;
using P = pair<long long, long long>;
using vl = vector<long long>;
using vvl = vector<vector<long long>>;
using vP = vector<pair<long long, long long>>;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, k, n) for (int i = k; i < n; i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define pb push_back
#define mkp make_pair
#define vin(v, N) for (long long i = 0; i < N; i++) cin >> v.at(i)
#define lin(n)long long n;cin >> n
#define chin(x)char x;cin >> x;
#define sin(s)string s;cin >> s;
#define vlin(v, N)vector<long long> v(N);for (long long i = 0; i < N; i++)cin >> v.at(i)
#define max(a, b) max((ll)a, (ll)b)
#define min(a, b) min((ll)a, (ll)b)
long long gcd(long long m, long long n){
long long a = max(m, n);
long long b = min(m, n);
long long r = a % b;
while (r != 0){
a = b;
b = r;
r = a % b;
}
return b;
}
long long lcd(long long m, long long n){
return m * n / gcd(m, n);
}
long long power(long long x, long long N){
long long ret = 1;
for (long long i = 0; i < N; i++)
ret *= x;
return ret;
}
long long repeat_squaring(long long x, long long n){
if (n == 0)
return 1;
else if (n % 2 == 0)
{
long long t = repeat_squaring(x, n / 2);
return t * t % mod;
}
else
return x * repeat_squaring(x, n - 1);
}
map<long long, long long> factor(long long p){
ll p1 = p;
map<long long, long long> ret;
for (long long i = 2; i * i <= p1; i++)
{
while (p % i == 0)
{
ret[i]++;
p /= i;
}
}
if (p != 1)
ret[p]++;
return ret;
}
bool is_prime(long long N){
for (long long i = 2; i * i <= N; i++)
{
if (N % i == 0)
return false;
}
return true;
}
void chmax(long long &a, long long b){
a = max(a, b);
}
void chmin(long long &a, long long b){
a = min(a, b);
}
struct UnionFind
{
vector<long long> par;
vector<long long> s;
UnionFind(long long N) : par(N), s(N){
for (long long i = 0; i < N; i++)
{
par[i] = i;
s[i] = 1;
}
}
long long root(long long i){
if (par[i] == i)
return i;
par[i] = root(par[i]);
return root(par[i]);
}
long long size(long long i){
return s[root(i)];
}
bool same(long long x, long long y){
return root(x) == root(y);
}
void unite(long long x, long long y){
if (!same(x, y)){
long long rx = root(x);
long long ry = root(y);
par[rx] = par[ry];
s[ry] = s[rx] + s[ry];
}
}
};
struct BIT{
vector<long long> bit;
long long N;
BIT(long long n){
N = n;
bit.resize(N + 1);
}
void add(long long i, long long w){
for (long long x = i; x <= N; x += x & -x){
bit[x] += w;
}
}
long long sum(long long i){
long long ret = 0;
for (long long x = i; x > 0; x -= x & -x){
ret += bit[x];
}
return ret;
}
};
int main(){
std::cout << fixed << setprecision(10);
lin(N);vlin(a,N);
vl dp(N, INF);
rep(i,N){
auto iter = lower_bound(all(dp), a[i]);
*iter = a[i];
}
ll res = 0;
rep(i,N){
if(dp[i] != INF) res++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using boost::multiprecision::cpp_int;
using namespace std;
#if __has_include("print.hpp")
#include "print.hpp"
#endif
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#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; }
typedef long long ll;
typedef pair<ll, ll> p;
ll n, x, m;
vector<ll> dp;
void f(ll a, ll m){
set<ll> s;
for (ll i = 1; i < a; ++i) {
dp[i] = (dp[i-1] * dp[i-1]) % m;
if(s.count((dp[i-1] * dp[i-1]) % m) == 1) break;
s.insert(dp[i]);
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> x >> m;
dp = vector<ll> (m+10, -1);
dp[0] = x;
f(n+1, m);
ll res = 0;
vector<ll> mp(m+10);
ll tmp = 0;
for (ll i = 0; i < 1000000; ++i) {
mp[dp[i]] = i;
if(dp[i+2] == -1){
tmp = i;
break;
}
}
ll syu = 0;
for (ll i = 0; i < mp[dp[tmp+1]]; ++i) {
res += dp[i];
n--;
}
for (ll i = mp[dp[tmp+1]]; i <= tmp; ++i) {
syu += dp[i];
}
ll len = tmp - mp[dp[tmp+1]] + 1;
res += (n/len)*syu;
n %= len;
for (ll i = mp[dp[tmp+1]]; i < mp[dp[tmp+1]] + n; ++i) {
res += dp[i];
}
cout << res << endl;
}
| 0
| 40,189,860
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<long long int> a(n);
vector<long long int> num(200001,0);
for(int i=0; i<n; i++){
cin >> a.at(i);
num.at(a.at(i))++;
}
long long int count=0;
for(int i=1; i<200001; i++){
count+=num.at(i)*(num.at(i)-1)/2;
}
long long int ans;
for(int i=0; i<n; i++){
ans=count-num.at(a.at(i))+1;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=2001,INF=1<<30;
int main(){
int N;cin>>N;
vector<int> A(N),S(100,0);
for(int i=0;i<N;i++){
cin>>A[i];
S[A[i]]++;
}
sort(all(A));
bool flag=true;
if(A[0]*2<A[N-1]) flag=false;
if(N!=2&&A[0]==A[1]&&A[0]==1) flag=false;
if(A[N-2]!=A[N-1]) flag=false;
if(N==2){
if(A[0]!=1||A[1]!=1) flag=false;
}
else{
for(int i=1;i<N-1;i++){
if(S[i-1]&&S[i+1]&&!S[i]) flag=false;
}
if(A[0]==A[2]) flag=false;
if(A[N-1]<=A[0]*2-2) flag=false;
if(A[0]==A[1]&&A[N-1]==A[0]*2) flag=false;
}
if(flag) cout<<"Possible"<<endl;
else cout<<"Impossible"<<endl;
}
| 0
| 6,498,243
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF = (1<<30) - 1;
const ll LINF = (1LL<<60) - 1;
int main(){
string s,t;
cin >> s >> t;
cout << t + s << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int dp[1145][1145];
int main(){
string s1,s2;
cin>>s1>>s2;
int n=s1.size(),m=s2.size();
for(int i=0;i<=n;i++){
for(int j=0;j<=m;j++){
dp[i][j]=1e9;
}
}
for(int i=0;i<=n;i++)dp[i][0]=i;
for(int j=0;j<=m;j++)dp[0][j]=j;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
dp[i][j]=min(dp[i][j],dp[i-1][j]+1);
dp[i][j]=min(dp[i][j],dp[i][j-1]+1);
dp[i][j]=min(dp[i][j],dp[i-1][j-1]+(s1[i-1]!=s2[j-1]));
}
}
cout<<dp[n][m]<<endl;
return 0;
}
| 0
| 91,653,328
|
#include <bits/stdc++.h>
using namespace std;
#include <string.h>
#include <map>
#define MEM(var, val) memset(var, (val), sizeof(var))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define nitro \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define mod 1000000007
vector<string>mat;
vector<vll>dp;
ll h,w;
ll paths(ll i,ll j)
{
if(i>h-1||j>w-1)
return 0;
if(i==h-1&&j==w-1)
return 1;
if(mat[i][j]=='#')
return 0;
ll &ans=dp[i][j];
if(ans!=-1)
return ans;
ans=paths(i+1,j)+paths(i,j+1);
ans=ans%mod;
return ans;
}
int main()
{
cin>>h>>w;
mat.clear();
mat.resize(h);
dp.clear();
dp.resize(h);
for(int i=0;i<h;i++)
cin>>mat[i];
for(int i=0;i<h;i++)
dp[i].resize(w,-1);
cout<<paths(0,0);
}
|
#include<bits/stdc++.h>
#define rep(i, n) for (int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
int main(void){
int n;
cin>>n;
vector<string> v(n);
int ans=0;
rep(i, n){
cin>>v[i];
rep(j, v[i].size()-1){
if(v[i][j] =='A' && v[i][j+1] =='B') ans++;
}
}
int ba=0;
int b=0;
int a=0;
rep(i, n){
int l = v[i].size();
if(v[i][0] == 'B' && v[i][l-1] == 'A'){
ba++;
}
else if(v[i][0]=='B') b++;
else if(v[i][l-1]=='A') a++;
}
ans+=max(0, ba-1);
if(a>0 && ba!=0) {
ans++;
--a;
}
if(b>0 && ba!=0){
ans++;
--b;
}
ans+=min(a, b);
cout<<ans<<endl;
return 0;
}
| 0
| 70,851,842
|
#include <bits/stdc++.h>
typedef long long ll;
typedef std::pair<int,int> pii;
typedef std::pair<ll,ll> pll;
typedef std::pair<std::string,ll> psl;
#define INF INT_MAX
#define INF_L LONG_MAX
#define INF_LL LLONG_MAX
#define MOD 1000000007
#define REP(ii,jj,nn) for (ll ii=jj;ii<(nn);ii++)
#define RREP(ii,nn,jj) for (ll ii = nn; jj<ii;ii--)
#define each(i,...) for (auto&& i:__VA_ARGS__)
#define ALL(vec) (vec).begin(),(vec).end()
#define sum(...) accumulate(ALL(__VA_ARGS__),0LL)
#define dsum(...) accumulate(ALL(__VA_ARGS__),0.0)
#define vec(type,name,...) vector<type> name(__VA_ARGS__)
template<class T> inline auto max(const T& a){ return *max_element(ALL(a)); }
template<class T> inline auto min(const T& a){ return *min_element(ALL(a)); }
inline ll gcd(ll a,ll b){if(b == 0) return a;return gcd(b,a%b);}
inline ll lcm(ll a,ll b){ll g = gcd(a,b);return a / g * b;}
using namespace std;
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector< vector<ll> > abc(n,vector<ll>(3));
REP(i,0,n){
REP(j,0,3){
cin >> abc[i][j];
}
}
vector<vector<ll>> dp(n,vector<ll>(3));
dp[0][0] = abc[0][0];
dp[0][1] = abc[0][1];
dp[0][2] = abc[0][2];
REP(i,1,n){
REP(j,0,3){
ll x = dp[i-1][(j+1)%3], y = dp[i-1][(j+2)%3];
dp[i][j] = x > y ? x : y;
dp[i][j] += abc[i][j];
}
}
ll ans = 0;
REP(i,0,3){
ans = max(dp[n-1][i],ans);
}
cout << ans << endl;
return 0;
}
|
#define DEBUG 1
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using tll = tuple<ll, ll, ll>;
using vtll = vector<tll>;
using vvtll = vector<vtll>;
#define all(v) (v).begin(), (v).end()
#define for1(i, n) for (ll i = 0; i < (n); i++)
#define for2(i, m, n) for (ll i = (m); i < (n); i++)
#define for3(i, m, n, d) for (ll i = (m); i < (n); i += (d))
#define rfor2(i, m, n) for (ll i = (m); i > (n); i--)
#define rfor3(i, m, n, d) for (ll i = (m); i > (n); i += (d))
#define PI 3.1415926535897932384626433832795028841971693993751L
#define INF 1111111111111111111LL
#define print(...) print_1(__VA_ARGS__)
#define in(...) in_1(__VA_ARGS__)
#if DEBUG
#define dump(...) dump_1(#__VA_ARGS__, __VA_ARGS__)
#define dumpa(...) dumpa_1(#__VA_ARGS__, __VA_ARGS__)
#else
#define dump(...)
#define dumpa(...)
#endif
template <typename Head>
void dump_1(const char* str, Head&& h)
{
cerr << str << ": " << h << '\n';
}
template <typename Head, typename... Tail>
void dump_1(const char* str, Head&& h, Tail&&... t)
{
while (*str != ',') {
cerr << *str++;
}
cerr << ": " << h << ' ';
dump_1(str + 1, t...);
}
template <typename T>
void dumpa_1(const char* str, const T v[], const ll size)
{
while (*str != ',') {
cerr << *str++;
}
cerr << ": ";
for1 (i, size) {
if (i != 0) {
cerr << ' ';
}
cerr << v[i];
}
cerr << '\n';
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& v)
{
os << v.first << ' ' << v.second;
return os;
}
template <typename T1, typename T2, typename T3>
ostream& operator<<(ostream& os, const tuple<T1, T2, T3>& v)
{
os << get<0>(v) << ' ' << get<1>(v) << ' ' << get<2>(v);
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v)
{
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v)
{
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const map<T1, T2>& v)
{
os << '{';
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ", ";
}
os << it->first << ':' << it->second;
}
os << '}';
return os;
}
void Yes(void) { cout << "Yes\n"; }
void No(void) { cout << "No\n"; }
void YES(void) { cout << "YES\n"; }
void NO(void) { cout << "NO\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;
}
template <typename T>
void vin(vector<T>& v, ll len)
{
for1 (i, len) {
cin >> v[i];
}
}
template <typename Head>
void in_1(Head& h)
{
cin >> h;
}
template <typename Head, typename... Tail>
void in_1(Head& h, Tail&... t)
{
cin >> h;
in_1(t...);
}
template <typename Head>
void print_1(Head&& h)
{
cout << h << '\n';
}
template <typename Head, typename... Tail>
void print_1(Head&& h, Tail&&... t)
{
cout << h << ' ';
print_1(t...);
}
struct UnionFind {
vll parent;
vll mini;
vll maxi;
ll N;
UnionFind(ll n)
{
this->N = n;
this->parent = vll(n, -1);
this->mini = vll(n);
this->maxi = vll(n);
for1 (i, n) {
this->mini[i] = i;
this->maxi[i] = i;
}
}
ll root(ll A)
{
if (this->parent[A] < 0) return A;
return this->parent[A] = this->root(this->parent[A]);
}
ll size(ll A)
{
return -this->parent[this->root(A)];
}
bool connect(ll A, ll B)
{
A = this->root(A);
B = this->root(B);
if (A == B) {
return false;
}
if (this->size(A) < this->size(B)) {
swap(A, B);
}
this->parent[A] += this->parent[B];
this->parent[B] = A;
chmax(this->maxi[A], this->maxi[B]);
chmin(this->mini[A], this->mini[B]);
return true;
}
};
void solve()
{
ll N, M;
in(N, M);
vll P(N);
vin(P, N);
for1 (i, N) {
P[i]--;
}
UnionFind uni(N);
for1 (i, M) {
ll x, y;
in(x, y);
x--;
y--;
uni.connect(x, y);
}
ll ans = 0;
for1 (i, N) {
if (uni.root(i) == uni.root(P[i])) {
ans++;
}
}
print(ans);
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(16);
cerr << fixed << setprecision(16);
solve();
}
| 0
| 27,507,617
|
#include <bits/stdc++.h>
using namespace std;
#define llong long long int
#define ldouble long double
#define rep(i, n) for (int i = 0; i < n; ++i)
#define stl_rep(itr, x) for (auto itr = x.begin(); itr != x.end(); ++itr)
#define all(x) x.begin(), x.end()
#define allr(x) x.rbegin(), x.rend()
constexpr static int MOD = 1000000000 + 7;
constexpr static int inf = INT_MAX / 2;
constexpr static llong INF = 1LL<<31;
constexpr static int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int main (int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
llong a, b;
cin >> a >> b;
if (abs(a - b) <= 1) cout << "Brown";
else cout << "Alice";
cout << endl;
return 0;
}
|
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<=n;i++)
#define int long long
#define ll long long
#define eps LDBL_EPSILON
#define mod (ll)1000000007
#define INF LLONG_MAX/10
#define P pair<int,int>
#define prique priority_queue
using namespace std;
int q, a, b;
signed main() {
cin >> q;
rep(i, q) {
cin >> a >> b;
int mi = min(a, b), ma = max(a, b) + 1;
while (mi + 1 < ma) {
int md = (mi + ma) / 2;
if (md * md < a * b)mi = md;
else ma = md;
}
int c = mi;
if (a == b || abs(a - b) == 1)cout << min(a, b) * 2 - 2 << endl;
else if (c * (c + 1) >= a * b)cout << c * 2 - 2 << endl;
else cout << c * 2 - 1 << endl;
}
}
| 0
| 74,792,585
|
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(a); (i)<(b); ++(i))
#define rFor(i, a, b) for(int (i)=(a)-1; (i)>=(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef pair<int, int> pii;
const lint mod = 1e9 + 7;
lint powmod(long x, long n){
lint ret = 1;
while(n > 0){
if(n&1) ret *= x, ret %= mod, n -= 1;
else x *= x, x %= mod, n >>= 1;
}
return ret;
}
vector<lint> fact;
vector<lint> revfact;
void setfact(int n){
fact.resize(n+1); revfact.resize(n+1);
fact[0] = 1;
rep(i, n) fact[i+1] = fact[i] * (i+1) % mod;
revfact[n] = powmod(fact[n], mod-2);
for(int i=n-1; i>=0; i--) revfact[i] = revfact[i+1] * (i+1) % mod;
}
int main(){
int n;
string s;
cin >> n >> s;
if(s[0] == 'W' || s[2*n-1] == 'W'){
printf("0\n");
return 0;
}
int ed[2*n];
ed[0] = 0;
int cnt = 0;
rep(i, 2*n-1){
ed[i+1] = ed[i] ^ (s[i] == s[i+1]);
cnt += ed[i+1];
}
if(cnt != n){
printf("0\n");
return 0;
}
setfact(n);
lint ans = fact[n];
lint cur = 0;
rep(i, 2*n){
if(ed[i]) ans = ans * (cur--) % mod;
else ++cur;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
#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 hahashad ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
typedef long long ll;
#define VL vector<ll>
#define IN(inp) ll inp;cin>>inp;
#define pb push_back
#define what(A) cout<<#A<<" is "<<A<<endl;
ll isprime[1000005];
ll ans;
void divisors()
{
FOR(i,1,1e6+1)
{
if(isprime[i]==0)
continue;
if(isprime[i]==1)
{
ans++;
}
for(ll j=2*i;j<=1e6;j+=i)
{
isprime[j]=0;
}
}
}
int main()
{
ll n;
cin >> n;
FOR(i, 0, n)
{
IN(inp)
isprime[inp]++;
}
divisors();
cout<<ans;
}
| 0
| 19,999,213
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
long long i;
for(i=0;i<12;i++){
if(i==4)
cout<<" "<<s[i];
else
cout<<s[i];
}cout<<endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
int k[500];
int n;
cin >> n;
for(int i = 1; i <= n; i++){
cin >> k[i];
}
for(int i = 1; i <= n; i++){
cout << "node " << i;
cout << ": key = " << k[i];
if(i > 1){
cout << ", parent key = " << k[i/2];
}
if(2*i <= n){
cout << ", left key = " << k[2*i];
}
if(2*i+1 <= n){
cout << ", right key = " << k[2*i+1];
}
cout << ", " << endl;
}
}
| 0
| 43,258,444
|
#include <bits/stdc++.h>
#define INF (1000000000000000000)
#define LL long long
using namespace std;
int main()
{
int n = 0 ;
int r = 0;
cin >> n >> r;
if(n < 10)
{
cout<<r+(100*(10-n));
}else
{
cout<<r;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, a, b) for(int i = a; i < b; i++)
#define all(x) (x).begin(),(x).end()
#define rall(v) (v).rbegin(), (v).rend()
#define FastIO ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
typedef long long ll;
using P = pair<int,int>;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return true; } return false; }
vector<pair<ll, int>> factorize(ll n){
vector<pair<ll, int>> res;
for (ll i = 2; i*i <= n; ++i){
if (n%i) continue;
res.emplace_back(i, 0);
while (n%i == 0){
n /= i;
res.back().second++;
}
}
if(n != 1) res.emplace_back(n, 1);
return res;
}
int main(){
ll n;
cin >> n;
vector<pair<ll, int>> res = factorize(n);
int ans = 0;
rep(i, res.size()){
int num = res[i].second;
int j = 1;
while(j <= num){
ans++;
num -= j;
j++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 54,034,995
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
char a[5];
cin>>a;
if((a[0]==a[1])&&(a[1]==a[2]))
cout<<"Yes"<<endl;
else if((a[1]==a[2])&&(a[2]==a[3]))
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
#define loop(i,n) for(int i=0;i<n;i++)
#define read(a) int a; cin >>a;
#define readarr(a,n) int a[n] ; for(int i=0;i<n;i++) cin >> a[i];
#define readmat(a,n,m) int a[n][m]; for(int i=0;i<n;i++) for(int j=0;j<m;j++) cin >> a[i][j];
#define pb push_back
#define ff first
#define ss second
#define vi vector<int>
#define pi pair<int,int>
#define vvi vector<vector<int>>
#define sti set<int>
#define vpi vector<pair<int,int>>
#define print(a,n) for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;
#define printmat(a,n,m) for(int i=0;i<n;i++) {for(int j=0;j<m;j++) cout<<a[i][j]<<" "; cout<<endl;}
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);
#define endl "\n"
#define mp make_pair
#define ins insert
#define rep(i,s,e) for(int i=s;i<=e;i++)
#define repd(i,s,e) for(int i=e;i>=s;i--)
#define vb vector<bool>
#define read2(n,m) int n,m; cin >> n >> m;
#define range(v) v.begin(),v.end()
#define sortd(v) sort(v.begin(),v.end(),greater<int>())
#define sorti(v) sort(v.begin(),v.end())
const ll inf = 1e18;
const ll mod = 1e9 + 7;
signed main()
{
fast;
read2(n,m);
readarr(a,n);
int k=0;
int lcm = a[0]/2;
sti v;
rep(i,0,n-1) {
a[i]=a[i]/2;
int x=a[i];
k=0;
while(x%2==0){
k++;
x=x/2;
}
v.ins(k);
lcm = (lcm*a[i])/__gcd(a[i],lcm);
}
if(v.size()!=1) {
cout<<0<<endl;
return 0;
}
int i=1,ans=0;
if(m<lcm) {
cout<<0<<endl;
return 0;
}
ans = m/lcm;
ans = (ans+1)/2;
cout<<ans<<endl;
return 0;
}
| 0
| 14,421,106
|
#include <iostream>
#include <string>
#include <vector>
#define fastIO (cin.tie(0), cout.tie(0), ios::sync_with_stdio(false))
#define rep(i, n) for (int i = 0; i < (n); ++i)
using lint = long int;
using llint = long long int;
using namespace std;
int main() {
fastIO;
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (1 <= i && i <= 9)
cnt++;
else if (100 <= i && i <= 999)
cnt++;
else if (10000 <= i && i <= 99999)
cnt++;
}
cout << cnt << endl;
}
|
#include<cstdio>
#include<cstring>
using namespace std;
const int INF=1e9;
const int maxn=200100;
char str[maxn];
int dp[1<<26];
int zt[1<<26];
int n;
int main(){
scanf("%s",str+1);
n=strlen(str+1);
zt[0]=0;
for(int i=1;i<=n;i++)
zt[i]=zt[i-1]^(1<<(str[i]-'a'));
for(int i=0;i<(1<<26);i++)
dp[i]=INF;
for(int i=0;i<26;i++)
dp[1<<i]=0;
dp[0]=0;
int st;
for(int i=1;i<=n;i++){
st=dp[zt[i]]+1;
for(int j=0;j<26;j++)
if(st<dp[zt[i]^(1<<j)])
dp[zt[i]^(1<<j)]=st;
if(i==n) printf("%d\n",st);
}
return 0;
}
| 0
| 43,644,567
|
#include <bits/stdc++.h>
#define PB emplace_back
using namespace std;
const int N = 1e5+100;
int n;
vector<int> v[N];
bool ok = 1, dp[N][3];
void dfs(int x, int px = -1) {
for(int u: v[x]) {
if(u != px) dfs(u, x);
}
int zero=0, one=0;
for(int u: v[x]) {
if(u != px) {
if(dp[u][0]) zero++;
if(dp[u][1]) one++;
}
}
if(zero + one != (int)v[x].size() - (px != -1)) return;
if(zero == 1) {
dp[x][1] = 1;
}
if(zero == 0) {
dp[x][0] = 1;
}
}
int main () {
ios::sync_with_stdio(0);
cin >> n;
for(int i = 0, u1, u2 ; i < n - 1 ; i++ ) {
cin >> u1 >> u2;
u1--;
u2--;
v[u1].PB(u2);
v[u2].PB(u1);
}
dfs(0);
cout << ((dp[0][1]) ? "Second" : "First") << '\n';
}
|
#include <iostream>
#include <utility>
#include <cstdio>
using namespace std;
int main(void) {
int nums[3];
cin >> nums[0] >> nums[1] >> nums[2];
if (nums[2] < nums[1])
swap(nums[2], nums[1]);
if (nums[2] < nums[0])
swap(nums[2], nums[0]);
if (nums[1] < nums[0])
swap(nums[1], nums[0]);
printf("%d %d %d\n", nums[0], nums[1], nums[2]);
return 0;
}
| 0
| 57,347,264
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double l;
cin >> l;
printf("%.12f\n", pow(l/3, 3));
return 0;
}
|
#include <iostream>
#include <stack>
#include <string>
using std::cout;
using std::cin;
using std::endl;
using std::string;
using std::stack;
int main(void) {
string s;
stack<char> st;
char comp;
bool check;
while (getline(cin, s)) {
if (s[0] == '.') {
break;
}
check = true;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(' || s[i] == '[') {
st.push(s[i]);
} else if (s[i] == ')' || s[i] == ']') {
if (st.empty()) {
check = false;
break;
}
comp = st.top();
st.pop();
if ((comp == '(' && s[i] == ']') || (comp == '[' && s[i] == ')')) {
check = false;
break;
}
}
}
if (! st.empty()) {
check = false;
while (! st.empty()) {
st.pop();
}
}
if (check == true) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
}
return 0;
}
| 0
| 71,333,865
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define dl double long
const int INF=0x3fffffff;
const ll MOD=1000000007;
const ll MODD=998244353;
#define rrep(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool chmin(T &m, const T q) { if (m > q) {m = q; return true;} else return false; }
ll gcd(ll a, ll b) { return (b > 0) ? gcd(b, a%b) : a; }
ll lcm(ll a, ll b) { return a*b/gcd(a, b); }
using ipair = pair<ll, ll>;
int main()
{
ll N, K;
vector<ipair> v;
cin >> N >> K;
if((N-1)*(N-2)/2 < K){
cout << "-1" << "\n";
}
else{
REP(i, 1, N) v.push_back({i, N});
ll max = (N-1)*(N-2)/2-K;
ll ci=1, cj=2;
rep(i, max){
v.push_back({ci, cj});
++cj;
if(cj == N){
++ci;
cj = ci + 1;
}
}
cout << v.size() << "\n";
for(auto a: v){
cout << a.first << " " << a.second << "\n";
}
}
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
using namespace std;
int main(){
int n, ans = 0;
cin >> n;
vector<int> x(n), y(n);
for(int i = 0; i < n; i++){
cin >> x[i] >> y[i];
}
bool f = true;
int o = (abs(x[0]) + abs(y[0])) % 2;
for(int i = 1; i < n; i++){
if((abs(x[i]) + abs(y[i])) % 2 != o){
f = false;
break;
}
}
if(f){
vector<long long> arm;
if(o == 0) arm.push_back(1);
for(int i = 0; i < 32; i++){
arm.push_back(1LL << i);
}
cout << arm.size() << endl;
for(int i = 0; i < arm.size(); i++){
if(i < arm.size() - 1){
cout << arm[i] << " ";
}else{
cout << arm[i] << endl;
}
}
for(int i = 0; i < n; i++){
long long a, b;
a = x[i]; b = y[i];
string s;
for(int j = arm.size() - 1; j >= 0; j--){
long long d = arm[j];
if(abs(a) >= abs(b)){
if(a >= 0){
a -= d;
s += "R";
}else{
a += d;
s += "L";
}
}else{
if(b >= 0){
b -= d;
s += "U";
} else{
b += d;
s += "D";
}
}
}
reverse(s.begin(), s.end());
cout << s << endl;
}
}else{
cout << -1 << endl;
}
return 0;
}
| 0
| 4,755,659
|
#include <iostream>
using namespace std;
int main(){
int N, A;
cin >> N >> A;
while(N >= 500){
N = N - 500;
}
if(N <= A){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
|
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <cctype>
#define rep(i,a,b) for(int i=(a);i<b;i++)
#define INF 1000000000
using namespace std;
bool debug=false;
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
int a,b,c;
cin>>a>>b>>c;
long long cnt=0;
while(1){
if(b==1&&c==1)break;
cnt++;
c++;
if(a%3==0){
if(c==21){
c=1;b++;
}
}else{
if(b%2==1&&c==21){
c=1;b++;
}else if(b%2==0&&c==20){
c=1;b++;
}
}
if(b==11){
b=1;
a++;
}
if(debug)cout<<a<<" "<<b<<" "<<c<<endl;
}
for(int j=a;j<1000;j++){
if(j%3==0)cnt+=200;
else cnt+=195;
}
cout<<cnt<<endl;
}
return 0;
}
| 0
| 93,492,059
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int INF = 1000000000;
#define REP(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
#define rep(i,n) REP(i, 0, n)
int main(){
stack<int> densha;
for(int a; cin >> a; ){
if(a == 0){
cout << densha.top() << endl;
densha.pop();
}else
densha.push(a);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[(int)1e5+1];
int solve(int *h, int n)
{
if(n == 0)
return 0;
if(dp[n] != -1)
return dp[n];
int op1, op2;
op1 = op2 = 1e9;
if(n >= 2)
op1 = solve(h, n-2) + abs(h[n]-h[n-2]);
if(n >= 1)
op2 = solve(h, n-1) + abs(h[n]-h[n-1]);
return dp[n] = min(op1, op2);
}
int main() {
int t = 1;
while(t--)
{
int n;
cin >> n;
int h[n];
for(int &val : h)
cin >> val;
memset(dp, -1, sizeof dp);
cout << solve(h, n-1);
}
return 0;
}
| 0
| 38,708,279
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
using ii=pair<ll,ll>;
using vi=vector<ll>;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define INF (ll)1e18
#define all(x) (x).begin(),(x).end()
#define print(a); for(auto x:a)cout<<x<<" "; cout<<"\n";
#define mset(a); memset(a,0,sizeof(a));
int main(){
ios_base::sync_with_stdio(0);cin.tie(0);
ll n,m;cin>>n>>m;
ll l=1,r=n;
for(int i=0;i<m;i++){
ll a,b;cin>>a>>b;
l=max(l,a);
r=min(r,b);
}
cout<<max(0ll,r-l+1)<<"\n";
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define loop(i, n) for(int i = 0 ; i < n ; ++i)
#define rloop(i, n) for(int i = int(n)-1 ; i >= 0 ; --i)
#define loopOne(i, n) for(int i = 1 ; i <= n; ++i)
#define range(i, a, b) for(int i = int(a) ; i <= int(b) ; ++i)
#define sz(x) int(x.size())
void GO(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const ll N = 1e5+100, OO = 1e9;
int mx = -OO, mn = OO;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int arr[N], n, memo[N];
int k;
int Solve(int idx){
if(idx == n-1) return 0;
if(memo[idx] != -1) return memo[idx];
int res = OO;
for(int i = 1; i <= k; ++i) {
if (idx + i < n)
res = min(res, abs(arr[idx] - arr[idx + i]) + Solve(idx + i));
else
break;
}
return memo[idx] = res;
}
int main() {
GO();
scanf("%d %d", &n, &k);
for(int i = 0; i < n; ++i){
scanf("%d", arr+i);
}
memset(memo, -1, sizeof(memo));
printf("%d", Solve(0));
return 0;
}
| 0
| 72,819,472
|
#pragma GCC optimze("Ofast")
#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 mod 1000000007
#define md 998244353
#define trace(...)
#define ll long long int
#define ld long double
#define fi first
#define se second
#define fr(i,a,b) for(ll i=a;i<=b;i++)
#define frr(i,b,a) for(ll i=b;i>=a;i--)
#define mem(a) memset(a, 0, sizeof(a))
#define vpi std::vector<pair<int,int>>
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pb push_back
#define sall(v) sort(v.begin(),v.end())
#define all(v) (v.begin(),v.end())
#define minf -10000000
#define vi vector<int>
#define CHMIN(a,b) a=min((a),(b))
#define CHMAX(a,b) a=max((a),(b))
const ll infl=0x3f3f3f3f3f3f3f3fLL;
const int infi=0x3f3f3f3f;
typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> oset;
auto clk=clock();
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0,lim-1);
return uid(rang);
}
ll power(ll x, ll y,ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res*x) % p;
y = y>>1;
x = (x*x) % p;
}
return res;
}
ll power(ll x, ll y) {
ll res = 1;
while (y > 0) {
if (y & 1)
res = (res*x) ;
y = y>>1;
x = (x*x);
}
return res;
}
ll max3(ll a,ll b,ll c){
return max(a,max(b,c));
}
ll min3(ll a,ll b,ll c){
return min(a,min(b,c));
}
bool isPrime(ll n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
const int d4i[4]={-1, 0, 1, 0}, d4j[4]={0, 1, 0, -1};
const int d8i[8]={-1, -1, 0, 1, 1, 1, 0, -1}, d8j[8]={0, 1, 1, 1, 0, -1, -1, -1};
const int nax=2e5+10;
void solve(){
ll a,b,c,k;cin>>a>>b>>c>>k;
ll ans=0;
ll tp=min(k,a);
ans+=tp;
k-=tp;a-=tp;
if(k==0){
cout<<ans<<endl;
return;
}
tp=min(k,b);
k-=tp;b=tp;
if(k==0){
cout<<ans<<endl;
return;
}
tp=min(k,c);
ans-=tp;
cout<<ans<<endl;
return;
}
int main(){
ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
cout<<fixed<<setprecision(8);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
int t;
t=1;
while(t--){
solve();
}
#ifndef ONLINE_JUDGE
cout<<endl<<endl<<endl<<endl<<"Time elapsed: "<<(double)(clock()-clk)/CLOCKS_PER_SEC<<endl;
#endif
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 inf 1001001001001001001
#define mod 1000000007
#define mod2 998244353
#define pi acos(-1)
#define all(v) v.begin(),v.end()
int main(){
vector<int>n(5);
int ans=644;
int num=0;
int a;
rep(i,5){
cin>>n.at(i);
}
do{
for(int i=0;i<5;i++){
if(num%10==0){
num+=n.at(i);
}else{
num+=10-num%10;
num+=n.at(i);
}
}
if(num<ans){
ans=num;
}
num=0;
}while(next_permutation(all(n)));
cout<<ans<<endl;
}
| 0
| 49,844,613
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MAX = 1000;
const int INF = 1e9;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,-1,0,1};
#define PI 3.14159265358979323846264338327950L
int main() {
int A, B; cin >> A >> B;
int tmp = A * 100 / 8;
int tmp2 = B * 100 / 10;
int mi = min(tmp, tmp2);
int ma = max(tmp, tmp2);
for (int ii = mi-1; ii <= ma+1; ii++) {
if ((ii*8/100 == A) && (ii*10/100 == B)) {
cout << ii << endl;
return 0;
}
}
cout << "-1" << endl;
}
|
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <fstream>
#include <string>
#include <math.h>
#include <cstdlib>
#include <istream>
#include <sstream>
#include <cctype>
#include <iomanip>
#define rep(i,N) for(int i=0;i<(int)N;++i)
typedef long long ll;
using namespace std;
int main()
{
ll A,B,M,t;
vector<ll>AA,BB,ANS;
cin>>A>>B>>M;
rep(i,A){
cin>>t;
AA.push_back(t);
}
rep(i,B){
cin>>t;
BB.push_back(t);
}
rep(i,M){
ll x,y,z,zz;
cin>>x>>y>>z;
zz=AA[x-1]+BB[y-1]-z;
ANS.push_back(zz);
}
sort(AA.begin(),AA.end());
sort(BB.begin(),BB.end());
ANS.push_back(AA[0]+BB[0]);
sort(ANS.begin(),ANS.end());
cout<<ANS[0]<<endl;
}
| 0
| 66,301,477
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> II;
typedef tuple<int,int,int> III;
typedef vector<int> VI;
typedef vector<string> VS;
typedef unordered_map<int,int> MAPII;
typedef unordered_set<int> SETI;
template<class T> using VV=vector<vector<T>>;
template<class T> inline T SMIN(T& a, const T b) { return a=(a>b)?b:a; }
template<class T> inline T SMAX(T& a, const T b) { return a=(a<b)?b:a; }
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) for(int i=0;i<=(n);++i)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define FORR(x,arr) for(auto& x:arr)
#define SZ(a) int((a).size())
#define ALL(c) (c).begin(),(c).end()
#define MINUS(dp) memset(dp, -1, sizeof(dp))
#define ZERO(dp) memset(dp, 0, sizeof(dp))
#define println(args...) fprintf(stdout, ##args),putchar('\n');
template<class Iter> void __kumaerrc(Iter begin, Iter end) { for(; begin!=end; ++begin) { cerr<<*begin<<','; } cerr<<endl; }
void __kumaerr(istream_iterator<string> it) { (void)it; cerr<<endl; }
template<typename T, typename... Args> void __kumaerr(istream_iterator<string> it, T a, Args... args) { cerr<<*it<<"="<<a<<", ",__kumaerr(++it, args...); }
template<typename S, typename T> std::ostream& operator<<(std::ostream& _os, const std::pair<S,T>& _p) { return _os<<"{"<<_p.first<<','<<_p.second<<"}"; }
#define __KUMATRACE__ true
#ifdef __KUMATRACE__
#define dump(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); __kumaerr(_it, args); }
#define dumpc(ar) { cerr<<#ar<<": "; FORR(x,(ar)) { cerr << x << ','; } cerr << endl; }
#define dumpC(beg,end) { cerr<<"~"<<#end<<": "; __kumaerrc(beg,end); }
#else
#define dump(args...)
#define dumpc(ar)
#define dumpC(beg,end)
#endif
const int MAX_N=1e6+1;
LL A[MAX_N],K;
int N;
LL gcd(LL a, LL b) { return b==0?a:gcd(b,a%b); }
bool solve() {
sort(A,A+N);
if(A[N-1]<K) return false;
LL g=A[0];
REP(i,N) g=gcd(g,A[i]);
return (K%g)==0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout<<setprecision(12)<<fixed;
cin>>N>>K;
REP(i,N) cin>>A[i];
cout<<(solve()?"POSSIBLE":"IMPOSSIBLE")<<endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int64_t i = 0; i < (n); i++)
#define irep(i, n) for (int64_t i = 0; i <= (n); i++)
#define rrep(i, n) for (int64_t i = (n)-1; i >= 0; i--)
#define rirep(i, n) for (int64_t i = n; i >= 0; i--)
int main()
{
int n, k;
cin >> n >> k;
vector<int> a(n), b(n);
rep(i, n)
{
cin >> a[i] >> b[i];
}
int64_t result = 0;
rep(i, n)
{
if ((~k & a[i]) == 0) {
result += b[i];
}
}
rep(i, 30)
{
if (((k >> i) & 1) == 1) {
int mask = ((~(k >> (i + 1)) << 1) + 1) << i;
int64_t score = 0;
rep(i, n)
{
if ((a[i] & mask) == 0) {
score += b[i];
}
}
result = max(result, score);
}
}
cout << result << endl;
return 0;
}
| 0
| 50,348,654
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct UnionFind
{
vector<int> r;
UnionFind(int N)
{
r = vector<int>(N, -1);
}
int root(int x)
{
if (r[x] < 0)
return x;
return r[x] = root(r[x]);
}
bool unite(int x, int y)
{
x = root(x);
y = root(y);
if (x == y)
return false;
if (r[x] > r[y])
swap(x, y);
r[x] += r[y];
r[y] = x;
return true;
}
int size(int x)
{
return -r[root(x)];
}
};
int main()
{
int N, M;
cin >> N >> M;
UnionFind tree(N);
for (int i = 0; i < M; i++)
{
int a, b;
cin >> a >> b;
a -= 1;
b -= 1;
tree.unite(a, b);
}
int ans = 0;
for (int i = 0; i < N; i++)
{
ans = max(ans, tree.size(i));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n; cin >> n;
string s; cin >> s;
if(s.size()%2!=0){
cout << "No";
return 0;
}
string t=s.substr(0,n/2);
if(t==s.substr(n/2,n/2)) cout << "Yes";
else cout << "No";
}
| 0
| 46,638,125
|
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
typedef long long ll;
using namespace std;
int main(){
int x,a;cin>>x>>a;
if(x<a) cout<<0;
else cout<<10;
}
|
#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main() {
vector<int>x;
string s;
while (cin >> s){
if (s == "0")break;
int sum = 0;
for (int i = 0; i != s.size(); i++){
sum += s[i] - '0';
}
x.push_back(sum);
}
for (int i = 0; i != x.size(); i++)
{
cout << x[i] << endl;
}
}
| 0
| 93,847,731
|
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(long long)(n);i++)
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const ll MOD=1e9+7;
const ll INF=1e18;
const int MAX=510000;
const double pi=acos(-1);
int dx[8] = {1,0,-1,0,1,1,-1,-1};
int dy[8] = {0,1,0,-1,-1,1,1,-1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
vector<int>a(101);
int n,k;
cin >> n >> k;
ll ans = k;
rep(i,n-1){
ans *= (k-1);
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int n,m;
void dfs(int i, vector<bool> &checked, bool c[10][10], int &ans){
int t = 0;
for (int j = 0; j < n; j++)
{
if(checked[j]) t++;
}
if(t == n) ans ++;
else{
for (int j; j < n; j++)
{
if(c[i][j] == true && !checked[j]){
checked[j] = true;
dfs(j,checked,c,ans);
checked[j] = false;
}
}
}
}
int main(){
cin>> n >> m;
vector<bool> checked(n,false);
bool c[10][10] = {false};
for (int i = 0; i < m; i++)
{
int x, y;
cin >> x >> y;
x--; y--;
c[x][y] = true;
c[y][x] = true;
}
checked[0] = true;
int ans = 0;
dfs(0,checked,c,ans);
cout << ans << endl;
}
| 0
| 8,643,805
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
#include <cmath>
using namespace std;
#define vi vector<int>
#define vii vector<vector<int>>
void testcase()
{
string s1, s2;
cin >> s1 >> s2;
int change = INT_MAX,x = 0;
for (int i = 0; i + s2.length() - 1 < s1.length(); i++)
{
x = 0;
for (int j = 0;j < s2.length(); j++)
{
if(s1[i + j] != s2[j]){
x++;
}
}
change = min(change,x);
}
cout << change << " ";
}
int main()
{
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
testcase();
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#define MAX_N (100000)
#define NUM_MOD (1000000007)
using namespace std;
int main(int argc, char *argv[]) {
int N, ts[MAX_N], as[MAX_N];
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &ts[i]);
}
for (int i = 0; i < N; i++) {
scanf("%d", &as[i]);
}
int hs[MAX_N], possible = 1;
for (int i = 0; i < N; i++) {
hs[i] = -1;
}
int prev;
prev = 0;
for (int i = 0; i < N; i++) {
const int h = ts[i];
if (prev != h && as[i] < h) {
possible = 0;
break;
}
prev = h;
}
prev = 0;
for (int i = N - 1; i >= 0; i--) {
const int h = as[i];
if (prev != h && ts[i] < h) {
possible = 0;
break;
}
prev = h;
}
prev = 0;
for (int i = 0; i < N; i++) {
const int h = ts[i];
if (prev != h) {
hs[i] = h;
}
prev = h;
}
prev = 0;
for (int i = N - 1; i >= 0; i--) {
const int h = as[i];
if (prev != h) {
hs[i] = h;
}
prev = h;
}
if (possible) {
long ans = 1;
for (int i = 0; i < N; i++) {
if (hs[i] == -1) {
ans = (ans * min(ts[i], as[i])) % NUM_MOD;
}
}
printf("%ld\n", ans);
} else {
printf("0\n");
}
return 0;
}
| 0
| 98,317,063
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> pll;
const ll mod=1e9+7;
const ll inf=5e18;
int main() {
ll a;
cin >> a;
if(a<1200) cout << "ABC" << endl;
else if(a<2800) cout << "ARC" << endl;
else cout << "AGC" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int N,K;
cin >> N >> K;
vector<ll> a;
for(int i=0; i<N; i++){int tt; cin >> tt; a.push_back(tt); }
ll ans = 1e18;
for(int bit=0; bit<(1<<N); bit++){
vector<int> cp(N);
copy(a.begin(),a.end(),cp.begin());
int t = cp[0]; ll diff=0;
for(int i=1; i<N; i++){
if(bit & (1<<i)){
if(t>=cp[i]){diff += t-cp[i]+1; cp[i]+=t-cp[i]+1;}
}
t = max(t,cp[i]);
}
int cnt=0;
t = cp[0];
for(int i=1; i<N; i++){
if(cp[i]>t){cnt++; t=cp[i];}
}
if(cnt>=K-1){ ans = min(ans,diff); }
}
cout << ans << endl;
}
| 0
| 26,689,031
|
#include <bits/stdc++.h>
#define ADAY 86400
using namespace std;
typedef long long ll;
int main(void){
ll n;
while(cin >> n, n){
vector < pair < ll, ll > > t;
for(ll i=0; i < n; i++){
pair<ll, ll> tmp;
int h, m, s;
scanf("%d:%d:%d", &h, &m, &s);
tmp.first = (ll)(h * 3600 + m * 60 + s);
scanf("%d:%d:%d", &h, &m, &s);
tmp.second = (ll)(h * 3600 + m * 60 + s);
t.push_back(tmp);
}
sort(t.begin(), t.end());
ll ans = 0, movin = 0, ind = 0;
vector<ll> q;
for(ll now=0; now <= ADAY; now++){
while(!q.empty() && now == q[0]){
movin--;
q.erase(q.begin());
}
while(ind < n && now == t[ind].first){
q.push_back(t[ind].second);
sort(q.begin(), q.end());
movin++;
ind++;
ans = max(ans, movin);
}
}
cout << ans << endl;
}
return 0;
}
|
const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No", "Yes"};
string YES[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t, a;
int x, y;
cin >> s >> t >> x >> y >> a;
if (a == s) x--;
else y--;
cout << x << " " << y;
}
| 0
| 35,857,549
|
#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() {
cerr << endl;
}
template <typename H, typename... T>
void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T>
void print(T x) {
cout << x << endl;
}
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> Pll;
typedef pair<int,int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9+7;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, K;
cin >> N >> K;
int k = (N - 2) * (N - 1) / 2;
if (K > k) {
print(-1);
return 0;
}
vector<pair<int, int>> ans;
REP(i, N - 1) {
ans.eb(1, i + 2);
}
int i = 2, j = 3;
while(k > K && i < N + 1 && j < N + 1) {
if (i == j) {
if (j == N) {
i++; j = i + 1;
} else {
j++;
}
}
ans.eb(i, j);
k--;
if (j == N) {
i++; j = i + 1;
} else {
j++;
}
}
if (k != K) {
print(-1);
return 0;
}
print(ans.size());
for(auto &e: ans) {
cout << e.fi << " " << e.se << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define dup(x,y) (((x)+(y)-1)/(y))
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
typedef pair<int, int> pii;
const double EPS = 1e-10;
const int INF = 1e9;
const ll LINF = 1e15;
const int MOD = 1000000007;
const double PI = acos(-1);
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
int main() {
ll a, b, c, k;
cin >> a >> b >> c >> k;
if (k <= a) cout << k << endl;
else if (k <= a + b) cout << a << endl;
else cout << a - (k - (a + b)) << endl;
}
| 0
| 95,158,781
|
#include <iostream>
using namespace std;
int SelectionSort(int A[], int N){
int minj, tmp, cnt=0;
for(int i = 0; i < N-1; i++){
minj = i;
for(int j = i; j < N; j++){
if(A[j] < A[minj]){
minj = j;
}
}
tmp = A[i];
A[i] = A[minj];
A[minj] = tmp;
if(i != minj) cnt++;
}
return cnt;
}
int main(){
int A[100], N, cnt;
cin >> N;
for(int i = 0; i < N; i++){
cin >> A[i];
}
cnt = SelectionSort(A, N);
cout << A[0];
for(int i = 1; i < N; i++){
cout << " " << A[i];
}
cout << endl << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
const long double PI = (acos(-1));
const long double EPS = 0.0000000001;
long double a, b, x;
void input() {
cin >> a >> b >> x;
}
long double f(long double a, long double b, long double theta) {
if(theta > PI / 2.0 - EPS) {
return 0.0;
}
long double ret;
if(a * tan(theta) <= b) {
ret = a * a * b - a * a * a * tan(theta) / 2.0;
} else {
ret = b * b / tan(theta) * a / 2.0;
}
return ret;
}
void solve() {
input();
long double ok = PI / 2.0;
long double ng = 0.0;
for(int _ = 1; _ <= 100000; _++) {
long double mid = (ok + ng) / 2.0;
if(f(a, b, mid) < x) ok = mid;
else ng = mid;
}
cout << fixed << setprecision(10) << ok / PI * 180 << endl;
return;
}
int main() {
solve();
return 0;
}
| 0
| 45,628,818
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.