code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define BIL ((ll)1e9)
#define MOD ((ll)1e9+7)
#define INF (1LL<<60) //1LL<<63でオーバーフロー
#define inf (1<<29) //1<<29でオーバーフロー
int main(int argc,char* argv[]){
int a,b;
cin >> a >> b;
int plug=1;
int tap=0;
while(plug<b){
tap++;
plug=plug-1+a;
}
cout << tap << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pii;
typedef tuple<ll, ll, ll> ti;
ll mod=1E9+7;
#define REP(a,b,c) for(ll a=b;a<(c);a++)
#define PER(a,b,c) for(ll a=b;a>=(c);a--)
ll ii(){ ll x; cin >> x; return x; }
string is(){ string x; cin >> x; return x; }
ld id(){ ld x; cin >> x; return x; }
void oi(ll x){ cout << x; }
void od(ld x){ cout << fixed << setprecision(10) << x; }
void os(string x){ cout << x; }
void oe(){ cout << endl; }
void oie(ll x){ oi(x); oe(); }
void ode(ld x){ od(x); oe(); }
void ose(string x){ os(x); oe(); }
int main(){
ll N=ii();
ll M=ii();
ll r=((N-1)/2);
ll r3=r/2;
ll r2=r-r3;
REP(i,0,min(r2,M)){
oi(i+1);
os(" ");
oie(2*r2-i);
}
REP(i,0,min(r3,M-r2)){
oi(2*r2+i+1);
os(" ");
oie(2*(r2+r3)+1-i);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i=0; i<n; i++)
#define pb push_back
#define int long long
typedef tuple<int, int, int, int> T;
int H, W;
int a[510][510];
vector<T> ans;
signed main() {
cin.tie(0); ios::sync_with_stdio(false);
cin >> H >> W;
rep(i, H) rep(j, W) cin >> a[i][j];
rep(i, H) {
if (i%2==0) {
rep(j, W) {
if (i==H-1 && j==W-1) continue;
int ni, nj;
if (j==W-1) ni = i+1, nj = W-1;
else ni = i, nj = j+1;
if (a[i][j]%2==1) {
ans.pb(make_tuple(i+1, j+1, ni+1, nj+1));
a[ni][nj]++;
}
}
}
else {
for (int j=W-1; j>=0; j--) {
if (i==H-1 && j==0) continue;
int ni, nj;
if (j==0) ni = i+1, nj = 0;
else ni = i, nj = j-1;
if (a[i][j]%2==1) {
ans.pb(make_tuple(i+1, j+1, ni+1, nj+1));
a[ni][nj]++;
}
}
}
}
cout << ans.size() << endl;
rep(i, ans.size()) cout << get<0>(ans[i]) << " " << get<1>(ans[i]) << " " << get<2>(ans[i]) << " " << get<3>(ans[i]) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i,n) for(ll (i)=0; (i)<(ll)(n); (i)++)
#define frep(i,m,n) for(ll (i)=(m); (i)<=(ll)(n); (i)++)
#define rrep(i,n) for(ll (i)=(n)-1; (i)>-1; (i)--)
#define frrep(i,m,n) for(ll (i)=(n); (i)>(ll)(m); (i)--)
#define ALL(x) (x).begin(), (x).end()
const ll INF = 100100100100100100;
const ll MOD = 1000000007;
// get abs
ll my_abs(ll a);
// a^n
ll a_n(ll a, ll n);
// get gcd
ll my_gcd(ll a, ll b);
// a^(-1) % MOD
ll inv(ll a);
// (a+b+c)%MOD
ll madd(ll a, ll b, ll c);
// (a-b)%MOD
ll msub(ll a, ll b);
// (a*b*c)%MOD
ll mtime(ll a, ll b, ll c);
int main() {
ll h, w;
cin >> h >> w;
vector<vector<bool>> odd(h, vector<bool>(w, false)); // 奇数ならtrue;
vector<pair<P,P>> ans;
rep(i, h) {
rep(j, w) {
ll a; cin >> a;
if((a%2) == 1) odd[i][j] = true;
}
}
rep(i, h) {
bool ok = false; // 奇数から取ったコインを移動中
rep(j, w) {
if(odd[i][j]) {
if(ok) {
ok = false;
}
else {
ok = true;
if(j != w-1) ans.push_back(make_pair(P(i+1,j+1), P(i+1,j+2)));
}
}
else {
if(ok && (j != w-1)) {
ans.push_back(make_pair(P(i+1,j+1), P(i+1,j+2)));
}
}
}
if(ok && i != h-1) {
ans.push_back(make_pair(P(i+1,w), P(i+2,w)));
odd[i+1][w-1] = !(odd[i+1][w-1]);
}
}
cout << ans.size() << endl;
rep(i, ans.size()) {
cout << ans[i].first.first << ' ';
cout << ans[i].first.second << ' ';
cout << ans[i].second.first << ' ';
cout << ans[i].second.second << endl;
}
return 0;
}
ll my_abs(ll a) {
if(a >= 0) return a;
else return -1 *a;
}
ll a_n(ll a, ll n) {
if(n == 0) return 1;
ll ret = a, count = 1;
while(count * 2 < n) {
ret *= ret;
count *= 2;
}
if(count == n) return ret;
else return (ret * a_n(a, n-count));
}
ll my_gcd(ll a, ll b) {
if(b == 0) return a;
return my_gcd(b, a%b);
}
ll inv(ll a) {
return a_n(a, MOD-2);
}
ll madd(ll a, ll b, ll c) {
ll ret = (a+b) % MOD;
return (ret+c) % MOD;
}
ll msub(ll a, ll b) {
if(a < b) return (a-b+MOD) % MOD;
else return (a-b) % MOD;
}
ll mtime(ll a, ll b, ll c) {
ll ret = (a*b) % MOD;
return (ret*c) % MOD;
}
| 1 |
#pragma region header
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------よく使う数字や配列----------------- */
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr ll inf = INT32_MAX/2;
constexpr ll INF = LLONG_MAX/2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------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 * b / gcd(a, b);
}
int keta(ll n) { //桁数を求める
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
/* ----------------------end----------------------- */
#pragma endregion
signed main() {
int h,w;cin >> h >> w;
vvb bo(h,vb(w));
vector<P> v;
rep(i, h) {
rep(j, w) {
char c;cin >> c;
if(c=='#') {
bo[i][j]=true;
v.pb({i,j});
}
else bo[i][j]=false;
}
}
bool ok = true;
rep(i, v.size()) {
rep(j, 4) {
int x=v[i].first+dx[j],y=v[i].second+dy[j];
if(x<0||x>=h||y<0||y>=w||!bo[x][y]) {
// cout << i << endl;
if(j==3) {
cout << "No" << endl;
return 0;
}
continue;
}
break;
}
}
cout << "Yes" << endl;
return 0;
} | #include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int main(void) {
int H, W;
scanf("%d %d", &H, &W);
string s[50];
for (int i = 0; i < H; i++) {
cin >> s[i];
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
bool paintable = false;
if (s[i][j] != '#') continue;
if (j != W - 1 && s[i][j + 1] == '#') paintable = true;
if (j != 0 && s[i][j - 1] == '#') paintable = true;
if (i != H - 1 && s[i + 1][j] == '#') paintable = true;
if (i != 0 && s[i - 1][j] == '#') paintable = true;
// cout << i << " " << j << " " << paintable << "\n";
if (!paintable) {
printf("No\n");
return 0;
}
}
}
printf("Yes\n");
return 0;
}
| 1 |
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>
using namespace std;
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int mx = 55555;
vector<vector<int>> G(10);
vector<bool> isPrime(mx + 2, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= mx; ++i) {
if (isPrime[i]) {
G[i % 10].push_back(i);
for (int j = i + i; j <= mx; j += i) {
isPrime[j] = false;
}
}
}
for (auto x : G[1]) {
cout << x;
if (--n == 0) {
cout << '\n';
break;
} else {
cout << ' ';
}
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
inline int read(){
int res=0;
char c;
bool zf=0;
while(((c=getchar())<'0'||c>'9')&&c!= '-');
if(c=='-')zf=1;
else res=c-'0';
while((c=getchar())>='0'&&c<='9')res=(res<<3)+(res<<1)+c-'0';
if(zf)return -res;
return res;
}
int tot[26];
signed main(){
string ss;cin>>ss;int n=ss.size(),s=0;
for(register int i=0;i<n;i++)tot[ss[i]-'a']++,s++;
long long ans=1ll*s*(s-1)/2;for(register int i=0;i<26;i++)ans-=1ll*tot[i]*(tot[i]-1)/2;printf("%lld\n",ans+1);
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <string>
#include <vector>
#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>;
int INF = 1e9;
int dist[1005][1005];
int dx[4] = {-1,1,0,0};
int dy[4] = {0,0,-1,1};
int main(){
int h,w;cin >> h >> w;
queue<int> q;
rep(i,h)rep(j,w){
char ch;cin >> ch;
if(ch == '#'){
dist[i][j]=0;
q.push(w*i+j);
}else dist[i][j] = -1;
}
while(q.size()){
int ind = q.front();
q.pop();
int y = ind/w;
int x = ind%w;
for(int i = 0;i < 4;i++){
int ny = y + dy[i];
int nx = x + dx[i];
if(ny < 0 || nx < 0 || h <= ny || w <= nx) continue;
if(dist[ny][nx]!=-1) continue;
dist[ny][nx] = dist[y][x] + 1;
q.push(w*ny+nx);
}
}
int ans = 0;
rep(i,h){
rep(j,w){
ans = max(ans,dist[i][j]);
}
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#include <utility>
#include <tuple>
#include <functional>
#include <bitset>
#include <cassert>
#include <complex>
#include <stdio.h>
#include <time.h>
#include <numeric>
#define all(a) a.begin(),a.end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef long double ld;
typedef complex<ld> com;
constexpr int inf = 1000000000;
constexpr ll INF = 1000000000000000000;
constexpr ld EPS = 1e-12;
constexpr ld PI = 3.141592653589793238;
template<class T, class U> inline bool chmax(T &a, const U &b) { if (a < b) { a = b; return true; } return false; }
template<class T, class U> inline bool chmin(T &a, const U &b) { if (a > b) { a = b; return true; } return false; }
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n;
string s;
cin >> n >> s;
rep(i, 4) {
string t = "";
rep(j, 2) {
if ((i >> j) & 1) t += 'S';
else t += 'W';
}
for (int i = 1; i < n - 1; i++) {
int cnt = 0;
if (t[i - 1] == 'S') cnt ^= 1;
if (t[i] == 'S') cnt ^= 1;
if (s[i] == 'o') cnt ^= 1;
if (cnt) t += 'S';
else t += 'W';
}
int check = 0;
if (t[n - 2] == 'S') check ^= 1;
if (t[n - 1] == 'S') check ^= 1;
if (t[0] == 'S') check ^= 1;
if (s[n - 1] == 'o') check ^= 1;
if (check) continue;
if (t[n - 1] == 'S') check ^= 1;
if (t[0] == 'S') check ^= 1;
if (t[1] == 'S') check ^= 1;
if (s[0] == 'o') check ^= 1;
if (check) continue;
cout << t << '\n';
return 0;
}
cout << -1 << '\n';
} | 0 |
#include <iostream>
#include <string>
using namespace std;
long long solve(long long x){
if(x <= 6){
return 1;
}
if(x <= 11){
return 2;
}
long long res;
res = x % 11;
if(res == 0){
return x / 11 * 2;
}
if(res <= 6){
return x / 11 * 2 + 1;
}
else{
return x / 11 * 2 + 2;
}
}
int main(void){
long long x;
cin >> x;
long long ans = solve(x);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int,int>
#define fi first
#define sc second
#define all(x) (x).begin(),(x).end()
signed main() {
#ifdef _DEBUG
// freopen("in" , "r", stdin );
// freopen("out", "w", stdout);
#endif
ios::sync_with_stdio(0); cin.tie(0);
string s;
cin >> s;
set<char> d;
for (char c = 'a'; c <= 'z'; c++) d.insert(c);
for (auto &i : s) d.erase(i);
if (d.empty()) cout << "None" << '\n';
else cout << *d.begin() << '\n';
}
| 0 |
#include<bits/stdc++.h>
// DEEP
using namespace std;
#define boost ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define fwd(i,a,n) for(int i=a;i<=n;i++)
#define bak(i,a,n) for(int i=a;i>=n;i--)
#define all(v) v.begin(),v.end()
#define pb push_back
#define lop '\n'
#define mp make_pair
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef pair<int,int> pi;
typedef set<int> si;
const ll mod = 1e9 + 7;
const ll mod1=998244353;
//power
ull power(ull x,ull y){
if(y==0) return 1;
else{
if(y%2==0) return power(x*x,y/2);
else return x*power(x*x,(y-1)/2);
}
}
// Modular Exponentiation
ll mod_power(ll x, ll y, ll m)
{
ll r = 1; // Initialize result
x = x % m; // Update x if it is more than or equal to m
if (x == 0) return 0; // In case x is divisible by m;
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
r = (r*x) % m;
// y must be even now
y = y/2;
x = (x*x) % m;
}
return r;
}
//GCD
ull gcd(ull x,ull y){
if(y==0)return x;
return gcd(y,x%y);
}
// EXTENDED_EUCLID
vector<ll>extended_Euclid(ll a,ll b){
vector<ll>v(3);
if(b==0){
v[0]=a;v[1]=1;v[2]=0;
return v;
}
else{
vector<ll>v1 = extended_Euclid(b,a%b); //recursive call
v[0]=v1[0];
v[1]=v1[2];
v[2]=v1[1]-(a/b)*v1[2];
return v;
}
}
// DFS ( number of connected components )
//vector<vector<ll> >adj(200001);
//bool visited[200001];
/*ll dfs(int x,int c){ // x - > node c - > number of edges in the component
if(visited[x])return c;
else{
visited[x]=true;
int y=c;
for(int i=0;i<adj[x].size();i++){
if(!visited[adj[x][i]]){
c+=1;
int d=dfs(adj[x][i],y);
c+=d;
}
}
return c;
}
}
*/
// SIEVE
/*
bool isPrime[100001];
void sieve(int N) {
for(int i = 0; i <= N;++i) {
isPrime[i]=true;
}
isPrime[0]=false;
isPrime[1]=false;
for(int i = 2; i * i <= N; ++i) {
if(isPrime[i] == true) {
for(int j = i * i; j <= N ;j += i)
isPrime[j] = false;
}
}
}
*/
// Binary Search
/*
ll bin_search(ll y){
while(lo<hi){
x=lo+(hi-lo)/2;
if(condition){
.....
}
else{
// increase lo or decrease hi suitably
}
}
}
*/
int main(){
boost;
int TESTS=1;
//cin>>TESTS;
while(TESTS--){
string s;
cin>>s;
if(s[0]==s[1] && s[0]==s[2])cout<<s<<endl;
else{
if(s[1]>s[0]){
char x=s[0];
x++;
cout<<x<<x<<x<<endl;
}
else{
if(s[1]==s[0]){
if(s[2]<s[1])cout<<s[0]<<s[0]<<s[0]<<endl;
else{
char x=s[0];
x++;
cout<<x<<x<<x<<endl;
}
}
else{
cout<<s[0]<<s[0]<<s[0]<<endl;
}
}
}
}
}
/* Be careful about integer ranges;
Check the corner cases before submitting.
*/
| #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <cctype>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <bitset>
#include <complex>
#include <fstream>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T> T RoundOff(T a){ return int(a+.5-(a<0)); }
template<class T, class C> void chmax(T& a, C b){ if(a < b) a = b; }
template<class T, class C> void chmin(T& a, C b){ if(b < a) a = b; }
template<class T, class C> pair<T, C> mp(T a, C b){ return make_pair(a, b); }
int main()
{
string str;
map<char, int> p;
p.insert(map<char, int>::value_type('I', 1));
p.insert(map<char, int>::value_type('V', 5));
p.insert(map<char, int>::value_type('X', 10));
p.insert(map<char, int>::value_type('L', 50));
p.insert(map<char, int>::value_type('C', 100));
p.insert(map<char, int>::value_type('D', 500));
p.insert(map<char, int>::value_type('M', 1000));
while(cin >> str)
{
int len = str.size();
vint num(len);
rep(i, len)
num[i] = p[str[i]];
int res = num[len-1];
rep(i, len-1)
{
if(num[i+1] <= num[i])
{
res += num[i];
}
else
{
res -= num[i];
if(i + 1 != len - 1) res += num[i+1];
i++;
}
}
cout << res << endl;
}
} | 0 |
#include "bits/stdc++.h"
using namespace std;
template<typename Itr>
auto partition2(const Itr first, const Itr last){
auto i=first;
for(auto j=first; j!=last; ++j){
if(*j<=*last){
iter_swap(i, j);
++i;
}
}
iter_swap(i, last);
return i;
}
int32_t main(){
size_t n; cin>>n;
vector<uint32_t> a(n); for(auto&& e:a) cin>>e;
const auto last=--end(a);
auto mid=partition2(begin(a), last);
for(auto i=begin(a); i!=mid; ++i) cout<<*i<<' ';
cout<<'['<<*mid<<"] ";
for(auto i=next(mid); i!=last; ++i) cout<<*i<<' ';
cout<<*last<<'\n';
}
| #include <iostream>
#include <cassert>
#include <queue>
#define INF 922337203685477580
typedef long long ll;
using namespace std;
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) {
i++;
int a = A[i];
A[i] = A[j];
A[j] = a;
}
}
int a = A[r];
A[r] = A[i + 1];
A[i + 1] = a;
return i + 1;
}
int main() {
int n;
cin >> n;
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int pos = partition(A, 0, n - 1);
for (int i = 0; i < n; i++) {
if (i) cout << " ";
if (i == pos) {
cout << "[" << A[i] << "]";
} else {
cout << A[i];
}
}
cout << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
vector<int> v(n);
for(int i = 0;i<n;i++)
{
cin>>v[i];
}
int minsofar = INT_MAX;
int count = 0;
for(int i = 0;i<n;i++)
{
minsofar = min(minsofar,v[i]);
if(v[i] <= minsofar)
{
count++;
}
}
cout<<count;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define sz(x) (int)(x.size())
#define FOR(x,y,z) for(int x = y; x <= z; x++)
#define int long long
const int N = 1e5 + 2, inf = 1e18;
int32_t main(){
ios::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int n, m;
cin >> n >> m;
if(n > m)
swap(n, m);
int k;
cin >> k;
int ans = 0;
while(k > 0){
k -= m;
ans++;
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define all(n) begin(n), end(n)
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef unsigned long long ull;
template <class T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
if (b < a)
{
a = b;
return 1;
}
return 0;
}
template <typename T>
vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts>
auto make_v(size_t a, Ts... ts)
{
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type
fill_v(T &t, const V &v) { t = v; }
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type
fill_v(T &t, const V &v)
{
for (auto &e : t)
fill_v(e, v);
}
int main()
{
int N;
cin >> N;
int first = 0, last = (N - 1);
vector<string> mem(N);
string str1, str2;
if (mem[first] == "")
{
cout << first << endl;
cin >> str1;
if (str1 == "Vacant")
return 0;
mem[first] = str1;
}
if (mem[last] == "")
{
cout << last << endl;
cin >> str2;
if (str2 == "Vacant")
return 0;
mem[last] = str2;
}
for (size_t i = 0; i < 18; i++)
{
int mid = (first + last) / 2;
string str;
if(mem[mid]=="")
{
cout<<mid<<endl;
cin>>str;
if(str == "Vacant")
return 0 ;
mem[mid]=str;
}
if (abs(first - mid) % 2 == 0)
{
if (mem[first] == mem[mid])
first = mid;
else
last = mid;
}
else if (abs(first - mid) % 2 != 0)
{
if (mem[first] == mem[mid])
last = mid;
else
first = mid;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef pair<int, int> ii;
int n;
string s, temp;
vector<int> vec;
int main() {
cin.tie(0), ios::sync_with_stdio(0);
cin >> n;
cout << 0 << "\n";
cout.flush();
cin >> s;
temp = s;
if(temp == "Vacant")
exit(0);
for(int i = 2; i < n; i+=2)
vec.pb(i);
int l = 0;
for(int i = 20; i >= 0; i--){
if(l + (1 << i) < n){
cout << l + (1 << i) << "\n";
cout.flush();
cin >> s;
if(s == "Vacant")
exit(0);
else{
if(temp == s)
l += (1 << i);
}
}
}
cout << l + 1 << "\n";
cout.flush();
cin >> s;
exit(0);
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define debug(x) cout << '>' << #x << ':' << x << endl;
#define ll long long
int main() {
int n;
scanf("%d", &n);
int arr[n + 1];
map<int, int> mp;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
if (mp[arr[i]] == 0) mp[arr[i]] = 1;
else mp[arr[i]] = 0;
}
long long ans = 0;
for (auto c : mp){
ans += c.second;
}
printf("%lld" , ans);
}
| #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n;
cin>>n;
int a[n];
int x;
for(int i=0;i<n;i++){
cin>>a[i];
}
sort(a,a+n);
int tmp=0;
int ans=0;
while(tmp<n){
int tmp2=a[tmp];
int cnt=0;
while(tmp<n&&a[tmp]==tmp2){
tmp++;
cnt++;
}
ans+=cnt%2;
}
cout<<ans<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) x.begin(), x.end()
using namespace std;
typedef long long ll;
typedef pair<int, int> pair;
const int inf = 1000000000; //10^9
const ll inff = 1000000000000000000; //10^18
int main(){
string s;
cin >> s;
int n = s.size();
bool a[26];
rep(i, 26) a[i] = false;
rep(i, n) {
a[s[i] - 'a'] = true;
}
rep(i, 26) {
if(!a[i]) {
cout << (char)(i + 'a') << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
} | #include <iostream>
#include <string>
#include <map>
#include <string.h>
using namespace std;
int main(){
map<char,int> ch;//文字の数字辞書登録
ch['I']=1;
ch['V']=5;
ch['X']=10;
ch['L']=50;
ch['C']=100;
ch['D']=500;
ch['M']=1000;
int ans=0;
int len=0;
char s[1111];
while(cin >> s){
len=strlen(s);
for(int i=0;i<len;i++){
if(ch[s[i]]<ch[s[i+1]]){//もしも引き算をすべき場合だったら
ans-=ch[s[i]];
}else{
ans+=ch[s[i]];
}
}
cout << ans << endl;
ans=0;
}
} | 0 |
#include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define debug(s, param) std::cerr << s << param << std::endl;
using namespace std;
using ll = long long;
const ll MOD = 1000000007;
int bfs(const vector<string>& grids, int h, int w) {
vector<vector<int>> deltas{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
vector<vector<bool>> visit(h, vector<bool>(w, false));
queue<pair<int, int>> q;
auto isAvailable = [h, w](int row, int col) { return (row >= 0 && row < h && col >= 0 && col < w); };
q.emplace(0, 0);
visit[0][0] = true;
int steps = 0;
while (!q.empty()) {
int size = (int)q.size();
rep (i, size) {
int row = q.front().first, col = q.front().second;
if (row == h - 1 && col == w - 1) return steps;
q.pop();
for (const auto& delta : deltas) {
int nextRow = row + delta[0], nextCol = col + delta[1];
if (isAvailable(nextRow, nextCol) && grids[nextRow][nextCol] == '.' && !visit[nextRow][nextCol]) {
visit[nextRow][nextCol] = true;
q.emplace(nextRow, nextCol);
}
}
}
++steps;
}
return -1;
}
int main() {
int h, w;
cin >> h >> w;
int blackNums = 0;
vector<string> grids(h, "");
rep (i, h) {
cin >> grids[i];
rep (j, w) if (grids[i][j] == '#') ++blackNums;
}
int res = bfs(grids, h, w);
if (res == -1) cout << -1 << endl;
else cout << h * w - (blackNums + res + 1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O0")
typedef long long int ll;
typedef long double ld;
const ll mod = 1e9+7;
const ll INF = 1e18;
#define rep(i,n) for (ll i = 0; i < (n); ++i)
#define Rep(i,a,n) for (ll i = (a); i < (n); ++i)
#define All(a) (a).begin(),(a).end()
#define Pi acos(-1)
using Graph = vector<vector<ll>>;
using V = vector<ll>;
using P = pair<ll,ll>;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << setprecision(15) << fixed;
chrono::system_clock::time_point start,end;
start = chrono::system_clock::now();
ll h, w;
cin >> h >> w;
vector<string> grid(h);
rep(i,h) cin >> grid[i];
Graph d(h, V(w,-1));
ll sy = 0, sx = 0, gy = h-1, gx = w-1;
d[sy][sx] = 0;
queue<P> q;
vector dy = {0,1,0,-1};
vector dx = {1,0,-1,0};
q.push(make_pair(sy,sx));
while(!q.empty()) {
ll y = q.front().first, x = q.front().second;
if (d[gy][gx] != -1) break;
rep(i,4) {
ll ny = y + dy[i], nx = x + dx[i];
if (ny < 0 || nx < 0 || ny >= h || nx >= w) continue;
if (grid[ny][nx] == '.' && d[ny][nx] == -1) {
d[ny][nx] = d[y][x]+1;
q.push(make_pair(ny,nx));
}
}
q.pop();
}
ll cnt = 0;
rep(i,h) rep(j,w) {
if (grid[i][j] == '.') ++cnt;
}
if (d[gy][gx] == -1) cout << -1 << '\n';
else cout << cnt - d[gy][gx] - 1 << '\n';
end = chrono::system_clock::now();
auto elapsed = chrono::duration_cast< chrono::milliseconds >(end - start).count();
cerr << elapsed << "ms" << '\n';
} | 1 |
#include <stdio.h>
#include <set>
using namespace std;
int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
int main(){
int n,ans,temp;
set<long long int> s;
scanf("%d%d",&n,&ans);
n--;
while(n--){
scanf("%d",&temp);
ans=gcd(ans,temp);
}
for(long long int i=1;i*i<=ans;i++)if(ans%i==0){
s.insert(i);
s.insert(ans/i);
}
for(auto u:s)printf("%lld\n",u);
}
| #include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <utility>
int main(){
int N, M;
scanf("%d", &N);
scanf("%d", &M);
std::vector<int > A(N);
for (int i=0; i<N; i++){
scanf("%d", &A[i]);
}
int sum=0;
std::map<int, int> mp;
mp[0]++;
long long ans = 0;
for (int i=0; i<N; i++){
sum+=A[i];
sum %= M;
ans += mp[sum];
mp[sum]++;
}
std::cout << ans << std::endl;
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <cmath>
#include <set>
#include <algorithm>
#include <iomanip>
typedef long long ll;
const ll MOD = 1e9 + 7;
const long long INF = 1LL<<60;
const double PI=3.14159265358979323846;
const int NMAX=100005;
using namespace std;
int main(){
int n;
cin >> n;
vector<ll> a(n);
for(int i = 0; i < n; i++){
cin >> a[i];
}
ll ans = 0;
ll digits = 1;
for(int i = 0; i < 60; i++){
ll zero = 0, one = 0;
for(int j = 0; j < n; j++){
int x = (a[j]>>i) & 1;
if(x == 0) zero++;
else one++;
}
ll cnt = zero * one;
cnt %= MOD;
cnt *= digits;
cnt %= MOD;
ans += cnt;
ans %= MOD;
digits *= 2L;
digits %= MOD;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int64_t n;
cin >> n;
int64_t a[n+1];
for(int i = 0; i < n; i++){
cin >> a[i];
}
a[n] = 100000001;
sort(a,a+n);
int64_t ans = 0,count = 1;
for(int i = 0; i < n; i++){
if(a[i] == a[i+1]){
count++;
}else{
if( (count % 2) == 1){
ans++;
}
count = 1;
}
}
cout << ans << endl;
} | 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
int main(){
int m,n;
priority_queue<int> que;
while(cin>>n>>m,m|n){
int sum=0;
for(int i=0;i<n;i++){
int p;
cin>>p;
que.push(p);
}
vector<int> bag;
while(que.size()){
int p=que.top();que.pop();
bag.push_back(p);
if(que.empty() || bag.size()==m){
for_each(bag.begin(),bag.end(),[&sum](int v){sum += v;});
if(bag.size()==m) sum-=p;
bag.clear();
}
}
cout<<sum<<endl;
}
return 0;
} | #include<iostream>
using namespace std;
long long cnt = 0;
void merge(int* arr, int left, int mid, int right) {
int len1 = mid - left + 1;
int len2 = right - mid;
int* tempL = new int[len1];
int* tempR = new int[len2];
for (int i = 0; i < len1; i++)tempL[i] = arr[left + i];
for (int i = 0; i < len2; i++)tempR[i] = arr[mid+1 + i];
int i = 0, j = 0;
for (int k = left; k <= right; k++)
if (i < len1 && (j >= len2 || tempL[i] <= tempR[j]))
arr[k] = tempL[i++];
else {
arr[k] = tempR[j++];
cnt += (len1 - i);
}
delete[]tempL;
delete[]tempR;
}
void mergeSort(int* arr, int left, int right) {
int mid = (left + right) / 2;
if (left < mid) {
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
}
merge(arr, left, mid, right);
}
int main() {
int len;
cin >> len;
int* arr = new int[len];
for (int i = 0; i < len; i++)
cin >> arr[i];
mergeSort(arr, 0, len - 1);
cout << cnt << endl;
delete[]arr;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 300
#define X 998244353
#define Inc(x,y) ((x+=(y))>=X&&(x-=X))
using namespace std;
int n,m,a[N+5],f[N+5][N+5][N+5];char s[N+5];
int main()
{
RI i,j,k,cnt=1;for(scanf("%s",s+1),n=strlen(s+1),i=1;i<=n;++i) s[i]^'0'?++a[cnt]:++cnt;//转化
RI p;scanf("%d",&m),m=min(n,m),f[0][0][0]=1;//初始化
for(i=0;i^cnt;++i) for(j=0;j<=m;++j) for(k=0;k<=m;++k) if(f[i][j][k])//枚举状态，如果状态能达到再去刷表
{
Inc(f[i+1][j][k],f[i][j][k]);//不操作
for(p=m-j;p;--p) Inc(f[i+1][j+p][k+p],f[i][j][k]);//加上一个数
for(p=min(a[i+1],k);p;--p) Inc(f[i+1][j][k-p],f[i][j][k]);//减去一个数
}
RI t=0;for(i=0;i<=m;++i) Inc(t,f[cnt][i][0]);return printf("%d\n",t),0;//输出答案
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 998244353;
string S;
int K, M;
int memo[400][400][400];
bool visited[400][400][400];
map<int,int> memo_g;
int g(int q) {
if (memo_g.count(q)) return memo_g[q];
int r = 0, qq = q;
while (qq >= 0 && S[qq] == '1') { -- qq; ++ r; }
return memo_g[q] = r;
}
int f(int p, int r, int s) {
if (r > K) return 0;
if (p == (int)S.length()) {
return 1;
}
if (visited[p][r][s]) return memo[p][r][s];
visited[p][r][s] = true;
int q = M-p-s;
int res = 0;
if (q >= 0 && S[q] == '0') {
res += f(p+1, r, s);
} else {
int x = g(q);
int qq = q-x;
if (qq >= 0 && S[qq] == '0') {
res += f(p+1, r+x, s+x);
}
}
if (q >= 0 && S[q] == '1') {
res += f(p+1, r, s);
} else if (s > 0) {
res += f(p+1, r, s-1);
}
return memo[p][r][s] = res % mod;
}
int main() {
cin >> S >> K;
M = (int)S.length()-1;
cout << f(0, 0, 0) << endl;
}
| 1 |
#pragma GCC optimize(3,"Ofast","inline")
#include<bits/stdc++.h>
using namespace std;
const int N=5e5+10;
int cnt[N],ans[N],a[N];
int n,q,bl;
int res;
struct node
{
int l,r,p;
}e[N];
bool cmp(const node &a,const node &b)
{
return (a.l/bl)==(b.l/bl) ? a.r<b.r :a.l>b.l;
}
void remove(int x)
{
if((--cnt[a[x]])==0) res--;
}
void add(int x)
{
if((++cnt[a[x]])==1) res++;
}
int main()
{
scanf("%d %d",&n,&q);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
bl=sqrt(n);
for(int i=1,l,r;i<=q;i++)
{
scanf("%d %d",&l,&r);
e[i]={l,r,i};
}
// cout<<"--------------"<<endl;
sort(e+1,e+1+q,cmp);
// cout<<"*****"<<endl;
res=0;
int curL=1,curR=0;
for(int i=1;i<=q;i++)
{
//cout<<i<<endl;
int L=e[i].l,R=e[i].r;
while(curL<L) remove(curL++);
while(curL>L) add(--curL);
while(curR<R) add(++curR);
while(curR>R) remove(curR--);
ans[e[i].p]=res;
}
for(int i=1;i<=q;i++) printf("%d\n",ans[i]);
}
| #include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define rep(i,N) for(int i=0;i<(int)N;i++)
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
static inline void PUT(char c)
{
static char buf[1<<15],*ptr=buf;
if(ptr==buf+strlen(buf)||c==0){fwrite(buf,1,ptr-buf,stdout),ptr=buf;}*ptr++=c;
}
static inline int IN(void)
{
int x=0,f=0,c=getchar();while(c<48||c>57){f^=c==45,c=getchar();}
while(c>47&&c<58){x=x*10+c-48,c=getchar();}return f?-x:x;
}
static inline void OUT(int a)
{
if(a<0)PUT('-'),a=-a;
int d[40],i=0;do{d[i++]=a%10;}while(a/=10);
while(i--){PUT(d[i]+48);}PUT('\n');
}
int N=0;
static inline void Add(int *fwt,int i,int v){while(i<N){fwt[i]+=v;i|=i+1;}}
static inline int Sum(int *fwt,int i){int v=0;while(i>=0){v+=fwt[i];i=(i&(i+1))-1;}return v;}
int main()
{
N=IN();int Q=IN(),after[500001],dat[500000],fenwick[500000],id[500001],left[500001],pos[500000],result[500000];
rep(i,N){dat[i]=IN()-1;}
rep(i,Q){left[i+1]=IN()-1;int r=IN()-1;after[i+1]=id[r];id[r]=i+1;}
for(int r=0;r<N;r++)
{
if(pos[dat[r]]){Add(fenwick,pos[dat[r]]-1,-1);}
Add(fenwick,r,1);
for(int i=id[r];i;i=after[i]){result[i-1]=Sum(fenwick,r)-Sum(fenwick,left[i]-1);}
pos[dat[r]]=r+1;
}
rep(i,Q){OUT(result[i]);}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout<<(s)<<endl
#define p2(s, t) cout << (s) << " " << (t) << endl
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << endl
#define p_yes() p("Yes")
#define p_no() p("No")
const ll mod = 1e9 + 7;
const ll inf = 1e18;
template < typename T >
void vprint(T &V){
for(auto v : V){
cout << v << " ";
}
cout << endl;
}
struct Point{
ll x;
ll y;
Point(ll x, ll y): x(x), y(y) {}
Point(){}
};
ll field[21][21];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
// input
for(;;){
// jewel num
ll N;
cin >> N;
if(N==0) return 0;
Point p = Point(10, 10);
FOR(i, 0, 21){
FOR(j, 0, 21){
field[i][j] = 0;
}
}
// jewel position
FOR(i, 0, N){
ll x, y;
cin >> x >> y;
field[y][x] = 1;
}
// move
ll count = 0;
ll M; cin >> M;
FOR(i, 0, M){
char c; cin >> c;
ll len; cin >> len;
FOR(j, 0, len){
if(c=='N') p.y++;
if(c=='S') p.y--;
if(c=='E') p.x++;
if(c=='W') p.x--;
if(field[p.y][p.x]==1){
field[p.y][p.x] = 0;
count++;
}
}
}
if(count==N){
p_yes();
}else{
p_no();
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T,class U> using P = pair<T,U>;
template<class T> using vec = vector<T>;
template<class T> using vvec = vector<vec<T>>;
class BVCC{
private:
vector<int> ord,low,used;
vector<vector<int>> g;
vector<vector<P<int,int>>> bc;
vector<P<int,int>> tmp;
int N,K = 0;
public:
set<int> ap;
BVCC(int n,vector<vector<int>> v){
N = n;
g = v;
ord = low = vector<int>(N,-1);
used = vector<int>(N,0);
}
void dfs(int now,int prev){
used[now] = 1;
ord[now] = K++;
low[now] = ord[now];
int cnt = 0;
for(auto x:g[now]) if(x!=prev){
if(ord[x]<ord[now]){
tmp.emplace_back(min(now,x),max(now,x));
}
if(!used[x]){
cnt++;
dfs(x,now);
low[now] = min(low[now],low[x]);
if(low[x]>=ord[now]){
if(now!=0) ap.insert(now);
bc.push_back({});
while(true){
P<int,int> e = tmp.back();
bc.back().emplace_back(e);
tmp.pop_back();
if(min(now,x)==e.first && max(now,x)==e.second) break;
}
}
}else low[now] = min(low[now],ord[x]);
}
if(now==0 && cnt>=2) ap.insert(now);
}
void decomposition(){
dfs(0,-1);
}
};
int N,M;
int main(){
cin >> N >> M;
vector<vector<int>> v(N);
int a,b;
for(int i=0;i<M;i++){
cin >> a >> b;
v[a].push_back(b); v[b].push_back(a);
}
BVCC bvcc(N,v);
bvcc.decomposition();
for(auto x:bvcc.ap) cout << x << endl;
}
| 0 |
#include<iostream>
using namespace std;
int main(){
int N,a,b,c,d;
int i,j;
int t[101]={0};
int r[101];
for(i=0;i<101;i++){
r[i]=1;
}
cin>>N;
for(i=0;i<N*(N-1)/2;i++){
cin>>a>>b>>c>>d;
if(c>d){
t[a]=t[a]+3;
}
else if(c<d){
t[b]=t[b]+3;
}
else{
t[a]=t[a]+1;
t[b]=t[b]+1;
}
}
for(i=1;i<=N;i++){
for(j=1;j<=N;j++){
if(t[i]<t[j]){
r[i]++;
}
}
}
for(i=1;i<=N;i++){
cout<<r[i]<<endl;
}
return 0;
} | #include<iostream>
#include<vector>
#include<queue>
using namespace std;
#define INF (1LL << 63)
struct edge{
size_t to;
size_t weight;
};
vector<size_t> dijkstra(vector<vector<edge>>& Graph, int& startPoint, int& vertexNum){
vector<size_t> minimumWeight(vertexNum,INF);
priority_queue<vector<pair<size_t,size_t>>, vector<pair<size_t,size_t>>, greater<pair<size_t,size_t>>> priorityQueue;
priorityQueue.push({0,startPoint});
minimumWeight[startPoint] = 0;
while(!priorityQueue.empty()){
pair<size_t,size_t> tmp = priorityQueue.top();
edge Edge;
Edge.to = tmp.second;
Edge.weight = tmp.first;
priorityQueue.pop();
if(minimumWeight[Edge.to] < Edge.weight) continue;
for(edge& edge : Graph[Edge.to]){
if(minimumWeight[edge.to] < minimumWeight[Edge.to] + edge.weight) continue;
minimumWeight[edge.to] = minimumWeight[Edge.to] + edge.weight;
priorityQueue.push({minimumWeight[edge.to],edge.to});
}
}
return minimumWeight;
}
int main(){
int N,M;
while(cin >> N >> M, N&&M){
vector<vector<edge>> costGraph(M);
vector<vector<edge>> timeGraph(M);
for(int i = 0;i < N; i++){
size_t a,b,c,t;
cin >> a >> b >> c >> t;
a--,b--;
costGraph[a].push_back({b,c});
costGraph[b].push_back({a,c});
timeGraph[a].push_back({b,t});
timeGraph[b].push_back({a,t});
}
int k;
cin >> k;
for(int j=0;j<k;j++){
int p,q,r;
cin >> p >> q >> r;
p--, q--;
vector<size_t> res;
if(r == 0) res = dijkstra(costGraph, p, M);
else res = dijkstra(timeGraph, p, M);
cout << res[q] << endl;
}
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
int main() {
string S; cin >> S;
int ans = 10000;
rep(s, S.size() - 2) {
string T = S.substr(s, 3);
int x = 0;
rep(i, 3) x = x * 10 + (T[i] - '0');
ans = min(ans, abs(753 - x));
}
cout << ans << endl;
return 0;
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<queue>
#include<set>
using namespace std;
typedef long long LL;
const int N=2e6;
int gi() {
int w=0;bool q=1;char c=getchar();
while ((c<'0'||c>'9') && c!='-') c=getchar();
if (c=='-') q=0,c=getchar();
while (c>='0'&&c <= '9') w=w*10+c-'0',c=getchar();
return q? w:-w;
}
int s1[N],s2[N];
int L[N],R[N],st[N];
int main()
{
int n=gi(),i,j,top=0,ans=0;char c;
for (i=1;i<=n;s1[i++]=c-'a') while ((c=getchar())<'a');
for (i=1;i<=n;s2[i++]=c-'a') while ((c=getchar())<'a');
for (i=n;i&&s1[i]==s2[i];i--);if (!i) return puts("0"),0;
for (i=j=n;i;L[j]=i--) {
while (j&&s1[j]!=s2[i]) j--;
if (!j) return puts("-1"),0;
if (!R[j]) R[j]=i,st[++top]=j;
j-=i==j;
}
reverse(st+1,st+1+top);
for (i=j=1;i<=top;i++) {
while (j<top&&st[j+1]-(j-i+1)<R[st[i]]) j++;
ans=max(ans,j-i+1);
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include <cstdio>
#define F(i, a, b) for (LL i = a; i <= b; i ++)
#define G(i, a, b) for (LL i = a; i >= b; i --)
#define pf printf
typedef long long LL;
const LL N = 1e7 + 10;
const LL M = 20;
using namespace std;
LL D, L, Ans, Sum, total, w[M];
LL ten[M], v[M], tot[M], TOT[M];
void Dfs(LL k, LL s, LL S) {
if (s < 0) return;
if (s + 10 * v[k] < D) return;
if (s - 10 * v[k] > D) return;
if (k > L) {
if (s == D) {
Sum += S;
// printf("Yes\n");
}
return;
}
F(i, -9, 9)
w[k] = i, Dfs(k + 1, s + v[k] * i, S * (k == 1 ? TOT[i + 9] : tot[i + 9]));
}
int main() {
scanf("%lld", &D);
// F(i, 1, N - 10) {
// LL rev = 0;
// for (LL x = i; x; rev = rev * 10 + (x % 10), x /= 10);
// if (rev - i == D)
// printf("%lld\n", i), total ++;
// }
// puts("");
F(i, 0, 9)
F(j, 0, 9)
tot[i - j + 9] ++;
F(i, 0, 9)
F(j, 1, 9)
TOT[i - j + 9] ++;
ten[0] = 1;
F(i, 1, 18)
ten[i] = ten[i - 1] * 10LL;
F(i, 2, 18) {
L = i / 2, Sum = 0;
F(j, 1, L)
v[j] = ten[i - j] - ten[j - 1];
Dfs(1, 0, 1);
Ans += Sum * ((i & 1) ? 10 : 1);
// pf("%d\n", i);
}
pf("%lld\n", Ans);
} | #include <iostream>
#include <vector>
#include <ios>
#include <limits.h>
using namespace std;
#define FOR(i, s, e) for(int i = s; i < e; ++i)
typedef vector<long> vec;
long long c = 0;
void Merge(vec& vA, int l, int m, int r)
{
int n1 = m - l;
int n2 = r - m;
vec vL(n1 + 1, 0);
vec vR(n2 + 1, 0);
FOR(i, 0, n1) vL[i] = vA[l + i];
FOR(i, 0, n2) vR[i] = vA[m + i];
vL[n1] = LONG_MAX;
vR[n2] = LONG_MAX;
int s = 0, t = 0;
FOR(i, l, r){
if ( vL[s] > vR[t]){
vA[i] = vR[t];
++t;
c += n1 - s;
}else{
vA[i] = vL[s];
++s;
}
}
}
void CountCross(vec& vA, int l, int r)
{
if (l + 1 >= r) return;
int m = (l + r) / 2;
CountCross(vA, l, m);
CountCross(vA, m, r);
Merge(vA, l, m, r);
}
int main()
{
int n;
cin >> n;
vec vA(n, 0);
FOR(i, 0, n) cin >> vA[i];
CountCross(vA, 0, n);
cout << c << "\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
#define pb push_back
#define mpr make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
#define ll long long
#define ld long double
#define all(arr) arr.begin(), arr.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define fo(i, l, r) for (int i = l; i <= r; i++)
#define INF 1000000001
#define inf1 1000000000000000001
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define N 100005
#define mid(l, r) l + (r - l) / 2
#define vec vector<int>
#define vecl vector<ll>
#define umap unordered_map<ll,ll>
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define endl "\n"
using namespace std;
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
int ddx[8]={1,1,0,-1,-1,-1,0,1},ddy[8]={0,1,1,1,0,-1,-1,-1};
ll gcd(ll a,ll b){ if(!a)return b;return gcd(b%a,a);}
void test_case() {
int a , b , c;
cin>>a>>b>>c;
swap(a,b);
swap(a,c);
cout<<a<<" "<<b<<" "<<c<<endl;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed<<setprecision(20);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int t = 1;
// cin >> t;
while (t--)
{
test_case();
}
} | #include<iostream>
#include<string>
#include<algorithm>
#include<cmath>
#include<map>
#include<vector>
#include<math.h>
#include<stdio.h>
#include<stack>
#include<queue>
#include<tuple>
#include<cassert>
#include<set>
//#include<bits/stdc++.h>
#define int long long
using namespace std;
const int INF = 10000000000000000;
const int mod = 1000000007;
int test[12345678], kari[345678], aa[12345678];
signed main() {
int n, a, b, ans; cin >> n >> a >> b;
n++; cout << (n - a)*(n - b) << endl;
cin >> n; return 0;
} | 0 |
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
#define int long long
using namespace std;
typedef pair<int,int>P;
#define F first
#define S second
int a[100009][20];
int b[100009];
int n,L,test;
signed main(){
cin>>n;
r(i,n) cin>>b[i];
cin>>L;
r(j,20){
if(j==0){
int id=0,sum=0;
r(i,n){
while(id<n-1 && sum+(b[id+1]-b[id])<=L) sum += b[id+1]-b[id],id++;
a[i][j] = id;
//cout<<id<<endl;
if(i!=n-1 && sum)sum -=b[i+1]-b[i];
}
}
else{
r(i,n){
a[i][j] = a[a[i][j-1]][j-1];
}
}
}
cin>>test;
while(test--){
int l,r;
cin>>l>>r; l--; r--;
if(r<l)swap(l,r);
int sum=0;
while(l<r){
//cout<<l<<endl;
for(int i=19;i>=0;i--){
if(i&&( a[l][i]>=r ))continue;
//cout<<l<<' '<<i<<' '<<a[l][i]<<' '<<i<<endl;
l=a[l][i];
sum+=pow(2,i);
break;
}
//cout<<l<<endl;
}
cout<<sum<<endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const int N = 100100;
int n, x[N], L, Q, dp[N][17];
void calc() {
for (int i = 0; i < N; i++)
for (int j = 0; j < 17; j++)
dp[i][j] = inf;
for (int i = 1; i <= n; i++) {
auto it = upper_bound(x + 1, x + 1 + n, x[i] + L);
it--;
dp[i][0] = it - x;
}
for (int j = 1; j < 17; j++)
for (int i = 1; i <= n; i++)
dp[i][j] = dp[dp[i][j - 1]][j - 1];
}
int get(int l, int r) {
if (l > r) swap(l, r);
int ll = 1, rr = n - 1, res = r - l;
while (ll <= rr) {
int mid = ll + rr >> 1, cur = l;
for (int i = 0; i < 17; i++)
if (mid & (1 << i)) cur = dp[cur][i];
if (cur >= r) {
res = mid;
rr = mid - 1;
} else ll = mid + 1;
}
return res;
}
int main() {
cin >> n;
fill(x, x + N, inf);
for (int i = 1; i <= n; i++)
cin >> x[i];
cin >> L >> Q;
calc();
while (Q--) {
int l, r;
cin >> l >> r;
cout << get(l, r) << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
// clang-format off
using namespace std; using ll = int64_t; using ull = uint64_t; const ll INF = 9e18;
void print() { cout << endl; }
template<typename Head,typename... Tail> void print(Head head,Tail... tail){cout<<head;if(sizeof...(Tail)>0)cout<<" ";print(tail...);}
void print0() {}
template<typename Head,typename... Tail> void print0(Head head,Tail... tail){cout<<head;print0(tail...);}
// clang-format on
int main() {
ll N;
cin >> N;
string S;
getline(cin, S);
getline(cin, S);
vector<ll> R;
vector<ll> G;
vector<ll> B;
set<ll> RS;
set<ll> GS;
set<ll> BS;
for (ll i = 0; i < S.length(); i++) {
char c = S.at(i);
if (c == 'R') {
R.push_back(i);
RS.insert(i);
} else if (c == 'G') {
G.push_back(i);
GS.insert(i);
} else {
B.push_back(i);
BS.insert(i);
}
}
ll total = 0;
// ll tpre = 0;
for (ll i = 0; i < S.length(); i++) {
char ci = S.at(i);
for (ll j = i + 1; j < S.length(); j++) {
char cj = S.at(j);
ll notk = j + j - i;
if (ci == 'R') {
if (cj == 'G') {
total += B.end() - lower_bound(B.begin(), B.end(), j) - BS.count(notk);
} else if (cj == 'B') {
total += G.end() - lower_bound(G.begin(), G.end(), j) - GS.count(notk);
}
} else if (ci == 'G') {
if (cj == 'R') {
total += B.end() - lower_bound(B.begin(), B.end(), j) - BS.count(notk);
} else if (cj == 'B') {
total += R.end() - lower_bound(R.begin(), R.end(), j) - RS.count(notk);
}
} else if (ci == 'B') {
if (cj == 'R') {
total += G.end() - lower_bound(G.begin(), G.end(), j) - GS.count(notk);
} else if (cj == 'G') {
total += R.end() - lower_bound(R.begin(), R.end(), j) - RS.count(notk);
}
}
// if (tpre != total) {
// print(i, j, total - tpre);
// }
// tpre = total;
}
}
print(total);
}
| #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL <<60;
int main(void){
long long res=0;
long long i,j,k;
long long l,m,h;
string s;
long long n_r=0,n_g=0,n_b=0;
long long n_max=4010;
long long n;
long r[n_max]={},g[n_max]={},b[n_max]={};
cin>>n;
cin>>s;
for(i=0;i<n;i++){
if(s[i]=='R'){
r[n_r]=i;
n_r++;
}
else if(s[i]=='G'){
g[n_g]=i;
n_g++;
}
else{
b[n_b]=i;
n_b++;
}
}
res=n_r*n_g*n_b;
//cout<<n_r<<" "<<n_g<<" "<<n_b<<endl;
for(i=0;i<n_r;i++){
for(j=0;j<n_g;j++){
h=max(r[i],g[j]);
l=min(r[i],g[j]);
if(2*l-h>=0 && s[2*l-h]=='B'){
res--;
}
if(2*h-l<n && s[2*h-l]=='B'){
res--;
}
if((h+l)%2==0 && s[(h+l)/2]=='B'){
res--;
}
}
}
cout<<res<<endl;
return 0;
} | 1 |
#include "bits/stdc++.h"
#define REP(i,num) for(ll i=0;i<(num);++i)
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}
using namespace std;
using ll = long long;
constexpr ll atcoder_mod = 1e9+7;
template<typename T=ll>
T in(){T x; cin >> x; return (x);}
template<typename T=ll,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}
void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
string S=in<string>();
map<char,ll> M;
for(auto& x:S) M[x]++;
ll N=S.size();
ll A=N*(N-1LL)/2LL;
for(auto& x:M){
A -= x.second*(x.second-1LL)/2LL;
}
out(A+1LL);
return 0;
}
| #include<iostream>
#include<cstdio>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<functional>
#include<map>
#include<cstring>
#define p pair<int,int>
#define P pair<int,p>
using namespace std;
P a[100000];
int Par[10000], Rank[10000];
int saiki(int b) {
if (Par[b] == b)return b;
return Par[b]=saiki(Par[b]);
}
void unite(int b, int c) {
b = saiki(b); c = saiki(c);
if (Rank[b] > Rank[c]) {
Par[c] = b;
}
else if (Rank[b] < Rank[c]) {
Par[b] = c;
}
else {
Par[c] = b;
Rank[b]++;
}
}
signed main() {
int b, c; cin >> b >> c;
for (int d = 0; d < c; d++) {
int e, f, g; scanf("%d%d%d", &e, &f, &g);
a[d] = P(g, p(e, f));
}
sort(a, a + c);
int cost = 0;
for (int i = 0; i < b; i++)Par[i] = i;
for (P s : a) {
if (saiki(s.second.first) != saiki(s.second.second)) {
cost += s.first;
unite(s.second.first, s.second.second);
}
}
cout << cost << endl;
} | 0 |
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<vector>
#include<queue>
#include<bitset>
#include<string>
#include<stack>
#include<set>
#include<unordered_set>
#include<map>
#include<unordered_map>
#include<cstring>
#include<complex>
#include<cmath>
#include<iomanip>
#include<numeric>
#include<algorithm>
#include<list>
#include<functional>
#include<cassert>
#define mp make_pair
#define pb push_back
#define X first
#define Y second
#define y0 y12
#define y1 y22
#define INF 1987654321987654321
#define PI 3.141592653589793238462643383279502884
#define fup(i,a,b,c) for(int (i)=(a);(i)<=(b);(i)+=(c))
#define fdn(i,a,b,c) for(int (i)=(a);(i)>=(b);(i)-=(c))
#define MEM0(a) memset((a),0,sizeof(a));
#define MEM_1(a) memset((a),-1,sizeof(a));
#define ALL(a) a.begin(),a.end()
#define SYNC ios_base::sync_with_stdio(false);cin.tie(0)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef double db;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int, int> Pi;
typedef pair<ll, ll> Pll;
typedef pair<double, double> Pd;
typedef vector<int> Vi;
typedef vector<ll> Vll;
typedef vector<double> Vd;
typedef vector<Pi> VPi;
typedef vector<Pll> VPll;
typedef vector<Pd> VPd;
typedef tuple<int, int, int> iii;
typedef tuple<ll, ll, ll> LLL;
typedef vector<iii> Viii;
typedef vector<LLL> VLLL;
typedef complex<double> base;
const ll MOD = 1000000007;
ll POW(ll a, ll b, ll MMM = MOD) {ll ret=1; for(;b;b>>=1,a=(a*a)%MMM)if(b&1)ret=(ret*a)% MMM; return ret; }
ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }
ll lcm(ll a, ll b) { if (a == 0 || b == 0)return a + b; return a*(b / gcd(a, b)); }
int dx[] = { 0,1,0,-1,1,1,-1,-1 }, dy[] = { 1,0,-1,0,1,-1,1,-1 };
int n,A,B,C,D;
ll d[1001][1001];
ll fac[1001],inv[1001];
ll go(int N,int K)
{
if(N==0)return fac[n];
if(K>B)return 0;
ll &ret=d[N][K];
if(ret!=-1)return ret;
ret=go(N,K+1);
for(int i=C;i<=D && i*K<=N;i++)
{
ll tt=POW(inv[K],i);
ll t=(tt*inv[i])%MOD;
ret=(ret+t*go(N-i*K,K+1))%MOD;
}
return ret;
}
int main() {
fac[0] = inv[0] = 1;
fup(i, 1, 1000, 1)
fac[i] = (fac[i - 1] * i) % MOD;
inv[1000] = POW(fac[1000], MOD - 2);
fdn(i, 999, 1, 1)
inv[i] = (inv[i + 1] * (i+1)) % MOD;
MEM_1(d);
scanf("%d%d%d%d%d",&n,&A,&B,&C,&D);
printf("%lld",go(n,A));
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long ll;
using Graph = vector<vector<int>>;
const int MOD = 1000000007;
const int INF_32 = 1LL << 30;
const int64_t INF_64 = 1LL << 60;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T& val)
{
std::fill((T*)array, (T*)(array + N), val);
}
// dp[c1][c2][c3]: (1個の皿がc1枚，2個の皿がc2枚，3個の皿がc3枚の状態ですべて食べるまでの操作回数の期待値)
double dp[305][305][305];
int N;
double rec(int c1, int c2, int c3)
{
if (dp[c1][c2][c3] != -1.0)
return dp[c1][c2][c3];
double ret = N;
if (c1 >= 1) {
ret += c1 * rec(c1 - 1, c2, c3);
}
if (c2 >= 1) {
ret += c2 * rec(c1 + 1, c2 - 1, c3);
}
if (c3 >= 1) {
ret += c3 * rec(c1, c2 + 1, c3 - 1);
}
ret /= (c1 + c2 + c3);
return dp[c1][c2][c3] = ret;
}
int main()
{
cin >> N;
Fill(dp, -1.0);
dp[0][0][0] = 0;
int c1, c2, c3;
c1 = c2 = c3 = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
if (a == 1)
c1++;
if (a == 2)
c2++;
if (a == 3)
c3++;
}
cout << fixed << setprecision(9);
cout << rec(c1, c2, c3) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
constexpr int B = 100000007;
constexpr int MOD = 1000000007;
constexpr int INF = 2147483647;
void yes(bool expr) {
cout << (expr ? "Yes" : "No") << "\n";
}
lint power(lint x, lint n, lint mod) {
lint ret = 1;
while(n > 0) {
if(n & 1) (ret *= x) %= mod;
(x *= x) %= mod;
n >>= 1;
}
return ret;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int N;
cin >> N;
vector<lint> a(N);
REP(i, N) cin >> a[i];
vector<lint> b(N);
REP(i, N) cin >> b[i];
vector<lint> pa(N);
vector<lint> pb(N);
REP(i, N) {
pa[i] = a[i] ^ a[(i+1)%N];
pb[i] = b[i] ^ b[(i+1)%N];
}
lint hash = 0;
lint target = 0;
REP(i, N) {
hash = (hash + pa[i]*power(B, i, MOD)) % MOD;
target = (target + pb[i]*power(B, i, MOD)) % MOD;
}
vector<pair<lint, lint>> ans;
REP(i, N) {
//cout << hash << " " << target << endl;
if(hash == target) {
lint x = b[0] ^ a[i];
ans.push_back(make_pair(i, x));
}
hash = hash * power(B, MOD-2, MOD) % MOD;
hash = (hash - pa[i]*power(B, MOD-2, MOD) % MOD + pa[i]*power(B, N-1, MOD) + MOD) % MOD;
}
sort(ans.begin(), ans.end(), [](auto const &a, auto const &b) { return a.first < b.first; });
REP(i, ans.size()) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
#include <fstream>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, a[200005] = {}, b[200005] = {}, c[600005] = {}, d[600005] = {};
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
a[n] = a[0]; b[n] = b[0];
for (int i = 0; i < n; i++) c[i] = b[i] ^ b[i + 1];
c[n] = -1;
for (int i = n + 1; i <= n + n; i++) c[i] = a[i - n - 1] ^ a[i - n];
for (int i = n + n + 1; i <= n + n + n; i++) c[i] = c[i - n];
for (int i = 1; i <= n + n + n + 1; i++) {
int x = i - 1;
while (x && d[x] != i - 1 && c[d[x]] != c[i - 1]) x = d[x];
if (x) d[i] = d[x] + 1;
}
for (int i = n + n + 1; i <= n + n + n; i++) if (d[i] == n) cout << i - n - n - 1 << ' ' << (a[i - n - n - 1] ^ b[0]) << '\n';
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n,m,i,j;
while(cin >> n >> m, n && m){
int ret = 0;
vector<int> data(n+1);
vector<int> all;
for(i=0;i<n;i++)cin >> data[i];
for(i=0;i<n+1;i++)
for(j=i;j<n+1;j++)
all.push_back(data[i]+data[j]);
sort(all.begin(),all.end());
for(i=0;i<all.size();i++){
int t = m-all[i];
vector<int>::iterator it = upper_bound(all.begin(),all.end(),t);
if(it != all.begin()){
ret = max(ret,all[i] + *(it-1) );
}
}
cout << ret << endl;
}
} | #include<iostream>
#include<cmath>
#include<vector>
#include<algorithm>
#include<fstream>
using namespace std;
typedef pair<int,pair<int, int> > P;
int main() {
while (1) {
int h, w;
vector<P> pos;
cin >> h >> w;
if (h == 0)break;
int X = pow(h, 2) + pow(w, 2);
//cout << X << endl;
for (int i = 1; i <= 150; i++) {
for (int j=i+1; j <= 150; j++) {
int x = pow(i, 2) + pow(j, 2);
if (x > X) {
//cout << i << ' ' << j << ' ' << x << endl;
pos.push_back(make_pair(x, make_pair(i, j)));
}
else if (x == X && i > h) {
pos.push_back(make_pair(x, make_pair(i, j)));
}
}
}
int n = 10000, m, minx=pow(X,2);
for (int i = 0; i < pos.size(); i++) {
if (pos[i].first < minx) {
minx = pos[i].first;
n = pos[i].second.first;
m = pos[i].second.second;
}
else if (pos[i].first == minx && pos[i].second.first < n) {
minx = pos[i].first;
n = pos[i].second.first;
m = pos[i].second.second;
}
}
cout << n << ' ' << m << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int x, y;
cin >> x >> y;
int total = 0;
if (x <= 3)
total += 4 - x;
if (y <= 3)
total += 4 - y;
if (x == 1 && x == y) {
total += 4;
}
total *= int(1e5);
cout << total;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define mod 1000000007
#define inf 1000000000
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define popcount(x) __builtin_popcountll(x)
const long double PI = acos(-1);
ll gcd(ll a,ll b){return b ? gcd(b,a%b) : a;}
ll lcm(ll a,ll b){return a / gcd(a,b) * b;}
int main(){
ll x, y;
cin >> x >> y;
ll ans = 0;
if(x == 1) ans += 300000;
if(x == 2) ans += 200000;
if(x == 3) ans += 100000;
if(y == 1) ans += 300000;
if(y == 2) ans += 200000;
if(y == 3) ans += 100000;
if(x == 1 && y == 1) ans += 400000;
cout << ans << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
ll A,B;
cin >>A>>B;
ll ans;
if(A==B){
ans = A+B;
}else{
ans = max(A,B)*2-1;
}
cout << ans << endl;
return 0;
} | #include<iostream>
#include<iomanip>
#include<string>
#include<algorithm>
#include<vector>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<stack>
#include<deque>
#include<bitset>
#include<math.h>
using namespace std;
using ll = int64_t;
using Graph = vector<vector<int> >;
const ll M = 1000000007;
int main(){
int n;
string s;
cin >> n >> s;
vector<int> w(n,0);
vector<int> e(n,0);
int cntw=0,cnte=0;
for(int i=0;i<n;i++){
if(s.at(i)=='W')cntw++;
w.at(i)=cntw;
}
for(int i=n-1;i>=0;i--){
if(s.at(i)=='E')cnte++;
e.at(i)=cnte;
}
int ans=n;
for(int i=0;i<n;i++){
int tmp=e.at(i)+w.at(i)-1;
ans=min(ans,tmp);
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define read(n) cin>>n;
#define write(n) cout<<n;
#define loop(x,n) for(int x = 0; x < n; ++x)
#define vector_loop(x,n) for(int i = 0; x < n; i++)
#define vii vector<int> a(n)
typedef pair<int, int> pii;
#define endl "\n"
#define sd(val) scanf("%d", &val)
#define ss(val) scanf("%s", &val)
#define sl(val) scanf("%lld", &val)
#define debug(val) printf("check%d\n", val)
#define all(v) v.begin(), v.end()
#define MP make_pair
#define FF first
#define SS second
#define ll long long
#define MOD 1000000007
#define clr(val) memset(val, 0, sizeof(val))
#define what_is(x) cerr << #x << " is " << x << endl;
#define OJ \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
int main()
{
FIO;
int a;
cin >> a;
cout << a + a*a + a*a*a;
return 0;
} | #include<iostream>
#include<cmath>
using namespace std;
int main()
{
int a,ans;
cin>>a;
ans=a+pow(a,2)+pow(a,3);
cout<<ans<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
auto check = [&](char out0, char out1) {
auto a = out0;
char out2;
auto v = vector<char>();
v.push_back(out0);
v.push_back(out1);
auto f = [](char in1, char out0, char out1) {
char out2;
if (in1 == 'o') {
if (out0 == 'S' && out1 == 'S') out2 = 'S';
if (out0 == 'S' && out1 == 'W') out2 = 'W';
if (out0 == 'W' && out1 == 'S') out2 = 'W';
if (out0 == 'W' && out1 == 'W') out2 = 'S';
} else {
if (out0 == 'S' && out1 == 'S') out2 = 'W';
if (out0 == 'S' && out1 == 'W') out2 = 'S';
if (out0 == 'W' && out1 == 'S') out2 = 'S';
if (out0 == 'W' && out1 == 'W') out2 = 'W';
}
return out2;
};
for (int i = 1; i < n; i++) {
char in1 = s[i];
out2 = f(in1, out0, out1);
v.push_back(out2);
out0 = out1;
out1 = out2;
}
if (out2 == a) {
v.erase(v.end() - 1);
if (f(s[0], v[n - 1], v[0]) == v[1]) {
return v;
}
}
return vector<char>();
};
auto intToC = [](int a) {
return a == 0 ? 'S' : 'W';
};
for (int i = 0; i < 4; i++) {
char out0 = intToC(i % 2);
char out1 = intToC(i / 2 % 2);
auto v = check(out0, out1);
if (v.size() > 0) {
for (auto c : v) {
putchar(c);
}
puts("");
return 0;
}
}
puts("-1");
}
| #include <bits/stdc++.h>
using namespace std;
#define loop(i, n) for(int i = 0;i < int(n);i++)
#define rloop(i, n) for(int i = int(n);i >= 0;i--)
#define range(i, a, b) for(int i = int(a);i <= int(b);i++)
#define SZ(c) int(c.size())
#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define PI acos(-1)
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define sfi1(v) scanf("%d",&v)
#define sfi2(v1, v2) scanf("%d %d",&v1,&v2)
#define sfi3(v1, v2, v3) scanf("%d %d %d",&v1,&v2,&v3)
#define sfll1(v) scanf("%I64d",&v);
#define sfll2(v1, v2) scanf("%I64d %I64d",&v1,&v2)
#define sfll3(v1, v2, v3) scanf("%I64d %I64d %I64d",&v1,&v2,&v3)
#define endl '\n'
typedef vector<int> vi;
typedef vector<pair<int, int> > vii;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e5 + 5;
int dp[N][2][2];
int vis[N][2][2], visid;
int F, L;
string str;
int n;
//sheep 0 , wolf 1
int solve(int idx, int cur, int lst) {
int &ret = dp[idx][cur][lst];
if (vis[idx][cur][lst] == visid)return ret;
vis[idx][cur][lst] = visid;
if (idx == n - 1) {
if (cur != L)return ret = 0;
if (cur == 0) {
ret = (str[idx] == 'o' && F == lst || str[idx] == 'x' && F != lst);
} else {
ret = (str[idx] == 'x' && F == lst || str[idx] == 'o' && F != lst);
}
return ret;
}
int nxt;
if (cur == 0) {
//truth
nxt = (str[idx] == 'o') ? lst : (!lst);
ret = solve(idx + 1, nxt, cur);
} else {
//lie
nxt = (str[idx] == 'o') ? (!lst) : lst;
ret = solve(idx + 1, nxt, cur);
}
return ret;
}
string ans;
void build(int idx, int cur, int lst) {
ans += (cur ? 'W' : 'S');
if (idx == n - 1)return;
int nxt;
if (cur == 0) {
//truth
nxt = (str[idx] == 'o') ? lst : (!lst);
build(idx + 1, nxt, cur);
} else {
//lie
nxt = (str[idx] == 'o') ? (!lst) : lst;
build(idx + 1, nxt, cur);
}
}
int main() {
#ifndef ONLINE_JUDGE
freopen("in.in", "r", stdin);
//freopen("out.in", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> str;
loop(f, 2) {
loop(l, 2) {
F = f, L = l;
visid++;
if (solve(0, f, l)) {
build(0, f, l);
cout << ans << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int main(){
string s; cin>>s;
cout<<s.substr(0,s.length()-8)<<'\n';
return 0;
}
| #include <iostream>
#include <numeric>
#include <math.h>
#include <algorithm>
#include <float.h>
#include <limits>
#include <vector>
#include <string.h>
#include <iomanip>
#define rep(i,a,n) for(ll int (i) = (a);(i) < (n);(i)++)
#define urep(i,a,n) for(ll int (i) = (a);(i) > (n);(i)--)
#define MOD 1000000007
#define INF 2147483647
#define ll long long
#define asort(a) sort(a.begin(),a.end());//昇順ソート
#define usort(a) sort(a.rbegin(),a.rend());//降順ソート
using namespace::std;
int jo(ll int a, ll int b){//累乗
ll int num=1;
rep(i,0,b) num=num*a;
return num;
}
char tobig(char s){//char大文字化
return (s-0x20);
}
char tolow(char s){//char小文字化
return (s+0x20);
}
int ctoi(char a){//char->int
if('0'<=a&&a<='9') return (a-'0');
return -1;
}
int gcd(ll int a,ll int b) {//最大公約数
if(a<b) return gcd(b,a);
int c;
while ((c=a%b)) {
a=b;
b=c;
}
return b;
}
int lcm(ll int a,ll int b){//最小公倍数
return (a*b)/gcd(a,b);
}
int main(){
string S;cin>>S;
rep(i,0,8) S.pop_back();
cout<<S;
}
// vector<vector<int>> 変数名(左の個数, vector<int>(右の個数));
//cout<<fixed<<setprecision(n); //小数点n桁まで表示
// vector<pair<int,int>> data(N); //2つのデータを格納、.first/.secondで参照
// pairのソートはfirst優先の昇順
| 1 |
#include <bits/stdc++.h>
#include <iostream>
#include<math.h>
#include<string>
#include<iomanip>
#include <numeric>
#include <limits>
using namespace std;
int main()
{
int n,g=0; cin>>n;
while(n>=3)
{
g++; n-=3;
}
cout<<g;
return 0;
} | #include <iostream>
using namespace std;
int main (){
int N;
cin>>N;
cout<<N/3;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ll long long
using namespace std;
const ll P = 1000000007;
const long long INF = 1LL << 60;
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main()
{
cout << fixed << setprecision(10);
int X,Y;
cin >> X >> Y;
if(X==1&&Y==1)
{
cout << 1000000 << endl;
return 0;
}
int sum = 0;
if(X==1)
{
sum += 300000;
}
else if(X==2)
{
sum += 200000;
}
else if(X==3)
{
sum += 100000;
}
if(Y==1)
{
sum += 300000;
}
else if(Y==2)
{
sum += 200000;
}
else if(Y==3)
{
sum += 100000;
}
cout << sum << 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(){
string s, t;
cin >> s >> t;
cout << t << s << endl;
return 0;
}
| 0 |
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int INF = 1e9+7;
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define tr(c, i) for(auto i = (c).begin(); i != (c).end(); i++)
#define rtr(c, i) for(auto i = (c).rbegin(); i != (c).rend(); i++)
#define repab(i,a,b) for(auto i=a;i<(b);i++)
#define rep(i,b) for(auto i=0;i<(b);i++)
#define pb push_back
#define sz(c) int((c).size())
enum {
FOUR_CARD,
FULL_HOURSE,
STRAIGHT,
THREE_CARD,
TWO_PAIR,
ONE_PAIR,
NULL_HAND,
} hands;
int check(map<int, int> m)
{
int maxnr = 0;
int minnr = INF;
int maxv = 0;
int minv = INF;
int maxnr_count = 0;
tr (m, i) {
if (maxnr < i->second) {
maxnr_count=1;
maxnr = i->second;
} else if (maxnr == i->second) {
maxnr_count++;
}
minnr = min(minnr, i->second);
maxv = max(maxv, i->first);
minv = min(minv, i->first);
}
if (maxnr == 4)
return FOUR_CARD;
if (maxnr == 3 && minnr == 2)
return FULL_HOURSE;
if (minnr == 1 && maxnr == 1) {
if ((maxv - minv == 4) || (m[10] && m[11] && m[12] && m[13] && m[1]))
return STRAIGHT;
}
if (maxnr == 3)
return THREE_CARD;
if (maxnr == 2) {
if (maxnr_count == 2)
return TWO_PAIR;
else
return ONE_PAIR;
}
return NULL_HAND;
}
void phand(map<int, int> m)
{
vector<string> hand_name = {
"four card",
"full house",
"straight",
"three card",
"two pair",
"one pair",
"null",
};
cout << hand_name[check(m)] << endl;
}
int main(int argc, char **argv)
{
vi v;
map<int, int> m;
char c;
int x, minval;
for (;;) {
v.clear();
m.clear();
rep (i, 4) {
cin >> x;
cin >> c;
v.pb(x);
}
cin >> x;
v.pb(x);
if (cin.eof())
break;
rep (i, 5) {
m[v[i]]++;
}
phand(m);
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int a[6] = {};
while(scanf("%d",&a[0])!=EOF){
for(int i=1;i<5;i++)scanf(",%d", &a[i]);
int cnt=0,flag=true,card[13]={},max = 4;
sort(a,a+5);
for (int i=0;i<4;i++)for(int j=i+1;j<5;j++)
if (a[i]==a[j])cnt++;
int i=0;
if(a[i]==1&&a[i+1]==10){
i=1;
max=5;
a[5]=14;
}
for(;i<max;i++)if(a[i]+1!=a[i+1])flag=0;
if (cnt == 6)printf("four card\n");
else if (cnt == 4)printf("full house\n");
else if (flag)printf("straight\n");
else if (cnt == 3)printf("three card\n");
else if (cnt == 2)printf("two pair\n");
else if (cnt == 1)printf("one pair\n");
else printf("null\n");
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
if(s[0]=='S' && s[2]=='N')
cout<<7-0;
else if(s[2]=='T')
cout<<7-6;
else if(s[0]=='F')
cout<<7-5;
else if(s[2]=='U')
cout<<7-4;
else if(s[0]=='W')
cout<<7-3;
else if(s[2]=='E')
cout<<7-2;
else if(s[0]=='M')
cout<<7-1;
return 0;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template<typename T> bool chmax(T &a,T b){if(a<b){a=b;return true;}return false;}
template<typename T> bool chmin(T &a,T b){if(a>b){a=b;return true;}return false;}
#define itn int
#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 rrep(i,n) for(int i=(int)(n)-1;i>=0;i--)
#define rrep1(i,n) for(int i=(int)(n);i>=1;i--)
#define all(vec) vec.begin(),vec.end()
#define sort(vec) sort((vec).begin(),(vec).end())
#define rsort(vec) sort((vec).rbegin(), (vec).rend())
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> pll;
typedef pair<int,int> pii;
typedef tuple<ll,ll,ll> tlll;
typedef tuple<int,int,int> tiii;
const ll mod=1e9+7;
const int inf=1<<30;
const ll lnf=1ll<<60;
int main(){
ll k; cin >> k;
ll n=50;
vector<ll> ans(50);
rep(i,50) ans[i]=i+k/n;
for(int i=n-k%n;i<n;i++) ans[i]++;
cout << n << endl;
rep(i,n) cout << ans[i] << " ";
cout << endl;
} | 0 |
//ヘッダー
#include<bits/stdc++.h>
using namespace std;
//型定義
typedef long long ll;
//定数
const int INF=1e+9;
const int MOD=1e+9+7;
//REPマクロ
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define REP2(i,a,b) for(ll i=a;i<(ll)(b);i++)
#define REPD2(i,a,b) for(ll i=a;i>(ll)(b);i--)
// 多次元 vector 生成
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...));
}
//vectorの扱い
#define ALL(x) (x).begin(),(x).end() //sortなどの引数省略
#define SIZE(x) ((ll)(x).size()) //size
#define MAX(x) *max_element(ALL(x)) //最大値
#define MIN(x) *min_element(ALL(x)) //最小値
int main(){
ll N;
cin>>N;
vector<ll> a(N),b(N),c(N),d(N);
REP(i,N){
cin>>a[i]>>b[i];
}
REP(i,N){
cin>>c[i]>>d[i];
}
vector<vector<bool>> p(110,vector<bool>(110,false));
ll cnt=0;
REP(i,N){
REP(j,N){
if(a[i]<c[j]&&b[i]<d[j]){
p[i][j]=true;
cnt++;
}
}
}
ll lose=INF;
ll ans=0;
while(lose>0){
ll lose_m=INF;
ll idx=-1,jdx=-1;
REP(i,N){
REP(j,N){
if(p[i][j]==false) continue;
lose=0;
REP(k,N){
if(p[i][k]==true) lose++;
if(p[k][j]==true) lose++;
}
lose--;
if(lose<lose_m){
lose_m=lose;
idx=i;
jdx=j;
}
}
}
if(idx==-1||jdx==-1) break;
REP(k,N){
p[idx][k]=false;
p[k][jdx]=false;
}
cnt-=lose_m;
ans++;
}
cout<<ans<<endl;
} | #include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#include <limits.h>
using namespace std;
typedef long long ll;
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
int main(void) {
int N;
cin >> N;
vector<pair<int, int>> reds(N);
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
reds[i] = {a, b};
}
// descending order by y
sort(reds.begin(), reds.end(), [](const pair<int, int> a, const pair<int, int> b) {
return a.second > b.second;
});
vector<pair<int, int>> blues(N);
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
blues[i] = {a, b};
}
sort(blues.begin(), blues.end());
int cnt = 0;
vector<bool> used_red(N, false);
for (int bi = 0; bi < N; bi++) {
for (int ri = 0; ri < N; ri++) {
if (used_red[ri]) {
continue;
}
auto blue = blues[bi];
auto red = reds[ri];
if (red.first < blue.first && red.second < blue.second) {
cnt++;
used_red[ri] = true;
break;
}
}
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
string S;
cin >> N >> S;
vector<int> W(N,0);
for(int i=0;i<N;i++){
if(i==0 && S.at(i)=='W') W.at(i) = 1;
else if(i==0 && S.at(i)=='E') W.at(i) = 0;
else if(S.at(i)=='W') W.at(i) = W.at(i-1) +1;
else W.at(i) = W.at(i-1);
}
int p_min = 0;
for(int i=0;i<N;i++){
if(i==0) p_min = N - 1 - W.at(N-1) + W.at(i);
else if(p_min > W.at(i-1) + ( N - (i+1) ) - ( W.at(N-1) - W.at(i) ) ){
p_min = W.at(i-1) + ( N - (i+1) ) - ( W.at(N-1) - W.at(i) );
}
}
cout << p_min << endl;
} | #include <bits/stdc++.h>
#include <math.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i,n) for (int i = 0; i < n; i++)
#define rrep(i,n) for (int i = n-1; i >= 0; i--)
#define MOD (1000000007)
#define vi vector<int>
#define vl vector<ll>
#define vb vector<bool>
#define vvi vector<vi>
#define vvl vector<vl>
#define pii pair<int, int>
#define pli pair<ll, int>
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(),(a).end()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
ll gcd(ll a, ll b) {
if (b == 0) return a;
else return gcd(b, a % b);
}
ll keta(ll n){
string s = to_string(n);
ll num = s.size();
return num;
}
const ll INF = 1LL << 60;
const int dh[4] = {1,0,-1,0};
const int dw[4] = {0,1,0,-1};
struct Edge{
int to;
int weight;
Edge(int t, int w) : to(t), weight(w){}
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, int>;
int main(){
int n,k; cin >> n >> k;
cout << n-k+1 << endl;
}
| 0 |
// https://atcoder.jp/contests/abc152/tasks/abc152_c
#include <bits/stdc++.h>
using namespace std;
int main()
{
long a, b;
cin >> a >> b;
long ans = 0;
for (int x = a; x <= b; x++)
{
string s, t;
s = to_string(x);
t = s;
reverse(t.begin(), t.end());
if (s == t)
{
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b;
int c;
int sum = 0;
cin >> a >> b;
c = a;
for (int i= 0; i < b-a+1; i++)
{
if (c/10000 == c-(c/10)*10 && c/1000 - (c/10000)*10 == c/10 - (c/100)*10 )
{
sum += 1;
c++;
continue;
}
else
{
c++;
continue;
}
}
cout << sum << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> FordFulkerson_dfs_sub(
const vector<map<int, int>>& graph, // source, (target, capacity)
int source, int target, set<int>& prev)
{
if(source==target) return vector<int>{source};
for(auto v : graph.at(source)){
if(v.second == 0) continue;
if(prev.count(v.first) > 0) continue;
prev.insert(source);
auto ret = FordFulkerson_dfs_sub(graph, v.first, target, prev);
if(ret.size() != 0){
ret.push_back(source);
return ret;
}
}
return vector<int>();
}
vector<int> FordFulkerson_dfs(
const vector<map<int, int>>& graph, // source, (target, capacity)
int source, int target)
{
auto s = set<int>();
auto ret = FordFulkerson_dfs_sub(graph, source, target, s);
reverse(ret.begin(), ret.end());
return ret;
}
// Graph: Directed, no loop
// Complexity: E * (max flow)
vector<map<int, int>> FordFulkerson(
vector<map<int, int>> graph, // source, (target, capacity)
int s, int t)
{
const int N = graph.size();
auto res = graph;
// Add inverted edges
for(int i=0; i<N; i++){
for(auto e : res[i]){
auto v = e.first;
graph[v][i] = -0;
}
}
while(true){
auto path = FordFulkerson_dfs(graph, s, t);
if(path.size()==0) break;
int c_min = numeric_limits<int>::max();
for(int i=0; i<path.size()-1; i++){
auto u = path[i];
auto v = path[i+1];
c_min = min(c_min, graph[u][v]);
}
if(c_min == 0) break;
for(int i=0; i<path.size()-1; i++){
auto u = path[i];
auto v = path[i+1];
graph[u][v] -= c_min;
graph[v][u] += c_min;
}
}
for(int i=0; i<res.size(); i++){
for(auto v : res[i]){
res[i][v.first] = graph[v.first][i];
}
}
return res;
}
vector<array<int, 2>> MaximumMatching(
vector<vector<int>> graph // source, target
){
const int N = graph.size();
vector<map<int, int>> graph2(2 + 2 * N);
for(int i=0;i<N;i++){
graph2[2*N][i] = 1;
graph2[N+i][2*N+1] = 1;
for(auto v : graph[i]){
graph2[i][v + N] = 1;
}
}
auto ret = FordFulkerson(graph2, 2*N, 2*N+1);
vector<array<int, 2>> res;
for(int i=0;i<N;i++){
for(auto m : ret[i]){
if(m.second == 0) continue;
res.push_back(array<int, 2>{i, m.first});
}
}
return res;
}
int main()
{
int N;
cin >> N;
vector<int> A(N);
vector<int> B(N);
vector<int> C(N);
vector<int> D(N);
for(int i=0;i<N;i++) cin >> A[i] >> B[i];
for(int i=0;i<N;i++) cin >> C[i] >> D[i];
vector<vector<int>> graph(N);
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
if(A[i] < C[j] && B[i] < D[j]){
graph[i].push_back(j);
}
}
}
auto ret = MaximumMatching(graph);
cout << ret.size() << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<vector<int>> ab(N, vector<int>(2));
for (int i = 0; i < N; i++) {
cin >> ab.at(i).at(1) >> ab.at(i).at(0);
}
vector<vector<int>> cd(N, vector<int>(2));
for (int i = 0; i < N; i++) {
cin >> cd.at(i).at(0) >> cd.at(i).at(1);
}
sort(ab.begin(), ab.end());
reverse(ab.begin(), ab.end());
sort(cd.begin(), cd.end());
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (cd.at(i).at(1) > ab.at(j).at(0) && cd.at(i).at(0) > ab.at(j).at(1)) {
ans++;
ab.at(j).at(0) = 200;
ab.at(j).at(1) = 200;
break;
}
}
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
if(A+B<=16 && A<=8 && B<=8) cout << "Yay!" << endl;
else cout << ":(" << endl;
} | #include <bits/stdc++.h>
#define ll long long
#define vi vector<int>
#define e "\n"
#define MaRiaMa { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }
#define fix(n) cout << fixed << setprecision(n);
using namespace std;
int main()
{
MaRiaMa;
int a, b,sum=16;
cin >> a >> b;
int s = max(a, b) - min(a, b);
if (s == 0)
cout << "Yay!";
else
{
sum -= (2*min(a,b));
if ((s += s) <= sum)
cout << "Yay!";
else
cout << ":(";
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, cnt = 0;
cin >> N;
vector<long long> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
if (vec[i] % 2 != 0) {
cout << cnt << endl;
return 0;
}
}
while (true) {
for (int i = 0; i < N; i++) {
if (vec[i] % 2 != 0) {
cout << cnt << endl;
return 0;
} else {
vec[i] /= 2;
}
}
cnt++;
}
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
int kai(int a) {
int n = 0;
while (1) {
if (a % 2 == 0) {
a = a / 2;
n++;
}
else break;
}
return n;
}
int main() {
int N;
cin >> N;
vector<int> A(N);
int count = 100000;
for (int i = 0; i < N; i++) {
cin >> A[i];
count = min(kai(A[i]), count);
}
cout << count << endl;
return 0;
} | 1 |
#include <iostream>
#include <vector>
using namespace std;
void fnInput(vector<int> &a_rviTarget, vector<int> &a_rviSearch)
{
int iTargetCnt;
cin >> iTargetCnt;
a_rviTarget.resize(iTargetCnt + 1);
for (int i = 0; i < iTargetCnt; i++)
cin >> a_rviTarget[i];
int iSearchCnt;
cin >> iSearchCnt;
a_rviSearch.resize(iSearchCnt);
for (int i = 0; i < iSearchCnt; i++)
cin >> a_rviSearch[i];
}
void fnLinearSearch(vector<int> &a_rviTarget, const vector<int> &a_cnrviSearch, int &a_riFound)
{
size_t zMaxSize = a_rviTarget.size() - 1;
for (size_t zi = 0; zi < a_cnrviSearch.size(); zi++)
{
a_rviTarget[zMaxSize] = a_cnrviSearch[zi];
size_t zj = 0;
while (a_rviTarget[zj] != a_cnrviSearch[zi])
zj++;
if (zj != zMaxSize)
a_riFound++;
}
}
void fnResultOut(int a_iFound)
{
cout << a_iFound << endl;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> viTarget, viSearch;
int iFound = 0;
fnInput(viTarget, viSearch);
fnLinearSearch(viTarget, viSearch, iFound);
fnResultOut(iFound);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define repp(i,m,n) for(int (i)=(m);(i)<(n);(i)++)
#define repm(i,n) for(int (i)=(n-1);(i)>=0;(i)--)
#define INF (1ll<<60)
#define all(x) (x).begin(),(x).end()
typedef long long lint;
const lint MOD =1000000007;
const lint MAX = 1000000;
using Graph =vector<vector<lint>>;
typedef pair<lint,lint> P;
lint fac[MAX], finv[MAX], inv[MAX];
void COMinit()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (lint i = 2; i < MAX; i++)
{
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(lint n, lint k)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint primary(lint num)
{
if (num < 2) return 0;
else if (num == 2) return 1;
else if (num % 2 == 0) return 0;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
{
return 0;
}
}
return 1;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
lint lcm(lint a,lint b){
return a/__gcd(a,b)*b;
}
lint gcd(lint a,lint b){
return __gcd(a,b);
}
int main(){
lint n;
cin>>n;
tuple<lint,lint,lint> a[n];
tuple<lint,lint,lint>b[n];
rep(i,n){
lint a1,b1;
cin>>a1>>b1;
a[i]=make_tuple(b1+a1,a1,i);
b[i]=make_tuple(a1+b1,b1,i);
}
bool iseat[n];
fill(iseat,iseat+n,false);
sort(a,a+n,greater<tuple<lint,lint,lint>>());
sort(b,b+n,greater<tuple<lint,lint,lint>>());
lint ans=0;
lint i=0,j=0,k=0;
while(1){
lint s1,v1,c1;
tie(s1,v1,c1)=a[i];
while(iseat[c1]){
i++;
tie(s1,v1,c1)=a[i];
}
iseat[c1]=true;
ans+=v1;
k++;
if(k==n)break;
tie(s1,v1,c1)=b[j];
while(iseat[c1]){
j++;
tie(s1,v1,c1)=b[j];
}
iseat[c1]=true;
ans-=v1;
k++;
if(k==n)break;
i++;j++;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
using ll = long long;
typedef pair<int, int> P;
ll Mod = 1000000007;
int main() {
int N,Q;
cin >> N >> Q;
ll S[N],T[N],X[N];
vector<ll> vect;
vect.push_back(-Mod * 1000LL);
vect.push_back(Mod * 1000LL);
for (int i = 0; i < N; i++) {
cin >> S[i] >> T[i] >> X[i];
vect.push_back(S[i]-X[i]);
vect.push_back(T[i]-X[i]);
}
sort(vect.begin(),vect.end());
vector<ll> vec;
for (int i = 1; i < (int)vect.size(); i++) {
if (vect[i-1] != vect[i]) {
vec.push_back(vect[i-1]);
}
}
vec.push_back(Mod * 1000LL);
int sz = vec.size();
vector<ll> ans(sz);
vector<ll> L[sz];
vector<ll> R[sz];
for (int i = 0; i < N; i++) {
int l = lower_bound(vec.begin(),vec.end(),S[i]-X[i]) - vec.begin();
int r = lower_bound(vec.begin(),vec.end(),T[i]-X[i]) - vec.begin();
L[l].push_back(i);
R[r].push_back(i);
}
multiset<ll> Set;
for (int i = 0; i < sz; i++) {
for (int j = 0; j < (int)L[i].size(); j++) {
Set.insert(X[L[i][j]]);
}
for (int j = 0; j < (int)R[i].size(); j++) {
auto itr = Set.lower_bound(X[R[i][j]]);
Set.erase(itr);
}
if (Set.empty()) {
ans[i] = -1;
} else {
auto itr = Set.begin();
ans[i] = *itr;
}
}
for (int i = 0; i < Q; i++) {
ll D;
cin >> D;
int w = lower_bound(vec.begin(),vec.end(),D) - vec.begin();
if (vec[w] != D) {
w--;
}
cout << ans[w] << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
const int V_MAX = 100000;
struct LowLink
{
const vector<vector<int>> &g;
int V;
vector<vector<int>> dfs_tree;
vector<int> dfs_roots;
int pre_order[V_MAX];
int p_ord = 0;
int lowlink[V_MAX];
bool articulation[V_MAX] = {};
vector<pair<int, int>> bridge;
LowLink(const vector<vector<int>> &g) : g(g), V(g.size()), dfs_tree(g.size()) {}
void dfs(int v, int parent) {
lowlink[v] = pre_order[v] = p_ord;
p_ord++;
for (int nv : g[v]) {
if (nv == parent) continue;
if (pre_order[nv] == -1) {
dfs_tree[v].push_back(nv);
dfs(nv, v);
lowlink[v] = min(lowlink[v], lowlink[nv]);
}
lowlink[v] = min(lowlink[v], pre_order[nv]);
}
}
void calc() {
p_ord = 0;
fill(pre_order, pre_order+V_MAX, -1);
for (int i = 0; i < V; i++) {
if (pre_order[i] != -1) continue;
dfs_roots.push_back(i);
dfs(i, -1);
}
for (int i = 0; i < V; i++) {
for (int j : dfs_tree[i]) {
if (pre_order[i] < lowlink[j]) bridge.push_back({i, j});
}
}
for (int i = 0, x = 0; i < V; i++) {
bool ok = false;
if (x < dfs_roots.size() && dfs_roots[x] == i) {
if (dfs_tree[i].size() > 1) ok = true;
x++;
} else {
for (int j : dfs_tree[i]) {
if (pre_order[i] <= lowlink[j]) ok = true;
}
}
articulation[i] = ok;
}
}
};
int main() {
int V, E;
cin >> V >> E;
vector<vector<int>> g(V);
for (int i = 0; i < E; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
LowLink L(g);
L.calc();
for (int i = 0; i < V; i++) {
if (L.articulation[i]) cout << i << endl;
}
return 0;
}
| 0 |
#include<iostream>
#include<iomanip>
#include<stack>
#include<queue>
#include<list>
#include<vector>
#include<set>
#include<map>
#include<string>
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<ctime>
#define ll long long
#define db double
#define inf 301
#define INF (int)1e8
#define mod (int)(1e9+7)
#define pi acos(-1)
#define rd(n) {n=0;char ch;int f=0;do{ch=getchar();if(ch=='-'){f=1;}}while(ch<'0'||ch>'9');while('0'<=ch&&ch<='9'){n=(n<<1)+(n<<3)+ch-48;ch=getchar();}if(f)n=-n;}
using namespace std;
const int lim=18;
ll P10[20],cnt[20];
void pre_work(void){
P10[0]=1LL;
for (int i=1;i<=lim;i++){
P10[i]=P10[i-1]*10LL;
}
for (int i=0;i<=9;i++){
for (int j=0;j<=9;j++){
cnt[i-j+10]++;
}
}
return;
}
ll D,ans=0;
void dfs(int step,ll x,ll sum,int len){
if (step>len/2-1){
if (len&1){
sum*=10LL;
}
if (x==D){
ans+=sum;
}
return;
}
ll now=-9;
while (now<=9 && x+now*(P10[len-step-1]-P10[step])<=D){
now++;
}
now--;
dfs(step+1,x+now*(P10[len-step-1]-P10[step]),sum*(cnt[now+10]-(step==0 && now>=0)),len);
now++;
if (now>9){
return;
}
dfs(step+1,x+now*(P10[len-step-1]-P10[step]),sum*(cnt[now+10]-(step==0 && now>=0)),len);
return;
}
int main(){
rd(D)
pre_work();
for (int i=1;i<=18;i++){
dfs(0,0LL,1LL,i);
}
printf("%lld\n",ans);
return 0;
}
| #include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cassert>
using namespace std;
typedef long long LL;
template <typename F, typename S> std::ostream& operator<<(ostream& os, const pair<F,S>& p) {
os << "(" << p.first << "," << p.second << ")"; return os; }
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) {
os << "["; for(const T& a: v){ os << a << ", "; } os << "]"; return os; }
template <typename K, typename V> ostream& operator<<(ostream& os, const map<K,V>& m) {
os << "{"; for(const auto& p: m){ os << p.first <<":"<< p.second << ", "; } os << "}"; return os; }
LL solve(vector<LL>& a){
LL res = 0;
for(LL d = 60; d >= 0; --d){
LL cur = -1;
for(LL i = 0; i < a.size(); ++i){
if(a[i] & (1LL<<d)) cur = i;
}
if(cur < 0) continue;
if((res & (1LL<<d)) == 0){
res ^= a[cur];
}
for(LL i = 0; i < a.size(); ++i){
if(a[i] & (1LL<<d)) a[i] ^= a[cur];
}
}
return res;
}
int main(){
LL n;
cin >> n;
vector<LL> a(n);
for(LL i = 0; i < n; ++i){
cin >> a[i];
}
vector<LL> cnt(61);
for(LL i = 0; i < n; ++i){
for(LL j = 0; j < 61; ++j){
if((a[i]>>j)&1) cnt[j] += 1;
}
}
LL ans = 0;
LL mask = 0;
for(LL j = 0; j < 61; ++j){
if(cnt[j] % 2 == 1){
ans += (1LL << j);
}else{
mask |= (1LL << j);
}
}
for(LL i = 0; i < n; ++i){
a[i] = (a[i] & mask);
}
ans += solve(a) * 2;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define clr(x) memset(x,0,sizeof (x))
#define For(i,a,b) for (int i=(a);i<=(b);i++)
#define Fod(i,b,a) for (int i=(b);i>=(a);i--)
#define fi first
#define se second
#define kill _z_kill
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define outval(x) cerr<<#x" = "<<x<<endl
#define outv(x) cerr<<#x" = "<<x<<" "
#define outtag(x) cerr<<"--------------"#x"---------------"<<endl
#define outarr(a,L,R) cerr<<#a"["<<L<<".."<<R<<"] = ";\
For(_x,L,R) cerr<<a[_x]<<" ";cerr<<endl;
#define User_Time ((double)clock()/CLOCKS_PER_SEC)
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned uint;
typedef long double LD;
typedef vector <int> vi;
typedef pair <int,int> pii;
LL read(){
LL x=0,f=0;
char ch=getchar();
while (!isdigit(ch))
f=ch=='-',ch=getchar();
while (isdigit(ch))
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return f?-x:x;
}
//int Pow(int x,int y){
// int ans=1;
// for (;y;y>>=1,x=(LL)x*x%mod)
// if (y&1)
// ans=(LL)ans*x%mod;
// return ans;
//}
//void Add(int &x,int y){
// if ((x+=y)>=mod)
// x-=mod;
//}
//void Del(int &x,int y){
// if ((x-=y)<0)
// x+=mod;
//}
//int Add(int x){
// return x>=mod?x-mod:x;
//}
//int Del(int x){
// return x<0?x+mod:x;
//}
//void ckmax(int &x,int y){
// if (x<y)
// x=y;
//}
//void ckmin(int &x,int y){
// if (x>y)
// x=y;
//}
int main(){
string s;
cin>>s;
if (s.size()&1)
return puts("No"),0;
For(i,0,(int)s.size()-1)
if ("hi"[i%2]!=s[i])
return puts("No"),0;
puts("Yes");
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);i++)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using namespace std;
template <typename T>
using vec = std::vector<T>;
int main() {
string S;
cin >> S;
if(S=="hi"||S=="hihi"||S=="hihihi"||S=="hihihihi"||S=="hihihihihi"){
cout << "Yes" << endl;
} else{
cout << "No" << endl;
}
} | 1 |
#include <iostream>
#include <string>
using namespace std;
int main(){
string s;
while(getline(cin,s)||!cin.eof()){
for(int i=0;i<25;i++){
if(s.find("the")!=-1||s.find("this")!=-1||s.find("that")!=-1)break;
else for(int j=0;j<s.size();j++)if(s[j]>='a'&&s[j]<='z')s[j]!='z'?s[j]++:s[j]='a';
}
cout<<s<<endl;
}
} | #include<stdio.h>
#include<string.h>
int main(){
char s[85];
int i;
memset(s,'0',sizeof(s));
while(fgets(s,83,stdin)){
while(1){
for(i=0;i<81;i++){
switch(s[i]){
case '.':
case ' ':
case '0':
case '\0':
case 10:
case 13:
continue;
}
s[i]='a'+(s[i]-'a'+1)%26;
}
if((NULL!=strstr(s,"the")) || (NULL!=strstr(s,"this")) || (NULL!=strstr(s,"that"))){
printf("%s",s);
memset(s,'0',sizeof(s));
break;
}
}
}
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <tuple>
#include <vector>
#include <string>
#include <queue>
#include <cmath>
#include <set>
#include <map>
#include <cassert>
using namespace std;
using ll = long long;
int main()
{
int n;
cin >> n;
vector<int> a(n+1);
for(int i = 1; i < n+1; i++){
cin >> a[i];
}
vector<int> b(n+1);
for(int i = n; i >= 1; i--){
int sum = 0;
for(int j = i+i; j <= n; j += i){
sum ^= b[j];
}
b[i] = sum^a[i];
}
vector<int> ans;
for(int i = 1; i <= n; i++){
if(b[i]) ans.push_back(i);
}
cout << ans.size() << endl;
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
cout << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M{};
cin >> N;
vector<int> a(N+1), b(N+1);
for (int i = 1; i <= N; ++i) {
cin >> a[i];
}
for (int i = N; i; --i) {
int s{};
for (int j = 2*i; j <=N; j += i) s += b[j];
if (a[i] != s%2) {
b[i] = 1;
++M;
}
}
cout << M << endl;
if (!M) return 0;
for (int i = 1; i <= N; i++) {
if (!b[i]) continue;
cout << (M?"":" ") << i;
M = 0;
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define P pair<ll, ll>
#define Graph vector<vector<ll>>
#define fi first
#define se second
constexpr ll mod = 1000000007;
constexpr ll INF = (1ll << 60);
constexpr double pi = 3.14159265358979323846;
template <typename T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll n, k;
cin >> n >> k;
cout << n - k + 1 << "\n";
return 0;
} | #include<bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
typedef long long ll;
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define REP(i,num,n) for(int i=num, i##_len=(n); i<i##_len; ++i)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define print(x) (cout << (x) << endl)
#define pb push_back
#define mp make_pair
#define sz(x) int(x.size())
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class itr> void cins(itr first, itr last){ for(auto i = first; i != last; i++){ cin >> (*i); } }
template<class itr> void array_output(itr start, itr goal){ string ans; for(auto i = start; i != goal; i++) ans += to_string(*i) + " "; if(!ans.empty()) ans.pop_back(); cout << ans << endl; }
#define fs first
#define sc second
const int INF = 1e9;
const ll LLINF = 1e16;
const ll MOD = 1e9+7;
template<class T> inline void add(T &a, T b){a = ((a+b) % MOD + MOD) % MOD;};
template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}
template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}
// 指定した文字cが文字列に何文字入ってるか
ll stringcount(string s, char c) {
return count(s.cbegin(), s.cend(), c);
}
// 割り算の切り上げ処理
template<typename T>
T rp(T a, T b) {
return (a + b - 1) / b;
}
// 桁和
template<typename T>
T digsum(T n) {
T res = 0;
while(n > 0) {
res += n%10;
n /= 10;
}
return res;
}
// 回文判定
bool kai (string s) {
string t{s};
reverse(begin(t), end(t));
return s == t;
}
using pint = pair<int, int>;
using pll = pair<ll, ll>;
int main(void)
{
cout.tie(0);
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n,k;
cin >> n >> k;
print(n - k + 1);
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int maxn=2005;
int T,n,m,a[maxn<<1][maxn<<1],now;
int b[maxn<<1][maxn<<1],c[maxn<<1][maxn<<1],d[maxn<<1][maxn<<1];
bool vis[maxn][maxn];
inline int read(){
int res=0,f_f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-') f_f=-1;ch=getchar();}
while(ch>='0'&&ch<='9') res=(res<<3)+(res<<1)-'0'+ch,ch=getchar();
return res*f_f;
}
inline bool check(int ux,int uy,int fx,int fy){
if(ux==fx&&uy==fy) return false;
if(ux<1||ux>n||uy<1||uy>m) return false;
if(vis[ux][uy]||a[ux][uy]==0) return false;
return true;
}
inline void dfs(int ux,int uy,int fx,int fy){
vis[ux][uy]=true;
if(fx&&fy) b[ux+fx][uy+fy]=1;
if(check(ux+1,uy,fx,fy)) dfs(ux+1,uy,ux,uy);
if(check(ux-1,uy,fx,fy)) dfs(ux-1,uy,ux,uy);
if(check(ux,uy+1,fx,fy)) dfs(ux,uy+1,ux,uy);
if(check(ux,uy-1,fx,fy)) dfs(ux,uy-1,ux,uy);
}
int main(){
n=read(),m=read(),T=read();
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++){
char ch=getchar();
while(ch!='0'&&ch!='1') ch=getchar();
a[i][j]=ch-'0';
}
}
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++){
if(a[i][j]==1){
if(!vis[i][j]) dfs(i,j,0,0);
c[i<<1][j<<1]=1;
}
}
}
for (int i=1;i<=(n<<1);i++){
for (int j=1;j<=(m<<1);j++){
b[i][j]+=b[i][j-1];
c[i][j]+=c[i][j-1];
}
}
for (int i=1;i<=(n<<1);i++){
for (int j=1;j<=(m<<1);j++){
b[i][j]+=b[i-1][j];
c[i][j]+=c[i-1][j];
}
}
while(T--){
int fx=read(),fy=read(),tx=read(),ty=read(),ans=0;
ans+=c[tx<<1][ty<<1]-c[tx<<1][(fy<<1)-1]-c[(fx<<1)-1][ty<<1]+c[(fx<<1)-1][(fy<<1)-1];
ans-=b[tx<<1][ty<<1]-b[tx<<1][(fy<<1)-1]-b[(fx<<1)-1][ty<<1]+b[(fx<<1)-1][(fy<<1)-1];
printf("%d\n",ans);
}
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
#include <utility>
#include <unordered_set>
#include <vector>
#include <list>
#include <string>
#include <iterator>
#include <deque>
#include <array>
#include <forward_list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <climits>
#include <bitset>
#include <numeric>
using namespace std;
const long double PI = 3.14159265358979323846264338327950;
const int N = 1e5+5;
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int ac[N], wa[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
int a, b;
string s;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> k >> s;
if (s[0] == 'W' && ac[k] == 0) {
wa[k]++;
} else {
ac[k]++;
}
}
a = b = 0;
for (int i = 0; i <= n; ++i) {
if (ac[i]) {
++a;
if (wa[i]) b += wa[i];
}
}
cout << a << ' ' << b << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(ll i=0;i<ll(n);i++)
int main() {
int n;
cin >> n;
int a;
ll ans = 0;
int m = 2e9;
int cnt = 0;
rep(i, n){
cin >> a;
if (a < 0) {
cnt++;
a *= -1;
}
m = min(m, a);
ans += a;
}
if (cnt%2 == 1) {
ans -= 2*m;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
#define repa(i,n) for (auto& i: n)
template<class T> inline bool chmax(T &a, const T &b) {if (a<b) { a=b; return 1;} return 0;}
template<class T> inline bool chmin(T &a, const T &b) {if (b<a) { a=b; return 1;} return 0;}
struct init{init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}}init_;
#ifdef DEBUG
template <class T, class N> void verr(const T& a, const N& n) { rep(i, n) cerr << a[i] << " "; cerr << "\n" << flush; }
ll dbgt = 1; void err() { cerr << "passed " << dbgt++ << "\n" << flush; }
template<class H, class... T> void err(H&& h,T&&... t){ cerr<< h << (sizeof...(t)?" ":"\n") << flush; if(sizeof...(t)>0) err(forward<T>(t)...); }
#endif
const ll INF = 4e18;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
//--------------------------------------------------------------------------------//
int main() {
ll N;
cin >> N;
vl A(N);
rep(i, N) cin >> A[i];
vvc<ll> dp(N + 1, vl(2, -INF));
dp[0][0] = 0;
rep(i, N){
dp[i + 1][0] = max(dp[i][0] + A[i], dp[i][1] - A[i]);
dp[i + 1][1] = max(dp[i][0] - A[i], dp[i][1] + A[i]);
}
cout << dp[N][0] << endl;
} | 1 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T> >;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;
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);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<P> lr(n);
rep(i, n) cin >> lr[i];
sort(all(lr));
int ans = 0;
vi mil(n+1, INT_MAX), mir(n+1, INT_MAX);
rep(i, n) {
mil[i+1] = min(mil[i], lr[i].second);
mir[n-1-i] = min(mir[n-i], lr[n-1-i].second);
}
int min = INT_MAX;
rep(i, n-1) {
chmin(min, lr[i].second);
if(min < lr[i].first) break;
chmax(ans, min-lr[i].first + mir[i+1]-lr[n-1].first + 2);
}
rep(i, n) {
chmax(ans, lr[i].second - lr[i].first + 1 + (mil[n] >= lr[n-1].first?mil[n]-lr[n-1].first+1:0));
}
cout << ans << endl;
} | #include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<pair<ll, ll>>> vvpll;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define exrep(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 100010;
int main() {
ll n;
cin >> n;
vl L(n), R(n);
ll p = 0, q = 0; // L[p]はLの最大値で、R[q]はRの最小値
ll MAXL = 0, MINR = INF;
rep(i, n) {
cin >> L[i] >> R[i];
R[i]++;
if(MAXL < L[i]) {
MAXL = L[i];
p = i;
}
if(MINR > R[i]) {
MINR = R[i];
q = i;
}
}
ll ans = 0;
// 区間pと区間qを同じ集合に入れる場合
rep(i, n) {
if(i == p || i == q) {
continue;
}
chmax(ans, max(0LL, R[q] - L[p]) + R[i] - L[i]);
}
// 区間pと区間qを違う集合に入れる場合
vector<pair<ll, ll>> c(n);
rep(i, n) {
ll a = max(0LL, R[i] - L[p]);
ll b = max(0LL, R[q] - L[i]);
c[i] = make_pair(a, -b);
}
sort(all(c));
ll u = abs(c[0].second);
exrep(i, 1, n-1) {
chmax(ans, c[i].first + u);
chmin(u, abs(c[i].second));
}
out(ans);
re0;
} | 1 |
#include <iostream>
#include <functional>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <queue>
#include <map>
#include <iomanip>
#include <complex>
#include <random>
#include <bitset>
#include <list>
// #include <prettyprint.hpp>
using namespace std;
#define repi(i,n) for(int i=0;i<n;++i)
#define rep(i,n) for(ll i=0;i<n;++i)
#define repinvi(i,n) for(int i=n-1;i>=0;--i)
#define sll(n) scanf("%lld", &n);
#define sii(n) scanf("%d", &n);
#define slf(n) scanf("%lf", &n);
#define pll pair<ll,ll>
#define pii pair<int,int>
#define psi pair<si,si>
typedef long long ll;
typedef double lf;
typedef short int si;
void Main(){
ll N, x, y;
string u;
map<ll,map<string, set<ll>>> leftup_group;
map<ll,map<string, set<ll>>> rightup_group;
map<ll,map<string, set<ll>>> updown_group;
map<ll,map<string, set<ll>>> lr_group;
sll(N);
rep(i, N){
sll(x);
sll(y);
cin >> u;
leftup_group[x+y][u].insert(x);
rightup_group[x-y][u].insert(x);
if(u=="U" || u == "D"){
updown_group[x][u].insert(y);
}else if(u=="R" || u == "L"){
lr_group[y][u].insert(x);
}
}
// x + y -> u & r ^ u_x >= r_x , d & l ^ d_x <= l_x
// x - y -> u & l ^ u_x <= l_x , d & r ^ d_x >= r_x
ll min_v = 1e15;
for(auto& p:leftup_group){
auto each_g = p.second;
for(auto c:each_g["R"]){
auto iter = each_g["U"].upper_bound(c);
if(iter != each_g["U"].end()){
// cout << "x+y, R & U, R_x="<<c << " U_x="<<*iter<<endl;
ll v = *iter;
min_v = min((v-c)*10, min_v);
}
}
for(auto c:each_g["D"]){
auto iter = each_g["L"].upper_bound(c);
if(iter != each_g["L"].end()){
// cout << "x+y, L & D, L_x="<<c << " D_x="<<*iter<<endl;
ll v = *iter;
min_v = min((v-c)*10, min_v);
}
}
}
for(auto& p:rightup_group){
auto each_g = p.second;
for(auto c:each_g["U"]){
auto iter = each_g["L"].upper_bound(c);
if(iter != each_g["L"].end()){
// cout << "x-y, U & L, U_x="<<c << " L_x="<<*iter<<endl;
ll v = *iter;
min_v = min((v-c)*10, min_v);
}
}
for(auto c:each_g["R"]){
auto iter = each_g["D"].upper_bound(c);
if(iter != each_g["D"].end()){
// cout << "x+y, R & D, R_x="<<c << " D_x="<<*iter<<endl;
ll v = *iter;
min_v = min((v-c)*10, min_v);
}
}
}
for(auto& p:updown_group){
auto each_g = p.second;
for(auto c:each_g["U"]){
auto iter = each_g["D"].upper_bound(c);
if(iter != each_g["D"].end()){
ll v = *iter;
min_v = min((v-c)*5, min_v);
}
}
}
for(auto& p:lr_group){
auto each_g = p.second;
for(auto c:each_g["R"]){
auto iter = each_g["L"].upper_bound(c);
if(iter != each_g["L"].end()){
ll v = *iter;
min_v = min((v-c)*5, min_v);
}
}
}
if(min_v == 1e15){
cout << "SAFE" <<endl;
}else{
cout << min_v <<endl;
}
}
int main(){
Main();
// string S = "ksdfjl";
// char v = S[3];
// S[3] = 'a';
// cout << S <<endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) {for(auto i: x){cout << i << " ";} cout << endl;}
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1e8;
int cal(vector<P> A) {
sort(A.begin(), A.end());
int res = INF;
for (int i = 1; i < sz(A); i++) {
if (A[i-1].second == 0 && A[i].second != 0) {
res = min(res, A[i].first - A[i-1].first);
}
}
return res;
}
int F(map<int, vector<P>>& mp) {
int res = INF;
for (auto p : mp) {
res = min(res, cal(p.second));
}
return res;
}
int main() {
int N;
cin >> N;
vector<int> X(N), Y(N), dir(N);
// URDL → 0123
rep(i, N) {
char c;
cin >> X[i] >> Y[i] >> c;
if (c == 'U') dir[i] = 0;
if (c == 'R') dir[i] = 1;
if (c == 'D') dir[i] = 2;
if (c == 'L') dir[i] = 3;
}
int ans = INF;
rep(_, 4) {
{ // UD
map<int, vector<P>> mp;
rep(i, N) {
if (dir[i] != 0 && dir[i] != 2) continue;
mp[X[i]].emplace_back(Y[i], dir[i]);
}
ans = min(ans, F(mp));
}
{ // UR
map<int, vector<P>> mp;
rep(i, N) {
if (dir[i] != 0 && dir[i] != 1) continue;
mp[X[i]+Y[i]].emplace_back(Y[i], dir[i]);
}
ans = min(ans, F(mp) * 2);
}
{
// rotate clockwise
rep(i, N) {
int px = X[i], py = Y[i];
X[i] = py;
Y[i] = -px;
dir[i] = (dir[i]+1)%4;
}
}
}
if (ans < INF) cout << ans * 5 << '\n';
else puts("SAFE");
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int n, s, x, p;
deque<pair<int, long long> > d;
long long amx(int a) {
if(s >= d.back().first) {
return s - d.front().first;
} else if(s <= d.front().first) {
return d.back().first - s;
}
int na;
long long D = d.back().first - d.front().first;
if(d.front().second >= d.back().second) {
pair<int, long long> t = d.front();
t.second += d.back().second;
d.pop_back();
d.pop_front();
d.push_front(t);
na = 0;
} else {
pair<int, long long> t = d.back();
t.second += d.front().second;
d.pop_front();
d.pop_back();
d.push_back(t);
na = 1;
}
return amx(na) + (long long)(a != na) * D;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
for(int i = 1; i <= n; ++i) {
cin >> x >> p;
d.push_back({x, p});
}
cout << amx(2) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define Int int64_t
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> a(N, vector<int>(M));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
cin >> a[i][j]; --a[i][j];
}
}
int ans = -1;
for (int n = 1; n <= N; ++n) {
vector<bool> sports(M, true);
vector<int> join(N, 0);
while (true) {
bool ok = true;
vector<int> cnt(M, 0);
for (int i = 0; i < N; ++i) {
while (join[i] <= M) {
if (join[i] == M) {
ok = false;
break;
}
if (sports[ a[i][join[i]] ]) {
++cnt[ a[i][join[i]] ];
break;
}
++join[i];
}
}
if (!ok) { break; }
for (int i = 0; i < M; ++i) {
if (cnt[i] > n) {
ok = false;
sports[i] = false;
}
}
if (ok) {
ans = n;
break;
}
}
if (ans > 0) { break; }
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main()
{
long long int s=0,r1,r2;
cin>>r1>>r2;
if(r1==1)
s+=300000;
if(r1==2)
s+=200000;
if(r1==3)
s+=100000;
if(r2==1)
s+=300000;
if(r2==2)
s+=200000;
if(r2==3)
s+=100000;
if(r1==1 &&r2==1)
s+=400000;
cout<<s;
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <stack>
#include <set>
#include <queue>
#include <iomanip>
using namespace std;
long long mod = 1000000007;
long long pow(long long x, long long k)
{
if (k == 0)
{
return 1LL;
}
long long temp = pow(x, k / 2);
if (k % 2 == 1)
{
return (((temp * temp) % mod) * x) % mod;
}
else
{
return (temp * temp) % mod;
}
}
long long modular_inverse(long long x)
{
return pow(x, mod - 2);
}
long long binomial(long long n, long long k)
{
long long rez = 1;
for (int i = n - k + 1; i <= n; i++)
{
rez *= i;
rez %= mod;
}
long long temp = 1;
for (int i = 1; i <= k; i++)
{
temp *= i;
temp %= mod;
}
rez *= modular_inverse(temp);
rez %= mod;
return rez;
}
int score(int x)
{
return max(100000 * (4 - x), 0);
}
int main()
{
int x, y;
cin >> x >> y;
cout << score(x) + score(y) + ((x == y && x == 1) ? 400000 : 0);
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <unordered_set>
#include <unordered_map>
#include <numeric>
#include <ctime>
#include <bitset>
#include <complex>
#include <chrono>
#include <random>
#include <functional>
using namespace std;
typedef long long ll;
const int N = 401;
const vector<int> dx = {0, 0, 1, -1};
const vector<int> dy = {1, -1, 0, 0};
int used[N * N];
vector<int> g[N * N];
int n, m;
int a[N][N];
int get(int i, int j) {
return i * m + j;
}
int ok(int i, int j) {
return 0 <= i & i < n && 0 <= j && j < m;
}
void dfs(int cur, int &c0, int &c1) {
used[cur] = 1;
if (a[cur / m][cur % m] == 0) {
c0++;
} else {
c1++;
}
for (auto t : g[cur]) {
if (!used[t]) {
dfs(t, c0, c1);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
a[i][j] = (c == '#');
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int f = 0; f < 4; f++) {
int i1 = i + dx[f];
int j1 = j + dy[f];
if (ok(i1, j1) && a[i][j] != a[i1][j1]) {
g[get(i, j)].push_back(get(i1, j1));
}
}
}
}
ll ans = 0;
for (int i = 0; i < n * m; i++) {
if (!used[i]) {
int c0 = 0;
int c1 = 0;
dfs(i, c0, c1);
ans += c0 * c1;
}
}
cout << ans << '\n';
}
| #include <cstdio>
#include <cstring>
#include <algorithm>
#define rep(i, n) for(int i = 0; i < (n); ++i)
using namespace std;
int n, m;
char s[1001];
char t[1001];
int dp[1001][1001];
int main(){
scanf("%s%s", s, t);
n = strlen(s);
m = strlen(t);
rep(i, n + 1){
dp[i][0] = i;
}
rep(i, m + 1){
dp[0][i] = i;
}
for(int i = 1; i <= n; ++i){
for(int j = 1; j <= m ; ++j){
dp[i][j] = min(dp[i - 1][j - 1] + (s[i - 1] != t[j - 1]), min(dp[i][j - 1], dp[i - 1][j]) + 1);
}
}
printf("%d\n", dp[n][m]);
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
struct data_t {
string name;
double eff;
bool operator<(const data_t& right) const {
if (eff == right.eff) {
return (name < right.name);
}
else {
return (eff > right.eff);
}
}
};
int main(void) {
int N;
while (cin >> N, N) {
vector<data_t> data(N);
int p,temp,d,e,f,m,s;
for (int i = 0; i < N; ++i) {
cin >> data[i].name;
cin >> p;
int time = 0;
for (int i = 'A'; i <= 'C'; ++i) {
cin >> temp;
time += temp;
}
cin >> d >> e >> f >> s >> m;
time += m * (d + e);
data[i].eff = (double)((f * m * s) - p)/(double)time;
}
sort(data.begin(),data.end());
for (int i = 0; i < N; ++i) {
cout << data[i].name << endl;
}
cout << "#" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(int)(n);++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
template<class T> void vin(vector<T>& v, int n) {
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
}
struct f {
string l;
int p, a, b, c, d, e, f, s, m;
double rate;
void input() {
cin >> l >> p >> a >> b >> c >> d >> e >> f >> s >> m;
}
void calc() {
double k = 0;
rep(i, m) {
if (i == 0) k += a+b+c+d+e;
else k += d+e;
}
double kk = (f*m*s)-p;
rate = kk/k;
}
void print() {
cout << l << endl;
}
};
int main() {
int n;
int count = 0;
while (cin >> n) {
if (n == 0) break;
vector<f> a(n);
rep(i, n) {
a[i].input();
a[i].calc();
}
sort(a.begin(), a.end(), [](const f& a, const f& b) {
if (a.rate == b.rate) {
return a.l < b.l;
}
return a.rate > b.rate;
});
rep(i, n) {
a[i].print();
}
cout << "#" << endl;
}
return 0;
}
| 1 |
#include<stdio.h>
int main()
{
char S[110];
char T[110];
scanf("%s%s", S, T);
printf("%s%s", T, S);
return 0;
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <fstream>
#include <numeric>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF 1e18
#define max(p,q)((p)>(q)?(p):(q))
#define min(p,q)((p)<(q)?(p):(q))
#define PI (acos(-1))
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define rep(i, init, n) for(int i = init; i <(int)(n); i++)
int main() {
int a, b;
cin >> a >> b;
cout << (a * b) << endl;
return 0;
} | 0 |
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);i++)
#define rep1(i,n) for(int i=1;i<int(n);i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using Pint = pair<int,int>;
const ll mod = 1e9+7;
int main(){
string s, t;
cin>>s>>t;
cout<<t<<s<<endl;
return 0;
} | #include <stdio.h>
int main(){
int s[100];
int t[100];
scanf ("%s %s",s,t);
printf("%s%s\n",t,s);
return 0;
} | 1 |
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define ll long long
#define maxn 2000005
#define inf 1e9
#define pb push_back
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define per(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
inline int read()
{
int x=0,w=1; char c=getchar();
while(c<'0'||c>'9') {if(c=='-') w=-1; c=getchar();}
while(c<='9'&&c>='0') {x=(x<<1)+(x<<3)+c-'0'; c=getchar();}
return w==1?x:-x;
}
ll n,x,a[maxn],F;
int main()
{
n=read(); x=read(); rep(i,1,n) a[i]=read(); sort(a+1,a+n+1);
ll tmp=0;
rep(i,1,n)
{
tmp+=a[i];
if(tmp==x) {F=1; cout<<i<<endl; break;}
else if(tmp>x) {F=1; cout<<i-1<<endl; break;}
}
if(!F) cout<<n-1<<endl;
return 0;
} | #include<bits/stdc++.h>
#define mod 1000000007
using namespace std;
int dy[4]={1,0,-1,0};
int dx[4]={0,1,0,-1};
vector<vector<int>> graph;
bool sort_sec(const pair<int,int> &a,const pair<int,int> &b){
if(a.second<b.second){
return true;
}
return false;
}
void swap(int *a,int *b){
int temp=*a;
*a=*b;
*b=temp;
}
int gcd(int a,int b){
if(a%b==0) return b;
return gcd(b,a%b);
}
int digit(int num){
int cnt=0;
while(num!=0){
cnt+=num%10;
num=num/10;
}
return cnt;
}
int main(void){
int N;
cin>>N;
long long x;
cin>>x;
vector<long long> a(N);
vector<long long> result(N);
for(int i=0;i<N;i++){
cin>>a[i];
}
sort(a.begin(),a.end());
for(int i=0;i<N;i++){
result[i]=min(x,a[i]);
x-=result[i];
}
result[N-1]+=x;
int ans=0;
for(int i=0;i<N;i++){
if(result[i]==a[i]) ans++;
}
cout<<ans<<endl;
return 0;
}
| 1 |
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <bitset>
#include <cstring>
using namespace std;
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, 0, sizeof(mat))
typedef long long ll;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c;
while(cin>>a>>b>>c,a||b||c) {
int N; cin >> N;
int info_[4][N];
FOR(i,0,N) FOR(j,0,4) cin >> info_[j][i];
int info[a+b+c+1];
FOR(i,0,a+b+c+1) info[i] = 2;
// ???????????????????????¨?????????
FOR(i,0,N) if(info_[3][i] == 1) FOR(j,0,3) info[info_[j][i]] = 1;
// ?????????????????¨?????????
FOR(i,0,N) {
if(info_[3][i] == 0) {
int cnt = 0;
FOR(j,0,3) cnt += info[info_[j][i]];
if(cnt == 4) {
FOR(j,0,3) if(info[info_[j][i]] == 2) info[info_[j][i]] = 1000;
}
}
}
FOR(i,1,a+b+c+1) cout << (info[i] == 1000 ? 0 : info[i]) << '\n';
}
return 0;
} | #include<iostream>
using namespace std;
struct ST{
int a;
int b;
int c;
int an;
};
int reset(int, int */*[100 + 10]*/);
int main()
{
int ans[1000 + 10];
ST res[1000 + 10];
int an, bn, cn, n;
int ml;
int ln;
int i, j;
int af, bf, cf;
while (cin >> an >> bn >> cn, an != 0 && bn != 0 && cn != 0)
{
cin >> n;
ln = n;
ml = an + bn + cn;
reset(ml, ans);
for (i = 1; i <= ln; i++)
{
cin >> res[i].a >> res[i].b >> res[i].c >> res[i].an;
if (res[i].an == 1)
{
ans[res[i].a] = 1;
ans[res[i].b] = 1;
ans[res[i].c] = 1;
i--;
ln--;
}
}
for (i = 1; i <= ln; i++)
{
af = bf = cf = 0;
if (ans[res[i].a] == 1) af = 1;
if (ans[res[i].b] == 1) bf = 1;
if (ans[res[i].c] == 1) cf = 1;
if (af + bf + cf == 2)
{
if (af == 0)
{
ans[res[i].a] = 0;
}
if (bf == 0)
{
ans[res[i].b] = 0;
}
if (cf == 0)
{
ans[res[i].c] = 0;
}
}
}
for (i = 1; i <= ml; i++)
{
cout << ans[i] << endl;
}
}
return 0;
}
int reset(int n,int *le)
{
int i;
for (i = 0; i < n; i++)
{
le[i] = 2;
}
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main(){
int day30[4] = {4,6,9,11};
while(1) {
int m,d;
cin >> m >> d;
if(m == 0 && d == 0) break;
int a = 1,b = 1,count = 0;
while(1) {
if(a == m && b == d) break;
b++;
count++;
if(a == 2 && b == 30) {
a++;
b = 1;
}
else if(b == 31) {
for(int i=0;i<4;i++)
if(day30[i] == a) {
a++;
b = 1;
break;
}
}
if( b == 32) {
a++;
b = 1;
}
}
if(count % 7 == 4 ) cout <<"Monday"<<endl;
else if(count % 7 == 5) cout << "Tuesday"<<endl;
else if(count % 7 == 6) cout <<"Wednesday"<< endl;
else if(count % 7 == 0) cout <<"Thursday"<< endl;
else if(count % 7 ==1) cout << "Friday" << endl;
else if(count % 7 ==2)cout << "Saturday" << endl;
else if(count % 7 ==3) cout << "Sunday" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
vector<int> hand(5);
char c;
while(cin >> hand[0]>>c>>hand[1]>>c>>hand[2]>>c>>hand[3]>>c>>hand[4]){
vector<int> cnt(15, 0);
for(int i=0; i<5; i++){
cnt[hand[i]]++;
if(hand[i] == 1) cnt[14]++;
}
bool flag = false;
// four card
for(int i=1; i<=13; i++){
if(cnt[i] == 4){
cout << "four card" << endl; flag = true;
}
}
if(flag) continue;
// three card or full house
for(int i=1; i<=13; i++){
if(cnt[i] == 3){
for(int j=1; j<=13; j++){
if(cnt[j] == 2){
cout << "full house" << endl; flag = true;
}
}
if(flag) break;
cout << "three card" << endl; flag = true;
}
}
if(flag) continue;
// two pair or one pair
for(int i=1; i<=13; i++){
if(cnt[i] == 2){
for(int j=i+1; j<=13; j++){
if(cnt[j] == 2){
cout << "two pair" << endl; flag = true;
}
}
if(flag) break;
cout << "one pair" << endl; flag = true;
}
}
if(flag) continue;
// straight
for(int i=1; i<=13; i++){
if(cnt[i] == 1 && cnt[i+1] == 1 && cnt[i+2] == 1 && cnt[i+3] == 1 && cnt[i+4] == 1){
cout << "straight" << endl; flag = true;
}
}
if(flag) continue;
//null
cout << "null" << endl;
}
}
| 0 |
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int>P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-6;
const ld pi = acos(-1.0);
typedef vector<vector<ll>> mat;
typedef vector<ll> vec;
void debug(vec &v) {
int n = v.size();
rep(i, n) {
if (i > 0)cout << " ";
cout << v[i];
}
cout << endl;
}
ll mod_pow(ll x, ll n) {
ll ret = 1;
while (n > 0) {
if (n % 2)ret = ret * x%mod;
x = x * x%mod; n >>= 1;
}
return ret;
}
struct perm {
private:
int sz;
vector<ll> p, invp;
public:
perm(int n) {
sz = n + 1;
p.resize(sz), invp.resize(sz);
p[0] = 1;
rep1(i, sz - 1) {
p[i] = p[i - 1] * i%mod;
}
invp[sz - 1] = 1;
ll cop = mod - 2, x = p[sz - 1];
while (cop) {
if (cop % 2)invp[sz - 1] = invp[sz - 1] * x%mod;
cop >>= 1; x = x * x % mod;
}
per(i, sz - 1) {
invp[i] = invp[i + 1] * (i + 1) % mod;
}
}
ll comb(ll x, ll y) {
if (x < y || y < 0)return 0;
ll ret = p[x];
(ret *= invp[y]) %= mod;
(ret *= invp[x - y]) %= mod;
return ret;
}
ll combP(ll x, ll y) {
if (x < y || y < 0)return 0;
return p[x] * invp[x - y] % mod;
}
};
perm pm(1 << 22);
ll dp[2001];
ll rdp[2002];
ll nex[2001];
void solve() {
int n, k; cin >> n >> k;
if (k == 1) {
cout << 1 << endl; return;
}
dp[1] = 1;
for (int i = 2; i < 2002; i++)rdp[i] = 1;
rep1(i, n - 1) {
for (int j = 1; j <= i + 1; j++) {
int num = i * k - (j - 1);
nex[j] = (rdp[i + 1] - rdp[j - 1])*pm.comb(num + k - 2, num);
nex[j] = (nex[j] % mod + mod) % mod;
}
for (int j = 1; j <= i + 1; j++) {
dp[j] = nex[j];
rdp[j + 1] = (rdp[j] + dp[j]) % mod;
}
}
ll ans = rdp[n + 1];
rep1(i, n)ans = ans * i%mod;
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(12);
//init();
//int t; cin >> t; rep(i, t)solve();
solve();
//stop
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int read(){
int x=0; char c=getchar(); int flag=1;
while(!isdigit(c)) { if(c=='-') flag=-1; c=getchar(); }
while(isdigit(c)) { x=((x+(x<<2))<<1)+(c^48); c=getchar(); }
return x*flag;
}
const int mod=1e9+7;
int n,k;
int dp[2005][2005];//i个白球，j种颜色
int fac[4000005],Inv[4000005];
int C(int n,int m){
if(m<0||n<m) return 0;
return 1ll*(1ll*fac[n]*Inv[m]%mod)*Inv[n-m]%mod;
}
void exgcd(int a,int b,int &x,int &y){
if(b==0) { x=1; y=0; return ; }
exgcd(b,a%b,y,x); y-=a/b*x;
}
int inv(int a){
int x=0,y=0;
exgcd(a,mod,x,y);
return (x%mod+mod)%mod;
}
signed main(){
fac[0]=1;
for(int i=1;i<=4000000;i++) fac[i]=1ll*fac[i-1]*i%mod;
Inv[4000000]=inv(fac[4000000]);
for(int i=3999999;i>=0;i--) Inv[i]=1ll*Inv[i+1]*(i+1)%mod;
n=read(),k=read();
if(k==1) { puts("1"); return 0; }
dp[0][0]=1;
for(int i=1;i<=n;i++){
dp[i][0]=1;
for(int j=1;j<=i;j++){
dp[i][j]=(dp[i-1][j]+1ll*(1ll*dp[i][j-1]*C(n*k-(j-1)*(k-1)-i-1,k-2))%mod*(n-j+1)%mod)%mod;
}
}
printf("%d\n",dp[n][n]);
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <chrono>
#include <random>
#include <cassert>
std::mt19937 rng((int) std::chrono::steady_clock::now().time_since_epoch().count());
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
std::ios_base::sync_with_stdio(false); std::cin.tie(NULL);
int n, k;
std::cin >> n >> k;
int mx = 0, g = 0;
while(n--) {
int x;
std::cin >> x;
g = gcd(g, x);
mx = std::max(mx, x);
}
std::cout << (k % g == 0 && k <= mx ? "POSSIBLE\n" : "IMPOSSIBLE\n");
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
main()
{
int a, b, sum, c = 1;
cin >> a >> b;
sum = a;
if(b == 1){
cout << 0;
}
else if(b <= a){
cout << 1;
}
else{
while(1){
sum = sum + (a - 1);
c++;
if(sum >= b){
break;
}
}
cout << c;
}
}
///promy_pompom
//hello world
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define ZERO_IQ ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define debug(x, y) cerr<<(#x)<<" " <<(#y)<<" is " << (x) <<" "<< (y) << endl
#define debug2(x, y, z) cerr<<(#x)<<" " <<(#y)<<" " <<(#z)<<" is " << (x) <<" "<< (y) <<" "<<(z) << endl
#define watch(x) cerr<<(#x)<<" is " << (x) << endl
const int N = 2e5 + 10;
typedef long long ll;
ll dp[N];
int main() {
ll n;
cin >> n;
vector<ll> v;
vector<ll> summ(n + 1);
for (int i = 1; i <= n; i++) {
ll q;
cin >> q;
v.push_back(q);
if (i % 2 == 1) {
if (i == 1)summ[i] = q;
else
summ[i] = summ[i - 2] + q;
}
}
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i % 2 == 1) {
dp[i] = max(dp[i - 2] + v[i - 1], dp[i - 1]);
} else
dp[i] = max(dp[i - 2] + v[i - 1], summ[i-1]);
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
#define debug(...) fprintf(stderr, __VA_ARGS__)
#ifndef AT_HOME
#define getchar() IO::myGetchar()
#define putchar(x) IO::myPutchar(x)
#endif
namespace IO {
static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;
inline char myGetchar() {
static char buf[IN_BUF], *ps = buf, *pt = buf;
if (ps == pt) {
ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
}
return ps == pt ? EOF : *ps++;
}
template<typename T>
inline bool read(T &x) {
bool op = 0;
char ch = getchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = getchar()) {
op ^= (ch == '-');
}
if (ch == EOF) {
return false;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + (ch ^ '0');
}
if (op) {
x = -x;
}
return true;
}
inline int readStr(char *s) {
int n = 0;
char ch = getchar();
for (; isspace(ch) && ch != EOF; ch = getchar())
;
for (; !isspace(ch) && ch != EOF; ch = getchar()) {
s[n++] = ch;
}
s[n] = '\0';
return n;
}
inline void myPutchar(char x) {
static char pbuf[OUT_BUF], *pp = pbuf;
struct _flusher {
~_flusher() {
fwrite(pbuf, 1, pp - pbuf, stdout);
}
};
static _flusher outputFlusher;
if (pp == pbuf + OUT_BUF) {
fwrite(pbuf, 1, OUT_BUF, stdout);
pp = pbuf;
}
*pp++ = x;
}
template<typename T>
inline void print_(T x) {
if (x == 0) {
putchar('0');
return;
}
static int num[40];
if (x < 0) {
putchar('-');
x = -x;
}
for (*num = 0; x; x /= 10) {
num[++*num] = x % 10;
}
while (*num){
putchar(num[*num] ^ '0');
--*num;
}
}
template<typename T>
inline void print(T x, char ch = '\n') {
print_(x);
putchar(ch);
}
inline void printStr_(const char *s, int n = -1) {
if (n == -1) {
n = strlen(s);
}
for (int i = 0; i < n; ++i) {
putchar(s[i]);
}
}
inline void printStr(const char *s, int n = -1, char ch = '\n') {
printStr_(s, n);
putchar(ch);
}
}
using namespace IO;
int n, k;
int main() {
read(n), read(k);
print(n - k + 1);
}
| 0 |
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdio>
using namespace std;
int S[100],R[100];
main(){
int N,i=0,a,b,c,d;
vector<pair<int,int> >v;
scanf("%d",&N);
for(;i<N*(N-1)/2;i++){scanf("%d%d%d%d",&a,&b,&c,&d);if(c==d)c=d=1;else if(c>d)c=3,d=0;else c=0,d=3;S[a-1]+=c,S[b-1]+=d;}
for(i=0;i<N;i++)v.push_back(make_pair(S[i],i));
sort(v.begin(),v.end(),greater<pair<int,int> >());
for(R[v[0].second]=1,a=0,i=1;i<N;i++){if(v[i].first<v[a].first)a=i;R[v[i].second]=a+1;}
for(i=0;i<N;i++)printf("%d\n",R[i]);
} | #include <iostream>
#include <iomanip>
#include <cassert>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <map>
#include <bitset>
#include <sstream>
#include <istream>
#include <cmath>
#include <cstdio>
using namespace std;
#define vci vector<int>
#define vcs vector<string>
#define pb push_back
#define sz size()
#define mapii map<int, int>
#define mapci map<char, int>
#define mapsi map<string, int>
#define all(x) x.begin(), x.end()
#define minit(a, i) memset(a, i, sizeof(a));
#define for_(i, a, b) for (int i=(int)a; i<(int)b; i++)
#define for_d(i, a, b) for (int i=(int)a-1; i>=b; i--)
#define for_r(i, a, b, c) for (int i=(int)a; i<(int)b; i += c)
#define for_dr(i, a, b, c) for (int i=(int)a-1; i>=b; i -= c)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
typedef long long ll;
const int iINF = 2147483647;
const ll lINF = 9223372036854775807;
template <class T> inline void dbg(T t) { cout << t << endl; }
string ret[7] = {"null", "one pair", "two pair", "three card", "straight", "full house", "four card"};
int main() {
vci t(5); char c;
while (cin>>t[0]>>c>>t[1]>>c>>t[2]>>c>>t[3]>>c>>t[4]) {
int ans = 0;
vci v(13, 0);
for_(i, 0, (int)t.sz) v[t[i]-1]++;
int cnt = 0;
// 0, 1, 2
for_(i, 0, 13) if (v[i]==2) cnt++;
ans = cnt;
// 3
cnt = 0;
for_(i, 0, 13) if (v[i]==3) cnt++;
if (cnt) ans = 3;
// 4
for_(i, 0, 10) {
cnt = 0;
for_(j, 0, 5) {
if (v[(i+j)%13]==1) cnt++;
}
if (cnt==5) ans = 4;
}
// 5
cnt = 0; int cnt2 = 0;
for_(i, 0, 13) {
if (v[i]==2) cnt++;
if (v[i]==3) cnt2++;
}
if (cnt2==1 && cnt==1) ans = 5;
cnt = 0;
for_(i, 0, 13) if (v[i]==4) cnt++;
if (cnt) ans = 6;
cout << ret[ans] << endl;
}
return 0;
} | 0 |
#include <cstdio>
#include <algorithm>
using namespace std;
int h[6];
int sq(int n){
return n*n;
}
int find( int n , int s = 0 ){
int count = 0, m = -1, mm = 0;
for(int i = s; i < 6; i++){
if( m == h[i] ){
count++;
}else{
if( count == n ){
mm = m;
break;
}
m = h[i];
count = 1;
}
}
return mm;
}
int main(){
while( scanf("%d,%d,%d,%d,%d",
h, h+1, h+2, h+3, h+4) != EOF ){
sort(h, h+5);
if( find(4) ) puts("four card");
else if( find(3)*find(2) &&
find(3) != find(2) ) puts("full house");
else if( (h[1]-h[0])*(h[2]-h[1])*(h[3]-h[2])*(h[4]-h[3]) == 1 ||
(h[0] == 1 && h[1] == 10 && h[2] == 11 &&
h[3] == 12 && h[4] == 13) ){
puts("straight");
}else if( find(3) ){
puts("three card");
}else if( find(2)*find(2,2) && find(2) != find(2,2) ){
puts("two pair");
}else if( find(2) ){
puts("one pair");
}else{
puts("null");
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int solve(int N, int P) {
int p = P;
vector<int> have(N, 0);
int turn = 0;
while (1) {
if (p > 0) {
--p;
if (++have[turn] == P) return turn;
}
else {
swap(p, have[turn]);
}
turn = (turn + 1) % N;
}
}
int main() {
int N, P;
while (cin >> N >> P, N || P) {
cout << solve(N, P) << endl;
}
} | 0 |
#include <cstdio>
int matrix[12][12];
int n;
int main() {
while(scanf("%d", &n) != EOF, n) {
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
scanf("%d", &matrix[i][j]);
}
}
// output
for (int i=0; i<n; i++) {
int sum = 0;
for (int j=0; j<n; j++) {
sum += matrix[i][j];
printf("%5d", matrix[i][j]);
}
matrix[i][n] = sum;
printf("%5d\n", sum);
}
for (int j=0; j<=n; j++) {
int sum = 0;
for (int k=0; k<n; k++) {
sum += matrix[k][j];
}
printf("%5d", sum);
}
printf("\n");
}
} | #include <bits/stdc++.h>
using namespace std;
#define rp(i, k, n) for (int i = k; i < n; i++)
typedef long long ll;
typedef double ld;
template<class T>inline bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>inline bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF = 1ll << 60;
const ll MOD = 1e9 + 7ll;
const double PI=3.14159265358979323846;
int main(){
int N; cin >> N;
ll m = INF;
int count = 0;
ll res = 0ll;
rp(i, 0, N) {
ll a; cin >> a;
if(a < 0) count ++;
a = abs(a);
chmin(m, a);
res += a;
}
if(count % 2) res -= 2 * m;
cout << res << endl;
return 0;
} | 0 |
// #include<bits/stdc++.h>
// using namespace std;
// int main(){
// ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
// int tc;
// cin >> tc;
// while(tc--){
// string s;
// cin >> s;
// int count_0 = 0, count_1 = 0;
// for(char ch : s)
// count_0 += 1 - ch + '0', count_1 += ch - '0';
// int ans = min(count_0, count_1);
// int c0 = 0, c1 = 0, n = s.size();
// for(int i = 0; i < n - 1; i++){
// c0 += 1 - s[i] + '0', c1 += s[i] - '0';
// ans = min(ans, c0 + count_1 - c1);
// ans = min(ans, c1 + count_0 - c0);
// }
// cout << ans << '\n';
// }
// }
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long
//increase stack size
#pragma comment(linker, "/STACK:16777216")
ll mxm() {return LLONG_MIN;}
template<typename... Args>
ll mxm(ll a, Args... args) { return max(a,mxm(args...)); }
ll mnm() {return LLONG_MAX;}
template<typename... Args>
ll mnm(ll a, Args... args) { return min(a,mnm(args...)); }
template<class T> ostream& operator<<(ostream& os,vector<T> V){
os<<"[ ";for(auto v:V)os<<v<<" ";return os<<"]";
}
template<class L,class R> ostream& operator<<(ostream& os,pair<L,R> P){
return os<<"("<<P.first<<","<<P.second<<")";
}
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__,__VA_ARGS__)
template<typename Arg1>
void __f(const char* name,Arg1&& arg1){
cout<<name<<" : "<<arg1<<endl;
}
template <typename Arg1,typename... Args>
void __f(const char* names,Arg1&& arg1,Args&&... args){
const char* comma=strchr(names+1,',');cout.write(names,comma-names)<<" : "<<arg1<<" | ";__f(comma+1,args...);
}
#else
#define trace(...) 1
#endif
#define ld long double
#define pll pair<ll,ll>
#define ii pair<int,int>
#define vll vector<ll>
#define vii vector<ii>
#define vi vector<int>
#define vpll vector<pll>
#define vld vector<ld>
#define vvld vector<vld>
#define vvi vector<vi>
#define vvll vector<vll>
#define vvpll vector<vpll>
#define vvii vector<vii>
#define I insert
#define F first
#define S second
#define pb push_back
#define endl "\n"
#define all(x) x.begin(),x.end()
const int mod=1e9+7;
// 128 bit: __int128
inline int add(int a,int b){a+=b;if(a>=mod)a-=mod;return a;}
inline int sub(int a,int b){a-=b;if(a<0)a+=mod;return a;}
inline int mul(int a,int b){return (a*1ll*b)%mod;}
inline int power(int a,int b){int rt=1;while(b>0){if(b&1)rt=mul(rt,a);a=mul(a,a);b>>=1;}return rt;}
inline int inv(int a){return power(a,mod-2);}
struct compare{
bool operator() (const int &a,const int &b) const{
return a>b;
}
};
int main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);cout<<setprecision(25);
int n;
cin >> n;
vector<string> v(n);
for(int i = 0; i < n; i++)
cin >> v[i];
vector<pair<int, int> > balances, negative_balances;
for(int i = 0; i < n; i++){
int tot = 0, mn = 0;
for(auto j : v[i]){
if(j == '(')
tot++;
else tot--;
mn = min(mn, tot);
}
if(tot < 0)
negative_balances.push_back({tot - mn, -tot});
else
balances.push_back({-mn, tot});
}
sort(all(balances));
sort(all(negative_balances));
reverse(all(negative_balances));
int mn_neg_sum = 0, cur_neg_sum = 0;
for(auto i : negative_balances){
mn_neg_sum = max(mn_neg_sum, cur_neg_sum + i.first + i.second);
cur_neg_sum += i.second;
}
int mn_seen = 0;
for(auto i : balances)
if(i.first > mn_seen){
cout << "No" << endl;
return 0;
}
else mn_seen += i.second;
if(mn_seen != cur_neg_sum || mn_seen < mn_neg_sum){
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define rep(i, n) for (int i = 0; i < (int)(n); ++ i)
const int mxn = 1e6 + 5;
int n;
char s[mxn];
int bg[mxn], ln[mxn];
int a[mxn], b[mxn];
int id[mxn];
bool comp(int x, int y) {
return min(-a[x], -a[x] + b[x] - a[y]) > min(-a[y], -a[y] + b[y] - a[x]);
}
void NO() {
puts("No");
exit(0);
}
int main() {
scanf("%d", &n);
rep(i, n) {
scanf("%s", s + bg[i]);
ln[i] = strlen(s + bg[i]);
rep(j, ln[i]) {
if (s[bg[i] + j] == '(') {
++ b[i];
} else {
if (b[i]) -- b[i];
else ++ a[i];
}
}
bg[i + 1] = bg[i] + ln[i];
id[i] = i;
}
sort(id, id + n, comp);
int A = 0;
rep(xx, n) {
int i = id[xx];
A -= a[i];
if (A < 0) NO();
A += b[i];
}
if (A != 0) NO();
puts("Yes");
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define FOR(i,a,b)for(int i=(a),_b=(b);i<=_b;i++)
#define FORN(i,b,a)for(int i=(b);_a=(a);i>=_a;i--)
#define REP(i,n)for(int i=0,_n=n;i<n;i++)
#define ll long long
#define pii pair<int,int>
#define re return
#define vi vector<int>
#define pb push_back
#define si set<int>
#define in insert
#define fl float
#define db double
#define ld long double
#define X first
#define Y second
#define st string
#define ull unsigned long long
#define mod 1000000007
#define INF 1000000007
#define x1 XZVJDFADSPFOE
#define y1 GASDIJSLDAEJF
#define x2 DFDAJKVOHKWIW
#define y2 PSFSAODSXVNMQ
using namespace std;
inline void read(int &x)
{
short negative=1;
x=0;
char c=getchar();
while(c<'0' || c>'9')
{
if(c=='-')
negative=-1;
c=getchar();
}
while(c>='0' && c<='9')
x=(x<<3)+(x<<1)+(c^48),c=getchar();
x*=negative;
}
int a,b;
int c[1001000],r[1001000];
int main()
{
int n,m;
cin>>n>>m;
REP(i,n)
{
cin>>a;
if(r[a])
{
cout<<0<<endl;
return 0;
}
r[a]=1;
}
REP(i,m)
{
cin>>b;
if(c[b])
{
cout<<0<<endl;
return 0;
}
c[b]=1;
}
ll nowr=0,nowc=0,ans=1;
for(int i=n*m;i>=1;i--)
{
if(r[i])
nowr++;
if(c[i])
nowc++;
if(c[i]||r[i])
{
if(c[i]&&!r[i])
ans*=nowr%mod;
if(r[i]&&!c[i])
ans*=nowc%mod;
}
else
{
ans*=(nowc*nowr-(n*m-i))%mod;
}
ans%=mod;
}
cout<<ans<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define all(v) v.begin(), v.end()
bool chmin(ll & a, ll b) { if (b < a) { a = b; return 1; } return 0; }
bool chmax(ll & a, ll b) { if (b > a) { a = b; return 1; } return 0; }
const ll INF = 999999999999999;
const ll MOD = 1000000007;
const ll MAX_N=500010;
ll a, b, c, d, e, f, p, t, x, y, z, q, m, n, r, h, k, w, l, ans;
int main() {
cin>>n;
vl beki;
multiset<ll> A;
beki.push_back(1);
rep(i,40){
beki.push_back(beki.back()*2);
}
rep(i,n){
cin>>x;
A.insert(x);
}
while(!A.empty()){
auto ite=A.end();
ite--;
x=*ite;
A.erase(ite);
k=upper_bound(all(beki),x*2)-beki.begin()-1;
if(!A.empty()&&A.count(beki[k]-x)>0){
auto ite2=A.lower_bound(beki[k]-x);
A.erase(ite2);
ans++;
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define repex(i, a, b, c) for(int i = a; i < b; i += c)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define pb push_back
int main(){
// 1. 入力情報.
char c[2020];
int w;
scanf("%s %d", c, &w);
// 2. 文字を連結.
string ans = "";
int l = strlen(c);
rep(i, l) if(i % w == 0) ans.pb(c[i]);
// 3. 出力.
printf("%s\n", ans.c_str());
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
int w;
cin>>w;
for(int i = 0;i<s.size();i++){
if(i%w==0){
cout<<s.at(i);
}
}
}
| 1 |
#include <cstdio>
#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#define rep(i,n) for (int i=0;i<n;i++)
using ll = long long;
using namespace std;
void solve(){
}
int main (){
ios::sync_with_stdio(0);
cin.tie(0);
ll n;
cin >> n;
ll ans = 1000000000000000;
rep(i,5){
ll m;
cin >> m;
ans = min(ans,m);
}
cout << (n+ans-1)/ans + 4 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define FS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define ld long double
#define pb push_back
#define bp __builtin_popcount
#define sz size()
#define ff first
#define ss second
#define vll vector<ll>
#define vbool vector<bool>
#define vpll vector<pair<ll,ll>>
#define pll pair<ll,ll>
#define vllv vector<vector<ll>>
#define setpri(x) cout<<setprecision(x)<<fixed;
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
#define yesr {cout<<"YES"<<endl;return;}
#define nor {cout<<"NO"<<endl;return;}
// getline (std::cin,name);
ll MOD=1e9+7;
ll ceil1(ll n,ll x){return (n-1)/x+(n>0);}
ll gcd(ll a,ll b){return __gcd(a,b);}
ll lcm(ll a,ll b){return (max(a,b)/gcd(a,b))*min(a,b);}
ll pow1(ll n,ll m ,ll mod=MOD );
ll pow2(ll n,ll k);
ll modinv(ll n,ll mod=MOD){ return pow1(n,mod-2,mod);}
bool func(pair<ll,ll> &a,pair<ll,ll> &b ){
if(a.ff != b.ff)return a.ff < b.ff;
return a.ss > b.ss;
}
ll const N=(ll)2e5+11;
ll const LG=(ll)log2(N)+1;
void solve(){
ll i,j,k,l,n,m,x,y,z,r;
vll a(5);
n=5;
cin>>m;
ll tt=1e15;
for(i=0;i<5;i++){
cin>>a[i];
tt=min(tt,a[i]);
}
ll ans=0;
for(i=n-1;i>=0;i--){
if(a[i]==tt){
ans=ceil1(m,tt);
ans+=n-1;
}
}
cout<<ans<<endl;
}
int main(){
FS;
ll i,j,k,n,m,x,y,z,q;
q=1;
// cin>>q;
for(ll tc=1;tc<=q;tc++){
// cout<<"Case #"<<tc<<": ";
solve();
}
return 0;
}
ll pow1(ll n,ll m,ll mod){
if(m==0)return 1;
if(m%2==0)return pow1((n*n)%mod,m/2,mod);
return (pow1((n*n)%mod,m/2,mod)*n)%mod;
}
ll pow2(ll n,ll k){
ll ans=1;
while(k>0){
if(k%2==1)ans=ans*n;
n=n*n;
k/=2;
}
return ans;
}
| 1 |
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, n) for (int i = 1; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
int main()
{
int n, m ;
cin >> n >> m;
vector<int> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
int lmax = *max_element(all(l));
int rmin = *min_element(all(r));
put(max(0, rmin - lmax + 1));
return 0;
} | #include <bits/stdc++.h>
#include <math.h>
#include <cmath>
using namespace std;
using ll =long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vs = vector<string>;
using vvs = vector<vs>;
using vc = vector<char>;
using vvc = vector<vc>;
using vb = vector<bool>;
using vvb = vector<vb>;
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 long long INF = 1LL << 60;
typedef pair<int, int> PR;
#define rep(i,n) ;for( int i =0; i < n ; i ++)
#define all(a) a.begin(),a.end()
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n",a)
#define mem(a) memset(a,0,sizeof(a))
#define fr(i,a,b) for(int i=a;i<b;i++)
#define pri(a) printf("%.14lf\n",a);
#define MOD 1000000007
bool is_int_lround(double x){
return std::lround(x)==x;
}
ll keta(ll x){
ll n=0;
while(x>0){
x /=10 ;
n ++;
}
return n;
}
ll conbi(int n,int m){
cin>>n>>m;
vector<ll> a(100);
a[0] =1;
for(int i=0;i<14;i++){
a[i+1]=a[i]*(i+1);
}
return a[n] /(a[m] *a[n-m]);
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;//繰り返し二乗法
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll kaijo(ll x){
ll z=1;
if(x==0){
return 1;
}
while(x>0){
z *=x;
z %=MOD;
x--;
}
return z;
}
ll yakusu_num(ll n){
vl yakusu(n+1,1);
for(ll i=2;i*i<=n;i++){
while(n%i==0){
n /=i;
yakusu[i]++;
}
}
if(n!=1)yakusu[n]++;
ll num=1;
for(ll i=0;i <=n;i++){
num*=yakusu[i];
}
return num;
}
//cout<<""<<endl;
int main(){
int N;cin>>N;
vector<PR> R(N),B(N);
rep(i,N){
int a,b;cin>>a>>b;
PR p =make_pair(b,a);
R[i]=p;
}
rep(i,N){
int a,b;cin>>a>>b;
PR p =make_pair(a,b);
B[i]=p;
}
sort(all(R));
reverse(all(R));
vb han(N);
rep(i,N)han[i]=false;
for(int i=0;i<N;i++){
int k=10000,ind=1000;
rep(j,N){
if(han[j])continue;
if(R[i].first<B[j].second){
if(R[i].second<B[j].first){
if(k>B[j].first){
k=B[j].first;
ind=j;
}
}
}
}
if(ind!=1000)han[ind]=true;
}
int cnt=0;
rep(i,N){
if(han[i])cnt++;
}
cout<<cnt<<endl;
}
| 0 |
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include "bits/stdc++.h"
using namespace std;
#define pb push_back
#define F first
#define S second
#define f(i,a,b) for(int i = a; i < b; i++)
// #define endl '\n'
using ll = long long;
using db = long double;
using ii = pair<int, int>;
const int N = 55, LG = 17, MOD = 1e9+7;
const int SQ = 320;
const long double EPS = 1e-7;
int cnt = 0;
vector<string> store[11];
void bt(string s = "", int sum = 0){
if(sum > 7)return;
store[sum].pb(s);
f(i,0,7){
s.pb('0' + i);
bt(s,sum+i+1);
s.pop_back();
}
}
const int M = 10;
int trie[N*N*N][M];
int go[N*N*N][M];
int mrk[N*N*N], f[N*N*N];
int ptr = 1;
void BFS(){
queue<int> q;
for(int i = 0; i < M; i++)
if(trie[0][i])
q.push(trie[0][i]), f[trie[0][i]] = 0;
for(int i = 0; i < M; i++) go[0][i] = trie[0][i];
while(!q.empty()) {
int x = q.front(); q.pop();
for(int i = 0; i < M; i++) {
if(trie[x][i]) {
int y = trie[x][i];
f[y] = f[x];
while(f[y] && !trie[f[y]][i])
f[y] = f[f[y]];
if(trie[f[y]][i]) f[y] = trie[f[y]][i];
q.push(y);
}
if(trie[x][i]) go[x][i] = trie[x][i];
else go[x][i] = go[f[x]][i];
}
}
}
void ins(string x){
int cur = 0;
for(int i = 0; i < x.size(); i++){
if(!trie[cur][x[i]-'0'])
trie[cur][x[i]-'0'] = ptr++;
cur = trie[cur][x[i]-'0'];
}
mrk[cur] = true;
}
int dp[N][N*N*N][2];
int n, x, y, z;
int solve(int idx, int state, bool f){
f|=mrk[state];
if(idx == n)
return f;
int &ret = dp[idx][state][f];
if(~ret)
return ret;
ret = 0;
f(j,0,10){
ret += solve(idx+1,go[state][j], f);
if(ret>=MOD)ret-=MOD;
}
return ret;
}
int32_t main(){
#ifdef ONLINE_JUDGE
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif // ONLINE_JUDGE
bt();
cin >> n >> x >> y >> z;
for(auto X : store[x])
for(auto Y : store[y])
for(auto Z : store[z])if(X.size()+Y.size()+Z.size()<=n)
ins(X+Y+Z);
BFS();
memset(dp,-1,sizeof dp);
cout << solve(0,0,0) << '\n';
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
constexpr int MOD = 1e9 + 7;
template <typename T>
T mypow(T a, T b)
{
if (b == 0)
return 1;
T tmp = mypow(a, b / 2);
if (b % 2)
return (((tmp * tmp) % MOD) * a) % MOD;
else
return (tmp * tmp) % MOD;
}
int n, x, y, z;
// v が x y z となっているか
bool check(const vector<int> &v)
{
int sz = v.size();
if (sz < 3)
return false;
vector<int> sum(sz + 1, 0);
for (int i = 0; i < sz; i++)
{
sum[i + 1] = sum[i] + v[i];
}
bool f = false;
for (int k = 0; k <= sz - 3; k++)
{
for (int i = k + 1; i <= sz - 2; i++)
{
for (int j = i + 1; j <= sz - 1; j++)
{
if (sum[i] - sum[k] == x && sum[j] - sum[i] == y && sum[sz] - sum[j] == z)
f = true;
}
}
}
return f;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> x >> y >> z;
int sum = x + y + z;
// dp[i][j] := i 番目迄見て, 直近(の符号)が j であり, 575 を含まないものの数
vector<vector<ll>> dp(n + 1, vector<ll>(1 << sum, 0));
// valid[i][j] := 直近が i の時に j を置けるか
vector<vector<int>> valid(1 << sum, vector<int>(11, 0));
for (int i = 0; i < (1 << sum); i++)
{
vector<int> num;
int v = 0;
for (int j = sum - 1; j >= 0; j--)
{
if ((i >> j) & 1)
{
if (v)
num.push_back(v);
v = 1;
}
else
{
if (v)
v++;
}
}
if (v)
num.push_back(v);
for (int j = 1; j <= 10; j++)
{
vector<int> num2 = num;
num2.emplace_back(j);
valid[i][j] = !check(num2);
}
}
dp[0][0] = 1;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < (1 << sum); j++)
{
for (int k = 1; k <= 10; k++)
{
if (!valid[j][k])
continue;
int mask = ((((j << k) & ((1 << sum) - 1)) | (1 << (k - 1)))) & ((1 << sum) - 1);
dp[i + 1][mask] += dp[i][j];
dp[i + 1][mask] %= MOD;
}
}
}
ll ret = 0;
for (int i = 0; i < (1 << sum); i++)
ret = (ret + dp[n][i]) % MOD;
cout << (mypow((ll)10, (ll)n) + MOD - ret) % MOD << endl;
}
| 1 |
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <cstdio>
#include <cmath>
#define rep(i,l,n) for(lint i=l;i<n;i++)
#define rer(i,l,n) for(lint i=l;i<=n;i++)
#define all(a) a.begin(),a.end()
#define o(a) cout<<a<<endl
#define pb(a) push_back(a)
#define mk(a,b) make_pair(a,b)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef vector<int> vi;
typedef vector<lint> vli;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
int main(){
int n;
cin>>n;
vi d(n);
int f,l,sf,sl;
rep(i,0,n*(n-1)/2){
cin>>f>>l>>sf>>sl;
f--;
l--;
if(sf<sl){
d[l]+=3;
}else if(sf>sl){
d[f]+=3;
}else{
d[l]++;
d[f]++;
}
}
vi e=d;
sort(all(e));
rep(i,0,n){
int res=upper_bound(all(e),d[i])-e.begin();
o(n+1-res);
}
} | // C++ 14
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for(ll __x = __start; __x < __end; __x++)
int main() {
int n; cin >> n;
vector<int> A(n);
loop(i,0,n) cin >> A[i];
map<int, int> C_ODD, C_EVEN;
loop(i,0,n) {
if (i&1) C_ODD[A[i]]++;
else C_EVEN[A[i]]++;
}
vector<int> R_ODD(2), R_EVEN(2);
{
int max_ = 0;
for (auto &m: C_ODD) if (max_ < m.second) { max_ = m.second; R_ODD[0] = m.first; }
}
{
int max_ = 0;
for (auto &m: C_EVEN) if (max_ < m.second) { max_ = m.second; R_EVEN[0] = m.first; }
}
{
int max_ = 0;
for (auto &m: C_ODD) {
if (R_ODD[0] == m.first) continue;
if (max_ < m.second) { max_ = m.second; R_ODD[1] = m.first; }
}
}
{
int max_ = 0;
for (auto &m: C_EVEN) {
if (R_EVEN[0] == m.first) continue;
if (max_ < m.second) { max_ = m.second; R_EVEN[1] = m.first; }
}
}
if (R_ODD[0] != R_EVEN[0]) {
cout << (n/2 - C_ODD[R_ODD[0]]) + (n/2 - C_EVEN[R_EVEN[0]]) << endl;
return 0;
}
if (R_ODD[0] == R_EVEN[0]) {
ll cost1 = (n/2 - C_ODD[R_ODD[1]]) + (n/2 - C_EVEN[R_EVEN[0]]);
ll cost2 = (n/2 - C_ODD[R_ODD[0]]) + (n/2 - C_EVEN[R_EVEN[1]]);
cout << min(cost1, cost2) << endl;
return 0;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define fast_io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int arr[200001];
int main()
{
fast_io;
int n;
cin >> n;
set <int> s;
for(int i =0 ; i < n; i++)
{
int x;
cin >> x;
s.insert(x);
}
if(n == s.size())
{
cout << "YES\n";
}
else
{
cout << "NO\n";
}
}
| #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define pii pair<int,int>
#define piii pair<int,pii>
#define pll pair<ll,ll>
#define plii pair<ll,pii>
#define vi vector<int>
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define SORT(x) sort(x.begin(), x.end())
#define GSORT(x) sort(x.begin(), x.end(), greater<int>())
#define lw(vc,num) lower_bound(vc.begin(), vc.end(), num) - vc.begin();
#define hg(vc,num) upper_bound(vc.begin(), vc.end(), num) - vc.begin();
#define bn(v,x) binary_search (v.begin(), v.end(), x)
#define mx 100001
#define eps 0.00000000001
#define mod 1000000007
#define pi acos(-1)
#define inf 100000000
#define loop(i,b,n) for(int i=b;i<n;++i)
#define rev_loop(i,b,n) for(int i=b;i>=n;--i)
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
bool isprime(int n)
{
if(n == 1) return false;
if(n == 2 || n == 3) return true;
if(n%2 == 0 || n%3 == 0) return false;
for(int i=5; i*i<=n; i+=6){
if((n%i == 0)||(n%(i+2) == 0)) return false;
}
return true;
}
long long binpow(long long a, long long b) {
if (b == 0)
return 1;
long long res = binpow(a, b / 2);
if (b % 2)
return res * res * a;
else
return res * res;
}
int main()
{
fio;
int n;
cin>>n;
vi v1(n);
loop(i,0,n)
{
cin>>v1[i];
}
int ans = 0,k1 = INT_MAX;
loop(i,0,n)
{
if(k1>v1[i])
{
k1 = v1[i];
ans++;
}
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 998244353;
ll x[301];
int N;
ll dp1[301][100001]; // 3-color
ll dp2[301][100001]; // 2-color
int main() {
cin >> N;
ll S = 0;
ll ans = 1;
for(int i = 0; i < N; i++) {
cin >> x[i];
S += x[i];
ans *= 3;
ans %= MOD;
}
dp1[0][0] = dp2[0][0] = 1;
for(int i = 0; i < N; i++) {
for(int j = 0; j < 100001; j++) {
dp1[i+1][j+x[i]] += dp1[i][j]; // 色を塗り替えても同じ．
dp1[i+1][j+x[i]] %= MOD;
dp1[i+1][j] += (2*dp1[i][j])%MOD;
dp1[i+1][j] %= MOD;
dp2[i+1][j+x[i]] += dp2[i][j];
dp2[i+1][j+x[i]] %= MOD;
dp2[i+1][j] += dp2[i][j];
dp2[i+1][j] %= MOD;
}
}
for(int i = (S+1)/2; i <= S; i++) {
ans -= (dp1[N][i] * 3) % MOD; // 条件(S/2 > i)を満たさない数を引く
ans %= MOD;
}
if(S%2 == 0) {
ans += (dp2[N][S/2]*3 % MOD);
}
ans += MOD;
ans %= MOD;
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;
const int MOD=998244353;
const int INF=0x3f3f3f3f;
const ll INFL=0x3f3f3f3f3f3f3f3f;
ll ppow(ll a,ll b){
a%=MOD;
ll res=1;
while(b){
if(b&1)res=(res*a)%MOD;
a=(a*a)%MOD;
b>>=1;
}
return res;
}
class Fact{
vector<ll>fact;
vector<ll>inv;
public:
Fact(){}
Fact(int n){
n=n*2+10;
fact=inv=vector<ll>(n);
fact[0]=inv[0]=1;
for(int i=1;i<n;i++){
fact[i]=(fact[i-1]*i)%MOD;
}
inv[n-1]=ppow(fact[n-1],MOD-2);
for(int i=n-2;i>=0;i--){
inv[i]=(inv[i+1]*(i+1))%MOD;
}
}
ll get(int n){
return fact[n];
}
ll get_inv(int n){
return inv[n];
}
ll nPr(int n,int r){
return fact[n]*inv[n-r]%MOD;
}
ll nCr(int n,int r){
return nPr(n,r)*inv[r]%MOD;
}
ll nrP(int n,int r){
return nPr(n+r,n);
}
ll nrC(int n,int r){
return nCr(n+r,n);
}
};
int main(){
int n,m;cin>>n>>m;
Fact fac(3*m+n);
ll ans=0;
for(int s=m%2;s<=min(n,m);s+=2){
ll a=fac.nCr(n,s);
ll b=fac.nCr((3*m-s)/2+n-1,n-1);
if((3*m-s)/2>=m)(b+=MOD-fac.nCr((3*m-s)/2-m+n-1,n-1)*s%MOD)%=MOD;
if((3*m-s)/2>=m+1)(b+=MOD-fac.nCr((3*m-s)/2-m-1+n-1,n-1)*(n-s)%MOD)%=MOD;
(ans+=a*b)%=MOD;
}
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for(int i = (a); i < (int)(b); i++)
#define pw(x) (1LL<<(x))
static const int fast_io = [](){ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);return 0;}();
static const int precise_doubles = [](){cout<<fixed<<setprecision(20);return 0;}();
typedef pair<int, int> PII;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
// find_by_order(k) - iterator to kth largest, order_of_key(k) - #things < k
typedef long double LD;
typedef long long LL;
#define EVAL(x) x
#define SPA(x) EVAL({cout << #x" = " << x << ' ';})
#define NEWL EVAL({cout << '\n';})
#define SPAR(a, b) EVAL({cout<<#a" = ";for(auto it=a;it!=b;)cout<<*(it++)<<" ";cout<<'\n';})
#define SPAV(v) EVAL({cout<<#v" = ";for(auto it=v.begin();it!=v.end();)cout<<*(it++)<<" ";cout<<'\n';})
const int INF = 0x3f3f3f3f; // 1.0e9
const LL LINF = 0x3f3f3f3f3f3f3f3fll; // 4.5e18
const LD eps = 1e-20;
const int mod = 3;
inline int msum(int x, int y) {return (x+y<mod ? x+y : x+y-mod);}
inline int mdif(int x, int y) {return (x>=y ? x-y : x-y+mod);}
inline int mprod(int x, int y) { return (1ll*x*y) % mod; }
inline int mpow(int x, LL y) {LL r=1;while(y){if(y&1)r=mprod(r,x);x=mprod(x,x);y>>=1;}return r;}
inline int minv(int x) { return mpow(x, mod-2); }
#define DIE EVAL({cout << -1 << '\n'; exit(0);})
//------------------------------------------------------------------------------------------------------
LL K;
int main() {
cin >> K;
LL x = K % 50;
LL m = (K-x)/50 + 49;
cout << 50 << '\n';
REP(i, 50-x) cout << (m-x) << ' ';
REP(i, x) cout << (m+51-x) << ' ';
cout << '\n';
}
| #pragma GCC optimize ("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
#define int ll
#define sz(x) (int)(x).size();
#define all(x) x.begin(), x.end()
#define trav(i,a) for(auto &i:a)
inline int in(){int x;scanf("%lld",&x);return x;}
int32_t main()
{
int n=in();
vector<int> a(5);
trav(i,a)i=in();
int ans=0;
for(auto i:a)ans=max(ans,(n-1)/i);
cout<<ans+5;
} | 0 |
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp> // Common file
//#include <ext/pb_ds/tree_policy.hpp>
//#include <functional> // for less
#define PI acos(-1.0)
#define eps 1e-9
#define ll long long
#define ull unsigned long long
#define nl printf("\n")
#define sf scanf
#define pf printf
#define INF (ll)1e15
#define mod 1000000007
///#define isValid(n,m,nx,ny)nx>=0&&nx<n&&ny>=0&&ny<m
///int kx[]={1, 1, -1, -1, 2, 2, -2, -2}; //knight moves
///int ky[]={2,-2, 2, -2, 1,-1, 1, -1}; //knight moves
///int dx[]={1,-1,0,0,1,-1,1,-1};//eight direction
///int dy[]={0,0,1,-1,1,-1,-1,1};//eight direction
///using namespace __gnu_pbds;
using namespace std;
///inline double toRad(double deg){return deg*PI/180;}
///inline double toDeg(double rad){return rad*180/PI;}
///typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> new_data_set;
const int S=123456;
int main()
{
#ifndef ONLINE_JUDGE
//freopen("input.txt","r",stdin);
#endif
ll n,a,b;
while(sf("%lld %lld %lld",&n,&a,&b)==3)
{
ll ara[n+5];
for(int i=0;i<n;i++)sf("%lld",&ara[i]);
ll ans=0;
for(int i=0;i<n-1;i++)
{
ll dis=ara[i+1]-ara[i];
if(dis*a<=b)ans+=(dis*a);
else ans+=b;
}
pf("%lld\n",ans);
}
return 0;
}
| #include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a;
cin >> a;
int vmax = a;
int g = a;
for (int i = 1; i < n; ++i) {
cin >> a;
g = __gcd(g, a);
vmax = max(a, vmax);
}
cout << (k / g * g == k && k <= vmax ? "POSSIBLE" : "IMPOSSIBLE") << endl;
} | 0 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define maxn 101
#define Max 10000
using namespace std;
int n,ans=0;
int map[maxn][maxn];
//struct edge
//{
// int u;
// int w;
// edge(int u=0,int w=Max):u(u),w(w){}
// bool operator <???(const node& rhs) const
// {
// return w>rhs.w;
// }
//};
void prim()
{
int d[maxn];
bool vis[maxn];
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;++i)
{
d[i]=Max;
vis[i]=0;
}
d[1]=0;
while(1)
{
int MIN=Max;
int u=-1;
for(int i=1;i<=n;++i)
if(MIN>d[i]&&!vis[i])
{
MIN=d[i];
u=i;
}
if(u==-1) break;
vis[u]=1;
ans+=d[u];
for(int i=1;i<=n;++i)
{
if(!vis[i] && map[u][i]!=Max)
if(d[i]>map[u][i])
d[i]=map[u][i];
}
}
return;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
{
int x;
scanf("%d",&x);
if(x!=-1)
map[i][j]=x;
else
map[i][j]=Max;
}
prim();
printf("%d\n",ans);
return 0;
} | #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
int n;
cin>>n;
vector<int>v;
int answer=0;
for(int i = 0 ; i< 2*n ;i++){
int k;
cin>>k;
v.push_back(k);
}
sort(v.begin(),v.end());
for(int i = 0 ; i < 2*n ; i+=2){
answer+=min(v.at(i),v.at(i+1));
}
cout<<answer<<endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main(void){
// Here your code !
int d;
int s;
while(cin>>d){
s=0;
for(int i=1;i<=(600/d)-1;i++){
s=s+d*(d*i)*(d*i);
}
cout<<s<<endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int d, s;
int main() {
while (scanf("%d",&d) != EOF) {
s = 0;
for (int i = d; i <= 600-d; i += d) s += i*i*d;
printf("%d\n",s);
}
}
| 1 |
#include<bits/stdc++.h>
#define FOR(i,a,b) for (register int i=(a);i<=(b);i++)
#define For(i,a,b) for (register int i=(a);i>=(b);i--)
#define mem(i,j) memset(i,j,sizeof(i))
#define GO(u) for (register int j=f[u];j!=-1;j=nxt[j])
#define fi first
#define se second
#define pii pair<int,int>
#define MP make_pair
using namespace std;
typedef long long ll;
const int N=1e5+5;
int n,a[N],ji,ou,pos,now,gcd;
inline int read()
{
int x=0,f=1;
char c=getchar();
while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
while (c>='0'&&c<='9') {x=(x<<1)+(x<<3)+c-'0';c=getchar();}
return f*x;
}
inline void write(int x)
{
if (x<0) putchar('-'),x=-x;
if (x>9) write(x/10);
putchar(x%10+'0');
return;
}
inline void yes() {if (now) printf("First\n");else printf("Second\n");exit(0);}
inline void no() {if (now) printf("Second\n");else printf("First\n");exit(0);}
inline int GCD(int x,int y)
{
if (!y) return x;
if (x<y) return GCD(y,x);
return GCD(y,x%y);
}
inline void solve()
{
ou=0,ji=0;
FOR(i,1,n) ji+=(a[i]&1),ou+=(!(a[i]&1));
if (!ou) no();
if (ou&1) yes();
if (!ji) no();
if (ji>1) no();
FOR(i,1,n) if (a[i]&1) {pos=i;break;}
if (a[pos]==1) no();
a[pos]--;
gcd=a[1];
FOR(i,2,n) gcd=GCD(gcd,a[i]);
FOR(i,1,n) a[i]/=gcd;
now^=1;
solve();
return;
}
int main()
{
now=1;
n=read();
FOR(i,1,n) a[i]=read();
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long lint;
typedef long long llint;
typedef pair<int, int> pint;
typedef pair<long long, long long> pllint;
// static const int MAX = 1e6;
// static const int NIL = -1;
// static const llint INF = 1<<21;
// static const llint MOD = 1e9 + 7;
bool compPair(const pint& arg1, const pint& arg2) { return arg1.first > arg2.first; }
template<class T> void chmax(T& a, T b) { if (a < b) { a = b; } }
template<class T> void chmin(T& a, T b) { if (a > b) { a = b; } }
int main(void) {
int sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
for(int i=0;i<tx-sx;i++) cout << 'R';
for(int i=0;i<ty-sy;i++) cout << 'U';
for(int i=0;i<tx-sx;i++) cout << 'L';
for(int i=0;i<ty-sy;i++) cout << 'D';
for(int i=0;i<1;i++) cout << 'D';
for(int i=0;i<tx-sx+1;i++) cout << 'R';
for(int i=0;i<ty-sy+1;i++) cout << 'U';
for(int i=0;i<1;i++) cout << 'L';
for(int i=0;i<1;i++) cout << 'U';
for(int i=0;i<tx-sx+1;i++) cout << 'L';
for(int i=0;i<ty-sy+1;i++) cout << 'D';
for(int i=0;i<1;i++) cout << 'R';
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,n,m) for(int i=(int)(n); i<=(int)(m); i++)
#define RFOR(i,n,m) for(int i=(int)(n); i>=(int)(m); i--)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define RITR(x,c) for(__typeof(c.rbegin()) x=c.rbegin();x!=c.rend();x++)
#define setp(n) fixed << setprecision(n)
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
#define ll long long
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll,ll>
#define pi pair<int,int>
#define all(a) (a.begin()),(a.end())
#define rall(a) (a.rbegin()),(a.rend())
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define ins insert
using namespace std;
/* Some Libraries */
//-------------------------------------------------
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int N,H,W; cin>>N>>H>>W;
cout<<(N-H+1)*(N-W+1)<<"\n";
return 0;
}
| #include <iostream>
#include <bitset>
#include <math.h>
#include <algorithm>
#include <vector>;
using namespace std;
int main() {
int d, s, t;
cin >> d >> s >> t;
int m = d / s;
if (d % s != 0) m++;
if (m <= t) {
cout << "Yes\n";
}
else {
cout << "No\n";
}
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);
int main()
{
FastRead
//freopen("output.txt", "w", stdout);
int x,y,tx,ty;
cin>>x>>y>>tx>>ty;
int n=abs(x-tx);
int m=abs(y-ty);
cout<<string(n,'R')<<string(m,'U');
cout<<string(n,'L')<<string(m,'D');
cout<<'L'<<string(m+1,'U')<<string(n+1,'R')<<'D';
cout<<'R'<<string(m+1,'D')<<string(n+1,'L')<<'U';
cout<<endl;
return 0;
}
| #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <functional>
using namespace std;
#define fst first
#define scd second
#define PB push_back
#define MP make_pair
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define omajinai ios::sync_with_stdio(false);cin.tie(0)
#define rep(i,x) for(int i=0;i<(int)(x);++i)
#define rep1(i,x) for(int i=1;i<=(int)(x);++i)
using ll=long long;
using ld=long double;
using vi=vector<int>;
using vvi=vector<vi>;
using pii=pair<int, int>;
using vpii=vector<pii>;
template<class T,class U>ostream&operator<<(ostream&os,const pair<T,U>p){os<<"("<<p.fst<<", "<<p.scd<<")";return os;}
template<class T>ostream&operator<<(ostream&os,const vector<T>v){rep(i,v.size()){if(i)os<<", ";os<<v[i];}return os;}
template<typename T>T&max(T&a,T&b){if(a>=b)return a;return b;}
template<typename T>T&min(T&a,T&b){if(a < b)return a;return b;}
template<typename T>bool chmax(T&a,T b){if(a < b){a=b;return true;}return false;}
template<typename T>bool chmin(T&a,T b){if(a > b){a=b;return true;}return false;}
int in(){int a;scanf("%d",&a);return a;}
ll lin(){ll a;scanf("%lld",&a);return a;}
constexpr int inf = 1e9;
constexpr ll linf = 3e18;
constexpr double eps = 1e-9;
int ans[301];
int item[1010][3], R[1010];
int main()
{
while (true) {
int a = in(), b = in(), c = in();
if (a == 0) return 0;
fill_n(ans, a+b+c+1, 2);
int N = in();
rep(i, N) {
rep(j, 3) item[i][j] = in() - 1;
R[i] = in();
if (R[i]) {
rep(j, 3) ans[item[i][j]] = 1;
}
}
rep(i, N) {
int cnt = 0;
rep(j, 3) cnt += ans[item[i][j]] == 1;
if (cnt == 2) {
rep(j, 3) if (ans[item[i][j]] != 1) ans[item[i][j]] = 0;
}
}
rep(i, a+b+c) printf("%d\n", ans[i]);
}
} | 0 |
#include <iostream>
#include <math.h>
#include <cstdlib>
#include <algorithm>
#include <cstdlib>
#include <string>
#include <stdio.h>
#include <cstdio>
#include <vector>
#include <cstring>
#include <bits/stdc++.h>
using namespace std;
pair <int,int> T_z[500100], T_or[500100];
int T_l[500100], T_najb[500100], tree[1048576], sts[500100];
bool comparison(const pair<int,int> &a,const pair<int,int> &b){
return ((a.first>b.first)||((a.first==b.first)&&(a.second>b.second)));
}
void wstaw(int x, int indx, int drz[])
{
drz[indx]=x;
while (indx!=1)
{
indx/=2; drz[indx]=drz[indx*2]+drz[indx*2+1];
}
}
int suma_prz(int l, int p, int drz[])
{
if (l==p) return drz[l];
if (l/2==p/2) return drz[l/2];
int res=drz[l]+drz[p];
if (l%2==0) res+=drz[l+1];
if (p%2==1) res+=drz[p-1];
while (l/2/2!=p/2/2)
{
l/=2; p/=2;
if (l%2==0) res+=drz[l+1];
if (p%2==1) res+=drz[p-1];
}
return res;
}
int su_bin(int p1, int p2, int poc, int kon, pair <int,int> T_wys[])
{
int res, sr;
while (poc<=kon)
{
sr=(poc+kon)/2;
if (T_wys[sr].first<p1) {res=sr; kon=sr-1; continue;}
if ((T_wys[sr].first==p1)&&(T_wys[sr].second<=p2)) {res=sr; kon=sr-1; continue;}
poc=sr+1;
}
return res;
}
int main()
{
ios_base::sync_with_stdio(0);
int n, q; cin>>n>>q;
for (int i=0;i<n;i++) cin>>T_l[i];
for (int i=0;i<q;i++)
{
cin>>T_z[i].first>>T_z[i].second;
T_or[i].first=T_z[i].first; T_or[i].second=T_z[i].second;
}
sort(T_z, T_z+q, comparison);
int pot;
for (int i=1;;i=i*2)
{
if (i>=n) { pot=i; break; }
}
int kt_q=0; bool prz=false;
for (int i=n-1;i>=0;i--)
{
if (prz) break;
if (T_najb[T_l[i]]!=0) wstaw(0, pot+T_najb[T_l[i]], tree);
wstaw(1, pot+i, tree);
T_najb[T_l[i]]=i;
while (T_z[kt_q].first==i+1)
{
sts[kt_q]=suma_prz(T_z[kt_q].first+pot-1, T_z[kt_q].second+pot-1, tree);
kt_q++;
if (kt_q==q) {prz=true; break;}
}
}
for (int i=0;i<kt_q;i++)
{
cout<<sts[su_bin(T_or[i].first,T_or[i].second, 0, kt_q, T_z)]<<"\n";
}
}
| #include <iostream>
#include <functional>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <queue>
#include <map>
#include <iomanip>
#include <complex>
#include <random>
#include <bitset>
#include <list>
// #include <prettyprint.hpp>
using namespace std;
#define repi(i,n) for(int i=0;i<n;++i)
#define rep(i,n) for(ll i=0;i<n;++i)
#define repinvi(i,n) for(int i=n-1;i>=0;--i)
#define sll(n) scanf("%lld", &n);
#define sii(n) scanf("%d", &n);
#define slf(n) scanf("%lf", &n);
#define pll pair<ll,ll>
#define pii pair<int,int>
#define psi pair<si,si>
typedef long long ll;
typedef double lf;
typedef short int si;
template<typename T>
class BIT{
public:
vector<T> x_list;
ll n;
BIT(ll n=1, T fill_value=0): n(n){
x_list.resize(n+1);
fill(x_list.begin(), x_list.end(), fill_value);
}
void add(ll idx, T v){
for(ll x=idx; x<= n;x += (x & -x)){
x_list[x] += v;
}
}
ll get_sum(ll idx){
T v = 0;
for(ll x=idx;x>0;x-=(x & -x)){
v += x_list[x];
}
return v;
}
};
void Main(){
ll N, Q, c, l, r;
cin >> N >> Q;
vector<ll> as(N);
vector<vector<pll>> qs(N);
// vector<pll> qs_org(Q);
vector<ll> ans(Q);
rep(i, N){
cin >> as[i];
}
rep(i, Q){
cin >> l >> r;
-- l;
-- r;
qs[r].emplace_back(l, i);
// qs_org[i] = make_pair(r, l);
}
// sort(qs.begin(), qs.end());
map<ll,ll> color_best;
// ll now_r = qs[0].first;
BIT<ll> bitree(N, 0);
rep(i, N){
// if(color_best[as[i]]<=i){
// continue;
// }
if(color_best.find(as[i])!=color_best.end() ){
if(color_best[as[i]]<i){
bitree.add(color_best[as[i]]+1, -1);
bitree.add(i+1, 1);
color_best[as[i]] = i;
}
}else{
bitree.add(i+1, 1);
color_best[as[i]] = i;
}
if(qs[i].size() == 0){
continue;
}
for(auto q:qs[i]){
ans[q.second] = bitree.get_sum(i+1) - bitree.get_sum(q.first);
}
}
rep(i, Q){
cout << ans[i] <<endl;
}
}
int main(){
Main();
} | 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n,m;
bool f[500][500];
bool ans[500];
int a,b;
for(;;){
cin >> n >> m;
if(!n && !m)break;
for(int i=0;i<n;i++){
ans[i] = false;
for(int j=0;j<n;j++)f[i][j] = false;
}
while(m--){
cin >> a >> b;
a--;
b--;
f[a][b] = true;
f[b][a] = true;
if(!a)ans[b] = true;
if(!b)ans[a] = true;
}
for(int i=0;i<n;i++)
if(f[0][i])
for(int j=0;j<n;j++)ans[j] |= f[i][j];
cout << count(ans+1,ans+n,true) << endl;
}
} | #include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
for(;;){
int n, m;
cin >> n >> m;
if(n == 0)
return 0;
vector<int> p(n);
for(int i=0; i<n; ++i)
cin >> p[i];
sort(p.rbegin(), p.rend());
for(int i=m-1; i<n; i+=m)
p[i] = 0;
cout << accumulate(p.begin(), p.end(), 0) << endl;
}
} | 0 |
#include<iostream>
using namespace std;
int main(){
int n=1;
int a = 0;
int f = 0;
int quest[10000] = { 1 };
double ans[10000];
int checkc = 0;
int i = 4;
double check[3] = { 1, 2, 4 };
do{
cin >> quest[a];
a++;
} while (quest[a-1] != 0);
while (a > f+1){
switch (quest[f]){
case 1:
ans[f] = 1;
break;
case 2:
ans[f] = 2;
break;
case 3:
ans[f] = 4;
break;
default:
while (quest[f] >= i){
ans[f] = check[0] + check[1] + check[2];
i++;
check[0] = check[1];
check[1] = check[2];
check[2] = ans[f];
}
}
ans[f] = ans[f] / 3650;
checkc = (int)(ans[f]);
if (ans[f] > (double)(checkc)){
checkc++;
}
if (ans[f] != 0){
cout << checkc << endl;
}
else{
cout << endl;
}
f++;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) sort(x.begin(), x.end()); x.erase(unique(x.begin(), x.end()), x.end());
#define rep(i, n) for (int (i) = (0); (i) < (n); ++(i))
#define repp(i, m, n) for (int (i) = (m); (i) < (n); ++(i))
#define dbg(x) cerr << #x << ": " << x << endl;
#define dbg2(x, y) cerr<<"("<<#x<<", "<<#y<<") = "<<"("<<x<<", "<<y<<")"<<endl;
#define dbg3(x, y, z) cerr<<"("<<#x<<", "<<#y<<", "<<#z<<") = "<<"("<<x<<", "<<y<<", "<<z<<")"<<endl;
#define dbgB(value, size) cerr<<#value<<": "<<bitset<size>(value) << endl;
#define line() cerr << "---------------" << endl;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const double PI = 3.14159265358979323846;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
template<typename T, typename U>
void print1(T Array, U size) {
for (int i = 0; i < size; i++) {
cout << Array[i] << " ";
}
cout << endl;
}
template<typename T>
void print(T Array, int height, int width) {
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
cout << " " << Array[i][j];
}
cout << endl;
}
}
// ------------------------------------------------------------------------------------------
int n;
int rec(int stage) {
if (stage == 0) {
return 1;
}
int ans = 0;
for (int i = 1; i <= 3; i++) {
if (stage - i < 0) continue;
ans += rec(stage - i);
}
return ans;
}
signed main() {
while (1) {
cin >> n;
if (n == 0) break;
int t = (rec(n) + 3650 - 1) / 3650;
cout << t << endl;
}
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <ctype.h>
#include <math.h>
using namespace std;
int main ()
{
long long x;
cin >> x;
long long happiness=0;
long long a,b,c;
a=x/500;
b=x%500;
c=b/5;
cout << a*1000+c*5 << endl;
return 0;
}
| #include<iostream>
#include<stdio.h>
#include<cmath>
using namespace std;
int main(){
double x1,x2,y1,y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << fixed << sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)) << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){
return o<<"("<<p.fs<<","<<p.sc<<")";
}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){
o<<"{";
for(const T& v:vc) o<<v<<",";
o<<"}";
return o;
}
using ll = long long;
template<class T> using V = vector<T>;
template<class T> using VV = vector<vector<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n-1); }
#ifdef LOCAL
#define show(x) cerr << "LINE" << __LINE__ << " : " << #x << " = " << (x) << endl
#define dump(x) cerr << "LINE" << __LINE__ << " : " << #x << " = {"; \
for(auto v: x) cerr << v << ","; cerr << "}" << endl;
#else
#define show(x) true
#define dump(x) true
#endif
int main(){
cin.tie(0);
ios::sync_with_stdio(false); //DON'T USE scanf/printf/puts !!
cout << fixed << setprecision(20);
int N,K; cin >> N >> K;
cout << N-K+1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;cin>>a>>b;
if (a==b)cout<<a*2;
else cout <<max(a,b)*2-1<<endl;
} | 0 |
#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;
char c[55][55];
bool visited[55][55];
int d[55][55];
int dx[4] = {0,1,0,-1}, dy[4] = {1,0,-1,0};
queue<P> Q;
int main()
{
int H,W;
cin >> H >> W;
int cntW = 0;
rep(i,H)
{
rep(j,W)
{
cin >> c[i][j];
if (c[i][j] == '.') cntW++;
}
}
rep(i,55)
{
rep(j,55)
{
d[i][j] = 1e8;
}
}
d[0][0] = 0;
Q.push(P(0,0));
while(!Q.empty())
{
P q = Q.front();
int f = q.first, s = q.second;
Q.pop();
if (visited[f][s]) continue;
visited[f][s] = true;
rep(i,4)
{
int xx = f+dx[i], yy = s+dy[i];
if (xx >= 0 && xx < H && yy >= 0 && yy < W && c[xx][yy] == '.')
{
d[xx][yy] = min(d[xx][yy],d[f][s]+1);
Q.push(P(xx,yy));
}
}
}
/*
rep(i,H)
{
rep(j,W)
{
cout << d[i][j] << " ";
}
cout << endl;
}
*/
if (d[H-1][W-1] == 1e8) cout << -1 << endl;
else cout << cntW - d[H-1][W-1] - 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
using P = pair<ll,ll>;
using graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll INF = 1LL<<60;
const ll mod = 1000000007LL;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
struct BIT{
int N;
int bit[1000010];
void add(int a,int w){
for(int x = a; x < N; x+=(x&-x)) bit[x]+=w;
}
int sum(int a){
int ret = 0;
for ( int x = a; x > 0;x-=(x&-x)) ret += bit[x];
return ret;
}
};
int main() {
ll N;
string S;
cin>>N>>S;
int Q;
cin>>Q;
vector<int> D,M,C;
vector<vector<ll>> cnt(N+1,vector<ll>(3,0));
rep(i,N){
if(S[i]=='D') {
D.push_back(i);
cnt[i+1][0]++;
}
if(S[i]=='M') {
M.push_back(i);
cnt[i+1][1]++;
}
if(S[i]=='C') {
C.push_back(i);
cnt[i+1][2]++;
}
}
rep(i,N){
rep(j,3){
cnt[i+1][j]+=cnt[i][j];
}
}
vector<ll> DMcnt(N+1,0);
rep(i,N){
if(S[i]=='M') DMcnt[i+1]+=cnt[i+1][0];
}
rep(i,N) DMcnt[i+1]+=DMcnt[i];
rep(i,Q){
int k;
cin>>k;
ll ans = 0;
for(auto x:C){
ll p = DMcnt[x+1]-DMcnt[max(0,x-k+1)]-cnt[max(0,x-k+1)][0]*(cnt[x+1][1]-cnt[max(0,x-k+1)][1]);
ans += p;
}
cout<<ans<<endl;
}
} | 0 |
#include<cstdio>
#include<cstring>
#include<map>
#include<set>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
#define mp make_pair
#define pb push_back
#define sz(x) ((int)(x).size())
#define rep(i,l,r) for(int i=(l);i<(r);++i)
typedef long long ll;
typedef pair<int,int> pii;
const int N = 5e5 + 7;
//--------head---------
struct Edge {
int u, v, c;
void in() {
cin >> u >> v >> c;
}
} E[N];
int n, m, tot;
map<pii, int> R;
map<pii, int>::iterator it;
vector<pii> e[N];
void ins(int u, int c) {
pii p = mp(u, c);
if (R.find(p) == R.end())
R[p] = ++tot;
}
void addEdge(int u, int v, int c) {
int x = R[mp(u, c)], y = R[mp(v, c)];
e[x].pb(mp(v, 0)), e[x].pb(mp(y, 0));
}
bool vis[N];
int dis[N];
priority_queue<pii> que;
int solve() {
rep(i, 0, tot + 1)
vis[i] = false, dis[i] = -1;
que.push(mp(0, 1));
while (!que.empty()) {
int u = que.top().second, d = -que.top().first;
que.pop();
if (vis[u])
continue;
dis[u] = d, vis[u] = true;
rep(i, 0, sz(e[u])) {
int v = e[u][i].first, w = e[u][i].second;
if (!vis[v])
que.push(mp(-(d + w), v));
}
}
int ans = dis[n];
rep(i, 0, sz(e[n])) {
int v = e[n][i].first;
if (~dis[v] && (ans == -1 || dis[v] < ans))
ans = dis[v];
}
return ans;
}
int main() {
cin >> n >> m;
tot = n;
rep(i, 0, m) {
E[i].in();
ins(E[i].u, E[i].c), ins(E[i].v, E[i].c);
}
for (it = R.begin(); it != R.end(); ++it) {
pii p = it->first;
int v = it->second;
e[p.first].pb(mp(v, 1));
}
rep(i, 0, m) {
int u, v, c;
u = E[i].u, v = E[i].v, c = E[i].c;
addEdge(u, v, c), addEdge(v, u, c);
}
cout << solve() << endl;
return 0;
}
| // includes
#include <cstdio>
#include <cstdint>
#include <iostream>
#include <iomanip>
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <utility>
#include <functional>
#include <cmath>
#include <climits>
#include <bitset>
// macros
#define ll long long int
#define pb push_back
#define mk make_pair
#define pq priority_queue
#define FOR(i, a, b) for(int i=(a); i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
using namespace std;
// types
typedef pair<int, int> P;
typedef pair<ll, int> Pl;
typedef pair<ll, ll> Pll;
// constants
const int inf = 1e9;
const ll linf = 1LL << 50;
const double EPS = 1e-10;
// solve
vector<int> kind[100001];
vector<P> edge[100001];
int fw[100001];
template <typename T>
struct Graph_ {
int n;
vector<vector<pair<int, T> > > edge;
vector<T> dis;
Graph_(int ns) {
n = ns;
edge.resize(n);
dis.resize(n);
}
void dijkstra(int s){
dijkstra(s, 0);
}
T dijkstra(int s, int t){
// initialize
fill(dis.begin(), dis.end(), -1);
vector<bool> used;
used.resize(n);
fill(used.begin(), used.end(), false);
dis[s] = 0;
// dijkstra
priority_queue<pair<T, int>, vector<pair<T, int> >, greater<pair<T, int> > > q;
q.push(make_pair(0, s));
while(!q.empty()){
pair<T, int> p = q.top(); q.pop();
int at = p.second;
T distance = p.first;
if(used[at])continue;
used[at] = true;
for(auto itr = edge[at].begin(); itr != edge[at].end(); ++itr){
int to = (*itr).first;
T cost = (*itr).second;
if(used[to])continue;
if(dis[to] == -1 || dis[to] > distance + cost){
q.push(make_pair(distance + cost, to));
dis[to] = distance + cost;
}
}
}
return dis[t];
}
void adde(int at, int to, T cost){
edge[at].push_back(make_pair(to, cost));
}
[[deprecated("This function takes O(edge[at].size()).")]]
void remove(int at, int to){
int index = -1;
for(int i = 0; i < edge[at].size(); i++){
if(edge[at][i].first == to){
index = i;
break;
}
}
edge[at].erase(edge[at].begin() + index);
}
};
typedef struct Graph_<int> GraphI;
typedef struct Graph_<ll> GraphL;
int main(int argc, char const* argv[])
{
int n, m;
cin >> n >> m;
rep(i, m){
int a, b, c;
cin >> a >> b >> c;
a--; b--;
kind[a].pb(c);
kind[b].pb(c);
edge[a].pb(mk(b, c));
edge[b].pb(mk(a, c));
}
map<P, int> ind;
int curr = 0;
rep(i, n){
fw[i] = curr;
curr++;
kind[i].erase(unique(kind[i].begin(), kind[i].end()), kind[i].end());
rep(j, kind[i].size()){
ind[mk(i, kind[i][j])] = curr;
curr++;
}
}
GraphI graphi(curr+3);
rep(i, n){
rep(j, edge[i].size()){
int at = ind[mk(i, edge[i][j].second)];
int to = ind[edge[i][j]];
graphi.adde(at, to, 0);
}
int cost = 1;
if(kind[i].size() < 2 || i == 0 || i == n - 1){
cost = 0;
}
rep(j, kind[i].size()){
graphi.adde(fw[i], ind[mk(i, kind[i][j])], cost);
graphi.adde(ind[mk(i, kind[i][j])], fw[i], cost);
}
}
int res = graphi.dijkstra(fw[0], fw[n-1]);
if(res == -1)cout << res << endl;
else{
cout << res/2 + 1 << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define all(v) (v).begin(),(v).end()
using namespace std;
using ll=long long;
using pii=pair<int, int>;
using vi=vector<int>;
const ll INF=1LL<<60;
const int MOD=998244353;
const int N=2e5+5;
int main(){
int N, u, v; cin >> N >> u >> v;
u--, v--;
vector<vi> G(N);
for(int i=0; i<N-1; i++){
int A, B; cin >> A >> B;
A--, B--;
G[A].push_back(B);
G[B].push_back(A);
}
vector<vi> dist(2, vi(N, -1));
for(int i=0; i<2; i++){
queue<int> que;
que.push(v+(u-v)*i);
dist[i][v+(u-v)*i]=0;
while(!que.empty()){
int p=que.front();
que.pop();
for(auto &np : G[p]){
if(dist[i][np] != -1) continue;
dist[i][np]=dist[i][p]+1;
que.push(np);
}
}
}
int res=0;
for(int i=0; i<N; i++){
if(dist[0][i] > dist[1][i]) res=max(res, dist[0][i]);
}
res--;
cout << res << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
vector<int>adj[100003],leaf;
int par[100003],depth[100005],sparse[100005][20],root=0,lz=0;
int lca(int p,int q)
{
int a,b,c,d,lp,i,j;
if(depth[p]<depth[q])
{
c=p; p=q; q=c;
}
for(j=19;j>=0;j--)
{
if((depth[p]-(1 << j))>=depth[q])
{
p=sparse[p][j]; if(depth[p]==depth[q])break;
}
}
if(p==q){ return p; }
else
{
for(j=19;j>=0;j--)
{
if(sparse[p][j]!=0 && sparse[p][j]!=sparse[q][j])
{
p=sparse[p][j]; q=sparse[q][j];
if(par[p]==par[q])break;
}
}
return par[p];
}
}
void dfs(int src)
{
int sz=adj[src].size();
if(sz==1 && src!=root){ leaf.push_back(src); lz++; }
for(int lp=0;lp<sz;lp++)
{
int u=adj[src][lp];
if(u!=root && par[u]==0)
{
par[u]=src; sparse[u][0]=src; depth[u]=depth[src]+1;
dfs(u);
}
}
}
int main()
{
int n,m,a,b,i,j,u,v,ans,z,x,y,fr,sc,tr,w;
scanf("%d %d %d",&n,&u,&v);
for(i=1;i<=n-1;i++)
{
scanf("%d %d",&a,&b);
adj[a].push_back(b); if(root==0){ if(adj[a].size()==2)root=a; }
adj[b].push_back(a); if(root==0){ if(adj[b].size()==2)root=b; }
}
if(n==2)printf("0\n");
else
{
dfs(root);
for(j=1;j<=19;j++)
{
for(i=1;i<=n;i++)
{
if(sparse[i][j-1]!=0)
{
sparse[i][j]=sparse[sparse[i][j-1]][j-1];
}
}
}
m=lca(u,v);
ans=(depth[v]-depth[m])+(depth[u]-depth[m]); ans=ans-1;
for(i=0;i<lz;i++)
{
y=leaf[i]; m=lca(u,y); w=lca(v,y);
fr=(depth[u]-depth[m])+(depth[y]-depth[m]);
sc=(depth[v]-depth[w])+(depth[y]-depth[w]);
if(fr<sc)
{
if(sc-1>ans)ans=sc-1;
}
}
printf("%d\n",ans);
}
return 0;
}
| 1 |
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include<ext/pb_ds/tag_and_trait.hpp>
// using namespace __gnu_pbds;
// #include<boost/multiprecision/cpp_int.hpp>
// namespace multiprecisioninteger = boost::multiprecision;
// using cint=multiprecisioninteger::cpp_int;
using namespace std;
using ll=long long;
#define double long double
using datas=pair<ll,ll>;
using ddatas=pair<double,double>;
using tdata=pair<ll,datas>;
using vec=vector<ll>;
using mat=vector<vec>;
using pvec=vector<datas>;
using pmat=vector<pvec>;
// using llset=tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>;
#define For(i,a,b) for(i=a;i<(ll)b;++i)
#define bFor(i,b,a) for(i=b,--i;i>=(ll)a;--i)
#define rep(i,N) For(i,0,N)
#define rep1(i,N) For(i,1,N)
#define brep(i,N) bFor(i,N,0)
#define brep1(i,N) bFor(i,N,1)
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define eb emplace_back
#define print(v) cout<<v<<endl
#define printyes cout<<"Yes"<<endl
#define printno cout<<"No"<<endl
#define printYES cout<<"YES"<<endl
#define printNO cout<<"NO"<<endl
#define output(v) do{bool f=0;for(auto outi:v){cout<<(f?" ":"")<<outi;f=1;}cout<<endl;}while(0)
#define matoutput(v) do{for(auto outimat:v)output(outimat);}while(0)
const ll mod=1000000007;
// const ll mod=998244353;
const ll inf=1LL<<60;
const double PI = acos(-1);
const double eps = 1e-9;
template<class T> inline bool chmax(T& a,T b){bool x=a<b;if(x)a=b;return x;}
template<class T> inline bool chmin(T& a,T b){bool x=a>b;if(x)a=b;return x;}
void startupcpp(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(15);
}
struct unionfind{
private:
int maxN;
vector<int> par,treesize;
public:unionfind(int N) :maxN(N),par(N),treesize(N,1){
for(int i=0;i<maxN;++i)par[i]=i;
}
int root(int x){
while(par[x]!=x){
x=par[x]=par[par[x]];
}
return x;
}
bool unite(int x,int y){
x=root(x);
y=root(y);
if(x==y)return false;
if(treesize[x]>treesize[y])swap(x,y);
par[x]=y;
treesize[y]+=treesize[x];
return true;
}
bool parcheck(int x,int y){
return root(x)==root(y);
}
int size(int x){
return treesize[root(x)];
}
void clear(){
treesize.assign(maxN,1);
for(int i=0;i<maxN;++i)par[i]=i;
}
};
int main(){
startupcpp();
ll i,N,M,cnt=0,ans=0;
cin>>N>>M;
vector<int> a(M),b(M);
map<int,int> mp;
rep(i,M){
cin>>a[i]>>b[i];
mp[a[i]]+=mp[b[i]];
}
for(auto& x:mp)x.second=cnt++;
ans=N*N-cnt*cnt;
N=cnt;
unionfind ut(N*2);
rep(i,M){
a[i]=mp[a[i]];
b[i]=mp[b[i]];
ut.unite(a[i],b[i]+N);
ut.unite(a[i]+N,b[i]);
}
mp.clear();
rep(i,N){
mp[ut.root(i)]|=ut.parcheck(i,i+N);
}
cnt=0;
for(auto& x:mp)cnt+=!x.second;
print(ans+(mp.size()-cnt/2)*(mp.size()-cnt/2)+cnt*cnt/4);
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
const int MN = 100010;
int n, m;
int c0;
int st[MN];
int bi_comp, bi_v;
int nbi_comp, nbi_v;
vi g[MN];
int sz;
bool dfs(int v, int c) {
st[v] = c;
++sz;
bool flg = true;
for (int to : g[v]) {
if (st[to] == -1) {
if (!dfs(to, c ^ 1)) {
flg = false;
}
} else {
if (st[to] == c) {
flg = false;
}
}
}
return flg;
}
int main() {
cin >> n >> m;
rep(i, m) {
int a, b;
cin >> a >> b;
--a; --b;
g[a].pb(b); g[b].pb(a);
}
memset(st, -1, sizeof(st));
rep(i, n) {
if (st[i] == -1) {
if (g[i].size() == 0) {
++c0;
} else {
sz = 0;
bool res = dfs(i, 0);
if (res) {
++bi_comp;
bi_v += sz;
} else {
++nbi_comp;
nbi_v += sz;
}
}
}
}
ll ret = (ll)n * n - (ll)(n - c0) * (n - c0) + (ll)bi_comp * bi_comp * 2 + 2LL * nbi_comp * bi_comp + (ll)nbi_comp * nbi_comp;
cout << ret << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstring>
#include <chrono>
#include <complex>
#define endl "\n"
typedef long long LL;
#define ld long double
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector < vi >
#define pii pair<int,int>
#define pll pair<long long, long long>
#define mod 1000000007
#define mod2 998244353
#define INFINITE 1000000000000000001;
#define all(c) c.begin(),c.end()
#define sz(v) ((ll)(v).size())
#define mp(x,y) make_pair(x,y)
#define mem(a,val) memset(a,val,sizeof(a))
#define eb emplace_back
#define pb push_back
#define f first
#define s second
#define dbg(a) cout<<#a<<" --> "<<(a)<<"\n";
#define forn(i,n) for (ll i=0; i<(n); ++i)
#define fornd(i,n) for (ll i=(n)-1; i>=0; --i)
#define forab(i,a,b) for (ll i=(a); i<=(b); ++i)
#define read(a) ll a; cin >> a;
#define reads(s) string s; cin >> s;
#define readb(a, b) ll a, b; cin >> a >> b;
#define readc(a, b, c) ll a, b, c; cin >> a >> b >> c;
#define readarr(a, n) int a[(n) + 1] = {}; forab(i, 0, (n-1)) {cin >> a[i];}
#define readmat(a, n, m) int a[n + 1][m + 1] = {}; forab(i, 1, n) {forab(j, 1, m) cin >> a[i][j];}
#define readv(A,n) vll A(n,0); forn(i,n) cin>>A[i];
#define print(a) cout << a << endl;
#define printarr(a, n) forab (i, 1, n) cout << a[i] << " "; cout << endl;
#define printv(v) for (int i: v) cout << i << " "; cout << endl;
#define printmat(a, n, m) forab(i, 1, n) {forab (j, 1, m) cout << a[i][j] << " "; cout << endl;}
#define precision(a) cout<<fixed<<setprecision(a);
#define INF (1e18+5)
#define inf (1e9+5)
int dx[4] = { 0, 0, 1, -1 };
int dy[4] = { 1, -1, 0, 0 };
// 8-directions
//int dx[]={1,1,1,0,0,-1,-1,-1};
//int dy[]={-1,0,1,-1,1,-1,0,1};
#define fast_io ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
using namespace std;
int begtime = clock();
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngb(chrono::steady_clock::now().time_since_epoch().count()); // can give negative values too
bool isPowerOfTwo(int x) {
return x && (!(x & (x - 1)));
}
int takemod(int x) {
return (x % mod + mod) % mod;
}
int fpow(int base, int power, int MOD) {
int result = 1;
base = base % MOD;
while (power) {
if (power & 1)
result = (result * base) % MOD;
base = (base * base) % MOD;
power = power >> 1;
}
return result;
}
int modinv(int x) {return fpow(x, mod - 2, mod);}
void solve()
{
string a;
cin>>a;
ll ans=0;
if(a[0]=='R'&&a[1]=='R'&&a[2]=='R')
{
cout<<3<<endl;
}
else if((a[0]=='R'&&a[1]=='R')||(a[1]=='R'&&a[2]=='R'))
{
cout<<2<<endl;
}
else if(a[0]=='R'||a[1]=='R'||a[2]=='R')
{
cout<<1<<endl;
}
else
{
cout<<0<<endl;
}
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
fast_io;
int T=1;
//cin>>T;
// cin.ignore(); must be there when using getline(cin, s)
while(T--)
{
solve();
}
#ifndef ONLINE_JUDGE
cerr << "Time elapsed: " << (clock() - begtime)*1000/CLOCKS_PER_SEC << " ms\n\n";
#endif
return 0;
}
| #include<stdio.h>
#include<string.h>
#include<iostream>
#include <fstream>
#include<iostream>
#include <sstream>
#include<string>
#include <list>
using namespace std;
const int M = 1003;
const int INIT = (M*M + 1);
int C[M][M];// = { 0 };
int countmatchstring(const char* p1, const char*p2, int length1, int length2,int x, int y, int i, int j,int cost)
{
int w = (i - 1 > j - 1) ? i - 1 : j - 1;
if (p1[x + i] == p2[y + j])
{
x = x + i;
y = y + j;
if (x == length1 - 1 && y == length2 - 1)
{
C[x][y] = 0;
return w;
}
if (x == length1 - 1 || y == length2 - 1)
{
while (1);
}
C[x][y] = countmatchstring(p1, p2, length1, length2, x, y, 1, 1, w + cost);
return w + C[x][y];
}
if (C[x + i][y + j] == INIT)
{
int c1 = INIT, c2 = INIT,c3 = INIT;
if (x + i + 1 < length1)
{
for (int p = 1; x + i + p < length1; ++p)
{
if (p1[x + i + p] == p2[y + j])
{
c1 = countmatchstring(p1, p2, length1, length2, x, y, i + p, j, cost);
break;
}
}
}
if (y + j + 1 < length2)
{
for (int q = 1; y + j + q < length2; ++q)
{
if (p1[x + i] == p2[y + j + q])
{
c2 = countmatchstring(p1, p2, length1, length2, x, y, i, j + q, cost);
break;
}
}
}
if ((x + i + 1 < length1) && (y + j + 1 < length2))
{
c3 = countmatchstring(p1, p2, length1, length2, x, y, i + 1, j + 1, cost);
}
int c = (c1 < c2 ? c1 : c2);
c = (c < c3 ? c : c3);
C[x + i][y + j] = c;
}
return C[x + i][y + j];
}
int main(){
std::istream & c_in = cin;
for (int i = 0; i < M; ++i){
for (int j = 0; j < M; ++j){
C[i][j] = INIT;
}
}
string s1, s2;
getline(c_in, s1);
getline(c_in, s2);
s1 = "A" + s1 + "B";
s2 = "A" + s2 + "B";
const char* p1 = s1.c_str();
const char* p2 = s2.c_str();
countmatchstring(p1, p2, s1.length(), s2.length(),0, 0, 1,1,0);
printf("%d\n", C[1][1]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define all(V) (V).begin(),(V).end()
#define MOD 1000000007
#define mod 998244353
int rw[100010];
vector<int> W[100010];
int main(){
for (int i = 0;i < 100010;i++)rw[i] = -1;
ll N, L;
cin >> N;
vector<ll> X(N);
for (int i = 0;i < N;i++)
cin >> X[i];
cin >> L;
for (int j = 0;j < N;j++) {
if (rw[j] >= 0)continue;
for (int i = j;i < N;) {
W[j].push_back(i);
if (rw[i] >= 0)break;
rw[i] = j;
auto it = upper_bound(all(X), X[i] + L);
it--;
i = it - X.begin();
}
}
//for (int i = 0;i < N;i++)cout << rw[i] << " ";
ll Q, a, b, c, d, ans = 0;
cin >> Q;
for (int i = 0;i < Q;i++) {
ans = 0;
cin >> a >> b;
if (a > b)swap(a, b);
a--;b--;
c = rw[a];
while (1) {
auto it = W[c].end();
it--;
d = *it;
if (d >= b)break;
ans += it - find(all(W[c]), a);
//cout << ans << endl;
a = d;
c = rw[a];
}
auto it1 = find(all(W[c]), a);
auto it2 = lower_bound(all(W[c]), b);
ans += it2 - it1;
cout << ans << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
#define int long long int
// #include"Template.cpp"
int n, l, q;
vector<int> arr;
vector<vector<int>> table;
void preprocess() {
int curr = 1;
int i = 1;
while(i <= n) {
if(curr == n+1) {
table[i][0] = curr - 1;
i ++;
continue;
}
while(curr <= n && (arr[curr] - arr[i]) <= l) {
curr ++;
}
table[i][0] = curr - 1;
i ++;
}
for(int i = n; i > 0; i --) {
for(int j = 1; j < 30; j ++) {
int mid = table[i][j-1];
if(mid != -1) {
table[i][j] = table[mid][j-1];
}
}
}
}
int query(int l, int r) {
if(l > r) swap(l, r);
int ans = 0;
for(int j = 29; j >= 0; j --) {
int pw = 1LL << j;
if(table[l][j] == -1) continue;
if(arr[table[l][j]] < arr[r]) {
l = table[l][j];
ans += pw;
}
}
++ans;
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cin >> n;
arr.assign(n + 1, 0);
table.assign(n+1, vector<int>(30, -1));
for(int i = 1; i <= n; i ++) cin >> arr[i];
cin >> l >> q;
preprocess();
// t(table);
while(q --) {
int low, high; cin >> low >> high;
int ans = query(low, high);
cout << ans << endl;
}
return 0;
} | 1 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#include <tuple>
#include <cassert>
#include <functional>
#include <set>
#include <deque>
#include <list>
using namespace std;
typedef long long ll;
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
const int INF = 1<<29;
#define LNF __LONG_LONG_MAX__
const ll MOD = 1000000007;
const int MAX = 200000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// 法mでのaの逆元を計算
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
//最大公約数
long long gcd(long long x, long long y){
if(y==0) return x;
else return gcd(y,x%y);
}
//最小公倍数
long long lcm(long long x, long long y){
return x / gcd(x, y) * y;
}
// nが大きく,kが10^7程度の時の二項係数
long long com[200005];
void combination(long long n,long long k){
com[0] = 1;
for(int i=1;i<=k;i++){
com[i] = (com[i-1]*(n-i+1)%MOD)*modinv(i,MOD)%MOD;
}
}
int main(){
int K,X; cin >> K >> X;
int a=X-K+1;
if(K==1){
cout << X << endl;
return 0;
}
for(int i=a;i<X+K;i++){
cout << i << " ";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define rep(i,n) for (ll i=0; i<n; ++i)
#define all(c) begin(c),end(c)
template<typename T1, typename T2>
bool chmax(T1 &a,T2 b){if(a<b){a=b;return true;}else return false;}
template<typename T1, typename T2>
bool chmin(T1 &a,T2 b){if(a>b){a=b;return true;}else return false;}
/*
(H,W)
(i,j)
1行ずつよまなきゃ
ああ、そういうことか
OXXXO
XXXXO
1
2になるのか
OXXXOXXOX
XXXOXXXXO
これはない
2e5)^2は無理
ええ・・・BITなら無理・・・
12345678
OOOXXXOO (1,1) (7,1) 4-6
OXXXXXXO (1,2) (8,2) 2-7
XXXXOOOO (5,7) (8,3) 1-4
OOOOOXXX (5,8) (9,3)みたいな
OOOXXXXX 4-8
XXOOOOOO 1-2
最高効率と手前保存しておくとか？
管理むずい
W通り保持・・・
12345678 //(スタート位置、今いるW）
OOOXXXOO {(1,1),(2,2),(3,3),(7,7),(8,8)} //0+1 {0,0,0,0,0}
OXXXXXXO {(1,1),(8,8)} //0+2 {0,0}
XXXXOOOO {(1,5),(8,8)} //0+3 {4,0}
OOOOOXXX {(1,5)} //(5-1)+4 {4}
mapとmultiset...
mapにlower_bound？
おしりから見ていくとか
(今いる位置、スタート位置）か。
・setにpair
set<pair<ll,ll>> S;
S.lower_bound({a,b});
a優先でb順に並んでる。
・eraseした後のitr
S.erase(itr);
itr++;
eraseした後ポインタの場所変わっちゃうので1つ先がとれるとは限らない。
S.erase(itr++);
erase処理前の移動でちゃんと1つ先がとれる。
おぎゃあああああああああああ
OOXX
XXOO
XXOO
OOOX
XXXO
XXXX
XXXO
最後消えてないじゃん
*/
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
ll H,W; cin>>H>>W;
set<pair<ll, ll>> POS;
multiset<ll> SC;
rep(i, H){
ll a, b, ans=0; cin>>a>>b;
if (i == 0){
for(ll j=1; j<a; j++){
POS.insert({j, j});
SC.insert(0);
}
for(ll j=b+1; j<=W; j++){
POS.insert({j, j});
SC.insert(0);
}
}
else{
auto itr1 = POS.lower_bound({a, -1});
ll v1, v2;
bool del = false;
while(itr1 != POS.end() && itr1->first <= b){
v1 = itr1->first;
v2 = itr1->second;
SC.erase(SC.find(v1 - v2));
POS.erase(itr1++);
del = true;
}
if (del && b < W && itr1->first != b+1){
POS.insert({b+1, v2});
SC.insert(b+1 - v2);
}
}
if (SC.size() == 0){
cout << -1 << endl;
continue;
}
ans = *SC.begin();
cout << ans + i + 1 << endl;
/*
cout<<"i:"<<i<<" SC.size():" << SC.size() << " POS.size():" << POS.size() << endl;
cout<<"SC:";
auto itr = SC.begin();
while (itr != SC.end()){
cout<<*itr<<" ";
itr++;
}
cout<<"POS:";
auto pitr = POS.begin();
while (pitr != POS.end()){
cout<<"("<< pitr->first<<", "<<pitr->second<<") ";
pitr++;
}
cout<<endl;
*/
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n;
cin >> n;
pair<ll, ll> p[n];
ll ans = 0;
for(int i = 0; i < n; i++){
cin >> p[i].first >> p[i].second;
ans += 0 - p[i].second;
}
ll q[n];
for(int i = 0; i < n; i++){
q[i] = p[i].first + p[i].second;
}
sort(q, q + n, greater<ll>());
for(int i = 0; i < n; i++){
if(i % 2 == 0){
ans += q[i];
}
}
cout << ans << 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) {
std::cin >> a;
}
template<class _T> static void getint(_T& a, _T& b) {
std::cin >> a >> b;
}
template<class _T> static void getint(_T& a, _T& b, _T& c) {
std::cin >> a >> b >> c;
}
template <class _T> static _T tp_abs(_T a) {
if (a < (_T)0) {
a *= (_T)-1;
}
return a;
}
static void exec();
int main()
{
exec();
fflush(stdout);
return 0;
}
static void exec()
{
int N;
getint(N);
std::vector<std::pair<LLONG, LLONG>> plates(N);
for (int i = 0; i < N; i++) {
getint(plates[i].first, plates[i].second);
}
std::sort(plates.begin(), plates.end(),
[](const std::pair<LLONG, LLONG>& a, const std::pair<LLONG, LLONG>& b) {
return (a.first + a.second) > (b.first + b.second);
});
bool tkhs = true;
std::vector<std::pair<LLONG, LLONG>> tk, ao;
for (int i = 0; i < N; i++) {
if (tkhs) {
tk.push_back(plates[i]);
tkhs = false;
}
else {
ao.push_back(plates[i]);
tkhs = true;
}
}
LLONG tkSum = 0;
for (auto it = tk.begin(); it != tk.end(); it++) {
tkSum += it->first;
}
LLONG aoSum = 0;
for (auto it = ao.begin(); it != ao.end(); it++) {
aoSum += it->second;
}
printf("%lld\n", tkSum - aoSum);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) \
for (int i = 0; i < (int)(n); i++) \
;
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
int main() {
int n;
cin >> n;
long x;
cin >> x;
vector<long> a(n);
for (long &x : a) {
cin >> x;
}
long count = 0;
for (int i = 0; i < n - 1; i++) {
if (a.at(i) + a.at(i + 1) > x) {
long count_plus = min(a.at(i) + a.at(i + 1) - x, a.at(i + 1));
count += count_plus;
a.at(i + 1) -= count_plus;
if (a.at(i + 1) == 0) {
long count_plus = a.at(i) - x;
count += count_plus;
a.at(i) -= count_plus;
}
}
}
cout << count << endl;
}
| #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <iomanip>
using namespace std;
typedef long long ll;
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
#define EPS (1e-7)
#define INF (1e15)
#define PI (acos(-1))
#define MOD 1000000007
#define REP(i,n) for(int i=0;i<n;i++)
#define REPS(i,f,n) for(int i=(f);i<(n);i++)
#define EACH(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define dump(x) cout << #x << " = " << (x) << endl;
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#define arrdump(n,a) for(int i=0;i<n;i++) {cout<<((i>0)? " ":"")<<a[i];}cout<<"\n";
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
int dy4[]={0, 0, 1, -1};
int dx4[]={1, -1, 0, 0};
int dx8[]={0, 0, 1, -1, 1, 1, -1, -1};
int dy8[]={1, -1, 0, 0, 1, -1, -1, 1};
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_6_B&lang=jp
int n;
int A[100005];
int cnt;
static int par(int p, int r) {
int i = p - 1;
int x = A[r];
for (int j = p; j < r; j++) {
if (A[j] <= x) {
i++;
swap(A[j], A[i]);
}
}
swap(A[r], A[i+1]);
return i+1;
}
int main() {
cin >> n;
REP(i, n) cin >> A[i];
int q = par(0, n-1);
REP(i, n) {
if (i) cout << " ";
if (i == q) cout << "[";
cout << A[i];
if (i == q) cout << "]";
}
cout << "\n";
return 0;
}
| 0 |