code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 137
101M
|
|---|---|---|---|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<int>a(n);
for(int i=0;i<n;i++){
cin >> a.at(i);
}
int max=a.at(0),min=a.at(0);
for(int i=1;i<n;i++){
if(min>a.at(i))
min=a.at(i);
if(max<a.at(i))
max=a.at(i);
}
cout << max-min << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int H, W, K;
cin >> H >> W >> K;
vector<vector<char>> blocks(H, vector<char>(W));
rep(i, H) {
rep(j, W) {
cin >> blocks.at(i).at(j);
}
}
int ans = 0;
for (int row = 0; row < (1 << H); row++) {
for (int col = 0; col < (1 << W); col++) {
int count = 0;
for (int i = 0; i < H; i++) {
if ((row >> i) & 1) continue;
for (int j = 0; j < W; j++) {
if ((col >> j) & 1) continue;
if (blocks.at(i).at(j) == '#') count++;
}
}
if (count == K) ans++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 55,739,416
|
#include <bits/stdc++.h>
#include <string>
#include <vector>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int n;
cin >> n;
vector<int> x(n);
rep(i,n) cin >> x[i];
int mean = 0;
rep(i,n) {
mean += x[i];
}
mean /= n;
int ans1 = 0;
int ans2 = 0;
rep(i,n){
ans1 += (x[i]-mean)*(x[i]-mean);
ans2 += (x[i]-mean-1)*(x[i]-mean-1);
}
int ans = min(ans1,ans2);
cout << ans << endl;
}
|
#include<iostream>
#include<vector>
#include<math.h>
#include<map>
#define TakeInput freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);
using namespace std;
int main(){
#ifndef ONLINE_JUDGE
TakeInput
#endif
int i,j,m,n,k,r,c;
cin>>n>>m>>k;
string a[n];
for(i=0;i<n;i++){
cin>>a[i];
}
int ans=0;
for(i=0;i<(1<<n);i++){
for(j=0;j<(1<<m);j++){
int count=0;
for(r=0;r<n;r++){
for(c=0;c<m;c++){
if((((i>>r)&1)==0) && (((j>>c)&1)==0) && a[r][c] == '#'){
count++;
}
}
}
if(count==k)ans++;
}
}
cout<<ans<<endl;
}
| 0
| 40,038,300
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, s, n) for(int i = s; i < (int)n; i++)
#define per(i, n) for(int i = n; i >= 0; i--)
#define ROF(i, s, n) for(int i = s; i >= (int)n; i--)
#define FORIT(i, A) for (auto i : A)
#define PRINT(x) cout << (x) << "\n"
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define MP make_pair
#define EACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define SZ(a) int((a).size())
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define CLR(a) memset((a), 0 ,sizeof(a))
#define NCLR(a) memset((a), -1 ,sizeof(a))
#define sq(n) (n) * (n)
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef priority_queue<int> maxpq;
typedef priority_queue< int, vector<int>, greater<int> > minpq;
typedef complex<double> P;
static const double EPS = 1e-10;
static const double PI = acos( -1.0 );
static const int mod = 1000000007;
static const int INF = 1 << 29;
static const LL LL_INF = 1ll << 60;
static const int dx[] = { -1, 0, 1, 0, 1, -1, 1, -1 };
static const int dy[] = { 0, -1, 0, 1, 1, 1, -1, -1 };
#ifdef WIN32
#define dump(x) cout << #x << " = " << (x) << "\n"
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << "\n"
#else
#define dump(x)
#define debug(x)
#endif
struct edge {
int to;
int cost;
edge( int t, int c ) {
to = t;
cost = c;
}
};
int n;
int r[ 10 ][ 10 ];
vector<edge> e[ 10 ];
void dijkstra( int s ) {
fill( r[ s ], r[ s ] + 10, INF );
priority_queue< PII, vector<PII>, greater<PII> > que;
que.push( PII( s, 0 ) );
while ( que.size() ) {
int to = que.top().first;
int cost = que.top().second;
que.pop();
if ( r[ s ][ to ] < cost ) {
continue;
}
r[ s ][ to ] = cost;
for ( int i = 0; i < e[ to ].size(); i++ ) {
if ( r[ s ][ e[ to ][ i ].to ] > cost + e[ to ][ i ].cost ) {
r[ s ][ e[ to ][ i ].to ] = r[ e[ to ][ i ].to ][ s ] = cost + e[ to ][ i ].cost;
que.push( PII( e[ to ][ i ].to, cost + e[ to ][ i ].cost ) );
}
}
}
}
int main() {
#ifdef WIN32
printf( "Debug Mode\n" );
#endif
while ( ~scanf( "%d", &n ) && n ) {
for ( int i = 0; i < 10; i++ ) {
e[ i ].clear();
}
int m = 0;;
for ( int i = 0; i < n; i++ ) {
int s, g, c;
scanf( "%d %d %d", &s, &g, &c );
m = max( max( s, g ), m );
dump( m );
e[ s ].push_back( edge( g, c ) );
e[ g ].push_back( edge( s, c ) );
}
for ( int i = 0; i < 10; i++ ) {
if ( e[ i ].size() ) {
m = i;
}
else {
break;
}
}
int ans_cost = INF;
int ans_t = 0;
for ( int i = 0; i <= m; i++ ) {
dijkstra( i );
}
for ( int i = 0; i <= m; i++ ) {
int cost = 0;
for ( int j = 0; j <= m; j++ ) {
cost += r[ i ][ j ];
}
if ( ans_cost > cost ) {
ans_cost = cost;
ans_t = i;
}
}
printf( "%d %d\n", ans_t, ans_cost );
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int H, W;
cin >> H >> W;
vector<string> c(H);
rep(i, H) cin >> c[i];
int ans = 0;
vector<vector<int>> cnt(H, vector<int>(W, 0));
rep(i, H) {
int l = 0, r = 0;
while (l < W) {
if (r >= W || c[i][r] == '#') {
if (r != l)
for (int j = l; j < r; ++j) {
cnt[i][j] = r - l;
}
++r, l = r;
} else
++r;
}
}
rep(i, W) {
int l = 0, r = 0;
while (l < H) {
if (r >= H || c[r][i] == '#') {
if (r != l)
for (int j = l; j < r; ++j) {
ans = max(ans, cnt[j][i] + r - l - 1);
}
++r, l = r;
} else
++r;
}
}
cout << ans << endl;
}
| 0
| 29,532,578
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define REP(i,k,n) for(int i = k; i < (int)(n); i++)
#define vi vector<int>
#define pb push_back
typedef long long ll;
using namespace std;
int main(){
int m,nmn,nmx;
while(cin >> m >> nmn >> nmx,m) {
int gmx = 0,mxn = 0;
vi p;
rep(i,m){
int tmp;
cin >> tmp;
p.pb(tmp);
}
sort(p.begin(),p.end());
REP(n,nmn,nmx + 1){
if(gmx <= (abs(p[m - n] - p[m - n - 1]))) {
gmx = abs(p[m - n ] - p[m - n - 1]);
mxn = n;
}
}
cout << mxn << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int N, K;
int main() {
long long Height[15];
long long copyHeight[15];
long long ans = 1000000000000;
cin >> N >> K;
for ( int i = 0; i < N; ++i ) {
cin >> Height[i];
}
for ( int bit = 0; bit < (1 << N); ++bit ) {
int count = 0;
for ( int p = 0; p < N; ++p ) {
if ( bit & (1 << p)) count++;
}
if ( count < K ) continue;
else {
for ( int i = 0; i < N; ++i ) copyHeight[i] = Height[i];
int flag_num = 0;
long long cost = 0;
for ( int i = 0; i < N; ++i ) {
if ( bit & (1 << i) ) {
long long max_h = 0;
for ( int j = flag_num; j < i; ++j ) {
max_h = (copyHeight[j] > max_h) ? copyHeight[j] : max_h;
}
if ( max_h >= copyHeight[i] ) {
cost += max_h - copyHeight[i] + 1;
copyHeight[i] = max_h + 1;
}
flag_num = i;
}
}
ans = (cost < ans) ? cost : ans;
}
}
cout << ans << endl;
return 0;
}
| 0
| 57,127,203
|
#include <iostream>
#include <cmath>
#include <climits>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <string>
#include <stack>
#include <algorithm>
#include <map>
#include <numeric>
#include <set>
#include <queue>
#include <bitset>
using namespace std;
#define ll long long
#define ld long double
#define pi 3.14159265359;
#define _sort(v,type,order) do { sort(v.begin(),v.end(),order<type>()); } while(0)
#define _sum(v,default_value) accumulate(v.begin(),v.end(),default_value )
#define _max_element(v) max_element(v.begin(),v.end())
#define _min_element(v) min_element(v.begin(),v.end())
#define _max_element_number(v) distance(v.begin(),max_element(v.begin(),v.end()))
#define _count(v,value) count(v.begin(),v.end(),value)
#define _round(v) round(v)
#define _square(v) pow(v,2)
#define _cube(v) pow(v,3)
#define _max(x,y) max(x,y)
#define _min(x,y) min(x,y)
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 _stringtoi(s) stoi(s)
#define _sqrt(x) sqrt(x)
#define _ceil(x) ceil(x)
#define _lower_bound(v,min) lower_bound(v.begin(), v.end(), min)
#define _upper_bound(v,min) upper_bound(v.begin(), v.end(), min)
#define _next_permutation(v) do { \
for (auto num : v) { \
printf("%d ", num); \
} \
printf("\n"); \
\
\
} while (next_permutation(v.begin(), v.end()))
template<typename T>
static T _abs(const T x) { return (x > 0 ? x : -x); }
int64_t gcd(int64_t a, int64_t b) { while (b) { int64_t c = b; b = a % b; a = c; } return a; }
int64_t lcm(int64_t a, int64_t b) { if (!a || !b) return 0; return a * b / gcd(a, b); }
template<class T>
vector<T> make_vec(size_t a) { return vector<T>(a); }
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts) { return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...)); }
class UnionFind
{
public:
vector <int32_t> par;
vector <int32_t> siz;
UnionFind(int32_t sz_) : par(sz_), siz(sz_, 1LL) { for (int32_t i = 0; i < sz_; ++i) par[i] = i; }
void init(int32_t sz_)
{
par.resize(sz_);
siz.assign(sz_, 1LL);
for (int32_t i = 0; i < sz_; ++i) par[i] = i;
}
int32_t root(int32_t x)
{
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(int32_t x, int32_t y)
{
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool is_same(int32_t x, int32_t y) { return root(x) == root(y); }
int32_t size(int32_t x) { return siz[root(x)]; }
void view(void) {
for (size_t i = 0; i < par.size(); i++) {
printf("%d\n", par[i]);
}
}
};
int main()
{
int64_t a, b;
int64_t c, d;
cin >> a >> b >> c >> d;
int64_t result = b - a + 1;
result = result - (b / c - (a - 1) / c) - (b / d - (a - 1) / d);
int64_t temp = lcm(c,d);
result += (b / temp - (a - 1) / temp);
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)
#define VIN(v) for(auto&elem_: (v) )cin>>elem_
#define VOUT(v, sep) for(_loop_int idx=0; idx<(_loop_int)v.size(); idx++) {cout<<v[idx]; if(idx<v.size()-1) cout<<sep;} cout<<endl
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG2(x,y) cout<<#x<<": "<<x<<" "<<#y<<": "<<y<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(debugidx,v.size())cout<<" "<<v[debugidx];cout<<endl
#define DEBUG_ARR(v,n) cout<<#v<<":";REP(debugidx,n)cout<<" "<<v[debugidx];cout<<endl
#define ALL(a) (a).begin(),(a).end()
const ll MOD = 1000000007ll;
const int IINF = numeric_limits<int>::max()/2-1;
const ll LINF = numeric_limits<ll>::max()/2-1;
#define FIX(a) ((a)%MOD+MOD)%MOD
int main() {
ios::sync_with_stdio(false); cin.tie(0);
int d;
cin>>d;
string ans="Christmas";
d = abs(d-25);
REP(i,d)
ans += " Eve";
cout << ans << endl;
return 0;
}
| 0
| 56,854,882
|
#include <bits/stdc++.h>
#ifdef LOCAL
#include "../cxx-prettyprint/prettyprint.hpp"
#endif
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
#define REP(i, n) for (int (i) = 0 ; (i) < (int)(n) ; ++(i))
#define REPN(i, m, n) for (int (i) = m ; (i) < (int)(n) ; ++(i))
#define REP_REV(i, n) for (int (i) = (int)(n) - 1 ; (i) >= 0 ; --(i))
#define REPN_REV(i, m, n) for (int (i) = (int)(n) - 1 ; (i) >= m ; --(i))
#define ALL(x) x.begin(), x.end()
#define INF ((1 << 29)-1)
#define MOD (1000000007)
#define print2D(h, w, arr) REP(i, h) { REP(j, w) cout << arr[i][j] << " "; cout << endl; }
#define print_line(vec, n) {for(int i=0;i<(n-1);i++) cout << (vec)[i] << " "; cout << (vec)[(n)-1] << endl;}
template<class T> void print(const T& x){cout << x << endl;}
template<class T, class... A> void print(const T& first, const A&... rest) { cout << first << " "; print(rest...); }
struct PreMain {PreMain(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(20);}} premain;
int main() {
#ifdef LOCAL
ifstream in("../arg.txt"); cin.rdbuf(in.rdbuf());
#endif
int A, B;
cin >> A >> B;
int ans = (A-1)*(B-1);
print(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define Fast ios::sync_with_stdio(false); cin.tie(0)
#define pb push_back
#define pf push_front
#define pp pop
#define ppb pop_back
#define ppf pop_front
#define mp make_pair
#define S second
#define F first
typedef long long ll;
const ll mod = 1e9 + 7;
const ll N = 2e5 + 5;
ll inf = 1e18;
ll tmp = 0;
vector <ll> vec[N];
pair <ll ,ll> p[N];
bool vst[N];
void dfs(int v){
vst[v] = true;
tmp ++;
for(int i = 0 ; i < vec[v].size(); i ++){
if(!vst[vec[v][i]]){
dfs(vec[v][i]);
}
}
}
int main(){
Fast;
int n , m;
cin >> n >> m;
for(int i = 0 ; i < m; i ++){
cin >> p[i].F >> p[i].S;
}
sort(p , p + m);
int x = p[0].F , y = p[0].S;
vec[p[0].F].pb(p[0].S);
vec[p[0].S].pb(p[0].F);
for(int i = 1; i < m ;i ++){
if((x == p[i].F && y == p[i].S) || (x == p[i].S && y == p[i].F));
else{
x = p[i].F;
y = p[i].S;
vec[x].pb(y);
vec[y].pb(x);
}
}
ll ans = 0;
for(int i = 1; i <= n ;i ++){
if(!vst[i]){
dfs(i);
ans = max(ans , tmp);
tmp = 0;
}
}
cout << ans << endl;
return 0;
}
| 0
| 69,351,690
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
typedef long long ll;
int main(){
ll N,K;
cin >> N >> K;
double ans=0;
for(ll i=0;i<N;i++){
int nn = i+1;
double tmp = 1.0/N;
while(nn<K){
nn*=2;
tmp/=2;
}
ans += tmp;
}
printf("%.12f\n",ans);
}
|
#include <iostream>
#include<algorithm>
#include<vector>
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
if (N == 1) {
cout << 1 << endl;
}
else if (2 <= N && N < 4) {
cout << 2 << endl;
}
else if (4 <= N && N < 8) {
cout << 4 << endl;
}
else if (8 <= N && N < 16) {
cout << 8 << endl;
}
else if (16 <= N && N < 32) {
cout << 16 << endl;
}
else if (32 <= N && N < 64) {
cout << 32 << endl;
}
else {
cout << 64 << endl;
}
}
| 0
| 64,445,669
|
#include<bits/stdc++.h>
#define mxn 200005
#define ll long long
using namespace std;
ll seg[4*mxn], lazy[4*mxn];
vector<int>adj[mxn];
void propagate(int n, int s, int e)
{
lazy[n*2]+= lazy[n];
lazy[n*2 +1]+= lazy[n];
int mid= (s+e)>>1;
seg[n*2]+= lazy[n]*(mid-s+1);
seg[n*2 +1]+= lazy[n]*(e-mid);
lazy[n]= 0;
return;
}
void update(int n, int s, int e, int l, int r, int val)
{
if(s>=l && e<=r)
{
seg[n] += val*(e-s+1);
lazy[n]+= val;
return;
}
if(s>r || e<l)return;
if(lazy[n])propagate(n, s, e);
int mid= (s+e)>>1;
update(n*2, s, mid, l, r, val);
update(n*2 +1, mid+1, e, l, r, val);
seg[n]= seg[n*2]+seg[n*2 +1];
return;
}
ll query(int n, int s, int e, int l, int r)
{
if(s>=l && e<=r)return seg[n];
if(s>r || e<l)return 0;
if(lazy[n])propagate(n, s, e);
int mid= (s+e)>>1;
return query(n*2, s, mid, l, r)+query(n*2 +1, mid+1, e, l, r);
}
int main()
{
int n, x, y;
scanf("%d", &n);
for(int i=1; i<n; i++)
{
scanf("%d %d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
ll res= 0;
for(int i=1; i<=n; i++)
{
vector<int>vec;
for(int j=0; j<adj[i].size(); j++)
if(adj[i][j]<i)vec.push_back(adj[i][j]);
sort(vec.begin(), vec.end());
int lst= i, c= 1;
for(int j=vec.size()-1; j>=0; j--)
update(1, 1, n, vec[j]+1, lst, c), lst= vec[j], c--;
update(1, 1, n, 1, lst, c);
res+= query(1, 1, n, 1, n);
}
printf("%lld\n", res);
return 0;
}
|
#include <iostream>
#include <deque>
#include <string>
using namespace std;
int stateA(deque<string>& a);
int stateB(deque<string>& a);
int stateC(deque<string>& a);
int stateD(deque<string>& a);
int stateE(deque<string>& a);
int stateF(deque<string>& a);
int main(){
int n;
while(true){
cin >> n;
if(n == 0){
break;
}
deque<string> hoge;
for(int i = 0; i < n; ++i){
string tmp;
cin >> tmp;
hoge.push_back(tmp);
}
cout << stateA(hoge) << endl;
}
return 0;
}
int stateA(deque<string>& a){
if(a.empty()){
return 0;
}
string cur = a.front(); a.pop_front();
if(cur == "lu"){
return stateB(a);
}
else if(cur == "ru"){
return stateC(a);
}
return stateA(a);
}
int stateB(deque<string>& a){
if(a.empty()){
return 0;
}
string cur = a.front(); a.pop_front();
if(cur == "ld"){
return stateA(a);
}
if(cur == "ru"){
return stateD(a) + 1;
}
return stateB(a);
}
int stateC(deque<string>& a){
if(a.empty()){
return 0;
}
string cur = a.front(); a.pop_front();
if(cur == "rd"){
return stateA(a);
}
if(cur == "lu"){
return stateD(a) + 1;
}
return stateC(a);
}
int stateD(deque<string>& a){
if(a.empty()){
return 0;
}
string cur = a.front(); a.pop_front();
if(cur == "ld"){
return stateE(a);
}
if(cur == "rd"){
return stateF(a);
}
return stateD(a);
}
int stateE(deque<string>& a){
if(a.empty()){
return 0;
}
string cur = a.front(); a.pop_front();
if(cur == "rd"){
return stateA(a) + 1;
}
if(cur == "lu"){
return stateD(a);
}
return stateE(a);
}
int stateF(deque<string>& a){
if(a.empty()){
return 0;
}
string cur = a.front(); a.pop_front();
if(cur == "ld"){
return stateA(a) + 1;
}
if(cur == "ru"){
return stateD(a);
}
return stateF(a);
}
| 0
| 97,360,891
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
int main(){
long long a;
double b;
cin >> a >> b;
if(a==0 || b==0){
cout << 0 << endl;
return 0;
}
long long num=b*100+0.000001;
long long ans=num*a;
ans/=100;
cout << ans << endl;
}
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
ll const INF = 1LL << 60;
int main() {
ll N, D;
cin >> N >> D;
vector<vector<ll>> x(N);
ll a;
for (int i = 0; i < N; i++) {
for (int j = 0; j < D; j++) {
cin >> a;
x[i].push_back(a);
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
long double sum = 0;
for (int k = 0; k < D; k++) {
sum += pow(x[i][k] - x[j][k], 2);
}
long double result = sqrtl(sum);
if (floorl(result) == result) ans++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 1,333,123
|
#include <bits/stdc++.h>
using namespace std;
#define io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define rep(i,n) for (int i = 0; i < (n); ++i)
int main(void) {
io;
int i; cin >> i;
cout << (i < 1200 ? "ABC" : "ARC");
return 0;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <cmath>
std::vector<int> PRIMES;
void init_primes(int max)
{
if (max < 2) return;
std::set<int> candidate;
PRIMES.push_back(2);
for (int i = 3; i < max; i+=2) {
candidate.insert(i);
}
for (int i = 3; i < sqrt(max); i+=2) {
auto it = candidate.find(i);
if (it != candidate.end()) {
PRIMES.push_back(i);
int del_num = i;
while (del_num < max) {
it = candidate.find(del_num);
if (it != candidate.end()) candidate.erase(it);
del_num += i;
}
}
}
for (auto it = candidate.begin(); it != candidate.end(); ++it) {
PRIMES.push_back(*it);
}
}
int main()
{
const int max = 1000000;
init_primes(max);
int i;
while (std::cin >> i) {
auto it = PRIMES.begin();
int n = 0;
while (*it <= i && it != PRIMES.end()) {
n++;
it++;
}
std::cout << n << std::endl;
}
return 0;
}
| 0
| 52,522,394
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <math.h>
#include <stack>
#include <deque>
#include <queue>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
#define debug(var) do{std::cout << #var << " : ";view(var);}while(0)
template<typename T> void view(T e) { std::cout << e << std::endl; }
template<typename T> void view(const std::vector<T>& v) { for (const auto& e : v) { std::cout << e << " "; } std::cout << std::endl; }
template<typename T> void view(const std::vector<std::vector<T> >& vv) { for (const auto& v : vv) { view(v); } }
template<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; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n; string s;
cin >> n >> s;
deque<char> Q;
for (int i = 0; i < n; i++) {
if (Q.size() && Q.back() == '(' && s[i] == ')') Q.pop_back();
else Q.push_back(s[i]);
}
int countL = 0, countR = 0;
while (Q.size()) {
char now = Q.front();
Q.pop_front();
if (now == ')') countL++;
else countR++;
}
while (countL--) cout << '(';
cout << s;
while (countR--) cout << ')';
}
|
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <map>
#include <numeric>
#include <cmath>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <complex>
#include <string.h>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <iomanip>
#include <sys/time.h>
#include <random>
using namespace std;
#define endl '\n'
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define UNIQ(v) (v).erase(unique((v).begin(), (v).end()), (v).end())
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef complex<double> comp;
typedef vector< vector<ld> > matrix;
struct pairhash {
public:
template<typename T, typename U>
size_t operator()(const pair<T, U> &x) const {
size_t seed = hash<T>()(x.first);
return hash<U>()(x.second) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}
};
const int inf = 1e9 + 9;
const ll mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1);
int k, n;
int a[200100];
int solve() {
int d = 0;
for (int i = 0; i < n-1; i++) {
d = max(d, a[i+1] - a[i]);
}
d = max(d, a[0]+k-a[n-1]);
return k - d;
}
void input() {
cin >> k >> n;
for (int i = 0; i < n; i++) cin >> a[i];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
input();
cout << solve() << endl;
}
| 0
| 27,685,565
|
#include <vector>
#include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for(int i = 0; i < M; ++i) {
cin >> L[i] >> R[i];
}
vector<int> p(N + 1);
for(int i = 0; i < M; ++i) {
++p[L[i] - 1];
--p[R[i]];
}
int sum = 0, ans = 0;
for(int i = 0; i < N; ++i) {
sum += p[i];
if(sum == M) ++ans;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define pb(x) push_back((x))
#define line() cerr << "DEBUG @" << __LINE__ << endl;
#define debug(x) \
cerr << "DEBUG @" << __LINE__ << " -> " << #x << " = " << x << endl;
using namespace std;
vector<int> m[(int) 1e6 + 1];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int &x : v) cin >> x;
const int mx = 1e6;
vector<int> divisors(mx + 1);
for (int i = 2; i <= 1000000; i++) {
if (!divisors[i]) {
for (int j = i; j <= 1000000; j += i) {
divisors[j] = i;
}
}
}
bool pair_wise_coprime = true;
bool gcd_is_one = true;
for (int x : v) {
int cur = x;
set<int> q;
while (cur != 1) {
q.insert(divisors[cur]);
cur /= divisors[cur];
}
for (int div : q) {
auto &curr_map = m[div];
curr_map.push_back(x);
if (curr_map.size() > 1) pair_wise_coprime = false;
if (curr_map.size() == n) gcd_is_one = false;
}
}
if (pair_wise_coprime) {
cout << "pairwise coprime\n";
return 0;
}
if (gcd_is_one) {
cout << "setwise coprime\n";
return 0;
}
cout << "not coprime\n";
}
| 0
| 70,966,441
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define rep(i,s,n) for(int i = s; i < (int)(n); i++)
int main() {
ll h,w;
ll ans = 1e10+1;
cin >> h >> w;
rep(x,1,h){
ll m,M;
m = min(x*w,(h-x)*(w/2));
M = max(x*w,(h-x)*((w+1)/2));
ans = min(ans,M-m);
m = min(x*w,((h-x)/2)*w);
M = max(x*w,((h-x+1)/2)*w);
ans = min(ans,M-m);
}
rep(y,1,w){
ll m,M;
m = min(y*h,(w-y)*(h/2));
M = max(y*h,(w-y)*((h+1)/2));
ans = min(ans,M-m);
m = min(y*h,((w-y)/2)*h);
M = max(y*h,((w-y+1)/2)*h);
ans = min(ans,M-m);
}
cout << ans << endl;
}
|
#include <stdio.h>
int main(void){
long long N,M;
long long ans;
scanf("%lld%lld",&N,&M);
if(N < M/2){
ans = N;
M -= 2*N;
ans += M/4;
}
else{
ans = M/2;
}
printf("%lld\n",ans);
return 0;
}
| 0
| 11,247,881
|
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<functional>
#include<string>
#include<iomanip>
#include<utility>
#include<string>
#include<map>
#include<unordered_map>
#include<queue>
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
using namespace std;
typedef long long ll;
typedef pair<int, int> Pi;
int gcd(int a, int b){return b ? gcd(b, a%b) : a;}
int lcm(int a, int b){return a*b / gcd(a, b);}
int main(){
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for(int i = 0; i < m; i++) cin >> a[i] >> b[i];
vector<bool> one2i(n+1, false);
vector<bool> i2n(n+1, false);
for(int i = 0; i < m; i++){
if(a[i] == 1){
one2i[b[i]] = true;
}
}
for(int i = 0; i < m; i++){
if(b[i] == n){
i2n[a[i]] = true;
}
}
string ans = "IMPOSSIBLE";
for(int i = 2; i < n; i++){
if(one2i[i] == true && i2n[i] == true){
ans = "POSSIBLE";
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> p(n), x(n + 1);
for (int i = 0; i < n; i++) {
cin >> p.at(i);
x.at(p.at(i)) = i;
}
multiset<ll> s;
s.insert(x.at(n));
s.insert(-1);
s.insert(-1);
s.insert(n);
s.insert(n);
ll ans = 0;
for (int i = n - 1; i >= 1; i--) {
s.insert(x.at(i));
auto now = s.find(x.at(i));
auto b = now;
b--;
auto a = b;
a--;
auto c = now;
c++;
auto d = c;
d++;
ll keep = (*now - *b) * (*d - *c) + (*b - *a) * (*c - *now);
ans += keep * i;
}
cout << ans << '\n';
}
| 0
| 71,086,003
|
#include <bits/stdc++.h>
using namespace std;
int ctos, son;
int A[10005];
int D[50005];
int main(){
ios::sync_with_stdio(false);
cin>>ctos>>son;
for(int i=1; i<=son; i++){
cin>>A[i];
}
for(int i=1; i<=ctos; i++){
D[i]=50001;
}
for(int k=1; k<=son; k++){
for(int i=1; i<=ctos; i++){
if(A[k] > i)
continue;
D[i] = min(D[i], 1 + D[i - A[k]]);
}
}
cout<<D[ctos]<<endl;
return 0;
}
|
#pragma target("avx")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef unordered_map<ll, ll> U_MAP;
typedef priority_queue<ll> pq;
typedef priority_queue<ll, vector<ll>, greater<ll>> rpq;
const int INF = 1e9, MOD = 1e9 + 7, ohara = 1e6 + 10;
const ll LINF = 1e18;
#define rep(i, n) for (ll(i) = 0; (i) < (int)(n); (i)++)
#define rrep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrrep(i, a, b) for (ll i = (a); i >= (b); i--)
#define all(v) (v).begin(), (v).end()
#define Size(n) (n).size()
#define Cout(x) cout << (x) << endl
#define doublecout(a) cout << fixed << setprecision(15) << a << endl;
#define fi first
#define se second
#define m_p make_pair
#define p_b push_back
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
string alph("abcdefghijklmnopqrstuvwxyz"), s;
ll n, cnt, ans, a[ohara], b[ohara], c, d, tmp, m, h, w, x, y, sum, k, q;
priority_queue<P, vector<P>, greater<P>> que;
U_MAP mem;
ll decrease = LINF;
int main(void) {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n) cin >> a[i] >> b[i];
rep(i, n) {
sum += a[i];
if (a[i] > b[i]) decrease = min(decrease, b[i]);
}
ans = sum - decrease;
ans = (decrease == LINF ? 0 : ans);
Cout(ans);
return 0;
}
| 0
| 66,537,798
|
#include<iostream>
#include<math.h>
#include<algorithm>
#include<stdint.h>
#include<vector>
#include<deque>
#include<stack>
#include<string>
#include<cstring>
#include<time.h>
#include<array>
#include<iomanip>
#include<list>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<random>
#include<bitset>
#include <queue>
#include <map>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ldouble = long double;
#define PRI(s) cout << s << endl
#define PRIY PRI("Yes")
#define PRIN PRI("No")
int main() {
int a, b;
cin >> a >> b;
if (a != 1 && b != 1)PRI(1);
if (a != 2 && b != 2)PRI(2);
if (a != 3 && b != 3)PRI(3);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
ios_base::sync_with_stdio(false);cin.tie(0);
string S;
int a = 0;
int b = 0;
int c = 0;
int y = 0;
int x = 0;
cin>>S;
string s = S;
reverse(s.begin(),s.end());
if(s == S){
a = 1;
}
y = ((S.size() - 1 / 2) - 1) / 2;
string d2;
for(int i = 0;i < y;i++){
d2.push_back(S[i]);
}
string d = d2;
reverse(d.begin(),d.end());
if(d == d2){
b = 1;
}
x = (((S.size() + 3) / 2) - 1);
string s2;
for(int i = x;i < (S.size());i++){
s2.push_back(S[i]);
}
string s3 = s2;
reverse(s3.begin(),s3.end());
if(s3 == s2){
c = 1;
}
if(a == 1 && b == 1 && c == 1){
cout<<"Yes"<<'\n';
}else{
cout<<"No"<<'\n';
}
}
| 0
| 41,480,090
|
#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=1e9+7;
int main(){
string s;
cin >> s;
ll n=s.length();
ll ans=0;
rep(i,n){
if(s[i]=='o') ans++;
}
if(ans+15-n>=8) cout << "YES" << endl;
else cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int mod = 1000000007;
int main(void){
int N, M; cin >> N >> M;
int S[N+1] = {}; rep(i, N) cin >> S[i+1];
int T[M+1] = {}; rep(i, M) cin >> T[i+1];
ll dp[N+1][M+1];
rep(i, N+1) rep(j, M+1) dp[i][j] = 0;
dp[0][0] = 1;
rep(i, N) dp[i+1][0] = 1;
rep(j, M) dp[0][j+1] = 1;
for(int i = 1; i <= N; i++){
for(int j = 0; j <= M-1; j++){
if(S[i] == T[j+1]) dp[i][j+1] = (dp[i][j] + dp[i-1][j+1]) % mod;
else dp[i][j+1] = (dp[i][j] + (dp[i-1][j+1] - dp[i-1][j])) % mod;
}
}
if(dp[N][M] < 0) dp[N][M] += mod;
cout << dp[N][M] << endl;
return 0;
}
| 0
| 32,102,348
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int H, W;
cin >> H >> W;
vector<string> s( H );
for( int i = 0; i < H; i++ ) {
cin >> s[i];
}
vector<vector<int>> dp( H, vector<int>( W, INT32_MAX / 2 ) );
dp[0][0] = 0;
if( s[0][0] == '#' ) dp[0][0] = 1;
int dx[2] = { 0, 1 };
int dy[2] = { 1, 0 };
for( int y = 0; y < H; y++ ) {
for( int x = 0; x < W; x++ ) {
for( int i = 0; i < 2; i++ ) {
int ny = y + dy[i];
int nx = x + dx[i];
if( ny >= H || nx >= W ) continue;
int a = 0;
if( s[y][x] == '.' && s[ny][nx] == '#' ) a = 1;
dp[ny][nx] = min( dp[ny][nx], dp[y][x] + a );
}
}
}
int ans = dp[H - 1][W - 1];
cout << ans << endl;
}
|
#include <iostream>
#include <stack>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, x;
stack<int> st;
int i, s;
int cnt = 0;
while (cin >> n >> x && (n > 0 || x > 0)) {
st = stack<int>();
i = 1; s = 0;
cnt = 0;
if (x == 0) {
cout << 0 << "\n";
continue;
}
while (i<=n) {
if (st.size()<3 && s+i <= x) {
st.push(i);
s += i;
if (st.size()==3 && s==x)
cnt++;
}
if (s >= x) {
i = st.top()+1; s -= st.top(); st.pop();
}
else {
i++;
}
while (i > n && st.size() > 0) {
i = st.top()+1; s -= st.top(); st.pop();
}
}
cout << cnt << "\n";
}
}
| 0
| 49,898,342
|
#include <bits/stdc++.h>
#define PI 3.14159265359
#define NIL -1
using namespace std;
const int64_t MOD = 1e9 + 7;
int main() {
int N, A;
cin >> N >> A;
cout << N * N - A << endl;
}
|
#include <iostream>
#include <string>
int main(void)
{
std::string s, p;
std::cin >> s >> p;
s += s;
int count;
bool contains = false;
for (int i = 0; i + p.size() <= s.size(); i++)
{
count = 0;
while (count < p.size() && p[count] == s[i + count])
{
count++;
}
if (count == p.size())
{
contains = true;
break;
}
}
std::cout << (contains ? "Yes" : "No") << '\n';
return 0;
}
| 0
| 10,236,609
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ll a,b;
char x;
cin>>a>>x>>b;
if(x == '+'){
cout<<a+b<<"\n";
}
else{
cout<<a-b<<"\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
bool a[100005];
int p[100005];
int main() {
int n, m;
cin >> n >> m;
int ac = 0, pena = 0;
rep(i, m) {
int x;
string s;
cin >> x >> s;
if (a[x]) continue;
if (s == "AC")
a[x] = 1, ac++, pena += p[x];
else
p[x]++;
}
cout << ac << ' ' << pena << endl;
return 0;
}
| 0
| 62,709,889
|
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <math.h>
#include <numeric>
using namespace std;
#define _GLIBCXX_DEBUG
#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++)
const int INF = 1001001001;
int main()
{
int a, b, c;
cin >> a >> b >> c;
if(c >= a && b >= c)
{
cout << "Yes" << endl;
}
else
{
cout << "No" << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main( void )
{
string s, t;
cin >> s >> t;
int size;
bool large = false;
int count = 0;
sort( s.begin(), s.end() );
sort( t.begin(), t.end() ,greater<int>() );
if( s.size() > t.size() )
size = t.size();
else
size = s.size();
for( int i = 0; i < size; i++ ) {
if( s.at( i ) < t.at( i ) ) {
large = true;
break;
}
else if( s.at( i ) > t.at( i ) ) {
large = false;
break;
}
count++;
}
if( count == size ) {
if( s.size() >= t.size() )
large = false;
else
large = true;
}
if( large )
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 0
| 47,755,644
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int row1, col1, row2, col2;
cin >> row1 >> row2;
col1 = row1;
col2 = row2;
vector<string> vec(row1);
vector<string> vec2(row2);
for (int i = 0; i < row1; i++) cin >> vec.at(i);
for (int i = 0; i < row2; i++) cin >> vec2.at(i);
for (int i = 0; i <= row1 - row2; i++) {
for (int j = 0; j <= col1 - col2; j++) {
bool okFlg = true;
for (int k = 0; k < row2; k++) {
string tmp1, tmp2;
tmp1 = vec.at(i+k);
tmp2 = vec2.at(k);
if (tmp1.substr(j, row2) != tmp2) {
okFlg = false;
break;
}
}
if (okFlg == true) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
}
|
#include <iostream>
#include <vector>
#include <queue>
#include <cstdio>
using namespace std;
int n;
vector <int> G[101];
queue <int> Q;
int d[100];
int dis[101];
int visit(int x){
int t,i;
Q.push(x);
dis[x] = 0;
d[x] = 1;
while(Q.empty() == false) {
t = Q.front();
Q.pop();
for(i=0; i<G[t].size();i++) {
if(d[G[t][i]] == 0 ) {
d[G[t][i]] = 1;
dis[G[t][i]] = dis[t] + 1;
Q.push(G[t][i]);
}
}
}
}
int main() {
int i,j,k,l,u,a,t;
scanf("%d",&n);
for(i=0;i<n;i++){
d[i] = 0;
dis[i] = -1;
scanf("%d %d ",&k,&u);
for(j=0;j<u;j++) {
scanf("%d",&a);
G[k-1].push_back(a-1);
}
}
visit(0);
for(i=0;i<n;i++) cout << i+1<<" " << dis[i] <<endl;
return 0;
}
| 0
| 55,621,209
|
#include "bits/stdc++.h"
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
using ll =long long;
using P =pair<int,int>;
int main(){
int n;
cin >> n;
string s,sf,sl;
vector <int> m(n,0);
cout << 0 << endl;
cin >> s;
if(s=="Vacant"){
exit(0);
}
else{
sf=s;
cout << n-1 << endl;
cin >> s;
if(s=="Vacant"){
exit(0);
}
else{
sl=s;
int mi,r,l;
r=n-1;
l=0;
while(r-l!=1){
mi=(r+l)/2;
cout << mi << endl;
cin >> s;
if(s=="Vacant"){
exit(0);
}
else{
if(s==sf){
if((mi-l)%2==0){
l=mi;
}
else{
r=mi+1;
}
}
else{
if((mi-l)%2==0){
r=mi;
}
else{
l=mi-1;
}
}
}
}
}
}
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 all(a) (a.begin(),a.end())
#define ff first
#define ss second
#define pii pair<int,int>
#define lcm(a,b) (a*b)/__gcd(a,b)
using namespace std;
inline void solve(){
map <int,int> ev,od;
int n,emax=0,omax=0; cin>>n;
for (int i=1;i<=n;i++){
int a;cin>>a;
if (i&1) {
od[a]++;
omax=max(omax,od[a]);
}
else {
ev[a]++;
emax=max(emax,ev[a]);
}
}
int a,b,c,d;
priority_queue<int> e,o;
e.push(0),o.push(0);
for (auto &it: ev) e.push(it.ss);
for (auto &it: od) o.push(it.ss);
for (auto &it: ev) {
if (emax==it.ss) {
emax=it.ff;break;
}
}
for (auto &it: od) {
if (omax==it.ss) {
omax=it.ff;break;
}
}
a=e.top();e.pop();
b=e.top();e.pop();
c=o.top();o.pop();
d=o.top();o.pop();
int ans=0;
if (omax==emax)
ans = min(n-a-d,n-b-c);
else ans = n-a-c;
cout << ans << endl;
}
signed main()
{
int n=1;
while (n--) solve();
return 0;
}
| 0
| 31,535,523
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> pll;
const ll mod=1e9+7;
const ll inf=1LL<<61;
int main() {
string a,b,c;
cin >> a >> b >> c;
cout << char(a[0]-'a'+'A') << char(b[0]-'a'+'A') << char(c[0]-'a'+'A') << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,n) for(ll i=0;i<n;i++)
#define Graph vector<vector<ll>>
#define INF (1ll<<60)
#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; }
int main(){
string L;cin>>L;
ll dp[100005][2];
rep(i,100005) dp[i][true]=dp[i][false]=0;
dp[0][false]=1;
rep(i,L.size()){
dp[i+1][true]+=3*dp[i][true];
dp[i+1][true]%=mod;
if(L[i]=='1'){
dp[i+1][false]+=2*dp[i][false];
dp[i+1][false]%=mod;
dp[i+1][true]+=dp[i][false];
dp[i+1][true]%=mod;
}else{
dp[i+1][false]+=dp[i][false];
dp[i+1][false]%=mod;
}
}
cout<<(dp[L.size()][true]+dp[L.size()][false])%mod<<endl;
return 0;
}
| 0
| 100,872,034
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
const ll INF = 100100100100;
int v, e;
int main()
{
cin >> v >> e;
vector<vector<ll>> D(v, vector<ll>(v, INF));
rep(i, e)
{
int s, t;
ll d;
cin >> s >> t >> d;
D[s][t] = d;
}
rep(k, v) rep(i, v) rep(j, v)
{
if (D[i][k] != INF && D[k][j] != INF && D[i][j] > D[i][k] + D[k][j])
{
D[i][j] = D[i][k] + D[k][j];
}
}
rep(i, v)
{
if (D[i][i] < 0)
{
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
D[i][i] = 0;
}
rep(i, v) rep(j, v)
{
if (D[i][j] == INF)
cout << "INF";
else
cout << D[i][j];
if (j == v - 1)
cout << endl;
else
cout << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
using bint = boost::multiprecision::cpp_int;
using ll = long long;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define repSE(i,s,n) for (int i = (s); i < (n); i++)
#define rrepSE(i,s,e) for (int i = (s); i > (e); i--)
#define ssort(v) sort(v.begin(), v.end())
#define gsort(v) sort(v.rbegin(), v.rend())
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
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 (q < m) {m = q; return true;} else return false; }
#define DEBUG_PRINT(var) std::cout << #var << " = " << var << "\n";
int main()
{
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
map<int,vector<int>> mp;
rep(i,n) mp[a[i]].push_back(i);
int cnt = 0, now = -1;
while (cnt < n) {
if (mp[cnt+1].empty()) break;
int j = 0;
while (j < mp[cnt+1].size() && mp[cnt+1][j] <= now) j++;
if (mp[cnt+1][j] <= now) break;
now = mp[cnt+1][j];
cnt++;
}
int ans = (cnt == 0) ? -1 : n - cnt;
cout << ans << "\n";
return 0;
}
| 0
| 27,967,426
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
int N;
vector<int> A, B;
int calc(int b) {
int ret = 0;
for (int i = 1; i <= N; i++) {
ret += abs(A[i-1] - (b + i));
}
return ret;
}
signed main() {
cin >> N;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
B[i] = A[i] - (i + 1);
}
sort(B.begin(), B.end());
cout << calc(B[N/2]) << endl;
return 0;
}
|
#define MYDEBUG
#include <bits/stdc++.h>
#ifdef MYDEBUG
#define dbp(x) cout<<#x<<": "<<x<<endl
#define dbp2(x,y) cout<<#x<<","<<#y<<": "<<x<<","<<y<<endl
#define dbp3(x,y,z) cout<<#x<<","<<#y<<","<<#z<<": "<<x<<","<<y<<","<<z<<endl
#define dbp4(w,x,y,z) cout<<#w<<","<<#x<<","<<#y<<","<<#z<<": "<<w<<","<<x<<","<<y<<","<<z<<endl
#define ifcin(x) std::ifstream cin(x)
#else
#define dbp(x)
#define dbp2(x,y)
#define dbp3(x,y,z)
#define dbp4(w,x,y,z)
#define ifcin(x)
#endif
#define ll long long
#define all(x) x.begin(), x.end()
#define rep(i, from, to) for(int i=from; i<to; ++i)
#define REP(i, from, to) for(int i=from; i<=to; ++i)
using namespace std;
typedef struct Node {
int parent, left, right;
} Node;
static const int NMAX = 100000;
static const int NIL = -1;
Node T[NMAX];
int n, D[NMAX];
static const string ROOT = "root";
static const string INTERNAL = "internal node";
static const string LEAF = "leaf";
void setDepth(int id, int depth) {
D[id] = depth;
if (T[id].right != NIL) {
setDepth(T[id].right, depth);
}
if (T[id].left != NIL) {
setDepth(T[id].left, depth + 1);
}
}
void printChildren(int id) {
cout << "[";
int cid = T[id].left;
while (cid != NIL) {
if (cid != T[id].left) {
cout << ", ";
}
cout << cid;
cid = T[cid].right;
}
cout << "]";
}
void printNode(int id) {
if (id == NIL) {
return;
}
printf("node %d: parent = %d, depth = %d, ", id, T[id].parent, D[id]);
string nodeType = INTERNAL;
if (T[id].parent == NIL) {
nodeType = ROOT;
} else if (T[id].left == NIL) {
nodeType = LEAF;
}
printf("%s, ", nodeType.c_str());
printChildren(id);
printf("\n");
}
int main() {
cin >> n;
rep(i,0,NMAX)
{
T[i].parent = T[i].left = T[i].right = NIL;
D[i] = 0;
}
rep(i,0,n)
{
int id, k;
cin >> id >> k;
int lastChild = NIL;
rep(j,0,k)
{
int c;
cin >> c;
T[c].parent = id;
if (T[id].left == NIL) {
T[id].left = c;
}
if (lastChild != NIL) {
T[lastChild].right = c;
}
lastChild = c;
}
}
int root = 0;
rep(i,1,n)
{
if (T[i].parent == NIL) {
root = i;
}
}
setDepth(root, 0);
rep(i,0,n)
{
printNode(i);
}
}
| 0
| 41,159,646
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <unordered_map>
typedef long long ll;
using namespace std;
const int mod=1e9+7;
string solve(){
string s;
cin>>s;
ll sm=0;
for(char c:s) sm+=(c-'0');
return (sm%9)?"No":"Yes";
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t=1;
while(t--) cout<<solve()<<'\n';
return 0;
}
|
#include <iostream>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#define rep(i,n) for(int i = 0; i < n; i++)
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int, int>
#define mod 1000000007
using ll = long long;
using namespace std;
int main(){
ll n;
cin >> n;
vector<ll> a(n);
rep(i, n){
ll A;
cin >> A;
A -= i + 1;
a[i] = A;
}
sort(a.begin(), a.end());
if(n % 2 == 0){
ll ans = 0, ans2 = 0;
ll num = a[n / 2];
rep(i, n) ans += abs(a[i] - num);
num = a[n / 2 - 1];
rep(i, n) ans2 += abs(a[i] - num);
ans = min(ans, ans2);
cout << ans << endl;
}else{
ll num = a[n / 2];
ll ans = 0;
rep(i, n) ans += abs(a[i] - num);
cout << ans << endl;
}
}
| 0
| 92,116,331
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define FOR(i,start,end) for(int i=start;i<=end;i++)
const int INF = 1001001001;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
typedef long long ll;
const ll MOD=1000000007;
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; }
template<class T>auto MAX(const T& a) { return *max_element(a.begin(),a.end()); }
template<class T>auto MIN(const T& a) { return *min_element(a.begin(),a.end()); }
template<class T, class U>U SUM(const T& a, const U& v) { return accumulate(a.begin(),a.end(), v); }
template<class T, class U>U COUNT(const T& a, const U& v) { return count(a.begin(),a.end(), v); }
template<class T, class U>int LOWER(const T& a, const U& v) { return lower_bound(a.begin(),a.end(), v) - a.begin(); }
template<class T, class U>int UPPER(const T& a, const U& v) { return upper_bound(a.begin(),a.end(), v) - a.begin(); }
int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }
int LCM(int a, int b) { int g = GCD(a, b); return a / g * b; }
typedef long double ld;
typedef unsigned long long int ull;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<pair<ll, ll>> vpll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vc> vvc;
typedef vector<vs> vvs;
typedef vector<vll> vvll;
typedef map<int, int> mii;
typedef set<int> si;
int main(void){
int n; cin >> n;
string s,t; cin >> s >> t;
int ans = 2*n;
int now = 0;
FOR(i,1,n) {
if (s.substr(n-i,i) == t.substr(0,i)) {
now = max(now,i);
}
}
cout << max(n,ans-now) << endl;
}
|
#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <map>
using namespace std;
int a[300010],num2[300010],num[300010],sum_num[300010],sum_tot[300010];
int check(int m,int n)
{
int p=0;
p+= sum_num[n]-sum_num[m-1];
p+= sum_tot[m-1]/m;
return p;
}
int main()
{
int n;scanf("%d",&n);
for(int i=0;i<n;++i) scanf("%d",&a[i]);
for(int i=0;i<n;++i) ++num2[a[i]];
for (int i=0;i<=n;++i) num[ num2[i] ]++;
sum_num[0]=sum_tot[0]=0;
for (int i=1;i<=n;++i)
{
sum_tot[i]=sum_tot[i-1]+num[i]*i;
sum_num[i]=sum_num[i-1]+num[i];
}
int ll=1;int rr=n;int ans=n;
for (int k=1;k<=n;++k)
{
ll=1;rr=ans;ans=0;
while (ll<=rr)
{
int mid=(ll+rr)/2;
if ( check(mid,n)>=k ){
ans=mid;ll=mid+1;
}
else rr=mid-1;
}
printf("%d\n",ans);
}
}
| 0
| 77,042,728
|
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
using ll = long long;
using ld = long double;
template <class T> using vt = vector<T>;
template <class T> using vvt = vector<vector<T>>;
template <class T> using vvvt = vector<vector<vector<T>>>;
using ml = boost::multiprecision::cpp_int;
#define all(c) (c).begin(), (c).end()
#define rep(i, b, e) for (ll i = b; i < e; i++)
#define repr(i, b, e) for (ll i = b; e < i; i--)
#define val(itr) *(itr)
#define llong_max 9223372036854775807
#define ldbl_max 1.79769e+308
#define mod 1000000007
#define pi 3.14159265358979323846
#define fori(i, ...) if(ll i = -1) for(__VA_ARGS__) if(i++, true)
#define each(i, e, c) fori(i, auto e = c.begin(); e != c.end(); ++e)
#define forir(i, v, ...) if(ll i = Size(v)) for(__VA_ARGS__) if(i--, true)
#define eachr(i, e, c) forir(i, auto e = c.rbegin(); e != c.rend(); ++e)
auto Count = []
(auto b, auto e, auto x) { return (ll)count(b, e, x); };
auto CtoN = []
(auto c) { return (ll)(c - '0'); };
auto DivC = []
(auto a, auto b) { return ceil((ld)a / (ld)b); };
auto Fix = []
(auto b, auto e, auto fix)
{ for (auto it = b; it != e; ++it)*it += fix; };
auto Pow = []
(auto a, auto b) { return (ll)pow(a, b); };
auto Pow2 = []
(auto n) { return (1LL << n); };
auto Pow10 = []
(auto n) { return (ll)pow(10, n); };
auto Size = []
(auto& c) { return (ll)(c).size(); };
auto Sum = []
(auto b, auto e) { return accumulate(b, e, 0LL); };
template <class T> vvt<T> VVT
(ll ys, ll xs, T fill = T())
{
vvt<T> v(ys);
each(i, y, v) { val(y).resize(xs, fill); } return v;
}
template <class T> vvvt<T> VVVT
(ll zs, ll ys, ll xs, T fill = T())
{
vvvt<T> v(zs);
each(i, z, v) { val(z) = VVT(ys, xs, fill); } return v;
}
template <class T> vt<T> InputVT
(ll size, T fix = T())
{
vt<T> v(size);
each(i, e, v) { cin >> val(e); val(e) += fix; } return v;
}
template <class T> vvt<T> InputVVT
(ll ys, ll xs, T fix = T())
{
vvt<T> v(ys); each(i, y, v) val(y).resize(xs);
each(i, y, v) each(j, x, val(y)) { cin >> val(x); val(x) += fix; }
return v;
}
template <class T> vvvt<T> InputVVVT
(ll zs, ll ys, ll xs, T fix = T())
{
vvvt<T> v(zs);
each(i, z, v) { val(z) = InputVVT<T>(ys, xs, fix); }
return v;
}
struct Engine
{
ll x;
ll y;
ld angle;
};
auto NyaSort = [](const Engine& l, const Engine& r)
{
return l.angle < r.angle;
};
int main(void)
{
ll N; cin >> N;
vt<Engine> v(N);
each(i, e, v)
{
cin >> e->x >> e->y;
e->angle = atan2(e->y, e->x);
}
sort(all(v), NyaSort);
ld ans = 0;
rep(i, 0, N)
{
ll xsum = 0;
ll ysum = 0;
rep(j, i, i+N)
{
xsum += v[j % N].x;
ysum += v[j % N].y;
ans = max(ans, (ld)sqrt(xsum * xsum + ysum * ysum));
}
}
cout << std::fixed << std::setprecision(12) << ans;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int K, S;
cin >> K >> S;
int ans = 0;
for (int x = 0; x <= K; ++x) {
for (int y = 0; y <= K; ++y) {
int z = S - x - y;
if (0 <= z && z <= K) ++ans;
}
}
cout << ans << endl;
return 0;
}
| 0
| 61,684,485
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct UnionFind
{
std::vector<int> par, cou;
UnionFind(int N = 0) : par(N), cou(N, 1) {
iota(par.begin(), par.end(), 0);
}
int find(int x) { return (par[x] == x) ? x : (par[x] = find(par[x])); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return false;
if (cou[x] < cou[y]) std::swap(x, y);
par[y] = x, cou[x] += cou[y];
return true;
}
int count(int x) { return cou[find(x)]; }
bool same(int x, int y) { return find(x) == find(y); }
};
void solve() {
int n; cin >> n;
int q; cin >> q;
UnionFind u(n);
while (q--) {
int t, a, b; cin >> t >> a >> b;
if (t == 0)u.unite(a, b);
else if (t == 1) {
if (u.same(a, b))cout << 1 << "\n";
else cout << 0 << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
solve();
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const ll LINF = 1e18;
const int mod = 1e9+7;
#define pi pair<int,int>
#define pl pair<lld,lld>
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
#define SANKOU(n,a,b) cout << ((n) ? (#a) : (#b) ) << endl
#define mem0(x) memset(x,0,sizeof(x))
#define fillnum(x,n) fill(begin(x),end(x),n)
#define asort(x) sort(x.begin(),x.end())
#define dsort(x,t) sort(x.begin(),x.end(),greater<t>())
#define vuniq(x) x.erase(unique(x.begin(), x.end()), x.end())
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
int main() {
ll N,A,B;
cin >> N >> A >> B;
ll cnt[3];
mem0(cnt);
for (int i = 0; i < N; i++) {
ll P; cin >> P;
if(B+1 <= P){
cnt[2]++;
} else if(P >= A+1 && P <= B){
cnt[1]++;
} else {
cnt[0]++;
}
}
cout << min(min(cnt[0],cnt[1]),cnt[2]) << endl;
}
| 0
| 16,330,535
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, fN = 0;
cin >> N;
M = N;
for(int i = 0; i < 8; i++) {
fN += N % 10;
N /= 10;
if (N == 0) {
break;
}
}
if(M % fN == 0){
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
|
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <sstream>
#include <map>
#include <queue>
#include <set>
#define rep(i,n) for(int i = 0; i < n; i++)
#define rep1(i,n) for(int i = 1; i <= n; i++)
#define co(x) cout << x <<endl
#define cs(x) cout << x <<" "
#define ALL(a) (a).begin(),(a).end()
typedef long long ll;
using namespace std;
ll mod = 1e9 + 7;
int main()
{
vector<int> n(4);
rep(i, 4)cin >> n[i];
sort(ALL(n));
if (n[0] == 1 && n[1] == 4 && n[2] == 7 && n[3] == 9)co("YES");
else co("NO");
return 0;
}
| 0
| 85,454,559
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define repa(i,a,n) for(int i=a;i<=n;i++)
#define repb(i,a,n) for(int i=a;i>=n;i--)
#define trav(a,x) for(auto a=x.begin();a!=x.end();a++)
#define all(x) x.begin(),x.end()
#define fst first
#define snd second
#define pb push_back
#define mp make_pair
typedef long double ld;
typedef pair <int,int> pii;
typedef vector <int> vi;
typedef long long ll;
void solve()
{
int d,t,s;
cin>>d>>t>>s;
if(s*t>=d)
{
cout<<"Yes"<<endl;
}else
{
cout<<"No"<<endl;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t=1;
for(int i=0;i<t;i++)
{
solve();
}
return 0;
}
|
#include <cmath>
#include <cstdio>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <map>
#include <stdio.h>
#include <functional>
#include <chrono>
#include <boost/version.hpp>
using namespace std;
#define rep(i,s,n) for(ll i=s;i<(n);++i)
using ll = long long;
using pll = pair<ll, ll>;
constexpr ll INF = (1LL << 60);
constexpr ll MAX_INF = 9223372036854775807;
constexpr ll MOD = (1e9 + 7);
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
template<class T>
vector<vector<T>> vvt(T init, ll m, ll n) {
vector<vector<T>> ans = vector<vector<T>>(m, vector<T>(n, init));
return move(ans);
}
template<class T>
vector<T> vt(T init, ll n) {
vector<T> ans = vector<T>(n, init);
return move(ans);
}
template<class T>
T maxVec(vector<T>& v) {
T ans = -INF;
rep(i, 0, v.size()) {
ans = max(ans, v[i]);
}
return ans;
}
bool judge(ll n) {
for (ll i = 2; i * i <= n; i++) if (n %= i)return false;
return true;
}
template <class C>
void print(const C & c, std::ostream & os = std::cout)
{
std::copy(std::begin(c), std::end(c), std::ostream_iterator<typename C::value_type>(os, ", "));
os << std::endl;
}
bool sortreverse(ll a, ll b) {
return a > b;
}
ll kiriage(ll a, ll b) {
if (a % b == 0)return a / b;
return a / b + 1;
}
ll n, m, t, q, s,k,h,w,x,y;
void warshall_floyd(ll v_num,vector<vector<long long>> &d) {
for (long long k = 0; k < v_num; k++) {
for (long long i = 0; i < v_num; i++) {
for (long long j = 0; j < v_num; j++) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
ll modpow(ll n, ll a, ll m) {
if (n > 1000000000) {
printf("large");
exit(0);
}
if (a == 0)return 1;
if (a % 2 == 0) {
ll b = modpow(n, a / 2, m);
if (b*b > 1000000000) {
printf("large");
exit(0);
}
return (b * b);
}
else if (a % 2 == 1) {
ll b = modpow(n, a -1, m);
if (b*n > 1000000000) {
printf("large");
exit(0);
}
return (n * b);
}
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
ll f;
cin >> n >> k;
ll ans = 0;
rep(i, k, n+2) {
ll minNum = (i - 1) * i / 2, maxNum = (n + 1) * n / 2 - (n + 1 - i) * (n - i) / 2;
ans += (maxNum - minNum + 1) % MOD;
ans %= MOD;
}
printf("%lld\n", ans);
}
| 0
| 35,429,691
|
#include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/2
using namespace std;
int MOD = 1000000007;
signed main(){
int h,w,n;
cin >> h >> w >> n;
map<pair<int,int>,int> m;
rep(i,n){
int a,b;
cin >> a >> b;
for(int x = -1;x <= 1;x++){
for(int y = -1;y <= 1;y++){
if(a+x <= 1 || a+x >= h || b+y <= 1 || b+y >= w)continue;
m[MP(a+x,b+y)]++;
}
}
}
int all = 0;
int cnt[10] = {0};
for(auto p:m){
cnt[p.se]++;
all++;
}
cout << (h-2)*(w-2) - all << endl;
for(int i = 1;i <= 9;i++) cout << cnt[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int A, B, C, D;
A = s.at(0) - '0';
B = s.at(1) - '0';
C = s.at(2) - '0';
D = s.at(3) - '0';
for (int tmp; tmp < (1 << 3); tmp++){
bitset<3> bit(tmp);
int sum = A;
char op1 = '-';
char op2 = '-';
char op3 = '-';
if(bit.test(0)){
sum += B;
op1 = '+';
}
else sum -= B;
if(bit.test(1)){
sum += C;
op2 = '+';
}
else sum -= C;
if(bit.test(2)){
sum += D;
op3 = '+';
}
else sum -= D;
if (sum == 7){
cout << A << op1 << B << op2 << C << op3 << D << "=7" << endl;
return 0;
}
}
}
| 0
| 43,341,314
|
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
#define V vector
#define P pair
typedef long long ll;
const int INT_INF = 1e9;
const ll INF = 1LL << 30;
int main() {
ll n; cin >> n;
map<ll, ll> m;
for(int i = 0; i < n; i++){
ll a; cin >> a;
m[a]++;
}
ll ans = 0;
for(auto p : m){
if(p.first != p.second){
if(p.second > p.first){
ans += p.second - p.first;
}else{
ans += p.second;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct matrix
{
int r, c;
};
int min_chain_mul(vector<matrix> M) {
int c[M.size() + 1][M.size() + 1];
for (int i = 1; i <= M.size(); i++) {
c[i][i] = 0;
}
for (int l = 2; l <= M.size(); l++) {
for (int i = 1; i <= M.size() - l + 1; i++) {
int j = i + l -1;
c[i][j] = (1 << 21);
for (int k = i; k <= j - 1; k++) {
c[i][j] = min(c[i][j], c[i][k]+c[k+1][j] + M.at(i-1).r * M.at(k-1).c * M.at(j-1).c);
}
}
}
return c[1][M.size()];
}
int main() {
int n;
cin >> n;
vector<matrix> M;
for (int i = 0; i < n; i++)
{
matrix m;
cin >> m.r >> m.c;
M.push_back(m);
}
cout<< min_chain_mul(M) << endl;
}
| 0
| 91,513,622
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i =0; i < (n); ++i)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
rep(i,m) cin >> L[i] >> R[i];
sort(R.begin(), R.end());
sort(L.begin(), L.end(),greater<int>());
int sms = R[0];
int ler = L[0];
int ans = 0;
for (int i = 1; i < n + 1; i++) {
if(i <= sms && i >= ler) {
ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long num;
cin >> num;
vector<long long> vec(num+1);
for (int i = 0; i < num; i++) cin >> vec.at(i+1);
if (num % 2 == 0){
for (int i = num; i > 1; i -= 2){
cout << vec.at(i) << " ";
}
for (int i = 1; i < num; i += 2){
cout << vec.at(i) << " ";
}
}else{
for (int i = num; i > 0; i -= 2){
cout << vec.at(i) << " ";
}
for (int i = 2; i < num; i += 2){
cout << vec.at(i) << " ";
}
}
}
| 0
| 12,796,292
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
int main()
{
int n;
double ans=0;
cin>>n;
rep(i,n){
double a;
cin>>a;
ans+=1/a;
}
ans=1/ans;
printf("%.10f",ans);
}
|
#include <iostream>
#include <string>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int i, j, d[7], d_next[7], num, top, front;
cin >> d[1] >> d[2] >> d[3] >> d[4] >> d[5] >> d[6];
cin >> num;
for(i=0;i<num;i++){
cin >> top >> front;
if (top == d[1]){
if(front == d[2]){
cout << d[3] << endl;
}else if(front == d[3]){
cout << d[5] << endl;
}else if(front == d[5]){
cout << d[4] << endl;
}else if(front == d[4]){
cout << d[2] << endl;
}
}else if(top == d[2]){
if(front == d[6]){
cout << d[3] << endl;
}else if(front == d[3]){
cout << d[1] << endl;
}else if(front == d[1]){
cout << d[4] << endl;
}else if(front == d[4]){
cout << d[6] << endl;
}
}else if(top == d[3]){
if(front == d[1]){
cout << d[2] << endl;
}else if(front == d[2]){
cout << d[6] << endl;
}else if(front == d[6]){
cout << d[5] << endl;
}else if(front == d[5]){
cout << d[1] << endl;
}
}else if(top == d[4]){
if(front == d[2]){
cout << d[1] << endl;
}else if(front == d[1]){
cout << d[5] << endl;
}else if(front == d[5]){
cout << d[6] << endl;
}else if(front == d[6]){
cout << d[2] << endl;
}
}else if(top == d[5]){
if(front == d[1]){
cout << d[3] << endl;
}else if(front == d[3]){
cout << d[6] << endl;
}else if(front == d[6]){
cout << d[4] << endl;
}else if(front == d[4]){
cout << d[1] << endl;
}
}else if(top == d[6]){
if(front == d[3]){
cout << d[2] << endl;
}else if(front == d[2]){
cout << d[4] << endl;
}else if(front == d[4]){
cout << d[5] << endl;
}else if(front == d[5]){
cout << d[3] << endl;
}
}
}
return 0;
}
| 0
| 81,180,505
|
#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 mod=1e9+7;
int main()
{
ll n,m;
cin >> n >> m;
if(n%2==0 && n-2==2*m){
bool ok=false;
for(ll l=1,r=n;l<r;l++,r--){
if(r-l<=n/2 && ok==false){
r++;
ok=true;
continue;
}
cout << l << " " << r << endl;
}
}
else{
for(ll i=1;i<=m;i++){
cout << i << " " << n+1-i << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define FASTIO
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Vl = vector<ll>;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
constexpr int I_INF = numeric_limits<int>::max();
constexpr ll L_INF = numeric_limits<ll>::max();
void solve() {
string S;
cin >> S;
for (auto& c : S) {
if (c == ',') {
c = ' ';
}
}
cout << S << "\n";
}
int main() {
#ifdef FASTIO
cin.tie(0), cout.tie(0);
ios::sync_with_stdio(false);
#endif
#ifdef FILEINPUT
ifstream ifs("./in_out/input.txt");
cin.rdbuf(ifs.rdbuf());
#endif
#ifdef FILEOUTPUT
ofstream ofs("./in_out/output.txt");
cout.rdbuf(ofs.rdbuf());
#endif
solve();
cout << flush;
return 0;
}
| 0
| 20,352,799
|
#include<bits/stdc++.h>
#define Vsort(a) sort(a.begin(), a.end())
#define rep(i,n) for(int i = 0; i < (n); i++)
#define Srep(i,a,n) for(int i = (a); i < (n); i++)
#define ll long long
#define P pair<int, int>
using namespace std;
int main(){
ll a,b,k;
cin >> a >> b >> k;
if(a < k){
b -= k - a;
a = 0;
if(b < 0) b = 0;
}else{
a -= k;
}
cout << a << " " << b << endl;
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i,n) for(int i=0, i##_len=(int)(n); i<i##_len; i++)
#define reps(i,n) for(int i=1 , i##_len=(int)(n);i<=i##_len;i++)
#define rrep(i,n) for(int i=((int)(n)-1);i>=0;i--)
#define rreps(i,n) for(int i=((int)(n));i>0;i--)
#define repi(i,x) for(auto i=(x).begin(),i##_fin=(x).end();i!=i##_fin;i++)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define solve(a) ((a)?"Yes":"No")
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef pair<int , int> Pi;
typedef vector<Pi> VPi;
typedef vector<long long> V;
typedef vector<V> VV;
typedef pair<long long , long long> P;
typedef vector<P> VP;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1;} return 0;}
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1;} return 0;}
const long long INFLL = 1LL<<60;
const int INF = 1<<30;
const double PI=acos(-1);
int main(){
int h,w;
string ans;
cin >>h>>w;
rep(i,h){
cin>>ans;
cout<<ans<<endl<<ans<<endl;
}
}
| 0
| 95,337,826
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define sd(x) scanf("%lf", &x)
#define l0(i,n) for(ll i=0; i<n; i++)
#define MAX 100005
#define maxn 200005
#define pb push_back
#define mk make_pair
#define endl "\n"
#define INF 1000000000
#define MOD 1000000007
#define imie(...) "[" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
int main()
{
int n;
cin >> n;
vector<int> hap[n+5];
vector<int> dp[n+5];
for (int i=0 ; i<n ; i++)
{
int a,b,c;
cin >> a >> b >> c;
hap[i].pb(a);
hap[i].pb(b);
hap[i].pb(c);
dp[i].pb(0);
dp[i].pb(0);
dp[i].pb(0);
}
dp[0][0] = hap[0][0];
dp[0][1] = hap[0][1];
dp[0][2] = hap[0][2];
for(int i = 1; i < n; i++){
dp[i][0] = hap[i][0]+max(dp[i-1][1], dp[i-1][2]);
dp[i][1] = hap[i][1]+max(dp[i-1][0], dp[i-1][2]);
dp[i][2] = hap[i][2]+max(dp[i-1][0], dp[i-1][1]);
}
int ans = *max_element(dp[n-1].begin(),dp[n-1].end());
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::string;
struct Four_digit {
string s1;
string s2;
int m;
int c;
int x;
int i;
};
vector<int> rewrite (string str);
void sum(vector<int> &v1, vector<int> &v2);
void output (vector<int> number);
int main(void) {
int n;
cin >> n;
vector<int> s1;
vector<int> s2;
for (int i = 0; i < n; i++) {
Four_digit num;
cin >> num.s1 >> num.s2;
s1 = rewrite(num.s1);
s2 = rewrite(num.s2);
sum(s1, s2);
output(s1);
}
return 0;
}
vector<int> rewrite (string str) {
vector<int> number(4, 0);
if (str[0] == 'm') {
number[0] = 1;
} else if (str[0] == 'c') {
number[1] = 1;
} else if (str[0] == 'x') {
number[2] = 1;
} else if (str[0] == 'i') {
number[3] = 1;
}
for (int i = 1; i < str.length(); i++) {
if (str[i] == 'm') {
if (str[i - 1] >= '0' && str[i - 1] <= '9') {
number[0] = str[i - 1] - '0';
} else {
number[0] = 1;
}
} else if (str[i] == 'c') {
if (str[i - 1] >= '0' && str[i - 1] <= '9') {
number[1] = str[i - 1] - '0';
} else {
number[1] = 1;
}
} else if (str[i] == 'x') {
if (str[i - 1] >= '0' && str[i - 1] <= '9') {
number[2] = str[i - 1] - '0';
} else {
number[2] = 1;
}
} else if (str[i] == 'i') {
if (str[i - 1] >= '0' && str[i - 1] <= '9') {
number[3] = str[i - 1] - '0';
} else {
number[3] = 1;
}
}
}
return number;
}
void sum(vector<int> &v1, vector<int> &v2) {
for (int i = 0; i < v1.size(); i++) {
v1[i] += v2[i];
}
for (int i = 3; i > 0; i--) {
if (v1[i] >= 10) {
v1[i] -= 10;
v1[i - 1]++;
}
}
return;
}
void output (vector<int> v) {
char kigou[4] = {'m', 'c', 'x', 'i'};
for (int i = 0; i < 4; i++) {
if (v[i] == 0) {
continue;
} else if (v[i] == 1) {
cout << kigou[i];
} else {
cout << v[i] << kigou[i];
}
}
cout << endl;
return;
}
| 0
| 73,417,871
|
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
cout<<max({a,b,c})-min({a,b,c})<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for (int i = 0; i < n; ++i)
#define range(i,a,b) ((a)<=(i) && (i)<(b))
#define debug(x) cout << #x << ' ' << '=' << ' ' << (x) << endl;
#define fs first
#define sc second
#define pb push_back
#define eb emplace_back
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
typedef vector<ll> vec;
typedef vector<P> pvec;
typedef vector<vector<ll>> vvec;
typedef vector<vector<P>> pvvec;
typedef priority_queue<ll> PQI;
typedef priority_queue<P> PQP;
typedef priority_queue<ll,vector<ll>,greater<ll>> PQIG;
typedef priority_queue<P,vector<P>,greater<P>> PQPG;
const vector<int> dx = {0, -1, 0, 1, 1, 1, -1, -1};
const vector<int> dy = {1, 0, -1, 0, 1, -1, 1, -1};
const int MOD = (1000000007);
const int INF = (1LL << 60);
const double EPS = (1 >> 30);
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return 1;} return 0;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return 1;} return 0;}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
int n;
cin>>n;
vector<int> a(n);
REP(i,n) cin >> a[i];
vec ra(n+1);
rep(i,n) ra[a[i]]=i;
ll ans=0;
multiset<int> s;
s.insert(-1); s.insert(n);
s.insert(-1); s.insert(n);
s.insert(ra[n]);
for(int d=n-1;d>=1;d--){
int i=ra[d];
auto it=s.lower_bound(i);
int r=*it;
it++;
int R=*it;
it--;
it--;
int l=*it;
it--;
int L=*it;
ll memo=0;
if(r!=n&&l!=-1){
ans+=d*(r-i)*(l-L);
ans+=d*(i-l)*(R-r);
memo+=d*(r-i)*(l-L)+d*(i-l)*(R-r);
}
else if(l==-1){
ans+=d*(i+1)*(R-r);
memo+=d*(i+1)*(R-r);
}
else if(r==n){
ans+=d*(n-i)*(l-L);
memo+=d*(n-i)*(l-L);
}
s.insert(i);
}
cout<<ans<<endl;
}
| 0
| 91,652,315
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int X,Y;
cin>>X>>Y;
for(int i=0;i<=X;i++){
int t=X-i;
int asi=i*2+t*4;
if(asi==Y){
cout<<"Yes"<<endl;
return 0;
}
}
cout<<"No"<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> VI;
typedef vector<VI> VVI;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = numeric_limits<int>::max() / 2;
const int NEG_INF = numeric_limits<int>::min() / 2;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> v[9];
int cnt=0;
v[0].push_back('.');v[0].push_back(',');v[0].push_back('!');v[0].push_back('?');v[0].push_back(' ');
for(int i=1;i<=5;i++){
for(int j=0;j<3;j++){
v[i].push_back('a'+cnt);
cnt++;
}
}
v[6].push_back('p');v[6].push_back('q');v[6].push_back('r');v[6].push_back('s');
v[7].push_back('t');v[7].push_back('u');v[7].push_back('v');
v[8].push_back('w');v[8].push_back('x');v[8].push_back('y');v[8].push_back('z');
int n;
cin >> n;
string s;
for(int i=0;i<n;i++){
string res="";
cin >> s;
int pre=0,num=0;
for(int j=0;j<(int)s.length();j++){
if(s[j]=='0'){
if(num==0&&pre==0) continue;
res.push_back(v[pre-1][num%(v[pre-1].size())]);
num=0;pre=0;
}
else{
if(pre) num++;
else pre=(s[j]-'0');
}
}
cout<<res<<endl;
}
}
| 0
| 82,744,756
|
#include <bits/stdc++.h>
#define all(X) (X).begin(),(X).end()
#define P 1000000007
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
using namespace std;
using ll = long long;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
void solve() {
int h, n, a[100010];
cin >> h >> n;
for(int i = 0; i < n; i++) cin >> a[i];
int sum = 0;
for(int i = 0; i < n; i++) sum += a[i];
if(sum >= h) cout << "Yes" << endl;
else cout << "No" << endl;
}
int main(){
#define MULTITEST 0
#if MULTITEST
CASET {
solve();
}
#else
solve();
#endif
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n,x;
int ans;
while(true){
ans = 0;
cin >> n >> x;
if(n == 0 && x == 0) break;
for(int i = 1; i <= n-2; ++i){
for(int j = i+1; j <= n-1; ++j){
if(i == j) continue;
for(int k = j+1; k <= n; ++k){
if(i == k || j == k) continue;
if(i+j+k == x){
++ans;
}
}
}
}
cout << ans << endl;
}
return 0;
}
| 0
| 93,950,422
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
char a[100005];
scanf("%s",&a);
int n=strlen(a);
int p=0,q=0;
for(int i=0; i<n-1; i++)
{
if(a[i]==a[i+1])
{
q=i+1;
break;
}
}
for(int i=0; i<n-2; i++)
{
if(a[i]==a[i+2])
{
p=i+1;
break;
}
}
if(q!=0)
printf("%d %d\n",q,q+1);
else if(p != 0)
printf("%d %d\n",p,p+2);
else
printf("-1 -1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int64_t msb(int64_t v){
v = v | (v >> 1);
v = v | (v >> 2);
v = v | (v >> 4);
v = v | (v >> 8);
v = v | (v >> 16);
v = v | (v >> 32);
return v ^ (v >> 1);
}
int nth_bit(int64_t num, int n){
return (num >> n) & 1;
}
int main(){
int N;
cin >> N;
int cnt[60] = {0};
vector<int64_t> V(N);
vector<int64_t> A;
for(int i=0; i<N; i++){
cin >> V[i];
for(int k=0; k<60; k++) cnt[k] += nth_bit(V[i], k);
}
for(int k=0; k<60; k++) if(cnt[k]%2) for(int i=0; i<N; i++) if(nth_bit(V[i], k)) V[i] -= 1LL<<k;
for(int64_t v : V){
for(int64_t a : A) if(msb(a) & v) v ^= a;
if(v > 0){
A.push_back(v);
sort(A.rbegin(), A.rend());
}
}
int64_t ans = 0, v = 0, use = 0;
for(int k=59; k>=0; k--){
if(cnt[k]%2){
ans += 1LL<<k;
}else{
int64_t v2 = use | (1LL<<k);
for(auto a : A) if(((v^a)&v2) == v2) v ^= a;
if((v&v2) == v2){
ans += 2LL<<k;
use |= 1LL<<k;
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 88,141,955
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,M;
cin >> N >> M;
vector<vector<int64_t>> data(N ,vector<int64_t>(3));
for(int i=0;i < N;i++){
for(int j=0;j < 3;j++){
cin >> data.at(i).at(j);
}
}
int64_t m=0;
int64_t sum=0;
vector<int64_t> datb(N, 0);
for(int i=0;i < N;i++){
datb.at(i) = data.at(i).at(0)+data.at(i).at(1)+data.at(i).at(2);
}
sort(datb.begin(), datb.end());
sum=0;
for(int i=0;i < M;i++){
sum += datb.at(N-1-i);
}
m = max(m, sum);
for(int i=0;i < N;i++){
datb.at(i) = data.at(i).at(0)+data.at(i).at(1)-data.at(i).at(2);
}
sort(datb.begin(), datb.end());
sum=0;
for(int i=0;i < M;i++){
sum += datb.at(N-1-i);
}
m = max(m, sum);
for(int i=0;i < N;i++){
datb.at(i) = data.at(i).at(0)-data.at(i).at(1)+data.at(i).at(2);
}
sort(datb.begin(), datb.end());
sum=0;
for(int i=0;i < M;i++){
sum += datb.at(N-1-i);
}
m = max(m, sum);
for(int i=0;i < N;i++){
datb.at(i) = -data.at(i).at(0)+data.at(i).at(1)+data.at(i).at(2);
}
sort(datb.begin(), datb.end());
sum=0;
for(int i=0;i < M;i++){
sum += datb.at(N-1-i);
}
m = max(m, sum);
for(int i=0;i < N;i++){
datb.at(i) = data.at(i).at(0)-data.at(i).at(1)-data.at(i).at(2);
}
sort(datb.begin(), datb.end());
sum=0;
for(int i=0;i < M;i++){
sum += datb.at(N-1-i);
}
m = max(m, sum);
for(int i=0;i < N;i++){
datb.at(i) = -data.at(i).at(0)+data.at(i).at(1)-data.at(i).at(2);
}
sort(datb.begin(), datb.end());
sum=0;
for(int i=0;i < M;i++){
sum += datb.at(N-1-i);
}
m = max(m, sum);
for(int i=0;i < N;i++){
datb.at(i) = -data.at(i).at(0)-data.at(i).at(1)+data.at(i).at(2);
}
sort(datb.begin(), datb.end());
sum=0;
for(int i=0;i < M;i++){
sum += datb.at(N-1-i);
}
m = max(m, sum);
for(int i=0;i < N;i++){
datb.at(i) = -data.at(i).at(0)-data.at(i).at(1)-data.at(i).at(2);
}
sort(datb.begin(), datb.end());
sum=0;
for(int i=0;i < M;i++){
sum += datb.at(N-1-i);
}
m = max(m, sum);
cout << m;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <cmath>
#include <set>
#include <algorithm>
#include <iomanip>
typedef long long ll;
const ll MOD = 1e9 + 7;
const long long INF = 1LL<<60;
const double PI=3.14159265358979323846;
const int NMAX=100005;
using namespace std;
ll fact[101];
int main(){
string n;
ll k;
cin >> n >> k;
fact[0] = 1;
for(int i = 1; i <= 100; i++){
fact[i] = fact[i-1]*i;
}
ll dp0[n.length()+1][k+1], dp1[n.length()+1][k+1];
for(int i = 0; i < k+1; i++){
dp0[0][i] = 0;
dp1[0][i] = 0;
}
dp0[0][0] = 0;
dp1[0][0] = 1;
for(int i = 1; i <= n.length(); i++){
for(int j = 0; j <= k; j++){
int d = n[i-1]-'0';
dp0[i][j] = dp0[i-1][j];
if(j != 0){
dp0[i][j] += dp0[i-1][j-1]*9;
if(d != 0){
dp0[i][j] += dp1[i-1][j-1]*(d-1);
dp0[i][j] += dp1[i-1][j];
}
} else {
dp0[i][j] = 1;
}
if(d != 0){
if(j != 0){
dp1[i][j] = dp1[i-1][j-1];
} else {
dp1[i][j] = 0;
}
} else {
dp1[i][j] = dp1[i-1][j];
}
}
}
cout << dp0[n.length()][k] + dp1[n.length()][k] << endl;
return 0;
}
| 0
| 99,304,626
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i ,n) for(int i = 0 ; i < (n) ; i ++ )
#define all(x) (x).begin(),(x).end()
using ll = long long;
using namespace std;
int main() {
ll x,y;
cin>>x>>y;
ll a=x;
ll ans=1;
while(a<=y){
a*=2;
if(a<=y){
ans++;}
}
cout<<ans<<endl;
}
|
#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 N;
cin >> N;
map<int,int> mp;
rep(i,N) {
int a;
cin >> a;
++mp[a];
}
int ans = 0;
for(auto e:mp){
int f = e.first;
int s = e.second;
if(f>s) ans+=s;
else if(f<s) ans+=(s-f);
}
cout << ans << endl;
}
| 0
| 40,667,618
|
#include "bits/stdc++.h"
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define FOR(i, a) for (auto &i : a)
#define ALL(obj) begin(obj), end(obj)
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define SUM(x) accumulate(ALL(x), 0LL)
#define LOWER_BOUND(A, key) distance(A.begin(), lower_bound(ALL(A), key))
#define UPPER_BOUND(A, key) distance(A.begin(), upper_bound(ALL(A), key))
using namespace std;
const int MOD = (int)(1e9 + 7);
const int INF = (int)(1e13 + 7);
const double EPS = 1e-14;
const double PI = acos(-1);
int CEIL(int a, int b) { return (a >= 0 ? (a + (b - 1)) / b : (a - (b - 1)) / b); }
int mod(int a, int b) { return a >= 0 ? a % b : a - (b * CEIL(a, b)); }
int bpm(int a, int b) {
int res = 1;
for (a %= MOD; b; a = a * a % MOD, b >>= 1)
if (b & 1) res = res * a % MOD;
return res;
}
class CDigitsInMultiplication {
public:
static void solve(istream &cin, ostream &cout) {
int N;
cin >> N;
int ans = INF;
REP(i, 1, bpm(10, 5) + 1) {
if (N % i == 0) {
ans = min(ans, (int)max(log10(i) / 1 + 1, log10(N / i) / 1 + 1));
}
}
cout << ans << endl;
}
};
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cout<<fixed<<setprecision(15);
CDigitsInMultiplication solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<int> Vi;
typedef tuple<int, int, int> T;
#define FOR(i,s,x) for(int i=s;i<(int)(x);i++)
#define REP(i,x) FOR(i,0,x)
#define ALL(c) c.begin(), c.end()
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
const int INF = 1<<29;
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
int H, W, N;
int D[16];
string town[1024];
int dist[1024][1024];
P factory[16];
inline bool in(int r, int c) {
return 0 <= r && r < H && 0 <= c && c < W;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> H >> W >> N;
REP(i, H) cin >> town[i];
int sr = 0, sc = 0;
REP(i, H) REP(j, W) {
if (town[i][j] == 'S') {
sr = i, sc = j;
break;
}
}
int ans = 0;
REP(i, N) {
REP(r, H) REP(c, W) dist[r][c] = -1;
queue<T> que;
que.push(T(sr, sc, 0));
while (!que.empty()) {
int r, c, d;
tie(r, c, d) = que.front(); que.pop();
if (dist[r][c] != -1) continue;
dist[r][c] = d;
if (town[r][c] != 'S' && town[r][c] != '.' && town[r][c] != 'X' && town[r][c] - '0' == i+1) {
ans += d;
sr = r, sc = c;
break;
}
REP(j, 4) {
int nr = r + dr[j], nc = c + dc[j];
if (in(nr, nc) && town[nr][nc] != 'X' && dist[nr][nc] == -1) {
que.push(T(nr, nc, d+1));
}
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 17,626,066
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int push = 0;
vector<int> a(n+1, 0);
for (int i = 1; i <= n; i++) cin >> a[i];
set<int> s;
int touch = 1;
while(true) {
s.insert(touch);
touch = a[touch];
push++;
if(touch == 2) break;
else if(s.count(touch)) {
push = -1;
break;
}
}
cout << push;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
string ans = "No";
if (str.size() >= 4) {
if (str.at(0) == 'Y') {
if (str.at(1) == 'A') {
if (str.at(2) == 'K') {
if (str.at(3) == 'I') {
ans = "Yes";
}
}
}
}
}
cout << ans << endl;
}
| 0
| 21,138,755
|
#include <iostream>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <bitset>
#include <complex>
#include <functional>
#include <numeric>
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for(int i=(a);i<(n);++i)
#define RFOR(i, a, n) for(int i=(n)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
#define OUT(a, x, b) (x<a || b<=x)
template<class T> inline T chmax(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T chmin(T& a, const T b) { return a = (a > b) ? b : a; }
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
int N, A, B, C;
vector<int> l(10);
int dfs(int i, int cost, int a, int b, int c){
if(i == N){
if(a*b*c == 0) return INF;
return cost+abs(A-a)+abs(B-b)+abs(C-c)-30;
}
int ret = INF;
chmin(ret, dfs(i+1, cost, a, b, c ));
chmin(ret, dfs(i+1, cost+10, a+l[i], b, c ));
chmin(ret, dfs(i+1, cost+10, a, b+l[i], c ));
chmin(ret, dfs(i+1, cost+10, a, b, c+l[i]));
return ret;
}
signed main() {
cin >> N >> A >> B >> C;
REP(i, N) cin >> l[i];
cout << dfs(0, 0, 0, 0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int h; cin >> h;
int h_lst[h+0];
for(int i=0;i<h+0;i++) cin >> h_lst[i];
for(int i=0;i<h+0;i++){
cout << "node " << i+1 << ": key = " << h_lst[i] << ", ";
if(i>0)
cout << "parent key = " << h_lst[(i-1)/2] << ", ";
if((2*i+1) < h){
cout << "left key = " << h_lst[2*i+1] << ", ";
if((2*i+2) < h)
cout << "right key = " << h_lst[2*i+2] << ", ";
}
cout << endl;
}
}
| 0
| 31,592,507
|
#include<bits/stdc++.h>
#define INF (int)1e9
#define EPS 1e-9
#define MOD 1000000007ll
#define PI 3.14159
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define REP(i, a, b) \
for (int i = int(a); i <= int(b); i++)
#define TRvi(c, it) \
for (vi::iterator it = (c).begin(); it != (c).end(); it++)
#define TRvii(c, it) \
for (vii::iterator it = (c).begin(); it != (c).end(); it++)
#define TRmsi(c, it) \
for (msi::iterator it = (c).begin(); it != (c).end(); it++)
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define setBit(S, j) (S |= (1 << j))
#define clearBit(S, j) (S &= ~(1 << j))
#define toggleBit(S, j) (S ^= (1 << j))
#define in(x,n) for(int e=0;e<n;e++){ll y;cin>>y;x.pb(y);}
#define print(x) for(auto it:x) cout<<it<<' '; cout<<endl;
#define printii(x) for(auto it:x) cout<<it.F<<' '<<it.S<<'\t'; cout<<endl;
#define ll long long
#define vi vector<ll>
#define vvi vector<vi>
#define ii pair<ll,ll>
#define pll pair<ll,ll>
#define vii vector<ii>
#define vvii vector<vii>
#define viii vector<pair<ii,ll>>
#define pb push_back
#define ppb pop_back
#define eb emplace_back
#define mp make_pair
#define F first
#define S second
#define uset unordered_set
#define umap unordered_map
using namespace std;
ll gcd(ll a, ll b){ll temp;while (b > 0){temp = a%b;a = b;b = temp;} return a;}
ll lcm(ll a, ll b){return a*b/gcd(a,b);}
ll fpow(ll b, ll exp, ll mod){if(exp == 0) return 1;ll t = fpow(b,exp/2,mod);if(exp&1) return t*t%mod*b%mod;return t*t%mod;}
ll divmod(ll i, ll j, ll mod){i%=mod,j%=mod;return i*fpow(j,mod-2,mod)%mod;}
clock_t time_p=clock();
void TimeTaken()
{
time_p=clock()-time_p;
cerr<<"Completion time : "<<(float)(time_p)/CLOCKS_PER_SEC<<"\n";
}
void solve() {
}
void swap(int *xp, int *yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void bubbleSort(int arr[], int n)
{
int i, j;
for (i = 0; i < n-1; i++)
for (j = 0; j < n-i-1; j++)
if( ( (arr[j]%10) < (arr[j+1]%10) ) || arr[j+1]%10==0)
swap(&arr[j], &arr[j+1]);
}
int main(){
int a[5];
REP(i,0,4)cin>>a[i];
bubbleSort(a,5);
int s=0;
REP(i,0,4){
s=s+a[i];
if(s%10!=0 && i!=4){
s=((s/10)+1)*10;
}
}
cout<<s;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
#define repa(i,n) for (auto& i: n)
template<class T> inline bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
void init() {cin.tie(0);ios::sync_with_stdio(false);cout << fixed << setprecision(15);}
#ifdef DEBUG
template <class T, class N> void verr(const T& a, const N& n) { rep(i, n) cerr << a[i] << " "; cerr << "\n" << flush; }
ll dbgt = 1; void err() { cerr << "passed " << dbgt++ << "\n" << flush; }
template<class H, class... T> void err(H&& h,T&&... t){ cerr<< h << (sizeof...(t)?" ":"\n") << flush; if(sizeof...(t)>0) err(forward<T>(t)...); }
#endif
const ll INF = 4e18;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
const ll MOD = 1e9 + 7;
int main() {
init();
ll N;
cin >> N;
vl A(N);
rep(i, N) cin >> A[i];
ll K = *max_element(all(A));
vl C(K + 1);
rep(i, N) C[A[i]]++;
rep(i, K) C[i + 1] += C[i];
vl ans(N);
repr(i, N) ans[--C[A[i]]] = A[i];
rep(i, N) cout << ans[i] << (i == N - 1 ? '\n' : ' ');
}
| 0
| 42,779,442
|
#include <stdio.h>
int main()
{
int n, Y, M, D;
int year = 20*5 + 19*5, year3 = 20*10;
int yearsum = 999*year + (int)(1000/3)*5;
scanf("%d", &n);
for( int i=0; i<n; i++ ){
scanf("%d %d %d", &Y, &M, &D);
Y--;M--;D--;
printf( "%d\n", yearsum - ( Y*year + (int)(Y/3)*5 + M*19 + D + (((Y+1)%3)?(int)((M+1)/2):M) ) );
}
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string.h>
#include <math.h>
#include <map>
#include <iomanip>
#include <stdio.h>
#include <bitset>
typedef long long LL;
constexpr long long INFLL = 1e18;
using namespace std;
LL solve(LL temp)
{
LL ans;
LL count;
LL x = 0;
count = temp / 2 + 1;
if (temp % 2)
{
if (count % 2)
{
ans = 1;
}
else
{
ans = 0;
}
}
else
{
count--;
ans = temp;
if (count % 2)
{
ans++;
}
else
{
}
}
return ans;
}
int main()
{
LL A, B;
cin >> A >> B;
if (A > 0)
{
A = solve(A - 1);
}
bitset<64> bsA(A);
bitset<64> bsB(solve(B));
cout << (bsA ^ bsB).to_ullong() << endl;
return 0;
}
| 0
| 98,700,403
|
#include <iostream>
using namespace std;
int main() {
int n;
int building[4][3][10] = {0};
int b,f,r,v;
cin >> n;
for(int i=0; i < n; ++i){
cin >> b >> f >> r >> v;
building[b-1][f-1][r-1] += v;
}
for(int i=0; i < 4; ++i){
if(i) cout << "####################" << endl;
for(int j=0; j < 3; ++j){
for(int k=0; k < 10; ++k){
cout << ' ' << building[i][j][k];
}
cout << endl;
}
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#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);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<typename T>
vector<T> table(int n, T v) { return vector<T>(n, v); }
template <class... Args>
auto table(int n, Args... args) {
auto val = table(args...);
return vector<decltype(val)>(n, move(val));
}
const ll INF = 1e16;
const ll MOD = 1000000007;
typedef pair<ll,ll> P;
const ll MAX = 200005;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,m;
cin >> n >> m;
ll x[n],y[n],z[n];
ll nx[n],ny[n],nz[n];
rep(i,n){
cin >> x[i] >> y[i] >> z[i];
}
ll ans = 0;
rep(i,(1<<3)){
if (i&1) rep(i,n) nx[i] = -x[i];
else rep(i,n) nx[i] = x[i];
if (i&2) rep(i,n) ny[i] = -y[i];
else rep(i,n) ny[i] = y[i];
if (i&4) rep(i,n) nz[i] = -z[i];
else rep(i,n) nz[i] = z[i];
vector<P> a;
rep(i,n){
a.push_back(P(nx[i]+ny[i]+nz[i],i));
}
RSORT(a);
ll b = 0,d = 0,p = 0,index;
rep(i,m){
index = a[i].second;
b += x[index];
d += y[index];
p += z[index];
}
chmax(ans,abs(b)+abs(d)+abs(p));
}
PRINT(ans);
}
| 0
| 72,562,919
|
#include <iostream>
#include <string>
#include <cmath>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
#include <functional>
using namespace std;
#define rep(i,x) for(ll i=0;i<x;i++)
#define repn(i,x) for(ll i=1;i<=x;i++)
typedef long long ll;
const ll INF = 1e17;
const ll MOD = 1000000007;
const ll MAX = 1000001;
ll max(ll a, ll b) {
if (a > b) { return a; }
return b;
}
ll min(ll a, ll b) {
if (a > b) { return b; }
return a;
}
ll gcd(ll a, ll b) {
if (b == 0) { return a; }
if (a < b) { return gcd(b, a); }
return gcd(b, a%b);
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) *b;
}
struct edge {
ll ind;
ll fr;
ll to;
ll d;
};
int main() {
ll N;
cin >> N;
vector<ll> A(N + 1);
repn(i, N) cin >> A[i];
sort(++A.begin(), A.end());
ll b = N;
ll ans = -A[1];
for (ll i = 2; i <= N - 1; i++) {
ans += max(A[i], -A[i]);
if (A[i] > 0 && b == N) { b = i; }
}
ans += A[N];
stack<ll> neg;
for (ll i = 1; i < b; i++) { neg.push(A[i]); }
stack<ll> pos;
for (ll i = b; i <= N; i++) { pos.push(A[i]); }
cout << ans << endl;
repn(i, N - 1) {
ll x = pos.top();
pos.pop();
ll y = neg.top();
neg.pop();
if(pos.empty()) {
cout << x << " " << y << endl;
pos.push(x - y);
}
else {
cout << y << " " << x << endl;
neg.push(y - x);
}
}
system("PAUSE");
}
|
#include<iostream>
#include<string>
#include<cctype>
#define rep(i,start,n) for(int i=start ; i<n ; i++)
using namespace std;
int main(){
int count=0,count2=0,x=0;
string taro,hanako;
cin >> x;
rep(i,0,x){
cin >> taro >> hanako;
rep(i , 0 , taro.length()){
if(isupper(taro[i])){
taro[i] = tolower(taro[i]);
}
}
rep(i , 0 , hanako.length()){
if(isupper(hanako[i])){
hanako[i] = tolower(hanako[i]);
}
}
if(taro == hanako){
count = count +1;
count2 = count2 + 1;
}
else if(hanako < taro){
count2 = count2 + 3;
}
else if(taro < hanako){
count = count + 3;
}
}
cout << count2 << " " << count << endl;
return 0;
}
| 0
| 64,374,475
|
#include <iostream>
#include <vector>
#include <string>
#include <unordered_set>
#include <unordered_map>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <numeric>
#include <iterator>
using namespace std;
namespace {
}
int main()
{
int N;
cin >> N;
vector<int> a(N,0);
for (int i = 0; i < N; ++i){
cin >> a[i];
}
int counts = 0;
for (int i = 0; i < N; ++i){
int j = a[i];
if (a[j-1] -1 == i){
++counts;
}
}
cout << counts / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define leading zero str.erase(0, min(str.find_first_not_of('0'), str.size()-1));
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
string text="abcdefghijklmnopqrstuvwxyz";
const int maxn=1e6+7;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin>>n;
vector<int>v;
for(int i=0;i<n;i++){
int x;
cin>>x;
v.push_back(x);
}
set<int>s;
int cnt=0;
s.insert(v[0]);
for(int i=1;i<n;i++){
if(*s.begin()>=v[i])cnt++;
s.insert(v[i]);
}
cout<<cnt+1<<endl;
}
| 0
| 22,925,791
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#define rep(i, n) for(int i = 0; i < n; i ++)
#define ALL(T) T.begin(), T.end()
using namespace std;
typedef pair<int, int> pii;
typedef unsigned long long ull;
const int S_N = 4;
const int P_N = 2;
int main(){
int res = 0;
rep(i, P_N){
int sum = 0;
rep(j, S_N){
int score; cin >> score;
sum += score;
res = max(res, sum);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define MOD 1e9+7;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n); i >= 0; --i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
void Main()
{
ll n;
cin >> n;
vector<ll> VA(n);
vector<ll> VB(n);
rep(i, n)
{
ll x, y;
cin >> x >> y;
VA.at(i) = x;
VB.at(i) = y;
}
ll cnt;
cnt = 0;
ll adder;
adder = 0;
rrep(i, n - 1)
{
if ((VA.at(i) + adder) % VB.at(i) == 0)
continue;
adder += VB.at(i) * ((VA.at(i) + adder) / VB.at(i) + 1) - (VA.at(i) + adder);
}
cout << adder << endl;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
Main();
}
| 0
| 6,758,399
|
#include <stdio.h>
int main(void)
{
int a,b;
int d,r;
double aa,bb,f;
double ba = 1;
scanf("%d%d",&a,&b);
d = a / b;
r = a % b;
aa = a / ba;
bb = b / ba;
f = aa / bb;
printf("%d %d %f\n",d,r,f);
return(0);
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
#define all(x) (x).begin(),(x).end()
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int ans = 0;
void an(){
ans++;
}
vector<pair<long long, long long> > prime_factorize(long long N) {
vector<pair<long long, long long> > res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1) res.push_back({N, 1});
return res;
}
int main() {
ll N;
cin >> N;
ll M;
vector<ll>pfs(N+1);
for (ll i=1; i<=N; i++){
vector<pair<ll, ll>>curr_pf;
curr_pf = prime_factorize(i);
for (ll j=0; j<curr_pf.size(); j++){
pair<ll, ll>pr;
pr = curr_pf[j];
pfs[pr.first] += pr.second;
}
}
int c2, c4, c14, c24, c74;
c2 = c4 = c14 = c24 = c74 = 0;
for (int i=0; i<N+1; i++){
if (pfs[i] >= 2)c2++;
if (pfs[i] >= 4)c4++;
if (pfs[i] >= 14)c14++;
if (pfs[i] >= 24)c24++;
if (pfs[i] >= 74)c74++;
}
ans += (c4 * (c4-1) * (c2-2)) /2;
ans += c14 * (c4-1);
ans += c24 * (c2 - 1);
ans += c74;
cout << ans << endl;
}
| 0
| 56,748,263
|
#include <bits/stdc++.h>
using namespace std;
int main () {
int N, M;
cin >> N >> M;
vector<int> ok(N);
int ans1 = 0;
vector<int> memo(N);
int ans2 = 0;
for (int i = 0; i < M; i++) {
int a;
string b;
cin >> a >> b;
if (ok.at(a - 1) == 0 && b == "WA") {
memo.at(a - 1)++;
}
else if (ok.at(a - 1) == 0 && b == "AC") {
ans1++;
ans2 += memo.at(a - 1);
ok.at(a - 1) = 1;
}
}
cout << ans1 << " " << ans2 << endl;
}
|
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
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; }
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout<<(s)<<'\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
#define p_yes() p("Yes")
#define p_no() p("No")
ll SUM(VI& V){
return accumulate(ALL(V), 0LL);
}
ll MIN(VI& V){return *min_element(ALL(V));}
ll MAX(VI& V){return *max_element(ALL(V));}
void print_vector(VI& V){
ll n = V.size();
rep(i, n){
if(i) cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b,a%b);
}
ll lcm(ll a,ll b){
ll g = gcd(a,b);
return a / g * b;
}
using ld = long double;
#define EPS (1e-14)
#define equals(a,b) (fabs((a)-(b)) < EPS)
void no(){p_no(); exit(0);}
void yes(){p_yes(); exit(0);}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
bool is_palindrome(string s){
string t = s;
reverse(ALL(t));
return s==t;
}
string f_swap(string s, ll i, ll j){
reverse(s.begin()+i, s.begin()+j+1);
return s;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string s;cin>>s;
ll N = s.size();
ll sum = N*(N-1)/2;
map<char,ll> mp;
for(char c : s){
mp[c]++;
}
for(auto pa : mp){
ll cnt = pa.second;
sum -= cnt*(cnt-1)/2;
}
p(sum+1);
return 0;
}
| 0
| 63,351,039
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL<<62
#define inf 1000000007
int main() {
ll n,a,b;
cin>>n>>a>>b;
ll sum=a+b;
ll ans=n/sum*a;
ll sum2=n%sum;
ans+=min(a,sum2);
cout <<ans;
return 0;
}
|
#include<bits/stdc++.h>
typedef long long int lli;
#define vi vector<int>
#define vs vector<string>
#define pb push_back
#define endl "\n"
#define sortin sort(arr.begin(),arr.end())
#define inputArray for(int i{};i<n;i++){cin>>arr[i];}
#define inputArray1 for(int i{};i<m;i++){cin>>arr1[i];}
#define intloop for(int i{};i<n;i++)
#define intloopminus for(int i{};i<n-1;i++)
#define strloop for(int i{};i<str.length();i++)
#define N int n;cin>>n
#define strlen str.length()
#define InputStr string str;cin>>str
#define twoinputs int n,k;cin>>n>>k
#define T int t;cin>>t;while(t--)
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;cin>>n;
int arr[n];int sum=0;
for(int i{};i<n;i++)
{
cin>>arr[i];
sum=sum+arr[i];
}
int temp=sum;
temp=ceil(sum/(float)n);
int floor_sum=0;
floor_sum=floor(sum/(float(n)));
int ansCeil=0;int ansFloor=0;
for(int i{};i<n;i++)
{
ansCeil=ansCeil+pow((arr[i]-temp),2);
}
for(int i{};i<n;i++)
{
ansFloor=ansFloor+pow((arr[i]-floor_sum),2);
}
cout<<min(ansCeil,ansFloor)<<endl;
}
| 0
| 2,537,135
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[])
{
int n;
cin>>n;
long long a,b,ans=0LL,mi=1000000000000000LL;
int f=0;
for (int i = 0; i < n; ++i)
{
cin>>a>>b;
if (a>b)
{
ans+=a;
mi=min(mi,b);
f=1;
}
else if (a<b)
{
ans+=a;
f=1;
}
else
{
ans+=a;
}
}
if (f)
{
cout<<ans-mi<<endl;
}
else
{
cout<<"0\n";
}
return 0;
}
|
#include<bits/stdc++.h>
typedef long long ll;
#define ff first
#define ss second
using namespace std;
void fast()
{
ios::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
}
ll gcd(ll a,ll b)
{
if(b==0)
return a;
else
gcd(b,a%b);
}
ll lcd(ll a,ll b)
{
return (a*b)/gcd(a,b);
}
int main()
{
int n,k,p[5005],c[5005];
cin>>n>>k;
for(int i=0;i<n;i++)
cin>>p[i],p[i]--;
for(int i=0;i<n;i++)
cin>>c[i];
ll ans=-INT_MAX;
for(int i=0;i<n;i++)
{
int now=i;
ll c_sum=0,c_cnt=0;
while(true)
{
c_cnt++;
c_sum+=c[now];
now=p[now];
if(now==i)
break;
}
ll sum=0,cnt=0;
while(true)
{
cnt++;
sum+=c[now];
if(cnt>k)
break;
ll temp=(k-cnt)/c_cnt;
temp=sum+max(0ll,c_sum)*temp;
ans=max(ans,temp);
now=p[now];
if(now==i)
break;
}
}
cout<<ans<<endl;
}
| 0
| 91,582,474
|
#include<bits/stdc++.h>
using namespace std;
#define Q int t; scanf("%d", &t); for(int q=1; q<=t; q++)
typedef long long int lli;
typedef pair<int, int> pi;
typedef pair<lli, int> pii;
int main()
{
lli s;
cin >> s;
lli x = 1e9;
cout << "0 0 " << x << " 1 ";
lli c = (s+x-1)/x;
lli m = s%x;
cout << (x*c)-s << " " << c << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int INF = 1<<30;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
int N,A,B,C;
cin>>N>>A>>B>>C;
vector<int> ban(N);
rep(i,N) cin>>ban[i];
int ans = INF;
for(int i = 0; i < (1<<(2*N));i++){
bitset<20> bi(i);
vector<int> v(N);
int cnt=0;
for(int j = 0; j < N; j++){
if(bi.test(2*j)&&bi.test(2*j+1)) v[j]=0;
if(!bi.test(2*j)&&bi.test(2*j+1)) v[j]=1;
if(bi.test(2*j)&&!bi.test(2*j+1)) v[j]=2;
if(!bi.test(2*j)&&!bi.test(2*j+1)) v[j]=3;
}
vector<vector<int>> vv(4);
rep(j,N) {
vv[v[j]].push_back(ban[j]);
}
if((int)vv[0].size()==0||(int)vv[1].size()==0||(int)vv[2].size()==0)continue;
rep(j,3){
cnt+=((int)vv[j].size()-1)*10;
int s=0;
for(auto x:vv[j]) s+=x;
if(j==0)cnt+=abs(s-A);
if(j==1)cnt+=abs(s-B);
if(j==2)cnt+=abs(s-C);
}
chmin(ans,cnt);
}
cout<<ans<<endl;
}
| 0
| 84,043,513
|
#include <stdio.h>
#define N 2000000
int main(){
int n;
scanf("%d",&n);
int i;
int A[N];
for(i=1;i<=n;i++){
scanf("%d",&A[i]);
}
for(i=1;i<=n;i++){
printf("node %d: key = %d, ",i,A[i]);
if(i/2>0)printf("parent key = %d, ",A[i/2]);
if(i*2<=n)printf("left key = %d, ",A[i*2]);
if(i*2+1<=n)printf("right key = %d, ",A[i*2+1]);
printf("\n");
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(long long i = 0; i < (n); i++)
#define REP(i,s,n) for(long long i = (s); i <= (n); i++)
#define repr(i,n) for(long long i = (n - 1); i >= 0; i--)
#define REPR(i,s,n) for(long long i = (s); i >= (n); i--)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sumvec(v) accumulate(all(v), 0LL)
#define DOUBLE fixed << setprecision(15)
#define OK cerr << "OK\n"
#define OK1 cerr << "OK1\n"
#define OK2 cerr << "OK2\n"
#define sz(s) (long long)s.size()
#define zero(x, n) setw(x) << setfill('0') << n
#define dbg(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<double> vd;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef vector<vd> vvd;
typedef vector<vc> vvc;
typedef vector<vb> vvb;
typedef pair<ll,ll> P;
typedef vector<P> vP;
void debug() { cerr << "\n"; }
template<class T, class... Args> void debug(const T &x, const Args &... args) { cerr << x << " "; debug(args...); }
template<class A, class B> ostream& operator<< (ostream& ost, const pair<A, B> &p) { ost << "{" << p.first << ", " << p.second << "} "; return ost; }
template<class T> ostream& operator<< (ostream& ost, const vector<T>&v) { ost << "{"; for (int i = 0; i < (int)v.size(); i++) { if(i) ost << " "; ost << v[i]; } ost << "} \n"; return ost; }
template <typename T> ostream& operator<<(ostream& os, const deque<T> &vec) { os << "deq["; for (auto v : vec) os << v << ","; os << "]\n"; return os; }
template<class A, class B> ostream& operator<< (ostream& ost, const map<A, B>&v) { ost << "{"; for (auto p : v) { ost << "{" << p.first << ", " << p.second << "} "; } ost << "}\n"; return ost; }
template<typename T> istream& operator>> (istream& is, vector<T>& vec) { for(T& e : vec) is >> e; return is; }
template<typename A, typename B> istream& operator>> (istream& is, pair<A, B>& p) { is >> p.first >> p.second; return is; }
template<typename T> string join(vector<T>& vec, string sep=" ") { stringstream ss; for(int i = 0; i < (int)vec.size(); i++) { ss << vec[i] << (i + 1 == (int)vec.size() ? "\n" : sep); } return ss.str(); }
template<typename A, typename B> pair<A, B> operator+ (const pair<A, B> &l, const pair<A, B> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template<typename A, typename B> pair<A, B> operator- (const pair<A, B> &l, const pair<A, B> &r) { return make_pair(l.first - r.first, l.second - r.second); }
template<typename T> ostream& operator<< (ostream &os, const set<T> &vec) { os << "{"; for (auto v : vec) os << v << ","; os << "}\n"; return os; }
template<typename T> ostream& operator<<(ostream &os, const multiset<T> &vec) { os << "{"; for (auto v : vec) os << v << ","; os << "}\n"; return os; }
template<class T> auto min(const T& a){ return *min_element(a.begin(), a.end()); }
template<class T> auto max(const T& a){ return *max_element(a.begin(), a.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 INT(...) int __VA_ARGS__; IN(__VA_ARGS__)
#define LL(...) long long __VA_ARGS__; IN(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__; IN(__VA_ARGS__)
#define DBL(...) double __VA_ARGS__; IN(__VA_ARGS__)
#define STR(...) string __VA_ARGS__; IN(__VA_ARGS__)
#define LD(...) long double __VA_ARGS__; IN(__VA_ARGS__)
void scan(int& a){ cin >> a; }
void scan(long long& a){ cin >> a; }
void scan(char& a){ cin >> a; }
void scan(double& a){ cin >> a; }
void scan(string& a){ cin >> a; }
void scan(long double& a){ cin >> a; }
void IN(){}
template<class Head, class... Tail> void IN(Head& head, Tail&... tail){ scan(head); IN(tail...); }
void YES(bool b) { cout << ((b) ? "YES\n" : "NO\n"); }
void Yes(bool b) { cout << ((b) ? "Yes\n" : "No\n"); }
void yes(bool b) { cout << ((b) ? "yes\n" : "no\n"); }
void Yay(bool b) { cout << ((b) ? "Yay!\n" : ":(\n"); }
void possible(bool b) { cout << ((b) ? "possible\n" : "impossible\n"); }
void Possible(bool b) { cout << ((b) ? "Possible\n" : "Impossible\n"); }
void POSSIBLE(bool b) { cout << ((b) ? "POSSIBLE\n" : "IMPOSSIBLE\n"); }
const int dy[] = {-1, 0, 0, 1};
const int dx[] = {0, -1, 1, 0};
const int dy8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
const int dx8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
const int inf = 1001001001;
const long long INF = ((1LL << 62) - (1LL << 31));
const long double pi = acos(-1.0);
const long long mod=1000000007;
const long long MOD=998244353;
ll powmod(ll a, ll b){ ll c = 1; while(b > 0){ if(b & 1){ c = a * c % mod; } a = a * a % mod; b >>= 1; } return c; }
ll nCrmod(ll n, ll r){ ll x = 1, y = 1; for(ll i = 0; i < r; i++) { x = x * (n - i) % mod; y = y * (i + 1) % mod; } return x * powmod(y, mod - 2) % mod; }
ll gcd(ll a, ll b){ while(b){ ll c = b; b = a % b; a = c; } return a; }
ll lcm(ll a, ll b){ if(!a || !b) return 0; return a * b / gcd(a, b); }
vll divisor(ll x){ vll v; for(ll i = 1; i * i <= x; i++) if(x % i == 0){ v.push_back(i); if(i * i != x) v.push_back(x / i); } sort(v.begin(), v.end()); return v; };
map<ll, ll> prime_factor(ll n){ map<ll, ll> m; for(ll i = 2; i * i <= n; i++){ while(n % i == 0){ m[i]++; n /= i; } } if(n != 1) m[n] = 1; return m; }
int main()
{
LL(n);
vll a(n);
cin >> a;
ll A = max(a);
vll c(A + 1);
rep(i, n) c[a[i]]++;
bool pairwise = true;
REP(i, 2, A) {
ll cnt = 0;
for(ll j = i; j <= A; j += i) cnt += c[j];
if(cnt > 1) pairwise = false;
}
if(pairwise) {
cout << "pairwise coprime\n";
return 0;
}
ll tmp = 0;
rep(i, n) tmp = gcd(tmp, a[i]);
if(tmp == 1) cout << "setwise coprime\n";
else cout << "not coprime\n";
return 0;
}
| 0
| 17,083,712
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REPLL(i, n) for (ll i = 0; i < (ll)(n); i++)
using namespace std;
template<class T>inline bool chmax(T &a, const T &b){if(a < b){a = b; return 1;}return 0;}
template<class T>inline bool chmin(T &a, const T &b){if(a > b){a = b; return 1;}return 0;}
typedef long long ll;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int A, B; cin >> A >> B;
int ans = A*B-A-B+1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i, s, n) for (int i = (s); i < (n); i++)
#ifdef LOCAL
#define INPUT_FILE \
ifstream in("atcoder-problems/abc109_b.txt"); \
cin.rdbuf(in.rdbuf());
#define print_vec(v) \
rep(l, v.size()) { cout << v[l] << " "; } \
cout << endl;
#else
#define INPUT_FILE
#define print_vec(v)
#endif
#define CIN_OPTIMIZE \
cin.tie(0); \
ios::sync_with_stdio(false);
typedef pair<int, int> P;
typedef long long ll;
typedef pair<ll, ll> pl;
const int INF = 100100100;
const ll LINF = 1e18 + 100;
const int MOD = 1e9 + 7;
int main() {
INPUT_FILE CIN_OPTIMIZE;
int N;
cin >> N;
vector<string> s(N);
set<string> ss;
rep(i, N) {
cin >> s[i];
ss.insert(s[i]);
}
if (s.size() != ss.size()) {
cout << "No" << endl;
return 0;
}
bool ok = true;
rep(i, N - 1) {
if (s[i][s[i].size() - 1] != s[i + 1][0]) {
ok = false;
break;
}
}
cout << (ok ? "Yes" : "No") << endl;
}
| 0
| 60,052,458
|
#include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" << f << endl
#define p7(a, b, c, d, e, f, g) idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" << f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" << f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" << f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" << f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp \
{ \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp \
{ \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp \
{ \
foreach (it, x) \
{ \
cout << (*it) << " "; \
} \
puts(""); \
}
#define dumpi2(x) \
idp \
{ \
foreach (it, x) \
{ \
cout << "[" << (it)->F << " , " << (it)->S << "] "; \
} \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) \
{ \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
li n, a, b;
inline li divup(li x, li y) {
li res = x / y;
if (x % y > 0)++res;
return res;
}
inline bool ng() {
if (n < a || n < b) {
return true;
}
if (b > n - a + 1) {
return true;
}
if (b < divup(n, a)) {
return true;
}
return false;
}
int main(void)
{
cin >> n >> a >> b;
if (ng()) {
cout << -1 << endl;
return 0;
}
li lds_len = b;
li last = n;
li now_base = n - a + 1;
while (last >= lds_len + a) {
rep(i, a) {
cout << now_base + i << " ";
}
now_base -= a;
lds_len -= 1;
last -= a;
}
li last_lis_len = last - lds_len + 1;
now_base = now_base + a - last_lis_len;
rep(i, last_lis_len) {
cout << now_base + i << " ";
}
last -= last_lis_len;
rep(i, last) {
cout << last - i << " ";
}
cout << endl;
return 0;
}
|
#include<iostream>
using namespace std;
void show(int* a, int n)
{
for(int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
void SelectionSort(int* a, int n)
{
int i, j, c, minj, count;
count = 0;
for(i = 0; i < n; i++){
minj = i;
for(j = i; j < n; j++){
if(a[minj] > a[j]) minj = j;
}
if(i < minj){
c = a[minj];
a[minj] = a[i];
a[i] = c;
count++;
}
}
show(a, n);
cout << count << endl;
}
int main()
{
int N, A[100];
cin >> N;
for(int i = 0; i < N; i++) cin >> A[i];
SelectionSort(A, N);
return 0;
}
| 0
| 2,472,845
|
#include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
void solve(long long N, long long M, long long X, long long Y, std::vector<long long> x, std::vector<long long> y){
sort(x.begin(), x.end(), greater<long long>());
sort(y.begin(), y.end());
if (x[0] >= y[0] || x[0] >= Y || y[0] <= X) cout << "War" << '\n';
else cout << "No War" << '\n';
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
long long N;
scanf("%lld",&N);
long long M;
scanf("%lld",&M);
long long X;
scanf("%lld",&X);
long long Y;
scanf("%lld",&Y);
std::vector<long long> x(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&x[i]);
}
std::vector<long long> y(M);
for(int i = 0 ; i < M ; i++){
scanf("%lld",&y[i]);
}
solve(N, M, X, Y, std::move(x), std::move(y));
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <numeric>
#include <string>
#include <algorithm>
#include <iostream>
#include <vector>
#include <bitset>
#include <queue>
#include <map>
#include <utility>
#include<functional>
#include <unordered_map>
#include <set>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll,ll> prll;
#define MOD 1000000007
#define juu 100000
#define hyaku 1000000
#define mINF -922337200085470000
#define pINF 922337203600070000
#define uINF 1844674407300000000
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
void primefac(ll num)
{
int i = 0, kosuu = 0;
while (*(factor + i) != 0)
{
while (num % *(factor + i) == 0)
{
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
int elast(ll number)
{
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++)
{
flag = 0;
for (int j = 0; j <= tmp; j++)
{
if (i % (*(factor + j)) == 0)
{
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
ll nCr(ll n, ll r)
{
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++)
{
val *= (n - i);
val /= (i + 1);
}
return val;
}
ll nPr(ll n, ll r)
{
ll val = 1;
ll i;
for (i = 0; i < r; i++)
{
val *= (n - i);
}
return val;
}
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 T>
void eraseSame(T &a)
{
sort(all(a));
a.erase(unique(all(a)), a.end());
}
template <typename T>
bool swapmax(T &a, T &b)
{
T temp;
temp = a;
if (a > b)
{
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
template <typename T>
void splitIn(ll N, vector<T> &array)
{
T temp;
int i = 0;
if(N == 0){
return ;
}
array.resize(N);
while (cin >> temp)
{
array[i] = temp;
i++;
if (i >= N)
{
break;
}
}
return;
}
int main()
{
ll n,k,a,b,c;
string s;
vector<ll> v;
cin >> a >> b >> c >> k;
if( (llabs(-(b + c) + (a + b))) > 10e18){
cout << "Unfair" ;
}
else {
ll ans = (b + c) - (a + c);
ans *= (k %2 != 0)?1:-1;
cout << ans;
}
return 0;
}
| 0
| 2,281,385
|
#include <bits/stdc++.h>
#define FOR(i, a, n) for(ll i = (ll)a; i < (ll)n; i++)
#define FORR(i, n) for(ll i = (ll)n - 1LL; i >= 0LL; i--)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
template <typename T> using V = vector<T>;
constexpr int Mod = 998244353;
constexpr int mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
template <typename T> constexpr bool chmax(T &a, const T &b) {
if(a >= b) return false;
a = b;
return true;
}
template <typename T> constexpr bool chmin(T &a, const T &b) {
if(a <= b) return false;
a = b;
return true;
}
ll n, k, sum;
V<ll> a;
bool need(const int &mid) {
bitset<5005> b(1);
rep(i, n) if(i != mid) b |= b << a[i];
FOR(i, max(0LL, k - a[mid]), k) if(b[i]) return true;
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cin >> n >> k;
a.resize(n);
rep(i, n) {
cin >> a[i];
sum += a[i];
}
sort(ALL(a));
ll ok = -1, ng = n;
while(ok + 1 < ng)
(need(ng + ok >> 1) ? ng : ok) = ng + ok >> 1;
cout << ng << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>
#include <map>
#include <bitset>
#include <cmath>
#include <set>
#include <utility>
#define INF 1000000000000
#define MOD 1000000007
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
int main(){
ll H,N;
cin >> H >> N;
vector<ll> A(N);
for(ll i = 0;i < N;i++)
cin >> A.at(i);
bool fla = false;
for(ll i = 0;i < N;i++){
if(H <= 0){
fla = true;
break;
}
H -= A.at(i);
}
if(H <= 0)
fla = true;
if(fla)
cout << "Yes" << endl;
else
{
cout << "No" << endl;
}
}
| 0
| 27,598,221
|
#include<bits/stdc++.h>
using namespace std;
const int INF=1e+9;
const int MOD=1e+9+7;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define REPD(i,n) for(int i=n-1;i>=0;i--)
#define REP2(i,a,b) for(int i=a;i<(int)(b);i++)
#define REPD2(i,a,b) for(int i=a;i>(int)(b);i--)
template<class T>
vector<T> make_vec(size_t a){
return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((int)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
bool L[5010][5010];
bool R[5010][5010];
int sumr[5010][5010];
int main(){
int N,K;
cin>>N>>K;
vector<int> a(N);
REP(i,N) cin>>a[i];
sort(ALL(a));
REP(i,5010){
REP(j,5010){
if(j==0){
L[i][j]=true;
R[i][j]=true;
}else{
L[i][j]=false;
R[i][j]=false;
}
}
}
REP(i,N){
REP(j,5010){
if(a[i]>=K) continue;
if(j-a[i]>=0){
L[i+1][j]=L[i][j-a[i]]|L[i][j];
}else{
L[i+1][j]=L[i][j];
}
}
}
sort(ALL(a),greater<int>());
REP(i,N){
REP(j,5010){
if(a[i]>=K) continue;
if(j-a[i]>=0){
R[N-1-i][j]=R[N-i][j-a[i]]|R[N-i][j];
}else{
R[N-1-i][j]=R[N-i][j];
}
}
}
sort(ALL(a));
int ans=0;
REP(i,5010){
REP(j,5010){
sumr[i][j]=0;
}
}
REP(i,5010){
REP(j,5009){
sumr[i][j+1]=sumr[i][j]+R[i][j];
}
}
REP(i,N){
if(a[i]>=K) continue;
bool flag=true;
REP(j,K+1){
if(!L[i][j]) continue;
int l=max(K-a[i]-j,0);
int r=K-j;
if(sumr[i+1][r]-sumr[i+1][l]>0){
flag=false;
break;
}
}
if(flag){
ans++;
}
}
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
using namespace std;
typedef long long ll;
int INF = (1LL << 30) - 1;
int MOD = 1e9+7;
main(){
int N;
cin >> N;
int K = 0,cnt = 1;
for(;K < N;cnt++)K += cnt;
if(K != N){
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
cout << cnt << endl;
vector<int> V[cnt];
int re = cnt-1,idx1 = 0,idx2 = 1;
rep(i,1,N+1){
V[idx1].push_back(i);
V[idx2].push_back(i);
if(idx2 == cnt-1){
idx1++;
idx2 = idx1 + 1;
}else idx2++;
}
rep(i,0,cnt){
cout << cnt - 1 << " ";
rep(j,0,cnt-1)cout << V[i][j] << " \n"[j==cnt-2];
}
}
| 0
| 11,329,532
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int N,b_num=0,ans=0,i=0;
cin >> N;
int data[N];
for(int i=0;i<N;i++) cin >> data[i];
for(int i=0;i<N;i++) data[i]--;
while(1){
ans++;
if(data[b_num] == 1) break;
int next = data[b_num];
if(i > 1000000){ans = -1; break;}
b_num = next;
i++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define int long long
#define INF 1000000000000000000
using namespace std;
typedef vector<int> vec;
typedef vector<vec> mat;
typedef pair<int, int> Pii;
template<typename T>
void readv(vector<T> &a){ REP(i, a.size()) cin >> a[i]; }
void readi(vector<int> &a){ REP(i, a.size()){cin >> a[i]; a[i]--;} }
double calcdist(double vi, double vf, double vm, double T){
double dist;
double vm2 = (T + vi + vf) / 2.0;
if(vm2 > vm){
dist = (vm + vi) * (vm - vi) / 2.0 + (vm + vf) * (vm - vf) / 2.0 + vm * (T - 2.0 * vm + vi + vf);
}else{
dist = (vm2 + vi) * (vm2 - vi) / 2.0 + (vm2 + vf) * (vm2 - vf) / 2.0;
}
return dist;
}
signed main(){
int N;
cin >> N;
vector<int> t(N), v(N);
readv(t);
readv(v);
vec v_max(N + 1);
v_max[0] = 0;
FOR(i, 1, N){
v_max[i] = min(v[i - 1], v[i]);
}
v_max[N] = 0;
priority_queue<Pii> que;
REP(i, N + 1) que.push(Pii(-1 * v_max[i], i));
while(!que.empty()){
Pii p = que.top(); que.pop();
int v0 = -1 * p.first;
int i0 = p.second;
if(v0 > v_max[i0]) continue;
if(i0 != 0){
if(v_max[i0] + t[i0 - 1] < v_max[i0 - 1]){
v_max[i0 - 1] = v_max[i0] + t[i0 - 1];
que.push(Pii(-1 * v_max[i0 - 1], i0 - 1));
}
}
if(i0 != N){
if(v_max[i0] + t[i0] < v_max[i0 + 1]){
v_max[i0 + 1] = v_max[i0] + t[i0];
que.push(Pii(-1 * v_max[i0 + 1], i0 + 1));
}
}
}
double ans = 0.0;
REP(i, N) ans += calcdist((double)v_max[i], (double)v_max[i + 1], (double)v[i], t[i]);
cout << setprecision(10) << ans;
return 0;
}
| 0
| 86,448,258
|
#include <iostream>
using namespace std;
int main(void){
int v[32] = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
int k;
cin>>k;
cout<<v[k-1];
}
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define eb emplace_back
#define pb push_back
#define size(s) (int)s.size()
#define int long long
#define vi vector<int>
#define vs vector<string>
#define vv vector<vector<int>>
#define pii pair<int,int>
#define m_p(x,y) make_pair(x,y)
#define vp vector<pair<int,int>>
#define setbits(x) __builtin_popcountll(x)
#define f first
#define se second
#define inc(v,n,x) v.assign(n,x)
#define incd(v,n) v.resize(n)
#define iniz(n) memset(n,0,sizeof(n))
#define inin(n) memset(n,-1,sizeof(n))
#define inimi(n) memset(n,0xc0,sizeof(n))
#define inima(n) memset(n,0x3f,sizeof(n))
#define all(v) (v).begin(),(v).end()
using namespace std;
template<typename T1,typename T2>istream &operator>>(istream &is, vector<pair<T1,T2>> &v) { for (pair<T1,T2> &t : v) is >> t.f>>t.se; return is; }
template<typename T>istream &operator>>(istream &is, vector<T> &v) { for (T &t : v) is >> t; return is; }
template<typename T>ostream &operator<<(ostream &os, const vector<T> &v) { for (const T &t : v) {os << t <<" ";} os << '\n'; return os; }
const int N=200001;
double pi=acos(-1.0);
int md=1e9+7;
const int INF=1e15;
int dx1[]={0,0,-1,1};
int dy1[]={1,-1,0,0};
template<class T>
T abst(T a)
{return a<0?-a:a;}
template<class T>
T max2(T a,T b){return a>b?a:b;}
template<class T>
T min2(T a,T b){return a<b?a:b;}
vp v[201];
int dis[201][201];
vi r;
int dp[1000][10];
int fun(int mask,int i)
{
if(setbits(mask)==size(r))return 0;
if(dp[mask][i]!=-1)return dp[mask][i];
int ans=INT_MAX;
for(int j=0;j<size(r);j++)
if(!((1<<j)&mask))
ans=min2(ans,dis[r[i]][r[j]]+fun(mask|(1<<j),j));
return dp[mask][i]=ans;
}
void solve()
{
inin(dp);
int n,m,r1;cin>>n>>m>>r1;
inima(dis);
for(int i=1;i<=n;i++)
dis[i][i]=0;
incd(r,r1);cin>>r;
while(m--)
{
int x,y,z;
cin>>x>>y>>z;
dis[x][y]=z;
dis[y][x]=z;
}
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
dis[i][j]=min2(dis[i][k]+dis[k][j],dis[i][j]);
}
}
int ans=INT_MAX;
for(int i=0;i<r1;i++)
ans=min2(ans,fun(1<<i,i));
cout<<ans;
}
int32_t main(){
ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
int t=1;
for(int i=1;i<=t;i++)
{
solve();
}
return 0;
}
| 0
| 25,254,871
|
#include<iostream>
#include<string>
using namespace std;
int main ()
{
int a,b,c;
cin>>a>>b>>c;
if ((c<=b)&&(c>=a))
{
cout<<"Yes\n";
}
else
{
cout<<"No\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
int main() {
int N;
cin >> N;
vector<int> a(N+1);
rep(i,N+1) {
cin >> a[i];
}
vector<long int> d_max(N+1), d_min(N+1), max(N+1);
bool tf = true;
reverse(a.begin(), a.end());
rep(i,N+1) {
if(i == 0) {
d_min[i] = a[0];
d_max[i] = a[0];
}
else {
d_min[i] = (d_min[i-1] + 1) / 2 + a[i];
d_max[i] = d_max[i-1] + a[i];
}
}
if(d_min[N] > 1)
tf = false;
reverse(d_max.begin(), d_max.end());
reverse(a.begin(), a.end());
rep(i,N+1) {
if(i == 0)
max[i] = 1;
else {
max[i] = min((max[i-1] - a[i-1]) * 2, d_max[i]);
}
}
long int sum = 0;
if(tf) {
rep(i,N+1) {
sum += max[i];
}
}
else
sum = -1;
cout << sum << endl;
return 0;
}
| 0
| 49,849,013
|
#include <bits/stdc++.h>
#include <vector>
#include <queue>
using namespace std;
int main(){
long long N;
cin >> N;
long long count=0;
long long val;
long long min_val = N;
for(int i=0; i<N; i++){
cin >> val;
if(val <= min_val){
count += 1;
min_val = val;
}
}
cout << count << endl;
return 0;
}
|
#include<stdio.h>
int solve (int d)
{
int ans = 0;
int i=d;
while(i<600)
{
ans+=d*i*i;
i=i+d;
}
return ans;
}
int main()
{
int d;
while(scanf("%d",&d)==1)
{
printf("%d\n",solve(d));
}
return 0;
}
| 0
| 66,467,152
|
#include <iostream>
#include <cmath>
using namespace std;
int main(void){
int n, a[1010]={0};
while(cin >> n){
int min=1000001;
if(n == 0) break;
for(int i=0; i< n; i++){
cin >> a[i];
}
for(int i=0; i<n; i++){
for(int j=i+1; j<n; j++){
if(min > abs(a[j]-a[i])) min=abs(a[j]-a[i]);
}
}
cout << min <<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#include<stack>
using namespace std;
int main(void) {
char str[105];
while(1){
cin.getline(str, sizeof(str));
if(str[0] == '.') break;
stack<char> s;
s.push('0');
int flag = 1;
for(int i = 0; str[i] != '\0'; i++){
if(str[i] == '(') s.push(')');
if(str[i] == '[') s.push(']');
if(str[i] == ')'){
if(s.top() == ')'){
s.pop();
}else{
flag = 0;
break;
}
}
if(str[i] == ']'){
if(s.top() == ']'){
s.pop();
}else{
flag = 0;
break;
}
}
}
if(flag == 1 && s.top() == '0') cout << "yes" << endl;
else cout << "no" << endl;
}
return 0;
}
| 0
| 80,526,188
|
#include <iostream>
#include <cmath>
#include <vector>
#include <map>
#include <iomanip>
#include <algorithm>
#include <sstream>
#include <string>
#include <math.h>
#include <set>
#include <deque>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0 ; i < n ; i++) cin >> a[i];
sort(a, a + n);
int b = 0;
for (int i = 0 ; i < n ; i++) if (a[i] != a[i + 1]) b++;
int c[b] = {}, j = 0;
for (int i = 0 ; i < n ; i++) {
c[j]++;
if (a[i] != a[i + 1]) j++;
}
if (b <= k) {
cout << 0;
return 0;
}
sort(c, c + b);
int d = 0;
for (int i = 0 ; i < b - k ; i++) d += c[i];
cout << d;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main()
{
int n, md = 0; cin >> n;
for (int i = 0; i < n; i ++){
int d; cin >> d; a[d] ++;
md = max(d, md);
}
int r = (md + 1) / 2;
for (int i = 0; i < r; i ++){
if (a[i] >= 1) return cout << "Impossible", 0;
}
if (md % 2 == 0) if (a[r] != 1) return cout << "Impossible", 0;
if (md % 2 != 0) if (a[r] != 2) return cout << "Impossible", 0;
for (int i = r + 1; i <= md; i ++){
if (a[i] <= 1) return cout << "Impossible", 0;
}
cout << "Possible";
return 0;
}
| 0
| 10,292,144
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
string s;
cin >> s;
bool ans = false;
sort(s.begin(), s.end());
if(s.at(0) == s.at(1) && s.at(2) == s.at(3) && s.at(0) != s.at(2))
cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
int main() {
ll N, A, B;
cin >> N >> A >> B;
if (N < A + B - 1 || N > A * B) {
cout << "-1\n";
return 0;
}
if (B == 1) {
rep(i, N) {
cout << i + 1;
if (i == N - 1) cout << "\n";
else cout << " ";
}
return 0;
}
ll q = (N - A - B + 1) / (B - 1);
ll r = (N - A - B + 1) % (B - 1);
vector<int> ans;
rep(i, q + 1) {
rep(j, B) {
ans.push_back((i + 1) * B - j);
}
}
int s = (q + 1) * B;
if (r > 0) {
rep(i, r + 1) {
ans.push_back((q + 1) * B + r + 1 - i);
}
s += r + 1;
}
if (s < N) {
for (int i = s + 1; i <= N; i++) ans.push_back(i);
}
rep(i, ans.size()) {
cout << ans[i];
if (i == ans.size() - 1) cout << "\n";
else cout << " ";
}
}
| 0
| 54,092,083
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, s, n) for (int i = (s); i < (n); ++i)
#define rrep(i, n, g) for (int i = (n)-1; i >= (g); --i)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define len(x) (int)(x).size()
#define dup(x, y) (((x) + (y)-1) / (y))
#define pb push_back
#define Field(T) vector<vector<T>>
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, k;
cin >> n >> k;
cout << n*k-n-k+1 << endl;
}
|
#include<bits/stdc++.h>
#define LL long long
using namespace std;
LL k,maxx=9;
void bfs(){
queue<pair<LL,LL> > q;
q.push(make_pair(1ll,1ll));
q.push(make_pair(2ll,2ll));
q.push(make_pair(3ll,3ll));
q.push(make_pair(4ll,4ll));
q.push(make_pair(5ll,5ll));
q.push(make_pair(6ll,6ll));
q.push(make_pair(7ll,7ll));
q.push(make_pair(8ll,8ll));
q.push(make_pair(9ll,9ll));
while(!q.empty()){
LL djl=q.front().first;
LL nums=q.front().second;
q.pop();
if (nums==k){
cout<<djl<<endl;
exit(0);
}
if ((djl%10)-1>-1){
maxx++;
q.push(make_pair(djl*10+(djl%10)-1,maxx));
}
maxx++;
q.push(make_pair(djl*10+(djl%10),maxx));
if ((djl%10)+1<10){
maxx++;
q.push(make_pair(djl*10+(djl%10)+1,maxx));
}
}
}
int main()
{
ios::sync_with_stdio(false);
cin>>k;
bfs();
return 0;
}
| 0
| 52,421,045
|
#pragma region Macros
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for(int i=0; i<(n); i++)
#define REPS(i, n) for(int i=0; i<=(n); i++)
#define FOR(i, a, b) for(int i=a; i<(b); i++)
#define FORS(i, a, b) for(int i=a; i<=(b); i++)
#define ALL(v) (v).begin(),(v).end()
#define RALL(v) (v).rbegin(),(v).rend()
#define SIZE(v) ((ll)(v).size())
#define MAX(v) *max_element(ALL(v))
#define MIN(v) *min_element(ALL(v))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;
#pragma endregion
int main(){
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
REP(i, m) cin >> a[i] >> b[i];
vector<int> ord(n);
iota(ALL(ord), 1);
int ans = 0;
do {
bool all_ok = true;
REP(i, n-1) {
bool ok = false;
if (ord[i] < ord[i+1]) {
REP(j, m) if (a[j]==ord[i] && b[j]==ord[i+1]) ok=true;
}
else {
REP(j, m) if (a[j]==ord[i+1] && b[j]==ord[i]) ok=true;
}
if (ok) continue;
else {
all_ok=false;
break;
}
}
if (all_ok) ans++;
} while(next_permutation(ord.begin()+1, ord.end()));
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int n;
vector<int> a;
int main() {
while (cin >> n) {
if (n == 0) break;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end());
int res = 1<<29;
for (int i = 0; i < n-1; ++i) res = min(res, a[i+1] - a[i]);
cout << res << endl;
}
}
| 0
| 28,898,215
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+9;
ll a[N],p[69],n,sum,res;
void insert(ll x){
for(int i=60;i>=0;i--)if(x&(1ll<<i)){
if(!p[i]){p[i]=x;break;}
x^=p[i];
}
}
void solve(){
for(int i=60;i>=0;i--){
if(res+(res^sum)<(res^p[i])+(res^p[i]^sum))res^=p[i];
}
}
int main(){
ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i],sum^=a[i];
for(int i=0;i<60;i++)if(sum&(1ll<<i)){
for(int j=1;j<=n;j++)if(a[j]&(1ll<<i))a[j]^=(1ll<<i);
}
for(int i=1;i<=n;i++)insert(a[i]);
solve();
cout<<res+(res^sum)<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <queue>
#include <map>
#include <set>
#include <tuple>
#include <functional>
#include <cassert>
#include <bitset>
using namespace std;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define RALL(x) (x).rbegin(),(x).rend()
#define SIZE(x) (int)(x).size()
#define SIZEL(x) (ll)(x).size()
#define MSG(a) cout << #a << " " << a << endl;
using ll = long long;
using ld = long double;
using Graph = vector<vector<int>>;
const double PI = 3.14159265358979323846;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll x, ll y) { return (x % y)? gcd(y, x % y): y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int main()
{
string s;
ll k;
cin >> s >> k;
ll len = SIZEL(s);
if (count(s.cbegin(), s.cend(), s[0]) == len){
cout << len*k/2 << endl;
return 0;
}
ll fCnt=0;
ll lCnt=0;
REP(i,len){
if (s[0]==s[i]) fCnt++;
else break;
}
REPD(i,len){
if (s[len-1]==s[i]) lCnt++;
else break;
}
ll dpCnt=0;
int c=1;
char now=s[0];
FOR(i,1, len){
if (now==s[i]){
c++;
}else{
dpCnt+=c/2;
now=s[i];
c=1;
}
}
if (fCnt%2==1 && lCnt%2==1 && k%2==0) {
cout << ((dpCnt+1)*k)-1 << endl;
}else{
cout << dpCnt*k << endl;
}
return 0;
}
| 0
| 41,598,441
|
#include <iostream>
using namespace std;
struct point{
double x;
double y;
};
int ccw(point p0, point p1, point p2){
double dx1, dx2, dy1, dy2;
dx1 = p1.x - p0.x;
dy1 = p1.y - p0.y;
dx2 = p2.x - p0.x;
dy2 = p2.y - p0.y;
if(dx1 * dy2 > dy1 * dx2){
return 1;
}else if(dx1 * dy2 < dy1 * dx2){
return -1;
}else return 0;
}
int main(){
point p1, p2, p3, p0;
while(cin >> p1.x >> p1.y >> p2.x >>p2.y
>> p3.x >> p3.y >> p0.x >> p0.y)
{
if(ccw(p0,p1,p2) && ccw(p0,p2,p3) && ccw(p0, p3, p1)){
if((ccw(p0, p1, p2 ) != ccw(p0, p1, p3))
&& (ccw(p0, p2, p1) != ccw(p0, p2, p3)))
cout << "YES" << endl;
else cout << "NO" << endl;
}else{
cout << "NO" << endl;
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
int h, w, k;
cin >> h >> w >> k;
char arr[h + 1][w + 1];
for(int i = 1;i <= h;i++)
{
for(int j = 1;j <= w;j++)
{
cin >> arr[i][j];
}
}
int cnt = 0;
for(int c1 = 0;c1 < (1 << h);c1++)
{
for(int c2 = 0;c2 < (1 << w);c2++)
{
int c = 0;
for(int i = 0;i < h;i++)
{
for(int j = 0;j < w;j++)
{
if((!(c1 & (1 << i))) && (!(c2 & (1 << j))))
{
if(arr[i + 1][j + 1] == '#')
c++;
}
}
}
if(c == k)
cnt++;
}
}
cout << cnt;
return 0;
}
| 0
| 83,397,701
|
#include <iostream>
#include <iomanip>
#include <cmath>
#include <string>
#include <vector>
#include <cstdlib>
#include <map>
#include <queue>
#include <deque>
#include <algorithm>
#include <stack>
#include <functional>
#include <sstream>
#define rep(i,j,n) for(i=j;i<(n);i++)
#define rrep(i,j,n) for(i=j;i>(n);i--)
typedef long long int lli;
#define N 1000000007
#define M 998244353
using namespace std;
lli gcd(lli a,lli b){
if(b>a){
swap(a,b);
}
if(a%b==0){
return b;
}
else{
return gcd(b,a%b);
}
}
int main(){
lli n,k,a,b;
vector<lli> vec,big;
lli i,j;
cin>>n>>k;
rep(i,0,n){
cin>>a;
if(a>=k){
big.push_back(a-k);
}
vec.push_back(a);
if(i==0){
b=a;
}
b=gcd(a,b);
}
if(big.size()==0){
cout<<"IMPOSSIBLE"<<endl;
}
else{
rep(i,0,big.size()){
if(big[i]%b==0){
cout<<"POSSIBLE"<<endl;
break;
}
else if(i==big.size()-1){
cout<<"IMPOSSIBLE"<<endl;
}
}
}
}
|
#include<vector>
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#define INF 100000000000000
using namespace std;
typedef long long llong;
int main(){
llong N,M;
llong cnt=0;
double total = 0.0;
cin >> N >> M;
vector<llong> A(N,0);
for(int i=0; i<A.size(); i++){
cin >> A[i];
total += A[i];
}
total = total*(1/((double)4*M));
for(int i=0; i<A.size(); i++){
if(A[i]<total){
continue;
}
cnt++;
}
if(cnt>=M){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
| 0
| 14,245,674
|
#include <iostream>
#include<string>
#include<cmath>
#include<ciso646>
#include<cstring>
#include<iomanip>
#include<vector>
#include<algorithm>
#include<utility>
#include<map>
#include<math.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
using ll = long long;
ll Max = 10 + 1e12;
int N = 5 + 1e5;
int main()
{
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int cnt = 0;
int ans = 0;
rep(i, n-1) {
if (h[i] >= h[i + 1])
cnt++;
else
cnt = 0;
ans = max(ans, cnt);
}
cout << ans;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int a, b, k;
cin >> a >> b >> k;
vector<int> ans;
for (int i = 1; i <= min(a, b); i++)
{
if (a % i == 0 && b % i == 0)
{
ans.push_back(i);
}
}
cout << ans[ans.size() - k] << endl;
}
| 0
| 96,351,004
|
#include <bits/stdc++.h>
#define rep(i,a,n) for (int i = (a); i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main(){
int n,k;
cin >> n >> k;
vector<int> p(n);
rep(i,0,n) cin >> p[i];
sort(p.begin(),p.end());
int sum = 0;
rep(i,0,k) sum += p[i];
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e6;
int d[MAXN+1];
bool prime[MAXN+1];
int n;
void sieve(){
memset(prime,true,sizeof(prime));
for(int p=2; p*p<=MAXN; p++){
if(prime[p]){
for(int i=p*p; i<=MAXN; i+=p){
prime[i] = false;
d[i] = p;
}
}
}
d[1]=1;
for(int i=2; i<=MAXN; i++) if(prime[i]) d[i] = i;
}
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
cin >> n;
int a[n]; for(int i=0; i<n; i++) cin >> a[i];
int b[n]; for(int i=0; i<n; i++) b[i] = a[i];
sieve();
bool pairwise = true;
map<int,int> m;
for(int i=0; i<n; i++){
set<int> s;
while(a[i]>1){
s.insert(d[a[i]]);
a[i]/=d[a[i]];
}
for(auto& a : s){
m[a]++;
if(m[a]>1){
pairwise = false;
break;
}
}
if(!pairwise) break;
}
if(pairwise) cout << "pairwise coprime" << endl;
else{
int curr = gcd(b[0],b[1]);
for(int i=2; i<n; i++){
curr = gcd(curr,b[i]);
}
if(curr==1) cout << "setwise coprime" << endl;
else cout << "not coprime" << endl;
}
}
| 0
| 95,385,693
|
#include<stdio.h>
int main(){
int a,b,c,d,x,y;
while(1){
scanf("%d %d",&x,&y);
if(x==0&&y==0)break;
for(c=1;c<=y;c++){
printf("#");
}
printf("\n");
for(b=3;b<=x;b++){
printf("#");
for(a=3;a<=y;a++){
printf(".");
}
printf("#\n");
}
for(d=1;d<=y;d++){
printf("#");
}
printf("\n\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,ans=10000000;
cin >> N;
vector<int> ary(N);
for(int i = 0 ; i < N ; i++){
cin >> ary[i];
}
sort(ary.begin(),ary.end());
for(int i = 1 ; i <= ary[N-1] ;i ++){
int P = i;
int tmp = 0;
for(int j = 0 ; j < N ; j++){
tmp += (ary[j] - P) * (ary[j] - P);
}
if(ans > tmp){
ans = tmp;
}else{
break;
}
}
cout << ans << endl;
}
| 0
| 30,676,226
|
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int n;
int cnt[86401];
int toSec(string s) {
int h = (s[0] - '0') * 10 + (s[1] - '0');
int m = (s[3] - '0') * 10 + (s[4] - '0');
int sec = (s[6] - '0') * 10 + (s[7] - '0');
return h * 3600 + m * 60 + sec;
}
int main() {
while (cin >> n) {
if (!n) return 0;
int i;
for (i = 0; i < 86400; i++) cnt[i] = 0;
for (i = 0; i < n; i++) {
string s, t;
cin >> s >> t;
cnt[toSec(s)]++;
cnt[toSec(t)]--;
}
for (i = 1; i < 86400; i++) cnt[i] += cnt[i - 1];
int ans = 0;
for (i = 0; i < 86400; i++) ans = max(ans, cnt[i]);
cout << ans << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int i,j,bo,ans;
string st;
int main()
{
getline(cin,st);
i=0;j=st.size()-1;
while(i<=j)
{
if(st[i]==st[j]) {i++;j--;continue;}
if(st[i]=='x') {i++;ans++;continue;}
if(st[j]=='x') {j--;ans++;continue;}
bo=1;break;
}
if(bo!=1) cout<<ans<<"\n";
else cout<<-1<<"\n";
return 0;
}
| 0
| 90,710,304
|
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = a; i < b; i++)
#define Rep(i, a, b) for(int i = a; i <= b; i++)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define _GLIBCXX_DEBUG
#define Vl vector<ll>
#define Vs vector<string>
#define Vp vector<pair<ll, ll>>
using ll = long long;
#define ALL(v) (v).begin(),(v).end()
#define endl "\n"
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define co(x) cout << x << endl
#define coel cout << endl
#define pb push_back
#define sz(v) ((ll)(v).size())
using namespace std;
const double pi = acos(-1.0);
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
#define pp pair<ll, pair<ll, ll>>
#define fi first
#define se second
int main() {
ll a, b, c; cin >> a >> b >> c;
ll k; cin >> k;
rep(i, 0, k){
if(a >= b) b*=2;
else c*=2;
}
if(a < b && b < c) co("Yes");
else co("No");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long LCM(long long a,long long b);
signed main(){
int n;
cin>>n;
long long t[n+2];
for(int i=0;i<n;i++){
cin>>t[i];
}
long long sum=t[0];
for(int i=0;i<n;i++){
sum=LCM(sum,t[i]);
}
cout<<sum<<"\n";
return(0);
}
long long LCM(long long a,long long b){
return(a/__gcd(a,b)*b);
}
| 0
| 82,363,833
|
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
if(n-6>=0){
cout<<n/3;
}
else{
cout<<0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=int(a);i<int(b);i++)
typedef long long ll;
int main(){
ll N,cn=0,A=0,B=0,BA=0;cin>>N;
string s[10010];
rep(i,0,N){
cin>>s[i];
rep(j,0,s[i].size()-1){
if(s[i].at(j)=='A'&&s[i].at(j+1)=='B')cn++;
}
if(s[i].at(0)=='B'&&s[i].at(s[i].size()-1)=='A')BA++;
else if(s[i].at(0)=='B')B++;
else if(s[i].at(s[i].size()-1)=='A')A++;
}
if(BA!=0&&B==0&&A==0)cn+=BA-1;
else cn+=min(BA+A,BA+B);
cout<<cn<<endl;
}
| 0
| 53,956,766
|
#include "bits/stdc++.h"
using namespace std;
int main()
{
int n,max,p,q;
max=0;
cin>>n;
vector<int> a(n);
vector<int> aa(n);
for(int i=0;i<n;i++)
{
cin>>a.at(i);
if(max<a.at(i))
{
max=a.at(i);
p=i;
}
}
for(int i=0;i<n;i++)
{
aa.at(i)=a.at(i);
}
sort(aa.begin(),aa.end());
reverse(aa.begin(),aa.end());
for(int i=0;i<n-1;i++)
{
if(aa.at(i)!=aa.at(i+1))
{
q=aa.at(i+1);
break;
}
}
if(aa.at(0)==aa.at(1))
{
for(int i=0;i<n;i++)
{
cout<<max<<endl;
}
}
else
{
for(int i=0;i<n;i++)
{
if(i!=p)
cout<<max<<endl;
else
cout<<q<<endl;
}
}
}
|
#define _USE_MATH_DEFINES
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<bitset>
#include<cctype>
#include<climits>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<deque>
#include<list>
#include<map>
#include<set>
#include<stack>
#include<string>
#include<sstream>
#include<queue>
#include<vector>
using namespace std;
struct P { double x, y; };
double th = M_PI * 60.0 / 180.0;
void p(P p) {
cout << p.x << " " << p.y << endl;
}
void koch(int n, P p1, P p2) {
if (n == 0)return;
P s, t, u;
s.x = (2 * p1.x + p2.x) / 3;
s.y = (2 * p1.y + p2.y) / 3;
t.x = (p1.x + 2 * p2.x) / 3;
t.y = (p1.y + 2 * p2.y) / 3;
u.x = (t.x - s.x)*cos(th) - (t.y - s.y)*sin(th) + s.x;
u.y = (t.x - s.x)*sin(th) + (t.y - s.y)*cos(th) + s.y;
koch(n - 1, p1, s);
p(s);
koch(n - 1, s, u);
p(u);
koch(n - 1, u, t);
p(t);
koch(n - 1, t, p2);
}
int main() {
cout << fixed << setprecision(6);
int n; cin >> n;
P p1, p2;
p1.x = 0; p1.y = 0;
p2.x = 100; p2.y = 0;
p(p1);
koch(n, p1, p2);
p(p2);
return 0;
}
| 0
| 47,460,820
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N; cin>>N;
vector<string>S(N);
for(int i=0;i<N;i++){
vector<char>C(10);
string A; cin>>A;
for(int j=0;j<10;j++)C[j]=A.at(j);
sort(C.begin(),C.end());
for(int j=0;j<10;j++)A.at(j)=C[j];
S[i]=A;
}
sort(S.begin(),S.end());
long long ans=0;
int count=1;
for(int i=1;i<N;i++){
if(S[i]==S[i-1]){ans+=count;count++;}
else count=1;
}
cout<<ans<<endl;
}
|
#include<stdio.h>
#include<string.h>
char a[105][3],b[105][3],c[105][3];
void squt(char a[],char b[]){
char s[105];
strcpy(s,a);memset(a,0,strlen(a));
strcpy(a,b);memset(b,0,strlen(b));
strcpy(b,s);
}
int main(){
char s;
int n,m,i,j,k,bo=1;
scanf("%d%c",&n,&s);
for(i=0;i<n;i++){
scanf("%s",a[i]);
strcpy(b[i],a[i]);
}
for(i=1;i<n;i++){
for(j=0;j<n-i;j++)
{
if(a[j][1]>a[j+1][1]){
squt(a[j],a[j+1]);
}
}
}
for(i=0;i<n;i++){
m=i;
for(j=i;j<n;j++){
if(b[j][1]<b[m][1])m=j;
}
squt(b[i],b[m]);
}
for(i=0;bo!=0&&i<n;i++){
if(a[i][0]!=b[i][0]||a[i][1]!=b[i][1])bo=0;
}
for(i=0;i<n-1;i++)printf("%s ",a[i]);printf("%s",a[n-1]);
printf("\nStable\n");
for(i=0;i<n-1;i++)
printf("%s ",b[i]);printf("%s",b[n-1]);
if(bo==0)
printf("\nNot stable\n");
else printf("\nStable\n");
return 0;
}
| 0
| 68,090,304
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,o,n) for(long long i = o;i<n;i++)
#define oneforall ios::sync_with_stdio(false);cin.tie(0);
#define all(v) (v).begin(),(v).end()
#define ini(...) int __VA_ARGS__; in(__VA_ARGS__)
#define inl(...) long long __VA_ARGS__; in(__VA_ARGS__)
#define ins(...) string __VA_ARGS__; in(__VA_ARGS__)
#define int long long
const long long INF=1e18;
void in(){} template <typename T,class... U> void in(T &t,U &...u){ cin >> t; in(u...);}
void out(){cout << "\n";} template <typename T,class... U> void out(const T &t,const U &...u){ cout << t; if(sizeof...(u)) cout << " "; out(u...);}
typedef vector<int> vi;
typedef vector<long long> vl;
typedef long long ll;
typedef vector<pair<long, long > > vpll;
typedef vector<pair<int, int > > vpii;
int32_t main() {
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
ini(n);
int tmp = 0;
vi morty;
vi morty1;
FOR(i,0,n){
ini(x);
morty.push_back(x);
tmp-=x;
}
FOR(i,0,n){
ini(x);
morty1.push_back(x);
tmp+=x;
}
int tmp1= 0;
FOR(i,0,n){
if(morty[i]<morty1[i]){tmp1+=((morty1[i]-morty[i])+1)/2;}
}
if(tmp >= tmp1)out("Yes");
else out("No");
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i=0;i < (int)(n);i++)
ll table[1000][1000];
const ll mod =1000000007;
int main(){
string s;
cin >> s;
int st=-1;
int end=-1;
for (int i =0;i < s.size();i++){
if (i+1 < s.size()){
if (s[i]==s[i+1]){
st=i;
end=i+1;
break;
}
}
if (i+2 < s.size()){
if (s[i]==s[i+2]){
st=i;
end=i+2;
break;
}
}
}
if (st==-1 && end==-1){
cout << -1 << " " << -1 << endl;
}
else{
st++;end++;
cout << st << " " << end << endl;
}
return 0;
}
| 0
| 55,903,224
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,(n)-1,0)
#define all(v) v.begin(), v.end()
#define endk '\n'
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
const ll mod2 = 998244353;
const ld eps = 1e-10;
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b){if(a>b) a=b;}
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b){if(a<b) a=b;}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
string s; cin >> s;
int sum = 0, mn = 0;
rep(i, n) {
if(s[i] == '(') sum++;
else sum--;
chmin(mn, sum);
}
cout << string(-mn, '(') + s + string(sum-mn, ')') << endk;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <limits>
#include <list>
#define ALL(x) (x).begin(),(x).end()
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define int_INF 2147483647
#define pint_INF 2000000000
#define ll_INF 9223372036854775807
#define MOD 1000000007
#define vi vector<int>
#define vvi vector<vector<int>>
#define vvll vector<vector<long long>>
#define vvc vector<vector<char>>
#define vll vector<long long>
#define pii pair<int,int>
#define vpii vector<pair<int,int>>
#define sysp system("PAUSE")
#define pno cout << "no" << endl
#define pyes cout << "yes" << endl
#define pYes cout << "Yes" << endl
#define pNo cout << "No" << endl
#define pNO cout << "NO" << endl
#define pYES cout << "YES" << endl
#define endl "\n"
#define pi 3.14159265358979
using namespace std;
using ll = long long;
int main() {
string s;
string ss;
cin >> s;
for (auto c : s) {
if (c != 'x') {
ss.push_back(c);
}
}
bool flag = true;
for (int i = 0; i < ss.size() / 2; i++) {
if (ss[i] != ss[ss.size() - 1 - i]) {
flag = false;
break;
}
}
if (!flag) {
cout << -1 << endl;
}
else {
list<char> lst;
for (auto c : s) {
lst.push_back(c);
}
int cnt = 0;
while (lst.size() > 1) {
if (lst.front() == lst.back()) {
lst.pop_front();
lst.pop_back();
}
else {
if (lst.front() == 'x') {
lst.push_back('x');
cnt += 1;
}else if (lst.back() == 'x') {
lst.push_front('x');
cnt += 1;
}
}
}
cout << cnt << endl;
}
sysp;
}
| 0
| 58,180,327
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <string>
using namespace std;
class cIsRightTriangle
{
public:
bool judge(vector<int>&);
};
bool cIsRightTriangle::judge(vector<int> &v)
{
sort(v.begin(), v.end());
if (v[2] * v[2] == (v[0] * v[0] + v[1] * v[1]))
return true;
else
return false;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
cIsRightTriangle ct;
vector<int> vd(3);
for (int i = 0; i < n; ++i)
{
cin >> vd[0] >> vd[1] >> vd[2];
cout << (ct.judge(vd) ? string("YES") : string("NO")) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool lrp[2];
int lr[2];
void c(bool f,char s){
if(s=='u'){
if(lrp[f]==0){
if(lr[!f]>=lr[f])lr[f]++;
else lr[f]--;
}
lrp[f]=1;
}else {
if(lrp[f]==1){
if(lr[!f]>=lr[f])lr[f]++;
else lr[f]--;
}
lrp[f]=0;
}
}
int main(){
int n;
while(cin>>n&&n){
string s;
lrp[0]=lrp[1]=0;
lr[0]=lr[1]=0;
while(n--){
cin>>s;
if(s[0]=='l') c(0,s[1]);
else c(1,s[1]);
}
cout<<min(lr[0],lr[1])<<endl;
}
return 0;
}
| 0
| 76,076,853
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define endl '\n'
#define INF INT_MAX
vector<ll> dp;
ll f(vector<ll> &v,ll n,ll k)
{
ll i,j;
dp[0]=0;
for(i=1;i<=min(n,k);i++)
{
for(j=0;j<i;j++)
{
dp[i]=min(dp[i],dp[j]+abs(v[j]-v[i]));
}
}
for(;i<=n;i++)
{
for(j=1;j<=k;j++)
{
dp[i]=min(dp[i],dp[i-j]+abs(v[i]-v[i-j]));
}
}
return dp[n];
}
void solve()
{
ll n,i,ans,k;
cin>>n>>k;
dp.resize(n,INF);
vector<ll> v(n);
for(i=0;i<n;i++)
{
cin>>v[i];
}
ans=f(v,n-1,k);
cout<<ans;
}
int main()
{
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
vector<vector<int> > A(3,vector<int>(3,0));
vector<vector<bool> > Abool(3,vector<bool>(3,0));
int ans = 0;
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
cin >> A.at(i).at(j);
}
}
int N = 0;
cin >> N;
vector<int> B(N,0);
for(int i = 0; i < N; i++) {
cin >> B.at(i);
for(int j = 0; j < 3; j++) {
for(int k = 0; k < 3; k++) {
if(A.at(j).at(k) == B.at(i)) {
Abool.at(j).at(k) = 1;
}
}
}
}
for(int i = 0; i < 3; i++) {
if(Abool.at(i).at(0) && Abool.at(i).at(1) && Abool.at(i).at(2)) {
ans++;
}
if(Abool.at(0).at(i) && Abool.at(1).at(i) && Abool.at(2).at(i)) {
ans++;
}
if(Abool.at(0).at(0) && Abool.at(1).at(1) && Abool.at(2).at(2)) {
ans++;
}
if(Abool.at(2).at(0) && Abool.at(1).at(1) && Abool.at(0).at(2)) {
ans++;
}
}
if(ans) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| 0
| 78,796,593
|
#include<bits/stdc++.h>
using namespace std;
#define For(i,n,k) for(int i=(n);i<(k);i++)
#define ALL(a) (a).begin(),(a).end()
int ans=0;
struct UnionFind {
vector<int> sz;
vector<int> par;
UnionFind(int N) : sz(N),par(N) {
for(int i = 0; i < N; i++){
sz[i] = 1;
par[i] = i;
}
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
int size(int x) {
return sz[root(x)];
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
par[rx] = ry;
sz[ry] += sz[rx];
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
void Main(){
int n,m;cin>>n>>m;
vector<int> p(n);
For(i,0,n) {
cin>>p[i];
p[i]--;
}
UnionFind Tree(n);
For(i,0,m){
int x,y;cin>>x>>y;
x--;y--;
Tree.unite(x,y);
}
For(i,0,n) if(Tree.same(i,p[i])) ans++;
cout<<ans<<endl;
}
int main(){
Main();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int ,int > pii;
typedef map<int,int>mii;
#define test int ct;cin>>ct;while(ct--)
#define fo(i,n) for( i=0;i<n;i++)
#define el <<"\n"
#define sc(n) scanf("%d",&n)
#define scl(n) scanf("%lld",&n)
#define sq(a) (a)*(a)
#define file() freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);
#define zro 1e-9
#define F first
#define S second
#define pb(a) push_back(a)
#define sqsum(n) (((n)*(n+1)*(2*(n)+1))/6)
#define mltpls(first,last,ratio) ((last)*(ratio)-(first))/(ratio-1)
#define linear_sum(n) (n)*(n+1)/2;
#define arithmetic_progression(first,last,ratio) ((ratio)*(first+last))/2
#define rb rbegin()
#define re rend()
#define bg begin()
#define en end()
#define itr iterator
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);
int i;
#define gcd(a,b) __gcd(a,b)
#define gl(s) getline(cin,s)
int main()
{
int a[3]={0};
fo(i,2)
{
int k;
cin>>k;
a[k-1]=1;
}
fo(i,3)
{
if(a[i]==0)
cout<<(i+1);
}
}
| 0
| 3,178,615
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long int ll;
int main(){
ll n, k;
cin >> n >> k;
vector<ll> a(n), b(n);
for(int i = 0; i < n; i++){
cin >> a[i] >> b[i];
}
ll ans = 0;
for(int i = 0; i <= 30; i++){
if(i != 0 && (k & (1LL << i)) == 0) continue;
ll t;
if(i == 0) t = k;
else t = k & ~(1LL << i) | ((1LL << i) - 1);
ll sum = 0;
for(int j = 0; j < n; j++){
if((t | a[j]) == t) sum += b[j];
}
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cstdio>
#include<string>
using namespace std;
int temp[5];
bool compare(int a,int b)
{
return a>b;
}
int main()
{
while(~scanf("%d",&temp[0]))
{
for(int i=1;i<5;i++)
cin>>temp[i];
sort(temp,temp+5,compare);
for(int i=0;i<4;i++)
{
cout<<temp[i]<<' ';
}
cout<<temp[4]<<endl;
}
return 0;
}
| 0
| 81,231,944
|
#include "bits/stdc++.h"
using namespace std;
#define ll long long
#define rep(i,n) for(int i = 0;i < (n); i++)
int main() {
ll n, p;
ll ans = 0;
cin >> n >> p;
string s;
cin >> s;
if (p == 2 || p == 5) {
rep(i, n) {
if ((s[i] - '0') % p == 0)ans += i + 1;
}
cout << ans << endl;
return 0;
}
else {
vector<ll> sum(n + 1);
vector<ll> c(p);
ll buf = 1;
for (int i = n - 1; i >= 0; i--) {
sum[i] = (sum[i + 1] + (s[i] - '0') * buf % p) % p;
buf *= 10;
buf %= p;
}
for (int i = n; i >= 0; i--) {
ans += c[sum[i]];
c[sum[i]]++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct dice{
vector<int> diceindex{0,1,2,3,4,5};
vector<int> dicenum{1,2,3,4,5,6};
void setNumber(vector<int> &setnum){
for(int i = 0; i < 6; i++){
dicenum[diceindex[i]] = setnum[diceindex[i]];
}
return;
}
vector<int> getNumber(){
vector<int> indexed(6);
for(int i = 0; i < 6; i++)
indexed[i] = dicenum[diceindex[i]];
return indexed;
}
void roll(char d){
vector<int> dump = diceindex;
vector<int> newindex(6);
switch(d){
case 'N':{
vector<int> n{4,0,2,3,5,1};
newindex = n;
break;
}
case 'S':{
vector<int> n{1,5,2,3,0,4};
newindex = n;
break;
}
case 'W':{
vector<int> n{3,1,0,5,4,2};
newindex = n;
break;
}
case 'E':{
vector<int> n{2,1,5,0,4,3};
newindex = n;
break;
}
}
for(int i = 0; i < 6; i++){
diceindex[newindex[i]] = dump[i];
}
return;
}
vector<int> getAround(int num){
int pos;
for(int i = 0; i < 6; i++){
if(dicenum[i] == num){
pos = i;
break;
}
}
vector<int> a;
switch(pos){
case 0:{
vector<int> n{1,2,4,3};
a = n;
break;
}
case 1:{
vector<int> n{5,2,0,3};
a = n;
break;
}
case 2:{
vector<int> n{0,1,5,4};
a = n;
break;
}
case 3:{
vector<int> n{1,0,4,5};
a = n;
break;
}
case 4:{
vector<int> n{0,2,5,3};
a = n;
break;
}
case 5:{
vector<int> n{1,3,4,2};
a = n;
break;
}
}
vector<int> re(4);
for(int i = 0; i < 4; i++){
re[i] = dicenum[a[i]];
}
return re;
}
};
int main(){
vector<int> dicenum(6);
for(int i = 0; i < 6; i++){
cin >> dicenum[i];
}
dice d;
d.setNumber(dicenum);
int q;
cin >> q;
for(int z = 0; z < q; z++){
vector<int> r(2);
cin >> r[0] >> r[1];
vector<int> a = d.getAround(r[0]);
int ans;
for(int i = 0; i < 4; i++){
if(a[i] == r[1]){
ans = a[(i+1)%4];
break;
}
}
cout << ans << endl;
}
return 0;
}
| 0
| 76,012,546
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
#define PI 3.14159265359
#define PB push_back
#define MP make_pair
#define F first
#define S second
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll A, B; cin >> A >> B;
if(A*500>=B) cout << "Yes";
else cout << "No";
}
|
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>
using namespace std;
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n = s.length();
bool res = false;
if (s[0] == 'A') {
int cs = 0;
int lowers = 0;
for (int i = 2; i + 1 < n; ++i) {
if (s[i] == 'C') {
++cs;
}
}
for (int i = 0; i < n; ++i) {
if (islower(s[i])) {
++lowers;
}
}
if (cs == 1 && lowers + 2 == n) {
res = true;
}
}
if (res) {
cout << "AC\n";
} else {
cout << "WA\n";
}
return 0;
}
| 0
| 46,211,546
|
#include <stdio.h>
#include <string.h>
int main() {
char n[255];
scanf("%[^\n]", &n);
int len = strlen(n);
for(int i = 0; i < len; i++){
if(n[i] == ','){
printf(" ");
}
else {
printf("%c", n[i]);
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for(int i = n-1; i >= 0; 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>;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VP = vector<P>;
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; }
int main(){
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll lcs = c * d / __gcd(c, d);
ll sum = b - a + 1;
sum -= b / d;
sum += a / d;
if (a % d == 0) sum--;
sum -= b / c;
sum += a / c;
if (a % c == 0) sum--;
sum += b / lcs;
sum -= a / lcs;
if (a % lcs == 0) sum++;
cout << sum << endl;
return 0;
}
| 0
| 22,360,546
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
#define X real()
#define Y imag()
using namespace std;
using namespace __gnu_pbds;
template<class T> using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
using ll = long long;
using point = complex<double>;
void err(istream_iterator<string> it) {cerr << endl;}
template<typename T, typename... Args>void err(istream_iterator<string> it, T a, Args... args) {cerr << *it << " = " << a << endl;err(++it, args...);}
const double EPS = 1e-8;
const long long mod = 1e9+7;
const int dx[] = {0, 0,1,-1,1,-1, 1,-1};
const int dy[] = {1,-1,0, 0,1,-1,-1, 1};
const int N = 1e5 + 5;
int n , m,arr[N];
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cin >> n >> m;
for(int i = 1; i <= n; ++i)
cin >> arr[i];
map<int,int> frq;
long long ans = 0;
for(int i = 1; i <= n; ++i){
arr[i] = (arr[i]%m + arr[i - 1]%m)%m;
ans += (arr[i]==0);
ans += frq[arr[i]];
frq[arr[i]]++;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int mod = 1000000007;
void solve();
int main(void){
int N, K; cin >> N >> K;
ll A[N]; rep(i, N) cin >> A[i];
vector<ll> bt(N*(N+1)/2);
int idx = 0;
for(int i = 0; i < N; i++){
ll acc = 0;
for(int j = i; j < N; j++){
acc += A[j];
bt[idx] = acc;
idx++;
}
}
ll pow2[40]; pow2[0] = 1;
for(int i = 1; i < 40; i++) pow2[i] = pow2[i-1] << 1;
int m = 39; ll ans = 0;
for(int t = m; t >= 0; t--){
int cnt = 0;
for(int i = 0; i < bt.size(); i++){
if(((ans + pow2[t]) & bt[i]) == (ans + pow2[t])) cnt++;
}
if(cnt >= K) ans += pow2[t];
}
cout << ans << endl;
return 0;
}
void solve(){}
| 0
| 87,354,783
|
#include <iostream>
using namespace std;
const int mxN = 2e5 + 5;
int a[mxN];
int main() {
int n;
cin >> n;
for(int i = 1; i <= n; ++i)
cin >> a[i];
int answer = 0, look = 1;
if(n == 1)
return cout << (a[1] == 1 ? 0 : -1), 0;
for(int i = 1; i <= n; ++i) {
if(a[i] == look) {
++look;
continue;
}
++answer;
}
cout << (look == 1 ? -1 : answer);
}
|
#include<bits/stdc++.h>
#define rep(X,A,B) for(int X=A;X<=B;X++)
#define tep(X,A,B) for(int X=A;X>=B;X--)
#define LL long long
#define DB double
const int N=400010;
const int M=800010;
using namespace std;
int n;
map<LL,int> mp;
LL sz[N];
int fa[N],edge[M],lst[N],nxt[M],t=0;
struct nn{
LL d;
int id;
}a[N];
int cmp(nn A,nn B){
return A.d<B.d;
}
void READ(){
scanf("%d",&n);
rep(i,1,n)scanf("%lld",&a[i].d),a[i].id=i,mp[a[i].d]=i;
sort(a+1,a+n+1,cmp);
}
void ADD(int x,int y){
edge[++t]=y;nxt[t]=lst[x];lst[x]=t;
}
LL SEARCH(int x,int dep){
LL res=dep;
for(int r=lst[x];r;r=nxt[r]){
res+=SEARCH(edge[r],dep+1);
}
return res;
}
int SOLVE(){
rep(i,1,n)sz[i]=1;
tep(i,n,2){
int x=a[i].id;
LL d=a[i].d;
LL now=d+2*sz[x]-n;
int pos=mp[now];
if(pos==0||now>=a[i].d)return 0;
fa[x]=pos;
ADD(fa[x],x);
sz[fa[x]]+=sz[x];
}
LL sum=SEARCH(a[1].id,0);
if(sum!=a[1].d)return 0;
rep(i,1,n){
if(i==a[1].id)continue;
printf("%d %d\n",i,fa[i]);
}
return 1;
}
int main(){
READ();
if(!SOLVE())printf("-1\n");
return 0;
}
| 0
| 57,462,306
|
#include<iostream>
#include<stdio.h>
#include<vector>
#include<float.h>
#include<iomanip>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<cmath>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<cassert>
#include<cmath>
#include<cstdint>
#define INF 1e9
#define rep(i,n)for(int i=0;(i)<(int)(n);i++)
#define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define vec(type,n) vector<type>(n)
#define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))
#define ALL(a) (a).begin(),(a).end()
#define chmin(a, b) a = min(a, b)
#define chmax(a, b) a = max(a, b)
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
const int MOD = 1e9 + 7;
int main(){
int n;
cin >> n;
vector<ll> a(n);
rep(i, n)cin >> a[i];
ll res = 0, m = 1;
rep(i, n){
if(a[i] == m)m = a[i] + 1;
else {
res += (a[i] / m);
if(a[i] % m == 0)res--;
}
if(m == 1)m++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, m, a, b;
cin >> n >> m;
vector<vector<bool>> vn(n, vector<bool>(n,false));
for(int i=0; i<m; ++i){
cin >> a >> b;
--a; --b;
vn[a][b] = true;
vn[b][a] = true;
}
vector<vector<int>> dp(n, vector<int>((1<<n),0));
dp[0][1] = 1;
for(int i=1; i<(1<<n); ++i) for(int j=0; j<n; ++j){
if(i >> j &1){
for(int k=0; k<n; ++k){
if(!vn[j][k]) continue;
if((i >> k &1) == 0) continue;
dp[j][i] += dp[k][i -(1 << j)];
}
}
}
int ans = 0;
for(int i=1; i<n; ++i){
ans += dp[i][(1<<n)-1];
}
cout << ans << endl;
}
| 0
| 23,918,971
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef long double ld;
const ll INF = 1e+14;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(),c.end()
#define pb push_back
void Yes(){
cout<<"Yes"<<endl;
exit(0);
}
void No(){
cout<<"No"<<endl;
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N; cin >> N;
char S[330][330];
rep(i, N) {
rep(j, N) {
cin >> S[i][j];
}
}
int ans = 0;
rep(B, N) {
char T[330][330];
rep(i, N) {
rep(j, N) {
T[i][j] = S[i][(j + B) % N];
}
}
bool flag = true;
rep(i, N) {
Rep(j, i + 1, N) {
if(T[i][j] != T[j][i]) {
flag = false;
}
}
}
if(flag) ans += N;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define s(x, n) memset(x, n, sizeof(x));
#define pb(x) push_back(x)
#define NIL -1
#define MAXN 11
void solve()
{
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
s(dp, 0);
for (int j = 0; j < k; j++)
{
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
}
for (int i = 2; i < n; i++)
{
int ans = INT_MAX;
for (int j = 0; j < k; j++)
{
if (i - (j + 1) >= 0)
{
ans = min(ans, dp[i - j - 1] + abs(a[i] - a[i - j - 1]));
}
}
dp[i] = ans;
}
cout << dp[n - 1] << "\n";
}
int main()
{
#ifdef WIN32
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
#ifndef WIN32
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#endif
int t;
t = 1;
for (int I = 1; I <= t; I++)
{
solve();
}
return 0;
}
| 0
| 5,458,179
|
#include <bits/stdc++.h>
using namespace std;
#define MAX 100000
int main() {
int n, a[MAX];
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
int L[MAX], l;
L[0] = a[0];
l = 1;
for (int i = 1; i < n; i++) {
if (L[l - 1] < a[i]) {
L[l++] = a[i];
} else {
*lower_bound(L, L + l, a[i]) = a[i];
}
}
cout << l << endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<vector>
#include<utility>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<bitset>
#include<climits>
#define MOD 1000000007
typedef long long ll;
using namespace std;
struct UnionFind{
vector<int> par;
UnionFind(int N) : par(N){
for(int i=0;i<N;i++) par[i] = i;
}
void init(int N){
for(int i=0;i<N;i++) par[i] = i;
}
int root(int x){
if(par[x] == x) return x;
else return par[x] = root(par[x]);
}
void unite(int x, int y){
int rx = root(x);
int ry = root(y);
if(rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y){
return root(x) == root(y);
}
};
int main(){
int N,M; cin >> N >> M;
int p[100005];
UnionFind px(N+1);
for(int i=1;i<=N;i++) cin >> p[i];
for(int i=1;i<=M;i++){
int a,b; cin >> a >> b;
px.unite(p[a],p[b]);
}
int ans = 0;
for(int i=1;i<=N;i++){
if(px.same(i,p[i])) ans++;
}
cout << ans << endl;
return 0;
}
| 0
| 44,190,015
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (n); ++i)
#define repr(i, a, b) for (auto i = (a); i < (b); ++i)
#define itr(x) for (auto&& v : (x))
#define updatemax(t, v) ((t) = std::max((t), (v)))
#define updatemin(t, v) ((t) = std::min((t), (v)))
ll a[100100];
int main() {
ll n, m;
cin >> n >> m;
rep(i, n) cin >> a[i];
rep(i, n) a[i] /= 2;
ll alcm = 1;
rep(i, n) {
alcm = lcm(alcm, a[i]);
if (alcm > m) {
cout << 0 << endl;
return 0;
}
}
rep(i, n) {
if ((alcm / a[i]) % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
cout << m / alcm - m / (2 * alcm) << endl;
}
|
#include<iostream>
using namespace std;
int main()
{
int h[10];
int i,j;
int temp=0;
for(i=0; i<10; i++)
{
cin>>h[i];
}
for(i=0; i<9; i++)
{
for(j=i+1; j<10; j++)
{
if(h[j]>h[i])
{
temp=h[j];
h[j]=h[i];
h[i]=temp;
}
}
}
for(i=0; i<3; i++)
{
cout<<h[i]<<endl;
}
return 0;
}
| 0
| 94,938,937
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.