code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int N, M; cin >> N >> M;
vector<int> cost(N);
for(int i = 0; i < N; ++i)
cin >> cost[i];
vector<int> score(N, 0);
while(M--) {
int x; cin >> x;
for(int i = 0; i < N; ++i) {
if(cost[i] <= x) {
score[i]++;
break;
}
}
}
int argmax = find(score.begin(), score.end(), *max_element(score.begin(), score.end())) - score.begin();
cout << argmax + 1 << endl;
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<cmath>
#include<cstdio>
#include<tuple>
#include<bitset>
#include<map>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ALL(x) x.begin(),x.end()
using ll = long long;
using lint = long long;
typedef pair<int,int> P;
const lint inf=1e18+7;
const int MOD=1000000007;
struct Node{
int row_no,col_no;
int indegree;
int dist;
vector<Node*> child;
vector<Node*> par;
void build(int i,int j){
row_no=i;col_no=j;indegree=0;
dist=-1;
}
};
vector<pair<int,int>> toposo(vector<vector<Node>> const& node,int n){
vector<P> res;
queue<Node> que;
rep1(i,n){
rep1(j,n){
if(node[i][j].indegree==0){
que.push(node[i][j]);
}
}
}
while(!que.empty()){
Node buf=que.front();que.pop();
int num=buf.child.size();
res.push_back({buf.col_no,buf.row_no});
rep(i,num){
buf.child[i]->indegree-=1;
if(buf.child[i]->indegree==0){
que.push(*buf.child[i]);
}
}
}
return res;
}
void dfs(Node& node){
if(node.dist!=-1){
return;
}
int num=node.par.size();
int res=0;
rep(i,num){
dfs(*node.par[i]);
res=max(res,node.par[i]->dist+1);
}
node.dist=res;
}
signed main(){
int n;cin>>n;
vector<vector<Node>> node(n+1,vector<Node>(n+1));
rep1(i,n){
rep1(j,n)node[i][j].build(i,j);
}
rep1(i,n){
int last=0;
rep(j,n-1){
int a;cin>>a;
if(last==0){
last=a;
continue;
}
int mx=max(i,a);
int mn=min(i,a);
node[mx][mn].par.push_back(&node[max(last,i)][min(last,i)]);
node[mx][mn].indegree+=1;
node[max(last,i)][min(last,i)].child.push_back(&node[mx][mn]);
last=a;
}
}
if(toposo(node,n).size()<n*n){
cout<<-1<<"\n";
return 0;
}
int res=0;
rep1(i,n){
rep1(j,n){
if(j>=i)break;
if(node[i][j].child.size()==0){
dfs(node[i][j]);
res=max(res,node[i][j].dist);
//printf("i,j=%lld,%lld, res=%lld\n",i,j,res);
}
}
}
cout<<res+1<<"\n";
return 0;
}
| 0 |
// 解説見たやつ
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define repeat(i, n) for (int i = 0; (i) < (n); ++(i))
#define repeat_from(i, m, n) for (int i = (m); (i) < (n); ++(i))
using namespace std;
template <class T>
void setmax(T &a, T const &b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T const &b) {
if (a > b) a = b;
}
template <typename T, typename X>
auto vectors(T a, X x) { return vector<T>(x, a); }
template <typename T, typename X, typename Y, typename... Zs>
auto vectors(T a, X x, Y y, Zs... zs) {
auto cont = vectors(a, y, zs...);
return vector<decltype(cont)>(x, cont);
}
int main() {
int h, w;
cin >> h >> w;
map<int, int> s;
multiset<int> vals;
repeat(i, w) s[i] = i;
repeat(i, w) vals.insert(0);
repeat(i, h) {
int l, r;
cin >> l >> r;
--l;
auto it = s.lower_bound(l);
int mr = -1;
while (it != s.end() && it->first <= r) {
setmax(mr, it->second);
int x = it->first - it->second;
vals.erase(vals.find(x));
//https://ox8000ffff.hatenadiary.org/entry/20100225/1267201650
//後置インクリメントはオブジェクトのコピーがeraseの引数になる
s.erase(it++);
}
if (mr != -1 && r < w) {
vals.insert(r - mr);
s[r] = mr;
}
int ans = -1;
if (vals.size() > 0) {
ans = *vals.begin() + (i + 1);
}
cout << ans << endl;
}
} | #include<cstdio>
const int N=1e5+9;
int L[17][N],R[17][N],n,t,q,X[N],ans;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;++i)scanf("%d",X+i);
scanf("%d",&t);
for(int i=1,it=1;i<=n;++i){
while(it<n&&X[it+1]-X[i]<=t)++it;
R[0][i]=it;
}
for(int i=n,it=n;i;--i){
while(it>1&&X[i]-X[it-1]<=t)--it;
L[0][i]=it;
}
for(int i=1;i<17;++i)
for(int j=1;j<=n;++j)
R[i][j]=R[i-1][R[i-1][j]],L[i][j]=L[i-1][L[i-1][j]];
for(scanf("%d",&q);q--;printf("%d\n",ans)){
int x,y;ans=1;
scanf("%d%d",&x,&y);
if(x<=y){
for(int i=16;~i;--i)
if(R[i][x]<y)ans+=1<<i,x=R[i][x];
}else{
for(int i=16;~i;--i)
if(L[i][x]>y)ans+=1<<i,x=L[i][x];
}
}
return 0;
} | 0 |
#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
template<class S, class T> inline S max_L(S a,T b){
return a>=b?a:b;
}
inline int my_getchar_unlocked(){
static char buf[1048576];
static int s = 1048576;
static int e = 1048576;
if(s == e && e == 1048576){
e = fread_unlocked(buf, 1, 1048576, stdin);
s = 0;
}
if(s == e){
return EOF;
}
return buf[s++];
}
inline void rd(int &x){
int k;
int m=0;
x=0;
for(;;){
k = my_getchar_unlocked();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = my_getchar_unlocked();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
struct MY_WRITER{
char buf[1048576];
int s;
int e;
MY_WRITER(){
s = 0;
e = 1048576;
}
~MY_WRITER(){
if(s){
fwrite_unlocked(buf, 1, s, stdout);
}
}
}
;
MY_WRITER MY_WRITER_VAR;
void my_putchar_unlocked(int a){
if(MY_WRITER_VAR.s == MY_WRITER_VAR.e){
fwrite_unlocked(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
MY_WRITER_VAR.s = 0;
}
MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a){
my_putchar_unlocked(a);
}
inline void wt_L(long long x){
int s=0;
int m=0;
char f[20];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
my_putchar_unlocked('-');
}
while(s--){
my_putchar_unlocked(f[s]+'0');
}
}
template<class S, class T> inline S chmax(S &a, T b){
if(a<b){
a=b;
}
return a;
}
int N;
int A[200000];
int main(){
int i;
long long res = 0;
long long mx = -1;
rd(N);
{
int Lj4PdHRW;
for(Lj4PdHRW=(0);Lj4PdHRW<(N);Lj4PdHRW++){
rd(A[Lj4PdHRW]);
}
}
for(i=(0);i<(N);i++){
res +=max_L(mx - A[i], 0);
chmax(mx, A[i]);
}
wt_L(res);
wt_L('\n');
return 0;
}
// cLay varsion 20200911-1
// --- original code ---
// int N, A[2d5];
// {
// ll res = 0, mx = -1;
// rd(N,A(N));
// rep(i,N){
// res += max(mx - A[i], 0);
// mx >?= A[i];
// }
// wt(res);
// }
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MN = 1e5+5;
ll N, M, i, x, y, f, val[MN], c1, c2, ans, sz;
vector<ll> adj[MN];
void dfs(int n){
for(auto v : adj[n]){
if(val[v]==-1) val[v]=!val[n], dfs(v);
else if(val[v]==val[n]) f=1;
}
}
int main(){
for(scanf("%lld%lld",&N,&M),i=1;i<=M;i++){
scanf("%lld%lld",&x,&y);
adj[x].push_back(y);
adj[y].push_back(x);
}
memset(val,-1,sizeof(val));
for(i=1;i<=N;i++){
if(adj[i].size()) sz++;
if(val[i]!=-1||adj[i].empty()) continue;
f=0; val[i]=0; dfs(i);
if(!f) ans+=2*(c1+2*c2)+2, c2++;
else ans+=2*(c1+c2)+1, c1++;
}
ans += N*N-sz*sz;
printf("%lld\n",ans);
return 0;
}
| 0 |
#include<iostream>
int cnt[100005];
const long long mod = 998244353;
int max_val = 0;
long long ans = 1;
long long mpow(int a, int b) {
if (!a) return 0LL;
if (!b) return 1LL;
return b%2 ? (long long)a * mpow(a, b-1) % mod : mpow((long long)a*a%mod, b/2);
}
int main(void) {
int n;
std::cin >> n;
for (int i = 0; i < n; ++i) {
int d;
std::cin >> d;
if (d > max_val) max_val = d;
if (!i && d || i && !d) {
std::cout << 0 << '\n';
return 0;
}
cnt[d]++;
}
for (int i = 2; i <= max_val; i++) {
ans = (ans * mpow(cnt[i-1], cnt[i])) % mod;
}
std::cout << ans << '\n';
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define arep(i,x,n) for(long long i=int(x);i<(int)(n);i++)
#define rep(i,n) for(long long i = 0;i < n;++i)
#define rrep(i,n) for(long long i=int(n);i>0;i--)
#define fs first
#define sc second
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9+5
using ll = long long;
using P=pair<int,int>;
using lP=pair<ll,ll>;
using fP=pair<double,double>;
using PPI=pair<P,int>;
//ll const mod=998244353;
ll const mod=1e9+7;
const ll MAX=1000005;
using vi=vector<int>;
using vl=vector<ll>;
using vc=vector<char>;
using vd=vector<double>;
using vs=vector<string>;
using vp=vector<P>;
using vb=vector<bool>;
using vvi =vector<vector<int>>;
using vvl =vector<vector<ll>>;
using vvd=vector<vector<double>>;
using vvc=vector<vector<char>>;
using vvp =vector<vector<P>>;
using vvb=vector<vector<bool>>;
template <typename T>
bool chmax(T &a, const T b){if(a < b){a = b; return true;} return false;}
template <typename T>
bool chmin(T &a, const T b){if(a > b){a = b; return true;} return false;}
int main(){
int n;
cin>>n;
vi a(n);
rep(i,n)cin>>a[i];
reverse(all(a));
ll ans=a[0];
bool ok=true;
arep(i,1,n){
if(a[i]==a[i-1]-1)continue;
else if(a[i]<a[i-1]-1)ok=false;
ans+=a[i];
}
if(a[n-1]!=0)ok=false;
if(ok)cout<<ans<<endl;
else cout<<-1<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(a) a.begin(), a.end()
#define rep(i, st, n) for (int i = (st); i < (n); ++i)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;
template <typename T1, typename T2> bool chkmin(T1 &x, T2 y) { return y < x ? (x = y, true) : false; }
template <typename T1, typename T2> bool chkmax(T1 &x, T2 y) { return y > x ? (x = y, true) : false; }
const int MOD = 1e9 + 7;
int add(int x, int y)
{
x += y;
if (x >= MOD) x -= MOD;
return x;
}
int sub(int x, int y)
{
x -= y;
if (x < 0) x += MOD;
return x;
}
int mult(int x, int y)
{
return x * (ll)y % MOD;
}
int bpow(int x, ll y)
{
int res = 1;
for (; y; y >>= 1)
{
if (y & 1)
{
res = mult(res, x);
}
x = mult(x, x);
}
return res;
}
int rev(int x)
{
return bpow(x, MOD - 2);
}
const int N = 300005;
int fact[N], rfact[N];
int cnk(int n, int k)
{
if (k > n)
return 0;
return mult(fact[n], mult(rfact[k], rfact[n - k]));
}
int grid(int n, int m)
{
return cnk(n - 1 + m - 1, n - 1);
}
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0);
#ifdef DEBUG
freopen("in", "r", stdin);
#endif
fact[0] = rfact[0] = fact[1] = rfact[1] = 1;
for (int i = 2; i < N; ++i)
{
fact[i] = mult(fact[i - 1], i);
rfact[i] = rev(fact[i]);
}
int H, W, A, B;
cin >> H >> W >> A >> B;
int sum = 0;
for (int i = 0; i < H - A; ++i)
{
sum = add(sum, mult(grid(B, i + 1), grid(H - i, W - B)));
}
cout << sum << '\n';
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const long long mod=1e9+7,INF=1e18;
#define ll long long
#define pll pair<ll,ll>
#define pii pair<int,int>
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
ll modInv(ll a)
{
ll res=1;
ll b=mod-2;
while(b)
{
if(b&1)
res=(res*a)%mod;
a=(a*a)%mod;
b>>=1;
}
return res;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t=1;
vector<ll> fac(200020,1),facInv(200020,1);
for(int i=2;i<=200010;i++)
{
fac[i]=(i*fac[i-1])%mod;
facInv[i]=modInv(fac[i]);
}
// cin>>t;
while(t--)
{
ll h,w,a,b;
cin>>h>>w>>a>>b;
ll ans=0,ans2=0;
ans2=fac[h+w-2];
ans2=(ans2*facInv[h-1])%mod;
ans2=(ans2*facInv[w-1])%mod;
for(int i=1;i<=a;i++)
{
ll res=1,res2=1;
res2=fac[a-i+w-b-1];
res2=(res2*facInv[a-i])%mod;
res2=(res2*facInv[w-b-1])%mod;
res=fac[h-a+i+b-2];
res=(res*facInv[h-a+i-1])%mod;
res=(res*facInv[b-1])%mod;
res=(res*res2)%mod;
// cout<<res<<" ";
ans=(ans+res)%mod;
}
ans=((ans2-ans)%mod+mod)%mod;
cout<<ans<<"\n";
}
return 0;
} | 1 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <sstream>
#include <string>
#include <utility>
#include <map>
#include <memory>
#include <set>
#include <vector>
#include <deque>
#include <list>
#include <stack>
#include <queue>
using namespace std;
struct Node
{
Node *parent;
Node *left;
Node *right;
int key;
};
class BStree
{
public:
Node *root;
Node *nil;
int solve();
int print();
int insert( Node *z );
int preorder( Node *nd );
int inorder( Node *nd );
Node* find( int k );
Node* next( Node *nd );
int delete_node( Node *nd );
};
int BStree::solve()
{
int n;
cin >> n;
string com;
int d;
Node *nd;
for ( auto i = 0; i < n; ++i )
{
cin >> com;
if ( com == "print" )
print();
else if ( com == "insert" )
{
cin >> d;
nd = new Node;
nd->key = d;
nd->parent = nil;
nd->left = nil;
nd->right = nil;
insert( nd );
}
else if ( com == "find" )
{
cin >> d;
if ( find( d ) == nil )
cout << "no" << endl;
else
cout << "yes" << endl;
}
else
{
cin >> d;
Node *x = find( d );
if ( x != nil )
{
delete_node( x );
}
}
}
return 0;
}
int BStree::print()
{
inorder( root );
cout << endl;
preorder( root );
cout << endl;
return 0;
}
int BStree::insert( Node *z )
{
Node *y = nil;
Node *x = root;
while ( x != nil )
{
y = x;
if ( z->key < x->key )
x = x->left;
else
x = x->right;
}
z->parent = y;
if ( y == nil )
root = z;
else if ( z->key < y->key )
y->left = z;
else
y->right = z;
return 0;
}
Node* BStree::find( int k )
{
Node *x;
x = root;
while ( x != nil )
{
if ( x->key == k )
return x;
else if ( x->key > k )
x = x->left;
else
x = x->right;
}
return x;
}
Node* BStree::next( Node *nd )
{
Node *x;
x = nd->right;
while ( x->left != nil )
{
x = x->left;
}
return x;
}
int BStree::delete_node( Node *nd )
{
if ( nd == nil )
return 0;
if ( nd->left == nil && nd->right == nil )
{
if ( nd->parent->left == nd )
nd->parent->left = nil;
else
nd->parent->right = nil;
delete nd;
}
else if ( nd->left == nil )
{
if ( nd->parent->left == nd )
nd->parent->left = nd->right;
else
nd->parent->right = nd->right;
nd->right->parent = nd->parent;
delete nd;
}
else if ( nd->right == nil )
{
if ( nd->parent->left == nd )
nd->parent->left = nd->left;
else
nd->parent->right = nd->left;
nd->left->parent = nd->parent;
delete nd;
}
else
{
Node *x = next( nd );
nd->key = x->key;
delete_node( x );
}
return 0;
}
int BStree::preorder( Node *nd )
{
if ( nd == nil )
return 0;
cout << " " << nd->key;
preorder( nd->left );
preorder( nd->right );
return 0;
}
int BStree::inorder( Node *nd )
{
if ( nd == nil )
return 0;
inorder( nd->left );
cout << " " << nd->key;
inorder( nd->right );
return 0;
}
int main()
{
BStree b;
b.nil = new Node;
b.nil->parent = b.nil;
b.nil->left = b.nil;
b.nil->right = b.nil;
b.nil->key = -1;
b.root = b.nil;
b.solve();
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for(i=0;i<n;i++)
#define NIL -1
using namespace std;
typedef struct{
int key;
int right;
int left;
int parent;
}node;
void insert(vector<node> &T, int i, int *root) {
int x=*root, y = NIL;
while(x != NIL){
y = x;
T[i].key<T[x].key?x=T[x].left:x=T[x].right;
}
T[i].parent = y;
if(y == NIL) *root = i;
else if(T[i].key < T[y].key) T[y].left = i;
else T[y].right = i;
}
void inorder(vector<node> &T, int i){
if(T[i].left != NIL)
inorder(T,T[i].left);
cout << " " << T[i].key;
if(T[i].right != NIL)
inorder(T,T[i].right);
}
void preorder(vector<node> &T, int i){
cout << " " << T[i].key;
if(T[i].left != NIL)
preorder(T,T[i].left);
if(T[i].right != NIL)
preorder(T,T[i].right);
}
int find(vector<node> &T, int i, int k) {
int result = NIL;
if(T[i].key == k) return i;
else if(T[i].key > k) {
if(T[i].left != NIL)
result = find(T,T[i].left,k);
} else if(T[i].key < k) {
if(T[i].right != NIL)
result = find(T,T[i].right,k);
}
return result;
}
int minimum(vector<node> &T,int a){
while(T[a].left != NIL) a = T[a].left;
return a;
}
int successor(vector<node> &T, int z){
int x = T[z].parent,y;
if(T[z].right != NIL) return minimum(T,T[z].right);
while(1) {
if(x != NIL && T[x].right == z) break;
y = x;
x = T[x].parent;
}
return x;
}
void erase(vector<node> &T, int *root, int z){
int x,y;
T[z].left==NIL||T[z].right==NIL?y = z:y = successor(T,z);
T[y].left!=NIL?x=T[y].left:x=T[y].right;
if(x != NIL) T[x].parent = T[y].parent;
if(T[y].parent == NIL) *root=x;
else if(y == T[T[y].parent].left) T[T[y].parent].left = x;
else T[T[y].parent].right = x;
if(y!=z) T[z].key = T[y].key;
T[y].parent = NIL;
T[y].left = NIL;
T[y].right = NIL;
T[y].key = 0;
}
int main(void) {
int judge,n,i,x,root=NIL;
string od;
vector<node> T;
cin >> n;
T.resize(n);
rep(i,n) {
T[i].key = 0;
T[i].right = NIL;
T[i].left = NIL;
T[i].parent = NIL;
}
rep(i,n){
cin >> od;
if(od == "insert"){
cin >> T[i].key;
insert(T,i,&root);
} else if(od == "print") {
inorder(T,root);
cout << endl;
preorder(T,root);
cout << endl;
} else if(od == "find") {
cin >> x;
judge = find(T,root,x);
if(judge != NIL) cout << "yes";
else cout << "no";
cout << endl;
} else if(od == "delete"){
cin >> x;
judge = find(T,root,x);
if(judge != NIL) erase(T,&root,judge);
}
}
return 0;
} | 1 |
#include <stdio.h>
#include<math.h>
#include <algorithm>
using namespace std;
int main(){
int subA[4],subB[2];
for(int i=0; i < 4; i++)scanf("%d",&subA[i]);
for(int i=0; i < 2; i++)scanf("%d",&subB[i]);
for(int i = 1; i <= 3; i++){
for(int k = 3; k >= i; k--){
if(subA[k] > subA[k-1]){
swap(subA[k],subA[k-1]);
}
}
}
if(subB[1] > subB[0])swap(subB[1],subB[0]);
printf("%d\n",subA[0]+subA[1]+subA[2]+subB[0]);
return 0;
} | #include <iostream>
#include <deque>
#include <stdio.h>
#include <string>
#include <vector>
#include <algorithm>
#include <limits.h>
using namespace std;
int n;
int ans=0;
typedef vector<int> vi;
int main()
{
vi a(4,0);
vi b(2,0);
cin >> a[0] >> a[1] >> a[2] >> a[3];
cin >> b[0] >> b[1];
sort(a.begin(),a.end(),greater<int>());
sort(b.begin(),b.end(),greater<int>());
int ans=0;
for(int i=0;i<3;i++)
{
ans+=a[i];
}
ans+=b[0];
cout << ans << endl;
return 0;
}
| 1 |
#include<cstdio>
#include<algorithm>
using namespace std;
int main(){
while(1){
int n,m;
scanf("%d%d",&n,&m);
if(n == 0 && m == 0) break;
int a[1001] = {0};
for(int i = 1; i <= n; i++){
scanf("%d",&a[i]);
}
sort(a+1,a+n+1);
reverse(a+1,a+n+1);
int sum = 0;
for(int i = 1; i <= n; i++){
if(i % m == 0)continue;
sum += a[i];
}
printf("%d\n",sum);
}
return 0;
} | #include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int do_stuff(int n)
{
vector<int> a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
int max_so_far = 0;
int max_ending_here = 0;
for (int i = 0; i < n; ++i) {
int curr = a[i];
max_ending_here = max(max_ending_here + curr, 0);
max_so_far = max(max_so_far, max_ending_here);
}
if (max_so_far == 0) {
max_so_far = *max_element(a.begin(), a.end());
}
return max_so_far;
}
int main(int argc, char* argv[])
{
//freopen("input.txt", "r", stdin);
int n;
scanf("%d", &n);
while (n != 0) {
int ans = do_stuff(n);
printf("%d\n", ans);
scanf("%d", &n);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double R;
double G;
cin >> R >> G;
double performance = 2 * G -R;
cout << performance << endl;
} | #include <iostream>
#include <vector>
using namespace std;
const int MAX = 1e6 + 100;
long long gcd(long long a, long long b) {
if (b == 0) return a;
else return gcd(b, a % b);
}
int main(){
long long a, b;
cin >> a >> b;
long long GCD = gcd(a, b);
vector<bool> primes(MAX, true);
primes[0] = primes[1] = false;
int ans = 1;
for (int i = 2; i < MAX; ++i) {
if (!primes[i]) continue;
for (int j = 2 * i; j < MAX; j += i) {
primes[j] = false;
}
if (GCD % i) continue;
while (GCD % i == 0) GCD /= i;
ans++;
}
if (GCD != 1) ans++;
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(n) begin(n), end(n)
using ll = long long;
using namespace std;
struct node{
int data;
node *l, *r;
};
node *new_node(int in){
node *ret = new node;
ret->data = in;
ret->l = NULL;
ret->r = NULL;
return ret;
}
void insert_node(node **root, int in){
node *add = new_node(in);
if(*root == NULL){
*root = add;
return ;
}
node *p = *root, *pp = NULL;
while(p != NULL){
pp = p;
if(add->data < p->data) p = p->l;
else p = p->r;
}
if(add->data < pp->data) pp->l = add;
else pp->r = add;
return ;
}
void print_n(node *root, bool mode){
if(mode == true) cout << " " << root->data;
if(root->l != NULL) print_n(root->l, mode);
if(mode == false) cout << " " << root->data;
if(root->r != NULL) print_n(root->r, mode);
}
void print_node(node *root){
print_n(root, false);
cout << endl;
print_n(root, true);
cout << endl;
}
void find_node(node *root, int in){
bool ans = false;
while(root != NULL){
if(in == root->data){
ans = true;
break;
}else if(in < root->data){
root = root->l;
}else{
root = root->r;
}
}
if(ans == false) cout << "no" << endl;
else cout << "yes" << endl;
}
void delete_node(node **root, int in){
node *p = *root, *pp = NULL;
while(p != NULL){
if(p->data == in) break;
pp = p;
if(in < p->data) p = p->l;
else p = p->r;
}
if(p->l == NULL && p->r == NULL){
if(in < pp->data) pp->l = NULL;
else pp->r = NULL;
delete p;
return ;
}
if(p->l == NULL){
if(in < pp->data) pp->l = p->r;
else pp->r = p->r;
delete p;
return;
}
if(p->r == NULL){
if(in < pp->data) pp->l = p->l;
else pp->r = p->l;
delete p;
return;
}
node *rl = p->r, *prl = p;
while(rl->l != NULL){
prl = rl;
rl = rl->l;
}
if(in < pp->data) pp->l = rl;
else pp->r = rl;
if(prl != p)prl->l = rl->r;
else prl->r = rl->r;
rl->l = p->l;
rl->r = p->r;
delete p;
}
int main(){
int n;
cin >> n;
node *root = NULL;
rep(i, n){
string s;
cin >> s;
if(s == "print"){
print_node(root);
}else if(s == "find"){
int in;
cin >> in;
find_node(root, in);
}else if(s == "delete"){
int in;
cin >> in;
delete_node(&root, in);
}else{
int in;
cin >> in;
insert_node(&root, in);
}
}
return 0;
}
| #include <iostream>
#include <bits/stdc++.h>
#define MAX_SIZE 500010
#define INFTY 2000000000
using namespace std;
struct Node {
int key;
Node *parent, *left, *right;
};
Node *root, *NIL;
void insert(int k) {
Node *z = (Node *)malloc(sizeof(Node));
z->key = k;
z->left = NIL;
z->right = NIL;
Node *y = NIL;
Node *x = root;
while (x != NIL) {
y = x;
if (z->key < x->key) x = x->left;
else x = x->right;
}
z->parent = y;
if (y == NIL) root = z;
else if (z->key < y->key) y->left = z;
else y->right = z;
}
Node *find(int k) {
Node *x = root;
while (x != NIL && k != x->key) {
if (k < x->key) x = x->left;
else x = x->right;
}
return x;
}
void replace(Node *x, Node *y, Node *z) {
}
Node *getMInimum(Node *x) {
while (x->left != NIL) x = x->left;
return x;
}
Node *getSuccessor(Node *x) {
if (x->right != NIL) return getMInimum(x->right);
Node *y = x->parent;
while (y != NIL && x == y->right) {
x = y;
y = x->parent;
}
return y;
}
void deleteNode(Node *z) {
Node *x, *y;
if (z->left != NIL && z->right != NIL) y = getSuccessor(z);
else y = z;
if (y->left != NIL) x = y->left;
else x = y->right;
if (x != NIL) x->parent = y->parent;
if (y->parent == NIL) root = x;
else if (y->parent->left == y) y->parent->left = x;
else y->parent->right = x;
if (y != z) z->key = y->key;
free(y);
}
void findPrint(int k) {
if (find(k) == NIL) printf("no\n");
else printf("yes\n");
}
void preorder(Node* u) {
if (u == NIL) return;
printf(" %d", u->key);
preorder(u->left);
preorder(u->right);
}
void inorder(Node* u) {
if (u == NIL) return;
inorder(u->left);
printf(" %d", u->key);
inorder(u->right);
}
void postorder(Node* u) {
if (u == NIL) return;
postorder(u->left);
postorder(u->right);
printf(" %d", u->key);
}
void print() {
inorder(root);
printf("\n");
preorder(root);
printf("\n");
}
int main(){
int n, k;
char cmd[10];
root = NIL;
cin >> n;
for (int i=0; i < n; i++) {
scanf("%s%d\n", cmd, &k);
// cout << cmd << k << endl;
if (cmd[0] == 'i') insert(k);
else if (cmd[0] == 'f') findPrint(k);
else if (cmd[0] == 'd') deleteNode(find(k));
else if (cmd[0] == 'p') print();
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int r,g;
cin>>r>>g;
cout<<g-r+g<<'\n';
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(void) {
int first_rate, goal, second_rate;
cin >> first_rate >> goal;
second_rate = 2 * goal - first_rate;
cout << second_rate << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll,ll>
#define FOR(I,A,B) for(ll I = int(A); I < int(B); ++I)
#define FORR(I,A,B) for(ll I = int((B)-1); I >= int(A); --I)
#define TO(x,t,f) ((x)?(t):(f))
#define SORT(x) (sort(x.begin(),x.end())) // 0 2 2 3 4 5 8 9
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin()) //xi>=v x is sorted
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin()) //xi>v x is sorted
#define NUM(x,v) (POSU(x,v)-POSL(x,v)) //x is sorted
#define REV(x) (reverse(x.begin(),x.end())) //reverse
ll gcd(ll a,ll b){if(a<b)swap(a,b);if(a%b==0)return b;return gcd(b,a%b);}
ll lcm(ll a,ll b){ll c=gcd(a,b);return ((a/c)*(b/c)*c);}//saisyo kobaisu
#define NEXTP(x) next_permutation(x.begin(),x.end())
const ll INF=1e18+7;
const ll MOD=1e9+7;
int main(){
ll N,X;
cin >> N >> X;
vector<ll> S(N);
FOR(i,0,N)cin>>S[i];
SORT(S);
REV(S);
ll dp[N+2][X+1]={};
dp[0][X]=1;
FOR(i,0,N){
FOR(j,0,X+1){
(dp[i+1][j%S[i]] += dp[i][j])%=MOD;
(dp[i+1][j] += dp[i][j]*(N-i-1))%=MOD;
}
}
ll ans = 0;
FOR(j,1,X+1){
(ans += dp[N][j]*j)%=MOD;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int solve(vector<int> v)
{
int n=v.size();
vector<int> l(n,-1);
stack<array<int,2>> s;
s.push({-1,-1});
for(int i=0;i<n;i++)
{
while(s.top()[0]>=v[i]) s.pop();
l[i]=s.top()[1];
s.push({v[i],i});
}
vector<int> r(n,n);
while(!s.empty()) s.pop();
s.push({-1,n});
for(int i=n-1;i>=0;i--)
{
while(s.top()[0]>=v[i]) s.pop();
r[i]=s.top()[1];
s.push({v[i],i});
}
int res=0;
for(int i=0;i<n;i++) res=max(res,(v[i]+1)*(r[i]-l[i]));
return res;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int h,w;
cin >> h >> w;
vector<string> s(h);
for(int i=0;i<h;i++) cin >> s[i];
vector<vector<int>> sum(h-1,vector<int>(w-1,0));
for(int i=0;i<h-1;i++) for(int j=0;j<w-1;j++) sum[i][j]=((((s[i][j]=='#')^(s[i][j+1]=='#')^(s[i+1][j]=='#')^(s[i+1][j+1]=='#'))%2)==0);
int res=max({h,w,solve(sum[h-2])});
for(int i=h-3;i>=0;i--)
{
for(int j=0;j<w-1;j++) if(sum[i][j]==1) sum[i][j]+=sum[i+1][j];
res=max(res,solve(sum[i]));
}
cout << res << "\n";
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <stack>
#include <cstring>
#include <cmath>
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, n) for(int i = 0; i < (n); i++)
#define MP make_pair
#define X first
#define Y second
#define all(v) v.begin(), v.end()
#define rev(v) v.rbegin(), v.rend()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> P;
const int INF = 1<<29;
int gcd(int m, int n){
return (n==0?m:gcd(n, m%n));
}
int main(){
int n, a, b;
cin >> n >> a;
rep(i, n-1){
cin >> b;
a = gcd(a, b);
}
vector<int> ans;
FOR(i, 1, sqrt(1.*a)+1){
if(a%i == 0){
ans.push_back(i);
ans.push_back(a/i);
}
}
sort(all(ans));
ans.erase(unique(all(ans)), ans.end());
rep(i, ans.size()){
cout << ans[i] << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define RFOR(i,a,b) for(int i=(b) - 1;i>=(a);i--)
#define REP(i,n) for(int i=0;i<(n);i++)
#define RREP(i,n) for(int i=n-1;i>=0;i--)
#define PB push_back
#define INF (1<<29)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define CLR(a) memset(a,0,sizeof(a))
const int dx[] = {-1,0,0,1},dy[] = {0,1,-1,0};
typedef long long int ll;
using namespace std;
int main(){
int n,m,l;
cin >> n;
if(n == 2){
cin >> n >> m;
if(n < m) swap(n,m);
FOR(i,1,n+1){
if(n % i == 0 && m % i == 0){
printf("%d\n",i);
}
}
}else{
cin >> n >> m >> l;
if(n < m) swap(n,m);
if(n < l) swap(n,l);
FOR(i,1,n+1){
if(n % i == 0 && m % i == 0 && l % i == 0){
printf("%d\n",i);
}
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
string s;
cin >> n >> s;
int a[100009];
for(int b: {0, 1}){
for(int c: {0, 1}){
a[1] = b;
a[2] = c;
a[0] = (s[1]=='o'?1:0)^b^c;
for(int i=3;i<n;i++){
a[i] = (s[i-1]=='o'?1:0)^a[i-1]^a[i-2];
}
if((s[n-1]=='o'?1:0)^a[n-1]==a[0]^a[n-2] && (s[0]=='o'?1:0)^a[0]==a[n-1]^a[1]){
for(int i=0;i<n;i++){
cout << (a[i]==1?'S':'W');
}
cout << endl;
return 0;
}
}
}
cout << -1 << endl;
}
| #include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < (n); i++)
#define REP1(i, n) for(int i = 1; i <= (n); i++)
#define REPD(i,a,b) for (int i=(a);i<(b);i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef set<int> si;
typedef vector<si> vsi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<int, int> pi;
typedef queue<int> qi;
typedef queue<pi> qpi;
typedef pair<ll, ll> pll;
typedef queue<pll> qpll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
const int mod = 1000000007;
const int INF = 1001001001;
// 小数点 << fixed << setprecision(0) <<
// sort降順 sort(ALL(),greater<int>());
// 円周率 M_PI
// 文字判定 isupper islower
// 文字変換
// 順列 do {} while(next_permutation(ALL(X)));
// 最大値 LLONG_MAX
// a内でx以上 auto iter = lower_bound(ALL(a), x);
// a内でxより大きい auto iter = upper_bound(ALL(a), x);
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
struct edge {
int from; //出発点
int to; //到達点
int cost; //移動コスト
};
typedef struct edge se;
typedef vector<edge> ve;
unsigned Euclidean_gcd(unsigned a, unsigned b) {
if(a < b) return Euclidean_gcd(b, a);
unsigned r;
while ((r=a%b)) {
a = b;
b = r;
}
return b;
}
vpll PrimeFactorization(ll n) {
vpll res;
for (ll i=2; i*i<=n; i++) {
if(n%i!=0) continue;
ll ex=0;
while(n%i==0) {
ex++;
n/=i;
}
res.push_back(pll(i,ex));
}
if(n!=1) res.push_back(pll(n,1));
return res;
}
int main() {
int n;
cin >> n;
char s[n];
cin >> s;
int mi=0;
REP(i,n) {
if(i>0&&s[i]=='E') {
mi++;
}
}
int temp=mi;
REP(i,n-1) {
if(s[i]=='W') temp++;
if(s[i+1]=='E') temp--;
mi=min(mi,temp);
}
cout << mi << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define fr(i,k) for(i=0;i<k;i++)
#define deb(x) cerr<<#x<<" = "<<x<<endl;
#define deb2(x,y) cerr<<#x<<" ="<<x<<endl<<#y<<" ="<<y<<endl;
#define SZ(x) (x).size();
#define ll long long
#define mod 1000000007
#define ff first
#define ss second
#define pb push_back
#define em emplace_back
#define ulli unsigned long long int
#define inf 1e18
#define endl "\n"
typedef vector<vector<ll>> vvll;
typedef vector<ll> vll;
typedef vector<pair<ll, ll>> vpll;
typedef pair<ll, ll> pll;
typedef vector<bool> vb;
void solve();
int main() {
fastio;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll t;
t = 1;
//cin >> t;
while (t--)
{
solve();
}
return 0;
}
ll dp[10001][101][2];
ll calc(string &k, ll pos, ll D, ll d, ll tight)
{
if (dp[pos][d][tight] != -1)
return dp[pos][d][tight];
ll ub = tight ? (k[pos] - '0') : 9;
if (pos == k.length() - 1)
{
ll ans = 0;
for (ll x = 0; x <= ub; x++)
{
if (x % D == d)
ans++;
}
return ans;
}
ll ans = 0;
for (ll x = 0; x <= ub; x++)
{
ans = (ans + calc(k, pos + 1, D, (D + d - x % D) % D, tight && (x == ub))) % mod;
}
return dp[pos][d][tight] = ans;
}
inline void solve()
{
ll D, i;
string k;
cin >> k >> D;
memset(dp, -1, sizeof dp);
cout << (mod + calc(k, 0, D, 0, 1) - 1) % mod << endl;
}
| /*
-ensure correct output format
-ensure printing required output
-reread the problem statement
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll>pll;
typedef pair<ll,pair<ll,ll>>plll;
#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));
#define vll(v) v.begin(),v.end()
#define all(x) x.rbegin(),x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int,vector<int>,greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))
#define bug cout<<"BUG"<<endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI =3.141592653589793238463;
bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.first > b.first);
}
ll lcm(ll a,ll b)
{
if(a==0 || b==0)return 0;
return a/__gcd(a,b)*b;
}
void input(ll ara[],ll n)
{
for(ll i=0; i<n; i++)cin>>ara[i];
}
void print(ll ara[],ll n)
{
for(ll i=0; i<n; i++)
cout<<ara[i]<<" ";
cout<<endl;
}
int main()
{
fastread();
ll i,j,n,m,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r,ans=0;
bool flag=false;
string str,ptr;
cin>>a>>b;
if(b==1)
{
cout<<0<<endl;
return 0;
}
a--;
b--;
n=b/a;
if(b%a)n++;
cout<<n<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef pair<ll,ll> l_l;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
#define pb push_back
#define sz(x) (int)(x).size()
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
const int INF=1001001000;
const int mINF=-1001001000;
const ll LINF=1010010010010010000;
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;
}
//グリッド：（典型）dp,dfs,bfs,最短経路,その他
string s[8];
int ng[8][8];
bool flg;
void dfs(int r){
if(r==8){
flg=1;
return;
}
for(int c=0;c<8;c++){
if(s[r][c]=='Q'){
dfs(r+1);
return;
}
}
for(int c=0;c<8;c++){
if(ng[r][c])continue;
s[r][c]='Q';
for(int j=0;j<8;j++){
if(r+j<8)ng[r+j][c]++;
if(r-j>=0)ng[r-j][c]++;
if(c+j<8)ng[r][c+j]++;
if(c-j>=0)ng[r][c-j]++;
if(r+j<8&&c+j<8)ng[r+j][c+j]++;
if(r+j<8&&c-j>=0)ng[r+j][c-j]++;
if(r-j>=0&&c+j<8)ng[r-j][c+j]++;
if(r-j>=0&&c-j>=0)ng[r-j][c-j]++;
}
dfs(r+1);
if(flg)return;
s[r][c]='.';
for(int j=0;j<8;j++){
if(r+j<8)ng[r+j][c]--;
if(r-j>=0)ng[r-j][c]--;
if(c+j<8)ng[r][c+j]--;
if(c-j>=0)ng[r][c-j]--;
if(r+j<8&&c+j<8)ng[r+j][c+j]--;
if(r+j<8&&c-j>=0)ng[r+j][c-j]--;
if(r-j>=0&&c+j<8)ng[r-j][c+j]--;
if(r-j>=0&&c-j>=0)ng[r-j][c-j]--;
}
}
}
int main(){
rep(i,8)s[i]=string(8,'.');
int n;cin>>n;
memset(ng,0,sizeof(ng));
for(int i=0;i<n;i++){
int r,c;cin>>r>>c;
s[r][c]='Q';
for(int j=0;j<8;j++){
if(r+j<8)ng[r+j][c]++;
if(r-j>=0)ng[r-j][c]++;
if(c+j<8)ng[r][c+j]++;
if(c-j>=0)ng[r][c-j]++;
if(r+j<8&&c+j<8)ng[r+j][c+j]++;
if(r+j<8&&c-j>=0)ng[r+j][c-j]++;
if(r-j>=0&&c+j<8)ng[r-j][c+j]++;
if(r-j>=0&&c-j>=0)ng[r-j][c-j]++;
}
}
flg=0;
dfs(0);
rep(i,8)cout<<s[i]<<endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#define int long long
#define dotimes(i, n) for (int i : range(n))
using namespace std;
class range {
class iterator {
int i, s;
public:
iterator(int i, int s): i(i), s(s) {}
int& operator*() {
return i;
}
void operator++() {
i += s;
}
bool operator!=(iterator const& that) {
return i < that.i;
}
};
iterator b, e;
public:
range(int e): b({0, 1}), e({e, 1}) {}
range(int b, int e): b({b, 1}), e({e, 1}) {}
range(int b, int e, int s): b({b, s}), e({e, s}) {}
iterator begin() {
return b;
}
iterator end() {
return e;
}
};
int rint() {
int n;
scanf("%lld", &n);
return n;
}
void wint(int n) {
printf("%lld\n", n);
}
template<typename T>
inline int size(T container) {
return static_cast<int>(container.size());
}
template<typename T>
inline bool maxs(T& a, T const& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template<typename T>
inline bool mins(T& a, T const& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
signed main() {
const int k = rint();
int rf[8] = {}, p[8 - k];
bool cf[8] = {};
dotimes(i, k) {
int r = rint();
int c = rint();
rf[r] = c + 1;
cf[c] = true;
}
for (int i = 0, j = 0, c = 0; i < 8; i++)
if (!rf[i]) {
while (cf[c])
c++;
p[j++] = ++c;
}
int a[8];
for (;; next_permutation(p, p + 8 - k)) {
for (int i = 0, j = 0; i < 8; i++)
a[i] = rf[i] ? rf[i] : p[j++];
dotimes(i, 8)
dotimes(j, i)
if (abs(a[j] - a[i]) == abs(j - i))
goto failed;
break;
failed:
;
}
dotimes(i, 8) {
dotimes(j, 8)
putchar(a[i] == j + 1 ? 'Q' : '.');
putchar('\n');
}
return 0;
}
| 1 |
#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <utility>
#include <numeric>
using namespace std;
const int INF = 2E9;
const uint64_t MOD = 1E9 + 7;
int partition(vector<int> &a)
{
int x = a.back();
int id = -1;
for (int i = 0; i < a.size() - 1; i++)
{
if (a.at(i) <= x)
{
id++;
swap(a.at(i), a.at(id));
}
}
swap(a.at(id + 1), a.back());
return id + 1;
}
int main()
{
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
{
cin >> a.at(i);
}
int p = partition(a);
for (int i = 0; i < n; i++)
{
cout << (i == 0 ? "" : " ");
if (i == p)
{
cout << "[" << a.at(i) << "]";
}
else
{
cout << a.at(i);
}
}
cout << endl;
}
| #include <bits/stdc++.h>
using namespace std;
struct StQuery
{
StQuery() : m_nLeft(0), m_nRigt(0) { }
int m_nLeft;
int m_nRigt;
};
void input(string& rsStr, vector<StQuery>& rvoQuery)
{
int nStrSiz, nQuerySiz;
cin >> nStrSiz >> nQuerySiz;
rvoQuery.resize(nQuerySiz);
cin >> rsStr;
for (StQuery& roQuery : rvoQuery)
cin >> roQuery.m_nLeft >> roQuery.m_nRigt;
}
void calcSubStrACCnt(string sStr, const vector<StQuery>& cnrvoQuery)
{
vector<int> vnCumlSum(sStr.size() + 1); // 累積和
//vnCumlSum_ix 0 1 2 3 4 5 6 7 8
//sStr_pos 1 2 3 4 5 6 7 8
//sStr A C A C T A C G
//sStr_ix 0 1 2 3 4 5 6 7
for (int nBgn = 0; nBgn < vnCumlSum.size() - 1; nBgn++)
{
vnCumlSum[ nBgn + 2 ] = vnCumlSum[ nBgn + 1 ];
if (sStr[nBgn] == 'A' && sStr[nBgn + 1] == 'C')
vnCumlSum[ nBgn + 2 ]++;
}
for (int i = 0; i < cnrvoQuery.size(); i++)
{
cout << vnCumlSum[ cnrvoQuery[i].m_nRigt ] - vnCumlSum[ cnrvoQuery[i].m_nLeft ];
cout << endl;
}
}
int main()
{
string sStr;
vector<StQuery> voQuery;
input(sStr, voQuery);
calcSubStrACCnt(sStr, voQuery);
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <string>
#include <map>
using namespace std;
int main(){
map<char, int> m;
m['I'] = 1;m['V'] = 5;m['X'] = 10;m['L'] = 50;
m['C'] = 100;m['D'] = 500;m['M'] = 1000;
string s;
while(cin >> s){
int i = 0, ans = 0;
while(i < s.size()){
char c = s[i];
int t = 0;
for(i;c == s[i] && i < s.size()-1;i++)t += m[c];
if(m[c] < m[s[i]])ans -= t;
else ans += t;
if(i == s.size()-1)ans += m[s[i++]];
}
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
int main() {
int N;
cin >> N;
map<ll, ll> A;
rep(i, N) {
ll tmp;
cin >> tmp;
A[tmp]++;
}
vl st;
for (auto x : A) {
int y = x.second;
while (y >= 2) {
y -= 2;
st.push_back(x.first);
}
}
if (st.size() < 2) {
cout << 0 << endl;
} else {
sort(st.begin(), st.end());
reverse(st.begin(), st.end());
ll ans = st[0] * st[1];
cout << ans << endl;
}
} | 0 |
#include<iostream>
using namespace std;
int cnt = 0;
int n;
int a[1000000];
int w[500000];
int G[500000];
int m;
int shellsort();
int aho(int g);
int shellsort()
{
m = n / 2;
if (m == 0)
{
m = 1;
}
//cout << m << endl;
for (int i = 0; i < m; i++)
{
if (i == 0)
{
G[0] = m;
}
else
G[i] = G[i - 1] / 2;
if (G[i] == 0)
{
m = i;
break;
}
//cout << G[i];
//if (i != m - 1)cout << " ";
}
cout << m << endl;
for (int i = 0; i < m; i++)
{
cout << G[i];
if (i != m - 1)
{
cout << " ";
}
}
cout << endl;
for (int i = 0; i < m; i++)
{
aho(G[i]);
}
return 0;
}
int aho(int g)
{
for (int i = g; i < n; i++)
{
int v = a[i];
int j = i - g;
while (j>=0 && a[j] > v)
{
a[j + g] = a[j];
j = j - g;
cnt++;
}
a[j + g] = v;
}
return 0;
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
shellsort();
cout << cnt << endl;
for (int i = 0; i < n; i++)
{
cout << a[i] << endl;
}
} | #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <string.h>
#include <string>
#include <vector>
#include <limits.h>
#include <stack>
#include <queue>
#define maxn 1e9
#define pi acos(-1)
#define LL long long
using namespace std;
double aabs(double x)
{
if(x<0)return -x;
return x;
}
int gcd(int a,int b)
{
if(a%b==0)return b;
return gcd(b,a%b);
}
struct card{char suit,value;};
void bubble(struct card A[],int N)///冒泡排序；
{
for(int i=0;i<N;i++)
for(int j=N-1;j>=i+1;j--)
if(A[j].value<A[j-1].value)
{
card t=A[j];
A[j]=A[j-1];
A[j-1]=t;
}
}
void selection(struct card A[],int N)///选择排序；
{
for(int i=0;i<N;i++)
{
int minj=i;
for(int j=i;j<N;j++)
{
if(A[j].value<A[minj].value)minj=j;
}
card t=A[i];
A[i]=A[minj];
A[minj]=t;
}
}
LL cnt;
int l;
int a[1000000];
int n;
vector<int>G;
void insertionSort(int A[],int n,int g)///指定了间隔g的插入排序
{
for(int i=g;i<n;i++)
{
int v=A[i];
int j=i-g;
while (j>=0&&A[j]>v) {
A[j+g]=A[j];
j-=g;
cnt++;
}
A[j+g]=v;
}
}
void shellSort(int A[],int n)///希尔排序；
{
for(int h=1;;)//生成数列G={1,4,13,40,121,364,1093,.....}
{
if(h>n)break;
G.push_back(h);
h=3*h+1;
}
for(int i=G.size()-1;i>=0;i--)///按逆序指定G[i]=g;
{
insertionSort(A, n, G[i]);
}
}
bool isStable(struct card c1[],struct card c2[],int N)///判断稳定；
{
for(int i=0;i<N;i++)
{
if(c1[i].suit!=c2[i].suit)return false;
}
return true;
}
int main()
{
card c1[107],c2[107];
int n;
char ch;
cin>>n;
for(int i=0;i<n;i++)scanf("%d",&a[i]);
cnt=0;
shellSort(a, n);
cout<<G.size()<<endl;
for(int i=G.size()-1;i>=0;i--)
{
printf("%d",G[i]);
if(i)printf(" ");
}
printf("\n");
printf("%lld\n",cnt);
for(int i=0;i<n;i++)printf("%d\n",a[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
ll n,m;
cin >> n >> m;
ll p[m];
string s[m];
rep(i,m) cin >> p[i] >> s[i];
ll acnum[n+1];
for(ll i = 0; i < m; i++){
if(s[i] == "AC"){
acnum[p[i]] = 1;
}
}
ll ac = 0, wa = 0;
ll ok[n+1];
for(ll i = 1; i <= n; i++) ok[i] = 0;
for(ll i = 0; i < m; i++){
if(s[i] == "WA" && ok[p[i]] == 0 && acnum[p[i]] == 1){
wa++;
}
if(s[i] == "AC" && ok[p[i]] == 0){
ok[p[i]] = 1;
ac++;
}
}
cout << ac << " " << wa << endl;
} |
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define int long long int
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(), (x).end()
#define capi(x) int x;cin>>x
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
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;}
signed main() {
int n, m;
cin >> n >> m;
int fl[100001];
memset(fl, 0, sizeof(int) * 100001);
int pe = 0;
int ac = 0;
rep(i, m) {
int p; string s;
cin >> p >> s;
if (s == "AC") {
if (fl[p] >= 0) {
++ac;
pe += fl[p];
fl[p] = -1;
}
} else {
if (fl[p] >= 0) ++fl[p];
}
}
cout << ac << " " << pe;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
string S;
int counter=0;
cin>>S;
for(int i=0;i<3;i++){
if(S[i]=='R'){
counter++;
for(int j=1;j<3;j++){
if(S[i+j]=='R'){
counter++;
if(j==2){
cout<<counter<<endl;
return 0;
}
}else{
cout<<counter<<endl;
return 0;
}
}
}
}
cout<<counter<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template<class T>
void debug(T itr1, T itr2) { auto now = itr1; while(now<itr2) { cout << *now << " "; now++; } cout << endl; }
#define repr(i,from,to) for (int i=(int)from; i<(int)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i,N) repr(i,0,N)
#define per(i,N) for (int i=(int)N-1; i>=0; i--)
const ll MOD = pow(10,9)+7;
const ll LLINF = pow(2,61)-1;
const int INF = pow(2,30)-1;
vector<ll> fac;
void c_fac(int x=pow(10,6)+10) { fac.resize(x,true); rep(i,x) fac[i] = i ? (fac[i-1]*i)%MOD : 1; }
ll inv(ll a, ll m=MOD) { ll b = m, x = 1, y = 0; while (b!=0) { int d = a/b; a -= b*d; swap(a,b); x -= y*d; swap(x,y); } return (x+m)%m; }
ll nck(ll n, ll k) { return fac[n]*inv(fac[k]*fac[n-k]%MOD)%MOD; }
ll gcd(ll a, ll b) { if (a<b) swap(a,b); return b==0 ? a : gcd(b, a%b); }
ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
int main() {
ll D; cin >> D;
ll result = 0;
rep(dig,19) {
rep(pm,1<<((dig+1)/2-1)) {
ll td = D, l = pow(10,dig-1), r = 1;
bool plus[(dig+1)/2]; rep(i,(dig+1)/2) plus[i] = pm&(1<<i); plus[(dig+1)/2-1] = true;
ll diff[(dig+1)/2];
per(i,(dig+1)/2) {
ll left = (td/r%10+10)%10;
if (plus[i]) { diff[i] = (10-left)%10; td -= (l-r)*diff[i]; }
else { diff[i] = left; td += (l-r)*diff[i]; }
l /= 10; r *= 10;
}
bool ok = td==0;
rep(i,(dig+1)/2-1) { if (diff[i]==0&&plus[i]) ok = false; }
if (!ok) continue;
// cout << dig << "," << pm << "->" << td << "..."; debug(diff,diff+(dig+1)/2);
ll tmpr = 1; rep(i,(dig+1)/2) {
if (i==0&&dig%2==1) tmpr *= 10;
else if (i==(dig+1)/2-1) tmpr *= 9-diff[i];
else tmpr *= 10-diff[i];
}
result += tmpr;
}
}
cout << result << endl;
return 0;
} | 0 |
// This file is a "Hello, world!" in C++ language by GCC for wandbox.
#include <stdio.h>
#include <string.h>
int main()
{
int n;
int runner;
int score;
int out;
char nyuuryoku[114514];
scanf("%d",&n);
for(int i=0;i<n;i++){
runner=0;
score=0;
out=0;
while(out<3){
scanf("%s",nyuuryoku);
if(strcmp(nyuuryoku,"HIT")==0){
runner=runner+1;
}
else if(strcmp(nyuuryoku,"HOMERUN")==0){
score=score+runner+1;
runner=0;
}
else if(strcmp(nyuuryoku,"OUT")==0){
if(out==2&&runner>3){
score=score+runner-3;
}
out=out+1;
}
}
printf("%d\n",score);
}
}
// GCC reference:
// https://gcc.gnu.org/
// C++ language references:
// https://msdn.microsoft.com/library/3bstk3k5.aspx
// http://www.cplusplus.com/
// https://isocpp.org/
// http://www.open-std.org/jtc1/sc22/wg21/
// Boost libraries references:
// http://www.boost.org/doc/ | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
//namespace mp = boost::multiprecision;
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
double equal(double a, double b) {
return fabs(a - b) < DBL_EPSILON;
}
std::istream &operator>>(std::istream &in, set<int> &o) {
int a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
typedef priority_queue<ll, vector<ll>, greater<ll> > PQ_ASK;
class Match {
multiset<ll> l, r;
public:
void add(P p) {
this->l.insert(p.first);
this->r.insert(p.second);
}
ll point() {
auto itl = l.end();
itl--;
ll lr = *itl;
auto itr = r.begin();
ll rl = *itr;
return max<ll>(rl - lr + 1, 0);
}
void pop(P p) {
l.erase(l.find(p.first));
r.erase(r.find(p.second));
}
};
int main() {
int n;
cin >> n;
vector<P> v(n);
for (P &p:v)cin >> p.first >> p.second;
ll ans_one = [&] {
Match a, b;
rep(i, n) {
b.add(v[i]);
}
ll ans = 0;
rep(i, n) {
b.pop(v[i]);
a.add(v[i]);
ll now = b.point() + a.point();
cmax(ans, now);
a.pop(v[i]);
b.add(v[i]);
}
return ans;
}();
ll ans_split = [&]() -> ll {
sort(v.begin(), v.end(), [](P p1, P p2) {
return p1.second < p2.second;
});
Match a, b;
for (P p : v) b.add(p);
ll ans = 0;
rep(i, n - 1) {
P p = v[i];
a.add(p);
b.pop(p);
ll now = a.point() + b.point();
cmax(ans, now);
}
return ans;
}();
ll ans = max(ans_split, ans_one);
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> AB(2);
for (int i=0;i<2;++i) cin >> AB[i];
int K; cin >> K;
for (int i=0;i<K;++i){
if (AB[i&1]&1) --AB[i&1];
AB[(i&1)^1]+=AB[i&1]/2;
AB[i&1]/=2;
}
cout << AB[0] << ' ' << AB[1] << '\n';
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e16;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
ll a, b, k;
cin >> a >> b >> k;
rep(i, k) {
if (i%2) {
if (b%2) {
b--;
a += b/2;
b /= 2;
} else {
a += b/2;
b /= 2;
}
} else {
if (a%2) {
a--;
b += a/2;
a /= 2;
} else {
b += a/2;
a /= 2;
}
}
}
cout << a << ' ' << b << endl;
} | 1 |
#include <bits/stdc++.h>
#define REP(i, e) for(int (i) = 0; (i) < (e); ++(i))
#define FOR(i, b, e) for(int (i) = (b); (i) < (e); ++(i))
#define ALL(c) (c).begin(), (c).end()
#define PRINT(x) cout << (x) << "\n"
using namespace std;
using ll = long long; using pint = pair<int, int>; using pll = pair<ll, ll>;
const long long MOD = 1000000007;
ll N, K, D[10];
bool check(ll x){
while(x > 0){
ll d = x % 10;
REP(i, K){
if(d == D[i]) return false;
}
x /= 10;
}
return true;
}
signed main(){
cin >> N >> K;
REP(i, K) cin >> D[i];
ll ans = N;
while(true){
if(check(ans)) break;
ans++;
}
PRINT(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long INF = 1LL << 60;
int main(){
int N, K;
cin >> N >> K;
vector<int> D(10, 0);
for(int i=0; i<K; i++) {
int a;
cin >> a;
D[a] = 1;
}
for(int i=N; i<=100000; i++) {
int num = i;
bool flg = true;
while(num) {
int x = num % 10;
if (D[x] == 1) {
flg = false;
break;
}
num /= 10;
}
if(flg && i>= N) {
cout << i << endl;
return 0;
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
int f[2][7],a[7][2]={
{1,3},
{2,0},
{1,1},
{4,5},
{6,3},
{5,5},
{4,4}
};
int main(){
string s;cin>>s;
int*p=f[0],*q=f[1];
p[0]=1;
for(char c:s){
memset(q,0,sizeof(f[0]));
for(int i=0;i<7;i++)
for(int j=0;j<2;j++)
if(c=='0'+j||c=='?')
(q[a[i][j]]+=p[i])%=mod;
swap(p,q);
}
cout<<(p[3]+p[5])%mod<<"\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define lor(a,b,c) for(register int a=b;a<=c;++a)
#define ror(a,b,c) for(register int a=c;a>=b;--a)
typedef long long ll;
const int N=3e5+5;
const ll MOD=1e9+7;
char s[N]; int n;
ll f[N][3][3],ans;
inline void inc(ll &a,ll b){
(a+=b)>=MOD?a-=MOD:a;
}
inline void trans(int &a,int &b,int c){
if(!c){
++b; if(b>=3) b-=2;
}
else{
if(b) --b;
else ++a,a=min(a,2);
}
}
int main(){
scanf("%s",s+1); n=strlen(s+1);
f[0][0][0]=1ll;
lor(k,1,n){
if(s[k]!='0'){
lor(i,0,2) lor(j,0,2){
int a=i,b=j; trans(a,b,1);
inc(f[k][a][b],f[k-1][i][j]);
}
}
if(s[k]!='1'){
lor(i,0,2) lor(j,0,2){
int a=i,b=j; trans(a,b,0);
inc(f[k][a][b],f[k-1][i][j]);
}
}
}
lor(i,0,2) lor(j,0,i) inc(ans,f[n][i][j]);
printf("%lld\n",ans);
return 0;
} | 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<set>
using namespace std;
int main(){
int N, Q;
cin >> N >> Q;
// person q is stopped by construction i
// S_i <= D_q + X_i < T_i
// S_i - X_i <= D_q < T_i - X_i
// for i of smallest X_i
vector<pair<int, pair<int, int>>> X_interval(N);
for(int i = 0; i < N; i++){
int s, t, x;
cin >> s >> t >> x;
X_interval[i] = make_pair(x, make_pair(s - x, t - x));
}
vector<int> D(Q);
for(auto& x: D){
cin >> x;
}
vector<pair<int, pair<int, bool>>> time_x_add;
for(int i = 0; i < N; i++){
int x = X_interval[i].first;
int begin_time = X_interval[i].second.first, end_time = X_interval[i].second.second;
time_x_add.push_back(make_pair(begin_time, make_pair(x, true)));
time_x_add.push_back(make_pair(end_time, make_pair(x, false)));
}
sort(time_x_add.begin(), time_x_add.end());
int next_event_idx = 0;
set<int> X;
for(int q = 0; q < Q; q++){
while(next_event_idx < 2 * N && time_x_add[next_event_idx].first <= D[q]){
int x = time_x_add[next_event_idx].second.first;
bool add = time_x_add[next_event_idx].second.second;
if(add){
X.insert(x);
}else{
X.erase(x);
}
next_event_idx++;
}
if(X.size() > 0){
cout << *X.begin() << endl;
}else{
cout << -1 << endl;
}
}
}
| #include<algorithm>
#include<cstring>
#include<cstdio>
#include<cctype>
#define rep(i,x,y) for(int i=x; i<=y; ++i)
using namespace std;
const int N=17,M=40000,INF=1000000000;
int n,m,f[M],q[M],tot,dis[N][N],u,v,c,g[N][M];
int getint()
{
char ch;
int f=1;
while(!isdigit(ch=getchar())) if(ch=='-') f=-1;
int x=ch-48;
while(isdigit(ch=getchar())) x=x*10+ch-48;
return x*f;
}
int query1(int x)
{
int rt=0;
rep(i,1,n)
if(x&(1<<i-1))
rep(j,i+1,n)
if(x&(1<<j-1) && dis[i][j]!=INF)
rt+=dis[i][j];
return rt;
}
int query2(int x,int y)
{
int rt=0,maxn=0;
rep(i,1,n)
if(x&(1<<i-1))
maxn=max(maxn,g[i][y]);
return maxn;
}
int main()
{
n=getint(),m=getint();
rep(i,1,n) rep(j,1,n) dis[i][j]=i==j?0:INF;
rep(i,1,m) u=getint(),v=getint(),dis[u][v]=dis[v][u]=c=getint(),tot+=c;
rep(i,1,n)
rep(j,0,(1<<n)-1)
rep(k,1,n)
if(dis[i][k]!=INF && j&(1<<k-1))
g[i][j]+=dis[i][k];
rep(i,1,(1<<n)-1) f[i]=-INF;
f[1]=0;
rep(i,1,(1<<n)-2)
if(f[i]!=-INF)
{
rep(j,1,n)
if(!(i&(1<<j-1)))
{
int maxn=0;
rep(k,1,n)
if(i&(1<<k-1) && dis[j][k]!=INF)
maxn=max(maxn,dis[j][k]);
if(maxn) f[i|(1<<j-1)]=max(f[i|(1<<j-1)],f[i]+maxn);
}
}
rep(i,1,(1<<n)-1)
{
if(!(i&1) || !(i&(1<<n-1))) f[i]=-INF;
q[i]=query1(i);
}
rep(i,1,(1<<n)-1)
if(f[i]!=-INF)
for(int j=((1<<n)-1)^i; j; j=(j-1)&(((1<<n)-1)^i))
f[i|j]=max(f[i|j],f[i]+q[j]+query2(i,j));
printf("%d\n",tot-f[(1<<n)-1]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<int,int> pint;
const int mod=1000000007;
int n,m;
int ca,cb;
ll a[1001],b[1001];
set<ll> sa,sb;
int main(){
cin>>n>>m;
bool flag=false;
rep(i,n){
cin>>a[i];
if(sa.count(a[i])==0) sa.insert(a[i]);
else flag=true;
}
rep(i,m){
cin>>b[i];
if(sb.count(b[i])==0) sb.insert(b[i]);
else flag=true;
}
if(flag){
cout<<0<<endl;
return 0;
}
ll ans=1;
for(int i=n*m;i>=1;--i){
int ac=sa.count(i),bc=sb.count(i);
if(ac==0&&bc==0){
ans*=(1ll*ca*cb-n*m+i);
}
else if(ac==0){
++cb;
ans*=1ll*ca;
}
else if(bc==0){
++ca;
ans*=1ll*cb;
}
else ++ca,++cb;
ans%=mod;
}
cout<<ans<<endl;
return 0;
}
| #include <cassert>
#include "limits.h"
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#include <random>
#include <memory>
#include <utility>
#define rep(i, a, b) for (long long (i) = (a); i < (b); i++)
#define all(i) i.begin(), i.end()
#define debug(i) std::cerr << "debug " <<"LINE:"<<__LINE__<<" "<< #i <<":"<< i << std::endl
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, std::pair<T1, T2> pa) {
return os << pa.first << " " << pa.second;
}
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T> vec) {
for (int i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template<typename T1,typename T2>
inline bool chmax(T1& a,T2 b){return a<b && (a=b,true);}
template<typename T1,typename T2>
inline bool chmin(T1& a,T2 b){return a>b && (a=b,true);}
long long pow_mod(long long a, long long b, long long mod=-1) {
if ((a == 0)||(mod!=-1&&a%mod==0)) {
return 0;
}
long long x = 1;
while (b > 0) {
if (b & 1) {
x = (mod!=-1)?(x * a) % mod:x*a;
}
a = (mod!=-1)?(a * a) % mod:a*a;
b >>= 1;
}
return x;
}
// const long long MOD = 998244353;
const long long MOD = 1e9 + 7;
using ll = long long;
using P = std::pair<long double, long double>;
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
ll n,m;
std::cin>>n>>m;
std::vector<ll> a(n*m+1,0),b(n*m+1,0);
rep(i,0,n){
ll temp;
std::cin>>temp;
a[temp]++;
}
rep(i,0,m){
ll temp;
std::cin>>temp;
b[temp]++;
}
rep(i,1,n*m+1){
if(a[i]>1||b[i]>1){
std::cout<<0<<"\n";
return 0;
}
a[i]+=a[i-1];
b[i]+=b[i-1];
}
ll ans=1;
for(ll i=n*m;i>0;i--){
bool isa=(a[i]!=a[i-1]);
bool isb=(b[i]!=b[i-1]);
if(isa){
if(!isb){
ans=(ans*(m-b[i]))%MOD;
}
}else{
if(isb){
ans=(ans*(n-a[i]))%MOD;
}else{
ll num=(n-a[i])*(m-b[i]);
if(num<=n*m-i){
ans=0;
}
ans=(ans*(num+i-n*m))%MOD;
}
}
}
std::cout<<ans<<"\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N;
const int MAXV = 1000005;
int A[1005][1005];
int ID[1005][1005];
vector<int> to[MAXV];
int toId(int i, int j)
{
if (i > j)
{
swap(i, j);
}
return ID[i][j];
}
vector<int> dp(MAXV, -1);
vector<bool> visited(MAXV, 0);
int dfs(int u)
{
if (visited[u])
{
return dp[u]; // 訪問済だが、dpが未決定の場合は閉路が存在
}
visited[u] = 1;
int ret = 1;
for (auto v : to[u])
{
int res = dfs(v);
if (res == -1)
return -1;
ret = max(ret, res + 1);
}
return dp[u] = ret;
}
int main()
{
cin >> N;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N - 1; j++)
{
cin >> A[i][j];
A[i][j]--;
}
}
int V = 0;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
if (i < j)
{
ID[i][j] = V++; // 各試合にノードのIDを割り当てる
}
}
}
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N - 1; j++)
{
A[i][j] = toId(i, A[i][j]); // i: 自分, j: 対戦相手, でIDに変換
}
for (int j = 1; j < N - 1; j++)
{
to[A[i][j]].push_back(A[i][j - 1]); // 入力のノード
}
}
int ans = 0;
for (int i = 0; i < V; i++)
{
int res = dfs(i);
if (res == -1)
{
cout << -1 << endl;
return 0;
}
ans = max(ans, res);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define debug(x) cout<<#x<<" = "<<(x)<<endl
#define debug2(x,y) cout<<"("<<#x<<","<<#y<<") = ("<<(x)<<","<<(y)<<")\n"
using vi = vector<int>;
using vvi = vector<vi>;
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define vmin(v) *min_element(all(v))
#define vmax(v) *max_element(all(v))
#define rep(i, n) for(int i=0; i<(int)n; i++)
namespace /*DAG.cpp*/{
int N,M; //頂点と辺の数
vector<vector<int>> G; //グラフ
vector<int> h; //入次数 : topoBFS
vector<int> l_depth; //最大経路長 //recDFSでは探索済みかどうかも示す
vector<int> s_depth; //最短経路長
vector<int> ans; //答えを格納(recDFSではreverse必要)
void input(){
cin>>N>>M;
G.resize(N);
h.resize(N, 0);
int f,t;
for(int i=0; i<M; i++){
cin>>f>>t;
f--;t--;
G[f].push_back(t); //recDFSとtopoBFS両方に必要
h[t]++; //topoBFSにのみ必要
}
}
void topoBFS(){
l_depth.resize(N, -1);
s_depth.resize(N, N);
queue<int> unchecked;
for(int i=0; i<N; i++){
if(h[i]==0){
unchecked.push(i);
l_depth[i] = 0;
s_depth[i] = 0;
}
}
while(!unchecked.empty()){
int current = unchecked.front();
unchecked.pop();
ans.push_back(current+1);
for(int next: G[current]){
h[next]--;
l_depth[next] = max(l_depth[next], l_depth[current]+1); //最長経路長
s_depth[next] = min(s_depth[next], s_depth[current]+1); //最短経路長
if(h[next]==0){
unchecked.push(next);
}
}
}
}
void recDFS(int look){
if(l_depth[look]!=-1) return;
if(G[look].size()){
for(int next: G[look]){
recDFS(next);
l_depth[look] = max(l_depth[next]+1, l_depth[look]);
s_depth[look] = min(s_depth[next]+1, s_depth[look]);
}
}else{
l_depth[look] = 0;
s_depth[look] = 0;
}
ans.push_back(look+1);
}
}
int main(){
int n;
cin>>n;
vvi IDs(n, vi(n, -1));
N = n*(n-1)/2;
G.resize(N);
h.resize(N, 0);
int id = 0;
for(int i=0; i<n; i++){
for(int j=i+1; j<n; j++){
IDs[i][j] = id;
IDs[j][i] = id;
id++;
}
}
/*
rep(i,n){
rep(j,n){
cout<<IDs[i][j]<<",";
}
cout<<endl;
}
debug(G.size());
//*/
int t, bufid, vsid;
for(int i=0; i<n; i++){
cin>>t;t--;
bufid = IDs[i][t];
for(int j=1; j<n-1; j++){
cin>>t;t--;
vsid = IDs[i][t];
G[bufid].push_back(vsid);
h[vsid]++;
bufid = vsid;
}
}
/*
for(int i=0; i<N; i++){
debug2(i, h[i]);
}
*/
topoBFS();
/*
for(int x: ans){
cout<<x<<",";
}cout<<" -> ";
*/
bool isDAG = ans.size()==N;
//cout<<(isDAG? "閉路なし": "閉路あり")<<endl;
if(isDAG){
int l_max = *max_element(l_depth.begin(), l_depth.end());
cout<<l_max+1<<endl;
}else{
cout<<-1<<endl;
}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define REP(i,m,n) for(int i=(m);i<(n);i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define all(a) a.begin(),a.end()
#define rall(c) (c).rbegin(),(c).rend()
#define mp make_pair
#define endl '\n'
#define vec vector<ll>
#define mat vector<vector<ll> >
#define fi first
#define se second
typedef long long ll;
typedef pair<ll,ll> pll;
typedef long double ld;
const ll inf=1e9+7;
const ll mod=998244353;
signed main(){
ll n;cin>>n;
map<ll,vector<pll> >x,y;
map<ll,vector<pll> >xpy;
map<ll,vector<pll> >ymx;
rep(i,n){
ll a,b;cin>>a>>b;
char c;cin>>c;
ll d=0;
if(c=='R')d=0;
if(c=='U')d=1;
if(c=='L')d=2;
if(c=='D')d=3;
x[a].pb(mp(b,d));
y[b].pb(mp(a,d));
xpy[a+b].pb(mp(a,d));
ymx[b-a+200000].pb(mp(a,d));
}
ll ans=inf*inf;
for(auto s:x){
ll u=-1,d=-1;
ll i=s.first;
sort(all(x[i]));
for(auto e:x[i]){
if(e.second==1)d=e.first;
if(e.second==3)u=e.first;
if(u>=0&&d>=0&&u-d>=0){
ans=min(ans,(u-d)*5);
}
}
}
for(auto s:y){
ll l=-1,r=-1;
ll i=s.first;
sort(all(y[i]));
for(auto e:y[i]){
if(e.second==0)l=e.first;
if(e.second==2)r=e.first;
if(l>=0&&r>=0&&r-l>=0){
ans=min(ans,(r-l)*5);
}
}
}
for(auto s:xpy){
ll l=-1,r=-1,u=-1,d=-1;
ll i=s.first;
sort(all(xpy[i]));
for(auto e:xpy[i]){
if(e.second==0)l=e.first;
if(e.second==2)r=e.first;
if(e.second==1)d=e.first;
if(e.second==3)u=e.first;
if(l>=0&&d>=0&&d>=l)ans=min(ans,(d-l)*10);
if(r>=0&&u>=0&&r>=u)ans=min(ans,(r-u)*10);
}
}
for(auto s:ymx){
ll l=-1,r=-1,u=-1,d=-1;
ll i=s.first;
sort(all(ymx[i]));
for(auto e:ymx[i]){
if(e.second==0)l=e.first;
if(e.second==2)r=e.first;
if(e.second==1)d=e.first;
if(e.second==3)u=e.first;
if(l>=0&&u>=0&&u>=l)ans=min(ans,(u-l)*10);
if(r>=0&&d>=0&&r>=d)ans=min(ans,(r-d)*10);
}
}
if(ans==inf*inf){
cout<<"SAFE"<<endl;
}else{
cout<<ans<<endl;
}
} | #line 2 "/Users/kaage/Desktop/ProgrammingWorkspace/library/other/template.hpp"
#define _CRT_SECURE_NO_WARNINGS
#pragma target("avx")
#pragma optimize("O3")
#pragma optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define all(V) V.begin(),V.end()
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
typedef std::pair<lint, lint> LP;
constexpr int INF = INT_MAX/2;
constexpr lint LINF = LLONG_MAX/2;
constexpr double eps = DBL_EPSILON;
constexpr double PI=3.141592653589793238462643383279;
template<class T>
class prique :public std::priority_queue<T, std::vector<T>, std::greater<T>> {};
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b; b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) {
return a / gcd(a, b) * b;
}
bool isprime(lint n) {
if (n == 1)return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)return false;
}
return true;
}
template<typename T>
T mypow(T a, lint b) {
if (!b)return T(1);
if (b & 1)return mypow(a, b - 1) * a;
T memo = mypow(a, b >> 1);
return memo * memo;
}
lint modpow(lint a, lint b, lint m) {
if (!b)return 1;
if (b & 1)return modpow(a, b - 1, m) * a % m;
lint memo = modpow(a, b >> 1, m);
return memo * memo % m;
}
template<typename T>
void printArray(std::vector<T>& vec) {
rep(i, vec.size() - 1)std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template<typename T>
void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
#line 2 "main.cpp"
int n,x[200010],y[200010];
char u[200010];
std::vector<std::pair<int,char>> vec[4][400010];
int main(){
std::cin>>n;
rep(i,n){
std::cin>>x[i]>>y[i]>>u[i];
vec[0][x[i]].emplace_back(y[i],u[i]);
vec[1][y[i]].emplace_back(x[i],u[i]);
vec[2][x[i]+y[i]].emplace_back(x[i],u[i]);
vec[3][x[i]-y[i]+200000].emplace_back(x[i],u[i]);
}
rep(i,4){
rep(j,400001)std::sort(all(vec[i][j]));
}
int ans=INF;
rep(i,400001){
int now=-1;
for(const auto& j:vec[0][i]){
if(j.second=='U')now=j.first;
if(j.second=='D'&&now!=-1)chmin(ans,(j.first-now)*5);
}
}
rep(i,400001){
int now=-1;
for(const auto& j:vec[1][i]){
if(j.second=='R')now=j.first;
if(j.second=='L'&&now!=-1)chmin(ans,(j.first-now)*5);
}
}
rep(i,400001){
int rnow=-1,dnow=-1;
for(const auto& j:vec[2][i]){
if(j.second=='R')rnow=j.first;
if(j.second=='D')dnow=j.first;
if(j.second=='U'&&rnow!=-1)chmin(ans,(j.first-rnow)*10);
if(j.second=='L'&&dnow!=-1)chmin(ans,(j.first-dnow)*10);
}
}
rep(i,400001){
int rnow=-1,unow=-1;
for(const auto& j:vec[3][i]){
if(j.second=='R')rnow=j.first;
if(j.second=='U')unow=j.first;
if(j.second=='L'&&unow!=-1)chmin(ans,(j.first-unow)*10);
if(j.second=='D'&&rnow!=-1)chmin(ans,(j.first-rnow)*10);
}
}
if(ans==INF)puts("SAFE");
else std::cout<<ans<<std::endl;
return 0;
} | 1 |
#include <iostream>
#include<cmath>
using namespace std;
int main()
{
int n,i;
cin>>n;
double res;
for(i=n; i>=1; i--)
{
res=pow(i,0.5);
if(abs(res-int(res))==0)
{
cout<<i;
return 0;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
#define all(v) v.begin(), v.end()
const ll mod=1000000007;
ll countBits(ll in){
int res=0;
for(;in>0;in>>=1){
if((in&0x01)!=0){
res++;
}
}
return res;
}
template<typename T>
void show2dVector(vector<vector<T>>& v){
for(int i=0;i<v.size();i++){
int m=v[i].size();
cout<<i<<" : ";
for(int j=0;i<m;i++){
cout<<v[i][j]<<" ";
}
cout<<endl;
}
}
void bfs(const vector<vector<int>>&g, int v, vector<bool>& seen){
seen[v]=true;
cout<<v<<" ";
for(auto next: g[v]){
if(seen[next]){
continue;
}
bfs(g,next,seen);
}
}
bool dfs(vector<vector<int>> &g,int start,int goal,vector<bool>&seen){
bool res=false;
seen[start]=true;
if(start==goal){
return true;
}
for(auto next: g[start]){
if(seen[next]){
continue;
}
res=dfs(g,next,goal,seen);
if(res){
break;
}
}
return res;
}
ll gcd(ll a,ll b) {
return b? gcd(b,a%b): a;
}
ll lcm(ll a,ll b) {
return a*b/gcd(a,b);
}
bool isLowerCase(char c){
return (c>='a'&&c<='z');
}
char toLowerCase(char c){
if(isLowerCase(c)){
return c;
}else{
return c+'a'-'A';
}
}
char toUpperCase(char c){
if(isLowerCase(c)){
return c-('a'-'A');
}else{
return c;
}
}
ll powm(ll a,ll n, ll m){
ll ret=1;
while(n>0){
if(n%2==1){
ret=(ret*a)%m;
}
n>>=1;
a=(a*a)%m;
}
return ret;
}
const string yesno(bool ans){
return (ans?"Yes":"No");
}
int main() {
string s;cin>>s;
int w;cin>>w;
for(int i=0;i<s.size();i+=w){
cout<<s[i];
}
cout<<endl;
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int main(){
int N = 100000;
bool a[100000];
for(int i = 0; i < N; i++){
a[i] = true;
}
a[0] = false;
a[1] = false;
for(int i = 2; i < N; i++){
if(a[i]){
for(int j = i * 2; j < N; j += i){
a[j] = false;
}
}
}
int n;
while(true){
cin >> n;
if(n == 0){
break;
}else if(n < 5 || n > 10000){
printf("NA\n");
continue;
}else{
for(int i = n; i > 2; i--){
if(a[i] && a[i - 2]){
printf("%d %d\n", i - 2, i);
break;
}
}
}
}
return 0;
} | #include <iostream>
#include <utility>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
#define gcu getchar_unlocked
#define pcu putchar_unlocked
#define _il inline
#define _in _il int in
#define _sc _il bool scan
_in(int c){int n=0;bool m=false;if(c=='-')m=true,c=gcu();
do{n=10*n+(c-'0'),c=gcu();}while(c>='0');return m?-n:n;} //&&c<='9'
_in() {return in(gcu());}
_sc(int &n){int c=gcu();return c==EOF?false:(n=in(c),true);}
_sc(char &c){c=gcu();gcu();return c!=EOF;}
//_sc(string &s){int c;s="";
// for(;;){c=gcu();if(c=='\n'||c==' ')return true;else if(c==EOF)return false;s+=c;}}
template <typename H,typename... T> _sc(H &h, T&&... t){return scan(h)&&scan(t...);}
#define _vo _il void out
#define _vl _il void outl
template <typename T>
_vo(T n){static char buf[20];char *p=buf;
if(n<0)pcu('-'),n*=-1;if(!n)*p++='0';else while(n)*p++=n%10+'0',n/=10;
while (p!=buf)pcu(*--p);}
_vo(const char *s){while(*s)pcu(*s++);}
_vo(char c){pcu(c);}
//_vo(string &s){for (char c: s) pcu(c);}
template <typename H,typename... T> _vo(H&& h, T&&... t){out(h);out(move(t)...);}
//template <typename T> _vo(vector<T> &v){for(T &x:v)out(&x == &v[0]?"":" "),out(x);out('\n');}
_vl(){out('\n');}
template <typename... T> _vl(T&&... t){out(move(t)...);outl();}
template<int N>
struct sieve {
bool s[N];
constexpr sieve() : s() {
for (int i = 0; i < N; i++)
s[i] = true;
for (int i = 4; i < N; i += 2)
s[i] = false;
for (int i = 9; i < N; i += 6)
s[i] = false;
for (int i = 6, e = sqrt(N); i <= e; i += 6) {
for (int j : {i - 1, i + 1})
if (s[j])
for (int k = j * j; k < N; k += j)
s[k] = false;
}
}
};
template<int N>
struct twin {
int t[N/10], l;
constexpr twin() : t(), l(1) {
sieve<N> s;
t[0] = 5;
for (int i = 0; i < N; i++)
if (s.s[i - 2] && s.s[i])
t[l++] = i;
}
};
int main() {
enum {N = 10001};
twin<N> t;
for (int n; (n = in());) {
auto r = upper_bound(t.t, t.t + t.l, n) - 1;
outl(*r - 2, ' ', *r);
}
}
| 1 |
#include <iostream>
#include <bitset>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <regex>
#include <iomanip>
#include <climits>
#include <utility>
#include <queue>
using namespace std;
using ll = long long int;
using dd = long double;
const ll MOD = 1e9 + 7;
const dd PI = 3.1415926435;
class UnionFind
{
public:
UnionFind(int N) : par(N)
{
for (ll i = 0; i < N; i++)
{
par[i] = i;
}
}
int root(int x)
{
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y)
{
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
par[rx] = ry;
}
bool same(int x, int y)
{
int rx = root(x);
int ry = root(y);
return rx == ry;
}
private:
vector<int> par;
};
ll gcd(ll a, ll b)
{
if (a % b == 0)
{
return b;
}
return gcd(b, a % b);
}
ll fact(ll n)
{
if (n == 0)
{
return 1;
}
if (n == 1)
{
return 1;
}
return n * fact(n - 1) % MOD;
}
ll pow_fast(ll n, ll k)
{
if (k == 0)
{
return 1;
}
if (k == 1)
{
return n;
}
if (k % 2 == 0)
{
ll tmp = pow_fast(n, k / 2LL);
return tmp * tmp % MOD;
}
else
{
ll tmp = pow_fast(n, k / 2LL);
tmp *= tmp;
tmp %= MOD;
return tmp * n % MOD;
}
}
map<ll, ll> sosuu(ll n)
{
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++)
{
while (n % i == 0)
{
res[i] += 1;
n /= i;
}
}
if (n != 1)
{
res[n] += 1;
}
return res;
}
struct Dish{
ll time;
ll taste;
};
int main()
{
ll N, T;
cin >> N >> T;
vector<Dish> dishes(N + 1);
for (ll i = 0; i < N; i++)
{
ll ai, bi;
cin >> ai >> bi;
Dish d = {ai, bi};
dishes[i + 1] = d;
}
vector<vector<ll>> DP1(N + 1, vector<ll>(T + 1, 0));
vector<vector<ll>> DP2(N + 1, vector<ll>(T + 1, 0));
// DP1 => 1-i 種類までの料理の中で j 分以内で最大の満腹度
for (ll i = 1; i <= N; i++)
{
for (ll j = 0; j <= T; j++)
{
if (j < dishes[i].time) {
DP1[i][j] = DP1[i - 1][j];
continue;
}
DP1[i][j] = max(DP1[i - 1][j], dishes[i].taste + DP1[i - 1][j - dishes[i].time]);
}
}
for (ll i = 1; i <= N; i++)
{
for (ll j = 0; j <= T; j++)
{
if (j < dishes[N - i + 1].time) {
DP2[i][j] = DP2[i - 1][j];
continue;
}
DP2[i][j] = max(DP2[i - 1][j], dishes[N - i + 1].taste + DP2[i - 1][j - dishes[N - i + 1].time]);
}
}
ll ans = 0;
for (ll i = 1; i <= N; i++)
{
for (ll j = 0; j <= T - 1; j++)
{
ans = max(ans, DP1[i - 1][j] + DP2[N - i][T - 1 - j] + dishes[i].taste);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX_N = 3009;
int N, T;
int A[MAX_N], B[MAX_N];
int dp[MAX_N][MAX_N];
void solve()
{
vector<pair<int,int>> v;
for(int i=0;i<N;++i) v.emplace_back(A[i],B[i]);
sort(v.begin(),v.end());
for(int i=0;i<N;++i){
int ti = v[i].first, de = v[i].second;
for(int t=0;t<=T;++t){
dp[i+1][t]=max(dp[i+1][t],dp[i][t]);
if(t<T)dp[i+1][min(T,t+ti)]=max(dp[i+1][min(T,t+ti)], de+dp[i][t]);
}
}
int ans = dp[N][T];
cout<<ans;
}
int main()
{
cin >> N >> T;
for(int i=0;i<N;++i) cin >> A[i] >> B[i];
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for(int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define all(x) (x).begin(), (x).end()
template <typename T> bool chmax(T &a, const T &b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> bool chmin(T &a, const T &b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
const long long INFLL = 1LL << 60;
const long long MOD = 1e9 + 7;
int main() {
int N;
cin >> N;
ll sum = 0;
rep(i, 1, N + 1) {
if(i % 3 == 0 || i % 5 == 0) continue;
sum += i;
}
cout << sum << endl;
}
| #include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
#define endl "\n"
//#define int long long
#define ALL(x) begin(x),end(x)
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
const int MOD = 1e9 + 7;
const int INF = 1e18 + 9;
constexpr long double pi = 3.141592653589793238462643383279;
int fact(int i) {
if (i == 0) return 1;
return ((fact(i - 1)) * i) % MOD;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int keta(int n) {
if (n == 0) return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
int ketasum(int n) {
int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
char toSmall(char c) { // 大文字を小文字へ
return (c + 0x20);
}
char toLarge(char c) { // 小文字を大文字へ
return (c - 0x20);
}
float myPower(int a, int n) { // aのn乗の計算
float x = 1;
while (n > 0) { // 全てのbitが捨てられるまで
if (n & 1) { // 一番右のbitが１のとき
x *= a;
}
a *= a;
n >>= 1; // bit全体を右に1つシフトして一番右を捨てる
}
return x;
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1: return false;
case 2: // fall-through
case 3: return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0) return false;
// n は 2 と 3 のいずれの倍数でもないことが保証された
// これより n は (6の倍数)-1 か (6の倍数)+1 である
// 6の倍数前後の数を使って試し割りをする
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0) return false; // (6の倍数)-1
if (n % (i + 2) == 0) return false; // (6の倍数)+1
}
return true;
}
/*signed*/int main(void) {
string s;
cin >> s;
int n;
cin >> n;
for (int i = 0; i < s.size(); i = i + n) {
cout << s[i];
}
cout << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int D,K;
cin>>K>>D;
//vector<int>ans;
for(int k=K;k>1;k--){
cout<<D-k+1<<" ";
}
cout<<D<<" ";
for(int k=1;k<K;k++){
cout<<D+k<<" ";
}
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
using namespace std;
template<typename T, typename Q>
istream &operator>>(istream &is, pair<T, Q> &p) {
return is >> p.first >> p.second;
}
template<typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
template<typename T, typename Q>
ostream &operator<<(ostream &os, pair<T, Q> p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template<typename T>
ostream &operator<<(ostream &os, vector<T> v) {
os << "[";
for (auto it = v.begin(); it != v.end(); it++)
os << (it == v.begin() ? "" : ", ") << *it;
return os << "]";
}
template<typename T, typename Q>
ostream &operator<<(ostream &os, map<T, Q> m) {
os << "[";
for (auto it = m.begin(); it != m.end(); it++)
os << (it == m.begin() ? "" : ", ") << *it;
return os;
}
#define imie(...) " [" << #__VA_ARGS__": " << (__VA_ARGS__) << "] "
int main() {
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int mn = -1000000;
int k, x; cin >> k >> x;
set<int> s;
if (x - k + 1 < mn) {
for (int i = mn; i <= mn + k - 1; i++) {
s.insert(i);
}
for (int i = x; i <= x + k - 1; i++) {
s.insert(i);
}
} else if (x + k - 1 > -mn) {
for (int i = -mn; i >= -mn - k + 1; i--) {
s.insert(i);
}
for (int i = x; i >= x - k + 1; i--) {
s.insert(i);
}
} else {
for (int i = x; i <= x + k - 1; i++) {
s.insert(i);
}
for (int i = x; i >= x - k + 1; i--) {
s.insert(i);
}
}
for (auto x : s) cout << x << " ";
}
| 1 |
#include <cstdio>
const int maxn = 1e6 + 10;
int n, fnt, rar, q[maxn], ans, i, j;
char s[maxn], t[maxn];
int main() {
scanf("%d%s%s", &n, s + 1, t + 1);
j = 1;
for (i = 1; i <= n; ++i) {
if(s[i] != t[i]) {
j = 0;
break;
}
}
if(j) {
return !puts("0");
}
j = n + 1;
for (i = n; i; --i) {
if(!(j - 1 >= i && t[j - 1] == s[i])) {
continue;
}
while(j - 1 >= i && t[j - 1] == s[i]) {
--j;
}
while(fnt < rar && q[fnt] - rar + fnt >= j) {
++fnt;
}
if(i < j) {
q[rar++] = i;
(rar - fnt > ans) && (ans = rar - fnt);
}
}
return !printf("%d\n", j == 1 ? ans + 1 : -1);
} | //khodaya khodet komak kon
#include <bits/stdc++.h>
#define F first
#define S second
#define pb push_back
#define all(x) x.begin(), x.end()
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 1000000 + 10;
const ll MOD = 1000000000 + 7;
const ll INF = 1000000010;
const ll LOG = 25;
int n, Ans;
char S[N], T[N];
int bias, que[N], head, tail;
int main() {
cin >> n;
for (int i = 1; i <= n;i++) cin >> S[i];
for (int i = 1; i <= n; i++) cin >> T[i];
int ok = 1;
for (int i = 1; i <= n; ++i) if (S[i] != T[i]) ok = 0;
if (ok) return cout << 0, 0;
head = 1, tail = 0;
for (int i = n, j = n; i >= 1; --i) {
if (j > i) j = i;
while (head <= tail && que[head] + bias > i) ++head;
Ans = std::max(Ans, tail - head + 2);
if (i == 1 || T[i - 1] != T[i]) {
while (j && S[j] != T[i]) --j;
if (!j) return cout << -1, 0;
--bias;
que[++tail] = j - bias;
--j;
}
}
cout << Ans;
return 0;
}
| 1 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=100000+10;
int n,m,a[maxn],ans[maxn],res[maxn],tmp[maxn];
long long k;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;++i)scanf("%d",a+i);
for(int i=1;i<n;++i)ans[i]=i;
scanf("%d%lld",&m,&k);
for(int i=1;i<=m;++i){
int x;
scanf("%d",&x);
swap(ans[x],ans[x-1]);
}
for(int i=1;i<n;++i)res[i]=i;
while(k){
if(k&1)
for(int i=1;i<n;++i)res[i]=ans[res[i]];
for(int i=1;i<n;++i)tmp[i]=ans[ans[i]];
for(int i=1;i<n;++i)ans[i]=tmp[i];
k>>=1;
}
long long sum=a[1];
for(int i=1;i<=n;++i){
printf("%lld.0\n",sum);
sum+=a[res[i]+1]-a[res[i]];
}
} | #include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep3(i,a,b) for(ll i=a;i>=b;i--)
#define REP(e,v) for(auto e:v)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define tii tuple<int,int,int>
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define edge(v,a,b) v[a].pb(b);v[b].pb(a);
#define MAX_V 400010
#define vec vector<int>
#define vecll vector<ll>
#define vecpii vector<pii>
#define endl "\n"
#define ALL(c) (c).begin(),(c).end()
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
void makegraph(int x,vector<vec> &v){rep(i,x-1){int a=in(),b=in();v[a].pb(b);v[b].pb(a);}}
template<typename A, size_t NNN, typename T>
void Fill(A (&array)[NNN], const T &val){
fill( (T*)array, (T*)(array+NNN), val );
}
#define INF 1e9+7
#define LLINF 1e18+7
ll MOD=1e9+7;
#define N 255050
ll n,m,k;
ll a[N],x[N];
int mv[80][N];
main(){
n=in();
rep(i,n)x[i]=in();
m=in();
k=lin();
rep(i,m)a[i]=in();
rep(i,n-1)mv[0][i]=i;
rep(i,m)swap(mv[0][a[i]-1],mv[0][a[i]-2]);
rep(i,63){
rep(j,n-1){
mv[i+1][j]=mv[i][mv[i][j]];
}
}
/*
rep(i,3){
rep(j,n)cout<<mv[i][j]<<" ";
cout<<endl;
}
*/
vec now(n),temp(n);
rep(i,n-1)now[i]=i;
rep(i,63){
if(k&(1ll<<i)){
rep(j,n-1){
temp[j]=now[mv[i][j]];
/*printf("mv[i][j]=%d now[mv[i][j]]=%d\n",mv[i][j],now[mv[i][j]]);
*/
}
/*cout<<"now="<<i<<endl;
rep(ii,n-1)cout<<temp[i]<<" ";
cout<<endl;
*/
now=temp;
}
}
/*
rep(i,n-1)cout<<now[i]<<" ";
cout<<endl;
*/
vec d(n);
rep(i,n-1)d[i]=x[i+1]-x[i];
/*
rep(i,n-1)cout<<d[i]<<" ";
*/
cout<<x[0]<<endl;
rep(i,n-1){
x[i+1]=x[i]+d[now[i]];
cout<<x[i+1]<<endl;
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int (i) = 0; (i) < (n); i++)
#define ll long long
using namespace std;
int main() {
ll N = 0, A,B;;
cin >> N >> A >> B;
if(N == 1){
cout << "Hello World";
}
else{
cout << A + B;
}
}
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <queue>
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <limits>
using namespace std;
typedef long long LL;
int main(int argc, char* argv[]){
cin.tie(0);
ios::sync_with_stdio(false);
string A, B, C;
cin >> A >> B >> C;
if(A[A.size()-1] == B[0] && B[B.size()-1] == C[0]){
printf("YES\n");
}
else{
printf("NO\n");
}
return 0;
}
| 0 |
#include <iostream>
#include<vector>
using namespace std;
typedef long long ll;
int main() {
int n;cin>>n;
ll d;cin>>d;
vector<ll> a(n);
for(int i=0;i<n;i++){
cin>>a[i];
}
vector<ll> r(n);
r[n-1]=n-1;
for(int i=n-2;i>=0;i--){
if(a[r[i+1]]+(r[i+1]-i)*d>a[i]){
r[i]=i;
}else{
r[i]=r[i+1];
}
}
int ri=0;
ll ra=a[0];
ll ans=0;
while(ri!=n-1){
ans+=ra+a[r[ri+1]]+(r[ri+1]-ri)*d;
for(int i=ri+1;i<r[ri+1];i++){
if((i-ri)*d+ra<(r[ri+1]-i)*d+a[r[ri+1]]){
ans+=a[i]+ra+(i-ri)*d;
}else{
ans+=a[i]+(r[ri+1]-i)*d+a[r[ri+1]];
}
}
ra+=(r[ri+1]-ri)*d;
if(ra>a[r[ri+1]]){
ra=a[r[ri+1]];
}
ri=r[ri+1];
}
cout<<ans<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int (i) = (a); (i) < (b); ++(i))
#define per(i, a, b) for (int (i) = (a); (i) >= (b); --(i))
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define ff first
#define ss second
#define sz(x) ((int) x.size())
#define rd(type, ...) type __VA_ARGS__; sc(__VA_ARGS__)
#define rda(a, n) rep(i, 0, n) cin >> a[i];
#define rdaa(a, n, m) rep(i, 0, n) rep(j, 0, m) cin >> a[i][j];
#define rdv(type, v, n) vector<type> v(n); rep(__ii, 0, n) cin >> v[__ii]
#define rdm(type, v, h, w) vector<vector<type>>(h, vector<type>(w)) v; rep(__ii, 0, h) rep(__jj, 0, w) cin >> v[__ii][__jj]
#define rdv2(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_rdv2_Init(n, __VA_ARGS__); for(int w_=0; w_<n; ++w_){MACRO_rdv2_Scan(w_, __VA_ARGS__);}
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "] : ", debug_out(__VA_ARGS__)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
void solve();
signed main() {ios::sync_with_stdio(false); cin.tie(0);
cout << fixed; cout.precision(20); solve(); return 0;}
template<typename T> void chmin(T &a, T b) {if (a > b) a = b;}
template<typename T> void chmax(T &a, T b) {if (a < b) a = b;}
template<typename T> void MACRO_rdv2_Init(int n, T& t) { t.resize(n); }
template<typename First, typename... Rest> void MACRO_rdv2_Init(int n, First& first, Rest& ...rest) { first.resize(n); MACRO_rdv2_Init(n, rest...); }
template<typename T> void MACRO_rdv2_Scan(int p, T& t) { std::cin >> t[p]; }
template<typename First, typename... Rest> void MACRO_rdv2_Scan(int p, First& first, Rest& ...rest) { std::cin >> first[p]; MACRO_rdv2_Scan(p, rest...); }
template<typename T> void wrv(const vector<T> &v) {rep(__ii, 0, sz(v)) {if (__ii) cout << ' '; cout << v[__ii];} cout << '\n';}
template<typename T> void wrm(const vector<vector<T>> &v) {rep(__ii, 0, sz(v)) {rep(__jj, 0, v[__ii].size()) {if (__jj) cout << ' '; cout << v[__ii][__jj];} cout << '\n';}}
template<typename T> void sc(T& x) {cin >> x;}
template<typename Head, typename... Tail> void sc(Head& head, Tail&... tail) {cin >> head; sc(tail...);}
template<typename T> void wr(const T& x) {cout << x << '\n';}
template<typename Head, typename... Tail> void wr(const Head& head, const Tail&... tail) {cout << head << ' '; wr(tail...);}
template<typename T> void wrf(const T& x) {cout << x << endl;}
template<typename Head, typename... Tail> void wrf(const Head& head, const Tail&... tail) {cout << head << ' '; wrf(tail...);}
template<typename T> void debug_out(const T& x) {cerr << x << '\n';}
template<typename Head, typename... Tail> void debug_out(const Head& head, const Tail&... tail) {cerr << head << ' '; debug_out(tail...);}
template<typename... T> void err(const T&... cod) {wr(cod...); exit(0);}
const int N = 305;
string s;
int n, k;
int dp[N][N][N];
int f(int l, int r, int sisa) {
if (l > r) return 0;
if (l == r) return 1;
if (dp[l][r][sisa] != -1) return dp[l][r][sisa];
int ans = 2 * (s[l] == s[r]) + f(l + 1, r - 1, sisa);
if (sisa > 0) chmax(ans, 2 + f(l + 1, r - 1, sisa - 1));
chmax(ans, f(l + 1, r, sisa));
chmax(ans, f(l, r - 1, sisa));
return dp[l][r][sisa] = ans;
}
void solve() {
cin >> s >> k;
n = sz(s);
memset(dp, -1, sizeof dp);
wr(f(0, n - 1, k));
} | 0 |
//#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
#define PI 3.14159265359
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const long long INF= 1e+18+1;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll> >vvl;
typedef pair<ll,ll> P;
typedef tuple<ll,ll,ll> T;
const ll MOD=1000000007LL;
string abc="abcdefghijklmnopqrstuvwxyz";
string ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
//素数判定O(√n)
bool is_prime(ll n){
for(ll i=2;i*i<=n;i++){
if(n%i==0)return false;
}
return n!=1;
}
int main(){
ll n;cin>>n;
vl vec;
ll i=1;
while(true){
ll k=5*i+1;
if(is_prime(k))vec.push_back(k);
if(vec.size()==n)break;
i++;
}
rep(i,n-1){
cout<<vec[i]<<" ";
}
cout<<vec[n-1]<<endl;
}
|
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
typedef unsigned long long ULLONG;
typedef long long LLONG;
static const LLONG MOD_NUM = 1000000007;
template<class _T> static void getint(_T& a) {
const char* fmt = " %d";
if (sizeof(_T) == sizeof(long long)) {
fmt = " %lld";
}
if (scanf(fmt, &a) < 0) {
printf("g1int Error\n");
}
}
template<class _T> static void getint(_T& a, _T& b) {
const char* fmt = " %d %d";
if (sizeof(_T) == sizeof(long long)) {
fmt = " %lld %lld";
}
if (scanf(fmt, &a, &b) < 0) {
printf("g2int Error\n");
}
}
template<class _T> static void getint(_T& a, _T& b, _T& c) {
const char* fmt = " %d %d %d";
if (sizeof(_T) == sizeof(long long)) {
fmt = " %lld %lld %lld";
}
if (scanf(fmt, &a, &b, &c) < 0) {
printf("g3int Error\n");
}
}
static void ABC096D();
#if 1
int main()
{
ABC096D();
fflush(stdout);
return 0;
}
#endif
template <class _T> void tp_getPrimes(_T targ, std::map<_T, _T>& primes)
{
_T target = targ;
_T i = 2;
while ((i * i) <= target) {
if ((target % i) == 0) {
target /= i;
primes[i]++;
}
else {
i++;
}
}
if (target > 1) {
primes[target]++;
}
}
static void ABC096D()
{
int N;
getint(N);
int count = 0;
std::vector<int> primeNumbers;
for (int i = 2; (i <= 55555) && (count < N); i++) {
std::map<int, int> primes;
tp_getPrimes<int>(i, primes);
if ((primes.size() == 1) && (primes.begin()->second == 1)) {
if (primes.begin()->first % 5 == 1) {
primeNumbers.push_back(primes.begin()->first);
count++;
}
}
}
std::string str;
for (int i = 0; i < N; i++) {
char tmp[16] = { 0 };
sprintf(tmp, "%d", primeNumbers[i]);
if (i) {
str += ' ';
}
str += tmp;
}
printf("%s\n", str.c_str());
}
| 1 |
#include <bits/stdc++.h>
#include <atcoder/all>
#define rep(i,n) for(int i=(0);i<(n);i++)
using namespace std;
using namespace atcoder;
typedef long long ll;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
vector<ll> a(n);
rep(i, n) cin >> a[i];
fenwick_tree<ll> fw(n);
rep(i, n) fw.add(i, a[i]);
rep(i, q){
int t;
cin >> t;
if(t == 0){
ll p, x;
cin >> p >> x;
fw.add(p, x);
}else{
ll l, r;
cin >> l >> r;
cout << fw.sum(l, r) << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n,m;
cin >> n >> m;
int k=m*2+1;
// first part
for ( int l=1,r=m; l<r; l++,r-- ) {
cout << l << ' ' << r << '\n';
}
for ( int l=m+1,r=k; l<r; l++,r-- ) {
cout << l << ' ' << r << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define ll long long
#define ls id << 1
#define rs id << 1 | 1
#define mem(array, value, size, type) memset(array, value, ((size) + 5) * sizeof(type))
#define memarray(array, value) memset(array, value, sizeof(array))
#define fillarray(array, value, begin, end) fill((array) + (begin), (array) + (end) + 1, value)
#define fillvector(v, value) fill((v).begin(), (v).end(), value)
#define pb(x) push_back(x)
#define st(x) (1LL << (x))
#define pii pair<int, int>
#define mp(a, b) make_pair((a), (b))
#define Flush fflush(stdout)
#define vecfirst (*vec.begin())
#define veclast (*vec.rbegin())
#define vecall(v) (v).begin(), (v).end()
#define vecupsort(v) (sort((v).begin(), (v).end()))
#define vecdownsort(v, type) (sort(vecall(v), greater<type>()))
#define veccmpsort(v, cmp) (sort(vecall(v), cmp))
using namespace std;
const int N = 500050;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
clock_t TIME__START, TIME__END;
void program_end()
{
#ifdef ONLINE
printf("\nTime used: %.6lf(s)\n", ((double)TIME__END - TIME__START) / 1000);
system("pause");
#endif
}
int h, w;
int A[N], B[N], cnt[N];
map<int, int> c;
inline void solve()
{
scanf("%d%d", &h, &w);
for (int i = 1; i <= h; ++i)
scanf("%d%d", &A[i], &B[i]);
for (int i = 1; i <= w; ++i)
c.insert(mp(i, i));
int ans = 0;
cnt[0] = w;
for (int i = 1; i <= h; ++i)
{
int L = A[i], R = B[i];
auto it = c.lower_bound(L);
int pos = 0;
while (it != c.end() && it->first <= R + 1)
{
pos = max(pos, it->second);
cnt[it->first - it->second]--;
it = c.erase(it);
}
if (pos && R + 1 <= w)
{
cnt[R + 1 - pos]++;
c.insert(mp(R + 1, pos));
}
while (!cnt[ans] && ans < w)
ans++;
if (ans == w)
puts("-1");
else
printf("%d\n", ans + i);
}
}
int main()
{
TIME__START = clock();
int Test = 1;
// scanf("%d", &Test);
while (Test--)
solve();
TIME__END = clock();
program_end();
return 0;
} | #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef vector<double> Vec;
typedef vector<Vec> Mat;
typedef pair<ll,ll> P;
typedef pair<double,ll> Pd;
typedef pair<double,double> PD;
typedef priority_queue<P,vector<P>,greater<P> > P_queue;
typedef priority_queue<Pd,vector<Pd>,greater<Pd> > Pd_queue;
const ll MOD=998244353;
const ll mod=1000000007;
const ll INF=1e15;
const double DEL=1e-6;
#define _GLIBCXX_DEBUG
#define REP(i,a,b) for(int i=(int)a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define mp make_pair
#define ALL(a) a.begin(),a.end()
#define U_ERASE(V) V.erase(unique(ALL(V)), V.end())
void Add(ll &a, ll b){
a=(a+b)%mod;
return;
}
void Pro(ll &a, ll b){
a=(a*b)%mod;
return;
}
ll H,W;
vector<P> d;
vec ans;
void init(){
cin>>H>>W;
rep(i,H){
ll x,y; cin>>x>>y;
x--; y--;
d.pb(mp(x,y));
ans.pb(-1);
}
}
void Solve(){
set<P> x;
multiset<ll> y;
rep(i,W) {
P f=mp(i,i);
x.insert(f);
y.insert(0);
}
rep(i,H){
ll Biggest=-INF;
for(auto itr=x.lower_bound(mp(d[i].first,-INF));itr!=x.end();){
ll R=(*itr).first, L=(*itr).second;
// cout<<i<<':'<<R<<' '<<L<<endl;
if(R>d[i].second+1) break;
Biggest=max(Biggest,L);
auto itr1=y.lower_bound(R-L);
y.erase(itr1);
itr=x.erase(itr);
}
if(Biggest!=-INF) if(d[i].second!=W-1) {x.insert(mp(d[i].second+1,Biggest)); y.insert(d[i].second+1-Biggest);}
if(y.size()) ans[i]=*(y.begin());
else break;
}
rep(i,H) if(ans[i]>=0) ans[i]+=(i+1);
}
int main(){
init();
Solve();
rep(i,H) cout<<ans[i]<<endl;
}
| 1 |
#include <iostream>
#include <string>
using namespace std;
int main() {
string cipher;
while (getline(cin, cipher)) {
for (int i = 0; i < 26;i++) {
for (unsigned int n = 0;n < cipher.length();n++) {
if (cipher.at(n) == 'z') {
cipher.at(n) = 'a';
}
else if (cipher.at(n) >= 'a'&&cipher.at(n) <= 'y') {
cipher.at(n)++;
}
}
if (cipher.find("the") != string::npos ||
cipher.find("this") != string::npos ||
cipher.find("that") != string::npos) {
cout << cipher << endl;
}
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define ar array
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T> using oset = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()
#define F_OR(i, a, b, s) for (int i=(a); (s)>0?i<(b):i>(b); i+=(s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define EACH(x, a) for (auto& x: a)
template<class A> void read(vt<A>& v);
template<class A, size_t S> void read(ar<A, S>& a);
template<class T> void read(T& x) {
cin >> x;
}
void read(double& d) {
string t;
read(t);
d=stod(t);
}
void read(long double& d) {
string t;
read(t);
d=stold(t);
}
template<class H, class... T> void read(H& h, T&... t) {
read(h);
read(t...);
}
template<class A> void read(vt<A>& x) {
EACH(a, x)
read(a);
}
template<class A, size_t S> void read(array<A, S>& x) {
EACH(a, x)
read(a);
}
string to_string(char c) {
return string(1, c);
}
string to_string(bool b) {
return b?"true":"false";
}
string to_string(const char* s) {
return string(s);
}
string to_string(string s) {
return s;
}
string to_string(vt<bool> v) {
string res;
FOR(sz(v))
res+=char('0'+v[i]);
return res;
}
template<size_t S> string to_string(bitset<S> b) {
string res;
FOR(S)
res+=char('0'+b[i]);
return res;
}
template<class T> string to_string(T v) {
bool f=1;
string res;
EACH(x, v) {
if(!f)
res+=' ';
f=0;
res+=to_string(x);
}
return res;
}
template<class A> void write(A x) {
cout << to_string(x);
}
template<class H, class... T> void write(const H& h, const T&... t) {
write(h);
write(t...);
}
void print() {
write("\n");
}
template<class H, class... T> void print(const H& h, const T&... t) {
write(h);
if(sizeof...(t))
write(' ');
print(t...);
}
void DBG() {
cerr << "]" << endl;
}
template<class H, class... T> void DBG(H h, T... t) {
cerr << to_string(h);
if(sizeof...(t))
cerr << ", ";
DBG(t...);
}
#ifdef _DEBUG
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif
template<class T> void offset(ll o, T& x) {
x+=o;
}
template<class T> void offset(ll o, vt<T>& x) {
EACH(a, x)
offset(o, a);
}
template<class T, size_t S> void offset(ll o, ar<T, S>& x) {
EACH(a, x)
offset(o, a);
}
mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) {
return uniform_int_distribution<ll>(a, b)(mt_rng);
}
const int d4i[4]={-1, 0, 1, 0}, d4j[4]={0, 1, 0, -1};
const int d8i[8]={-1, -1, 0, 1, 1, 1, 0, -1}, d8j[8]={0, 1, 1, 1, 0, -1, -1, -1};
ll mod=1e9+7;
const int N=1e6+5;
const ld PI=2*acos(0.0);
ll modpow(ll a, ll b){
ll res=1; a%=mod;
while(b){
if(b&1){ res=(res*a)%mod;}
a=(a*a)%mod;
b>>=1;
}
return res;
}
#define lcm(a,b) ((a)*(b))/(__gcd(a,b))
bool compare(array<int,2> a,array<int,2> b){
return a[0]<b[0];
}
void solve() {
int n,t; read(n,t);
vt<array<int,2> > td(n+1);
FOR(i,1,n+1) read(td[i][0],td[i][1]);
sort(++td.begin(),td.end(),compare);
int siz=(*--td.end())[0]+t+5;
vt<int> dp(siz,0);
vt<int> pre(siz,0);
FOR(i,1,n+1){
FOR(j,1,siz){
if(j-td[i][0]<0||j-td[i][0]>=t) { dp[j]=pre[j];}
else{ dp[j]=max(pre[j],pre[j-td[i][0]]+td[i][1]);}
}
FOR(j,1,siz){ pre[j]=dp[j]; dp[j]=0; }
//dbg(i,pre);
}
print(*max_element(all(pre)));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define REP(i,a,n) for(ll i=a;i<n;i++)
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef tuple<int,int,int> tiii;
typedef pair<ll, ll> pll;
const int INF = 100000000;
const ll LINF = 1e18+5;
ll A[200000];
ll B[200000];
ll C[200000];
ll D[400000];
//ll T[200000];
int main() {
ll N;
cin >> N;
rep(i,N) cin >> A[i];
rep(i,N) cin >> B[i];
rep(i,N) {
C[i] = A[i] ^ A[(i+1)%N];
D[i] = B[i] ^ B[(i+1)%N];
D[i+N] = D[i];
}
ll pos = 0;
ll wpos = 0;
// T構築
/*ll tpos = 2;
ll twpos = -1;
T[0] = -1;
T[1] = 0;
while(tpos < N) {
if (C[tpos-1] == C[twpos]) {
T[tpos] = twpos + 1;
tpos++;
twpos++;
} else if (twpos > 0) {
twpos = T[twpos];
} else {
T[tpos] = 0;
tpos++;
}
}*/
vector<int> T(N+1);
T[0] = -1;
int j = -1;
for (int i = 0; i < N; i++) {
while (j >= 0 && C[i] != C[j]) j = T[j];
T[i+1] = ++j;
}
vector<ll> Ks;
while(pos + wpos < 2*N-1) {
if(C[wpos] == D[pos+wpos]) {
wpos++;
if(wpos == N) {
Ks.push_back((N-pos)%N);
pos = pos + wpos - T[wpos];
wpos = T[wpos];
}
} else {
pos = pos + wpos - T[wpos];
if(wpos > 0) wpos = T[wpos];
}
}
sort(Ks.begin(), Ks.end());
for(auto k : Ks) {
ll x = B[0] ^ A[k];
cout << k << " " << x << endl;
}
return 0;
} | #include<iostream>
#include<vector>
using namespace std;
struct Answer
{
int m;
vector<int> G;
int cnt;
};
void insertionSort(vector<int> &A, int &g, int &cnt)
{
for(int i = g; i < A.size(); i++){
int v = A[i];
int j = i - g;
while(j >= 0 && A[j] > v){
A[j+g] = A[j];
j = j - g;
cnt++;
}
A[j+g] = v;
}
}
vector<int> FindShellSortNumber(int n)
{
int g = 1;
vector<int> G;
while(g <= n){
G.push_back(g);
g = 3 * g + 1;
}
int size = G.size();
for(int i = 1; i <= size / 2; i++){
swap(G[i-1], G[size-i]);
}
return G;
}
Answer shellSort(vector<int> &A)
{
Answer Result;
Result.cnt = 0;
Result.G = FindShellSortNumber(A.size());
Result.m = Result.G.size();
for(int i = 0; i < Result.m; i++){
insertionSort(A, Result.G[i], Result.cnt);
}
return Result;
}
int main()
{
int n;
cin >> n;
vector<int> A;
A.resize(n);
for(int i = 0; i < n; i++){
cin >> A[i];
}
Answer Result = shellSort(A);
cout << Result.m << endl;
for(int i = 0; i < Result.G.size() - 1; i++){
cout << Result.G[i] << ' ';
}
cout << Result.G[Result.G.size() - 1] << endl;
cout << Result.cnt << endl;
for(int i = 0; i < A.size(); i++){
cout << A[i] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define TOP 0
#define FRONT 1
#define LEFT 2
#define RIGHT 3
#define BACK 4
#define BOTTOM 5
using namespace std;
//TOP,FRONT,LEFT,RIGHT,BACK,BOTTOM
int dice[6]={1,2,4,3,5,6};
void rotN(){
swap(dice[TOP],dice[FRONT]);
swap(dice[FRONT],dice[BOTTOM]);
swap(dice[BOTTOM],dice[BACK]);
}
void rotS(){rotN(),rotN(),rotN();}
void rotE(){
swap(dice[TOP],dice[LEFT]);
swap(dice[LEFT],dice[BOTTOM]);
swap(dice[BOTTOM],dice[RIGHT]);
}
void rotW(){rotE(),rotE(),rotE();}
void rotCW(){
swap(dice[FRONT],dice[RIGHT]);
swap(dice[RIGHT],dice[BACK]);
swap(dice[BACK],dice[LEFT]);
}
void rotCCW(){rotCW(),rotCW(),rotCW();}
int main(){
cin>>dice[TOP]>>dice[FRONT]>>dice[RIGHT];
cin>>dice[LEFT]>>dice[BACK]>>dice[BOTTOM];
string str;
cin>>str;
for(int i=0;i<str.size();i++){
if(str[i]=='N') rotN();
if(str[i]=='S') rotS();
if(str[i]=='E') rotE();
if(str[i]=='W') rotW();
}
cout << dice[TOP]<<endl;
} | #include <bits/stdc++.h>
#include<math.h>
#include<algorithm>
#define rep(i,n) for (int i = 0; i < (n) ; ++i)
using namespace std;
using ll = long long ;
using P = pair<int, int> ;
#define PI 3.14159265358979323846264338327950
#define INF 1e18
#define mod 1000000007
ll gcd (ll x, ll y){
ll r = x % y ;
if(r == 0) return y ;
return gcd(y, r) ;
}
bool isprime(ll x){
ll s = sqrt((double) x) ;
for(ll i = 2; i <= s ; i++){
if(x % i == 0) return false ;
}
return true ;
}
int main (){
ll a, b ;
cin >> a >> b ;
ll k = gcd(a, b) ;
ll s = sqrt((double)k) ;
vector<ll> y ;
for(ll i = 1; i <= s; i++){
if(k % i == 0){
y.push_back(i) ;
if(i != k/i){
y.push_back(k/i) ;
}
}
}
sort(y.begin(), y.end()) ;
ll num = y.size() ;
ll ans = 0 ;
rep(i, num){
if(isprime(y[i])) ans++ ;
}
cout << ans << endl ;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
int sum = 0;
for (int i = A; i <= B; i++) {
int x = i;
int n1 = x % 10;
x = x / 10;
int n2 = x % 10;
x = x / 10;
//int n3 = x % 10;
x = x / 10;
int n4 = x % 10;
x = x / 10;
int n5 = x;
if (n1 == n5 && n2 == n4) {
sum++;
}
}
cout << sum << endl;
}
| #include <iostream>
using namespace std;
int main()
{
int r;
int g;
//int ans;
cin >> r;
cin >> g;
cout << 2 * g - r << endl;
} | 0 |
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <bitset>
#include <math.h>
typedef long long ll;
typedef unsigned long long ull;
#define vi std::vector<int>
#define vl std::vector<ll>
#define floop(n) for(int i = 0; i < n; ++i)
#define print(x) std::cout << x << std::endl;
const ll INF = 1e18;
int main()
{
int A, B;
std::cin >> A >> B;
print(A*B);
return 0;
} | #include<cstdio>
#include<set>
using namespace std;
set<int> numbers;
int n, k, cards[10], used[10];
void addcard(int x, int y){
if(x == 0){
numbers.insert(y);
}
for(int i = 0;i < n;i++){
if(used[i] == 0){
int shift = 10;
if(cards[i] >= 10)shift *= 10;
used[i] = 1;
addcard(x - 1, y * shift + cards[i]);
used[i] = 0;
}
}
}
int main(){
while(1){
numbers.clear();
scanf("%d%d", &n, &k);
if(n == 0 && k == 0)return 0;
for(int i = 0;i < n;i++){
used[i] = 0;
scanf("%d", cards + i);
}
addcard(k, 0);
printf("%d\n", numbers.size());
}
} | 0 |
#include<stdio.h>
#define ll long long
int main(){
ll n, rev, i = 0;
scanf("%lld", &n);
char str[100];
while(n){
if(n == 0){
break;
}
n--;
rev = n % 26;
n /= 26;
str[i] = 'a' + rev;
i++;
}
for(ll j = i - 1; j >= 0; j--){
printf("%c", str[j]);
}
puts("");
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
long long N;
cin >> N;
string S="";
while(N){
N--;
int A=N%26;
N/=26;
char a='a'+A;
S.push_back(a);
}
reverse(S.begin(),S.end());
cout << S << endl;
} | 1 |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define SIZE 12
char A[SIZE],B[SIZE],C[SIZE];
int main(){
scanf("%s %s %s",A,B,C);
char last_a,last_b;
for(int i = 0; A[i] != '\0'; i++){
last_a = A[i];
}
for(int i = 0; B[i] != '\0'; i++){
last_b = B[i];
}
if(last_a == B[0] && last_b == C[0]){
printf("YES\n");
}else{
printf("NO\n");
}
return 0;
}
| #include <iostream>
#include <utility>
#include <map>
#include <vector>
#include <algorithm>
#include <queue>
#include <math.h>
#include <stack>
#include <set>
#include <deque>
#include <cmath>
using namespace std;
typedef long long ll;
ll mod = 1e9+7;
//ll mod = 998244353;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
int h, w, n;
cin >> h >> w >> n;
cout << (n + max(h, w) - 1) / max(h, w) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct data {
string l;
int p, a, b, c, d, e, f, s, m;
};
int n;
vector<data> v;
bool ch(data l, data r);
void solve();
double calc(data now);
int main() {
while(1) {
cin >> n;
if(n == 0) break;
for(int i = 0; i < n; ++i) {
data now;
cin >> now.l >> now.p >> now.a >> now.b >> now.c >>
now.d >> now.e >> now.f >> now.s >> now.m;
v.push_back(now);
}
solve();
for(int i = 0; i < n; ++i) cout << v[i].l << endl;
cout << "#" << endl;
v.erase(v.begin(), v.end());
}
return 0;
}
bool ch(data l, data r) {
double nowl = calc(l), nowr = calc(r);
if(nowl != nowr) return nowl > nowr;
return l.l < r.l;
}
void solve() { sort(v.begin(), v.end(), ch); }
double calc(data now) {
double sumt =
now.a + now.b + now.c + (now.d + now.e) * now.m;
return (now.s * now.f * now.m - now.p) / sumt;
}
| #include<bits/stdc++.h>
using namespace std;
pair<int,int> pii;
int main() {
int w,h,n;
int xs,ys;
int xg,yg;
int c,d,x,y;
int v[101][101];
int u[101][101];
int flag=0;
int xx[4]={-1,0,1,0};
int yy[4]={0,1,0,-1};
int xxx,yyy;
while(cin>>w>>h,w||h){
cin>>xs>>ys;
cin>>xg>>yg;
cin>>n;
fill(v[0],v[101],0);
fill(u[0],u[101],0);
for (int i = 0; i < n; ++i) {
cin>>c>>d>>x>>y;
if(d==0){
v[x][y]=c; v[x+1][y]=c; v[x+2][y]=c; v[x+3][y]=c;
v[x][y+1]=c; v[x+1][y+1]=c; v[x+2][y+1]=c; v[x+3][y+1]=c;
}
if(d==1){
v[x][y]=c; v[x][y+1]=c; v[x][y+2]=c; v[x][y+3]=c;
v[x+1][y]=c; v[x+1][y+1]=c; v[x+1][y+2]=c; v[x+1][y+3]=c;
}
}
queue<pair<int,int> > q;
u[xs][ys]=1;
int color=v[xs][ys];
q.push(make_pair(xs,ys));
while(!q.empty()){
pii=q.front();q.pop();
if(pii.first==xg&&pii.second==yg){flag=1;break;}
for (int i = 0; i < 4; ++i) {
xxx=xx[i]+pii.first;
yyy=yy[i]+pii.second;
if(xxx>=1&&xxx<=w&&yyy>=1&&yyy<=h&&u[xxx][yyy]!=1&&color==v[xxx][yyy]){
u[xxx][yyy]=1;
q.push(make_pair(xxx,yyy));
}
}
}
if(flag){cout<<"OK"<<endl;}
else{cout<<"NG"<<endl;}
flag=0;
}
return 0;
} | 0 |
#include<iostream>
#include<cmath>
#include<iomanip>
#include<string>
#include<vector>
#include<stack>
#include<cstdlib>
#include<queue>
#include<list>
using namespace std;
int main(){
int n, m, b, j, ans=0;
cin>>n;
int a[n+1];
for(int i=0; i<n; i++) cin>>a[i];
cin>>m;
for(int i=0; i<m; i++){
cin>>b;
a[n]=b;
for( j=0; a[j]!=b; j++);
if(j!=n)ans++;
}
cout<<ans<<endl;
}
| #include <iostream>
#include <algorithm>
#include <climits>
#include <vector>
#include <queue>
#include <stack>
#include <list>
using namespace std;
int main(int argc, char *argv[])
{
vector<int> S;
int q = 0;
int t = 0;
int C = 0;
int n = 0;
int s = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
S.push_back(s);
}
sort(S.begin(), S.end());
cin >> q;
for (int i = 0; i < q; i++) {
cin >> s;
int start = 0;
int end = S.size();
while (start < end) {
// cout << start <<" "<< end << "\n";
if (S[(int)((end + start)/2)] < s) {
start = (int)((end+start)/2)+1;
}else if(S[(int)((end + start)/2)] > s){
end = (int)((end + start)/2);
}
else{
C++;
break;
}
}
}
cout << C << "\n";
return 0;
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; i--)
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int inf = 1000000007;
const int MOD = 1000000007;
const long long INF = 1000000000000000007;
// -------------------------------------------------------
int A, B;
int main() {
cin >> A >> B;
int cnt_w = 1, cnt_b = 1;
cout << 100 << " " << 100 << "\n";
rep(h, 0, 50) {
rep(w, 0, 100) {
if (h % 2 == 0 && w % 2 == 0) {
if (cnt_b < B) {
cout << '#';
++cnt_b;
} else {
cout << ".";
}
} else {
cout << ".";
}
if (w == 99) {
cout << "\n";
}
}
}
rep(h, 50, 100) {
rep(w, 0, 100) {
if (h % 2 == 1 && w % 2 == 0) {
if (cnt_w < A) {
cout << '.';
++cnt_w;
} else {
cout << '#';
}
} else {
cout << '#';
}
if (w == 99) {
cout << "\n";
}
}
}
}
| #pragma region
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <list>
#include <iomanip>
#include <cstdint>
#include <bitset>
using namespace std;
typedef long long ll;
//#define rep(i, s, e) for (int(i) = (s); (i) < (e); ++(i))
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s) - 1; (i) >= 0; --(i))
#define all(x) x.begin(),x.end()
#pragma region UnionFind
struct UnionFind
{
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x)
{
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y)
{
return root(x) == root(y);
}
bool merge(int x, int y)
{
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x)
{
return -par[root(x)];
}
};
#pragma endregion
#pragma region GCD
int gcd(int a, int b)
{
if (a%b == 0)return b;
return gcd(b, a%b);
}
#pragma endregion
#pragma region chmin
template<class T> inline bool chmin(T& a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma region chmax
template<class T> inline bool chmax(T& a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma endregion
int main()
{
int a, b; cin >> a >> b;
vector<string> res;
rep(i, 50)
{
string s = "";
rep(j, 100)s += '.';
res.push_back(s);
}
rep(i, 50)
{
string s = "";
rep(j, 100)s += '#';
res.push_back(s);
}
int x = 0;
int y = 0;
--a, --b;
while (b > 0)
{
if (y >= 100)
{
x += 2;
y = 0;
}
res[x][y] = '#';
y += 2;
--b;
}
x = 51;
y = 0;
while (a > 0)
{
if (y >= 100)
{
x += 2;
y = 0;
}
res[x][y] = '.';
y += 2;
--a;
}
cout << 100 << " " << 100 << endl;
rep(i, 100)cout << res[i] << endl;
} | 1 |
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cmath>
#include<cstring>
#include<climits>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
#define LL long long
//#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
//char buf[(1 << 21) + 1], *p1 = buf, *p2 = buf;
inline int read() {
bool f=0;int x=0;char c=getchar();
while(c<'0'||'9'<c){if(c==EOF)exit(0);if(c=='-')f=1;c=getchar();}
while('0'<=c&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
return !f?x:-x;
}
#define MAXN 2000
#define INF 0x3f3f3f3f
#define Mod (int)(1e9+7)
LL fac[MAXN*MAXN+5],inv[MAXN*MAXN+5];
LL Pow(LL x,LL y){
LL ret=1;
while(y){
if(y&1) ret=ret*x%Mod;
x=x*x%Mod,y>>=1;
}
return ret;
}
void Prepare(){
fac[0]=1;
for(int i=1;i<=MAXN*MAXN;i++)
fac[i]=fac[i-1]*i%Mod;
inv[MAXN*MAXN]=Pow(fac[MAXN*MAXN],Mod-2);
for(int i=MAXN*MAXN-1;i>=0;i--)
inv[i]=inv[i+1]*(i+1)%Mod;
return ;
}
LL f[MAXN+5][MAXN+5];
LL C(int n,int m){
if(n<m) return 0;
return fac[n]*inv[m]%Mod*inv[n-m]%Mod;
}
int main(){
Prepare();
int n=read(),k=read();
if(k==1)
puts("1"),exit(0);
f[0][0]=1;
for(int i=1;i<=n;i++){
f[i][0]=1;
for(int j=1;j<=i;j++)
f[i][j]=(f[i-1][j]+C(n-i+(n-(j-1))*(k-1)-1,k-2)*f[i][j-1]%Mod)%Mod;
}
printf("%lld\n",f[n][n]*fac[n]%Mod);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a), i##_end_ = (b); i <= i##_end_; ++i)
#define drep(i, a, b) for(int i = (a), i##_end_ = (b); i >= i##_end_; --i)
#define clar(a, b) memset((a), (b), sizeof(a))
#define debug(...) fprintf(stderr, __VA_ARGS__)
typedef long long LL;
typedef long double LD;
const int BUF_SIZE = (int)1e6 + 10;
struct fastIO {
char buf[BUF_SIZE], buf1[BUF_SIZE];
int cur, cur1; FILE *in, *out;
fastIO() { cur = BUF_SIZE, in = stdin, out = stdout; cur1 = 0; }
inline char getchar() { if(cur == BUF_SIZE) fread(buf, BUF_SIZE, 1, in), cur = 0; return *(buf + (cur++)); }
inline void putchar(char ch) { *(buf1 + (cur1++)) = ch; if (cur1 == BUF_SIZE) fwrite(buf1, BUF_SIZE, 1, out), cur1 = 0; } inline int flush() { if (cur1 > 0) fwrite(buf1, cur1, 1, out); return cur1 = 0; }
}IO;
#define getchar IO.getchar
#define putchar IO.putchar
LL read() {
char ch = getchar();
LL x = 0, flag = 1;
for (;!isdigit(ch); ch = getchar()) if (ch == '-') flag *= -1;
for (;isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
return x * flag;
}
void write(LL x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
const int Maxn = 4009, Mod = 1e9 + 7;
int n, k, fac[Maxn * Maxn / 4], invFac[Maxn * Maxn / 4];
LL fpm(LL base, LL tims) {
LL r = 1;
while (tims) {
if (tims & 1) r = r * 1ll * base % Mod;
base = base * 1ll * base % Mod;
tims >>= 1;
}
return r;
}
void init() {
n = read(), k = read();
fac[0] = 1;
rep (i, 1, n * k) fac[i] = fac[i - 1] * 1ll * i % Mod;
invFac[n * k] = fpm(fac[n * k], Mod - 2);
drep (i, n * k - 1, 0) invFac[i] = invFac[i + 1] * (i + 1ll) % Mod;
}
LL C(int n, int m) {
if (n < m) return 0;
return 1ll * fac[n] * invFac[m] % Mod * invFac[n - m] % Mod;
}
LL dp[Maxn][Maxn];
void solve() {
if (k == 1) {
puts("1");
return ;
}
dp[0][0] = 1;
rep (i, 0, n)
rep (j, 0, i) {
(dp[i + 1][j] += dp[i][j]) %= Mod;
(dp[i][j + 1] += dp[i][j] * 1ll * C(n * k - i - j * (k - 1) - 1, k - 2) % Mod) %= Mod;
}
cout << 1ll * dp[n][n] * fac[n] % Mod << endl;
}
int main() {
// freopen("bosky.in", "r", stdin);
// freopen("bosky.out", "w", stdout);
init();
solve();
#ifdef Qrsikno
debug("\nRunning time: %.3lf(s)\n", clock() * 1.0 / CLOCKS_PER_SEC);
#endif
return IO.flush();
}
| 1 |
#include <iostream>
using namespace std;
void MySwap(int &a, int &b){
int tmp = a;
a = b;
b = tmp;
}
int partition(int *A, int p, int r){
int x = A[r];
int i = p - 1;
for(int j = p; j < r; j++){
if(A[j] <= x){
MySwap(A[++i], A[j]);
}
}
MySwap(A[++i], A[r]);
return i;
}
int main(){
int A[100000], n, place;
cin >> n;
for(int i = 0; i < n; i++) cin >> A[i];
place = partition(A, 0, n-1);
for(int i = 0; i < n; i++)
cout << (i==place?"[":"") << A[i] << (i==place?"]":"") << (i==n-1?'\n':' ');
return 0;
}
| #include <iostream>
#include <utility>
static int isort(long *a, int n, int g) {
int c = 0;
for (int i = g; i < n; ++i) {
long v = a[i];
int j = i - g;
for (; j >= 0 && a[j] > v; j -= g, ++c) {
a[j + g] = a[j];
}
a[j + g] = v;
}
return c;
}
static int ssort(long *a, int n) {
int c = 0, m = 1, g[100] = { 1 };
for (int gm = 3 * g[0] + 1; gm < n; gm = 3 * g[++m - 1] + 1) {
g[m] = gm;
}
std::cout << m << std::endl;
for (int i = 0; i < m; ++i) {
std::cout << ((i == 0) ? "" : " ") << g[m - i - 1];
c += isort(a, n, g[m - i - 1]);
}
std::cout << std::endl;
return c;
}
int main() {
int n;
long a[1000000];
std::cin >> n;
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
}
std::cout << ssort(a, n) << std::endl;
for (int i = 0; i < n; ++i) {
std::cout << a[i] << std::endl;
}
}
| 0 |
#include <iostream>
#include <vector>
#include <algorithm>
int main(void){
int N, x, ans=0;
std::cin >> N >> x;
std::vector<int> a(N);
for (int i=0; i<N; ++i){
std::cin >> a.at(i);
}
std::sort(a.begin(), a.end());
for (int i: a) {
x -= i;
if (x < 0){
break;
} else {
++ans;
}
}
if (x > 0 && ans > 0) {
--ans;
}
std::cout << ans << std::endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define req(i,n,m) for(int i=n;i<m;i++)
#define REQ(i,n,m,l) for(int i=n;i<m;i+=l)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
signed gcd(int x, int y) {
if (y == 0)return x;
return gcd(y, x % y);
}
signed lcm(int x, int y) {
return x / gcd(x, y) * y;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main() {
long long N, x; cin >> N >> x;
vector < long long > a(N);
long long count = 0;
rep(i, N) {
cin >> a[i];
count += a[i];
}
long long A = abs(x - count);
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
rep(i, N) {
if (A <= 0) {
cout << N-i << endl;
return 0;
}
A -= a[i];
}
cout << 0 << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
bool pal(int a)
{
return true;
}
int main()
{
int n,m,mn=0,mx;
cin>>n>>m;
mx=n+1;
for(int i=0;i<m;i++)
{
int a,b;
cin>>a>>b;
if(a>=mn)
mn=a;
if(b<=mx)
mx=b;
}
if(mn>mx)
cout<<0;
else
cout<<mx-mn+1;
return 0;
}
| #pragma GCC target ("avx2")
#pragma GCC optimize ("unroll-loops")
#pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include <unordered_set>
#include <unordered_map>
#include <random>
using namespace std;
typedef long long ll;
const ll MOD = /*1'000'000'007LL;*/ 998'244'353LL;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
const int dx[4]={ 1,0,-1,0 };
const int dy[4]={ 0,1,0,-1 };
int N;
int L[100000], R[100000]; // [L,R)
pair<int, int> sec[100000];
vector<pair<int, int>> v;
signed main(){
cin >> N;
rep(i, N){
cin >> L[i] >> R[i];
L[i]--;
sec[i] ={ L[i],-R[i] };
}
sort(sec, sec+N);
rep(i, N){
while(v.size() > 0 && v.back().second >= -sec[i].second){
v.pop_back();
}
v.pb({ sec[i].first,-sec[i].second });
}
if(v.size() == 1){
int ans = 0;
rep(i, N-1){
ans = max(ans, -sec[i].second - sec[i].first);
}
cout << ans + -sec[N-1].second - sec[N-1].first << endl;
exit(0);
}
int ans = 0;
for(int i=1; i<v.size(); i++){
ans = max(ans, max(0, v[0].second-v[i-1].first) + max(0, v[i].second-v[v.size()-1].first));
}
set<pair<int,int>> l, r;
rep(i, N){
l.insert({ L[i],i });
r.insert({ R[i],i });
}
rep(i, N){
l.erase({ L[i],i });
r.erase({ R[i],i });
ans = max(ans, R[i]-L[i] + max(0, r.begin()->first-prev(l.end())->first));
l.insert({ L[i],i });
r.insert({ R[i],i });
}
cout << ans << endl;
} | 0 |
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) range(i,0,b)
#define debug(x) cout << "debug" << x << endl;
using namespace std;
int main(){
double a, b, c, d;
while(cin >> a >> b >> c >> d){
double ans = sqrt( (c-a) * (c-a) + (d-b) * (d-b));
printf("%.6lf",ans);
}
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cstring>
#include <climits>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };
int MOD = 1000000007;
int main() {
double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
double dx = x2 - x1, dy = y2 - y1;
printf("%f\n", sqrt(dx * dx + dy * dy));
} | 1 |
#include<iostream>
#include<string>
using namespace std;
int Roman_to_Arabia(char c){
if (c == 'I')return 1;
else if (c == 'V')return 5;
else if (c == 'X')return 10;
else if (c == 'L')return 50;
else if (c == 'C')return 100;
else if (c == 'D')return 500;
else if (c == 'M')return 1000;
else return 0;
}
int main(){
string roman;
int num;
while (cin >> roman){
num = 0;
for (int i = 0; i < roman.size(); ++i){
if (Roman_to_Arabia(roman[i]) < Roman_to_Arabia(roman[i + 1]))
num -= Roman_to_Arabia(roman[i]);
else
num += Roman_to_Arabia(roman[i]);
}
cout << num << endl;
}
return 0;
} | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef vector <int> vi;
int main(void){
map <char, int> m;
vi x;
int num[] = {1,5,10,50,100,500,1000};
for (int i=0; i<7; i++)
m["IVXLCDM"[i]] = num[i];
while (true){
string roman;
cin>>roman;
if (cin.eof()) break;
int tmp, tmp2= m[roman[0]];
for (int i=0; i<(int)roman.size(); i++){
tmp = m[roman[i]];
if (i!=0 && tmp2<tmp)
x[i-1] = -tmp2;
x.push_back(tmp);
tmp2 = tmp;
}
int s=0;
for (int i=0; i<(int)x.size(); i++)
s += x[i];
cout<<s<<endl;
x.clear();
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define _for(i,j,N) for(int i = (j);i < (N);i++)
#define _rep(i,j,N) for(int i = (j);i <= (N);i++)
#define ALL(x) x.begin(),x.end()
int get_int(){int x;scanf("%d",&x);return x;}
typedef long long ll;
const int mod = 998244353;
inline int mul(int x,int y){return 1ll*x*y%mod;}
int add(int x,int y) {return x+y>=mod?x+y-mod:x+y;}
int sub(int x,int y) {return x-y>=0?x-y:x-y+mod;}
int sq(int x){return 1ll*x*x%mod;}
int pows(int a,int b){return b == 0?1:(b&1?mul(a,sq(pows(a,b/2))):sq(pows(a,b/2)));}
const int maxn = 305;
int cnt[maxn*maxn];
int cnt2[maxn*maxn];
int sum;
int N;
void cal(int n,vector<int> &vi){
cnt[0] = 1;
cnt2[0] = 1;
_for(i,0,N){
int l = vi[i];
for(int j = sum;j>=0;j--){
cnt2[j] = add(cnt2[j],cnt2[j]);
if(j-l >= 0) {
cnt[j] = add(cnt[j],cnt[j-l]);
cnt2[j] = add(cnt2[j],cnt2[j-l]);
}
}
}
}
int main()
{
vector<int> vi;
N = get_int();
_for(i,0,N){
int num = get_int();
sum += num;
vi.push_back(num);
}
sort(ALL(vi));
int ans = pows(3,N);
//printf("all:%d\n",ans);
cal(N,vi);
//_rep(i,0,sum) printf("%d\n",cnt2[i]);
_rep(i,(sum+1)/2,sum){
ans = sub(ans,mul(3,cnt2[i]));
//printf("%d\n",cnt2[i]);
}
if(!(sum&1)){
ans = add(ans,mul(cnt[sum/2],3));
}
printf("%d\n",ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i,n) for(long long i = 0; i < (n); i++)
#define FOR(i, m, n) for(long long i = (m);i < (n); ++i)
#define ALL(obj) (obj).begin(),(obj).end()
#define SPEED cin.tie(0);ios::sync_with_stdio(false);
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
const ll MOD = (ll)1e9 + 7;
const ll MOD2 = 998244353;
const ll HIGHINF = (ll)1e18;
const ll LOWINF = (ll)1e15;
const long double PI = 3.1415926535897932384626433;
template<typename T> vector<T> make_v(size_t N,T init){return vector<T>(N,init);}
template<typename... T> auto make_v(size_t N,T... t){return vector<decltype(make_v(t...))>(N,make_v(t...));}
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; exit(0);}}
template <class T, class U>ostream &operator<<(ostream &o, const map<T, U>&obj) {o << "{"; for (auto &x : obj) o << " {" << x.first << " : " << x.second << "}" << ","; o << " }"; return o;}
template <class T>ostream &operator<<(ostream &o, const set<T>&obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr) o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
template <class T>ostream &operator<<(ostream &o, const multiset<T>&obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr) o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
template <class T>ostream &operator<<(ostream &o, const vector<T>&obj) {o << "{"; for (int i = 0; i < (int)obj.size(); ++i)o << (i > 0 ? ", " : "") << obj[i]; o << "}"; return o;}
template <class T, class U>ostream &operator<<(ostream &o, const pair<T, U>&obj) {o << "{" << obj.first << ", " << obj.second << "}"; return o;}
template <template <class tmp> class T, class U> ostream &operator<<(ostream &o, const T<U> &obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr)o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
void print(void) {cout << endl;}
template <class Head> void print(Head&& head) {cout << head;print();}
template <class Head, class... Tail> void print(Head&& head, Tail&&... tail) {cout << head << " ";print(forward<Tail>(tail)...);}
template <class T> void chmax(T& a, const T b){a=max<T>(a,b);}
template <class T> void chmin(T& a, const T b){a=min<T>(a,b);}
void YN(bool flg) {cout << ((flg) ? "YES" : "NO") << endl;}
void Yn(bool flg) {cout << ((flg) ? "Yes" : "No") << endl;}
void yn(bool flg) {cout << ((flg) ? "yes" : "no") << endl;}
int main() {
ll N; cin >> N;
V<ll> a(N);
for(int i = 0; i < N; ++i) cin >> a[i];
ll sum = 0;
for(int i = 0; i < N; ++i) sum += a[i];
auto dp = make_v(N+1,sum + 1,0LL);
dp[0][0] = 1;
for(int i = 0; i < N; ++i){
for(int j = 0; j <= sum; ++j){
if(j+a[i]<=sum) (dp[i+1][j+a[i]] += dp[i][j]) %=MOD2;
(dp[i+1][j] += (2LL*dp[i][j]) % MOD2 ) %= MOD2;
}
}
auto dp2 = make_v(N+1,sum+1,0LL);
dp2[0][0] = 1;
for(int i = 0; i < N; ++i){
for(int j = 0; j <= sum; ++j){
if(j+a[i]<=sum) (dp2[i + 1][j + a[i]] += dp2[i][j]) %= MOD2;
(dp2[i+1][j] += dp2[i][j]) %=MOD2;
}
}
ll haf = sum/2 + (sum%2?1:0);
ll ans = 1;
for(int i = 0; i < N; ++i) (ans *= 3LL) %= MOD2;
for(int j = haf; j <= sum; ++j){
(ans += (MOD2 - (3LL*dp[N][j])%MOD2) ) %= MOD2;
}
if(!(sum%2)) (ans += (3LL*dp2[N][sum/2]) % MOD2 ) %= MOD2;
// for(int i = 0; i < N; ++i) print(i,a[i],dp2[i]);
// print(N,-N,dp2[N]);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
int x = 0;
int y = 0;
cin >> N;
vector<string> blue(N);
for (int i = 0; i < N; i++) {
string s;
cin >> s;
blue.at(i) = s;
}
sort(blue.begin(), blue.end());
reverse(blue.begin(), blue.end());
cin >> M;
vector<string> red(M);
for (int i = 0; i < M; i++) {
string t;
cin >> t;
red.at(i) = t;
}
sort(red.begin(), red.end());
reverse(red.begin(), red.end());
for (int j = 0; ; ) {
if (N > 1 && M > 0) {
if (blue.at(N - 1) != red.at(M - 1)) {
if (blue.at(N - 1) > red.at(M - 1)) {
red.pop_back();
M--;
}
else {
if (blue.at(N - 1) == blue.at(N - 2)) {
blue.pop_back();
N--;
x++;
}
else {
blue.pop_back();
N--;
x++;
if (x > y) {
y = x;
}
x = 0;
}
}
}
else if (blue.at(N - 1) == red.at(M - 1)) {
if (blue.at(N - 1) == blue.at(N - 2)) {
blue.pop_back();
red.pop_back();
N--;
M--;
}
else {
blue.pop_back();
red.pop_back();
N--;
M--;
if (x > y) {
y = x;
}
x = 0;
}
}
}
else if (N > 1 && M == 0)
if (blue.at(N - 1) == blue.at(N - 2)) {
blue.pop_back();
N--;
x++;
}
else {
blue.pop_back();
N--;
x++;
if (x > y) {
y = x;
}
x = 0;
}
else if (N == 1 && M == 0) {
x++;
if (x > y) {
y = x;
}
x = 0;
break;
}
else if (N == 1 && M > 0) {
if (M > 1 && blue.at(N - 1) != red.at(M - 1)) {
M--;
}
else if (M == 1 && blue.at(N - 1) != red.at(M - 1)) {
x++;
if (x > y) {
y = x;
}
x = 0;
break;
}
else if (blue.at(N - 1) == red.at(M - 1)) {
if (x > y) {
y = x;
}
x = 0;
break;
}
}
}
cout << y << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
int main() {
int n, m;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s.at(i);
cin >> m;
vector<string> t(m);
rep(i, m) cin >> t.at(i);
int ans = 0;
string say;
rep(i, n) {
int rwd = 0;
say = s.at(i);
rep(i, n) {
if(say == s.at(i)) rwd++;
}
rep(i, m) {
if(say == t.at(i)) rwd--;
}
if(rwd > ans) ans = rwd;
}
cout << ans << endl;
}
| 1 |
#include <iostream>
#include <fstream>
using namespace std;
int main() {
int n, x, t;
cin >> n >> x >> t;
int time = 0;
while (n > 0) {
time = time + t;
n = n - x;
}
cout << time;
return 0;
} | #include <iostream>
#include <cmath>
using namespace std;
int main() {
int N, X, T;
cin >> N >> X >> T;
cout << (int)(ceil(1.0*N / X) * T) << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;
using namespace atcoder;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll N, Q;
cin >> N >> Q;
fenwick_tree<ll> ft(N);
for(ll i = 0; i < N; ++i) {
ll ai;
cin >> ai;
ft.add(i, ai);
}
for(;Q-->0;) {
ll op;
cin >> op;
if (op) {
ll l, r;
cin >> l >> r;
cout << ft.sum(l, r) << endl;
} else {
ll p, x;
cin >> p >> x;
ft.add(p, x);
}
}
return 0;
}
|
#include <iostream>
#include <map>
#include <set>
#include <algorithm>
#include <vector>
#include <sstream>
#include <string>
#include <functional>
#include <queue>
#include <deque>
#include <stack>
#include <limits>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <iterator>
#include <random>
#include <chrono>
#define forr(i,start,count) for (int i = (start); i < (start)+(count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i) int i; cin >> i
#define readll(i) ll i; cin >> i
#define readdouble(i) double i; cin >> i
#define readstring(s) string s; cin >> s
typedef long long ll;
using namespace std;
ll modd = 1000 * 1000 * 1000 + 7;
template<class T>
class SegmentTree2 {
public:
SegmentTree2(const vector<T>& data, function<T(T,T)> f_, T zero_value = 0) : zv(zero_value), f(f_) {
Initialize(data);
}
SegmentTree2(int n, function<T(T,T)> f_, T zero_value = 0) : zv(zero_value), f(f_) {
vector<T> temp(n, zv);
Initialize(temp);
}
T operator[](int i) {
return tree[B+i];
}
T GetEvaluation(int L, int R) { // "min/max" on interval [L,R); 0-based indexing, as usual
if (R<=L) { return zv; }
return GetEvaluationHelper(L, R, 0, B, 1);
}
void SetVal(int i, T val) {
tree[B+i] = val;
for(int j = (B + i) / 2; j >= 1; j /= 2) {
tree[j] = f(tree[2*j], tree[2*j+1]);
}
}
private:
vector<T> tree;
int B; // power of two greater than size of input data
T zv;
function<T(T,T)> f;
void Initialize(const vector<T>& data) {
B = 1;
while(B < data.size()) {B *= 2; }
tree = std::move(vector<T>(2*B, zv));
copy(data.begin(), data.end(), next(tree.begin(), B));
for(int i = B - 1; i >= 1; --i) {
tree[i] = f(tree[2*i], tree[2*i+1]);
}
}
T GetEvaluationHelper(int L, int R, int start, int length, int tree_index) {
if (L==R) { return zv; }
if ((L==start) && (R==start+length)) { return tree[tree_index]; }
int midpoint = start + length/2;
T left_ = zv, right_ = zv;
if (L<=min(midpoint,R)) {
left_ = GetEvaluationHelper(L, min(midpoint,R), start, length/2, 2*tree_index);
}
if (max(midpoint,L)<=R) {
right_ = GetEvaluationHelper(max(midpoint,L), R, midpoint, length/2, 2*tree_index+1);
}
return f(left_, right_);
}
};
int main() {
ios_base::sync_with_stdio(false);
cout.precision(17);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> rand_gen(0, modd); // rand_gen(rng) gets the rand no
// readint(test_cases);
int test_cases = 1;
forr(t, 1, test_cases) {
readint(n); readint(q);
vector<ll> data;
forr(i,0,n) {
readint(dd); data.push_back(dd);
}
SegmentTree2<ll> seg(data, [](ll x, ll y){return x+y;}, 0);
forr(i,0,q) {
readint(a); readint(b); readint(c);
if (a==0) {
seg.SetVal(b, seg[b] + c);
}
if (a==1) {
cout << seg.GetEvaluation(b,c) << endl;
}
}
}
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int main()
{
string ans = "Yes";
int h, w;
cin >> h >> w;
vector<string> S(h);
for (int i = 0; i < h; ++i)
{
cin >> S[i];
}
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
for (int i = 0; i < h; ++i)
{
for (int j = 0; j < w; ++j)
{
if (S[i][j] == '#')
{
bool can = false;
for (int k = 0; k < 4; ++k)
{
int ni = i + dx[k];
int nj = j + dy[k];
if (ni < 0 || ni > h - 1)
{
continue;
}
if (nj < 0 || nj > w - 1)
{
continue;
}
if (S[ni][nj] == '#')
{
can = true;
}
}
if (can == false)
{
ans = "No";
}
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main(){
int n,k;
cin>>n>>k;
vector<int>a(n);
rep(i,n)cin>>a[i];
rep(i,k){
vector<int>sum(n);
rep(j,n){
int l=max(0,j-a[j]);
int r=min(n,j+a[j]+1);
sum[l]++;
if(r!=n)sum[r]--;
}
rep(j,n-1)sum[j+1]+=sum[j];
bool same=true;
rep(j,n){
if(a[j]!=sum[j])same=false;
a[j]=sum[j];
}
if(same)break;
}
rep(i,n)cout<<a[i]<<" ";
} | 0 |
#include <bits/stdc++.h>
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define pb push_back
#define all(v) v.begin(), v.end()
#define rip return;
#define fo(i,a,b) for(int i = a ; a < b ? i <= b : i >= b ; i += (a < b ? 1 : -1))
#define F first
#define S second
#define sz(x) int(x.size())
using namespace std;
using ll = long long;
using pii = pair <int, int>;
using pll = pair <ll, ll>;
using ld = long double;
const int mod = 1e9 + 7;
// const int mod = 998244353;
const ll inf = 2e9;
const ll INF = 1e18;
const ld EPS = 1e-7;
const int N = 1e6 + 55;
int dp[N], dp2[N];
int solve (string s) {
s = "0" + s;
int n = s.size();
fo (i, 0, n + 1) {
dp[i] = 0, dp2[i] = 0;
}
dp2[0] = 1;
fo (i, 1, n) {
int u = s[i - 1] - '0';
dp[i] = min (dp[i - 1] + u, dp2[i - 1] + 10 - u);
dp2[i] = min (dp2[i - 1] + 9 - u, dp[i - 1] + 1 + u);
}
return dp[n];
}
int to_int (string s) {
int res = 0;
for (char c : s) {
res = res * 10 + c - '0';
}
return res;
}
int dig (int x) {
int res = 0;
while (x) res += x % 10, x /= 10;
return res;
}
pair <int, int> brute (string s) {
int u = to_int (s);
int best = dig (u), sec = u;
for (int v = u ; v <= 1e7 ; ++ v) {
int cur = dig (v) + dig (v - u);
if (cur < best) {
sec = v;
best = cur;
}
// best = min (best, dig (v) + dig (v - u));
}
return {best, sec};
}
int main () {
// ios;
// cout << fixed << setprecision (10);
int tt = 1;
// cin >> tt;
while (tt-- || 0) {
string s;
cin >> s;
// cout << brute (s).F << " " << brute (s).S << "\n";
// if (solve (s) != brute (s).F) {
// cout << "ERROR " << solve (s) << " " << brute (s).F << "\n\t" << brute (s).S << "\nERROR " << s << "\n";
// return 0;
// }
cout <<
solve(s);
// cout << "\n";
}
}
| #include<bits/stdc++.h>
using namespace std;
int st[1000003][5];
string q;
int dmc(int g,int k)
{
if(g==q.length())return k;
if(st[g][k]!=1e9)return st[g][k];
int z=1e8;
if(!k)z=min((dmc(g+1,0)+(q[g]-'0')),(dmc(g+1,1)+10-(q[g]-'0')));
else{
z=min(z,dmc(g+1,0)+1+(q[g]-'0'));
z=min(z,dmc(g+1,1)+10-((q[g]-'0')+1));
}
return st[g][k]=z;
}
int main()
{
int g;
cin>>q;
reverse(q.begin(),q.end());
for(g=0;q[g];g++)st[g][0]=st[g][1]=1e9;
printf("%d\n",dmc(0,0));
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int n, h[11][11];
while(scanf("%d", &n)){
if(!n)break;
for(int i = 0;i < n;i++){
int num = 0;
for(int j = 0;j < n;j++){
scanf("%d", &h[i][j]);
num += h[i][j];
printf("%5d", h[i][j]);
}
h[i][n] = num;
printf("%5d\n", num);
}
for(int i = 0;i <= n;i++){
int num = 0;
for(int j = 0;j < n;j++)num += h[j][i];
printf("%5d", num);
}
printf("\n");
}
} | #include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 3e5 + 10;
const int Mod = 1e9 + 7;
void Chkadd(int &x, const int &y) { if ((x += y) >= Mod) x -= Mod; }
char s[maxn];
int F[7], G[7];
int main()
{
int n = fread(s, 1, maxn, stdin);
while (s[n - 1] != '0' && s[n - 1] != '1' && s[n - 1] != '?') -- n;
int *f = F, *g = G;
f[0] = 1;
for (int i = 0; i < n; ++ i)
{
swap(f, g);
fill(f, f + 7, 0);
if (s[i] != '1')
{
Chkadd(f[1], g[0]);
Chkadd(f[2], g[1]);
Chkadd(f[1], g[2]);
Chkadd(f[4], g[3]);
Chkadd(f[6], g[4]);
Chkadd(f[5], g[5]);
Chkadd(f[4], g[6]);
}
if (s[i] != '0')
{
Chkadd(f[3], g[0]);
Chkadd(f[0], g[1]);
Chkadd(f[1], g[2]);
Chkadd(f[5], g[3]);
Chkadd(f[3], g[4]);
Chkadd(f[5], g[5]);
Chkadd(f[4], g[6]);
}
}
Chkadd(f[5], f[3]);
printf("%d\n", f[5]);
return 0;
}
| 0 |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define INIT \
cin.tie(0); \
ios::sync_with_stdio(false);
template <class T>
inline bool chmax(T& a, T b) {
return a = (a < b) ? b : a;
}
template <class T>
inline bool chmin(T& a, T b) {
return a = (a > b) ? b : a;
}
ll const INF = 1LL << 60;
ll const MOD = 1000000007;
// 約数の列挙 O(√n)
vector<ll> divisor(ll n) {
vector<ll> res;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i) res.push_back(n / i);
}
}
return res;
}
int main() {
INIT;
ll N;
cin >> N;
vector<ll> a(N + 1, 0);
reps(i, 1, N + 1) cin >> a[i];
vector<ll> b;
vector<ll> sum(N + 1, 0);
ll ans = 0;
for (ll i = N; i > 0; i--) {
if (sum[i] % 2 != a[i]) {
b.pb(i);
vector<ll> divs = divisor(i);
rep(j, SZ(divs)) { sum[divs[j]]++; }
}
// cout << i << ": ";
// repv(sum) cout << *it << " ";
// cout << endl;
}
sort(ALL(b));
cout << SZ(b) << endl;
if (SZ(b) > 0) {
repv(b) { cout << *it << " "; }
cout << endl;
}
return 0;
} | #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 mt make_tuple
#define pb push_back
#define eb emplace_back
string solve(bool a) { return ((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;}
template <class T, class U>ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T>ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
rep(i, v.size()) {
if (i) os << ",";
os << v[i];
}
os << "}";
return os;
}
template <class T, class U>istream& operator>>(istream& is, pair<T, U>& p) {
is >> p.first >>p.second ;
return is;
}
template <class T>istream& operator>>(istream& is, vector<T>& v) {
rep(i, v.size()) {
is >> v[i];
}
return is;
}
const long long INFLL = 1LL<<60;
const int INF = 1<<30;
const double PI=acos(-1);
int main(){
int n;
cin >>n;
vector<int> a(n);
cin >> a;
for (int i = n - 1; i >= 0;i--){
for (int j = i * 2+1; j < n;j+=i+1){
a[i] = (a[i] + a[j]) % 2;
} }
//clog << a << endl;
Vi ans;
rep(i,n){
if(a[i]){
ans.pb(i);
}
}
cout << ans.size()<<endl;
rep(i, ans.size()) { cout << ans[i]+1;
if(i!=ans.size()-1){
cout << " ";
} }
cout << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long N,L;
cin >> N >> L;
long long wa=0,sa=10000000000;
for(int i=0; i<N; i++){
long long kaage = L+i;
wa += kaage;
if(abs(sa) > abs(kaage)){
sa = kaage;
}
}
cout << wa-sa << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
using P = pair<int, int>;
int main() {
int n, l;
cin >> n >> l;
int r = n + l - 1;
int eat;
if (r <= 0) eat = r;
else if (l >= 0) eat = l;
else eat = 0;
cout << (r + l) * (r- l + 1) / 2 - eat << endl;
return 0;
} | 1 |
#pragma region header
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define int long long
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------よく使う数字や配列----------------- */
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr int inf = INT32_MAX/2;
constexpr ll INF = LLONG_MAX/2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/* --------------------テンプレート------------------ */
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;
}
/* ----------------------end----------------------- */
/* --------------------ライブラリ-------------------- */
ll fact(int i) { //階乗
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) { //最大公約数
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //最小公倍数
return a / gcd(a, b) * b ;
}
int keta(ll n) { //桁数を求める
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
/* ----------------------end----------------------- */
#pragma endregion
struct edge{int to,cost;};
vector<vector<edge>> G(100100);
int dist[100100];
void dijkstra(int s) {
fill(dist,dist+100100,INF);
priority_queue<P,vector<P>,greater<P>> pri;
dist[s]=0;
pri.push({0,s});
while(!pri.empty()) {
P p = pri.top();pri.pop();
int v = p.second;
if(dist[v]<p.first) continue;
for(auto e:G[v]) if(chmin(dist[e.to],dist[v]+e.cost)) pri.push({dist[e.to],e.to});
}
}
signed main() {
int n;cin >> n;
rep(i, n-1) {
int a,b,c;cin >> a >> b >> c;
a--;b--;
G[a].pb({b,c});
G[b].pb({a,c});
}
int q,k;cin >> q >> k;
dijkstra(--k);
rep(i, q) {
int a,b;cin >> a >> b;
cout << dist[--a]+dist[--b] << char(10);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0,_n=(int)(n);i<_n;++i)
#define ALL(v) (v).begin(),(v).end()
#define CLR(t,v) memset(t,(v),sizeof(t))
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>&a){return os<<"("<<a.first<<","<<a.second<< ")";}
template<class T>void pv(T a,T b){for(T i=a;i!=b;++i)cout<<(*i)<<" ";cout<<endl;}
template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}
ll nextLong() { ll x; scanf("%lld", &x); return x;}
const int MAX_N = 212345;
vector<pair<int,int>> g[MAX_N];
ll dist[MAX_N];
void dfs(int u, int prev, ll cur_dist) {
dist[u] = cur_dist;
for (auto e : g[u]) if (e.first != prev) {
dfs(e.first, u, cur_dist + e.second);
}
}
int main2() {
REP(i, MAX_N) g[i].clear();
int N = nextLong();
REP(i, N-1) {
int a = nextLong() - 1;
int b = nextLong() - 1;
ll c = nextLong();
g[a].push_back({b, c});
g[b].push_back({a, c});
}
int Q = nextLong();
int K = nextLong() - 1;
dfs(K, -1, 0);
REP(_, Q) {
int x = nextLong() - 1;
int y = nextLong() - 1;
ll ans = dist[x] + dist[y];
cout << ans << '\n';
}
return 0;
}
int main() {
#ifdef LOCAL
for (;!cin.eof();cin>>ws)
#endif
main2();
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
int main(void)
{
int n;
while(cin >> n && n != 0)
{
vector<int> a(n+1);
a[0] = 1;a[1] = 1;a[2] = 2;
for (int i = 3; i <= n; i++)
a[i] = a[i-1] + a[i-2] + a[i-3];
double year;
year = ceil((double)a[n] / 3650);
cout << year << endl;
}
return 0;
}
| #include<iostream>
#include<vector>
#include<string>
using namespace std;
int main(){
int n;
vector<int> K(100);
string s;
string c="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
while(1){
int l=0;
cin>>n;
if(n==0)break;
for(int i=0;i<n;i++) cin>>K[i];
for(int j=n;j<100;j++){
int count=0;
if(count==n)l=count=0;
K[j]=K[l];
l++;
count++;
}
cin>>s;
for(int i=0;i<s.size();i++){
for(int j=0;j<c.size();j++){
if(s[i]==c[j]){
if(j-K[i]<0){
s[i]=c[c.size()+j-K[i]];
break;
}else{
s[i]=c[j-K[i]];
break;
}
}
}
}
cout<<s<<endl;
s.clear();
K.clear();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(n) for(int i=0;i<n;i++)
#define repp(j, n) for(int j=0;j<n;j++)
#define reppp(i, m, n) for(int i=m;i<n;i++)
#define all(c) c.begin(), c.end()
#define rall(c) c.rbegin(), c.rend()
#define debug(x) cerr << #x << ": " << x << endl
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
struct Edge{
int from, to; ll cost;
Edge(int from, int to, ll cost){
this->from = from;
this->to = to;
this->cost = cost;
}
bool operator<(const Edge &e) const{
return cost < e.cost;
}
bool operator>(const Edge &e) const{
return cost > e.cost;
}
};
struct Graph{
int V,E;
vector<vector< pair<int, ll> > > edges;
Graph(){
cin >> V >> E;
edges.resize(V);
int s,t; ll w;
rep(E){
cin >> s >> t >> w;
edges[s].emplace_back(t, w);
edges[t].emplace_back(s, w);
}
}
ll kruskal(){
ll ret = 0LL;
priority_queue<Edge, vector<Edge>, greater<Edge> > que;
vector<bool> used(V, false);
used[0] = true;
for(pair<int, ll> e: edges[0])
que.push(Edge(0, e.first, e.second));
while(!que.empty()){
Edge e = que.top(); que.pop();
while(!que.empty() && used[e.to]){
e = que.top(); que.pop();
}
if(used[e.to]) break;
ret += e.cost;
used[e.to] = true;
for(pair<int, ll> next: edges[e.to])
if(!used[next.first]) que.push(Edge(e.to, next.first, next.second));
}
return ret;
}
};
int main(){
Graph g = Graph();
cout << g.kruskal() << endl;
}
| #include <bits/stdc++.h>
const int MAXN = 100010;
int xs[MAXN], D, n, Q;
int R[MAXN][20];
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n;
for (int i = 1; i <= n; ++i) std::cin >> xs[i];
std::cin >> D >> Q;
for (int i = 1; i <= n; ++i)
R[i][0] = std::upper_bound(xs + 1, xs + 1 + n, xs[i] + D) - xs - 1;
for (int i = 1; i < 20; ++i)
for (int j = 1; j <= n; ++j)
R[j][i] = R[R[j][i - 1]][i - 1];
while (Q --> 0) {
int x, y, t = 0; std::cin >> x >> y; if (x > y) std::swap(x, y);
for (int i = 19; ~i; --i) if (R[x][i] < y) t += 1 << i, x = R[x][i];
std::cout << t + 1 << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ss second
#define ff first
#define all(a) a.begin(), a.end()
#define All(a) a.rbegin(), a.rend()
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.precision(10), cout << fixed
//double Time=clock();
int main() {
ios;
int a, b;
cin >> a >> b;
cout << max({a + b, a + (a - 1), b + (b - 1)});
//cout <<endl<< clock() - Time << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
struct edge {int to; ll cost; };
int dx[] = {-1, 1, 0, 0};
int dy[] = { 0, 0, 1, -1};
int main(){
int n, k;
cin >> n >> k;
double ans = 0.0, ex = 0.0;
vector<double> p(n);
for(int i=0; i<n; i++){
cin >> p[i];
}
for(int i=0; i<k; i++){
ex += 1+p[i];
}
if(n==k){
ex /= 2.0;
cout << ex << endl;
return 0;
}
ans = ex;
for(int i=k; i<n; i++){
ex = ex-p[i-k]+p[i];
ans = max(ans, ex);
}
ans /= 2.0;
printf("%.6lf", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define times(n, i) uptil(0, n, i)
#define upto(f, t, i) for(decltype(t) _##i = (t), i = (f); i <= _##i; i++)
#define uptil(f, t, i) for(decltype(t) _##i = (t), i = (f); i < _##i; i++)
#define downto(f, t, i) for(decltype(t) _##i = (t), i = (f); i >= _##i; i--)
#define downtil(f, t, i) for(decltype(t) _##i = (t), i = (f); i > _##i; i--)
#define unless(c) if(!(c))
#define until(c) while(!(c))
#define loop while(true)
#define all(v) v.begin(), v.end()
#define ln << "\n"
struct line{};
template<class T> istream& operator>>(istream& in, vector<T>& v) {
times(v.capacity(), i) in >> v[i];
return in;
}
template<class T> const ostream& operator<<(ostream& out, const vector<T>& v) {
times(v.size(), i) out << (i ? " " : "") << v[i];
return out;
}
template<class T, class...U> typename enable_if<is_same<T, line>::value, string>::type next(istream& in, const U&... args) {
string s;
getline(in, s, args...);
return move(s);
}
template<class T, class...U> typename enable_if<!is_same<T, line>::value, T>::type next(istream& in, const U&... args) {
T t(args...);
in >> t;
return move(t);
}
template<class T, class...U> auto next(const U&... args) -> decltype(next<T>(cin)) {
return next<T>(cin, args...);
}
template<class T> T sum(const vector<T>& v) {
T ans = T();
for(const T& t : v) ans += t;
return ans;
}
template<class T> T sum(const typename vector<T>::iterator& begin, const typename vector<T>::iterator& end) {
T ans = T();
for(typename vector<T>::iterator t = begin; t != end; t++) ans += *t;
return ans;
}
template<class T> T min(const vector<T>& v) {
return *min_element(v.begin(), v.end());
}
template<class T> T min(const typename vector<T>::iterator& begin, const typename vector<T>::iterator& end) {
return *min_element(begin, end);
}
template<class T> T max(const vector<T>& v) {
return *max_element(v.begin(), v.end());
}
template<class T> T max(const typename vector<T>::iterator& begin, const typename vector<T>::iterator& end) {
return *max_element(begin, end);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
auto N = next<int>();
vector<int> point(N, 0);
times(N * (N - 1) / 2, i) {
auto A = next<int>() - 1, B = next<int>() - 1, C = next<int>(), D = next<int>();
if(C > D) {
point[A] += 3;
} else if(C < D) {
point[B] += 3;
} else {
point[A]++;
point[B]++;
}
}
vector<int> point_(N, 0), rank(N);
times(N, i) point_[i] = point[i];
sort(all(point_), greater<int>());
int p_ = 0;
#ifdef debug
times(N, i) cout << point[i] ln;
cout ln;
times(N, i) cout << point_[i] ln;
cout ln;
#endif
times(N, i) {
int p = point_[i];
if(p == p_) continue;
p_ = p;
times(N, j) {
if(p == point[j]) {
rank[j] = i + 1;
}
}
}
times(N, i) cout << rank[i] ln;
return 0;
} | #include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
typedef pair<int,int> P;
int main(){
int n;
cin >> n;
int table[101][101] = {0};
for(int i=0 ; i < n*(n-1)/2 ; i++ ){
int a, b, c, d;
cin >> a >> b >> c >> d;
a--, b--;
int s1, s2;
if( c > d ){
s1 = 3;
s2 = 0;
}else if( c == d ){
s1 = s2 = 1;
}else{
s1 = 0;
s2 = 3;
}
table[a][b] = s1;
table[b][a] = s2;
}
vector<P> v;
int score[101] = {0};
for(int i=0 ; i < n ; i++ ){
for(int j=0 ; j < n ; j++ ){
if( i == j ) continue;
score[i] += table[i][j];
}
v.push_back( P(-score[i],i) );
}
sort( v.begin() , v.end() );
int rank[101] = {0};
rank[ v[0].second ] = 1;
for(int i=1 ; i < v.size() ; i++ ){
rank[ v[i].second ] = ( v[i].first == v[i-1].first )? rank[ v[i-1].second ] : i+1;
}
for(int i=0 ; i < n ; i++ ){
cout << rank[i] << endl;
}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using Map = map<ll,ll>;
using T = tuple<ll,ll,ll>;
using vvl = vector<vector<ll>>;
#define all(v) v.begin(), v.end()
#define print(v) cout<<v<<endl;
#define fi(v) get<0>(v)
#define se(v) get<1>(v)
#define th(v) get<2>(v)
template <typename T> bool chmax(T &a, const T &b){if (a<b){a=b;return 1;}return 0;}
template <typename T> bool chmin(T &a, const T &b){if (a>b){a=b;return 1;}return 0;}
const ll INF=1LL<<60;
const ll MOD=1000000007;
ll N;
vector<vector<ll>> A(16, vector<ll>(16, 0));
//dp[i]は集合の状態がiのときの最大値
vector<ll> dp((1<<16),0);
int main(){
cin>>N;
for(ll i=0;i<N;i++)
for(ll j=0;j<N;j++)cin>>A[i][j];
for(ll S=0;S<(1<<N);S++){
for(ll i=0;i<N;i++)
for(ll j=0;j<i;j++){
if(S>>i&S>>j&1)dp[S]+=A[i][j];
}
for(ll T=S;T>0;T=(T-1)&S)chmax(dp[S],dp[T]+dp[S-T]);
}
print(dp[(1<<N)-1])
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
void debug() {cout<<endl;}
template<typename T,typename... Args>
void debug(T x,Args... args) {cout<<x<<" ";debug(args...);}
#define forn(i,a,b) for(int i=a;i<b;++i)
#define pb push_back
#define F first
#define S second
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
const int INF = -1e18;
const int N = 16;
ll cost[1<<N];
ll dp[1<<N];
int n;
ll f(int mask) {
if (mask == 0) return 0;
ll &r = dp[mask];
if (r != -1) return r;
r = -INF;
for (int sub = mask; sub; sub = (sub-1)&mask) {
int next = mask&~sub;
r = max(r, f(next) + cost[sub]);
}
return r;
}
int main() {
ios::sync_with_stdio(0); cin.tie(0);
cin >> n;
int g[n][n];
forn(i, 0, n) {
forn(j, 0, n) {
cin >> g[i][j];
}
}
forn(mask, 1, 1<<n) {
forn(i, 0, n) if ((mask>>i)&1) {
forn(j, i, n) if ((mask>>j)&1) {
cost[mask] += g[i][j];
}
}
}
int mask = (1<<n)-1;
memset(dp, -1, sizeof dp);
ll ans = f(mask);
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool vanmo = false;
while(n > 0){
if(n % 10 == 7){
vanmo = true;
}
n = n / 10;
}
if(vanmo){
cout << "Yes";
}else{
cout << "No";
}
return 0;
}
| #include<iostream>
using namespace std;
int main() {
int N; cin >> N;
string s = to_string(N);
int sum = 0;
for (int i = 0; i < s.size(); i++) {
sum += s[i] - '0';
}
if (N % sum == 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int n, m;
while(cin >> n >> m, n || m) {
vector<int> v;
for(int i = 0; i < n; i++) {
int tmp;
cin >> tmp; v.push_back(tmp);
}
sort(v.rbegin(), v.rend());
int res = 0;
for(int i = 0; i < v.size(); i++) {
if((i+1) % m)
res += v[i];
}
cout << res << endl;
}
} | #include<iostream>
using namespace std;
int main(){
int n, i;
while(cin >> n && n != 0) {
int dp[n+1] = {};
dp[1] = 1;
dp[2] = 2;
dp[3] = 4;
for(i = 4; i <= n; i++) {
dp[i] = dp[i-3] + dp[i-2] + dp[i-1];
}
i = 0;
while(dp[n] > 0) {
dp[n]-=3650;
i++;
}
cout << i << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(int)(n); i++)
using namespace std;
int main(){
int H, W;
cin >> H >> W;
int a[510][510];
rep(i,H){
rep(j,W) cin >> a[i][j];
}
int ans=0;
vector<int> ys, xs, yg, xg;
rep(i,H){
rep(j,W){
if(i==H-1 && j==W-1) break;
if(a[i][j]%2==1){
ans++;
if(j!=W-1){
a[i][j]--;
a[i][j+1]++;
ys.emplace_back(i+1);
xs.emplace_back(j+1);
yg.emplace_back(i+1);
xg.emplace_back(j+2);
}
else{
a[i][j]--;
a[i+1][j]++;
ys.emplace_back(i+1);
xs.emplace_back(j+1);
yg.emplace_back(i+2);
xg.emplace_back(j+1);
}
}
}
}
cout << ans << endl;
rep(i,ans) cout << ys[i] << " " << xs[i] << " "
<< yg[i] << " " << xg[i] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _for(i,j,N) for(int i = (j);i < (N);i++)
#define _rep(i,j,N) for(int i = (j);i <= (N);i++)
#define _dec(i,N,j) for(int i = (N-1);i >= (j);i--)
#define _rec(i,N,j) for(int i = (N);i >=(j);i--)
#define ALL(x) x.begin(),x.end()
#define MEM(a,n) memset(a,n,sizeof(a))
#define fst first
#define scd second
#define PB push_back
#define MP make_pair
typedef long long LL;
typedef long double LD;
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;
int get_int(){int x;scanf("%d",&x);return x;}
LL get_ll(){LL x;scanf("%lld",&x);return x;}
double get_db(){double x;scanf("%lf",&x);return x;}
template<typename T> int chmin(T &a,T b){if(a > b){a = b;return 1;}else return 0;}
template<typename T> int chmax(T &a,T b){if(a < b){a = b;return 1;}else return 0;}
template<typename T>
ostream& operator<<(ostream& os,const vector<T>& v) {_for(i,0,v.size()) os << v[i] << " ";return os;}
template<typename T>
ostream& operator<<(ostream& os,const set<T>& v){for(auto a:v) os << a <<" ";return os;}
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& v){os << v.fst <<" "<<v.scd << " ";return os;}
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const map<T1,T2>& v){for(auto a:v) cout << a << endl;return os;}
static const int dx[8] = { -1, 0, 1, 0, 1, -1, 1, -1};
static const int dy[8] = {0, 1, 0, -1, 1, -1, -1, 1};
const double pi = acos(-1.0);
const double eps = 1e-8;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5+5;
unsigned long long sum = 0;
LL ans = 0;
LL one = 1;
unsigned long long A[maxn];
int used[maxn];
int cnt[maxn];
char M[62][maxn];
int N;
int Gauss(int H,int W)
{
int i,j,col;
for(col = 0;col < W;col++){
int pivot = -1;
for(int row = 0;row < H;row++){
int bit = 61 - row;
if(used[bit]) continue;
if(M[row][col] == 1){
pivot = row;
break;
}
}
used[61 - pivot] = 1;
for(int row = 0;row < H;row++){
int bit = 61 - row;
if(used[bit]) continue;
if(M[row][col] == 1){
for(j = col;j <= W;j++){
M[row][j] ^= M[pivot][j];
}
}
}
}
return 0;
}
int bit_n(LL t){
int ret = 0;
_for(i,0,N){
if(t & A[i]) ret++;
}
return ret;
}
int main()
{
cin >> N;
_for(i,0,N) {
cin >> A[i];
}
MEM(used,0);
for(int bit = 61;bit >= 0;bit--){
LL t = one<<bit;
cnt[bit] = bit_n(t);
}
MEM(M,0);
LL ans = 0;
for(int bit = 0;bit <= 61;bit++){
LL t = one<<bit;
if(cnt[bit] == 0) {
used[bit] = 1;
continue;
}
else if(cnt[bit] & 1) {
ans += t;
used[bit] = 1;
continue;
}
else M[61 - bit][N] = 1;
_for(i,0,N){
if(t & A[i]){
if(!used[bit])
M[61-bit][i] = 1;
}
}
}
/*
_for(i,54,62){
if(cnt[61-i] == 0 || (cnt[61-i]&1)) continue;
_rep(j,0,N){
printf("%d ",M[i][j]);
}
printf("\n");
}
*/
Gauss(62,N);
_rep(i,0,61){
int bit = 61 - i;
if(cnt[bit] == 0 || (cnt[bit]) & 1) continue;
int ok = 0;
_for(j,0,N) if(M[i][j]) ok = 1;
if(!M[i][N]) ok = 1;
if(ok) ans += (one << (bit+1));
}
/*
_for(i,54,62){
if(cnt[61-i] == 0 || (cnt[61-i]&1)) continue;
_rep(j,0,N){
printf("%d ",M[i][j]);
}
printf("\n");
}
*/
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for (ll i = (a); i < (b); i++)
#define REP(i,n) rep(i,0,n)
void solve()
{
int n;cin>>n;
int a[n],b[n];
REP(i,n)cin>>a[i];
REP(i,n)cin>>b[i];
int j=0,now=-1;
REP(i,n){
if(now!=a[i])j=0;
if(a[i]==b[i]){
for(;j<n;j++){
if(a[i]!=a[j]&&a[i]!=b[j]){
swap(b[i],b[j]);
break;
}
}
if(j==n){cout<<"No"<<endl;return;}
}
now=a[i];
}
cout<<"Yes"<<endl;
REP(i,n)cout<<(i?" ":"")<<b[i];cout<<endl;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define N 200010
int n,a[N],b[N],c[N],d[N];
int main(){
cin>>n;
rep(i,n)cin>>a[i];
rep(i,n)cin>>b[i];
rep(i,n+1)c[i]=d[i]=0;
rep(i,n)c[a[i]]++,d[b[i]]++;
rep(i,n+1){
if(c[i]+d[i]>n){
cout<<"No\n";
return 0;
}
}
for(int i=1;i<=n;i++){
c[i]+=c[i-1];
d[i]+=d[i-1];
}
int x=0;
for(int i=1;i<=n;i++)x=max(x,c[i]-d[i-1]);
cout<<"Yes\n";
rep(i,n){
if(i)cout<<" ";
cout<<b[(i+n-x)%n];
}
cout<<"\n";
}
| 1 |
#include <iostream>
using namespace std;
typedef long long int LLI;
int main()
{
int n;
LLI a, b, x, diff, sum = 0 ;
cin >> n >> x;
cin >> a >> b;
if( a + b > x )
{
diff = a + b - x;
if( diff <= b )
b -= diff;
else
b = 0;
sum += diff;
}
a = b;
for(int i = 2; i < n; i++)
{
cin >> b;
if( a + b > x )
{
diff = a + b - x;
if( diff <= b )
b -= diff;
else
b = 0;
sum += diff;
}
a = b;
}
cout << sum;
}
| #include <iostream>
#include <vector>
#include <algorithm>
int main()
{
int n, x;
std::cin >> n >> x;
std::vector<int> arr;
arr.reserve(n);
for (int i = 0; i < n; ++i)
{
int tmp;
std::cin >> tmp;
arr.push_back(tmp);
}
int64_t count = 0;
if (arr[0] + arr[1] > x)
{
const int d = arr[0] + arr[1] - x;
count += d;
arr[1] = std::max(arr[1] - d, 0);
// arr[0]はもう参照しないので編集しない
}
for (int i = 2; i < n; ++i)
{
const int d = arr[i - 1] + arr[i] - x;
if (d > 0)
{
arr[i] -= d;
count += d;
}
}
std::cout << count << std::endl;
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <set>
std::set <int> s;
int main()
{
int n;
std::cin >> n;
for(int i = 1;i <= n;i++)
{
int x;
std::cin >> x;
if(s.find(x) != s.end())
{
s.erase(x);
}
else
{
s.insert(x);
}
}
std::cout << s.size();
// system("pause");
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define _USE_MATH_DEFINES
#include <math.h>
#define NIL = -1;
#define all(x) x.begin(),x.end()
const ll INF = 1e9;
const ll mod = 1e9 + 7;
int digit(ll x) {
if (x / 10 == 0) return 1;
return digit(x / 10) + 1;
}
ll gcd(long long a,long long b) {
if (a < b) swap(a,b);
if (b == 0) return a;
return gcd(b,a%b);
}
bool is_prime(long long N){
if (N == 1) return false;
for (long long i = 2;i * i <= N;i++){
if (N % i == 0) return false;
}
return true;
}
ll lcm(ll a,ll b){
return ((a * b == 0)) ? 0 : (a / gcd(a,b) * b);
}
double DegreeToRadian(double degree){
return degree * M_PI / 180.0;
}
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
///////////////////////////////////////////////////////////////////////////////////
int main(){
map<long long, int> mp;
int n;
cin >> n;
for (int i = 0;i < n;i++){
int a;
cin >> a;
mp[a]++;
}
int cnt = 0;
for (auto v : mp){
if (v.second % 2 != 0){
cnt++;
}
}
cout << cnt << endl;
} | 1 |
#include <bits/stdc++.h>
#define inf 1e9
using namespace std;
int w,h,ans = inf,gx,gy;
int grid[21][21];
int syoki[21][21];
int x[4] = {-1,0,1,0};
int y[4] = {0,1,0,-1};
bool in(int a,int b){
if(a< 0 || b<0 || w<=a || h<=b)return false;
return true;
}
void dfs(int w1,int h1,int count){
// cout<<h1<<" "<<w1<<" "<<count<<endl;
if(count == 10)return;
for(int i = 0;i < 4;i++){
int a = w1,b = h1;
if(in(a+y[i],b+x[i]) && grid[b+x[i]][a+y[i]]==0){
while(1){
if(!in(a+y[i],b+x[i]))break;
if((b+x[i])==gy && (a+y[i]) == gx){
ans = min(ans,count+1);
return;
}
else if(grid[b+x[i]][a+y[i]] == 1){
grid[b+x[i]][a+y[i]] = 0;
dfs(a,b,count+1);
grid[b+x[i]][a+y[i]] = 1;
break;
}
a += y[i];
b += x[i];
}
}
}
}
int main(){
int sx,sy;
while(1){
cin >> w >> h;
if(w == 0)break;
for(int i = 0;i < h;i++){
for(int j = 0;j < w;j++){
cin >> grid[i][j];
if(grid[i][j] == 2){
sx = j;
sy = i;
grid[i][j]=0;
}
if(grid[i][j] == 3){
gx = j;
gy = i;
grid[i][j]=0;
}
}
}
ans = inf;
dfs(sx,sy,0);
if(ans == inf)cout << -1 <<endl;
else cout << ans <<endl;
}
return 0;
} | #include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long LL;
const int MAXN=400;
LL n, m, ans, cntW, cntB;
bool visited[MAXN][MAXN];
string s[MAXN];
bool avail(int i, int j, char c){
if(i < 0 || i >= n || j < 0 || j >= m) return false;
if(s[i][j] == c) return false;
return true;
}
void dfs(int i, int j){
if(i < 0 || i >= n || j < 0 || j >= m) return;
if(visited[i][j]) return;
visited[i][j] = true;
if(s[i][j] == '.') cntW++;
else cntB++;
if(avail(i, j - 1, s[i][j])) dfs(i, j - 1);
if(avail(i, j + 1, s[i][j])) dfs(i, j + 1);
if(avail(i + 1, j, s[i][j])) dfs(i + 1, j);
if(avail(i - 1, j, s[i][j])) dfs(i - 1, j);
}
int main(){
cin >> n >> m;
for(int i = 0; i < n; i++) cin >> s[i];
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
visited[i][j] = false;
ans = 0;
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
if(!visited[i][j]){
cntB = 0; cntW = 0;
dfs(i, j);
ans += cntB * cntW;
}
cout << ans << "\n";
} | 0 |
#define _USE_MATH_DEFINES
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
using namespace std;
int main(){
int l[10];
int v1, v2;
char c;
int d;
while(cin >> l[0]){
d=l[0];
for(int i=1;i<10;i++){
cin >> c >> l[i];
d+=l[i];
}
cin >> c >> v1 >> c >> v2;
double t = (double)d/(v1+v2);
d=0;
//cout << t<<endl;
for(int i=0;i<10;i++){
d+=l[i];
//cout << v1*t <<" "<<d<<endl;
if(v1*t <= d){
cout << i+1 <<endl;
break;
}
}
}
return 0;
} | #include<iostream>
#include<numeric>
#include<cstdio>
int l[10],v,v2;
int main(){
while(true){
for(int i=0;i<10;i++){
if(scanf("%d,",&l[i])==EOF)return 0;
}
if(scanf("%d,%d",&v,&v2)==EOF)return 0;
double k=(double)std::accumulate(l,l+10,0)/(v+v2)*v;
int sum=0;
for(int i=0;i<10;i++){
sum+=l[i];
if(sum>=k){
std::cout<<i+1<<std::endl;
break;
}
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int x, y;
cin >> x >> y;
long long ans = 0;
ans += abs(abs(x) - abs(y));
if(x > 0){
if(y > 0 && x > y) ans += 2;
if(y < 0) ans++;
}
if(x < 0){
if(y < 0 && x > y) ans += 2;
if(y > 0) ans++;
}
if(x == 0 && y < 0) ans++;
if(y == 0 && x > 0) ans++;
cout << ans << endl;
} | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <algorithm>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// class
// ------------------------------------------------
class Combi
{
public:
Combi();
long long Combination(long long n, long long k);
private:
vector<vector<long long>> memo;
long long n_num;
long long k_num;
void Resize(long long n, long long k);
};
// define
// ------------------------------------------------
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define sz(a) int((a).size())
#define rep(i,n) for(int(i)=0;(i)<(n);(i)++)
#define repe(i,n) for(int(i)=0;(i)<=(n);(i)++)
#define vsort(v) sort((v).begin(),(v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a,b) __gcd((a),(b))
#define LCM(a,b) (a)/GCD((a),(b))*(b)
#define kiriage(a,b) ((a)+(b)-1)/(b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long> vll;
// code
// ------------------------------------------------
int main() {
ll x,y;
cin >> x >> y;
ll ans = 0;
if(x * y > 0)
{
ans = abs(y-x) + ( x < y ? 0 : 2);
}
else if(x == 0)
{
ans = abs(y) + ( y < 0 ? 1 : 0);
}
else if(y == 0)
{
ans = abs(x) + ( x < 0 ? 0 : 1);
}
else
{
ans = abs( y + x ) + 1;
}
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(int n)
{
int i = 1;
while(1)
{
n = n / 10;
if(n == 1)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n)
{
int s = 0;
while(n)
{
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str)
{
for(auto itr = str.begin();itr != str.end() ; itr++)
{
if(97 <= *itr && *itr <= 122)
{
*itr = *itr - 32;
}
}
return str;
}
string lower(string str)
{
for(auto itr = str.begin();itr != str.end() ; itr++)
{
if(65 <= *itr && *itr <= 90)
{
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi(){
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k)
{
Resize(n,k);
ll ret;
if(memo[n][k] != 0)
{
ret = memo[n][k];
}
else if(n == k || k == 0)
{
memo[n][k] = 1;
ret = 1;
}
else
{
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
void Combi::Resize(ll n, ll k)
{
if(n_num <= n || k_num <= k)
{
n_num = (n + 1) * 2;
k_num = (k + 1) * 2;
memo.resize(n_num);
for(auto itr = memo.begin(); itr != memo.end(); ++itr)
{
itr->resize(k_num);
}
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(int)(n); i++)
#define all(v) v.begin(), v.end()
#define allR(v) v.rbegin(), v.rend()
#define PRINT(v) for (auto x : (v)) cout <<x <<" " ; cout <<endl;
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
typedef pair<int,int> Pi;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
const int inf = 1001001001;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
template<class T> inline bool chmin(T& a, T b){if (a>b){a = b; return true;}return false;}
template<class T> inline bool chmax(T& a, T b){if (a<b){a = b; return true;}return false;}
template<class T> inline T powerM(T a,T b){if (b==0) return 1;
T tmp = powerM(a,b/2); if (b%2==0) return tmp*tmp%MOD; else return tmp*tmp%MOD*a%MOD; }
template<class T> inline T power(T a,T b,T m=numeric_limits<T>::max()){ if (b==0) return 1;
T tmp = power(a,b/2,m); if (b%2==0) return tmp*tmp%m; else return tmp*tmp%m*a%m; }
template<class T> inline T gcd(T a, T b){if (b==0) return a; return gcd(b, a%b);}
template<class T> inline T lcm(T a, T b){return a / gcd(a,b) * b;}
// ax+by=gcd(a,b)を解く
template<class T> inline T extgcd(T a,T b,T &x,T &y){if (b==0){x=1; y=0; return a;} T d=extgcd(b,a%b,y,x); y -= a/b*x; return d;}
void hey(){ cout <<"hey" <<endl; }
template<class T> struct edge { int to; T cost;};
int main() {
int H,W; cin >>H >>W;
int A,B; cin >>A >>B;
for (int i=0; i<H; i++){
int ai = i < B ? 0 : 1;
for (int j=0; j<W; j++){
int aj = j < A ? 0 : 1;
int res = (ai+aj)%2;
cout <<res;
}
cout <<endl;
}
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
using ll = long long;
void solve(long long H, long long W, long long A, long long B){
rep(i,H-B) {
rep(j,W-A) {
std::cout << 1;
}
rep(j,A) {
std::cout << 0;
}
std::cout << std::endl;
}
rep(i,B) {
rep(j,W-A) std::cout << 0;
rep(j,A) std::cout << 1;
std::cout << std::endl;
}
}
int main(){
long long H;
scanf("%lld",&H);
long long W;
scanf("%lld",&W);
long long A;
scanf("%lld",&A);
long long B;
scanf("%lld",&B);
solve(H, W, A, B);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n,d,k=1;
long long minx=10000;
cin>>n;
while(1){
d=n/k%1000;
if(d<100){
break;
}
else if(abs(753-d)<minx){
minx=abs(753-d);
}
k*=10;
}
cout<<minx<<endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
using ll = long long;
int main(void){
string S;
cin>>S;
int len=S.size();
int num;
int ans=1000;
rep(i,len-2){
num=(S[i]-'0')*100+(S[i+1]-'0')*10+S[i+2]-'0';
ans=min(ans,abs(753-num));
}
cout<<ans<<endl;
} | 1 |
#include <iostream>
using namespace std;
#include <stdio.h>
#include <math.h>
/********
* ?????¢????±???????????????°??????
*********/
/*********??¢?????´?????????
* (1)??°????????\???
* (2)?¨???????????????????
*********/
int main(void)
{
double answer;
double x1,x2,y1,y2;
cin >> x1 >> y1>> x2 >> y2 ;
answer =sqrt( (y2-y1)*(y2-y1)+(x2-x1)*(x2-x1));
printf("%f",answer);
return 0;
} | #include <iostream>
using namespace std;
class Dice {
private:
int num[6];
void go2N() {
int tmp = num[0];
num[0] = num[1];
num[1] = num[5];
num[5] = num[4];
num[4] = tmp;
}
void go2S() {
int tmp = num[0];
num[0] = num[4];
num[4] = num[5];
num[5] = num[1];
num[1] = tmp;
}
void go2E() {
int tmp = num[0];
num[0] = num[3];
num[3] = num[5];
num[5] = num[2];
num[2] = tmp;
}
void go2W() {
int tmp = num[0];
num[0] = num[2];
num[2] = num[5];
num[5] = num[3];
num[3] = tmp;
}
public:
Dice(int *_num) {
for (int i=0;i<6;i++) {
num[i] = _num[i];
}
}
void go(char op) {
switch (op) {
case 'N':
go2N();
break;
case 'S':
go2S();
break;
case 'E':
go2E();
break;
case 'W':
go2W();
break;
default:
break;
}
}
int getNum(int id) {
int ret = 0;
if (0 <= id && id < 6) ret = num[id];
return ret;
}
};
int main() {
int num[6];
string op;
cin >> num[0] >> num[1] >> num[2] >> num[3] >> num[4] >> num[5];
Dice D(num);
cin >> op;
for (int i=0;i<op.size();i++) {
D.go(op[i]);
}
cout << D.getNum(0) << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
///Welcome to Nasif's Code
#define bug printf("bug\n");
#define bug2(var) cout<<#var<<" "<<var<<endl;
#define co(q) cout<<q<<endl;
#define all(q) (q).begin(),(q).end()
typedef long long int ll;
typedef unsigned long long int ull;
const int MOD = (int)1e9+7;
const int MAX = 1e6;
#define pi acos(-1)
#define inf 1000000000000000LL
#define FastRead ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll arr[MAX];
int main()
{
FastRead
//freopen("output.txt", "w", stdout);
int n,neg=0,mn=INT_MAX;
cin>>n;
for(int i=0; i<n; i++)
{
cin>>arr[i];
if(arr[i]<0)
neg++;
int cur=abs(arr[i]);
mn=min(mn,cur);
}
ll sum=0,sub=0;
if(neg%2)
{
sub=mn;
}
for(int i=0; i<n; i++)
sum+=abs(arr[i]);
sum-=sub*2;
cout<<sum<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(long long i=0;i<(long long)(n);i++)
#define rep2(i, s, n) for(long long i=(s);i<(long long)(n);i++)
#define repi(i, n) for(int i=0;i<(int)(n);i++)
#define rep2i(i, s, n) for(int i=(s);i<(int)(n);i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define chmax(s, t) s=max(s,t);
#define chmin(s, t) s=min(s,t);
#define deg2rad(deg) (((deg)/360)*2*M_PI)
#define rad2deg(rad) (((rad)/2/M_PI)*360)
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
const ll INF = (1LL<<60);
const int INFi = (1<<29);
/*素数判定*/
bool is_prime(ll n){
if(n==1) return false;
for(ll i=2;i*i<=n;i++){
if(n%i==0) return false;
}
return true;
}
/*約数列挙*/
vll enum_divisors(ll n){
vll l;
for(ll i=1;i*i<=n;i++){
if(n%i==0){
l.push_back(i);
if(n/i != i) l.push_back(n/i);
}
}
sort(all(l));
return l;
}
/*素因数分解*/
vector<P> prime_factorize(ll n){
vector<P> l;
for(ll i=2;i*i<=n;i++){
if(n%i!=0) continue;
ll e = 0;
while(n%i==0){
e++;
n /= i;
}
l.push_back({i, e});
}
if(n!=1) l.push_back({n, 1});
return l;
}
/*最小公倍数*/
ll lcm(ll a, ll b){
return a*b/__gcd(a,b);
}
/*最大公約数*/
ll gcd(ll a, ll b){
return __gcd(a,b);
}
/*組み合わせ(Combination)*/
const ll CMAX = 1010000;
const ll CMOD = 1e9+7;
ll fac[CMAX], finv[CMAX], inv[CMAX];
// テーブルを作る前処理
void combinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < CMAX; i++) {
fac[i] = fac[i - 1] * i % CMOD;
inv[i] = CMOD - inv[CMOD%i] * (CMOD / i) % CMOD;
finv[i] = finv[i - 1] * inv[i] % CMOD;
}
}
// 二項係数計算
ll comb(ll n, ll k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % CMOD) % CMOD;
}
/*階乗*/
ll factorial(ll n){
const ll FMOD = 1e9+7;
ll ret = n;
for(ll i=n-1;i>0;i--){
ret*=i;
ret%=FMOD;
}
return (ret?ret:1);
}
int main(){
ll n; cin >> n;
ll absmin = INF;
ll ans = 0;
ll minuscnt = 0;
rep(i, n){
ll in; cin >> in;
chmin(absmin, abs(in));
if(in<0) minuscnt++;
ans += abs(in);
}
cout << (minuscnt%2==0?ans:ans-2*absmin) << endl;
return 0;
} | 1 |
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
ll X;
cin>>X;
ll ans = 0;
ans += X/500*1000;
X %= 500;
ans += X/5*5;
X %= 5;
cout<<ans<<endl;
}
| #include <iostream>
#include <algorithm>
#include <utility>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <queue>
#include <map>
#include <math.h>
#include <string.h>
#include <iomanip>
#include <numeric>
#include <cstdlib>
#include <cstdint>
#include <cmath>
#include <functional>
#include <limits>
#include <cassert>
using namespace std;
/* template */
using ll = long long;
void debug_out() { std::cout << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << H << " ";
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cout << "debug: "; debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
#define rep(i, a, n) for (int i = (int)(a); i < (int)(n); i++)
#define rrep(i, a, n) for (int i = ((int)(n-1)); i >= (int)(a); i--)
#define Rep(i, a, n) for (long long i = (long long)(a); i< (long long)(n); i++)
#define RRep(i, a, n) for (long long i = ((long long)(n-1ll)); i>=(long long)(a); i--)
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T> vec) {
for (std::size_t i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
struct Edge{
int to;
int weight;
Edge(int t, int w) : to(t), weight(w){ }
};
struct edge{
int from;
int to;
int weight;
edge(int f,int t,int w) : from(f), to(t), weight(w){ }
};
using Graph = vector<vector<Edge>>;
using graph = vector<vector<int>>;
using edges = vector<edge>;
template <class T>
inline bool chmin(T &a, T b){
if (a > b){
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b){
if (a < b){
a = b;
return true;
}
return false;
}
template <class T>
T lcm(T a, T b){
return (a*b)/gcd(a,b);
}
bool isPalindrome(string s){
string t = s;
reverse(all(t));
return s==t;
}
constexpr ll LNF = 1e18+7;
constexpr int INF = 1e9+7;
vector<int> dx = {-1,0,1,0,-1,1,-1,1};
vector<int> dy = {0,-1,0,1,1,-1,-1,1};
/* template */
int main(){
ll n; cin >> n;
string a;
ll left = 0ll, right = n-1ll;
cout << 0 << endl;
cin >> a;
if(a=="Vacant"){
return 0;
}
string b;
while(b!="Vacant"){
ll mid = (left+right)/2ll;
cout << mid << endl;
cin >> b;
if(b=="Vacant") return 0;
if(mid%2==0){
if(a==b){
left = mid+1;
}
else{
right = mid-1;
}
}
else{
if(a!=b){
left = mid+1;
}
else{
right = mid-1;
}
}
}
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
double n, m, d;
cin >> n >> m >> d;
double ans;
if(d == 0){
ans = 1/n;
}else{
ans = 2*(n-d)/(n*n);
}
ans *= (m-1);
cout << fixed << setprecision(10) << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long int
#define ld long double
#define pb push_back
#define pll pair<ll, ll>
#define tri pair<pll, ll>
#define vl vector<ll>
#define vvl vector< vector<ll> >
#define vlp vector< pair<ll, ll> >
#define vllp vector<pair<pll, ll> >
#define mll map<ll, ll>
#define rep(i,a) for(ll i=0; i< a; i++)
#define rep1(i,a) for(ll i = 1; i< a; i++)
#define foi(i, a, b) for(ll i = a; i<b ; i++)
#define fod(i, a, b) for(ll i = a; i>=b ; i--)
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fst first
#define sec second
#define ff first.first
#define fs first.second
#define max3(a, b, c) max(max(a, b), c)
#define min3(a, b, c) min(min(a, b), c)
#define MAX 1000005
#define MOD 1000000007
// #define MOD 998244353
#define endl "\n"
#define INF (ll)1e18
#define s(v) (ll)v.size()
#define e(v) v.empty()
#define bscount(x) __builtin_popcountll(x)
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
// using namespace __gnu_pbds;
ll gcd(ll a, ll b){if(b==0)return a;return gcd(b, a%b);}
ll cpow(ll a, ll b, ll M){ll ans = 1;while(b){if(b&1) ans = ans*a%M; b/=2;a=a*a%M;}return ans;}
void ingraph(vvl& graph, ll m){ll x, y;rep(i, m){cin>>x>>y;x--, y--;graph[x].pb(y);graph[y].pb(x);}}
ll modify(ll n){ll res = n;res%=MOD;res+=MOD;res%=MOD;return res;}
ll fexp(ll a, ll b) {return cpow(a, b, MOD);}
ll cinv(ll a, ll p){return cpow(a, p-2, p);}
ll inverse(ll a) {return cinv(a, MOD);}
int main(){
// #ifndef ONLINE_JUDGE
// freopen("../input.txt", "r", stdin);
// freopen("../output.txt", "w", stdout);
// #endif
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
ll t;
// cin>>t;
t = 1;
ll tc = 0;
while(tc++ < t){
ll n, m, d;
cin>>n>>m>>d;
ld ans = 1.0*(m-1)*(n-d)/(n*1.0*n);
if(d > 0) ans *= 2.0;
cout<<fixed<<setprecision(10)<<ans;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) int(x.size())
#define get_unique(x) x.erase(unique(all(x)), x.end());
typedef long long ll;
typedef complex<double> Complex;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll LINF = 1e18;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T>
vector<T> make_vec(size_t a) {
return vector<T>(a);
}
template <class T, class... Ts>
auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
bool dfs(int now, int pre, vector<int> &d, vector<vector<int>> &g) {
if (now) d[now] = d[pre] + 1;
bool ret = false;
for (int nxt : g[now]) {
if (d[nxt] != -1) {
if (d[nxt] % 2 != d[now] % 2)
continue;
else
return true;
}
ret |= dfs(nxt, now, d, g);
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> g(n);
rep(i, m) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> d(n, -1);
d[0] = 0;
if (dfs(0, -1, d, g)) {
cout << (ll)n * (n - 1) / 2 - (ll)m << endl;
return 0;
}
ll odd = 0, even = 0;
rep(i, n) {
(d[i] % 2 == 0 ? even : odd)++;
}
cout << odd * even - (ll)m << endl;
}
| #include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#define _USE_MATH_DEFINES
#include<math.h>
#include<queue>
#include<deque>
#include<stack>
#include<cstdio>
#include<utility>
#include<set>
#include<list>
#include<cmath>
#include<stdio.h>
#include<string.h>
#include<iomanip>
#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const ll dx[4] = { 0,1,0,-1 };
const ll dy[4] = { -1, 0, 1,0 };
const ll INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)swap(x, y);
if (y == 0)return x;
return gcd(y, x%y);
}
void mul(ll a, ll b) {
a = a * b % INF;
}
double mysqrt(double x) {
double l = 0, r = x;
for (int i = 0; i < 64; ++i) {
double m = (l + r) / 2.0;
if (m*m < x)l = m;
else r = m;
}
return l;
}
///////////////////////////////////////
int V, E;
vector<int>G[10010];//グラフの隣接リスト表現
vector<int>rG[10010];//辺の向きを逆にしたグラフ
vector<int>vs;//帰りがけ順の並び
bool used[10010];//すでに調べたか
int cmp[10010];//属する強連結成分のトポロジカル順序
void add_edge(int from, int to) {
G[from].push_back(to);
rG[to].push_back(from);
}
void dfs(int v) {
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
if (!used[G[v][i]])dfs(G[v][i]);
}
vs.push_back(v);
}
void rdfs(int v, int k) {
used[v] = true;
cmp[v] = k;
for (int i = 0; i < rG[v].size(); ++i) {
if (!used[rG[v][i]])rdfs(rG[v][i], k);
}
}
int main() {
cin >> V >> E;
REP(i, E) {
int s, t;
cin >> s >> t;
G[s].push_back(t);
rG[t].push_back(s);
}
int Q;
cin >> Q;
int num = 0;
memset(used, 0, sizeof(used));
vs.clear();
for (int v = 0; v < V; ++v) {
if (!used[v])dfs(v);
}
memset(used, 0, sizeof(used));
for (int i = vs.size() - 1; i >= 0; i--) {
if (!used[vs[i]])rdfs(vs[i], num++);
}
REP(i, Q) {
int u, v;
cin >> u >> v;
if (cmp[u] == cmp[v]) {
cout << 1 << endl;
}
else {
cout << 0 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define PI 3.14159265359
#define NIL (-1)
#define LL long long
using namespace std;
const int64_t MOD = 1e9 + 7;
int main() {
int R;
cin >> R;
if (R < 1200) cout << "ABC" << endl;
else if (R < 2800) cout << "ARC" << endl;
else cout << "AGC" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
string A;
cin >> A;
if(A.at(0)-'0'==7||A.at(1)-'0'==7||A.at(2)-'0'==7) cout << "Yes" << endl;
else cout << "No" << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1e9+7;
//const ll MOD = 998244353;
const int inf = (1<<30)-1;
const ll INF = (1LL<<60)-1;
const ld EPS = 1e-10;
template<typename T> bool chmax(T &x, const T &y) {return (x < y)? (x = y, true) : false;};
template<typename T> bool chmin(T &x, const T &y) {return (x > y)? (x = y, true) : false;};
int main(){
ll N, M, V, P;
cin >> N >> M >> V >> P;
ll A[N];
rep(i, N) cin >> A[i];
int ans = 0;
sort(A, A+N, greater<ll>());
ll sum = 0;
rep(i, N){
if(i < P-1) {ans++; continue;}
if(A[i]+M < A[P-1]) break;
ll S = (N-i-1)*M;
S += (i-P+1)*(A[i]+M) - sum;
if(S >= M*(V-P)) ans++;
sum += A[i];
}
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
#ifndef LOCAL
#define endl '\n'
#endif
#define fr(i, a, b) for(int i = a; i <= b; i++)
#define pf push_front
#define pb push_back
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)x.size()
#define rsz resize()
#define lb lower_bound
#define ub upper_bound
typedef long long ll;
typedef long double f80;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
int pct(int x) { return __builtin_popcount(x); }
int pct(ll x) { return __builtin_popcountll(x); }
int bit(int x) { return 31 - __builtin_clz(x); } // floor(log2(x))
int bit(ll x) { return 63 - __builtin_clzll(x); } // floor(log2(x))
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
ll cdiv(ll a, ll b) { return a / b + !(a < 0 || a % b == 0); }
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll rand(ll l, ll r){
uniform_int_distribution<ll> uid(l, r);
return uid(rng);
}
#ifdef LOCAL
#define debug(...) cerr << "[L:" << __LINE__ << "][" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
#ifndef LOCAL
string to_string(__int128 x) {
string s = "";
bool neg = 0;
if(x < 0) { s += "-"; neg = 1; }
if(!x) s += '0';
while(x) {
int rem = x % 10;
s += to_string(rem);
x /= 10;
}
reverse(s.begin() + neg, s.end());
return s;
}
#endif
const int mod = 1e9 + 7; // 998244353;
int pwr(int a,int b) {
int ans = 1;
while(b) {
if(b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
/*
Lookout for overflows!!
Check array sizes!!
Clear before test cases!!
Use the correct modulo!!
Check for corner cases!!
Are you forgetting something?!
*/
const int N = 1e5 + 5;
int a[N];
int n, m, v, p;
int good(int idx) {
vector<int> bad;
fr(i, 1, n) {
if(a[i] > a[idx]) bad.pb(a[i] - a[idx]);
}
sort(all(bad));
int tot = max(0, (int)bad.size() - p + 1);
int maxi = 0;
ll s = 0;
fr(i, 0, tot - 1) {
s += bad[i];
maxi = max(maxi, bad[i]);
}
debug(a[idx], bad);
return (maxi <= m) && (s <= m * 1LL * v);
}
void solve() {
cin >> n >> m >> v >> p;
v = n - v;
fr(i, 1, n) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
int l = 0, r = n + 1;
while(r - l > 1) {
int m = (l + r) >> 1;
if(good(m))
l = m;
else
r = m;
}
cout << l;
}
int main() {
ios :: sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
// cin >> t;
t = 1;
for(int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
} | 1 |
#define _GIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main(void) {
int n;
cin >> n;
map<ll, int> a;
rep(i, n) {
ll temp;
cin >> temp;
a[temp]++;
}
ll ans = 0;
for (auto x : a) {
if (x.second % 2 != 0) ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef pair<int, int> P;
// input
int N;
vector<int> A;
void input() {
cin >> N;
A = vector<int>(N);
rep(i, N) cin >> A[i];
}
int main() {
input();
set<int> s;
for (int a : A) {
if (s.count(a)) s.erase(a);
else s.insert(a);
}
int ans = s.size();
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, N) for (int i = 0; i < (int)N; i++)
const ll MOD = pow(10,9)+7;
const ll LLINF = pow(2,61)-1;
const int INF = pow(2,30)-1;
int main() {
ll N; cin >> N;
ll x[N]; rep(i,N) cin >> x[i];
ll M, K; cin >> M >> K;
ll a[M]; rep(i,M) { cin >> a[i]; a[i]--; }
ll diff[N-1]; rep(i,N-1) diff[i] = x[i+1] - x[i];
ll pos[N-1]; rep(i,N-1) pos[i] = i;
ll p_bit[N-1]; rep(i,N-1) p_bit[i] = i;
for (int i=0; (1ull<<i)<=K; i++) {
if (i==0) rep(i,M) swap(p_bit[a[i]-1], p_bit[a[i]]);
else {
ll p_tmp[N-1]; rep(i,N-1) p_tmp[i] = p_bit[i];
rep(i,N-1) p_bit[i] = p_tmp[p_tmp[i]];
}
if (K&(1ull<<i)) rep(i,N-1) pos[i] = p_bit[pos[i]];
// cout << i << ":"; rep(i,N-1) cout << p_bit[i] << " "; cout << endl;
// rep(i,N-1) cout << pos[i] << " "; cout << endl;
}
ll result[M]; result[0] = x[0];
rep(i,N-1) result[i+1] = result[i] + diff[pos[i]];
rep(i,N) cout << result[i] << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define int ll
const int N=1e5+5;
int a[N],b[N],d[N],p[N],ans[N],vis[N],st[N],tt=0,n,m;ll k;
void dfs(int u){if(!vis[u])vis[u]=1,st[++tt]=u,dfs(p[u]);}
main()
{
scanf("%lld",&n);for(int i=1;i<=n;i++)scanf("%lld",&a[i]),d[i]=a[i]-a[i-1];
scanf("%lld%lld",&m,&k);
for(int i=1;i<=n;i++)p[i]=i;
for(int i=1;i<=m;i++)scanf("%lld",&b[i]),swap(p[b[i]],p[b[i]+1]);
for(int i=1;i<=n;i++)
{
if(vis[i])continue;
tt=0;dfs(i);
for(int j=1;j<=tt;j++)ans[st[j]]=d[st[(j+k-1)%tt+1]];
}
for(int i=1;i<=n;i++)printf("%lld.0\n",ans[i]+=ans[i-1]);
}
| 1 |
#include <iostream>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m) {
int i, a[10001] = { 0 }, b[10001] = { 0 };
bool list[2][1001] = { false };
if (n == 0 && m == 0) goto END;
for (i = 0; i < m; i++) {
cin >> a[i] >> b[i];
if (a[i] == 1) {
list[0][b[i]] = true;
list[1][b[i]] = true;
}
if (b[i] == 1) {
list[0][a[i]] = true;
list[1][a[i]] = true;
}
}
for (i = 0; i < m; i++) {
if (list[0][a[i]] == true) {
list[1][b[i]] = true;
}
if (list[0][b[i]] == true) {
list[1][a[i]] = true;
}
}
int ans = 0;
for (i = 2; i <= n; i++) {
if (list[1][i]) ans++;
}
cout << ans << endl;
}
END:;
return 0;
} | #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>
/*
* coder :: ATUL_PANDEY_2608
* >>> INDIA <<<
*/
using namespace std;
using namespace __gnu_pbds;
// #define part ..
#define pb(a) push_back(a)
#define all(a) a.begin(),a.end()
#define mod 1000000007
//#define maxx 200006
#define ll long long
#define quick ios_base::sync_with_stdio(NULL),cin.tie(0);
#define listll vector< long long >
#define listi vector< int>
#define pii pair<int , int>
#define pll pair<long long , long long >
#define minheap priority_queue<long long , vector< long long >, greater<long long > >
#define rep(i,a,b) for(int i=a;i<b;i++)
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
template < class T > using oset = tree< T , null_type, less < T > , rb_tree_tag , tree_order_statistics_node_update > ;
// end of #define
// define globals ...
const int maxx = 2e6+26;
//write function from here ...
vector < int > arr;
void prime () {
bool vis[maxx];
memset ( vis, 0 , sizeof (vis) );
for ( ll i = 2; i*i <=maxx; i++){
if( vis[i] == 0 ){
for( ll j = i*i; j<maxx ; j+= i){
vis[j] =1 ;
}
}
}
for ( int i= 2; i < maxx; i++){
if( vis[i]== 0){
arr.pb( i);
}
}
}
int Main(){
prime();
ll a,b;
cin>>a>>b;
int nn = arr.size();
ll temp =a;
int i = 0 ;
set < ll > st ;
map< ll , int > mp1 ,mp2;
//int j = 0 ;
//for(auto it : arr ) {
//if( j > 100)
//break;
//else
//{cout<<it<<" ";j++;
//}
//}
while(i < nn && temp > 1){
if( temp%arr[i]==0)
{
mp1[arr[i]]= 1;
st.insert( arr[i]);
}
while(temp%arr[i] == 0 )
{
temp/=arr[i];
}
i++;
}
if(temp > 1)
{
mp1[temp ] = 1;
st.insert(temp);
}
temp = b;
i =0 ;
while(i < nn && temp > 1){
if( temp%arr[i]==0){
mp2[arr[i]]= 1;
st.insert(arr[i]);
}
while(temp%arr[i] == 0 )
{
temp/=arr[i];
}
i++;
}
if(temp > 1)
{
mp2[temp ] = 1;
st.insert(temp);
}
int cnt =1;
for( auto it : st ) {
if(mp1 [it] && mp2[it] ){
cnt++;
}
}
cout<<cnt<<endl;
return 0;
}
int main(){
quick;
int t =1;
//cin>>t;
while(t-- )
Main();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MM = 1000000000;
const int MOD = MM + 7;
const int MAX = 510000;
#define rep(i, n) for(ll i=0; i<n; i++)
#define Rep(i, j, n) for(ll i=j; i<n; i++)
#define all(vec) vec.begin(), vec.end()
template<class T> inline bool chmin(T& a, T b) {if(a > b) {a = b; return true;} return false;}
template<class T> inline bool chmax(T& a, T b) {if(a < b) {a = b; return true;} return false;}
const ll INF = 1LL << 60;
const double pi = acos(-1.0);
int main() {
ll d, g; cin >> d >> g;
vector<ll> p(d), c(d);
rep(i, d) cin >> p[i] >> c[i];
ll ans = INF;
rep(i, (1<<d)) {
ll sum = 0;
ll cnt = 0;
rep(j, d) {
if(i&(1<<j)) {
sum += 100 * (j + 1) * p[j] + c[j];
cnt += p[j];
}
}
//cout << d << ' ' << g << ' ' << ans << ' ' << sum << endl;
if(sum >= g) {chmin(ans, cnt); continue;}
for(ll j=d-1; j>=0; j--) {
if(!(i&(1<<j))) {
Rep(k, 1, p[j]) {
sum += 100 * (j + 1);
cnt++;
if(sum >= g) chmin(ans, cnt);
}
}
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define F first
#define S second
const int mod = 1e9 + 7, A = 1e5 + 2;
int n, k, p[11], c[11];
ll dp[11][A];
ll solve(int ind, int rem) {
if (rem <= 0) return 0;
if (ind == n) return 1e9;
if (~dp[ind][rem])
return dp[ind][rem];
ll val = solve(ind + 1, rem - (p[ind] * (ind + 1)) - c[ind]) + p[ind];
for (int i = 0; i < p[ind]; i++)
val = min(val, solve(ind + 1, rem - (i * (ind + 1))) + i);
return dp[ind][rem] = val;
}
int main() {
ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
cin >> n >> k;
k /= 100;
for (int i = 0; i < n; i++) {
cin >> p[i] >> c[i];
c[i] /= 100;
}
memset(dp, -1, sizeof dp);
cout << solve(0, k);
return 0;
} | 1 |
#include <bits/stdc++.h>
#include<string>
#define mod 1000000007
using ll = long long;
using namespace std;
int main(){
ll n; cin >> n;
ll ans=0;
ll s=n/3;
ll a=n/5;
ll d=n/15;
ans=(1+n)*n/2;
ans=ans-(3+s*3)*s/2-(5+a*5)*a/2+(15+d*15)*d/2;
cout << ans << "\n";
}
| #include <stdio.h>
int main(){
int n;
scanf("%d", &n);
long long int ans=0;
for(int i=1;i<=n;i++){
if(i%3==0 ||i%5==0){
continue;
}
ans +=i;
}
printf("%lld\n", ans);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
typedef long long ll;
const char nl = '\n' ;
const ll MOD = 1e9 + 7;
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int a, b;
string s;
cin >> a >> b >> s;
if(a+b+1 != s.size() || s[a] != '-')
{
cout << "No" << nl;
return 0;
}
for(int i = 0; i < s.size(); i++)
{
if(i == a) continue;
if(s[i] < '0' || s[i] > '9')
{
cout << "No" << nl;
return 0;
}
}
cout << "Yes" << nl;
return 0;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(k,i,n) for(ll i=k;i<n;++i)
int main(void){
ll a,b;
cin>>a>>b;
string s;
cin>>s;
bool ans=true;
rep(0,i,a)if(!(s[i]>='0'&&s[i]<='9'))ans=false;
if(s[a]!='-')ans=false;
rep(0,i,b)if(!(s[a+1+i]>='0'&&s[a+1+i]<='9'))ans=false;
if(ans)cout<<"Yes";
else cout<<"No";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
ll N;
cin >> N;
vec A(N);
REP(i,0,N) cin >> A[i];
ll ng = 0, m = INF, sum = 0;
REP(i,0,N) {
if(A[i] < 0) ++ng;
m = MIN(m,abs(A[i]));
sum += abs(A[i]);
}
if(ng % 2 == 0) PR(sum);
else PR(sum-m*2);
return 0;
}
/*
*/ | #include <iostream>
#include <algorithm>
using namespace std;
int main(){
int N, mcount=0;
cin >> N;
long long A[N];
for (int i = 0; i < N; i++){
cin >> A[i];
if (A[i]<0){
mcount++;
A[i] *= -1;
}
}
long long ans = 0;
if (mcount%2==0){
for (int i = 0; i < N; i++){
ans += A[i];
}
printf("%llu\n", ans);
}else{
sort(A, A+N);
for (int i = 1; i < N; i++){
ans += A[i];
}
printf("%llu\n", ans - A[0]);
}
}
| 1 |
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <iomanip>
#include <math.h>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
//#define local
#ifdef local
#include "dbg-macro/dbg.h"
#endif
//#define hacks
#ifdef hacks
#include <boost/multiprecision/cpp_int.hpp>
#endif
#define p std::pair
#define ll long long
#define ld long double
#define ull unsigned long long
#define pi std::pair<int, int>
#define stdabs std::abs
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (unsigned long long i = 0; i < (unsigned long long)(n); ++i)
#define vec std::vector
#define oreq |=
#define npm next_permutation
using namespace std;
std::vector<unsigned ll> genprimevec(const unsigned ll N);
ll extgcd(ll a, ll b, ll& x, ll& y);
ll nCr(ll n, ll r);
void stat();
template <typename T> T fact(T num);
constexpr ll mod = 1000000000 + 7;
int main()
{
stat();
ll n, t;
cin >> n >> t;
ull ans = 0,curtime=0;
vec<ll> v(n);
rep(i, n) { cin >> v[i]; }
rep(i,n-1){
curtime+=v[i];
ans+=min(t,abs(v[i+1]-v[i]));
}
cout<<ans+t<<endl;
return 0;
}
ll extgcd(ll a, ll b, ll& x, ll& y)
{
if (b == 0) {
x = 1, y = 0;
return a;
}
ll d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
std::vector<unsigned ll> genprimevec(const unsigned ll N)
{
std::vector<bool> is_prime(N + 1);
for (unsigned ll i = 0; i <= N; i++) {
is_prime[i] = true;
}
std::vector<unsigned ll> P;
for (unsigned ll i = 2; i <= N; i++) {
if (is_prime[i]) {
for (unsigned ll j = 2 * i; j <= N; j += i) {
is_prime[j] = false;
}
P.emplace_back(i);
}
}
return P;
}
void stat(){
#ifdef local
rep(i, 2){std::cout << "local enable" << std::endl;
}
#endif
#ifdef hacks
rep(i, 2) { std::cout << "boost enable" << std::endl; }
#endif
}
ll nCr(ll n, ll r)
{
ll num = 1;
for (ll i = 1; i <= r; i++) {
num = num * (n - i + 1) / i;
}
return num;
}
template <typename T> T fact(T num)
{
if (num == 1) { return 1; }
return num * fact(num - 1);
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
int dp[1005][1005];
void ExtendedEditDistance(vector<string> s1, vector<string> s2){
const int INF = 1e9;
for(int i=0;i<1005;i++)
for(int j=0;j<1005;j++) dp[i][j] = INF;
dp[0][0] = 0;
int sum1 = 0, sum2;
for(int i=0;i<(int)s1.size();i++){
for(int j=0;j<(int)s1[i].size();j++){
int idx1 = sum1 + j;
sum2 = 0;
for(int k=0;k<(int)s2.size();k++){
for(int l=0;l<(int)s2[k].size();l++){
int idx2 = sum2 + l;
if( s1[i][j] == s2[k][l] ) dp[idx1+1][idx2+1] = min( dp[idx1+1][idx2+1], dp[idx1][idx2] );
else{
dp[idx1+1][idx2] = min( dp[idx1+1][idx2], dp[idx1][idx2] + 1 );
dp[idx1][idx2+1] = min( dp[idx1][idx2+1], dp[idx1][idx2] + 1 );
dp[idx1+1][idx2+1] = min( dp[idx1+1][idx2+1], dp[idx1][idx2] + 1 );
}
/*
if( j == 0 ) dp[idx1+s1[i].size()][idx2] = min( dp[idx1+s1[i].size()][idx2], dp[idx1][idx2] + 1 );
if( l == 0 ) dp[idx1][idx2+s2[k].size()] = min( dp[idx1][idx2+s2[k].size()], dp[idx1][idx2] + 1 );
*/
if( i == (int)s1.size() - 1 ){
int idx1 = sum1 + s1[i].size();
dp[idx1][idx2+1] = min( dp[idx1][idx2+1], dp[idx1][idx2] + 1 );
//if( l == 0 ) dp[idx1][idx2+s2[k].size()] = min( dp[idx1][idx2+s2[k].size()], dp[idx1][idx2] + 1 );
}
}
if( k == (int)s2.size() - 1 ){
int idx2 = sum2 + s2[k].size();
dp[idx1+1][idx2] = min( dp[idx1+1][idx2], dp[idx1][idx2] + 1 );
// if( j == 0 ) dp[idx1+s1[i].size()][idx2] = min( dp[idx1+s1[i].size()][idx2], dp[idx1][idx2] + 1 );
}
sum2 += s2[k].size();
}
}
sum1 += s1[i].size();
}
cout<<dp[sum1][sum2]<<endl;
/*
int ans = dp[sum1][sum2];
for(int i=0;i<1005;i++) ans = min( ans, dp[sum1][i] + sum2 - i );
for(int i=0;i<1005;i++) ans = min( ans, dp[i][sum2] + sum1 - i );
cout<<ans<<endl;
*/
}
signed main(){
vector<string> s1, s2;
string A, B;
cin>>A>>B;
s1.push_back( A );
s2.push_back( B );
ExtendedEditDistance(s1,s2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> ii;
#define DEBUG freopen("in.txt", "r", stdin);
struct fastio {
fastio() {
ios::sync_with_stdio(false);
cout << setprecision(10) << fixed;
cin.tie(0);
}
};
fastio _fast_io;
int a, b;
int main() {
cin >> a >> b;
int ans = a + b;
ans = max(ans, a - b);
ans = max(ans, a * b);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
typedef pair<int,int> P;
typedef long long ll;
int main() {
string s, t;
cin >> s >> t;
cout << t + s << endl;
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <cstring>
#include <sstream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <chrono>
#include <numeric>
using namespace std;
class cLSearch
{
int mn, mq;
string mS, mT;
vector<int> vs, vt;
int ans;
void decode();
public:
cLSearch(const int &n, const int &q, const string &s, const string &t)
{
mn = n;
mq = q;
mS = s;
mT = t;
decode();
}
void search();
void output();
};
void cLSearch::search()
{
sort(vs.begin(), vs.end());
sort(vt.begin(), vt.end());
int count = 0;
vector<int>::iterator vis = vs.begin();
vector<int>::iterator vit = vt.begin();
int ts, tt;
while (vis != vs.end() && vit != vt.end())
{
if (*vis == *vit)
{
++count;
ts = *vis;
tt = *vit;
while (vis != vs.end() && ts == *vis)
++vis;
while (vit != vt.end() && tt == *vit)
++vit;
}
else
{
if (vis != vs.end() && vit != vt.end() && *vis > *vit)
++vit;
else
++vis;
}
}
ans = count;
}
void cLSearch::output()
{
cout << ans << endl;
}
void cLSearch::decode()
{
istringstream iss;
iss.str(mS);
int ts;
for (int i = 0; i < mn; ++i)
{
iss >> ts;
vs.push_back(ts);
}
iss.str(mT);
iss.seekg(0, iss.beg);
for (int i = 0; i < mq; ++i)
{
iss >> ts;
vt.push_back(ts);
}
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
string s, t;
cin >> n;
cin.ignore();
getline(cin, s);
cin >> q;
cin.ignore();
getline(cin, t);
cLSearch cls(n, q, s, t);
cls.search();
cls.output();
return 0;
} | #include <cstdio>
#include <vector>
#define rep(i, N) for (int i = 0; i < N; ++i)
using namespace std;
bool linerSearch(vector<int> vec, int key) {
rep(i, vec.size()) if (vec[i] == key) return true;
return false;
}
int main() {
int n, q, key;
scanf("%d", &n);
vector<int> S(n);
rep(i, n) scanf("%d", &S[i]);
int ans = 0;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d", &key);
if (linerSearch(S, key)) ++ans;
}
printf("%d\n", ans);
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.