code_file1
stringlengths 87
4k
| code_file2
stringlengths 85
4k
|
|---|---|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
using namespace std;
#define debug(x) cout << #x << " is " << x << endl
typedef long long ll;
typedef pair<int, int> P;
const int INF = 0x3f3f3f3f;
int n, ans;
string S, T;
vector<int> a, b;
int main()
{
cin >> n;
cin >> S >> T;
for (int i = 0; i < n; ++i) {
if (S[i] == '0') a.push_back(i);
if (T[i] == '0') b.push_back(i);
}
if (a.size() != b.size()) { puts("-1"); return 0; }
for (int i = 0; i < (int)a.size(); ++i) {
if (a[i] == b[i]) continue;
if (a[i] < b[i]) {
ans++;
}
else if (a[i] > b[i]) {
ans++;
}
}
printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// #include <atcoder/all>
// using namespace atcoder;
// #define int long long
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define irreps(i, m, n) for (int i = ((int)(n)-1); i > (int)(m); ++i)
#define SORT(v, n) sort(v, v + n);
#define REVERSE(v, n) reverse(v, v+n);
#define vsort(v) sort(v.begin(), v.end());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cinline(n) getline(cin,n);
#define replace_all(s, b, a) replace(s.begin(),s.end(), b, a);
#define PI (acos(-1))
#define FILL(v, n, x) fill(v, v + n, x);
#define sz(x) (int)(x.size())
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vs = vector<string>;
using vpll = vector<pair<ll, ll>>;
using vtp = vector<tuple<ll,ll,ll>>;
using vb = vector<bool>;
using ld = long double;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class t> using vc=vector<t>;
template<class t> using vvc=vc<vc<t>>;
const ll INF = 1e9+10;
// const ll MOD = 1e9+7;
const ll MOD = 998244353;
const ll LINF = 1e18;
// 以下の操作が行える時、SをTに一致させられるか
// 011..1 :0が連続している区間から始めて登場する1とswap
// 11..10 :逆
// まずこの操作によってある0（1でもよい）は任意の場所に移動できると気付く
// 正確には、0001100みたいに先頭から0が3個、1が2個、0が2個みたいな情報が与えられたとき、0，1の個数が一致するなら必ずそれが作れるということ
// 以下は0，1の個数が一致する場合
// s,tの0のindexをリスト化する(a,bとする)
// a[i]!=b[i]なら、明らかにs[a[i]]はいずれかの1とswapする必要があるが、この時aの他の要素が変化することはない（swapするのは1なので）
// 上記から、少なくともa[i]!=b[i]の個数だけ操作する必要があるとわかる
// どのような場合でも最適に操作すれば、上の個数回だけの操作で一致させられるか？ => 可能
// 今いくつかa[i]!=b[i]であるようなiが存在するとする
// 今移動させられるiとswapできるs[x]==1 && s[x]!=t[x]なるindex xが存在するはずで、これを適切な組合せと順序でswapしていけば（端から処理するイメージ）よい
// s=10111001
// t=01011011
// 上の例なら、今a[0]=1を見ているなら、x=0(前方)となる
// a[i]!=b[i]なるiが存在していて、1手で操作できる範囲にxが存在しないということは有り得ない
// s=101
// t=?1?
// （a,bの長さが一致するなら、0,2のいずれかは0である）tの0,2いずれを0にするとしても必ず s,tは1手で一致させられる
signed main()
{
cin.tie( 0 ); ios::sync_with_stdio( false );
int n; cin>>n;
string s,t; cin>>s>>t;
vc<int> a,b;
rep(i,n) {
if(s[i]=='0') a.push_back(i);
if(t[i]=='0') b.push_back(i);
}
if(a.size()!=b.size()) {
cout<<-1<<endl;
return 0;
}
int ans=0;
rep(i,a.size()) if(a[i]!=b[i]) ans++;
cout<<ans<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
template<typename T = int> vector<T> create(size_t n){ return vector<T>(n); }
template<typename T, typename... Args> auto create(size_t n, Args... args){ return vector<decltype(create<T>(args...))>(n, create<T>(args...)); }
template<typename T = int, T mod = 1'000'000'007, typename U = long long>
struct umod{
T val;
umod(): val(0){}
umod(U x){ x %= mod; if(x < 0) x += mod; val = x;}
umod& operator += (umod oth){ val += oth.val; if(val >= mod) val -= mod; return *this; }
umod& operator -= (umod oth){ val -= oth.val; if(val < 0) val += mod; return *this; }
umod& operator *= (umod oth){ val = ((U)val) * oth.val % mod; return *this; }
umod& operator /= (umod oth){ return *this *= oth.inverse(); }
umod& operator ^= (U oth){ return *this = pwr(*this, oth); }
umod operator + (umod oth) const { return umod(*this) += oth; }
umod operator - (umod oth) const { return umod(*this) -= oth; }
umod operator * (umod oth) const { return umod(*this) *= oth; }
umod operator / (umod oth) const { return umod(*this) /= oth; }
umod operator ^ (long long oth) const { return umod(*this) ^= oth; }
bool operator < (umod oth) const { return val < oth.val; }
bool operator > (umod oth) const { return val > oth.val; }
bool operator <= (umod oth) const { return val <= oth.val; }
bool operator >= (umod oth) const { return val >= oth.val; }
bool operator == (umod oth) const { return val == oth.val; }
bool operator != (umod oth) const { return val != oth.val; }
umod pwr(umod a, U b) const { umod r = 1; for(; b; a *= a, b >>= 1) if(b&1) r *= a; return r; }
umod inverse() const {
U a = val, b = mod, u = 1, v = 0;
while(b){
U t = a/b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
if(u < 0)
u += mod;
return u;
}
};
using U = umod<int, 998244353>;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
if(max(n, m) == 1){
cout << k << '\n';
return 0;
}
if(min(n, m) == 1){
cout << (U(k) ^ (max(n, m))).val << '\n';
return 0;
}
if(n > m) swap(n, m);
vector<U> ways_n(k + 1);
for(int i = 1; i <= k; i++){
ways_n[i] = (U(i) ^ n) - (U(i - 1) ^ n);
}
vector<U> fat(m + 1), ifat(m + 1);
fat[0] = 1;
for(int i = 1; i <= m; i++){
fat[i] = fat[i - 1] * i;
}
for(int i = 0; i <= m; i++){
ifat[i] = U(1) / fat[i];
}
auto ncr = [&](int n, int r){
if(n < r) return U(0);
if(n == r || r == 0) return U(1);
return fat[n] * ifat[r] * ifat[n - r];
};
U ans = 0;
for(int i = 1; i <= k; i++){
// cout << i << ' ' << ways_n[i].val << ' ' << (U((k - i + 1)) ^ m).val << '\n';
ans += ways_n[i] * (U((k - i + 1)) ^ m);
}
cout << ans.val << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int T=1, caseIdx=0;
//cin >> T;
while (T--) {
caseIdx++;
long r, x, y, ans=0;
cin >> r >> x >> y;
double d = sqrt(x*x + y*y);
ans = ceil(d/r);
if (ans==1 && d != r)
++ans;
cout << ans << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main(){
int n;
string s;
int q;
cin >> n;
cin >> s;
cin >> q;
vector<int> T(q);
vector<int> A(q);
vector<int> B(q);
rep(i, q){
cin >> T[i] >> A[i] >> B[i];
}
rep(i, q - 1){
if (T[i] == 2 && T[i + 1] == 2){
T[i] = -1;
T[i + 1] = -1;
i++;
}
}
rep(i, q){
if (T[i] == 1){
char tmp = s[A[i] - 1];
s[A[i] - 1] = s[B[i] - 1];
s[B[i] - 1] = tmp;
}
else if (T[i] == 2){
string s1, s2;
s1 = s.substr(n);
s2 = s.substr(0, n);
s = s1 + s2;
}
else continue;
}
cout << s << endl;
} | /*Jai Shree Ram*/
// Never Give Up
#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#define umii unordered_map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define F(i,s,e,j) for(int i=s;i<=e;i+=j)
#define mt19937 rng(chrono::steady_clock::now().tjhe_since_epoch().count());
//shuffle(arr,arr+n,rng)
/*---------------------------------------------------------------------------------------------------------------------------*/
int gcd(int a, int b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
int expo(int a, int b,int m) {int res = 1; while (b > 0) {if (b & 1)res = (res * a) % m; a = (a * a) % m; b = b >> 1;} return res;}
void extendgcd(int a, int b, int*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); int x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
int mminv(int a, int b) {int arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
int mminvprime(int a, int b) {return expo(a, b - 2, b);}
void swap(int &x, int &y) {int temp = x; x = y; y = temp;}
int combination(int n, int r, int m, int*fact, int *ifact) {int val1 = fact[n]; int val2 = ifact[n - r]; int val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
void google(int t) {cout << "Case #" << t << ": ";}
vi sieve(int n) {int*arr = new int[n + 1](); vi vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
int mod_add(int a, int b, int m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
int mod_mul(int a, int b, int m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
int mod_sub(int a, int b, int m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
int mod_div(int a, int b, int m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;} //only for prime m
int phin(int n) {int number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0) n /= 2;} for (int i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
/*--------------------------------------------------------------------------------------------------------------------------*/
void c_p_c()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int32_t main()
{ c_p_c();
int n;
cin>>n;
string str;
cin>>str;
string a = str.substr(0,n);
string b = str.substr(n,n);
w(q)
{
int t,l,r;
cin>>t>>l>>r;
l--;
r--;
if(t==2)
{
swap(a,b);
}
else
{
if(l<n && r<n)
swap(a[l],a[r]);
else if(l>=n && r>=n)
swap(b[l-n],b[r-n]);
else
{
swap(a[l],b[r-n]);
}
}
}
str = a+b;
cout<<str<<endl;
} |
#include<bits/stdc++.h>
using namespace std;
int m1(int n)
{
string s;
s=to_string(n);
sort(s.begin(),s.end());
n=stoi(s);
return(n);
}
int m2(int n)
{
string s2;
s2=to_string(n);
sort(s2.begin(),s2.end(),greater<int>());
n=stoi(s2);
return(n);
}
int main(){
int x,y,z,i,k;
scanf("%d %d",&x,&k);
for(i=0;i<k;i++)
{
y=m1(x);
z=m2(x);
x=z-y;
}
printf("%d",x);
return(0);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
set<int> st1, st2;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
st1.insert(a);
}
for (int i = 0; i < m; i++) {
int b;
cin >> b;
st2.insert(b);
}
vector<int> ans;
for (auto i : st1) {
if (st2.find(i) == st2.end()) ans.emplace_back(i);
}
for (auto i : st2) {
if (st1.find(i) == st1.end()) ans.emplace_back(i);
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
if (i) cout << " ";
cout << ans.at(i);
}
cout << '\n';
} |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=(n)-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,1,0,-1,1,-1,1,-1};
template <typename T> inline bool chmax(T &a, T b) {
return ((a < b) ? (a = b, true) : (false));
}
template <typename T> inline bool chmin(T &a, T b) {
return ((a > b) ? (a = b, true) : (false));
}
int main(){
ll n;cin >> n;
string s;cin >> s;
vl a(n+1);rep(i,n+1)cin >> a[i];
ll k=inf;rep(i,n)chmin(k,abs(a[i+1]-a[i]));
cout << k <<endl;
vvl mat(k,vl(n+1));
vl use(n+1);
rep(i,k){
rep(j,n+1){
mat[i][j]=a[j]/k;
use[j]+=a[j]/k;
}
}
rep(i,n+1)a[i]-=use[i];
rep(i,n+1){
rep(j,a[i]){
mat[j][i]++;
}
}
rep(i,k){
rep(j,n+1)cout << mat[i][j] <<" ";cout << endl;
}
} | #include <bits/stdc++.h>
#define PRINT(x) cerr<<#x<<'='<<x<<endl
#define NL(x) " \n"[(x)]
#define sz(x) int((x).size())
#define all(x) begin(x),end(x)
#define mid (l+r)/2
#define fi first
#define se second
#define pb push_back
#define endl '\n'
#define lld long long
#define pii pair<int,int>
#define pli pair<lld,int>
#define pil pair<int,lld>
#define pll pair<lld,lld>
#define INF 1000000000
#define LINF 1000000000000000000LL
#define EPS 1e-9
using namespace std;
#define MAXN 200010
lld X[MAXN], Y[MAXN];
lld sgnX[MAXN], sgnY[MAXN];
lld koefX[MAXN], koefY[MAXN];
lld flipped[MAXN];
int main() {
ios::sync_with_stdio(false); cin.tie(0);
int N; cin >> N;
for(int i = 1; i <= N; i++) cin >> X[i] >> Y[i];
sgnX[0] = sgnY[0] = 1;
koefX[0] = koefY[0] = 0;
flipped[0] = 0;
int M; cin >> M;
for(int i = 1; i <= M; i++) {
int tip; cin >> tip;
if(tip == 1) {
koefX[i] = koefY[i-1]; koefY[i] = -koefX[i-1];
sgnX[i] = sgnY[i-1]; sgnY[i] = -sgnX[i-1];
flipped[i] = 1^flipped[i-1];
} else if(tip == 2) {
koefX[i] = -koefY[i-1]; koefY[i] = koefX[i-1];
sgnX[i] = -sgnY[i-1]; sgnY[i] = sgnX[i-1];
flipped[i] = 1^flipped[i-1];
} else if(tip == 3) {
lld p; cin >> p;
koefY[i] = koefY[i-1]; sgnY[i] = sgnY[i-1];
koefX[i] = 2*p-koefX[i-1]; sgnX[i] = -sgnX[i-1];
flipped[i] = flipped[i-1];
} else if(tip == 4) {
lld p; cin >> p;
koefX[i] = koefX[i-1]; sgnX[i] = sgnX[i-1];
koefY[i] = 2*p-koefY[i-1]; sgnY[i] = -sgnY[i-1];
flipped[i] = flipped[i-1];
}
}
int Q; cin >> Q;
for(int i = 1; i <= Q; i++) {
int A, B; cin >> A >> B;
cout << sgnX[A]*(flipped[A] ? Y[B]:X[B]) + koefX[A] << ' ' << sgnY[A]*(flipped[A] ? X[B]:Y[B]) + koefY[A] << endl;
}
return 0;
}
|
//g++ -std=gnu++14 a.cpp
// ./compile_run.sh
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <tuple>
#include <iomanip>
#include <random>
#include <math.h>
#include <stdio.h>
using namespace std;
#define ll long long
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define revrep(i, n) for(ll i = (n)-1; i >=0; i--)
#define P pair<ll,ll>
#define pb push_back
ll MOD = 1e9 + 7;
int INF = 1 << 30;
ll INFL = 1LL << 60;
ll MODP = 998244353;
//const ll M = MOD;
template<typename __T__>
int len(vector<__T__> x){
return int(x.size());
}
template<typename __T__>
void vecout(vector<__T__> x){
rep(i, len(x)) cout << x[i] << " ";
cout << endl;
}
ll lmax(ll x,ll y){
if(x < y) return y;
else return x;
}
ll lmin(ll x, ll y){
if(x > y)return y;
else return x;
}
ll gen(ll x,ll y){
if(y == 0)return 1;
if(y == 1)return x%MOD;
if(y%2 == 1){
return ((x%MOD)*gen(x,y-1)%MOD)%MOD;
}else{
ll res = gen(x,y/2)%MOD;
return ((res%MOD)*(res%MOD))%MOD;
}
}
ll Factorial(ll x,ll y){ //xのy乗
if(y == 1) return x;
if(y == 0) return 1;
if(y%2 == 0){
ll res = Factorial(x,y/2);
return res*res;
}else{
return x*Factorial(x,y-1);
}
}
ll gcd(ll x, ll y){
if(x < y) swap(x,y);
if(y == 0) return x;
return gcd(y,x%y);
}
ll lcm(ll x,ll y){
ll s = gcd(x,y);
x /= s;
y /= s;
return x*y*s;
}
int main() {
ll n;
cin >> n;
string s;
cin >> s;
vector<ll> a(n),b(n);
rep(i,2*n){
ll c = s.at(i) - 'A';
if(i < n) a[i] = c;
else b[i-n] = c;
}
ll q;
cin >> q;
rep(i,q){
ll x,y,z;
cin >> x >> y >> z;
y--;
z--;
if(x == 1){
ll na,nb;
if(y < n) na = a[y];
else na = b[y-n];
if(z < n) nb = a[z];
else nb = b[z-n];
if(y < n) a[y] = nb;
else b[y-n] = nb;
if(z < n) a[z] = na;
else b[z-n] = na;
}else{
swap(a,b);
}
}
string ans = "";
rep(i,2*n){
char add;
if(i < n) add = 'A'+a[i];
else add = 'A'+b[i-n];
ans += add;
}
cout << ans << endl;
}
| //#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using db = double;
using ld = long double;
template<typename T> using V = vector<T>;
template<typename T> using VV = vector<vector<T>>;
template<typename T> using PQ = priority_queue<T>;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define all(v) (v).begin(),(v).end()
#define siz(v) (ll)(v).size()
#define rep(i,a,n) for(ll i=a;i<(ll)(n);++i)
#define repr(i,a,n) for(ll i=n-1;(ll)a<=i;--i)
#define ENDL '\n'
typedef pair<int,int> Pi;
typedef pair<ll,ll> PL;
constexpr ll mod = 1000000007; // 998244353;
constexpr ll INF = 1000000099;
constexpr ll LINF = (ll)(1e18 +99);
const ld PI = acos((ld)-1);
constexpr ll dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
template<typename T,typename U> inline bool chmin(T& t, const U& u){if(t>u){t=u;return 1;}return 0;}
template<typename T,typename U> inline bool chmax(T& t, const U& u){if(t<u){t=u;return 1;}return 0;}
template<typename T> inline T gcd(T a,T b){return b?gcd(b,a%b):a;}
inline void Yes() { cout << "Yes" << ENDL; }
inline void No() { cout << "No" << ENDL; }
inline void YES() { cout << "YES" << ENDL; }
inline void NO() { cout << "NO" << ENDL; }
template<typename T,typename Y> inline T mpow(T a, Y n) {
T res = 1;
for(;n;n>>=1) {
if (n & 1) res = res * a;
a = a * a;
}
return res;
}
template <typename T>
vector<T> finddivisor(T x) { //整数xの約数(xを含む)
vector<T> divisor;
for(T i = 1; (i * i) <= x; i++) {
if(x % i == 0) {
divisor.push_back(i);
if(i * i != x) { divisor.push_back(x / i);}
}
}
sort(divisor.begin(), divisor.end());
return divisor;
}
template <typename T> V<T> prefix_sum(const V<T>& v) {
int n = v.size();
V<T> ret(n + 1);
rep(i, 0, n) ret[i + 1] = ret[i] + v[i];
return ret;
}
template<typename T>
istream& operator >> (istream& is, vector<T>& vec){
for(auto&& x: vec) is >> x;
return is;
}
template<typename T,typename Y>
ostream& operator<<(ostream& os,const pair<T,Y>& p){
return os<<"{"<<p.fs<<","<<p.sc<<"}";
}
template<typename T> ostream& operator<<(ostream& os,const V<T>& v){
os<<"{";
for(auto e:v)os<<e<<",";
return os<<"}";
}
template<typename ...Args>
void debug(Args&... args){
for(auto const& x:{args...}){
cerr<<x<<' ';
}
cerr<<ENDL;
}
signed main(){
cin.tie(0);cerr.tie(0);ios::sync_with_stdio(false);
cout<<fixed<<setprecision(20);
ll n,m;cin>>n>>m;
V<int> a(m),b(m);
map<Pi,int> id;
V<int> dir(m,0);//1 ->
rep(i,0,m){
cin>>a[i]>>b[i];
--a[i];--b[i];
id[{a[i],b[i]}]=id[{b[i],a[i]}]=i;
}
V<ll> c(n);cin>>c;
VV<int> e(n);
rep(i,0,m){
int x=a[i],y=b[i];
if(c[x]>c[y])dir[i]=1;
else if(c[x]<c[y])dir[i]=2;
else{
e[x].eb(y);
e[y].eb(x);
}
}
V<bool> used(n,false);
auto dfs=[&](auto self,int now)->void{
for(auto&& to:e[now]){
if(dir[id[{now,to}]])continue;
if(now==a[id[{now,to}]])dir[id[{now,to}]]=1;
else dir[id[{now,to}]]=2;
if(used[to])continue;
used[to]=true;
self(self,to);
}
};
rep(i,0,n)if(!used[i]){
used[i]=true;
dfs(dfs,i);
}
rep(i,0,m){
assert(dir[i]);
if(dir[i]==1)cout<<"->"<<ENDL;
else cout<<"<-"<<ENDL;
}
}
//(・_・)(・_・)(・_・)(・_・)
//CHECK overflow,what to output?
//any other simpler approach? |
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <set>
#include <climits>
#include <string>
#include <cmath>
#include <stack>
#include <functional>
#include <list>
#include <array>
#include <queue>
#include <bitset>
#include <ciso646>
#include <fstream>
#include <string.h>
using namespace std;
#define db(x) cout << #x << " " << (x) << "\n";
const int mod1 = 1000000007;
const int mod2 = 1000000009;
#define inf LLONG_MAX
#define n_inf LLONG_MIN
#define all(x) x.begin(), x.end()
#define sorta(x) sort(all(x))
typedef long long int ll;
template<typename... T>
void read(T&... args)
{
((cin >> args), ...);
}
template<typename... T>
void write(T&&... args)
{
((cout << args << " "), ...);
}
#define w(t) \
int t; \
std::cin >> t; \
while (t--)
#define FastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
void solve(int test_case = 0)
{
int n; cin>>n;
vector<ll> A(n);
for(int i=0; i<n; i++)
{
cin>>A[i];
}
ll curr = 0, max_inc = 0, last_inc = 0, max_possible = 0;
for(int i=0; i<n; i++)
{
max_inc = max(max_inc, last_inc + A[i]);
max_possible = max(max_possible, curr + max_inc);
curr += last_inc + A[i];
last_inc += A[i];
}
cout<<max_possible;
}
int main()
{
FastIO;
#ifdef LOCAL
freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif
int test_case = 1, i = 0;
//cin>>test_case;
while (test_case--)
{
i++;
solve(i);
}
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < (n); i++)
#define REPS(i, n) for(int i = 1; i <= (n); i++)
#define RREP(i, n) for(int i = (n)-1; i >= 0; i--)
#define RREPS(i, n) for(int i = (n); i > 0; i--)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
using ll = long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const int MOD = 1e9 + 7;
//const int MOD = 998244353;
const ll INF = 1e9 + 7;
const ll INFL = 1e18;
const double PI = 3.14159265359;
template<class T> bool chmax(T &a, const T &b) { if(a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if(a > b) { a = b; return true; } return false; }
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll N, Q; cin >> N >> Q;
vl A(N); REP(i, N) cin >> A[i];
vl K(Q); REP(i, Q) cin >> K[i];
sort(ALL(A));
vl s;
vl t;
t.pb(0);
if(A[0] != 1)
{
s.pb(1);
t.pb(A[0]-1);
}
REP(i, N-1)
{
if(A[i]+1 != A[i+1]) s.pb(A[i]+1), t.pb(A[i+1]-A[i]-1);
}
s.pb(A[N-1]+1);
t.pb((ll)2e18);
REP(i, (int)t.size()-1) t[i+1] += t[i];
REP(i, Q)
{
int idx = lower_bound(ALL(t), K[i]) - t.begin() -1;
cout << s[idx]+K[i]-1-t[idx] << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
cin.tie(nullptr);
cin.sync_with_stdio(false);
}
using LL = long long;
using LD = long double;
const LL MOD = 998244353;
const LL INF = LLONG_MAX;
const LL N = 3e5+1;
#define S second
#define F first
#define vt vector
LL binpow (LL x, LL p, LL m) {
LL res = 1;
x %= m;
while (p) {
if (p&1) {
res = res * x % m;
}
x = x * x % m;
p >>= 1;
}
return res;
}
int main () {
fastio();
LL n, k;
cin >> n >> k;
vt<LL> a(n);
for (LL i = 0; i < n; ++i) {
cin >> a[i];
}
vt<vt<LL>> binom(k+1, vt<LL>(k+1));
binom[0][0] = 0;
for (LL i = 1; i <= k; ++i) {
binom[i][0] = binom[i][i] = 1;
for (LL j = 1; j <= i-1; ++j) {
binom[i][j] = binom[i-1][j-1]+binom[i-1][j];
binom[i][j] %= MOD;
}
}
vt<vt<LL>> sum(k+1, vt<LL>(n, 1));
for (LL i = 0; i < n; ++i) {
sum[1][i] = a[i];
}
for (LL i = 2; i <= k; ++i) {
for (LL j = 0; j < n; ++j) {
sum[i][j] = (sum[1][j]*sum[i-1][j]) % MOD;
}
}
vt<LL> sumacc(k+1, 0);
LL twoinv = binpow(2, MOD-2, MOD);
LL tp = 2;
for (LL i = 0; i <= k; ++i) {
for (LL j = 0; j < n; ++j) {
sumacc[i] = (sumacc[i] + sum[i][j])%MOD;
}
}
for (LL i = 1; i <= k; ++i, tp <<= 1, tp %= MOD) {
LL accum = 0;
for (LL j = 0; j <= i; ++j) {
accum = (accum + sumacc[j]*sumacc[i-j] % MOD * binom[i][j] % MOD) % MOD;
}
accum = ((accum - tp * sumacc[i] % MOD) % MOD + MOD) % MOD;
accum = (accum * twoinv) % MOD;
cout << accum << "\n";
}
} | #include <iostream>
#include <stdio.h>
#include <vector>
#include <queue>
#include <utility>
using namespace std;
typedef struct edge{
int to;
int cost;
}Edge;
typedef pair<int,int> P;
long long INF=250000010;
int V;
vector<Edge> G[1000000];
long long d[1000000];
void dijkstra(int s){
priority_queue<P,vector<P>,greater<P>> que;
fill(d,d+V,INF);
d[s]=0;
que.push(P(0,s));
while(!que.empty()){
P p=que.top();que.pop();
int v=p.second;
if(d[v]<p.first)continue;
for(unsigned int i=0;i<G[v].size();i++){
Edge e=G[v][i];
if(d[e.to]>d[v]+e.cost){
d[e.to]=d[v]+e.cost;
que.push(P(d[e.to],e.to));
}
}
}
}
int main(){
int R,C;
cin>>R>>C;
V=R*C*2;
vector<vector<int>> A,B;
for(int i=0;i<R;i++){
vector<int>tmp(C-1);
for(int j=0;j<C-1;j++)cin>>tmp.at(j);
A.push_back(tmp);
}
for(int i=0;i<R-1;i++){
vector<int>tmp(C);
for(int j=0;j<C;j++)cin>>tmp.at(j);
B.push_back(tmp);
}
int q=R*C;
for(int i=0;i<R;i++){
for(int j=0;j<C;j++){
if(j<C-1){
G[C*i+j].push_back({C*i+j+1,A.at(i).at(j)});
}
if(j>0){
G[C*i+j].push_back({C*i+j-1,A.at(i).at(j-1)});
}
if(i<R-1){
G[C*i+j].push_back({C*(i+1)+j,B.at(i).at(j)});
}
G[C*i+j].push_back({q+C*i+j,1});
G[q+C*i+j].push_back({C*i+j,0});
if(i>0){
G[q+C*i+j].push_back({q+C*(i-1)+j,1});
}
}
}
dijkstra(0);
printf("%d\n",d[R*C-1]);
return 0;
} |
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int T, n;
string s1, s2, s3;
int main()
{
std::ios::sync_with_stdio(0);
cin >> T;
while (T--) {
cin >> n;
cin >> s1 >> s2 >> s3;
for (int i = 1; i <= n; i++) cout << '0';
for (int i = 1; i <= n; i++) cout << '1';
cout << "0\n";
}
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int T;
cin >> T;
for (int t = 0; t < T; t++) {
int N;
string S1, S2, S3;
cin >> N >> S1 >> S2 >> S3;
if (S1[0] == '0' && S2[0] == '0' && S3[0] == '0') {
cout << string("0") + string(2*N, '1') << endl;
} else {
// int d1 = 0;
// int d2 = 0;
// int d3 = 0;
// for (int i=0; i<2*N; i++) {
// if (S1[i] == '1') d1 = i;
// }
// for (int i=0; i<2*N; i++) {
// if (S2[i] == '1') d2 = i;
// }
// for (int i=0; i<2*N; i++) {
// if (S3[i] == '1') d3 = i;
// }
cout << "1" << string(N, '0') + string(N, '1') << endl;
}
}
} |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
int n;
cin>>n;
double a = 1.08 * n;
int r = (int)a;
if(r < 206){
cout<<"Yay!"<<endl;
}else if(r == 206){
cout<<"so-so"<<endl;
}else{
cout<<":("<<endl;
}
}
| #line 1 "Contests/AtCoder_abc206/abc206_a/main.cpp"
using namespace std;
#line 2 "library/bits/stdc++.h"
// C
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
#line 3 "Contests/AtCoder_abc206/abc206_a/main.cpp"
#include <unordered_set>
#define ll long long
#define MAX 9223372036854775807
#define REP(i,N) for(ll i=0; i<N; i++)
void solve(){
// write your solution here.
}
int main() {
ll N;
cin >> N;
double x=(double)108*N/100;
x=floor(x);
if(x<206) cout << "Yay!" << endl;
else if(x==206) cout << "so-so" << endl;
else cout << ":(" << endl;
return 0;
}
|
//g++ -std=c++11 -Wall test.cpp -o test -lm -g -O2
#include <bits/stdc++.h>
#include <cstdio>
#include <iterator>
using namespace std;
#define sws \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define vi vector<int>
#define vll vector<long long int>
#define vb vector<bool>
#define pb push_back
#define ll long long int
#define endl '\n'
#define pii pair<int,int>
#define pill pair<int,ll>
#define plli pair<ll,int>
#define plli pair<ll,int>
#define tlli tuple<ll,ll,int>
#define till tuple<int,ll,ll>
#define forn(b) for(int i = 0; i<b ;i++)
#define MAX 4005
int main(){
int n;
cin>>n;
string ans = n%2?"Black":"White";
cout<<ans<<endl;
}
| #include<bits/stdc++.h>
#define ll long long
#define F first
#define S second
#define pb push_back
using namespace std;
const ll maxn = 1e5 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n = 0;
cin >> n;
ll x = 1.08 * 1.0 * n;
ll c = 206;
// cout << x << " " << c << "\n";
if (x < c)
cout << "Yay!";
else if (x > c)
cout << ":(";
else
cout << "so-so";
}
|
#include <bits/stdc++.h>
long double EPS = 1e-12;
using namespace std;
vector<complex<long double>> rotate(vector<complex<long double>> points, const complex<long double>& rot) {
for (auto& p : points) {
p *= rot;
}
return points;
}
bool equals(vector<complex<long double>> points1, vector<complex<long double>> points2) {
if (points1.size() != points2.size()) return false;
int n = points1.size();
sort(points1.begin(), points1.end(), [](const complex<long double>& c1, const complex<long double>& c2) {
if (abs(c1.real() - c2.real()) < EPS) return c1.imag() < c2.imag();
return c1.real() < c2.real();
});
sort(points2.begin(), points2.end(), [](const complex<long double>& c1, const complex<long double>& c2) {
if (abs(c1.real() - c2.real()) < EPS) return c1.imag() < c2.imag();
return c1.real() < c2.real();
});
for (int i = 0; i < n; i++) {
if (abs(points1[i] - points2[i]) >= EPS) return false;
}
return true;
}
int main() {
int N;
cin >> N;
vector<complex<long double>> S(N), T(N);
for (int i = 0; i < N; i++) {
double x, y;
cin >> x >> y;
S[i] = x + y * 1i;
}
for (int i = 0; i < N; i++) {
double x, y;
cin >> x >> y;
T[i] = x + y * 1i;
}
complex<long double> gS = 0, gT = 0;
for (int i = 0; i < N; i++) {
gS += S[i];
gT += T[i];
}
gS /= N;
gT /= N;
for (int i = 0; i < N; i++) {
S[i] -= gS;
T[i] -= gT;
}
for (int i = 0; i < N; i++) {
if (S[i] == complex<long double>(0)) {
S.erase(S.begin() + i);
break;
}
}
for (int i = 0; i < N; i++) {
if (T[i] == complex<long double>(0)) {
T.erase(T.begin() + i);
break;
}
}
bool able = false;
if (S.size() == T.size()) {
for (int i = 0; i < N; i++) {
able |= equals(S, rotate(T, S[0] * abs(T[i]) / (T[i] * abs(S[0]))));
}
}
if (able) puts("Yes");
else puts("No");
return 0;
} | #include<bits/stdc++.h>
#define ln puts("")
#define sp printf(" ")
using namespace std;
typedef long long ll;
inline ll read() {
ll sum = 0, ff = 1;
char ch = getchar();
while(ch < '0' || ch > '9') {
if(ch == '-')
ff = -1;
ch = getchar();
}
while(ch >= '0' && ch <= '9')
sum = sum * 10 + ch - '0', ch = getchar();
return sum * ff;
}
void write(ll x) {
if(x < 0)
putchar('-'), x = -x;
if(x > 9)
write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e5 + 7;
int n, a[N], b[N], c[N], mp1[N], mp2[N];
ll ans;
int main() {
// freopen("", "r", stdin);
// freopen("", "w", stdout);
n = read();
for(int i = 1; i <= n; i++)
a[i] = read(), mp1[a[i]]++;
for(int i = 1; i <= n; i++)
b[i] = read();
for(int i = 1; i <= n; i++)
c[i] = read(), mp2[c[i]]++;
for(int i = 1; i <= n; i++)
ans += (ll)mp1[b[i]] * mp2[i];
write(ans);
return 0;
}
|
#include <cstdio>
#include <algorithm>
using namespace std;
const int M = 100005;
#define db double
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n;db ans,a[M];
db Abs(db x) {return x>0?x:-x;}
signed main()
{
n=read();
for(int i=1;i<=n;i++)
{
db x=read();
ans+=x/2;
a[i]=x/2;
}
sort(a+1,a+1+n);
db tmp=a[(n+1)/2];
for(int i=1;i<=n;i++)
ans+=Abs(tmp-a[i]);
printf("%.7f\n",ans/n);
} | #pragma GCC optimize("Ofast")
#pragma GCC optimization ("unroll-loops")
#include <bits/stdc++.h>
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define ff first
#define ss second
#define ins insert
#define sz(x) (int)x.size()
#define dbg(x) cout << x << "\n";
const int N = 2e5 + 5;
const long long int mod = 1e9 + 7;
const long long int Mod = 998244353;
const long double Pi = acos(-1);
const long long int Inf = 4e18;
const long double Eps = 1e-9;
int dx[9] = {0, 1, -1, 0, 0, 1, 1, -1, -1};
int dy[9] = {0, 0, 0, 1, -1, 1, -1, 1, -1};
using namespace std;
#define int long long int
void TestCase (){
int n;
cin >> n;
long double ans = Inf;
vector <int> a(n + 1);
for(int i = 1; i<=n; i++) cin >> a[i];
sort(a.begin() + 1, a.end());
int sum = accumulate(a.begin() + 1, a.begin() + n + 1, 0LL);
ans = (long double)sum / n;
int tn = 0;
for(int i = 1; i<=n; i++){
long double x = (long double)a[i] / 2.0;
long double cur = n * x + sum - tn - (n - i + 1) * a[i];
ans = min(ans, cur / n);
tn += a[i];
}
cout << fixed << setprecision(10) << ans;
}
#undef int
int main(){
IOS;
int T = 1;
// cin >> T;
while(T--){
TestCase();
cout << "\n";
}
return 0;
} |
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
const ll INF = 1LL << 60;
int main(){
string a, b;
cin >> a >> b;
int ai, bi;
ai = (a[0] - '0') + (a[1] - '0') + (a[2] - '0');
bi = (b[0] - '0') + (b[1] - '0') + (b[2] - '0');
if(ai >= bi) cout << ai << endl;
else cout << bi << endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long int lint;
typedef long long int llint;
#define INF 1073741824
#define LINF 4611686018000000000
#define MOD 1000000007
int digsum(int n) {
int ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
int main() {
int a, b;
cin >> a >> b;
cout << max(digsum(a), digsum(b)) << endl;
return 0;
}
|
// Containers
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
// #include "conf.d/say.h"
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define INF 0x3F3F3F3F
#define all(v) v.begin(), v.end()
#define f first
#define s second
#define MOD 1000000007
#define vt(T) vector<T>
#define FOR(i, n) for (int i = 0; i < n; i++)
#define FORUP(i, a, b) for (int i = a; i < b; i++)
#define FORDOWN(i, a, b) for (int i = a; i > b; --i)
#define EACH(e, C) for (auto &e : C)
#define len(v) (int)v.size()
#define PQ(type) priority_queue<type>
#define PQD(type) priority_queue<type, vector<type>, greater<type>>
#define US unordered_set
#define UM unordered_map
typedef map<int, int> mii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef pair<int, pair<int, int>> pipii;
typedef vector<pii> vpii;
template <class T> bool in(const T e, unordered_set<T> s) {
return s.count(e) > 0;
}
template <class T> bool in(const T e, set<T> s) { return s.count(e) > 0; }
template <class K, class V> bool in(const K e, unordered_map<K, V> s) {
return s.count(e) > 0;
}
template <class K, class V> bool in(const K e, map<K, V> s) {
return s.count(e) > 0;
}
int dirs[5] = {-1, 0, 1, 0, -1};
// fast IO
static auto __2333__ = []() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
return 0;
}();
// --------------------------------------------------------
int main() {
int N;
cin >> N;
ll res = 0;
FOR(i, N) {
int a, b;
cin >> a >> b;
res += (ll)(b + a) * (1 + b - a) / 2;
}
cout << res << endl;
} | #include<bits/stdc++.h>
#define mod 1000000007
#define INF 10000000000000001
#define F first
#define S second
#define LB lower_bound
#define UB upper_bound
#define vc vector
#define vll vector<long long>
#define pll pair<long long,long long>
#define pb push_back
#define all(v) v.begin(),v.end()
#define T ll test;cin>>test; while(test--)
#define rep(i,a,n) for(ll i=a;i<(long long)n;++i)
#define repr(i,n,a) for(ll i=n;i>(long long)a;--i)
#define MAX 200005
#define sz(x) (ll)x.size()
#define ins insert
#define mp make_pair
#define int long long
typedef long long ll;
typedef long double ld;
using namespace std;
signed main()
{
ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL);
ll pre[MAX];
memset(pre,0,sizeof(pre));
ll n,w;
cin>>n>>w;
ll s,t,p;
rep(i,0,n)
{
cin>>s>>t>>p;
pre[s]+=p;
pre[t]-=p;
}
ll f=0;
if(pre[0]>w) f=1;
rep(i,1,MAX)
{
pre[i]+=pre[i-1];
if(pre[i]>w) f=1;
}
if(f) cout<<"No\n";
else cout<<"Yes\n";
} |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long int i=1,n,s=0;
cin>>n;
while(s<n)
{
s+=i;
i++;
}
cout<<i-1<<endl;
return 0;
}
| #include <math.h>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, n) for (int i = (l); i < (n); i++)
#define max(p, q) ((p) > (q) ? (p) : (q))
#define min(p, q) ((p) < (q) ? (p) : (q))
using ll = long long;
using P = pair<int, int>;
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T> >;
const ll INF = 1e18 + 1;
const ll mod = 1000000007;
int main()
{
ll n;
cin >> n;
ll ans = 1;
while(2*n>ans*(ans+1))
ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c;cin>>a>>b>>c;
int ans=a+b+c;
int g;
g=min(a,b);
g=min(g,c);
cout << ans-g << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{
long double r, x, y;
cin >> r >> x >> y;
long double cnt = sqrtl(x * x + y * y) / r;
if (cnt < 1) {
// ちょうどrしか動けないため、迂回して2歩
cout << 2 << endl;
} else {
cout << ceil(cnt) << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define req(i,n) for(int i = 1;i <=n;i++)
#define pai 3.14159265358979323846
const int INF = 1001001001;
typedef long long ll;
bool punched[3][3];
//using Graph = vector<vector<int>>;
const int MOD = 1000000007;
typedef pair<int,int> P;
//最大公約数
ll gcd(ll a,ll b){
if (a%b == 0){
return b;
}
else{
return gcd(b,a%b);
}
}
//最小公倍数
ll lcm(ll a,ll b){
return a /gcd(a,b) * b;
}
//素数判定
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
// 素因数分解
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) { ++num; n /= p; }
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
// 10進数から2進数
int binary(int bina){
int ans = 0;
for (int i = 0; bina>0 ; i++)
{
ans = ans+(bina%2)*pow(10,i);
bina = bina/2;
}
return ans;
}
//Union-Find
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for(int i = 0; i < N; i++) par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); //xの根をrx
int ry = root(y); //yの根をry
if (rx == ry) return; //xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] = ry; //xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
ll powmod(ll x,ll y){
ll res=1;
for(ll i=0;i<y;i++){
res=res*x%MOD;
}
return res;
}
bool ok(int v, int b) {
while (v) {
if (v % b == 7) return false;
v /= b;
}
return true;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
int ans = n;
for (int i = 0;i < s.size() - 2;i++) {
//cout << i << endl;
if (s.size()<3) break;
if (s[i]== 'f' && s[i+1] == 'o' && s[i+2] == 'x') {
//ans -= 3;
s.erase(s.begin()+i);
s.erase(s.begin()+i);
s.erase(s.begin()+i);
if (i < 3){
i = -1;
}
else {
i -= 3;
}
}
}
// cout << s << endl;
cout << s.size() << endl;
}
| #include<bits/stdc++.h>
#define x first
#define y second
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mem(x,val) memset(x,val,sizeof x)
#define pii pair<int,int>
#define pb emplace_back
#define ar array
#define int long long
#define FOR(i, a, b) for(int i = a; i < b; i++)
#define M 1000000007
#define wopen(x) freopen((x),"w",stdout)
#define ropen(x) freopen((x),"r",stdin)
using namespace std;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
const int N = 2e5 + 5;
int n, m, top, chose, dp[(1<<18)], group[(1<<18)], st[20];
bitset<20> mat[20];
void init(){
for(int i = 0; i < (1<<n); i++){
top = 0;
for(int j = 0; j < n; j++)
if((i>>j)&1) st[top++] = j;
for(int j = 0; j < top; j++)
for(int k = 0; k < j; k++)
if(mat[st[j]][st[k]] == 0)
goto next;
group[i] = 1;
next:;
}
}
void dfs(int now, int bit){
if(now == top){
if(group[bit]) dp[chose|bit] = min(dp[chose|bit], dp[chose] + 1);
return;
}
dfs(now + 1, bit | (1<<st[now]));
dfs(now + 1, bit);
}
signed main(void){
ios_base::sync_with_stdio(0); cin.tie(0);
cin >> n >> m;
for(int i = 0; i < m; i++){
int a, b;
cin >> a >> b;
a--, b--;
mat[a][b] = mat[b][a] = 1;
}
init();
mem(dp, 0x3f);
dp[0] = 0;
for(int i = 0; i < (1<<n); i++){
top = 0;
for(int j = 0; j < n; j++)
if(((i>>j)&1) == 0) st[top++] = j;
chose = i;
dfs(0, 0);
}
cout << dp[(1<<n)-1];
}
|
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define task "BIGROUP"
#define pll pair<ll, ll>
#define pii pair<pll, ll>
#define fi first
#define se second
using namespace std;
const ll mod = 998244353;
const ll N = 2e5+5;
const int base = 313;
ll n, m, t, k, T, ans, siz, tong, a[N], b[N], c[N];
string s;
vector<ll> adj[N], kq;
ll pw(ll k, ll n)
{
ll total = 1;
for(; n; n >>= 1)
{
if(n & 1)total = total * k % mod;
k = k * k % mod;
}
return total;
}
ll pw1(ll k, ll n)
{
ll total = 1;
for(; n; n >>= 1)
{
if(n & 1)total = total * k % (mod-1);
k = k * k % (mod-1);
}
return total;
}
void ask(int i, int j, int l)
{
cout << i <<" "<< j << " " << l << endl ;
}
void sol()
{
cin >> n;
for(int i = 1; i <= n; i ++)
{
cin >> a[i];
}
sort(a+1 ,a+1+n);
for(int i = 1; i <= n; i ++)
{
ans = (ans + a[i] * a[i] % mod + a[i] * tong % mod) % mod;
tong = (tong * 2 + a[i]) % mod;
}
cout << ans;
}
int main()
{
if(fopen(task".INP", "r"))
{
freopen(task".INP", "r", stdin);
freopen(task".OUT", "w", stdout);
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ntest = 1;
//cin >> ntest;
while(ntest -- > 0)
sol();
}
/*
5 1
5 7
3 3 7
7 4 8
10 5 4
13 4 3
15 2 8
16 5 2
18 3 7
https://codeforces.com/contest/791/problem/E
*/
| #include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
ll n;
ll d[105][105];
double ans;
int main()
{
scanf("%lld", &n);
for(ll i = 0; i < n; i++)
{
for(ll j = 0; j < n; j++)
{
scanf("%1lld", &d[i][j]);
}
}
for(ll k = 0; k < n; k++)
{
for(ll i = 0; i < n; i++)
{
for(ll j = 0; j < n; j++)
{
d[i][j] |= (d[i][k] & d[k][j]);
}
}
}
for(ll i = 0; i < n; i++)
{
ll cnt = 0;
for(ll j = 0; j < n; j++)
{
if(i == j || d[j][i]) cnt++;
}
ans += 1.0 / cnt;
}
printf("%.12f", ans);
return 0;
}
|
#include <iostream>
#include <string>
#include <queue>
using namespace std;
#define SIZE 101
int main()
{
int a, b, c;
cin >> a >> b >> c;
double dp[SIZE][SIZE][SIZE] = { 0 };
dp[a][b][c] = 1;
for (int i = a; i < SIZE; i++) {
for (int j = b; j < SIZE; j++) {
for (int k = c; k < SIZE; k++) {
if (i + j + k <= 1)continue;
if (i > 0 && j != SIZE - 1 && k != SIZE - 1) {
dp[i][j][k] += dp[i - 1][j][k] * (i - 1) / (i + j + k - 1);
}
if (j > 0 && i != SIZE - 1 && k != SIZE - 1) {
dp[i][j][k] += dp[i][j - 1][k] * (j - 1) / (i + j + k - 1);
}
if (k > 0 && j != SIZE - 1 && i != SIZE - 1) {
dp[i][j][k] += dp[i][j][k - 1] * (k - 1) / (i + j + k - 1);
}
}
}
}
double ans = 0;
int first = a + b + c;
for (int i = a; i < SIZE; i++) {
for (int j = b; j < SIZE; j++) {
for (int k = c; k < SIZE; k++) {
if (i == SIZE - 1 || j == SIZE - 1 || k == SIZE - 1) {
ans += dp[i][j][k] * (i + j + k - first);
}
}
}
}
printf("%.8f", ans);
} | #include <iostream>
#include <math.h>
#include <algorithm>
using namespace std;
#define f first
#define s second
#define ll long long
#define mp make_pair
#define ull unsigned long long
#define p push
#define pb push_back
double r, x, y;
int main() {
cin >> r >> x >> y;
double dist = sqrt((x * x) + (y * y));
double ans = dist / r;
int out = 0;
if (ceil(ans)!=ans) {
out = ceil(ans);
}
else {
out = (int)ans;
}
if (r > dist) {
cout << "2\n";
}
else {
cout << out << "\n";
}
} |
//#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
//#include <immintrin.h>
//#include <emmintrin.h>
#include <bits/stdc++.h>
using namespace std;
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
#define me(x) memset(x,0,sizeof(x))
#define IL inline
#define rint register int
inline ll rd(){
ll x=0;char c=getchar();bool f=0;
while(!isdigit(c)){if(c=='-')f=1;c=getchar();}
while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
return f?-x:x;
}
char ss[1<<24],*A=ss,*B=ss;
IL char gc()
{
return A==B&&(B=(A=ss)+fread(ss,1,1<<24,stdin),A==B)?EOF:*A++;
}
template<class T>void maxa(T &x,T y)
{
if (y>x) x=y;
}
template<class T>void mina(T &x,T y)
{
if (y<x) x=y;
}
template<class T>void read(T &x)
{
int f=1,c; while (c=gc(),c<48||c>57) if (c=='-') f=-1; x=(c^48);
while(c=gc(),c>47&&c<58) x=x*10+(c^48); x*=f;
}
const int mo=1e9+7;
ll fsp(int x,int y)
{
if (y==1) return x;
ll ans=fsp(x,y/2);
ans=ans*ans%mo;
if (y%2==1) ans=ans*x%mo;
return ans;
}
struct cp {
ll x,y;
cp operator +(cp B)
{
return (cp){x+B.x,y+B.y};
}
cp operator -(cp B)
{
return (cp){x-B.x,y-B.y};
}
ll operator *(cp B)
{
return x*B.y-y*B.x;
}
int half() { return y < 0 || (y == 0 && x < 0); }
};
const int N=3e5;
struct re{
int a,b,c;
}a[N],b[N];
bool cmp1(re x,re y)
{
return x.a<y.a;
}
bool cmp2(re x,re y)
{
return x.b<y.b;
}
int main()
{
ios::sync_with_stdio(false);
int n;
cin>>n;
int mx1,mx2,mx3,mx4;
rep(i,1,n)
{
cin>>a[i].a>>a[i].b;
b[i].a=a[i].a; a[i].c=b[i].c=i;
b[i].b=a[i].b;
}
sort(a+1,a+n+1,cmp1);
sort(b+1,b+n+1,cmp2);
int ans=0;
if (a[1].c==b[1].c&&a[n].c==b[n].c)
{
ans=max(a[n].a-a[2].a,a[n-1].a-a[1].a);
ans=max(ans,max(b[n].b-b[2].b,b[n-1].b-b[1].b));
} else
{
if (a[n].a-a[1].a>b[n].b-b[1].b)
{
ans=max(max(a[n].a-a[2].a,a[n-1].a-a[1].a),b[n].b-b[1].b);
} else
{
ans=max(max(b[n].b-b[2].b,b[n-1].b-b[1].b),a[n].a-a[1].a);
}
}
cout<<ans<<endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, j, k) for(int i = j; i < k; i++)
#define print(x) cout << x
#define newline cout << endl
#define space cout << ' '
#define INF 1000000007
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
int main(){
ll n;
cin >>n;
vl x(n);
vl y(n);
rep(i,n){
cin >> x[i];
cin >> y[i];
}
rep(i,n){
for(int j=i+1;j<n;j++){
for(int k=j+1;k<n;k++){
ll e=(x[i]-x[j])*(y[k]-y[i])-(y[i]-y[j])*(x[k]-x[i]);
if(!e){
print("Yes");
return 0;
}
}
}
}
print("No");
return 0;
} |
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<bitset>
#include<cmath>
#include<ctime>
#include<queue>
#include<map>
#include<set>
#define int long long
#define lowbit(x) (x&(-x))
#define mp(x,y) make_pair(x,y)
#define lc (x<<1)
#define rc (x<<1|1)
#define fi first
#define se second
#define mid ((l+r)>>1)
#define fan(x) (((x-1)^1)+1)
#define max Max
#define min Min
#define abs Abs
using namespace std;
inline int read()
{
int ans=0,f=1;
char c=getchar();
while(c>'9'||c<'0'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){ans=(ans<<1)+(ans<<3)+c-'0';c=getchar();}
return ans*f;
}
inline void write(int x)
{
if(x<0) putchar('-'),x=-x;
if(x/10) write(x/10);
putchar((char)(x%10)+'0');
}
template<typename T>inline T Abs(T a){return a>0?a:-a;};
template<typename T,typename TT>inline T Min(T a,TT b){return a>b?b:a;}
template<typename T,typename TT> inline T Max(T a,TT b){return a>b?a:b;}
const int mod=998244353;
int n,m,k,ans;
inline int q_pow(int a,int b);
signed main()
{
n=read();m=read();k=read();
if(n==1)
{
printf("%lld\n",q_pow(k,m));
return 0;
}
if(m==1)
{
printf("%lld\n",q_pow(k,n));
return 0;
}
for(int i=1;i<=k;++i)
ans+=((q_pow(i,n)-q_pow(i-1,n)+mod)%mod)*q_pow(k-i+1,m)%mod,ans%=mod;
printf("%lld\n",ans);
return 0;
}
inline int q_pow(int a,int b)
{
int c=1;
while(b)
{
if(b&1) c=a*c%mod;
a=a*a%mod;b>>=1;
}
return c;
} | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
#define sz(x) (int)(x).size()
using namespace std;
const int64_t INV = int64_t(332748118);
const int64_t MOD = int64_t(998244353);
const int mxN = int(5e3) + 5;
int64_t dp[mxN][mxN];
char arr[mxN][mxN];
int h,w,k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> h >> w >> k;
for(int i=0; i<k; i++) {
int r,c; char val;
cin >> r >> c >> val;
arr[r][c] = val;
}
dp[1][1] = 1;
for(int i=1; i<=h; i++)
arr[i][0] = 'X';
for(int j=1; j<=w; j++)
arr[0][j] = 'X';
for(int i=1; i<=h; i++) {
for(int j=1; j<=w; j++) {
if(i==1 && j==1) continue;
switch(arr[i-1][j]) {
case 0:
dp[i][j] += (2 * INV * dp[i-1][j]) % MOD;
break;
case 'X':
case 'D':
dp[i][j] += dp[i-1][j];
break;
}
switch(arr[i][j-1]) {
case 0:
dp[i][j] += (2 * INV * dp[i][j-1]) % MOD;
break;
case 'X':
case 'R':
dp[i][j] += dp[i][j-1];
break;
}
}
}
int times = h * w - k;
int64_t mul = 1;
while(times--) {
mul *= 3;
mul %= MOD;
}
cout << (dp[h][w] * mul) % MOD << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define Yes cout << "Yes" << endl;
#define No cout << "No" << endl;
#define INF INT_MAX
#define LLINF LLONG_MAX
#define MOD 1000000007
#define PI acos(-1)
using ll = long long;
using ull = unsigned long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
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;
}
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> A(N);
rep (i, N) {
cin >> A[i];
}
ll ans = INF;
rep (bit, (1<<(N-1))) {
ll xored = 0;
ll ored = 0;
rep (i, N+1) {
if (i < N) {
ored |= A[i];
}
if ((bit & (1<<i)) || (i == N)) {
xored ^= ored;
ored = 0;
}
}
ans = min(ans, xored);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll MOD = 1000000007;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define REP2(i, x, n) for (ll i = x; i < (n); i++)
#define PR(x) cout << (x) << "\n"
#define PS(x) cout << (x) << " "
#define PRYES(x) PR((x) ? "Yes" : "No")
const long long INF = numeric_limits<long long>::max();
const long long DP_INF = 1 << 29;
template <class T> using arr = vector<vector<T> >;
using vint = vector<int>;
using vll = vector<ll>;
// SourceTest用出力マクロ
#ifdef SOURCE_TEST
#define SPR(x) PR(x)
#define SPS(x) PS(x)
#define STRACE(var) cout << #var << "=" << var << endl;
#define SMAPTRACE(var) \
cout << #var << "=" \
<< "{" << var.first << "," << var.second << "}" << endl;
#else
#define SPR(x) \
{}
#define SPS(x) \
{}
#define STRACE(var) \
{}
#define SMAPTRACE(var) \
{}
#endif
template <class T> void dump(const vector<T>& vec) {
#ifdef SOURCE_TEST
for (ll i = 0; i < vec.size(); ++i) {
cout << vec[i] << ",";
}
cout << endl;
#endif
}
vector<vll> orNums;
int main() {
ll N;
cin >> N;
vll values(N);
REP(i, N) {
cin >> values[i];
}
orNums.resize(N);
vector<vll> xorNums(N);
orNums[0].resize(N);
for (ll s = 0; s < N; ++s) {
orNums[0][s] |= values[s];
}
for (ll i = 1; i < N; ++i) {
orNums[i].resize(N, 0);
for (ll s = 0; s < N; ++s) {
ll n = s + i;
if (n >= N) continue;
orNums[i][s] = orNums[i - 1][s] | orNums[0][n];
}
}
SPR("orList");
for (const auto& ss : orNums) {
dump(ss);
}
struct INFO {
ll value;
ll remainNum;
ll next;
void dump() const {
SPS(value);
SPS(remainNum);
SPR(next);
SPR("---");
}
};
queue<INFO> infos;
for (ll i = 0; i < N; ++i) {
infos.push({orNums[i][0], N - 1 - i, i + 1});
}
ll ans = INF;
while (!infos.empty()) {
auto info = infos.front();
infos.pop();
SPR("------dumpInfomation");
info.dump();
if (info.remainNum == 0) {
ans = min(ans, info.value);
} else {
for (ll i = 0; i < N; ++i) {
ll nextValue = orNums[i][info.next];
ll nextR = info.remainNum - i - 1;
if (nextR >= 0) {
INFO infomation;
infomation.value = info.value ^ nextValue;
infomation.remainNum = nextR;
infomation.next = info.next + 1 + i;
STRACE(i);
STRACE(nextValue);
infomation.dump();
infos.push(infomation);
}
}
}
}
PR(ans);
return 0;
} |
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define rep2(i, a)for(auto i : a)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x, std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll mod = 998244353;
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll co(ll n, ll k) { ll a = 1; rep(i, 1ll, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }
ll modinv(ll a) { ll b = mod, u = 1, v = 0; while (b) { ll t = a / b; a -= t * b; swap(a, b); u -= t * v; swap(u, v); }u %= mod; if (u < 0) u += mod; return u; }
int main() {
int n, m;
cin >> n >> m;
vector<ll> h(n), w(m);
rep(i, 0, n)cin >> h[i];
rep(i, 0, m)cin >> w[i];
sort(all(h));
sort(all(w));
ll ans = 1ll << 60;
ll t = 0;
for (int i = 0; i < n; i += 2) {
auto it = lower_bound(all(w), h[i]);
ll w1 = 1ll << 60, w2 = 1ll << 60;
if (it != w.begin())w1 = *(it - 1);
if (it != w.end())w2 = *it;
ll temp = min(abs(h[i] - w1), abs(h[i] - w2));
t += temp;
if (i == 0) {
for (int j = 1; j < n; j += 2) {
t += h[j + 1] - h[j];
}
}
else {
t -= h[i] - h[i - 1];
t += h[i - 1] - h[i - 2];
}
ans = min(ans, t);
t -= temp;
}
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; (i) < (int)(n); ++(i))
#define REP3(i, m, n) for (int i = (m); (i) < (int)(n); ++(i))
#define REP_R(i, n) for (int i = (int)(n)-1; (i) >= 0; --(i))
#define REP3R(i, m, n) for (int i = (int)(n)-1; (i) >= (int)(m); --(i))
#define ALL(x) ::std::begin(x), ::std::end(x)
using namespace std;
const int INF = 1001001001;
auto solve(int64_t A, int64_t B, int64_t W) {
// TODO: edit here
W *= 1000;
int l = 0, r = 0, ans_min = INF, ans_max = -1, cnt = 0;
while (1) {
cnt++;
l += A;
r += B;
if (l <= W && W <= r) {
ans_min = min(ans_min, cnt);
ans_max = max(ans_max, cnt);
}
if (W < l) break;
}
if (ans_min == INF && ans_max == -1) {
cout << "UNSATISFIABLE" << endl;
exit(0);
}
vector<int> ans = {ans_min, ans_max};
return ans;
}
// generated by oj-template v4.7.2 (https://github.com/online-judge-tools/template-generator)
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
constexpr char endl = '\n';
int64_t A, B, W;
cin >> A >> B >> W;
auto ans = solve(A, B, W);
REP (i, 2) { cout << ans[i] << endl; }
cout << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using V = vector<int>;
using VV = vector<V>;
using VVV = vector<VV>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VVVL = vector<VVL>;
template<class T> using VE = vector<T>;
template<class T> using P = pair<T, T>;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define REP(i,k,n) for(int i=(k);i<(n);i++)
#define all(a) (a).begin(),(a).end()
#define output(x,y) cout << fixed << setprecision(y) << x << endl;
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) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
ll upper = MOD + MOD;
ll under = -upper;
ll UPPER = MOD * MOD;
ll UNDER = -UPPER;
const long double pi = 3.141592653589793;
int main() {
int n, m;
cin >> n >> m;
if (n == m || n == m + 1 && m != 0 || m < 0) {
cout << -1 << endl;
return 0;
}
V a, b;
m++;
int pos = 2;
while (m) {
m--;
a.push_back(pos), b.push_back(pos + 1);
pos += 2;
}
a.push_back(1), b.push_back(pos);
int N = n - a.size();
int over = 100000000;
while (N > 0) {
N--;
a.push_back(over), b.push_back(over + 1);
over += 2;
}
rep(i, n) {
cout << a[i] << " " << b[i] << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5;
int main(){
vector<pair<int,int>>ans;
int n,m;cin>>n>>m;
int x=m;
if((m>0&&x+2>n)||m<0){
cout<<"-1\n";
return 0;
}
ans.emplace_back(1,4*x+3);
for(int i=0;i<n-1;i++){
ans.emplace_back(4*i+2,4*i+4);
}
for(auto& i:ans){
cout<<i.first<<' '<<i.second<<'\n';
}
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
int32_t main()
{
int n;
cin>>n;
vector<int> a(n),b(n);
for(auto& x:a)
cin>>x;
for(auto& x:b)
cin>>x;
reverse(a.begin(),a.end());
priority_queue<int,vector<int>,greater<int>> q;
for(int i=0;i<n;i++)
{
q.push(a[i]);
q.push(b[i]);
q.pop();
}
int res=0;
while(!q.empty())
{
res+=q.top();
q.pop();
}
cout<<res;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// template {{{
#define range(i, l, r) for (int i = (int)(l); i < (int)(r); (i) += 1)
#define rrange(i, l, r) for (int i = (int)(r) - 1; i >= (int)(l); (i) -= 1)
#define whole(f, x, ...) ([&](decltype((x)) container) { return (f)( begin(container), end(container), ## __VA_ARGS__); })(x)
#define rwhole(f, x, ...) ([&](decltype((x)) container) { return (f)( rbegin(container), rend(container), ## __VA_ARGS__); })(x)
#define debug(x) cerr << "(" << __LINE__ << ")" << #x << ": " << (x) << endl
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
constexpr i32 mod = 1e9 + 7;
// constexpr i32 mod = 998244353;
constexpr i32 inf = 1001001001;
constexpr i64 infll = 1001001001001001001ll;
constexpr i32 dx[] = {0, -1, 1, 0, -1, 1, -1, 1};
constexpr i32 dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};
struct IoSetup { IoSetup(i32 x = 15){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(x); cerr << fixed << setprecision(x); } } iosetup;
template <typename T = i64> T input() { T x; cin >> x; return x; }
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) { range(i, 0, v.size()) { os << v[i] << (i + 1 != (int)v.size() ? " " : ""); } return os; }
template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.first >> p.second; return is; }
template <typename T> vector<T> make_vector(size_t a, T b) { return vector<T>(a, b); }
template <typename... Ts> auto make_vector(size_t a, Ts... ts) { return vector<decltype(make_vector(ts...))>(a, make_vector(ts...)); }
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); }
// }}}
void solve() {
int n = input();
vector< int > as(n), bs(n);
cin >> as >> bs;
whole(reverse, as);
vector< int > vs;
for (auto &a : as) vs.emplace_back(a);
for (auto &b : bs) vs.emplace_back(b);
whole(sort, vs);
range(i, 0, n) {
if (as[i] > bs[i]) swap(as[i], bs[i]);
}
i64 ans = 0;
using P = pair<i64, i64>;
priority_queue<P, vector< P >, greater< P >> pq;
range(i, 0, n) {
if (not pq.empty() and pq.top().first < as[i]) {
ans += bs[i] + as[i] - pq.top().first;
pq.emplace(pq.top().second, infll);
pq.emplace(as[i], bs[i]);
pq.pop();
} else {
ans += bs[i];
pq.emplace(bs[i], infll);
}
}
cout << ans << endl;
}
signed main() {
solve();
}
|
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define ROF(i, a, b) for (int i = a; i >= b; --i)
#define NEXT(i, u) for (int i = h[u]; i; i = e[i].u)
const int INF = 2e9;
const int K = 1e5 + 7;
int Max(const int &a, const int &b) {return a > b ? a : b;}
int Min(const int &a, const int &b) {return a > b ? b : a;}
int sum[20], tot[20];
int k, n;
double sy;
double ans, sm;
char s[20], t[20];
int po(int x){
int ans = 1;
FOR (i, 1, x) ans *= 10;
return ans;
}
int main(){
scanf("%d", &k);
sy = 9 * k - 8;
scanf(" %s %s", s, t);
n = strlen(s);
FOR (i, 0, 3){
int c = s[i] - '0', cc = t[i] - '0';
++sum[c];
++tot[cc];
}
FOR (i, 1, 9){
FOR (j, 1, 9){
if (i == j){
if (sum[i] + tot[j] + 2 <= k) ++sum[i], ++tot[j];
else continue;
}
else {
if (sum[i] + tot[i] + 1 <= k && sum[j] + tot[j] + 1 <= k) ++sum[i], ++tot[j];
else continue;
}
int sc1 = 0, sc2 = 0;
FOR (l, 1, 9){
sc1 += l * po(sum[l]);
sc2 += l * po(tot[l]);
}
--sum[i];
--tot[j];
if (sc1 > sc2){
if (i == j) ans += (1.0 * (1.0 * k - sum[i] - tot[i]) / sy) * (1.0 * (1.0 * k - sum[j] - tot[j] - 1) / (sy - 1));
else ans += (1.0 * (1.0 * k - sum[i] - tot[i]) / sy) * (1.0 * (1.0 * k - sum[j] - tot[j]) / (sy - 1));
}
}
}
printf("%.16lf\n", ans);
return 0;
} | #include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <set>
#include <vector>
#define ALL(container) container.begin(), container.end()
using namespace std;
using ll = long long;
int score(const string &s) {
auto cnt = vector<int>(10);
iota(ALL(cnt), 0);
for (auto c : s) cnt[c - '0'] *= 10; // 所持カードの点数を10^ci倍していく
return accumulate(ALL(cnt), 0); // 点数の総和を求める
}
int main() {
ll k{};
string s{}, t{};
cin >> k >> s >> t;
auto cards = vector<ll>(10, k); // カードの枚数を保持する（インデックス0は使用しない）
for (const auto &c : s + t) {
if (c != '#') --cards[c - '0'];
}
ll win = 0; // 高橋くんが勝つ組み合わせの総和
for (int si = 1; si <= 9; ++si) {
for (int ti = 1; ti <= 9; ++ti) {
s.back() = '0' + si;
t.back() = '0' + ti;
if (score(s) <= score(t)) continue; // 青木くんが勝つ、もしくは引き分ける場合
win += cards[si] * (cards[ti] - (si == ti)); // 5枚目のカードの残り枚数から、そのカードの組み合わせを求める
}
}
ll p = (9 * k - 8) * (9 * k - 9); // 組み合わせの総数
cout << fixed << setprecision(5) << static_cast<double>(win) / p << endl;
return 0;
}
|
// C - Collinearity
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ll = long long;
#define rp(i,s,e) for(int i=(int)(s);i<(int)(e);++i)
int main(){
int n; cin>>n;
vi X, Y;
rp(i, 0, n){
int x, y; cin>>x>>y;
X.push_back(x);
Y.push_back(y);
}
rp(a, 0, n-1) rp(b, a+1, n) rp(c, 0, n){
if(c == a || c == b) continue;
int dx = X[b] - X[a];
int dy = Y[b] - Y[a];
ll dx_y = dx*Y[c];
ll dx_fx = dy*(X[c] - X[a]) + dx*Y[a];
if(dx_y == dx_fx){
puts("Yes");
return 0;
}
}
puts("No");
}
| #include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);++i)
#define all(a) (a).begin(),(a).end()
#define dunk(a) cout << (a) << endl
#define rall(a) (a).rbegin(),(a).rend()
const int INF = 2e9;
using namespace std;
using Graph = vector<vector<int>>;
typedef pair<int,int> P;
typedef long long ll;
int main(){
int n, k, m; cin >> n >> k >> m;
int sum = 0;
vector<int> a(n);
rep(i,n-1){
cin >> a[i];
sum+= a[i];
}
if(n*m < sum) dunk(0);
else if(n*m > sum + k) dunk(-1);
else dunk(n*m-sum);
}
|
#include<bits/stdc++.h>
using namespace std;
const int N = 105;
int n, k, MOD;
void sub(int& x, int y){
x-=y;
if(x<0)x+=MOD;
}
void add(int& x, int y){
x+=y;
if(x>MOD)x-=MOD;
}
int dp[N][N*N*N];
void solve(){
dp[0][0]=1;
for(int i=1;i<=n;++i){
int up=k*(i+1)*i/2;
for(int j=0;j<=up;++j){
dp[i][j]=dp[i-1][j];
if(j>=i){
add(dp[i][j],dp[i][j-i]);
}
}
for(int j=up;j>=(k+1)*i;--j){
sub(dp[i][j],dp[i][j-(k+1)*i]);
}
}
}
void getAns(){
for(int i=1;i<=n;++i){
int ans=0;
int l=i-1, r=n-i;
int up=min(k*l*(l+1)/2,k*r*(r+1)/2);
for(int j=0;j<=up;++j){
add(ans,1ll*dp[l][j]*dp[r][j]%MOD);
}
ans=1ll*ans*(k+1)%MOD;
add(ans,-1);
cout<<ans<<endl;
}
}
int main(){
cin>>n>>k>>MOD;
solve();
getAns();
return 0;
}
| #line 1 "main.cpp"
/**
* @title Template
*/
#include <iostream>
#include <algorithm>
#include <utility>
#include <numeric>
#include <vector>
#include <array>
#include <cassert>
#include <iomanip>
#line 2 "/Users/kodamankod/Desktop/cpp_programming/Library/other/range.cpp"
#line 4 "/Users/kodamankod/Desktop/cpp_programming/Library/other/range.cpp"
class range {
struct iter {
std::size_t itr;
constexpr iter(std::size_t pos) noexcept: itr(pos) { }
constexpr void operator ++ () noexcept { ++itr; }
constexpr bool operator != (iter other) const noexcept { return itr != other.itr; }
constexpr std::size_t operator * () const noexcept { return itr; }
};
struct reviter {
std::size_t itr;
constexpr reviter(std::size_t pos) noexcept: itr(pos) { }
constexpr void operator ++ () noexcept { --itr; }
constexpr bool operator != (reviter other) const noexcept { return itr != other.itr; }
constexpr std::size_t operator * () const noexcept { return itr; }
};
const iter first, last;
public:
constexpr range(std::size_t first, std::size_t last) noexcept: first(first), last(std::max(first, last)) { }
constexpr iter begin() const noexcept { return first; }
constexpr iter end() const noexcept { return last; }
constexpr reviter rbegin() const noexcept { return reviter(*last - 1); }
constexpr reviter rend() const noexcept { return reviter(*first - 1); }
};
/**
* @title Range
*/
#line 2 "/Users/kodamankod/Desktop/cpp_programming/Library/other/rev.cpp"
#include <type_traits>
#include <iterator>
#line 6 "/Users/kodamankod/Desktop/cpp_programming/Library/other/rev.cpp"
template <class T>
class rev_impl {
public:
using iterator = decltype(std::rbegin(std::declval<T>()));
private:
const iterator M_begin;
const iterator M_end;
public:
constexpr rev_impl(T &&cont) noexcept: M_begin(std::rbegin(cont)), M_end(std::rend(cont)) { }
constexpr iterator begin() const noexcept { return M_begin; }
constexpr iterator end() const noexcept { return M_end; }
};
template <class T>
constexpr decltype(auto) rev(T &&cont) {
return rev_impl<T>(std::forward<T>(cont));
}
/**
* @title Reverser
*/
#line 17 "main.cpp"
using i32 = std::int32_t;
using i64 = std::int64_t;
using u32 = std::uint32_t;
using u64 = std::uint64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr i32 inf32 = (u32) ~0 >> 2;
constexpr i64 inf64 = (u64) ~0 >> 2;
template <class T>
using Vec = std::vector<T>;
using f80 = long double;
int main() {
usize N, M, K;
std::cin >> N >> M >> K;
Vec<bool> ok(N + 1, true);
while (K--) {
usize i;
std::cin >> i;
ok[i] = false;
}
Vec<std::pair<f80, f80>> dp(N + 1);
std::pair<f80, f80> sum;
const f80 invM = 1.0L / (double) M;
for (auto i: rev(range(0, N))) {
if (!ok[i]) {
dp[i].first = 1.0L;
}
else {
dp[i].first = sum.first * invM;
dp[i].second = sum.second * invM + 1;
}
sum.first += dp[i].first;
sum.second += dp[i].second;
if (i + M <= N) {
sum.first -= dp[i + M].first;
sum.second -= dp[i + M].second;
}
}
std::cout << std::fixed << std::setprecision(10);
if (std::abs(1.0L - dp[0].first) < 1e-9) {
std::cout << -1 << '\n';
}
else {
std::cout << dp[0].second / (1.0L - dp[0].first) << '\n';
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <unordered_set>
#define ll long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define P pair<ll, ll>
using namespace std;
const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x=0):x((x%mod+mod)%mod){}
mint operator-() const { return mint(-x);}
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod-a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this;}
mint operator+(const mint a) const { return mint(*this) += a;}
mint operator-(const mint a) const { return mint(*this) -= a;}
mint operator*(const mint a) const { return mint(*this) *= a;}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t>>1);
a *= a;
if (t&1) a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod-2);}
mint& operator/=(const mint a) { return *this *= a.inv();}
mint operator/(const mint a) const { return mint(*this) /= a;}
};
istream& operator>>(istream& is, mint& a) { return is >> a.x;}
ostream& operator<<(ostream& os, const mint& a) { return os << a.x;}
int main(){
int n, m, k; cin >> n >> m >> k;
mint ans = 0, sum = 0;
for(int i = 1; i <= k; i++){
mint a = i, b = k-i+1;
mint x = a.pow(n) - (a-1).pow(n);
mint y = b.pow(m);
if(n == 1){
y = mint(k).pow(m) - mint(k-i).pow(m);
y -= sum;
sum += y;
}
if(m == 1) y = 1;
ans += x * y;
// cout << i << "-------------" << endl;
// cout << x << "," << y << endl;
// cout << ans << endl;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// 2の27乗＝１億３千万
#define rep(i, n, N) for (int i = n; i < (int)(N); i++)
#define ascending(array) sort(array.begin(), array.end());
#define descending(array) sort(array.rbegin(), array.rend());
#define log(name, message) cout << name << " = " << message << endl
#define out(content) cout << content << endl
#define max(array) *max_element(array.begin(), array.end())
#define min(array) *min_element(array.begin(), array.end())
int main() {
int n;
string s;
int q;
cin >> n >> s >> q;
vector<int> t(q), a(q), b(q);
rep(i, 0, q) { cin >> t[i] >> a[i] >> b[i]; }
bool reverse = false;
rep(i, 0, q) {
if (t[i] == 1) {
if (reverse) {
if (a[i] > n) {
a[i] = a[i] - n;
} else {
a[i] = a[i] + n;
}
if (b[i] > n) {
b[i] = b[i] - n;
} else {
b[i] = b[i] + n;
}
}
int order1 = a[i] - 1;
int order2 = b[i] - 1;
string first = {s[order1]};
string second = {s[order2]};
int last = s.size() - 1;
string test = {s[last]};
s.pop_back();
s += test;
s.replace(order1, 1, second);
s.replace(order2, 1, first);
} else {
reverse = !reverse;
}
}
if (reverse) {
s = s.substr(n) + s.substr(0, n);
}
out(s);
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int inf=1e18+3;
const int mix=1e6+5;
int n,m,fx,ty,cn;
int hea[mix],nxt[mix],tor[mix];
int len[mix],kai[mix],dis[mix];
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > q;
bool vis[mix];
inline void Build(){
int a, b, t, k;
scanf("%lld%lld%lld%lld", &a, &b, &t, &k);
nxt[++cn]=hea[a],tor[hea[a]=cn]=b,len[cn]=t,kai[cn]=k;
nxt[++cn]=hea[b],tor[hea[b]=cn]=a,len[cn]=t,kai[cn]=k;
}
#undef int
int main() {
#define int long long
scanf("%lld%lld%lld%lld", &n, &m, &fx, &ty);
for(int i=1;i<=m;++i)Build();
for(int i=1;i<=n;++i)dis[i]=inf;
q.push(make_pair(dis[fx]=0,fx));
while(!q.empty()){
int x=q.top().second;
q.pop();
if(vis[x])continue;
for(int t,i=hea[x];i;i=nxt[i])
if(!vis[t=tor[i]]){
int tim=dis[x]+kai[i]-(dis[x]+kai[i]-1)%kai[i]-1+len[i];
if(tim<dis[t])q.push(make_pair(dis[t]=tim,t));
}
}
printf("%lld\n", dis[ty]<inf?dis[ty]:-1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long i64;
typedef unsigned long long ui64;
typedef vector<i64> vi;
typedef vector<vi> vvi;
typedef pair<i64, i64> pi;
#define pb push_back
#define sz(a) i64((a).size())
#define all(c) (c).begin(), (c).end()
#define REP(s, e, i) for(i=(s); i < (e); ++i)
inline void RI(i64 &i) {scanf("%lld", &(i));}
inline void RVI(vi &v) { for(i64 i=0;i<sz(v);++i) { RI(v[i]); } }
inline void RVVI(vvi &vv) { for(i64 i=0;i<sz(vv);++i) { RVI(vv[i]); } }
#define BUF_LENGTH 1000000
inline void RS(string &s) {static char buf[BUF_LENGTH]; scanf("%s", buf); s = buf;}
template<typename T> inline bool IN(T &S, const typename T::key_type &key) {
return S.find(key) != S.end();
}
int main(int argc, char *argv[]) {
i64 i, j, k;
i64 N, M, K;
cin >> N >> M >> K;
unordered_set<i64> A;
REP(0, K, i) {
i64 a;
cin >> a;
A.insert(a);
}
for(auto a: A) {
bool f = true;
REP(a, a+M, i) {
if(!IN(A, i)) {
f = false;
}
}
if(f) {
printf("-1\n");
return 0;
}
}
vector<double> a(N+M+1), b(N+M+1);
REP(N, N+M+1, i) {
a[i] = 0;
b[i] = 0;
}
double b_sum = 0;
double a_sum = 0;
for(j=N-1;j>=0;--j) {
if(IN(A, j)) {
b[j] = 0;
a[j] = 1;
}
else {
b[j] = b_sum / M + 1;
a[j] = a_sum / M;
}
b_sum -= b[j+M];
b_sum += b[j];
a_sum -= a[j+M];
a_sum += a[j];
}
printf("%.10f\n", double(b[0]) / double(1 - a[0]));
/*
REP(0, N+M+1, i) {
cerr << a[i] << " " << b[i] << endl;
}
*/
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1000000010
#define EPS 1e-9
#define F first
#define S second
#define debug(x) cout<<x<<endl;
#define repi(i,x,n) for(int i=x;i<n;i++)
#define rep(i,n) repi(i,0,n)
#define lp(i,n) repi(i,0,n)
#define repn(i,n) for(int i=n;i>=0;i--)
#define int long long
#define endl "\n"
typedef pair<int,int> PII;
typedef pair<int,string> PIS;
typedef pair<string,int> PSI;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int h,w;
cin>>h>>w;
char mp[h][w];
rep(i,h){
rep(j,w){
cin>>mp[i][j];
}
}
int ans=0;
rep(i,h){
rep(j,w){
if(mp[i][j]=='.'){
if(i!= h-1 && mp[i+1][j]=='.') ans++;
if(j!= w-1 && mp[i][j+1]=='.') ans++;
}
}
}
cout<<ans<<endl;
return 0;
}
| //author: hitch_hiker42;
#include<bits/stdc++.h>
using namespace std;
//solution:
#define int int64_t
#define span(a) begin(a), end(a)
void hike() {
int n, k; cin >> n >> k;
int cost[n + 1][n + 1];
for(int i = 1; i <= n; ++i) {
for(int j = 1; j <= n; ++j) cin >> cost[i][j];
}
vector<int> path(n - 1);
iota(span(path), 2);
int count = 0;
do {
int i = 1, sum = 0;
for(int& j: path) {
sum += cost[i][j], i = j;
}
sum += cost[i][1];
count += (sum == k);
} while(next_permutation(span(path)));
cout << count << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr); cout.tie(nullptr);
int t = 1; //cin >> t;
while(t--) hike();
return 0;
} //farewell, until we meet again.. |
#include <bits/stdc++.h>
#define DEBUG if(0)
#define lli __int128
#define ldouble long double
using namespace std;
/*
(2x + 2y)n + x <= t < (2x + 2y)n + x + y
range = y (max 500)
(p + q)n + p <= t < (p + q)(n + 1)
range = q (max 500)
try all combinations of mod (500^2)
t - (2x + 2y)n - x == remY
t - (2x + 2y)n = remY + x
t = remY + x + (2x + 2y)n1
t - (p + q)n - p == remQ
t - (p + q)n = remQ + p
t = remQ + p + (p + q)n2
remQ + p + (p + q)n2 = remY + x + (2x + 2y)n1
(p + q)n2 - (2x + 2y)n1 = remY + x - remQ - p
*/
lli read() {
lli x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void print(lli x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
lli abslol(lli num)
{
return num < 0 ? -num : num;
}
lli gcd(lli a, lli b, lli& x, lli& y)
{
if (b == 0) {
x = 1;
y = 0;
return a;
}
lli x1, y1;
lli d = gcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
bool find_any_solution(lli a, lli b, lli c, lli &x0, lli &y0, lli &g)
{
g = gcd(abslol(a), abslol(b), x0, y0);
if (c % g) {
return false;
}
x0 *= c / g;
y0 *= c / g;
if (a < 0) x0 = -x0;
if (b < 0) y0 = -y0;
return true;
}
const lli inf = LONG_LONG_MAX;
lli x, y, p, q;
lli findMinSolution(lli remY, lli remQ)
{
// t - (2x + 2y)n - x == remY
// t - (2x + 2y)n = remY + x
// t = remY + x + (2x + 2y)x0
// t - (p + q)n - p == remQ
// t - (p + q)n = remQ + p
// t = remQ + p + (p + q)y0
// remQ + p + (p + q)y0 = remY + x + (2x + 2y)x0
// -(2x + 2y)x0 + (p + q)y0 = remY + x - remQ - p
lli x0, y0, g;
lli a = -(2*x + 2*y), b = p + q, c = remY + x - remQ - p;
if (find_any_solution(a, b, c, x0, y0, g))
{
lli t1 = remY + x + (2*x + 2*y)*x0, t2 = remQ + p + (p + q)*y0;
bool isNegative = a / g < 0;
// lli lo = 0, hi = 1e18;
// while (lo < hi)
// {
// lli mid = (lo + hi + 1) >> 1;
// if ((y0 + mid*(a / g)) != 0 && LONG_LONG_MAX / abslol(y0 + mid*(a / g)) < (p + q))
// hi = mid - 1;
// else
// lo = mid;
// }
// lli maxHi = lo;
// lo = -1e18, hi = 0;
// while (lo < hi)
// {
// lli mid = (lo + hi) >> 1;
// if ((y0 + mid*(a / g)) != 0 && LONG_LONG_MAX / abslol(y0 + mid*(a / g)) < (p + q))
// lo = mid + 1;
// else
// hi = mid;
// }
// lli minLo = lo;
lli lo = -1e18, hi = 1e18;
while (lo < hi)
{
lli mid = (lo + hi + isNegative) >> 1;
lli e = remQ + p + (p + q)*(y0 + mid*(a / g));
// DEBUG printf("\t\t%lld %lld\n", mid, e);
if (isNegative)
{
if (e >= 0) lo = mid;
else hi = mid - 1;
}
else
{
if (e >= 0) hi = mid;
else lo = mid + 1;
}
}
x0 -= lo * b / g;
y0 += lo * a / g;
// DEBUG printf("\t%lld %lld - %lld %lld | %lld %lld\n", remY, remQ, t1, t2, 0LL, b / g);
return remQ + p + (p + q)*y0;
}
else
return inf;
}
int main()
{
int t; scanf("%d", &t);
for (int tt = 1; tt <= t; tt++)
{
// scanf("%lld %lld %lld %lld", &x, &y, &p, &q);
x = read();
y = read();
p = read();
q = read();
lli ans = inf;
for (int i = 0; i < y; i++)
for (int j = 0; j < q; j++)
ans = min(ans, findMinSolution(i, j));
if (ans == inf) printf("infinity\n");
else
{
print(ans);
printf("\n");
}
}
return 0;
} | #include <sstream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <utility>
#include <set>
#include <tuple>
#include <cctype>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;
using ll = long long;
const ll INF = __LONG_LONG_MAX__/2;
inline long long mod(long long a, long long m) {
return (a % m + m) % m;
}
tuple<ll, ll, ll> extGCD(ll a, ll b){
if(b==0){
return {1, 0, a};
}
auto [y, x, xygcd] = extGCD(b, a%b);
y -= a/b * x;
return {x, y, xygcd};
}
pair<ll, ll> ChineseRem(pair<ll, ll>x, pair<ll, ll>y){
auto [b1, m1] = x;
auto [b2, m2] = y;
auto [p, q, mgcd] = extGCD(m1, m2);
if((b2-b1)% mgcd !=0) return make_pair(0, -1);
ll m_lcm = m1 * (m2/mgcd);
ll tmp = (b2 - b1) / mgcd * p % (m2/mgcd);
ll r = mod(b1 + m1 * tmp, m_lcm);
return make_pair(r, m_lcm);
}
void solve(int X, int Y, int P, int Q){
ll ans = INF;
for (int i = X; i < X + Y; i++)
{
for (int j = P; j < P + Q; j++)
{
auto [t, lcm] = ChineseRem({i, 2*X+2*Y}, {j, P+Q});
if(lcm == -1) continue;
ans = min(ans, t);
}
}
if(ans==INF) cout << "infinity" << endl;
else cout << ans << endl;
}
int main(){
int T; cin >> T;
while(T--){
int X, Y, P, Q; cin >> X >> Y >> P >> Q;
solve(X, Y, P, Q);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a,x) for (auto& a : x)
#define uid(a, b) uniform_int_distribution<int>(a, b)(rng)
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const int MX = 100001;
void solve(){
int a,b; cin>>a>>b;
int ans;
a = a+b;
if(a>= 15 && b >= 8) ans=1;
else if(a>= 10 && b >= 3) ans=2;
else if(a>= 3) ans=3;
else ans=4;
cout<<ans<<"\n";
// int a, b;
// cin >> a >> b;
// a = a + b;
// int ans;
// if(a >= 15 && b >= 8) ans = 1;
// else if(a >= 10 && b >= 3) ans = 2;
// else if(a >= 3) ans = 3;
// else ans = 4;
// cout << ans << endl;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll T = 1;
//cin>>T;
while(T--) solve();
return 0;
} | #include<bits/stdc++.h>
#define ll long long
#define ff first
#define ss second
const int mod=1000000007;
using namespace std;
void A(){
int a,b;cin>>a>>b;
int x=0;
if(b>=8&&a+b>=15){cout<<1;return;}
if(b>=3&&a+b>=10){cout<<2;return;}
if(a+b>=3){cout<<3;return;}
cout<<4;
}
void B(){
}
void C(){
}
void D(){
}
int main(){
A();
// B();
// C();
// D();
} |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define T int t; cin>>t; while(t--)
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL)
#define PI 3.141592653589793238462643383
#define pb push_back
#define all(s) s.begin(),s.end()
int main (){
fast;
int h,w;
cin>>h>>w;
string arr[h];
for(int i=0;i<h;i++){
cin>>arr[i];
}
int ans = 0;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(arr[i][j] == '.'){
if(j+1 < w and arr[i][j+1] =='.') ans++;
if(i+1 < h and arr[i+1][j] == '.') ans++;
}
}
}
cout<<ans<<endl;
} | /*************************************************************************
> File Name: 1.cpp
> Author: Knowledge_llz
> Mail: [email protected]
> Blog: https://blog.csdn.net/Pig_cfbsl
> Created Time: 2020/10/10 20:03:44
************************************************************************/
#include<bits/stdc++.h>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define pb push_back
#define pr pair<int,int>
#define fi first
#define se second
#define LL long long
using namespace std;
int read(){
char x=getchar(); int u=0,fg=0;
while(!isdigit(x)){ if(x=='-') fg=1; x=getchar(); }
while(isdigit(x)){ u=(u<<3)+(u<<1)+(x^48); x=getchar(); }
return fg?-u:u;
}
int n,m,ans=0;
char s[250][250];
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.in", "r", stdin);
freopen("output.out", "w", stdout);
#endif
n=read(); m=read();
For(i,1,n) scanf("%s",s[i]+1);
For(i,1,n) For(j,1,m){
if(s[i][j]=='.'){
if(s[i+1][j]=='.') ++ans;
if(s[i][j+1]=='.') ++ans;
}
}
printf("%d\n",ans);
return 0;
}
|
//****************************Template Begins****************************//
// Header Files
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<utility>
#include<set>
#include<unordered_set>
#include<list>
#include<iterator>
#include<deque>
#include<queue>
#include<stack>
#include<set>
#include<bitset>
#include<random>
#include<map>
#include<unordered_map>
#include<stdio.h>
#include<complex>
#include<math.h>
#include<cstring>
#include<chrono>
#include<string>
// Header Files End
using namespace std;
#define HARI ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define umap unordered_map
#define uset unordered_set
#define lb lower_bound
#define ub upper_bound
#define fo(i,a,b) for(i=a;i<=b;i++)
#define all(v) (v).begin(),(v).end()
#define all1(v) (v).begin()+1,(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define allr1(v) (v).rbegin()+1,(v).rend()
#define sort0(v) sort(all(v))
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define max3(a,b,c) max(max((a),(b)),(c))
#define max4(a,b,c,d) max(max((a),(b)),max((c),(d)))
#define min3(a,b,c) min(min((a),(b)),(c))
#define min4(a,b,c,d) min(min((a),(b)),min((c),(d)))
#define pb push_back
#define ppb pop_back
#define mkp make_pair
#define inf 9999999999999
const ll mod = 1e9 + 7;
ll inv(ll i) {if (i == 1) return 1; return (mod - ((mod / i) * inv(mod % i)) % mod) % mod;}
ll mod_mul(ll a, ll b) {a = a % mod; b = b % mod; return (((a * b) % mod) + mod) % mod;}
ll mod_add(ll a, ll b) {a = a % mod; b = b % mod; return (((a + b) % mod) + mod) % mod;}
ll gcd(ll a, ll b) { if (b == 0) return a; return gcd(b, a % b);}
ll ceil_div(ll a, ll b) {return a % b == 0 ? a / b : a / b + 1;}
ll pwr(ll a, ll b) {a %= mod; ll res = 1; while (b > 0) {if (b & 1) res = res * a % mod; a = a * a % mod; b >>= 1;} return res;}
//****************************Template Ends*******************************//
int main() {
HARI;
#ifndef ONLINE_JUDGE
freopen("input.txt" , "r" , stdin);
freopen("output.txt", "w", stdout);
#endif
ll t, n, i, j, ans, temp, sum;
string sans;
t = 1;
// cin >> t;
while (t--)
{
sans = "NO";
ans = temp = sum = 0;
cin >> n;
vll a(n + 1, 0), psum(n + 1, 0);
fo(i, 1, n)
{
cin >> a[i];
psum[i] = psum[i - 1] + a[i];
}
vector<vll>dp(n + 1, vll(n + 1, 0));
vector<vll>pre(n + 1, vll(n + 1, -1));
vector<vll>idx(n + 1, vll(n + 1, -1));
fo(i, 1, n)
{
fo(j, 1, n)
{
if (j == 1)
{
idx[i][j] = i - 1;
}
else idx[i][j] = pre[j][psum[i] % j];
pre[j][psum[i] % j] = i;
}
}
dp[0][0] = 1;
fo(i, 1, n)
{
fo(j, 1, n)
{
temp = idx[i][j];
if (temp == -1)continue;
dp[i][j] = mod_add(dp[temp][j - 1], dp[temp][j]);
}
}
fo(i, 1, n)
{
ans = mod_add(ans, dp[n][i]);
}
cout << ans;
}
return 0;
}
| #include<bits/stdc++.h>
#define int long long
const int p=1e9+7;
using namespace std;
int n,a[4000],sum[4000],f[3008][3008],cnt[3008][3008],ans;
signed main() {
scanf("%lld",&n);
for(int i=1; i<=n; i++) {
scanf("%lld",&a[i]);
sum[i]=sum[i-1]+a[i];
}
cnt[1][0]=1;
for(int i=1; i<=n; i++) {
for(int j=1; j<=i; j++) {
f[i][j]+=cnt[j][sum[i]%j];
f[i][j]%=p;
}
for(int j=1; j<=i; j++) {
cnt[j+1][sum[i]%(j+1)]+=f[i][j];
}
}
for(int i=1; i<=n; i++)
ans=(ans+f[n][i])%p;
printf("%lld\n",ans);
return 0;
} |
#include <bits/stdc++.h>
#define ADD(a, b) a = (a + ll(b)) % mod
#define MUL(a, b) a = (a * ll(b)) % mod
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define rep(i, a, b) for(int i = int(a); i < int(b); i++)
#define rer(i, a, b) for(int i = int(a) - 1; i >= int(b); i--)
#define all(a) (a).begin(), (a).end()
#define sz(v) (int)(v).size()
#define pb push_back
#define sec second
#define fst first
#define debug(fmt, ...) Debug(__LINE__, ":", fmt, ##__VA_ARGS__)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<int, pi> ppi;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> mat;
typedef complex<double> comp;
void Debug() {cerr << '\n'; }
template<class FIRST, class... REST>void Debug(FIRST arg, REST... rest){
cerr<<arg<<" ";Debug(rest...);}
template<class T>ostream& operator<<(ostream& out,const vector<T>& v) {
out<<"[";if(!v.empty()){rep(i,0,sz(v)-1)out<<v[i]<<", ";out<<v.back();}out<<"]";return out;}
template<class S, class T>ostream& operator<<(ostream& out,const pair<S, T>& v){
out<<"("<<v.first<<", "<<v.second<<")";return out;}
const int MAX_N = 500010;
const int MAX_V = 100010;
const double eps = 1e-6;
const ll mod = 1000000007;
const int inf = (1 << 30) - 1;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
mt19937 rng; //use it by rng() % mod, shuffle(all(vec), rng)
///////////////////////////////////////////////////////////////////////////////////////////////////
int N;
ll V[MAX_N];
void solve() {
cin >> N;
rep(i, 0, 2 * N) cin >> V[i];
ll res = accumulate(V, V + 2 * N, 0ll);
priority_queue<ll, vector<ll>, greater<ll>> que;
for(int i = 0; i < N; i++) {
que.push(V[N - 1 - i]);
que.push(V[N + i]);
res -= que.top(); que.pop();
}
cout << res << "\n";
}
uint32_t rd() {
uint32_t res;
#ifdef __MINGW32__
asm volatile("rdrand %0" :"=a"(res) ::"cc");
#else
res = std::random_device()();
#endif
return res;
}
int main() {
#ifndef LOCAL
ios::sync_with_stdio(false);
cin.tie(0);
#endif
cout << fixed;
cout.precision(20);
cerr << fixed;
cerr.precision(6);
rng.seed(rd());
#ifdef LOCAL
//freopen("in.txt", "wt", stdout); //for tester
if(!freopen("in.txt", "rt", stdin)) return 1;
#endif
solve();
cerr << "Time: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define inf (int)(1e18)
signed main(){
int N, i, ans = 0;
scanf("%lld", &N);
vector<int> V(2 * N);
for(i = 0; i < 2 * N; i++){
scanf("%lld", &V[i]);
ans += V[i];
}
priority_queue<int, vector<int>, greater<int>> pq;
for(i = 0; i < N; i++){
pq.push(V[N - 1 - i]);
pq.push(V[N + i]);
ans -= pq.top();
pq.pop();
}
printf("%lld\n", ans);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF=2e18;
ll clamp(ll x,ll min,ll max)
{
if(x>max)
{
return max;
}
if(x<min)
{
return min;
}
return x;
}
int main()
{
ll n;
cin>>n;
ll low=-INF;
ll high=INF;
ll bias=0;
for(ll i=1;i<=n;i++)
{
ll a,t;
cin>>a>>t;
if(1==t)
{
low+=a;
high+=a;
bias+=a;
}
else if(2==t){
low=max(low,a);
high=max(high,a);
}else{
low=min(low,a);
high=min(high,a);
}
}
ll q;
cin>>q;
for(ll i=1;i<=q;i++)
{
ll x;
cin>>x;
cout<<clamp(x+bias,low,high)<<"\n";
}
} | #include <bits/stdc++.h>
using namespace std;
#define fo(a,b) for(int64_t a=0;a<b;a++)
#define sor(a) sort(a.begin(),a.end())
#define rev(a) reverse(a.begin(),a.end())
#define ll int64_t
#define mod 1000000007
#define vl vector<int64_t>
#define vc vector<char>
#define vs vector<string>
#define np(vec) next_permutation(vec.begin(),vec.end())==true
#define en endl
#define vvl vector<vector<int64_t>>
#define stl stack<int64_t>
#define qul que<int64_t>
#define ms(a,b) memset(a,b,sizeof(a))
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define pq priority_queue
#define pql priority_queue<int64_t>
#define pu push
#define pop pop()
#define top top()
#define pqr priority_queue<ll,vector<ll>,greater<ll>>
#define co cout
#define ci cin
#define wh while
#define size size()
#define front front()
int main() {
ll n;
ll a=0;
char c;
cin>>n;
vl v1;
vl v2;
fo(i,n){
cin>>c;
if(c=='0'){v1.push_back(i);}
}
fo(i,n){
cin>>c;
if(c=='0'){v2.push_back(i);}
}
if(v1.size!=v2.size){cout<<-1<<en;}
else{
sor(v1);
sor(v2);
fo(i,v1.size){
if(v1.at(i)!=v2.at(i)){a++;}
}
cout<<a<<en;
}
} |
#include <iostream>
using namespace std;
unsigned long long n,cn;
int s,cnt,nrcif,cf[19],i,r,j;
int main()
{
cin>>n;
cn=n;
while(cn)
{
cf[++cnt]=(cn%10)%3;
s+=cf[cnt];
cn/=10;
nrcif++;
}
r=s%3;
if(r==0)
{
cout<<0;
return 0;
}
int cnt1=1;
if(cnt1<nrcif)
{
for(i=1; i<=cnt; i++)
{
if(r==cf[i])
{
cout<<cnt1;
return 0;
}
}
cnt1++;
if(cnt1<nrcif)
{
for(i=1; i<=cnt; i++)
for(j=i+1; j<=cnt; j++)
{
if(r==cf[i]+cf[j])
{
cout<<cnt1;
return 0;
}
}
for(i=1; i<=n; i++)
{
if(cf[i]%3==0)
{
cout<<nrcif-1;
return 0;
}
}
}
}
cout<<-1;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
vector<int> num(3);
while (n) {
num[n % 10 % 3]++;
n /= 10;
}
int x = (num[1] + num[2] * 2) % 3;
int k = num[0] + num[1] + num[2];
if(x == 0){
cout << 0 << endl;
} else if (x == 1) {
if (num[1]) {
if (k == 1) {
cout << -1 << endl;
} else {
cout << 1 << endl;
}
} else {
if (k == 2) {
cout << -1 << endl;
} else {
cout << 2 << endl;
}
}
} else {
if (num[2]) {
if (k == 1) {
cout << -1 << endl;
} else {
cout << 1 << endl;
}
} else {
if (k == 2) {
cout << -1 << endl;
} else {
cout << 2 << endl;
}
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
int H, W;
while(scanf("%d%d", &H, &W) > 0){
char S[H][W+1];
for(int i = 0; i < H; i++){
scanf("%s", S[i]);
}
int ans = 0;
for(int i = 1; i < H; i++){
bool at_side = false;
for(int j = 0; j < W; j++){
if(S[i-1][j] == '.' and S[i][j] == '#'){
if(!at_side) ans++;
at_side = true;
} else {
at_side = false;
}
}
}
for(int i = H-2; i >= 0; i--){
bool at_side = false;
for(int j = 0; j < W; j++){
if(S[i+1][j] == '.' and S[i][j] == '#'){
if(!at_side) ans++;
at_side = true;
} else {
at_side = false;
}
}
}
for(int j = 1; j < W; j++){
bool at_side = false;
for(int i = 0; i < H; i++){
if(S[i][j-1] == '.' and S[i][j] == '#'){
if(!at_side) ans++;
at_side = true;
} else {
at_side = false;
}
}
}
for(int j = W-2; j >= 0; j--){
bool at_side = false;
for(int i = 0; i < H; i++){
if(S[i][j+1] == '.' and S[i][j] == '#'){
if(!at_side) ans++;
at_side = true;
} else {
at_side = false;
}
}
}
printf("%d\n", ans);
}
}
| #include <bits/stdc++.h>
using namespace std;
const int dx[]={1,-1,0,0};
const int dy[]={0,0,1,-1};
int n,m;
char c[15][15];
bool vis[15][15];
int main()
{
cin>>n>>m;
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
cin>>c[i][j];
}
}
int ans=0;
for(int i=1;i<n-1;i++)
{
for(int j=1;j<m-1;j++)
{
if(c[i][j]=='#')
for(int k=0;k<4;k++)
{
int ax=i+dx[k];
int ay=j+dy[k];
if(c[ax][ay]=='.')
{
ans++;
}
}
}
}
for(int i=1;i<n-1;i++)
{
for(int j=1;j<m-1;j++)
{
if(c[i][j]=='#')
{
if(c[i-1][j]=='#')
{
if((c[i][j-1]=='.'&&c[i-1][j-1]=='.'))
{
ans--;
}
if((c[i][j+1]=='.'&&c[i-1][j+1]=='.'))
{
ans--;
}
}
if(c[i][j-1]=='#')
{
if((c[i-1][j]=='.'&&c[i-1][j-1]=='.'))
{
ans--;
}
if((c[i+1][j]=='.'&&c[i+1][j-1]=='.'))
{
ans--;
}
}
}
}
}
cout<<ans<<endl;
return 0;
} |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <cmath>
#include <stdio.h>
#include <list>
#include <numeric>
#include <stack>
#include <queue>
#include <tuple>
#include <bitset>
#include <map>
#include <math.h>
#include <cstring>
//ceil(a/b) (a + (b - 1))/ b
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int,int> P;
const int inf=1000000007;
const int mod=1e9 + 7;
const double PI=3.14159265358979323846;
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};
int main() {
ll N;
cin >> N;
int x[N];
int y[N];
int ans = 0;
rep(i,N) cin >> x[i] >> y[i];
for(int i=0; i<N; i++) {
for(int j=i+1; j<N; j++){
for(int k=j+1; k<N; k++) {
int a,b,c,d;
a = x[i] - x[k];
b = y[i] - y[k];
c = x[j] - x[k];
d = y[j] - y[k];
if(a*d == b*c) ans++;
}
}
}
if(ans > 0) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
vector<ll>v1;
ll n;
cin>>n;
ll a[n],b[n];
for(ll i=0;i<n;i++){
cin>>a[i];
cin>>b[i];
ll res=a[i]+b[i];
v1.push_back(res);
}
ll res1=*min_element(a,a+n);
ll res2=*min_element(b,b+n);
ll store1,store2;
for(ll i=0;i<n;i++){
if(a[i]==res1){
store1=i;
break;
}
}
for(ll i=0;i<n;i++){
if(b[i]==res2){
store2=i;
break;
}
}
ll finalres;
if(store1!=store2){
finalres=max(res1,res2);
}
else{
sort(b,b+n);
res2=b[1];
finalres=max(res1,res2);
}
v1.push_back(finalres);
ll check=*min_element(v1.begin(),v1.end());
cout<<check<<endl;
}
|
// Problem: B - Many 110
// Contest: AtCoder - AtCoder Regular Contest 110（Sponsored by KAJIMA CORPORATION）
// Time: 2020-12-05 17:30:21
// 私に忍び寄るのをやめてください、ありがとう
#include<bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ll long long
#define int long long
#define mod 1000000007 //998244353
#define fast ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define f(i,n) for(ll i=0;i<n;i++)
#define fore(i, a, b) for (ll i = (ll)(a); i <= (ll)(b); ++i)
#define nl "\n"
#define trace(x) cerr<<#x<<": "<<x<<" "<<endl
#define trace2(x, y) cerr<<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl
#define trace3(x, y, z) cerr<<#x<<":" <<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl
#define trace4(a, b, c, d) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<endl
#define x first
#define y second
#define vc vector
#define pb push_back
#define ar array
#define all(a) (a).begin(), (a).end()
#define rall(x) (x).rbegin(), (x).rend()
#define ms(v,n,x) fill(v,v+n,x);
#define init(c,a) memset(c,a,sizeof(c))
#define pll pair<ll,ll>
#define mll map<ll,ll>
#define sll set<ll>
#define vll vector<ll>
#define vpll vector<pll>
#define inf 9e18
#define cases ll T;cin>>T;while(T--)
#define BLOCK 500
//const double PI = 3.141592653589793238460;
template<typename T> bool mmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool mmin(T &m, const T q) { if (m > q) {m = q; return true;} else return false; }
typedef std::complex<double> Complex;
typedef std::valarray<Complex> CArray;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
// void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else+9
#define debug(x...)
#endif
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N=1<<20;
// 110 110 110 110 ...
int32_t main()
{
fast
cout << fixed << setprecision(12);
ll n;
string s;
cin>>n>>s;
ll big=(ll)1e10;
string ans="110";
ll pos=0,sz=0;
if(n==1){
if(s[0]=='1'){
cout<<2*big;
}
else
cout<<big;
return 0;
}
if(n==2){
if(s[0]=='0'){
if(s[1]=='1')
cout<<big-1;
else
cout<<0;
}
else
cout<<big;
return 0;
}
// 3 cases
// 110
if(s[0]=='1' and s[1]=='1'){
pos=0;
sz=((n-3)+2)/3+1;
}
//10
else if(s[0]=='1' and s[1]=='0'){
pos=1;
sz=((n-2)+2)/3+1;
}
//0
else{
pos=2;
sz=((n-1)+2)/3+1;
}
f(i,n){
if(s[i]!=ans[pos%3]){
cout<<0;
return 0;
}
pos++;
}
cout<<(big-sz+1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0,_n=(int)(n);i<_n;++i)
#define ALL(v) (v).begin(),(v).end()
#define CLR(t,v) memset(t,(v),sizeof(t))
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>&a){return os<<"("<<a.first<<","<<a.second<< ")";}
template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}
#ifdef LOCAL
template<class T>void pv(T a,T b){for(T i=a;i!=b;++i)cerr<<(*i)<<" ";cerr<<endl;}
#else
template<class T>void pv(T a,T b){}
#endif
ll nextLong() { ll x; scanf("%lld", &x); return x;}
int main2() {
ll t = nextLong();
ll N = nextLong();
ll hi = 1e16;
ll lo = 0;
while (hi - lo > 1) {
ll m = (hi + lo) / 2;
ll d = (m*(100+t)/100) - m;
if (d >= N) hi = m; else lo = m;
}
ll ans = hi * (100 + t) / 100 - 1;
cout << ans << endl;
return 0;
}
int main() {
#ifdef LOCAL
for (;!cin.eof();cin>>ws)
#endif
main2();
return 0;
}
|
#ifdef LOCAL
//#define _GLIBCXX_DEBUG
#endif
//#pragma GCC target("avx512f,avx512dq,avx512cd,avx512bw,avx512vl")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<char> Vc;
typedef vector<P> VP;
typedef vector<vector<ll>> VV;
typedef vector<vector<int>> VVi;
typedef vector<vector<char>> VVc;
typedef vector<vector<vector<ll>>> VVV;
typedef vector<vector<vector<vector<ll>>>> VVVV;
#define endl '\n'
#define REP(i, a, b) for(ll i=(a); i<(b); i++)
#define PER(i, a, b) for(ll i=(a); i>=(b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
const ll INF=1e18+18;
const ll MOD=1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a,b)
#define Each(a,b) for(auto &a :b)
#define rEach(i, mp) for (auto i = mp.rbegin(); i != mp.rend(); ++i)
#ifdef LOCAL
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbgmap(mp) cerr << #mp << ":"<<endl; for (auto i = mp.begin(); i != mp.end(); ++i) { cerr << i->first <<":"<<i->second << endl;}
#define dbgset(st) cerr << #st << ":"<<endl; for (auto i = st.begin(); i != st.end(); ++i) { cerr << *i <<" ";}cerr<<endl;
#define dbgarr(n,m,arr) rep(i,n){rep(j,m){cerr<<arr[i][j]<<" ";}cerr<<endl;}
#define dbgdp(n,arr) rep(i,n){cerr<<arr[i]<<" ";}cerr<<endl;
#else
#define dbg(...)
#define dbgmap(...)
#define dbgset(...)
#define dbgarr(...)
#define dbgdp(...)
#endif
#define out(a) cout<<a<<endl
#define out2(a,b) cout<<a<<" "<<b<<endl
#define vout(v) rep(i,v.size()){cout<<v[i]<<" ";}cout<<endl
#define Uniq(v) v.erase(unique(v.begin(), v.end()), v.end())
#define fi first
#define se second
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) { return s<<"("<<p.first<<", "<<p.second<<")"; }
template<typename T>istream& operator>>(istream&i,vector<T>&v)
{rep(j,v.size())i>>v[j];return i;}
// vector
template<typename T>
ostream &operator<<(ostream &s, const vector<T> &v) {
int len=v.size();
for(int i=0; i<len; ++i) {
s<<v[i];
if(i<len-1) s<<" ";
}
return s;
}
// 2 dimentional vector
template<typename T>
ostream &operator<<(ostream &s, const vector<vector<T> > &vv) {
int len=vv.size();
for(int i=0; i<len; ++i) {
s<<vv[i]<<endl;
}
return s;
}
vector<ll> divisor(ll n) {
vector<ll> ret;
for(ll i=1; i*i<=n; i++) {
if(n%i==0) {
ret.pb(i);
if(i*i!=n) {
ret.pb(n/i);
}
}
}
return ret;
}
vector<pair<ll,ll>> factorize(ll n) {
vector<pair<ll,ll>> res;
for (ll i = 2; i*i <= n; ++i) {
if (n%i) continue;
res.emplace_back(i,0);
while (n%i == 0) {
n /= i;
res.back().second++;
}
}
if (n != 1) res.emplace_back(n,1);
return res;
}
int solve(){
ll s,p;
cin>>s>>p;
Vec div = divisor(p);
bool ok = false;
Each(d, div){
ll n = d;
ll m = p/d;
if(n+m == s){
ok = true;
}
}
Yes(ok);
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout<<std::setprecision(10);
// ll T;
// cin>>T;
// while(T--)
solve();
}
| #include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <utility>
#include <algorithm>
#include <cmath>
#include <climits>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int INF = (1<<30)-1;
const ll LINF = 1e18;
#define rep(i, n) for (int i = 0; i < n; i++)
template<class T>
bool chmax(T &a, T b) {if (a < b) {a = b;return true;}else return false;}
template<class T>
bool chmin(T &a, T b) {if (a > b) {a = b;return true;}else return false;}
int main() {
ll s, p; cin >> s >> p;
ll ans = 0;
for (ll x = 1; x * x <= p; x++) {
if (p % x == 0) {
if (x + p/x == s)
ans++;
}
}
if (ans)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
//小数点精度
//cout << fixed << std::setprecision(15) << y << endl; |
#include<bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define PI 3.14159265359
#define pb push_back
#define mp make_pair
#define MP ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define IG cin.ignore(numeric_limits<streamsize>::max(),'\n');
#define ll long long int
#define ull unsigned long long int
#define N 1378
#define maxn 1000001
#define FP ff.open("output.txt")
#define FR ff.open("input.txt")
#define valid(a,b) if(a>=1 && a<row-1 && b>=1 && b<col-1)
fstream ff;
ll a, q, b, c, d, k, h, e, f, t, m, n, i, j, x, y, tcase = 0, l, r;
string s1, s2, s;
int A[100][100];
void process(){
}
int main(){
long double a,b;
cin>>a>>b;
printf("%.10Lf",(1-b/a)*100);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; ++i)
#define ll long long
template <typename T>
bool PN(T x){ if (x <= 1) return false; if (x == 2) return true; for (int i = 2; i < sqrt(x) + 1; i++) if (x % i == 0) return false; return true;}
const ll MOD = 1e9+7;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
long long Comb(int n, int i){long long ans = 1; if(i>n || i < 0) return 0; if(i == 0 || i == n) return 1; else {for(int j = 1; j <= i; ++j){ans *=(n+1-j); ans /= j; ans %= MOD;} }return ans;}
template<typename T> T gcd(T a, T b){if(b == 0) return a;else return gcd(b, a%b);}
template<typename T> T lcm(T a, T b){if(b > a) swap(a, b); T g = gcd(a, b);return a / g * b;}
ll ans = 0;
void judge(ll a, ll b, ll c) {
if(a == b && b == c) ans ++;
else if(a == b || b == c || c == a) ans += 3;
else ans += 6;
}
void solve() {
int a, b;
cin >> a >> b;
cout <<((double)a-(double)b)/double(a)*100 << endl;
}
int main(void){
solve();
return 0;
}
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long int
#define mp(a,b) make_pair(a,b)
#define vi vector<int>
#define mii map<int,int>
#define mpi map<pair<int,int>,int>
#define msi map<string,int>
#define vp vector<pair<int,int> >
#define pb(a) push_back(a)
#define fr(i,n) for(i=0;i<n;i++)
#define rep(i,a,n) for(i=a;i<n;i++)
#define F first
#define S second
#define endl "\n"
#define Endl "\n"
#define fast std::ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define mod 1000000007
#define dom 998244353
#define sl(a) (int)a.length()
#define sz(a) (int)a.size()
#define all(a) a.begin(),a.end()
#define pii pair<int,int>
#define mini 2000000000000000000
#define time_taken 1.0 * clock() / CLOCKS_PER_SEC
//const long long INF=1e15;
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//auto dist=uniform_int_distribution<int>(0,INF);
//const long double pi = acos(-1);
//primes for hashing 937, 1013
typedef tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
template<typename T, typename U> static inline void amin(T &x, U y)
{
if (y < x)
x = y;
}
template<typename T, typename U> static inline void amax(T &x, U y)
{
if (x < y)
x = y;
}
void shikhar7s(int cas)
{
int n,i;
cin>>n;
int s[n],a[n];
fr(i,n)
{
cin>>a[i];
if(!i)
s[i]=a[i];
else
s[i]=s[i-1]+a[i];
}
int l[n+5][n+5];
memset(l,0,sizeof(l));
rep(i,1,n+1)
{
vi v[i];
int j;
fr(j,n)
{
v[s[j]%i].pb(j);
}
fr(j,i)
{
int k;
rep(k,1,sz(v[j]))
{
l[v[j][k]+1][i]=v[j][k-1]+1;
}
}
}
int dp[n+5][n+5],j;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
rep(i,1,n+1)
{
rep(j,1,n+1)
{
int la=l[i][j];
dp[i][j]=(dp[la][j-1]+dp[la][j])%mod;
}
}
int ans=0;
rep(i,1,n+1)
{
ans=(ans+dp[n][i])%mod;
}
cout<<ans;
}
signed main()
{
fast;
//freopen("input.txt", "rt", stdin);
//freopen("output.txt", "wt", stdout);
int t=1;
//cin>>t;
int cas=1;
while(cas<=t)
{
//cout<<"Case #"<<cas<<": ";
shikhar7s(cas);
cas++;
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define vec vector
#define pii pair<int, int>
using namespace std;
const long long MAXVAL = (long long) 1e18 + 1;
//const long long MOD = 1000000007ll;
const long long MOD = 998244353ll;
const int INF = 1000000001;
long long poww(int x, long long pow) {
if (pow == 0ll ) return 1;
if (pow == 1ll) return x % MOD;
long long ans = poww(x, pow >> 1) % MOD;
ans = (ans * ans) % MOD;
if ((pow & 1) == 1) {
ans = (ans * x ) % MOD;
}
return ans % MOD;
}
ll gcd(ll x, ll y) {
if (x == 0) return y;
while (y) {
x %= y;
swap(x, y);
}
return x;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int q = 1;
//cin >> q;
while (q-- >0) {
int h,w;
cin >> h >> w;
int k;
cin >> k;
vec<vec<int>> dyn(h, vec<int>(w));
map<pii, char> pre;
for (int i = 0; i < k; ++i) {
int x, y;
cin >> x>> y;
--x;
--y;
char c;
cin >> c;
pre[(make_pair(x,y))] = c;
}
ll inv3 = poww(3, MOD - 2);
dyn[0][0] = poww(3, w * h - k);
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (pre.count(make_pair(i, j))) {
char c = pre[make_pair(i, j)];
if (c == 'X') {
if (i < h - 1) {
dyn[i + 1][j] = (dyn[i + 1][j] + dyn[i][j]) % MOD;
}
if (j < w - 1) {
dyn[i][j + 1] = (dyn[i][j + 1] + dyn[i][j]) % MOD;
}
} else if (c == 'D') {
if (i < h - 1) {
dyn[i + 1][j] = (dyn[i + 1][j] + dyn[i][j]) % MOD;
}
} else {
if (j < w - 1) {
dyn[i][j + 1] = (dyn[i][j + 1] + dyn[i][j]) % MOD;
}
}
} else {
if (i < h - 1) {
dyn[i + 1][j] = (dyn[i + 1][j] + 2ll * inv3 * dyn[i][j]) % MOD;
}
if (j < w - 1) {
//cout << " I J " << i << " " << j << endl;
//cout << " inv3 " << inv3 << endl;
//cout << " dyn i j " << dyn [i][j] << endl;
dyn[i][j + 1] = (dyn[i][j + 1] + 2ll * inv3 * dyn[i][j]) % MOD;
}
}
}
}
cout << dyn[h - 1][w - 1] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define endl "\n";
#define rep(i, a, b) for (int i=a; i<b; i++)
#define pre(i, a, b) for (int i=a; i>=b; i--)
const int MAX_N = 2e5+5;
const int MOD = 1e9 + 7;
const int INF = 1e9;
#define pb push_back
#define fi first
#define se second
#define sz size()
#define bg begin()
#define ed end()
#define bk back()
#define pii pair<int, int>
#define mp map<int, int>
#define vi vector<int>
#define vvi vector<vector<int>>
#define si set<int>
/* #define deb(...) logger(#__VA_ARGS__, __VA_ARGS__)
template<typename ...Args>
void logger(string vars, Args&&... values) {
cout << vars << " = ";
string delim = "";
(..., (cout << delim << values, delim = ", "));
} */
int ans = 0;
int parent[MAX_N], siz[MAX_N];
int findParent(int i){
if(parent[parent[i]]!=parent[i]){
parent[i] = findParent(parent[i]);
}
return parent[i];
}
void unionNodes(int a, int b){
int parent_a = findParent(a);
int parent_b = findParent(b);
if(parent_b==parent_a){
return;
}
ans++;
if(siz[parent_a]>=siz[parent_b]){
swap(parent_a,parent_b);
}
siz[parent_b] += siz[parent_a];
parent[parent_a] = parent_b;
return;
}
void cleardsu(int n){
rep(i,1,n+1){
parent[i] = i;
siz[i] = 1;
}
}
void solve() {
int n; cin>>n;
cleardsu(MAX_N-2);
vi a(n);
rep(i,0,n) cin>>a[i];
rep(i,0,n){
int j = n - 1 - i;
unionNodes(a[i],a[j]);
}
cout<<ans;
}
signed main() {
fast
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
cout.precision(10);
cout<<fixed;
int t = 1;
// cin >> t;
for (int i = 1; i <= t; i++) {
// cout << "Case #" << i << ": ";
solve();
}
}
| #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;
struct UnionFind {
vector<int> par;
UnionFind (int n) : par(n, -1){}
int root(int x){
if(par[x] < 0) return x;
return par[x] = root(par[x]);
}
bool unite(int x, int y){
x = root(x), y = root(y);
if(x == y) return false;
if(par[x] > par[y]) swap(x,y);
par[x] += par[y];
par[y] = x;
return true;
}
bool same(int x, int y){
return root(x) == root(y);
}
int size(int x) {
return -par[root(x)];
}
};
int main()
{
int n;
cin >> n;
vector<int> a(n);
for(int i = 0; i < n; i++) cin >> a[i];
UnionFind uf(200005);
for(int i = 0; i < n; i++) uf.unite(a[i], a[n-1-i]);
int ans = 0;
for(int i = 0; i < 200005; i++) if(uf.root(i) == i) ans += uf.size(i)-1;
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
ll n, x;
cin >> n >> x;
vector<ll> v(n);
vector<ll> p(n);
rep(i, n) cin >> v.at(i) >> p.at(i);
ll ans = -1;
x *= 100;
ll sum = 0;
rep(i, n)
{
sum += v.at(i) * p.at(i);
if (sum > x)
{
ans = i + 1;
break;
}
}
cout << ans << endl;
return 0;
} | //#pragma GCC optimize(2)
#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<map>
#include<cmath>
#include<cctype>
#include<vector>
#include<set>
#include<queue>
#include<algorithm>
#include<sstream>
#include<ctime>
#include<cstdlib>
#define X first
#define Y second
#define L (u<<1)
#define R (u<<1|1)
#define pb push_back
#define mk make_pair
#define Mid (tr[u].l+tr[u].r>>1)
#define Len(u) (tr[u].r-tr[u].l+1)
#define random(a,b) ((a)+rand()%((b)-(a)+1))
#define db puts("---")
using namespace std;
//void rd_cre() { freopen("d://dp//data.txt","w",stdout); srand(time(NULL)); }
//void rd_ac() { freopen("d://dp//data.txt","r",stdin); freopen("d://dp//AC.txt","w",stdout); }
//void rd_wa() { freopen("d://dp//data.txt","r",stdin); freopen("d://dp//WA.txt","w",stdout); }
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> PII;
const int N=1000010,mod=1e9+7,INF=0x3f3f3f3f;
const double eps=1e-8;
int n;
double x,sum;
int main()
{
// ios::sync_with_stdio(false);
// cin.tie(0);
cin>>n>>x;
bool f=false;
int ans=0;
for(int i=1;i<=n;i++)
{
int v,p; scanf("%d%d",&v,&p);
sum+=v*1.0*p/100;
if(sum-x>eps&&!f) f=1,ans=i;
}
if(f) printf("%d\n",ans);
else printf("-1\n");
return 0;
}
/*
*/
|
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define f first
#define s second
#define pb push_back
#define eb emplace_back
#define mk make_pair
#define mt make_tuple
#define MOD 1000000007
#define fo(i,a,b) for(i=a;i<b;i++)
#define foe(i,a,b) for(i=a;i<=b;i++)
#define all(x) x.begin(), x.end()
#define vi vector<int>
#define vl vector <long long int>
#define pii pair <int,int>
#define pll pair <long long int, long long int>
#define vpii vector< pair<int,int> >
#define vpll vector < pair <long long int,long long int> >
#define boost ios::sync_with_stdio(false); cin.tie(0)
using namespace std;
const int inf = 1e9 + 5;
const ll inf64 = 1e18 + 5;
int main()
{
boost;
ll n, i;
cin >> n;
auto get = [] (ll a, ll b) {
return (a * b) / (__gcd(a, b));
};
ll ans = 1;
foe(i, 2, n)
ans = get(ans, i);
cout << ans + 1;
}
| /*
Credit_Card_CRD
*/
#include <iostream>
#include <string>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <set>
#include <map>
#include <utility>
#include <queue>
#include <vector>
#include <stack>
#include <sstream>
#include <algorithm>
#include <fstream>
#include <functional>
#include <string.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define forn(i,a,b) for(int i=a;i<b;i++)
#define m_p make_pair
#define pb push_back
#define foreach(i,c) for(__typeof(c.begin())i=(c.begin());i!=(c).end();i++)
#define sz(s) s.size()
#define all(s) s.begin(),s.end()
#define MOD 1000000007
#define imax 2147483647
#define llmax 9223372036854775807
typedef long long ll;
using namespace std;
long long read()
{
char c=getchar();
long long x=0LL;
while(c<'0'||c>'9')
c=getchar();
while(c>='0'&&c<='9')
{
x*=10LL;
x+=(c-'0');
c=getchar();
}
return x;
}
string i_to_s(int x)
{
string t="";
while(x)
{
t+=x%10+'0';
x/=10;
}
reverse(all(t));
return t;
}
int s_to_i(string t)
{
int x=0;
rep(i,sz(t))
{
x=x*10+(t[i]-'0');
}
return x;
}
string s;
int a[20];
int main()
{
cin>>s;
if(sz(s)<4){
sort(all(s));
do{
int now=s_to_i(s);
if(now%8==0){
cout<<"Yes"<<endl;
return 0;
}
}
while(next_permutation(s.begin(),s.end()));
cout<<"No"<<endl;
return 0;
}
rep(i,sz(s))
a[(int)(s[i]-'0')]++;
int now=0;
while(now<1000){
now+=8;
if(now>=1000)
break;
int a1=now/100,a2=now/10%10,a3=now%10;
a[a1]--;
if(a[a1]<0){
a[a1]++;
continue;
}
a[a2]--;
if(a[a2]<0){
a[a1]++;
a[a2]++;
continue;
}
a[a3]--;
if(a[a3]<0){
a[a1]++;
a[a2]++;
a[a3]++;
continue;
}
cout<<"Yes"<<endl;
return 0;
}
cout<<"No"<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for(ll i = 0; i < (ll)(n); ++i)
#define FOR(i, a, b) for(ll i=(a); i < (ll)(b); ++i)
template<class T> inline bool chmax(T& a, T b) { if(a < b){ a=b; return 1; } return 0;}
template<class T> inline bool chmin(T& a, T b) { if(a > b){ a=b; return 1; } return 0;}
int main(){
int n;
cin >> n;
vector<vector<ll>> c(n,vector<ll>(n));
vector<ll> a(n), b(n);
REP(i,n) REP(j,n) cin >> c[i][j];
if(n==1){
cout << "Yes\n";
cout << c[0][0] << "\n0\n";
return 0;
}
ll amin=0,bmin=0;
a[0]=0;
FOR(i,1,n){
ll diff = c[i][0] - c[0][0];
FOR(j,1,n){
if(diff != c[i][j] - c[0][j]){
cout << "No\n";
return 0;
}
}
a[i] = diff;
chmin(amin, a[i]);
}
b[0]=0;
FOR(j,1,n){
ll diff = c[0][j] - c[0][0];
FOR(i,1,n){
if(diff != c[i][j] - c[i][0]){
cout << "No\n";
return 0;
}
}
b[j] = diff;
chmin(bmin, b[j]);
}
if(amin == 0 && bmin == 0){
REP(j,n){
b[j]+=c[0][0];
}
}else if(amin > bmin){
if(-1*bmin > c[0][0]){
cout << "No\n";
return 0;
}
REP(j,n) b[j] -= bmin;
REP(i,n) a[i] = c[i][0] - b[0];
}else{
if(-1*amin > c[0][0]){
cout << "No\n";
return 0;
}
REP(i,n) a[i] -= amin;
REP(j,n) b[j] = c[0][j] - a[0];
}
cout << "Yes\n";
REP(i,n){
if(i!=0) cout << " ";
cout << a[i];
}
cout << "\n";
REP(i,n){
if(i!=0) cout << " ";
cout << b[i];
}
cout << "\n";
return 0;
} | //#undef DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll llinf = (1ll<<61)-1;
#define sz(a) int(a.size())
#define all(x) begin(x), end(x)
#ifdef DEBUG
const int DEBUG_END = 26;
#define DOS cout
#include <debug.h>
#else
#define bug(args...) void()
#define cbug(a, args...)
#endif
#define ASSERT(a, o, b, args...) if (!((a)o(b))) bug(a, b, ##args), assert((a)o(b));
#define fi first
#define se second
int TC = 1, CN;
const int inf = 998244353;
template<class C, class D> bool operator ==(const C &ls, const D &rs) { return !(ls<rs or rs<ls); }//{
template<class C, class D> bool operator !=(const C &ls, const D &rs) { return !(rs==ls); }
template<class C, class D> bool operator >(const C &ls, const D &rs) { return rs<ls; }
template<class C, class D> bool operator <=(const C &ls, const D &rs) { return !(rs<ls); }
template<class C, class D> bool operator >=(const C &ls, const D &rs) { return !(ls<rs); }
// += can't be made generic as x+=y is not the same as x=x+y when x is string
template<class C, class D> C& operator -=(C &x, const D &y) { return x = x-y; }
template<class C, class D> C& operator *=(C &x, const D &y) { return x = x*y; }
#include <ext/numeric>
using __gnu_cxx::power;
template<int mod> struct mint// Make sure to not do any operation with int outside [-mod, 2*mod), *1 to mod forcefully), use << instead of 2*
{
int x;
mint() = default;
mint(const int &rs) : x(rs + (rs>=0 ? 0 : mod) - (rs<mod ? 0 : mod)) {};
mint operator -() { return -x; }
// mint operator ~() = delete; // when mod is not surely prime
mint operator ~() { ASSERT(x, !=, 0, "modinverse 0 is undefined"); return power(*this, mod-2); }
mint operator +(const mint &rs) const { return x+rs.x; }
mint& operator +=(const mint &rs) { return *this = *this + rs; }
mint operator -(const mint &rs) const { return x-rs.x; }
mint operator *(const mint &rs) const { return int(x*ll(rs.x)%mod); }
mint operator <<(const int &rs) { return rs==1 ? *this+*this : *this*mint{1<<rs}; }
mint& operator <<=(const int &rs) { return *this = *this<<rs; }
mint& operator >>=(const int &rs) { return x>>=rs, *this; } // only for power()
mint& operator ++() { return *this += 1; }
mint& operator --() { return *this -= 1; }
mint operator ++(int) { mint ret = x; ++*this; return ret; }
mint operator --(int) { mint ret = x; --*this; return ret; }
friend istream& operator >>(istream &is, mint &rs) { return is>>rs.x; }
friend ostream& operator <<(ostream &os, const mint &rs) { return os<<rs.x; }
friend mint operator +(const mint &ls, const int &rs) { return ls+mint(rs); }
friend mint operator +(const int &ls, const mint &rs) { return mint(ls)+rs; }
friend mint operator -(const mint &ls, const int &rs) { return ls-mint(rs); }
friend mint operator -(const int &ls, const mint &rs) { return mint(ls)-rs; }
friend mint operator *(const mint &ls, const int &rs) { return ls*mint(rs); }
friend mint operator *(const int &ls, const mint &rs) { return mint(ls)*rs; }
bool operator <(const mint &rs) const { return x<rs.x; }
friend bool operator <(const int &ls, const mint &rs) { return ls<rs.x; }
friend bool operator <(const mint &ls, const int &rs) { return ls.x<rs; }
};
using Int=mint<inf>;
Int operator""_i(unsigned long long x) { return {int(x)}; }//}
const int N = 200005;
int n, m, k;
signed main() { cin.tie(0)->sync_with_stdio(0); cin.exceptions(cin.failbit); cout.precision(11), cout.setf(ios::fixed);
//cin >> TC;// inputAll + resetAll -> solution
auto kase = [&]()->void {
cin >> n >> m >> k;
Int ans = 0;
if (n == 1) ans = power(Int(k), m);
else if (m == 1) ans = power(Int(k), n);
else {
for (int i = 1; i <= k; i++) {
ans += (power(Int(i), n)-(i == 1 ? 0 : power(Int(i-1), n)))*power(Int(k-i+1), m);
}
}
cout << ans << '\n';
};
while (CN++!=TC) kase();
} |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < n; i++)
#define Rep(i,n) for(int i = 1; i <= n; i++)
#define sz(x) int(x.size())
#define All(v) v.begin(), v.end()
#define rAll(v) v.rbegin(), v.rend()
#define YesorNo(a) printf(a ? "Yes\n" : "No\n")
#define endl '\n'
#define fi first
#define se second
using ll = long long;
using ld = long double;
using P = pair<int,int>;
using Pl = pair<ll,ll>;
template<class T> using V = vector<T>;
const int dx[] = {0,1,0,-1,1,1,-1,-1};
const int dy[] = {1,0,-1,0,1,-1,-1,1};
ll ceil(const ll &a, const ll &b){return ((a)+(b)-1)/b;}
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; }
struct INF { template<class T> operator T() { return numeric_limits<T>::max() / 2; } } INF;
const ld eps = 1e-11;
int sgn(const ld &r) {return (r > eps) - (r < eps);}
const ll mod = 998244353;
int main(){
ll a, b, c;
cin >> a >> b >> c;
a = ((a+1)*a/2) % mod;
b = ((b+1)*b/2) % mod;
c = ((c+1)*c/2) % mod;
ll ans = a * b % mod * c % mod;
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll a,b,c;
cin>>a>>b>>c;
ll ans,m=998244353;
ll x=(a*(a+1)/2);
ll y=(b*(b+1)/2);
ll z=(c*(c+1)/2);
ll d=((x%m)*(y%m))%m;
ll e=((d%m)*(z%m))%m;
cout<<e;
//951633476
} |
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
using ll = long long;
int main(){
ll k,n,m;
cin >> k >> n >> m;
vector<ll> a(k);
vector<ll> b(k);
for(int i = 0;i < k;i++){
cin >> a[i];
}
for(int i = 0;i < k;i++){
b[i] = (m * a[i]) / n;
}
int sum_of_b = 0;
for(int i = 0;i < k;i++){
sum_of_b += b[i];
}
vector<pair<ll,int>> potential(k);
for(int i = 0;i < k;i++){
potential[i].first = abs(n * (b[i] + 1) - m * a[i]) - abs(n * b[i] - m * a[i]);
potential[i].second = i;
}
sort(potential.begin(),potential.end(),[](pair<ll,int> a,pair<ll,int> b){return a.first < b.first;});
for(int i = 0;i < m - sum_of_b;i++){
b[potential[i].second] ++;
}
for(int i = 0;i < k;i++){
cout << b[i] << ' ';
}
cout << endl;
return 0;
}
| #include<iostream>
#include<vector>
#include<algorithm>
//#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
#define ll long long
#define sort(a) sort(a.begin(),a.end())
#define reverse(a) reverse(a.begin(),a.end())
int main(){
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int K;
ll N,M,count=0;
cin>>K>>N>>M;
vector<ll> A(K+10);
vector<ll> C(K+10);
vector<ll> D(K+10);
vector<ll> E(K+10);
for(int i=0;i<K;i++){
int X;
cin>>X;
A[i]=M*X;
C[i]=A[i]/N*N;
count+=C[i]/N;
}
count=M-count;
for(int i=0;i<K;i++){
D[i]=abs(A[i]-C[i]);
E[i]=D[i];
}
sort(D);
reverse(D);
for(int j=0;j<count;j++){
for(int i=0;i<K;i++){
if(D[j]==E[i]){
C[i]+=N;
E[i]=abs(E[i]-N);
break;
}
}
}
for(int i=0;i<K;i++){
cout<<C[i]/N<<" ";
}
return 0;}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(long long i=0;i<(long long)(n);i++)
#define REP(i,k,n) for(long long i=k;i<(long long)(n);i++)
#define all(a) a.begin(),a.end()
#define rsort(a) {sort(all(a));reverse(all(a));}
#define pb emplace_back
#define eb emplace_back
#define lb(v,k) (lower_bound(all(v),(k))-v.begin())
#define ub(v,k) (upper_bound(all(v),(k))-v.begin())
#define fi first
#define se second
#define pi M_PI
#define PQ(T) priority_queue<T>
#define SPQ(T) priority_queue<T,vector<T>,greater<T>>
#define dame(a) {out(a);return 0;}
#define decimal cout<<fixed<<setprecision(15);
#define dupli(a) {sort(all(a));a.erase(unique(all(a)),a.end());}
typedef long long ll;
typedef pair<ll,ll> P;
typedef tuple<ll,ll,ll> PP;
typedef tuple<ll,ll,ll,ll> PPP;
typedef multiset<ll> S;
using vi=vector<ll>;
using vvi=vector<vi>;
using vvvi=vector<vvi>;
using vvvvi=vector<vvvi>;
using vp=vector<P>;
using vvp=vector<vp>;
using vb=vector<bool>;
using vvb=vector<vb>;
const ll inf=1001001001001001001;
const ll INF=1001001001;
const ll mod=998244353;
const double eps=1e-10;
template<class T> bool chmin(T&a,T b){if(a>b){a=b;return true;}return false;}
template<class T> bool chmax(T&a,T b){if(a<b){a=b;return true;}return false;}
template<class T> void out(T a){cout<<a<<'\n';}
template<class T> void outp(T a){cout<<'('<<a.fi<<','<<a.se<<')'<<'\n';}
template<class T> void outvp(T v){rep(i,v.size())cout<<'('<<v[i].fi<<','<<v[i].se<<')';cout<<'\n';}
template<class T> void outvvp(T v){rep(i,v.size())outvp(v[i]);}
template<class T> void outv(T v){rep(i,v.size()){if(i)cout<<' ';cout<<v[i];}cout<<'\n';}
template<class T> void outvv(T v){rep(i,v.size())outv(v[i]);}
template<class T> bool isin(T x,T l,T r){return (l)<=(x)&&(x)<=(r);}
template<class T> void yesno(T b){if(b)out("yes");else out("no");}
template<class T> void YesNo(T b){if(b)out("Yes");else out("No");}
template<class T> void YESNO(T b){if(b)out("YES");else out("NO");}
template<class T> void noyes(T b){if(b)out("no");else out("yes");}
template<class T> void NoYes(T b){if(b)out("No");else out("Yes");}
template<class T> void NOYES(T b){if(b)out("NO");else out("YES");}
void outs(ll a,ll b){if(a>=inf-100)out(b);else out(a);}
ll gcd(ll a,ll b){if(b==0)return a;return gcd(b,a%b);}
ll modpow(ll a,ll b){ll res=1;a%=mod;while(b){if(b&1)res=res*a%mod;a=a*a%mod;b>>=1;}return res;}
class UF{
public:
vi data;stack<P> st;
UF(ll n){
data=vi(n,1);
}
bool heigou(ll x,ll y,bool undo=false){
x=root(x);y=root(y);
if(data[x]>data[y])swap(x,y);
if(undo){st.emplace(y,data[y]);st.emplace(x,data[x]);}
if(x==y)return false;
data[y]+=data[x];data[x]=-y;
return true;
}
ll root(ll i){if(data[i]>0)return i;return root(-data[i]);}
ll getsize(ll i){return data[root(i)];}
bool same(ll a,ll b){return root(a)==root(b);}
void undo(){rep(i,2){data[st.top().fi]=st.top().se;st.pop();}}
};
int main(){
ll n,m;cin>>n>>m;
vector<string> v(n);
rep(i,n)cin>>v[i];
UF uf(n+m);
rep(i,n)rep(j,m)if(v[i][j]=='#')uf.heigou(i,j+n);
rep(i,2)rep(j,2)uf.heigou(i*(n-1),n+j*(m-1));
// outv(uf.data);
vi a,b;
rep(i,n)a.pb(uf.root(i));
rep(i,m)b.pb(uf.root(i+n));
dupli(a);dupli(b);
out(min(a.size(),b.size())-1);
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e5+500;
int gti(void)
{
char c=getchar();
int ret=0,st=1;
for (;!isdigit(c)&&c!='-';c=getchar());
if (c=='-') st=-1,c=getchar();
for (;isdigit(c);c=getchar()) ret=ret*10+c-'0';
return ret*st;
}
int cnt[N];
int main(void)
{
int n=gti(),k=gti();
for (int i=1;i<=n;i++)
++cnt[gti()];
int now=n;
ll ans=0;
for (int i=0;i<=n;i++)
{
now=min(now,cnt[i]);
ans+=min(now,k);
}
printf("%lld\n",ans);
return 0;
}
|
#include<set>
#include<ctime>
#include<cstdio>
#include<cctype>
#include<vector>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1e4+7;
int read(){
char c;
int x=0,f=1;
while(!isdigit(c=getchar()))
f-=2*(c=='-');
while(isdigit(c)){
x=x*10+f*(c-48);
c=getchar();
}
return x;
}
struct que{
int p,i,r;
que(int a=0,int b=0,int c=0){
p=a;
i=b;
r=c;
}
friend bool operator <(que a,que b){
return a.p<b.p;
}
};
struct sol{
int a,b,c,d;
sol(int A=0,int B=0,int C=0,int D=0){
a=A;
b=B;
c=C;
d=D;
}
};
int c[N];
bool vis[N];
int n,x,y,r,k,tot;
vector<que>l[N];
sol ans[N];
int abs(int x){
return x>0?x:-x;
}
int random(int l,int r){
return rand()%(r-l+1)+l;
}
int calc(int a,int b,int c,int d,int r){
return abs((b-a)*(d-c)-r);
}
int main(){
#ifndef ONLINE_JUDGE
freopen("0014.txt","r",stdin);
freopen("A.out","w",stdout);
#endif
clock_t t1=clock();
//--------
n=read();
srand(210280344);
for(int i=1;i<=n;++i){
x=read();
y=read();
r=read();
l[x].push_back(que(y,i,r));
vis[x]=1;
}
for(int i=0;i<N-7;++i){
if(vis[i]){
++tot;
c[tot]=i;
sort(l[i].begin(),l[i].end());
}
}
c[tot+1]=N-7;
for(int i=1;i<=tot;++i){
int A;
int B;
int C;
int D;
int sz=l[c[i]].size();
if(i==1)
A=random(0,c[i]);
else
A=random(c[i-1],c[i]);
C=random(c[i]+1,c[i+1]);
B=random(0,l[c[i]][0].p);
if(sz==1){
k=1e9;
r=l[c[i]][0].r;
for(int ii=1;ii<N;++ii){
int t=random(l[c[i]][0].p+1,N-7);
int s=calc(A,B,C,t,r);
if(k>s){
k=s;
D=t;
}
}
ans[l[c[i]][0].i]=sol(A,B,C,D);
c[i]=C;
continue;
}
k=1e9;
r=l[c[i]][0].r;
for(int ii=1;ii<N;++ii){
int t=random(l[c[i]][0].p+1,l[c[i]][1].p);
int s=calc(A,B,C,t,r);
if(k>s){
k=s;
D=t;
}
}
l[c[i]][0].p=D;
ans[l[c[i]][0].i]=sol(A,B,C,D);
for(int j=1;j<sz-1;++j){
B=random(l[c[i]][j-1].p,l[c[i]][j].p);
k=1e9;
r=l[c[i]][j].r;
for(int ii=1;ii<N;++ii){
int t=random(l[c[i]][j].p+1,l[c[i]][j+1].p);
int s=calc(A,B,C,t,r);
if(k>s){
k=s;
D=t;
}
}
l[c[i]][j].p=D;
ans[l[c[i]][j].i]=sol(A,B,C,D);
}
B=random(l[c[i]][sz-2].p,l[c[i]][sz-1].p);
k=1e9;
r=l[c[i]][sz-1].r;
for(int j=1;j<=N-7;++j){
int t=random(l[c[i]][sz-1].p+1,N-7);
int s=calc(A,B,C,t,r);
if(k>s){
k=s;
D=t;
}
}
ans[l[c[i]][sz-1].i]=sol(A,B,C,D);
c[i]=C;
}
for(int i=1;i<=n;++i){
int A=ans[i].a;
int B=ans[i].b;
int C=ans[i].c;
int D=ans[i].d;
printf("%d %d %d %d\n",A,B,C,D);
}
//--------
fprintf(stderr,"%0.3lfs",1.0*(clock()-t1)/CLOCKS_PER_SEC);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i = (m); i <= (n); i++)
#define zep(i,m,n) for(ll i = (m); i < (n); i++)
#define rrep(i,m,n) for(ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x,m,n) for(int i = (m); i <= n; i++){cout << (x[i]) << " ";} cout<<endl;
int main(){
cin.tie(0); ios::sync_with_stdio(false);
ll n; cin >> n;
ll a[2 * n]; char c[2 * n]; zep(i, 0, 2 * n)cin >> a[i] >> c[i];
multiset<ll> s[3];
zep(i, 0, 2 * n){
s[c[i] % 3].insert(a[i]);
}
if(s[0].size() % 2 == 0 && s[1].size() % 2 == 0 && s[2].size() % 2 == 0){
print(0) return 0;
}
// cout << 'R' % 3 << 'G' % 3 << 'B' % 3 << endl;
ll v[3][3];
zep(i, 0, 3)zep(j, 0, 3)v[i][j] = INF;
zep(i, 0, 3){
zep(j, 0, 3){
for(auto it = s[i].begin(); it != s[i].end(); it++){
ll x = *it;
if(s[j].lower_bound(x) != s[j].end()){
ll y = *s[j].lower_bound(x);
v[i][j] = min(v[i][j], y - x);
v[j][i] = min(v[j][i], y - x);
}
}
}
}
//zep(i, 0, 3){zep(j, 0, 3)cout << v[i][j] << " "; cout << endl;}
zep(i, 0, 3){
if(s[i].size() % 2 == 0){
print(min(v[(i + 1) % 3][(i + 2) % 3], v[i][(i + 1) % 3] + v[i][(i + 2) % 3]))
return 0;
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
template <unsigned long long mod> class modint {
public:
unsigned long long v;
modint(const long long x = 0) : v(x % mod) {}
modint operator+(const modint rhs) { return modint(*this) += rhs; }
modint operator-(const modint rhs) { return modint(*this) -= rhs; }
modint operator*(const modint rhs) { return modint(*this) *= rhs; }
modint operator/(const modint rhs) { return modint(*this) /= rhs; }
modint operator-() { return modint(mod - this->v); }
modint& operator+=(const modint rhs) {
v += rhs.v;
if (v >= mod) v -= mod;
return *this;
}
modint& operator-=(const modint rhs) {
if (v < rhs.v) v += mod;
v -= rhs.v;
return *this;
}
modint& operator*=(const modint rhs) {
v = v * rhs.v % mod;
return *this;
}
modint inverse(modint a) {
unsigned long long exp = mod - 2;
modint ret(1ULL);
while (exp) {
if (exp % 2) {
ret *= a;
}
a *= a;
exp >>= 1;
}
return ret;
}
modint& operator/=(modint rhs) {
(*this) *= inverse(rhs);
return *this;
}
friend ostream& operator<<(ostream& os, modint& u) {
os << u.v;
return (os);
}
friend istream& operator>>(istream& is, modint& u) {
is >> u.v;
return (is);
}
};
const int MOD = 1000000007;
using mint = modint<MOD>;
template <class T> T fastpow(T a, long long p) {
T tmp = a;
T ret = 1;
while (p) {
if (p & 1) ret *= tmp;
p >>= 1;
tmp = tmp * tmp;
}
return ret;
}
class Solution {
public:
void solve() {
int h, w;
cin >> h >> w;
vector<string> ss(h);
for (int i = 0; i < h; i++) cin >> ss[i];
vector<vector<int>> sx(h, vector<int>(w, 0));
vector<vector<int>> sy(h, vector<int>(w, 0));
int cv = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (ss[i][j] == '.') {
cv++;
if (i != 0)
sy[i][j] = sy[i - 1][j] + 1;
else
sy[i][j] = 1;
if (j != 0)
sx[i][j] = sx[i][j - 1] + 1;
else
sx[i][j] = 1;
}
}
}
for (int i = h - 1; i >= 0; i--) {
for (int j = w - 1; j >= 0; j--) {
if (ss[i][j] == '.') {
if (i != h - 1 && ss[i + 1][j] == '.') sy[i][j] = sy[i + 1][j];
if (j != w - 1 && ss[i][j + 1] == '.') sx[i][j] = sx[i][j + 1];
}
}
}
mint ans = fastpow(mint{2}, cv) * cv;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (ss[i][j] == '.') {
ans -= fastpow(mint{2}, cv - sx[i][j] - sy[i][j] + 1);
}
}
}
cout << ans << "\n";
return;
};
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
Solution solution;
solution.solve();
return 0;
}
| //
// main.cpp
// Atcoder1
//
// Created by Hamske on 2020/09/17.
// Copyright © 2020 Author. All rights reserved.
//
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <string>
#include <sstream>
using namespace std;
//#define pb push_back
//#define mp make_pair
#define fi first
#define se second
typedef long long ll;
//#define rep(_i,iv,n) for(int _i=(int)(iv);_i<(int)(n);++_i)
#define rep0(_i,n) for(int _i=0;_i<(int)(n);++_i)
//#define REP(_i,iv,_l,n) for(int _i=(int)(iv),_l=(int)(n);_i<_l;++_i)
#define REP0(_i,_l,n) for(int _i=0,_l=(int)(n);_i<_l;++_i)
//#define all(x) (x).begin(),(x).end()
#define REPV(v,_itr,_end) for(auto _itr=(v).begin(),_end=(v).end();_itr!=_end;++_itr)
#define REPVC(v,_itr,_end) for(auto _itr=(v).cbegin(),_end=(v).cend();_itr!=_end;++_itr)
#define td typedef
//#define tds(stl,type,name) typedef stl<type > name;
#define tdv(type,name) typedef vector<type > name;
typedef vector<bool> vb;
typedef vector<vb > vvb;
typedef vector<int> vi;
typedef vector<vi > vvi;
typedef vector<ll> vll;
typedef vector<vll > vvll;
#define INF 1<<30
td pair<int, int > pii;
td priority_queue<pii,vector<pii>,greater<pii> > pq;
#define mod7 1000000007
long long modpow(long long a, long long n, long long mod) {//O(log2(n))
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main(int argc, const char * argv[]) {
int H,W;
cin>>H>>W;
vvb room(H,vb(W));
int K=0;
rep0(i, H){
string str;
cin>>str;
rep0(j, W){
room[i][j]=str[j]=='.';
if(room[i][j]){
++K;
}
}
}//4e6
vvi rowCont(H,vi(W,0));
rep0(i,H){
rep0(j, W){
if(room[i][j]){
int count=0,j1=j;
while(j1<W&&room[i][j1]){
++count;
++j1;
}
while(j<j1){
rowCont[i][j]=count;
++j;
}
}
}
}
vvi colCont(H,vi(W,0));
rep0(j, W){
rep0(i,H){
if(room[i][j]){
int count=0,i1=i;
while(i1<H&&room[i1][j]){
++count;
++i1;
}
while(i<i1){
colCont[i][j]=count;
++i;
}
}
}
}
ll X=(modpow(2,K, mod7)*K)%mod7;
// cout<<"x="<<X<<endl;
rep0(i, H){//H*W*(4*H*W+log2(K-T))
rep0(j, W){
if(room[i][j]){
int T=colCont[i][j]+rowCont[i][j]-1;
// cout<<i<<","<<j<<":"<<T<<endl;
X-=modpow(2, K-T, mod7);
X%=mod7;
if(X<0){
X+=mod7;
}
}
}
}
cout<<X<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> p_ll;
typedef vector<pair<ll, ll>> vec_p; //vector<pair<ll, ll>> pairs(n) ,pairs.at(i) = make_pair(i*i, i)
#define ture ture
#define flase false
#define falg flag
#define REP(i, x) for (ll i = 0; i < (ll)(x); i++)
#define REPS(i, x) for (ll i = 1; i <= (ll)(x); i++)
#define RREP(i, x) for (ll i = ((ll)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (ll i = ((ll)(x)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
const ll MOD = pow(10, 9) + 7;
const ll LLINF = pow(2, 61) - 1;//llの最大9*10^18
const int INF = pow(2, 30) - 1;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll A,B;
string S;
cin >> A>>B;
ll tmp = 2 * A + 100;
cout << tmp - B << endl;
}
| #include <iostream>
using namespace std;
int main() {
int A,B;
cin>>A>>B;
int x=(2*A+100)-B;
cout<<x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
#define ll long long
#define print(a) \
for (auto x : a) \
cout << x << " "; \
cout << endl
#define print_upto(a, n) \
for (ll i = 1; i <= n; i++) \
cout << a[i] << " "; \
cout << endl
#define take(a, n) \
for (ll i = 1; i <= n; i++) \
cin >> a[i];
#define watch(x) cout << (#x) << " is " << (x) << "\n"
#define watch2(x, y) cout << (#x) << " is " << (x) << " and " << (#y) << " is " << (y) << "\n"
#define watch3(x, y, z) cout << (#x) << " is " << (x) << " and " << (#y) << " is " << (y) << " and " << (#z) << " is " << (z) << "\n"
#define watch4(x, y, z, u) cout << (#x) << " is " << (x) << " and " << (#y) << " is " << (y) << " and " << (#z) << " is " << (z) << " and " << (#u) << " is " << (u) << "\n"
void my_debugger(string s, int LINE_NUM)
{
cerr << endl;
}
template <typename start, typename... end>
void my_debugger(string s, int LINE_NUM, start x, end... y)
{
if (s.back() != ',')
{
s += ',';
cerr << "LINE(" << LINE_NUM << "): ";
}
int i = s.find(',');
cerr << s.substr(0, i) << " = " << x;
s = s.substr(i + 1);
if (!s.empty())
cerr << ", ";
my_debugger(s, LINE_NUM, y...);
}
#define debug(...) my_debugger(#__VA_ARGS__, __LINE__, __VA_ARGS__);
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define ff first
#define ss second
#define null NULL
#define all(c) (c).begin(), (c).end()
#define allr(c) (c).rbegin(), (c).rend()
#define nl "\n"
#define ld long double
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define MOD 1000000007
#define MOD2 998244353
#define set_bits(n) __builtin_popcountll(n)
#define inf 1e17
// cout << fixed << setprecision(15) << ans << nl;
// cout << "Case #" << Q << ": ";
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// auto dist = uniform_int_distribution<int>(l, r);
// ll random_val = dist(rng);
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> ppll;
const ll N = 200009;
ll Q = 0;
void solve()
{
ll a, b, c;
cin >> a >> b >> c;
if (a * a + b * b < c * c)
{
cout << "Yes" << nl;
}
else
{
cout << "No" << nl;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll T = 1;
// cin >> T;
auto start1 = high_resolution_clock::now();
while (T--)
{
Q++;
solve();
}
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
// cerr << "Time: " << duration.count() / 1000 << endl;
return 0;
}
| /*
@author : ashnove
*/
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define lld long double
#define F first
#define S second
#define Th third
// #define endl "\n"
#define nl cout << endl;
#define pb push_back
#define f(i, a, b) for (ll i = a; i < b; i++)
#define what_is(x) cerr << #x << " is " << x << endl;
#define ar vector<ll>
#define mat vector<vector<ll>>
mat cn(ll n, ll m) {return vector<vector<ll>>(n, vector<ll>(m));}
bool comp1(char &s1, char &s2) { return s1 > s2; }
bool comp2(const pair<ll, pair<ll, ll>> &a, const pair<ll, pair<ll, ll>> &b) {
if (a.first > b.first)
return 1;
if (a.first == b.first && a.S.S > b.S.S)
return 1;
return 0;
}
class Pair { public: ll first, second;};
bool comp3(const Pair &a, const Pair &b) {
if (a.F > b.F) return 1; return 0;
}
class Trips { public: ll first, second, third;};
bool comp4(const Trips &a, const Trips &b) {
if (a.Th > b.Th) return 1; return 0;
}
ll const mod = 1e9 + 7;
ll const inf = 1e18;
ll const maxn = 5e5 + 1;
void solve()
{
ll t = 1;
// cin >> t;
for (ll tt = 1; tt <= t; tt++) {
ll a,b,c; cin >> a >> b >> c;
cout << ( (a*a + b*b < c*c)?"Yes":"No");
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
//*
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif/**/
solve();
// cout << "Case #" <<tt<<": ";
// printf("TIME: %.3lf\n", double(clock()) / CLOCKS_PER_SEC);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define mii map <int, int>
#define mll map <ll, ll>
#define pii pair <int, int>
#define pll pair <ll, ll>
#define vi vector <int>
#define vd vector <double>
#define vll vector <ll>
#define fi first
#define se second
#define si set <int>
#define sll set <ll>
#define spii set <pii>
#define vs vector <string>
#define vpii vector <pair <int, int> >
#define vpll vector <pair <long long, long long> >
#define vvi vector <vector <int> >
#define vvpii vector <vector <pii > >
#define vb vector <bool>
#define vvb vector <vb>
#define mp make_pair
#define vvll vector <vll>
#define vsi vector <si>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define MANX MAXN
#define itn int
#define dbg(x); {cout << #x << "=" << x << ", ";}
#define in(x); { for (auto &to : x) cin >> to;}
#define out(x); { for (auto &to : x) cout << to << " "; cout << '\n'; }
template<class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; }
const ll INFLL = 1e18;
const int MAXN = 1e6+100;
const ll INF = 1e9;
const int mod1 = 1e9+7;
const int mod2 = 1e9+21;
void solve()
{
vi a(3);
in(a);
sort(all(a));
cout<<(a[1]-a[0]==a[2]-a[1]?"Yes\n":"No\n");
}
int main() {
#ifdef Mip182
freopen("a.in", "r", stdin);
#else
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif
int _t;
_t=1;
// cin>>_t;
while (_t--)
solve();
#ifdef Mip182
cout<<'\n'<<"Time : "<<(double)(clock())/CLOCKS_PER_SEC<<'\n';
#endif
}
| #include<bits/stdc++.h>
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) { cerr << name << " : " << arg1 << endl; }
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args&&... args) {
const char *comma = strchr(names + 1, ','); cerr.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
#define pi 3.14159265358979323846
#define MOD 1000000007
#define MOD1 998244353
#define to() int tt; cin>>tt; while(tt--)
#define pb push_back
#define in insert
#define mp make_pair
#define ff first
#define ss second
#define fori(it,v) for(it=v.begin();it!=v.end(); it++)
#define for1(i,low,high) for(int i=low;i<high;i++)
#define all(x) x.begin(), x.end()
#define fil(x,i) memset(x,i,sizeof(x));
#define setbits(x) __builtin_popcount(x)
#define boost ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
void i_o() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin) ; freopen("output.txt", "w", stdout); //freopen("error.txt", "w", stderr);
#endif
}
int main()
{
boost; i_o();
vector<ll>v(3);
for1(i,0,3) cin>>v[i];
sort(all(v));
if(v[0]+v[2]==2*v[1]) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define N 200100
#define MOD 1000000007 //998244353
#define ll long long
#define rep(i, n) for(int i = 0; i < n; ++i)
#define rep2(i, a, b) for(int i = a; i <= b; ++i)
#define rep3(i, a, b) for(int i = a; i >= b; --i)
#define eb emplace_back
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define vi vector<int>
#define pii pair<int,int>
#define pll pair<ll,ll>
struct Setup_io {
Setup_io() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
}
} setup_io;
int main() {
int n;
ll a[N];
ll b[N];
ll c[N];
ll x = 0;
cin >> n;
rep(i, n) {
cin >> a[i];
}
rep(i, n) {
cin >> b[i];
}
rep(i, n) {
x = max(x, a[i]);
if (i == 0)c[0] = a[0] * b[0];
else c[i] = max(c[i - 1], x*b[i]);
}
rep(i, n) {
cout << c[i]<<endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
#define all(a) a.begin(), a.end()
using namespace std;
using P = pair<int, int>;
using ll = long long;
using vi = vector<int>;
using vv = vector<vi>;
//const int mod = 1000000007;
const int mod = 998244353;
struct UnionFind{
vector<int> d;
UnionFind(int n=0): d(n, -1) {}
int root(int x){
if(d[x]<0)return x;
return d[x] = root(d[x]);
}
bool unite(int x, int y){
x = root(x); y = root(y);
if(x==y) return false;
if(d[x]>d[y]) swap(x,y);
d[x] += d[y]; d[y] = x;
return true;
}
bool same(int x, int y){return root(x) == root(y);}
int size(int x){return -d[root(x)];}
};
vector<ll> fac(51);
void fac_init(){
fac[0] = 1;
for(ll i=1; i<=50; i++){
fac[i] = fac[i-1] * i % mod;
}
}
int main(){
fac_init();
int n, k;
cin >> n >> k;
vv a(n, vi (n));
rep(i,n)rep(j,n)cin >> a[i][j];
UnionFind uf1(n), uf2(n);
for(int x=0; x<n; x++){
for(int y=x+1; y<n; y++){
bool ok = true;
rep(i,n)if(a[i][x]+a[i][y]>k)ok = false;
if(ok)uf1.unite(x,y);
}
}
for(int x=0; x<n; x++){
for(int y=x+1; y<n; y++){
bool ok = true;
rep(i,n)if(a[x][i]+a[y][i]>k)ok = false;
if(ok)uf2.unite(x,y);
}
}
vi check1(n, 0), check2(n, 0);
ll ans = 1;
rep(i,n){
if(check1[uf1.root(i)])continue;
check1[uf1.root(i)] = 1;
ans *= fac[uf1.size(i)];
ans %= mod;
}
rep(i,n){
if(check2[uf2.root(i)])continue;
check2[uf2.root(i)] = 1;
ans *= fac[uf2.size(i)];
ans %= mod;
}
cout << ans << endl;
return 0;
} |
#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <climits>
constexpr int SINT_MAX = std::numeric_limits<int>::max();
constexpr int SINT_MIN = std::numeric_limits<int>::min();
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
template<class T>
T choose(bool b, T t, T f)
{
if (b) return t;
else return f;
}
const char *YesNo(bool b)
{
return choose(b, "Yes", "No");
}
const char *YESNO(bool b)
{
return choose(b, "YES", "NO");
}
template<class NumT>
NumT diffabs(NumT l, NumT r)
{
if (l < r) return r-l;
else return l-r;
}
struct myinout_t {} io;
template<class T>
myinout_t &operator >>(myinout_t &my, T &i)
{
cin >> i;
return my;
}
myinout_t &operator >>(myinout_t &my, int &i)
{
int r = scanf("%d", &i);
if (r != 1) exit(EXIT_FAILURE);
return my;
}
myinout_t &operator >>(myinout_t &my, ll &i)
{
int r = scanf("%lld", &i);
if (r != 1) exit(EXIT_FAILURE);
return my;
}
template<class T>
myinout_t &operator <<(myinout_t &my, const T &i)
{
cout << i;
return my;
}
myinout_t &operator <<(myinout_t &my, int i)
{
printf("%d", i);
return my;
}
myinout_t &operator <<(myinout_t &my, ll i)
{
printf("%lld", i);
return my;
}
myinout_t &operator <<(myinout_t &my, double i)
{
printf("%.20f", i);
return my;
}
constexpr char BR = '\n';
///////////////////////////////////////////////////
const int MAX_N = 60; // n の最大値
vector<vector<long long>> com; // 前計算の結果を保存
void bi_init() {
com.assign(MAX_N, vector<long long>(MAX_N));
com[0][0] = 1;
for (int i = 1; i < MAX_N; ++i) {
com[i][0] = 1;
for (int j = 1; j < MAX_N; j++) {
com[i][j] = (com[i - 1][j - 1] + com[i - 1][j]);
}
}
}
long long bi(int n, int k) {
return com[n][k];
}
ll hbi(int n, int m)
{
return bi(n+m, m);
}
vector<char> f(int rest_a, int rest_b, ll K)
{
if (rest_a == 0)
{
return vector<char>(rest_b, 'b');
}
if (rest_b == 0)
{
return vector<char>(rest_a, 'a');
}
ll biA = hbi(rest_a - 1, rest_b);
if (K <= biA)
{
vector<char> t = f(rest_a - 1, rest_b, K);
t.push_back('a');
return t;
}
else
{
vector<char> t = f(rest_a, rest_b - 1, K - biA);
t.push_back('b');
return t;
}
}
int main()
{
int A , B;
ll K;
io >> A >> B >> K;
bi_init();
vector<char> ans = f(A, B, K);
reverse(ans.begin(), ans.end());
for (char c : ans)
{
io << c;
}
io << BR;
} | // atcoder/abc186/F/main.cpp
// author: @___Johniel
// github: https://github.com/johniel/
#include <bits/stdc++.h>
#define each(i, c) for (auto& i : c)
#define unless(cond) if (!(cond))
using namespace std;
template<typename P, typename Q> ostream& operator << (ostream& os, pair<P, Q> p) { os << "(" << p.first << "," << p.second << ")"; return os; }
template<typename P, typename Q> istream& operator >> (istream& is, pair<P, Q>& p) { is >> p.first >> p.second; return is; }
template<typename T> ostream& operator << (ostream& os, vector<T> v) { os << "("; for (auto& i: v) os << i << ","; os << ")"; return os; }
template<typename T> istream& operator >> (istream& is, vector<T>& v) { for (auto& i: v) is >> i; return is; }
template<typename T> ostream& operator << (ostream& os, set<T> s) { os << "#{"; for (auto& i: s) os << i << ","; os << "}"; return os; }
template<typename K, typename V> ostream& operator << (ostream& os, map<K, V> m) { os << "{"; for (auto& i: m) os << i << ","; os << "}"; return os; }
template<typename T> inline T setmax(T& a, T b) { return a = std::max(a, b); }
template<typename T> inline T setmin(T& a, T b) { return a = std::min(a, b); }
using lli = long long int;
using ull = unsigned long long;
using point = complex<double>;
using str = string;
template<typename T> using vec = vector<T>;
constexpr array<int, 8> di({0, 1, -1, 0, 1, -1, 1, -1});
constexpr array<int, 8> dj({1, 0, 0, -1, 1, -1, -1, 1});
constexpr lli mod = 1e9 + 7;
template<typename T>
struct SegTree {
int n;
int origin_size;
vector<T> v;
using F = function<T(T, T)>;
F fn;
T e;
SegTree(int n_, T e_, F fn_) {
origin_size = n_;
e = e_;
fn = fn_;
n = 1;
while (n < n_) n *= 2;
v.resize(2 * n - 1, e);
}
void update(size_t k, T a) {
k += n - 1;
v[k] = a;
while (k > 0) {
k = (k - 1) / 2;
v[k] = fn(v[k * 2 + 1], v[k * 2 + 2]);
}
return ;
}
T operator [] (size_t idx) const {
return v.at(idx + n - 1);
}
inline T operator () () const {
return query(0, origin_size, 0, 0, n);
}
inline T operator () (size_t a) const {
return query(a, a+1, 0, 0, n);
}
inline T operator () (size_t a, size_t b) const {
return query(a, b, 0, 0, n);
}
inline T query(size_t a, size_t b) const {
assert(a < b);
assert(b <= origin_size);
return query(a, b, 0, 0, n);
}
T query(size_t a, size_t b, size_t k, size_t l, size_t r) const {
if (r <= a || b <= l) return e;
if (a <= l && r <= b) return v.at(k);
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return fn(vl, vr);
}
};
int main(int argc, char *argv[])
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.setf(ios_base::fixed);
cout.precision(15);
lli h, w;
int m;
while (cin >> h >> w >> m) {
vec<pair<lli, lli>> v(m);
cin >> v;
each (i, v) --i.first, --i.second;
const int N = 2 * 1e5 + 5;
const lli inf = 1LL << 60;
static lli mn[N];
fill(mn, mn + N, h);
each (i, v) {
setmin(mn[i.second], i.first);
}
lli sum = 0;
for (int j = 0; j < w; ++j) {
if (mn[j] == 0) break;
sum += mn[j];
}
static vec<int> u[N];
fill(u, u + N, vec<int>());
each (i, v) {
u[i.first].push_back(i.second);
}
for (int i = 0; i < N; ++i) {
sort(u[i].begin(), u[i].end());
}
if (u[0].size()) {
for (int j = u[0].front(); j < w; ++j) {
u[0].push_back(j);
}
}
SegTree<int> segtree(N, 0, [] (int a , int b) { return a + b; });
for (int i = 1; i < h; ++i) {
if (u[i].size() && u[i].front() == 0) break;
each (j, u[i - 1]) {
segtree.update(j, 1);
}
sum += segtree.query(0, (u[i].empty() ? w : u[i].front()));
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, s) for (int i = 0; i < s; ++i)
#define ALL(v) (v).begin(), (v).end()
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define EACH(i, s) for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
#define DEBUG
#define int long long
#define INF 1e18
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T1, class T2> ostream& operator << (ostream &s, pair<T1,T2> P)
{ return s << '<' << P.first << ", " << P.second << '>'; }
template<class T> ostream& operator << (ostream &s, vector<T> P)
{ for (int i = 0; i < P.size(); ++i) { if (i > 0) { s << " "; } s << P[i]; } return s; }
template<class T> ostream& operator << (ostream &s, vector<vector<T> > P)
{ for (int i = 0; i < P.size(); ++i) { s << endl << P[i]; } return s << endl; }
template<class T> ostream& operator << (ostream &s, set<T> P)
{ EACH(it, P) { s << "<" << *it << "> "; } return s << endl; }
template<class T1, class T2> ostream& operator << (ostream &s, map<T1,T2> P)
{ EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; } return s << endl; }
template<class T>void show(vector<T>v){for (int i = 0; i < v.size(); i++){cerr<<v[i]<<" ";}cerr<<"\n";}
typedef long long ll;
string x="atcoder";
void solve(){
string s;
cin>>s;
//cerr<<string(s.size(),'a')<<endl;;
if(s>x){
cout<<0<<endl;
return ;
}
if(s==string(s.size(),'a')){
cout<<-1<<endl;
}
else{
for (int i = 0; i < s.size(); i++)
{
if(s[i]!='a'){
if(s[i]>'t'){
cout<<i-1<<endl;
}
else{
cout<<i<<endl;
}
return ;
}
}
}
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin>>t;
while(t--){
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int T, ans, howlong;
string S, Spoint, comppoint;
cin >> T;
for(int i = 0; i < T; i++){
cin >> S;
howlong = S.size();
if("atcoder" < S){
ans = 0;
}else{
for(int j = 0; j < howlong; j ++){
Spoint = S.at(j);
if("t" < Spoint){
ans = j - 1;
break;
}if("a" < Spoint){
ans = j;
break;
}else{
ans = -1;
}
}
}
cout << ans << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define ll long long
int main(){
int n;
cin >> n;
vector<string> s(n);
for(int i=0;i<n;i++){
cin >> s.at(i);
}
ll int ans = 1;
for(int i=0;i<n;i++){
if(s.at(i) == "OR"){
ll a = pow(2,i+1);
ans += a;
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <iomanip>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_map>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define repr(e,x) for(auto& e:x)
using namespace std;
typedef long long ll;
typedef long double ld;
//typedef pair<int,int> P;
double const PI=3.141592653589793;
int const INF=1001001001;
ll const LINF=1001001001001001001;
ll const MOD=1000000007;
int N;
string S[61];
ll dp[61][2];
int main(){
cin>>N;
repn(i,N) cin>>S[i];
dp[0][0]=1;
dp[0][1]=1;
repn(i,N){
rep(x,2) rep(y,2){
int n=x;
if(S[i]=="AND") n&=y;
else n|=y;
dp[i][n]+=dp[i-1][y];
}
}
cout<<dp[N][1]<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define dd double
#define endl "\n"
#define pb push_back
#define all(v) v.begin(),v.end()
#define mp make_pair
#define fi first
#define se second
#define vll vector<ll>
#define pll pair<ll,ll>
#define fo(i,n) for(int i=0;i<n;i++)
#define fo1(i,n) for(int i=1;i<=n;i++)
ll mod=1000000007;
ll n,k,t,m,q,flag=0;
ll power(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
// #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>
// ordered_set s ; s.order_of_key(a) -- no. of elements strictly less than a
// s.find_by_order(i) -- itertor to ith element (0 indexed)
ll min(ll a,ll b){if(a>b)return b;else return a;}
ll max(ll a,ll b){if(a>b)return a;else return b;}
ll gcd(ll a , ll b){ if(b > a) return gcd(b , a) ; if(b == 0) return a ; return gcd(b , a%b) ;}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
#ifdef NOOBxCODER
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
#define NOOBxCODER 0
#endif
//cin>>t;
t=1;
while(t--){
cin>>n>>k;
ll ans=0;
for(int i=2;i<=2*n;i++){
if(i-k>=2 && i-k<=2*n){
ans+= min(i-1,2*n+1-i)*min(i-k-1,2*n+1-i+k);
}
}
cout<<ans;
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
return 0;
}
| #include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<sstream>
#include<queue>
#include<list>
#include<stack>
#include<bitset>
#include<cmath>
#include<map>
#include<functional>
#define int long long
#define IO ios::sync_with_stdio(false)
#define ll int
using namespace std;
signed main()
{
IO;
int a,b,c,d,k,n;
while(cin>>n>>k){
k=(k>0)?k:-k;
ll ans=0;
for(ll i=2+k;i<=2*n;i++){ //枚举 A , A=k+B
ll A=i,B=i-k;
ll min_A=max(A-n,1ll);
ll max_A=min(A-1,n);
ll min_B=max(B-n,1ll);
ll max_B=min(B-1,n);
ans+=(max_A-min_A+1)*(max_B-min_B+1);
}
cout<<ans<<endl;
}
//PAUSE;
return 0;
} |
#include<bits/stdc++.h>
#define fo(i,n) for(int i=0;i<n;i++)
#define dsort(arr,n) sort(arr, arr + n, greater<int>())
#define vsortd(a) sort(a.begin(), a.end(), greater<double>())
#define vsort(a) sort(a.begin(), a.end())
#define dbg(x) cout<<#x<<'='<<(x)<<endl;
#define dbg2(x,y) cout<<#x<<'='<<(x)<<endl<<#y<<'='<<(y)<<endl;
#define dbg3(x,y,z) cout<<#x<<'='<<(x)<<endl<<#y<<'='<<(y)<<endl<<#z<<"="<<(z)<<endl;
#define dbg4(x,y,z,w) cout<<#x<<'='<<(x)<<endl<<#y<<'='<<(y)<<endl<<#z<<"="<<(z)<<endl<<#w<<"="<<(w)<<endl;
#define minheap priority_queue <int, vector<int>, greater<int> >
#define maxheap priority_queue <int>
#define test int tc;cin>>tc;while(tc--)
#define ll long long int
#define pb push_back
#define ff first
#define ss second
#define mpr make_pair
#define mkv vector<int>
#define allzero(dp) memset(dp,0,sizeof(dp))
#define endl "\n"
#define print(x) cout<<x<<endl;
#define full(v) v.begin(),v.end()
#define inf INT_MAX
const int mod=1e9+7;
using namespace std;
void fastio()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
bool compare(pair<ll,ll> a,pair<ll,ll> b){
if(a.first>b.first)return true;
if(a.first==b.first)return a.second<b.second;
return false;
}
ll power(ll x, ll y){
ll res = 1;x=x%mod;
while(y>0){
if(y&1)res=(res*x)%mod;
y=y>>1;x=(x*x)%mod;}
return res;
}
void solve()
{
ll z = 0;
ll b,c;cin>>b>>c;
if(b==0){
ll mimi = -c/2;
ll mimx = z;
ll mxmx = (c-1)/2;
ll mxmi = 0;
// dbg4(mimi,mimx,mxmi,mxmx)
if(mimx == 0 && mxmi == 0)
z=1;
print(mimx-mimi+1+mxmx-mxmi+1-z)
}
else if(b>0){
ll mimi = -b-(c-1)/2;
ll mimx = min(z,-(b-(c-1)/2));
ll mxmx = max(b,-(-b-(c-2)/2));
ll mxmi = max(z,b-c/2);
// dbg4(mimi,mimx,mxmi,mxmx)
if(mimx == 0 && mxmi == 0)
z=1;
print(mimx-mimi+1+mxmx-mxmi+1-z)
}
else{
b*=-1;
ll mimi = -b-c/2;
ll mimx = min(z,-(b-(c-2)/2));
ll mxmx = max(b,-(-b-(c-1)/2));
ll mxmi = max(z,b-(c-1)/2);
// dbg4(mimi,mimx,mxmi,mxmx)
if(mimx == 0 && mxmi == 0)
z=1;
print(mimx-mimi+1+mxmx-mxmi+1-z)
}
}
int main()
{
//cout<<fixed<<setprecision(20);
// fastio();
// test
solve();
}
| #define _CRT_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <utility>
#include <algorithm>
#include <functional>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <limits>
#include <numeric>
#include <valarray>
#include <fstream>
#include <array>
#include <random>
#include <unordered_set>
#include <unordered_map>
using namespace std;
using uint = uint32_t;
using LL = int64_t;
using ULL = uint64_t;
using PP = pair<LL, LL>;
template <typename T> using PriorityQ = priority_queue<T, vector<T>, greater<T> >;
#define REP(i, a, n) for(LL i = (a), i##_max_ = (n); i < i##_max_; ++i)
#define REM(i, a, n) for(LL i = (LL)(n) - 1, i##_min_ = (a); i >= i##_min_; --i)
#define FLOAT fixed << setprecision(16)
#define SPEEDUP { cin.tie(NULL); ios::sync_with_stdio(false); }
const int INF = 0x3FFFFFFF;
const LL INFLL = 0x3FFFFFFF3FFFFFFF;
const double INFD = 1.0e+308;
const double EPS = 1.0e-9;
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T, class U> istream& operator>>(istream& ist, pair<T, U>& right) { return ist >> right.first >> right.second; }
template <class T, class U> ostream& operator<<(ostream& ost, const pair<T, U>& right) { return ost << right.first << ' ' << right.second; }
template <class T, class TCompatible, size_t N> void Fill(T(&dest)[N], const TCompatible& val) { fill(dest, dest + N, val); }
template <class T, class TCompatible, size_t M, size_t N> void Fill(T(&dest)[M][N], const TCompatible& val) { for (int i = 0; i < M; ++i) Fill(dest[i], val); }
template <class T> T Next() { T buf; cin >> buf; return buf; }
istream& Ignore(istream& ist) { string s; ist >> s; return ist; }
bool Inside(int i, int j, int h, int w) { return i >= 0 && i < h&& j >= 0 && j < w; }
#ifdef ONLY_MY_ENVIR
#include "Accumulator.h"
#include "Algebraic.h"
#include "BinaryMatrix.h"
#include "BinaryTree.h"
#include "Bipartite.h"
#include "BIT.h"
#include "CartesianTree.h"
#include "Compressor.h"
#include "Decompositions.h"
#include "DiscreteLog.h"
#include "DominatorTree.h"
#include "DynamicMod.h"
#include "Exponential.h"
#include "Factorization.h"
#include "FFT.h"
#include "Field.h"
#include "FlatTree.h"
#include "FlowSolver.h"
#include "Geometric2D.h"
#include "Geometric2DFloat.h"
#include "Geometric3D.h"
#include "Geometric3DFloat.h"
#include "Graph.h"
#include "GraphUtil.h"
#include "HLD.h"
#include "Interpolation.h"
#include "IntMod.h"
#include "KDTree.h"
#include "LazySegmentTree.h"
#include "LCA.h"
#include "LIS.h"
#include "List.h"
#include "Math.h"
#include "MathUtil.h"
#include "Matrix.h"
#include "MatrixTree.h"
#include "Multivariate.h"
#include "MinCostFlowSolver.h"
#include "MinMax.h"
#include "Numbers.h"
#include "Optimize.h"
#include "Permutation.h"
#include "Polynomial.h"
#include "Position.h"
#include "Quadratic.h"
#include "Random.h"
#include "Range.h"
#include "Rational.h"
#include "RollingHash.h"
#include "RuntimeMod.h"
#include "SafeInt.h"
#include "SegmentTree.h"
#include "SegmentTree2D.h"
#include "Sets.h"
#include "Shortest.h"
#include "SlidingWindow.h"
#include "SpanningTree.h"
#include "StringSearching.h"
#include "SuffixArray.h"
#include "SwitchList.h"
#include "Timer.h"
#include "Tree.h"
#include "TreeUtil.h"
#include "UnionFind.h"
#include "Unicyclic.h"
#include "Util.h"
#include "VectorUtil.h"
#endif
#ifdef __GNUC__
using LLL = __int128;
istream& operator>>(istream& ist, __int128& val) { LL tmp; ist >> tmp; val = tmp; return ist; }
ostream& operator<<(ostream& ost, __int128 val) { LL tmp = val; ost << tmp; return ost; }
#else
using LLL = LL;
#endif
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << 21 - (a + b + c) << endl;
return 0;
}
// Included Files:
// * Main.cpp
|
#include <bits/stdc++.h>
#define endl "\n";
#define inf 1000000000000000;
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;
using vi = vector<int>;
using vii = vector<pi>;
using vll = vector<pl>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
const ll BIG=998244353;//1000000007
const double PI=3.141592653589793238;
#define FOR(i,a,b) for (ll i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (ll i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)
// pairs
#define mp make_pair
#define f first
#define s second
// vectors
#define sz(x) (int)(x).size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sor(x) sort(all(x))
#define rsz resize
#define ins insert
#define ft front()
#define bk back()
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
ll binpow(ll a,ll b,ll m)
{
ll res=1;
while(b>0){
if(b&1){res=(res*a)%m;}
b>>=1;a=(a*a)%m;
}
return res;
}
template <typename T,typename Q>
T max(T a,Q b)
{
if(a>b)
return a;
return b;
//return a+b-b^((a^b)&-(a<b));
}
template <typename T,typename Q>
T min(T a,Q b)
{
if(a<b)
return a;
return b;
//return b^((a^b)&-(a<b));
}
ll fact[1000001];
void precal()
{
fact[0]=1;
fact[1]=1;
for(int i=2;i<=1e6;i++)
{
fact[i]=(fact[i-1]*i)%BIG;
}
}
ll mod(ll a)
{
return a%BIG;
// return a-(BIG & -(a>=BIG));
}
ll imod(ll a)
{
return binpow(a,BIG-2,BIG);
}
ll C(ll a,ll b)
{
return mod(fact[a]*mod(imod(fact[a-b])*imod(fact[b])));
}
void solve()
{
int n;cin>>n;
vi v(n);
trav(a,v) cin>>a;
int p=-1,q=-1;
for(int i=2;i<=1000;i++)
{
int t=0;
trav(a,v)
{
if(a%i==0) t++;
}
if(t>p)
{
p=t;
q=i;
}
}
cout<<q;
}
int main() {
int t;t=1;
while(t--)
{
solve();
}
return 0;
}
| #include <bits/stdc++.h>
#include <cstdlib>
#include <algorithm>
using namespace std;
int main() {
long k;
string s, t;
cin >> k;
cin >> s >> t;
int c[10] = {0};
int d[10] = {0};
for(int i = 0; i < 4; i++){
int ss = s[i] - '0';
int tt = t[i] - '0';
c[ss]++;
d[tt]++;
}
long count = 0;
for(int i = 1; i <= 9; i++){
for(int j = 1; j <= 9; j++){
int flag = 0;
if(i == j){
if(c[i]+d[i]+2 <= k){
flag = 1;
}
} else {
if(c[i]+d[i]+1 <= k && c[j]+d[j]+1 <= k){
flag = 2;
}
}
if(flag == 1 || flag == 2){
long takahashi = 0 ;
long aoki = 0 ;
for(int k = 1; k <= 9; k++){
if(k == i){
takahashi += k*pow(10, c[k] + 1);
} else {
takahashi += k*pow(10, c[k]);
}
if(k == j){
aoki += k*pow(10, d[k] + 1);
} else {
aoki += k*pow(10, d[k]);
}
}
if(takahashi > aoki){
if(flag == 1) count += (k-c[i]-d[i]) * (k-c[j]-d[j]-1);
if(flag == 2) count += (k-c[i]-d[i]) * (k-c[j]-d[j]);
//cout << i << ' ' << j << endl;
}
}
}
}
cout << setprecision(15) << (double)(count)/(double)((9*k-8)*(9*k-9)) << endl;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <math.h>
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(a) ((a) < 0 ? (-(a)) : (a))
typedef long long ll;
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
ll t;
ll N;
scanf("%lld %lld", &t, &N);
ll q;
if ((100LL * N) % t == 0) q = (100LL * N) / t - 1;
else q = (100LL * N) / t;
printf("%lld\n", q + (t * q / 100) + 1);
return 0;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t, n;
cin >> t >> n;
bool vis[100005];
for (int i = 0; i < 100005; i++) vis[i] = false;
for (int i = 0; i <= 100000; i++) {
int x = ((100+t)*i)/100;
if (x < 100005) vis[x] = true;
}
vector<int> cyc;
for (int i = 0; i < 100005; i++) if (!vis[i]) {
if (cyc.size() < 100*t) {
cyc.push_back(i);
}
}
n--;
int res = (cyc[100*t-1]+1)*(n/(100*t));
n %= 100*t;
res += cyc[n];
cout << res << '\n';
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long t, N;
cin >> t >> N;
long long n = 100 * N / t;
if(100 * N % t != 0) n++;
n += (N - 1);
cout << n << endl;
} | #include <bits/stdc++.h>
#define IO ios::sync_with_stdio(NULL)
#define sc(z) scanf("%d", &(z))
#define _ff(i, a, b) for (ll i = a; i <= b; ++i)
#define _rr(i, a, b) for (ll i = b; i >= a; --i)
#define _f(i, a, b) for (ll i = a; i < b; ++i)
#define _r(i, a, b) for (ll i = b - 1; i >= a; --i)
#define mkp make_pair
#define endl "\n"
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 1e5 + 5;
int a[N];
int main() {
ll t, n; cin >> t >> n;
for (int i = 1; i <= 100; ++i) {
a[(100+t) * i / 100] = 1;
}
vector<int> v;
for (int i = 1; i <= 100 + t; ++i) {
if (!a[i]) v.push_back(i);
}
// for (int i : v) cout << i << " ";
ll ans;
if (n % v.size()) {
ans = (100 + t) * (n / v.size()) + v[n % v.size() - 1];
} else {
ans = (100 + t) * (n / v.size() - 1) + v[v.size() - 1];
}
cout << ans << endl;
return 0;
} |
#include<bits/stdc++.h>
#define rep(i,n) for (int i=0; i<n; i++)
#define REP(i,x,n) for (int i=x; i<n; i++)
#define P pair<int,int>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
#define T tuple<int, int, int>
const int MAX_N = 2e5;
vvi G(MAX_N);
void reveal(int v, int cnt, vi &ranks){
ranks[v] = cnt;
for (int nv : G[v]){
if (ranks[nv] != -1) continue;
reveal(nv, cnt+1, ranks);
}
}
void imos_dfs(int v, ll cnt, vector<ll> &V, vi &ranks){
cnt += V[v];
V[v] = cnt;
for (int nv : G[v]){
if (ranks[nv] < ranks[v]) continue;
imos_dfs(nv, cnt, V, ranks);
}
}
int main(){
int n;
cin >> n;
vector<ll> V(MAX_N);
vector<P> E;
vi ranks(MAX_N, -1);
rep(i,n-1){
int a, b;
cin >> a >> b;
a--; b--;
G[a].push_back(b);
G[b].push_back(a);
E.push_back(P(a, b));
}
reveal(0, 0, ranks);
int q;
cin >> q;
rep(i,q){
int t, e, x;
cin >> t >> e >> x;
e--;
int a = E[e].first;
int b = E[e].second;
if (t == 1){
if (ranks[a] > ranks[b]){
V[a] += x;
} else {
V[0] += x;
V[b] -= x;
}
} else {
if (ranks[b] > ranks[a]){
V[b] += x;
} else {
V[0] += x;
V[a] -= x;
}
}
}
imos_dfs(0, 0, V, ranks);
rep(i,n){
cout << V[i] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int N, M, Q;
cin >> N >> M >> Q;
vector<pair<int, int>> VW(N);
for(int i=0; i<N; i++){
int w, v;
cin >> w >> v;
VW[i] = {v, w};
}
sort(VW.rbegin(), VW.rend());
vector<int> X(M);
for(int i=0; i<M; i++) cin >> X[i];
while(Q--){
int l, r;
cin >> l >> r;
l--; r--;
multiset<int> st;
for(int i=0; i<l; i++) st.insert(X[i]);
for(int i=r+1; i<M; i++) st.insert(X[i]);
int ans = 0;
for(auto [v, w] : VW){
auto it = st.lower_bound(w);
if(it != st.end()){
ans += v;
st.erase(it);
}
}
cout << ans << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i,n,m) for(int i=(n);i<(m);i++)
#define REP(i,n) for(int i=0;i<(n);i++)
#define REPR(i,n) for(int i=(n);i>=0;i--)
#define all(vec) vec.begin(),vec.end()
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using P=pair<ll,ll>;
using PP=pair<ll,P>;
using vp=vector<P>;
using vpp=vector<PP>;
using vs=vector<string>;
#define fi first
#define se second
#define pb push_back
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return true;}return false;}
template<class T>bool chmin(T &a,const T &b){if(a>b){a=b;return true;}return false;}
template<typename A,typename B>istream&operator>>(istream&is,pair<A,B> &p){is>>p.fi>>p.se;return is;}
template<typename A,typename B>ostream&operator<<(ostream&os,const pair<A,B> &p){os<<"("<<p.fi<<","<<p.se<<")";return os;}
template<typename T>istream&operator>>(istream&is,vector<T> &t){REP(i,t.size())is>>t[i];return is;}
template<typename T>ostream&operator<<(ostream&os,const vector<T>&t){os<<"{";REP(i,t.size()){if(i)os<<",";os<<t[i];}cout<<"}";return os;}
const ll MOD=1000000007LL;
const int INF=1<<30;
const ll LINF=1LL<<60;
template<int mod>
struct ModInt{
int x;
ModInt():x(0){}
ModInt(long long y):x(y>=0?y%mod:(mod-(-y)%mod)%mod){}
ModInt &operator+=(const ModInt &p){
if((x+=p.x)>=mod)x-=mod;
return *this;
}
ModInt &operator-=(const ModInt &p){
if((x+=mod-p.x)>=mod)x-=mod;
return *this;
}
ModInt &operator*=(const ModInt &p){
x=(int)(1LL*x*p.x%mod);
return *this;
}
ModInt &operator/=(const ModInt &p){
*this*=p.inverse();
return *this;
}
ModInt operator-()const{return ModInt(-x);}
ModInt operator+(const ModInt &p)const{return ModInt(*this)+=p;}
ModInt operator-(const ModInt &p)const{return ModInt(*this)-=p;}
ModInt operator*(const ModInt &p)const{return ModInt(*this)*=p;}
ModInt operator/(const ModInt &p)const{return ModInt(*this)/=p;}
bool operator==(const ModInt &p)const{return x==p.x;}
bool operator!=(const ModInt &p)const{return x!=p.x;}
ModInt inverse()const{
int a=x,b=mod,u=1,v=0,t;
while(b>0){
t=a/b;
a-=t*b;
swap(a,b);
u-=t*v;
swap(u,v);
}
return ModInt(u);
}
friend ostream &operator<<(ostream &os,const ModInt<mod> &p){
return os<<p.x;
}
friend istream &operator>>(istream &is,ModInt<mod> &a){
long long x;
is>>x;
a=ModInt<mod>(x);
return (is);
}
};
const int mod=1e9+7;
using mint=ModInt<mod>;
mint mpow(mint a,int b){
if(!b){
return 1;
}
if(b%2){
return mpow(a,b-1)*a;
}else{
mint t=mpow(a,b/2);
return t*t;
}
}
int main(){
int n,p;
cin>>n>>p;
mint ans=(p-1);
ans*=mpow(p-2,n-1);
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std ;
const int MAX = 2004 ;
int arr[MAX] ;
int n ;
map<int , int>mp ;
vector<int>v ;
void factorize(int x)
{
for(int i = 1 ; i * i <= x ; ++i)
{
if(x % i == 0)
{
mp[i] = __gcd(mp[i] , x) ;
v.push_back(i) ;
if(x / i != i)
mp[x / i] = __gcd(mp[x / i] , x) , v.push_back(x / i) ;
}
}
}
int main()
{
ios_base::sync_with_stdio(0) ;
cin.tie(0) ;
cin>>n ;
for(int i = 0 ; i < n ; ++i)
cin>>arr[i] ;
for(int i = 0 ; i < n ; ++i)
factorize(arr[i]) ;
int Min = *min_element(arr , arr + n) ;
sort(v.begin() , v.end()) ;
v.erase(unique(v.begin() , v.end()) , v.end()) ;
int ans = 0 ;
for(auto &x : v)
{
if(x > Min)
break ;
if(mp[x] == x)
ans++ ;
}
return cout<<ans<<"\n" , 0 ;
} |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#endif
int main()
{
int64_t n;
cin >> n;
vector<int64_t> cs(n), as(n - 1), bs(n - 1);
for (auto &&c : cs)
{
cin >> c;
c--;
}
for (int64_t i = 0; i < n - 1; i++)
{
cin >> as[i] >> bs[i];
as[i]--;
bs[i]--;
}
vector<vector<int64_t>> g(n);
for (int64_t i = 0; i < n - 1; i++)
{
g[as[i]].emplace_back(bs[i]);
g[bs[i]].emplace_back(as[i]);
}
set<int64_t> ans;
vector<int64_t> cnt(100'000, 0);
auto dfs = [&](auto &&f, int64_t now, int64_t par = -1) -> void {
if (cnt[cs[now]] == 0)
{
ans.insert(now);
}
cnt[cs[now]]++;
for (auto &&nxt : g[now])
{
if (nxt == par)
{
continue;
}
f(f, nxt, now);
}
cnt[cs[now]]--;
};
dfs(dfs, 0);
for (auto &&x : ans)
{
cout << (x + 1) << endl;
}
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define rep2(i, a)for(auto i : a)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x, std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll mod = 998244353;
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll co(ll n, ll k) { ll a = 1; rep(i, 1ll, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }
ll modinv(ll a) { ll b = mod, u = 1, v = 0; while (b) { ll t = a / b; a -= t * b; swap(a, b); u -= t * v; swap(u, v); }u %= mod; if (u < 0) u += mod; return u; }
vector<vector<int>> G;
vector<int> c, used;
int t[100001];
vector<int> good;
void dfs(int v) {
if (used[v] == 1)return;
used[v] = 1;
if (t[c[v]] == 0)good.push_back(v + 1);
t[c[v]]++;
for (auto u : G[v])dfs(u);
t[c[v]]--;
}
int main() {
int n;
cin >> n;
G.resize(n);
c.resize(n);
used.resize(n);
rep(i, 0, n)cin >> c[i];
rep(i, 0, n - 1) {
int a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0);
sort(all(good));
for(auto v : good)printf("%d\n", v);
return 0;
} |
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#include <bits/stdc++.h>
#include <chrono>
using namespace std;
#define forr(i,n) for(int i = 0 ; i < n ; i++)
#define forr1(i,n) for(int i = 1 ; i <= n ; i++)
#define pb push_back
// #define int long long
#define endl "\n"
#define ll long long
#define sz(a) int(a.size())
const int mod = 998244353;
const int N = 2e5 + 10 ;
const ll inf = 1e9;
const int maxm = 1005;
vector<vector<char>> matrix(maxm , vector<char>(maxm));
// vector<vector<bool>> vt(maxm, vector<bool>(maxm));
struct event {
int x, y, size;
};
int dx[] = {0, 0, 1, - 1};
int dy[] = { -1, 1 , 0 , 0};
struct myComp {
constexpr bool operator()(pair<int, int> const& a, pair<int, int> const& b)const noexcept
{
return a.first < b.first;
}
};
bool cmp(pair<int, int>a , pair<int, int> b)
{
if (a.first == b.first)
return a.second < b.second ;
return a.first < b.first ;
}
string s ;
pair<bool, int> chk(int j )
{
int k = j ;
int n = sz(s);
for (int i = 0 ; i < n ; i++)
{
if ( k >= n)
{
// cout << "yes";
if (s[1] < s[0]) return {false, j};
}
if (s[i] > s[k]) return {true, k};
else if (s[i] < s[k]) return {false, k};
else if (s[i] == s[k])k++;
// cout << i << " " << k << " " << j << endl;
}
return {true, k} ;
}
void solve()
{
int n ;
cin >> n;
map<int, int> m ;
ll res = 0 ;
forr(i, n)
{
int x ;
cin >> x;
res += m[x];
m[x]++;
}
ll ans = (n * 1ll * (n - 1)) / 2 - res;
cout << ans ;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt" , "r" , stdin);
freopen("3.txt" , "w" , stdout);
#endif
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// int t;
// cin >> t;
// while (t--)
solve();
} | #pragma region Region_1
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
using ll = long long;
using P = pair<int, int>;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VP = vector<P>;
using VS = vector<string>;
using VC = vector<char>;
using VVC = vector<vector<char>>;
#define MOD 1000000007
const int INF = 1e9 + 10; // int max > 2*10^9
const long long INFL = (long long)2e18 + 10; // ll max > 9*10^18
template <class T, class C>
bool chmax(T& a, C b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class C>
bool chmin(T& a, C b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
T sum(const vector<T>& v) {
T res = 0;
for (size_t i = 0; i < v.size(); ++i) res += v[i];
return res;
}
/////////////////////////////////////////////////////////
// print like python
// https://qiita.com/Lily0727K/items/06cb1d6da8a436369eed
/////////////////////////////////////////////////////////
void print() { cout << endl; }
template <class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
cout << head;
if (sizeof...(tail) != 0) cout << " ";
print(forward<Tail>(tail)...);
}
template <class T>
void print(vector<T>& vec) {
for (auto& a : vec) {
cout << a;
if (&a != &vec.back()) cout << " ";
}
cout << endl;
}
template <class T>
void print(vector<vector<T>>& df) {
for (auto& vec : df) {
print(vec);
}
}
#pragma endregion Region_1
/////////////////////////////////////////////////////////
int main() {
//入力の高速化用のコード
ios::sync_with_stdio(false);
cin.tie(nullptr);
std::cout << std::setprecision(15);
//////////////////////////////////////////
string s;
ll M;
cin >> s;
cin >> M;
int maxd = 0;
VI sv;
for (char c : s) {
chmax(maxd, (c - '0'));
sv.push_back((c - '0'));
}
if(sv.size()==1){
if(maxd <= M)print(1);
else print(0);
return 0;
}
auto n_fnc = [&](ll m) {
if (m == 1) return false;
ll v = 1;
ll tot = 0;
drep(i, sv.size()) {
if (((ll)1e18+v-1) / v < sv[i]) return false;
tot += v * sv[i];
if (tot > M) {
return false;
}
if (i > 0) {
if (((ll)1e18+v-1) / v < m){
return false;
}
}
v *= m;
}
return true;
};
ll l = maxd, r = (ll)1e18 + 1;
while (l + 1 < r) {
ll mid = (l + r) / 2;
if (n_fnc(mid)) {
l = mid;
} else
r = mid;
}
print(l-maxd);
return 0;
}
|
#include<bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#define endl "\n"
#define pb push_back
#define ll long long
#define d1(x) cerr << #x << "--> " << x << endl
#define d2(x,y) cerr << #x << "--> " << x << " | " << #y << "--> " << y <<endl
#define d3(x,y,z) cerr << #x << "--> " << x << " | " << #y << "--> " << y <<" | " << #z << "--> "<< z<< endl
#define d4(x,y,z,w) cerr << #x << "--> " << x << " | " << #y << "--> " << y <<" | " << #z << "--> "<< z << " | "<< #w << "--> " << w <<endl
#define vpll vector<pair<ll,ll>>
#define F first
#define S second
using namespace std;
ll mode = 1e9 + 7;
const ll maxn = 1e6 + 5;
const ll inf = 1e18;
ll __lcm(ll a, ll b){ return (a*b)/__gcd(a,b); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll getRand(ll l, ll r){ uniform_int_distribution<int> uid(l, r); return uid(rng); }
template <class A, class B> ostream& operator << (ostream& out, const pair<A, B> &a) { return out << "(" << a.F << ", " << a.S << ")"; }
template <class A> ostream& operator << (ostream& out, const vector<A> &v) {
out << "["; for (int i=0;i<v.size();i++) { if(i) out << ", "; out << v[i]; } return out << "]"; }
vector<ll> primes;
vector<ll> spf(maxn);
void sieve(){
spf[1] = 1;
for (ll i=2; i<maxn; i++)
spf[i] = i;
for (ll i=4; i<maxn; i+=2)
spf[i] = 2;
primes.push_back(2);
for (ll i=3; i<maxn; i++) {
if (spf[i] == i) {
primes.push_back(i);
for (ll j=i; j<maxn; j+=i)
if (spf[j]==j)
spf[j] = i;
}
}
}
map<ll,ll> fact(ll x) {
map<ll,ll> mp;
while (x != 1)
{
mp[spf[x]]++;
x = x / spf[x];
}
return mp;
}
ll get(ll a, ll b){
if (a<=1) return 0;
map<ll,ll> mp = fact(a);
vector<ll> factor;
for (auto i:mp){
factor.push_back(i.first);
}
map<ll,ll> sub;
ll n = factor.size();
for (int i=1;i<(1<<n);i++){
ll x = i;
ll num = 1;
for (int j=0;j<n;j++, x/=2){
if (x&1){
num *= factor[j];
}
}
sub[i] += (b/num);
}
ll ans = 0;
for (auto i:sub){
ll count = __builtin_popcount(i.first);
if (count%2) ans += i.second;
else ans -= i.second;
}
ans = ans - (b/a);
//if (spf[a]==a) ans += (b/a);
return ans;
}
void solve(){
ll l, r;
cin>>l>>r;
ll res = 0;
for (int i=l;i<=r;i++){
ll add = get(i, r) - get(i, i-1);
//d3(i, get(i,r), get(i, i-1));
res += add;
}
res += res;
cout<<res<<endl;
}
int main(){
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
srand(time(0));
ios::sync_with_stdio(0);
cin.tie(0);
sieve();
ll test_case = 1;
//cin>>test_case;
for (int i=1;i<=test_case;i++){
solve();
}
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <set>
using namespace std;
long long int L, R;
long long int ans = 0;
int p[1000006];
vector<int>V;
long long int num[1000006];
int c[1000006];
vector<int> PRIME(int k) {
vector<int> ret;
for (auto y : V) {
if (y*y > k) { break; }
if (k <= 1) { break; }
if (k%y == 0) {
ret.push_back(y);
while (k%y == 0) {
k /= y;
}
}
}
if (k != 1) { ret.push_back(k); }
return ret;
}
int main(void) {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> L >> R;
/* for (int i = 2; i <= R; i++) {
c[i] = 1;
}
for (int i=2; i <= R; i++) {
if (c[i] == 1) {
for (int j = i * 2; j <= R; j += i) {
c[j] = 0;
}
}
}
for (int i = 2; i <= R; i++) {
if (c[i] == 1) { V.push_back(i); }
}
*/
for (int i = R; i >= 2; i--) {
long long int r = R / i;
long long int l = max((long long int)i-1, (L - 1)) / i;
num[i] = (r-l)*(r-l);
for (int j = i * 2; j <= R; j += i) {
num[i] -= num[j];
}
}
long long int ans = 0;
for (int i = 2; i <= R; i++) {
ans += num[i];
}
/* for (int i = 1; i <= 20; i++) {
cout << "num[" << i << "]= " << num[i] << endl;
}*/
long long int sum1 = 0;
for (long long int i = max(L,2LL); i <= R; i++) {
for (int j = i * 2; j <= R; j += i) {
sum1++;
}
}
//cout << "sum1= " << sum1 << endl;
ans -= sum1 * 2;
ans -= (R - max(L,2LL) + 1);
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<queue>
using namespace std;
int main()
{
string s,t;
long long n , ans=0 , sone=0 , tone=0 , erase=0; cin>>n>>s>>t;
queue<int> que;
for(int i=0;i<n;i++)
{
if(s[i]=='1'&&erase>0){
ans+=i-que.front();
que.pop();
erase-- , s[i]='0';
}
if(s[i]=='1') sone++;
if(t[i]=='1') tone++;
if(sone>tone){
s[i]='0' , erase++ , sone--;
que.push(i);
}
else if(sone==tone)
sone-- , tone--;
}
sone=tone=0;
for(int i=0;i<n;i++)
if(s[i]=='1') sone++;
for(int i=0;i<n;i++)
if(t[i]=='1') tone++;
if(sone<tone){
puts("-1");
return 0;
}
while(que.size())
que.pop();
for(int i=0;i<n;i++)
{
if(t[i]=='1')
que.push(i);
if(s[i]=='1'){
ans+=i-que.front();
que.pop();
}
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
#include <time.h>
#define rep(i, n) for(int i=0;i<(int)(n);i++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll=long long;
typedef pair<int,int> P;
bool LOCAL_TEST = false;
int h[30][30],v[30][30];
double priority[30][30];
vector<string> paths;
map<int,char> mp;
inline void InitRand(){
srand((unsigned int)time(NULL));
}
void read_s_t_a_e(){
int si,sj,ti,tj,a;
double e;
cin>>si>>sj>>ti>>tj>>a>>e;
string path;
if(si<=ti) rep(j,ti-si) path+='D';
else rep(j,si-ti) path+='U';
if(sj<=tj) rep(j,tj-sj) path+='R';
else rep(i,sj-tj) path+='L';
paths.push_back(path);
}
void move(int si,int sj,int ti,int tj,string& path){
int y=si,x=sj;
while(y!=ti||x!=tj){
if(y==ti){
rep(i,abs(tj-x)) path+=mp[1];
break;
}
else if(x==tj){
rep(i,abs(ti-y)) path+=mp[0];
break;
}
int next=rand()%2;
path+=mp[next];
if(next==0){
if(y<ti) y++;
else y--;
}else{
if(x<tj) x++;
else x--;
}
}
}
void read_s_t(){
int si,sj,ti,tj;
cin>>si>>sj>>ti>>tj;
string path;
if(si<=ti) mp[0]='D';
else mp[0]='U';
if(sj<=tj) mp[1]='R';
else mp[1]='L';
move(si,sj,ti,tj,path);
cout<<path<<endl;
flush(cout);
int a;
cin>>a;
}
int main(){
rep(i,30) fill(priority[i],priority[i]+30,-1);
if(LOCAL_TEST){
rep(i,30) rep(j,29) cin>>h[i][j];
rep(i,29) rep(j,30) cin>>v[i][j];
}
rep(k,1000){
if(LOCAL_TEST) read_s_t_a_e();
else read_s_t();
}
if(LOCAL_TEST){
ofstream output("out.txt");
rep(k,1000) output<<paths[k]<<'\n';
}
} |
// Problem: B - Abbreviate Fox
// Contest: AtCoder - AtCoder Regular Contest 108
// URL: https://atcoder.jp/contests/arc108/tasks/arc108_b
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define X first
#define Y second
#define pb push_back
#define dlt decltype
#define vi vector<int>
#define vii vector<vector<int>>
#define INF 0x3f3f3f3f
using namespace std;
#ifdef LOCAL
namespace DEBUG {
template <typename T>
inline void _debug(const char* format, T t) {
cerr << format << '=' << t << endl;
}
template <class First, class... Rest>
inline void _debug(const char* format, First first, Rest... rest) {
while (*format != ',') cerr << *format++;
cerr << '=' << first << ",";
_debug(format + 1, rest...);
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& V) {
os << "[ ";
for (const auto& vv : V) os << vv << ", ";
os << "]";
return os;
}
#define debug(...) _debug(#__VA_ARGS__, __VA_ARGS__)
}
using namespace DEBUG;
#endif
template<class T1,class T2>
inline bool cmin(T1 &a,T2 b){return a>b?a=b,1:0;}
template<class T1,class T2>
inline bool cmax(T1 &a,T2 b){return a<b?a=b,1:0;}
template<class T1,class T2,class ...T3>
inline bool cmin(T1 &a,T2 b,T3 ...rest){return cmin(a,b)||cmin(a,rest...);}
template<class T1,class T2,class ...T3>
inline bool cmax(T1 &a,T2 b,T3 ...rest){return cmin(a,b)||cmax(a,rest...);}
ll gcd(ll a,ll b){return b==0?a:gcd(b,a%b);}
ll gi(){
ll i=0;bool f=false;char c;
while (!isdigit(c=getchar())) f=c=='-';
do i=(i<<3)+(i<<1)+c-'0'; while (isdigit(c=getchar()));
return f?-i:i;
}
int main(){
int n=gi();
string a;
for (int i=1;i<=n;i++) a+=getchar();
char b[200010];int ni=0;
for (auto &i:a){
b[ni++]=i;
while (ni>=3&&
b[ni-1]=='x'&&
b[ni-2]=='o'&&
b[ni-3]=='f'
) ni-=3,n-=3;
}
cout << n;
}
| #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;
typedef long long ll;
template <class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937/*_64*/ rng(chrono::steady_clock::now().time_since_epoch().count());
#define printArr(arr, n) cerr << #arr << " = ["; for(int i=0; i<(n); i++){if (i) cerr << ", "; cerr << arr[i];} cerr << "]\n"
template<class A> ostream& operator<<(ostream &cout, vector<A> const &v) {cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";};
template<class A, class B> ostream& operator<<(ostream &cout, const pair<A,B> &x) {return cout << "(" <<x.first << ", " << x.second << ")";};
void _print() {cerr << "]\n";}
template <class T, class... V> void _print(T t, V... v) {cerr << t; if (sizeof...(v)) cerr << ", "; _print(v...);}
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#define fi first
#define se second
#define SZ(x) (int)((x).size())
#define pii pair<int,int>
struct dsu{
vector<int> v, sz, edge;
dsu(int n) : v(n), sz(n,1), edge(n)
{
iota(v.begin(), v.end(), 0);
}
int root(int a)
{
return (v[a] == a ? a : v[a] = root(v[a]));
}
bool unite(int a, int b)
{
int a1 = root(a), b1 = root(b);
if (a1 == b1) {
edge[a1]++;
return false;
}
if (sz[a1] < sz[b1]) swap(a1,b1);
sz[a1]+=sz[b1];
v[b1] = a1;
edge[a1] += edge[b1]+1;
return true;
}
};
const int mx = 400005;
dsu d(mx);
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int q = 0; q < n; q++) {
int a,b;
cin >> a >> b;
d.unite(a,b);
}
int ans = 0;
for (int q = 1; q < mx; q++) {
if (d.root(q) != q) continue;
ans += min(d.edge[q], d.sz[q]);
}
cout << ans << "\n";
return 0;
}
|
#include "bits/stdc++.h"
#define rep0(var,cnt) for(int (var)=0; (var)<(int)(cnt); ++(var))
#define rep1(var,cnt) for(int (var)=1; (var)<(int)(cnt); ++(var))
#define repi(var,init,cnt) for(int (var)=(init); (var)<(int)(cnt); ++(var))
#define Yn(flag) cout<<(flag?"Yes":"No")
#define pre(var) cout<<fixed<<setprecision(var);
using namespace std;
using ll = long long;
using ull = unsigned long long;
template<typename T>
using vec = vector<T>;
template<typename T>
using mat = vector<vec<T>>;
template<typename T>
ostream &operator<<(ostream &os, const vector<T> &v){
for(int i=0; i<(int)v.size(); ++i){
os<<v[i]<<" ";
}
return os;
}
template<typename T>
istream &operator>>(istream &is, vector<T> &v){
for(T &in:v) is>>in;
return is;
}
template<typename T>
T chclamp(T x, T low, T high){
if(x<low) return low;
if(x>high) return high;
return x;
}
template< int mod >
struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if((x += p.x) >= mod) x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if((x += mod - p.x) >= mod) x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int) (1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while(b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while(n > 0) {
if(n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) {
return os << p.x;
}
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt< mod >(t);
return (is);
}
static int get_mod() { return mod; }
};
void MAIN(void);
int main(void){
cin.tie(0);
ios::sync_with_stdio(0);
//pre(10);
MAIN();
}
// Usual Template End =========================================
// Template End ===============================================
ll INF=numeric_limits<ll>::max()/4;
constexpr int MOD=1e9+7;
using mint = ModInt<MOD>;
#define between(a,b,c) ((a)<=(b))&&((b)<(c))
void MAIN(void){
int H,W,X,Y; cin>>H>>W>>X>>Y;
vec<string> S(H); cin>>S;
--X,--Y;
int ans=1;
int dx[]={0,1,0,-1},dy[]={1,0,-1,0};
for(int i=0; i<4; ++i){
int x=X,y=Y;
while(1){
x+=dx[i],y+=dy[i];
//cout<<x<<y<<endl;
if(!(between(0,x,H)&&between(0,y,W))) break;
else if(S[x][y]=='.') ++ans;
else break;
}
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i=0; i<(n); i++)
#define rep2(i,n) for (int i=1; i<(n); i++)
using ll = long long;
using P = pair<int,int>;
int main() {
int a,b,x,y; cin >> a >> b >> x >> y;
int fast = min(y,2*x);
int dist = abs((2*b+1)-(2*a));
int ans = (dist/2)*fast+x;
cout << ans << endl;
} |
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 2e5+8, inf = 1e18+9, mod = 998244353;
struct node { int a; char c; } a[maxn];
int n, m;
void solve() {
int i, j;
cin >> n; n *= 2;
for (i = 1; i <= n; i++) cin >> a[i].a >> a[i].c;
sort(a + 1, a + n + 1, [](node &o1, node &o2) { if (o1.c != o2.c) return o1.c < o2.c; else return o1.a < o2.a; });
vector<int> R, G, B;
for (i = 1; i <= n; i++) {
if (a[i].c == 'R') R.push_back(a[i].a);
else if (a[i].c == 'G') G.push_back(a[i].a);
else B.push_back(a[i].a);
}
if (B.size() % 2 != 0) {
if (R.size() % 2 == 0) swap(B, R);
else swap(B, G);
}
if (R.size() % 2 == 0) return (void)(cout << 0 << endl);
int ans = inf; i = 0, j = 0;
while (i < R.size() && j < G.size()) {
ans = min(ans, llabs(R[i] - G[j]));
if (R[i] < G[j]) i++;
else j++;
}
i = 0, j = 0;
while (i < R.size() && j < G.size()) {
ans = min(ans, llabs(R[i] - G[j]));
if (G[j] < R[i]) j++;
else i++;
}
int idx = 0, idx2 = 0, g1 = inf, g2 = inf;
i = 0; j = 0;
while (i < R.size() && j < B.size()) {
if (g1 > llabs(R[i] - B[j])) g1 = llabs(R[i] - B[j]), idx = j;
if (R[i] < B[j]) i++;
else j++;
}
i = 0; j = 0;
while (i < R.size() && j < B.size()) {
if (g1 > llabs(R[i] - B[j])) g1 = llabs(R[i] - B[j]), idx = j;
if (B[j] < R[i]) j++;
else i++;
}
i = 0; j = 0;
while (i < G.size() && j < B.size()) {
if (j == idx) {
j++;
continue;
}
if (g2 > llabs(G[i] - B[j])) g2 = llabs(G[i] - B[j]);
if (G[i] < B[j]) i++;
else j++;
}
i = 0; j = 0;
while (i < G.size() && j < B.size()) {
if (j == idx) {
j++;
continue;
}
if (g2 > llabs(G[i] - B[j])) g2 = llabs(G[i] - B[j]);
if (B[j] < G[i]) j++;
else i++;
}
ans = min(ans, g1 + g2);
g1 = g2 = inf;
while (i < G.size() && j < B.size()) {
if (g1 > llabs(G[i] - B[j])) g1 = llabs(G[i] - B[j]), idx = j;
if (G[i] < B[j]) i++;
else j++;
}
i = 0; j = 0;
while (i < G.size() && j < B.size()) {
if (g1 > llabs(G[i] - B[j])) g1 = llabs(G[i] - B[j]), idx = j;
if (B[j] < G[i]) j++;
else i++;
}
i = 0; j = 0;
while (i < R.size() && j < B.size()) {
if (j == idx) {
j++;
continue;
}
if (g2 > llabs(R[i] - B[j])) g2 = llabs(R[i] - B[j]);
if (R[i] < B[j]) i++;
else j++;
}
i = 0; j = 0;
while (i < R.size() && j < B.size()) {
if (j == idx) {
j++;
continue;
}
if (g2 > llabs(R[i] - B[j])) g2 = llabs(R[i] - B[j]);
if (B[j] < R[i]) j++;
else i++;
}
ans = min(ans, g1 + g2);
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); //cout << fixed << setprecision(15);
int t = 1; //cin >> t;
while (t--) solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long int
#define rep(i, a, b) for (int i = a; i < b; i++)
#define revrep(i, a, b) for (int i = a; i >= b; i--)
#define pb push_back
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
ostream &operator<<( ostream &output, const pii &p ) { output << p.first << " " << p.second;return output; }
istream &operator>>( istream &input, pii &p ) { input >> p.first >> p.second;return input; }
template<typename T>
void inline println(vector<T> args){ for(T i: args)cout<<i<<" ";cout<<endl; }
int INF = 1e18;
int MOD = 1e9+7;
void solve()
{
int n;cin>>n;
map<int, int> mp;
rep(i, 0, n) {
int temp;cin>>temp;
mp[temp]++;
}
if(n%2 == 0) {
int first = true;
for(auto pr: mp)
if(pr.second%2 != 0) first = false;
if(first) cout<<"Second";
else cout<<"First";
} else {
cout<<"Second";
}
cout<<endl;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--)
{
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#include<tuple>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<string> > vvs;
typedef vector<vector<ll> > vvll;
typedef vector<vector<bool> > vvb;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define irep(it, stl) for (auto it = stl.begin(); it != stl.end(); it++)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define mes(a) cout << (a) << endl
#define dmes(a, b) cout << (a) << " " << (b) << endl
#define CHOOSE(a) CHOOSE2 a
#define CHOOSE2(a0,a1,a2,a3,a4,x,...) x
#define debug_1(x1) cout<<#x1<<": "<<x1<<endl
#define debug_2(x1,x2) cout<<#x1<<": "<<x1<<", "#x2<<": "<<x2<<endl
#define debug_3(x1,x2,x3) cout<<#x1<<": "<<x1<<", "#x2<<": "<<x2<<", "#x3<<": "<<x3<<endl
#define debug_4(x1,x2,x3,x4) cout<<#x1<<": "<<x1<<", "#x2<<": "<<x2<<", "#x3<<": "<<x3<<", "#x4<<": "<<x4<<endl
#define debug_5(x1,x2,x3,x4,x5) cout<<#x1<<": "<<x1<<", "#x2<<": "<<x2<<", "#x3<<": "<<x3<<", "#x4<<": "<<x4<<", "#x5<<": "<<x5<<endl
#define debug(...) CHOOSE((__VA_ARGS__,debug_5,debug_4,debug_3,debug_2,debug_1,~))(__VA_ARGS__)
#define ynmes(a) (a) ? mes("Yes") : mes("No")
#define YNmes(a) (a) ? mes("YES") : mes("NO")
#define re0 return 0
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define rSort(a) sort(a.rbegin(), a.rend())
#define Rev(a) reverse(a.begin(), a.end())
#define MATHPI acos(-1)
#define itn int;
int dx[8] = { 1, 0, -1, 0, 1, -1, -1, 1 };
int dy[8] = { 0, 1, 0, -1, 1, 1, -1, -1 };
template <class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template <class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
struct io { io() { ios::sync_with_stdio(false); cin.tie(0); } };
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
const double EPS = 1e-9;
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; }
ll modpow(ll x, ll y) {
if(y == 1) {
return x;
}
ll ans;
if(y % 2 == 1) {
ll r = modpow(x,(y-1)/2);
ans = r * r % MOD;
ans = ans * x % MOD;
}
else {
ll r = modpow(x,y/2);
ans = r * r % MOD;
}
return ans;
}
ll modncr(ll N, ll K) {
ll res = 1;
ll p=1;
for (ll n = 0; n < K; ++n) {
res = (res*(N - n))%MOD;
p = (p*(n + 1))%MOD;
}
return (res*modpow(p,MOD-2))%MOD;
}
signed main() {
ll n;
cin >> n;
vll a(n), b(n);
vll s(n);
map <ll, ll> mp;
vector<tuple<ll, ll, ll> > tp(n);
ll ss = 0;
ll as = 0;
rep(i, n) {
cin >> a[i] >> b[i];
s[i] = 2*a[i] + b[i];
tp.pb(make_tuple(s[i], a[i], a[i]+b[i]));
ss += a[i] + b[i];
as += a[i];
}
rSort(tp);
ll sum = 0;
ll pos = 1;
while(sum <= as) {
sum += get<2>(tp[pos-1]);
as -= get<1>(tp[pos-1]);
pos++;
}
mes(pos-1);
}
|
/**
* Dont raise your voice, improve your argument.
* --Desmond Tutu
*/
#include <bits/stdc++.h>
using namespace std;
const bool ready = [](){
ios_base::sync_with_stdio(false); cin.tie(0);
cout << fixed << setprecision(12);
return true;
}();
using ld=long double;
const ld PI = acos((ld)-1);
using ll= long long;
#define int ll
#define all(v) (v).begin(), (v).end()
#define fori(n) for(int i=0; i<int(n); i++)
#define cini(i) int i; cin>>i;
#define cins(s) string s; cin>>s;
#define cind(d) ld d; cin>>d;
#define cinai(a,n) vi a(n); fori(n) { cin>>a[i]; }
#define cinas(s,n) vs s(n); fori(n) { cin>>s[i]; }
#define cinad(a,n) vd a(n); fori(n) { cin>>a[i]; }
using pii= pair<int, int>;
using pdd= pair<ld, ld>;
using vd= vector<ld>;
using vb= vector<bool>;
using vi= vector<int>;
using vvi= vector<vi>;
using vs= vector<string>;
#define endl "\n"
/*
* WA.
* Some overflow?
* Got the statement wrong?
* -> villages are not sorted :/
*/
void solve() {
cini(n);
cini(k);
vector<pii> ab(n);
for(int i=0; i<n; i++)
cin>>ab[i].first>>ab[i].second;
sort(all(ab));
int pos=0;
for(int i=0; i<n; i++) {
pos+=k;
k=0;
if(pos>=ab[i].first) {
k+=ab[i].second;
} else {
break;
}
}
pos+=k;
cout<<pos<<endl;
}
signed main() {
solve();
} |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long
#define x1 first
#define y1 second
#define frb(i,a,b) for(ll (i)=(a);(i) <= (b); (i)+=(i)&-(i))
#define rfrb(i,a) for(ll (i)=(a);(i) > 0;(i)-=(i)&-(i))
#define fr(i,a,b) for(ll (i) = (a); (i) <= (b); (i)++)
#define rep(i,c) for(auto (i) : (c))
#define mini(a,b) ((a) < (b)) ? (a) : (b)
#define maxi(a,b) ((a) > (b)) ? (a) : (b)
#define par pair<ll,ll>
#define vp vector<par>
#define vi vector<ll>
const ll mod = 1e9+7;
ll n;
vi g;
map<ll,ll>ar;
int main() {
ios_base::sync_with_stdio(0);cin.tie(0);
cout.setf(ios::fixed);cout.precision(0);
cin>>n;
ll a;
g.push_back(0);
fr(i,1,n){
cin>>a;
ar[a]++;
if(ar[a]==1)g.push_back(a);
}
sort(g.begin(),g.end());
ll id = 0,sol=1;
rep(v,g){
sol = ((v-id+1)*(sol))%mod;
sol%=mod;
id = v;
}
cout<<sol;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
// const int MOD = 998244353;
struct mint {
ll x;
mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
mint operator-() { return mint(-x); }
mint operator+=(mint rhs) {
x += rhs.x;
if (x >= MOD) x -= MOD;
return *this;
}
mint operator-=(mint rhs) {
x -= rhs.x;
if (x < 0) x += MOD;
return *this;
}
mint operator*=(mint rhs) {
x = x * rhs.x % MOD;
return *this;
}
mint operator+(mint rhs) { return mint(*this) += rhs; }
mint operator-(mint rhs) { return mint(*this) -= rhs; }
mint operator*(mint rhs) { return mint(*this) *= rhs; }
mint pow(ll n) {
mint r = 1;
for (mint t = (*this); n; t *= t, n >>= 1)
if (n & 1) r *= t;
return r;
}
mint inv() { return (*this).pow(MOD - 2); }
mint operator/=(mint rhs) { return *this *= rhs.inv(); }
mint operator/(mint rhs) { return mint(*this) /= rhs; }
};
ostream &operator<<(ostream &os, const mint &dt) {
os << dt.x;
return os;
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
set<int> s;
for (int i = 0; i < n; i++) {
s.insert(a[i]);
}
mint ans = 1;
int pre = 0;
for (auto v : s) {
ans *= v - pre + 1;
pre = v;
}
cout << ans << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
void E(){
int n;
cin>>n;
vector<int> elems;
ll sum = 0;
ll res = 0;
for(int i = 0; i < n; i++){
int elem;
cin>>elem;
sum += elem;
elems.push_back(elem);
}
for(int i = 0; i < n; i++){
sum -= elems[i];
res = (res%MOD + (elems[i]%MOD * sum%MOD))%MOD;
}
cout<<res<<endl;
}
void F(){
int n, m;
cin>>n>>m;
int mn = 1e9;
int grid[n][m];
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
int elem;
cin>>elem;
mn = min(mn, elem);
grid[i][j] = elem;
}
}
int res = 0;
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
res += grid[i][j] - mn;
}
}
cout<<res<<endl;
}
int main(){
F();
} | #include<bits/stdc++.h>
#define ll long long
#define mod 998244353ll
using namespace std;
ll mem[5003][5003], inv;
char str[5003][5003];
int n, m;
ll dp(int x, int y)
{
if(x==n-1 && y==m-1)return 1;
if(x==n || y==m)return 0;
if(mem[x][y]!=-1)return mem[x][y];
if(!str[x][y])mem[x][y]= (((2ll*(dp(x+1, y)+dp(x, y+1)))%mod)*inv)%mod;
else
{
if(str[x][y]=='R')mem[x][y]= dp(x, y+1);
else if(str[x][y]=='D')mem[x][y]= dp(x+1, y);
else mem[x][y]= (dp(x+1, y)+dp(x, y+1))%mod;
}
return mem[x][y];
}
ll bigmod(int b, int p)
{
if(!p)return 1;
ll ret= bigmod(b, p/2);
ret= (ret*ret)%mod;
if(p&1ll)ret= (ret*b)%mod;
return ret;
}
int main()
{
inv= bigmod(3, mod-2);
int k;
scanf("%d %d %d", &n, &m, &k);
ll external= 1ll;
for(int i=0; i<(n*m)-k; i++)
external= (3ll*external)%mod;
while(k--)
{
char c;
int x, y;
scanf("%d %d %c", &x, &y, &c);
str[x-1][y-1]= c;
}
memset(mem, -1, sizeof mem);
printf("%lld\n", (external*dp(0, 0))%mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define rep3(i,m,n) for(int (i)=m;(i)<=(n);(i)++)
#define rep3rev(i,m,n) for(int (i)=m;(i)>=(n);(i)--)
#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 eb emplace_back
using ll = long long;
using vll = vector<ll>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using P = pair<int, int>;
using LD = long double;
template <typename T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template <typename T> bool chmin(T &a, const T &b) { if (a > b) { a = b; return true; } return false; }
void yes(bool ok = true){ cout << (ok ? "yes" : "no") << endl; }
void Yes(bool ok = true){ cout << (ok ? "Yes" : "No") << endl; }
void YES(bool ok = true){ cout << (ok ? "YES" : "NO") << endl; }
void Main(){
int n, m, t; cin >> n >> m >> t;
int tot = n;
int prev = 0;
rep(i, m){
int a, b; cin >> a >> b;
tot -= (a-prev);
if(tot <= 0){
Yes(0);
return;
}
tot += (b-a);
if(tot > n) tot = n;
prev = b;
}
tot -= t - prev;
Yes(tot > 0);
return;
}
int main(){
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
} |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
#define endl "\n"
#define fi first
#define se second
#define pb push_back
#define int long long
#define ll long long
#define ld long double
#define pii pair<ll,ll>
#define re(t) ll t;cin>>t;
#define all(value) value.begin(),value.end()
#define f(a,b,c) for(ll a=b;a<c;a++)
#define For(i,n) for(ll i=0;i<n;i++)
#define what(value) cerr << #value << " is " << value << endl;
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL) ;
typedef tree<pair<ll,ll>, null_type,less<pair<ll,ll>>, rb_tree_tag,tree_order_statistics_node_update> omultiset;
typedef tree<long long,null_type,less<long long>,rb_tree_tag,tree_order_statistics_node_update> oset;
typedef tree<long long,null_type,greater<long long>,rb_tree_tag,tree_order_statistics_node_update> oset1;
/*.....................................................................................................................*/
//a.erase(unique(a.begin(),a.end()),a.end());
double pi=3.141592653589793238462641;
ll dx[4]={1,-1,0,0},dy[4]={0,0,1,-1};
const int mod=1e9+7, mod2=998244353, inf =1e18;
long long binpow(int a,int b,int m)
{
a %= m;int res = 1;
while (b > 0)
{
if (b & 1)res=(res*a)%m;
a=(a*a)%m ; b/=2;
}
return res;
}
int modinv(int n,int m) {return binpow(n,m-2,m);}
const ll man =(int)2e5+5;
/*......................................................................................................................*/
signed main()
{
fast;
int n,m,t ;
cin>>n>>m>>t;int n0=n;
vector<pii>a(m);
for(int i=0;i<m;i++)cin>>a[i].first>>a[i].second;
int last=0;
for(int i=0;i<m;i++)
{
if(a[i].first-last>=n)
{
// what(i)
// what(n)
cout<<"No"<<endl;
return 0;
}
else
{
n-=(a[i].first-last);
last=a[i].second;
n+=(a[i].second-a[i].first);
if(n>n0)n=n0;
}
}
if(t-last>=n)
{
cout<<"No"<<endl;
return 0;
}
cout<<"Yes"<<endl;
}
|
//Codeforcesで128bit整数を使いたいとき
//→__int128_tを使う&GNU C++17 (64)で提出する
//インクルードなど
#include <iostream> // cout, endl, cin
// string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <string>
using namespace std;
typedef long long ll;
//イテレーション
#define REP(i,n) for(ll i=0;i<ll(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=ll(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=ll(b);i--)
#define FORA(i,I) for(const auto& i:I)
//x:コンテナ
#define ALL(x) x.begin(),x.end()
#define SIZE(x) ll(x.size())
//定数
#define INF32 2147483647 //2.147483647×10^{9}:32bit整数のinf
#define INF64 9223372036854775807 //9.223372036854775807×10^{18}:64bit整数のinf
#define MOD 998244353 //問題による
//略記
#define F first
#define S second
//出力(空白区切りで昇順に)
#define coutALL(x) for(auto i=x.begin();i!=--x.end();i++)cout<<*i<<" ";cout<<*--x.end();
#define coutall(x) {for(int i=0;i<sizeof(x)/sizeof(x[0]);i++){cout<<x[i]<<"|";};};cout;
//aをbで割る時の繰上げ,繰り下げ
ll myceil(ll a,ll b){return (a+(b-1))/b;}
ll myfloor(ll a,ll b){return a/b;}
ll nCr(ll n, ll r) {
ll ans = 1;
for (ll i = n; i > n - r; --i) {
ans = ans*i;
}
for (ll i = 1 ; i < r + 1; ++i) {
ans = ans / i;
}
return ans;
}
ll f(ll &k,ll &m,ll x){
FORD(i,m,0){
k-=nCr(m-i+x-1,m-i);
if(k<0){k+=nCr(m-i+x-1,x-1)
;m-=i;return i;};
};
return 0;
}
signed main(){
ll n;cin>>n;
vector<ll> M(n+1,0),A(n+1,0);
ll x,m=0;
REP(i,n){
cin>>x;
m+=x;
A[i+1]=A[i]+m;
M[i+1]=max(M[i],x);
};
REP(i,n){
cout<<A[i+1]+M[i+1]*(1+i)<<endl;
}
}
| /**So..a**/
#include<bits/stdc++.h>
using namespace std;
#define FAST ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define B_ begin()
#define E_ end()
#define all(a) a.begin(), a.end()
#define NL_ "\n"
#define F first
#define S second
#define FF first.first
#define FS first.second
#define SF second.first
#define SS second.second
#define __lcm(a, b) (a/__gcd(a, b)*b)
#define PI acos(-1)
#define EXP 10e-6
#define what_is(x) cerr << #x << " is " << x << endl;
template<typename item>
item abs(item i)
{
if(i < 0) i= -i;
return i;
}
ll mod = 1000000000+7;
template<class typea>
typea POW(typea b, typea p)
{
typea res = 1;
while(p)
{
if(p&1)
{
res*=b;
res%=mod;
}
b*=b;
b%=mod;
p/=2;
}
return res;
}
int tc =0;
#define ull unsigned long long int
#define maxn 2*100000+10
ll arr[maxn], sum[maxn], n;
int main()
{
cin >> n;
for(ll i=1; i<=n; i++) cin >> arr[i];
for(ll i=1; i<=n; i++) sum[i] = arr[i]+sum[i-1];
for(ll i= 2; i<=n; i++) sum[i]+=sum[i-1];
ll mx =0;
for(ll i=1; i<=n; i++)
{
mx = max(mx, arr[i]);
cout<< sum[i]+(i*mx)<<NL_;
}
}
|
// Problem: D - Cooking
// Contest: AtCoder - AtCoder Beginner Contest 204
// URL: https://atcoder.jp/contests/abc204/tasks/abc204_d
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include<bits/stdc++.h>
#define ll long long int
#define vl vector<ll>
#define pl pair<ll,ll>
#define pb push_back
#define F first
#define S second
using namespace std;
ll findMin(ll arr[], ll n)
{
// Calculate sum of all elements
ll sum = 0;
for (ll i = 0; i < n; i++)
sum += arr[i];
// Create an array to store results of subproblems
bool dp[n+1][sum+1];
// Initialize first column as true. 0 sum is possible
// with all elements.
for (ll i = 0; i <= n; i++)
dp[i][0] = true;
// Initialize top row, except dp[0][0], as false. With
// 0 elements, no other sum except 0 is possible
for (ll i = 1; i <= sum; i++)
dp[0][i] = false;
// Fill the partition table in bottom up manner
for (ll i=1; i<=n; i++)
{
for (ll j=1; j<=sum; j++)
{
// If i'th element is excluded
dp[i][j] = dp[i-1][j];
// If i'th element is included
if (arr[i-1] <= j)
dp[i][j] |= dp[i-1][j-arr[i-1]];
}
}
// Initialize difference of two sums.
ll diff = 10000000000;
// Find the largest j such that dp[n][j]
// is true where j loops from sum/2 t0 0
for (ll j=sum/2; j>=0; j--)
{
// Find the
if (dp[n][j] == true)
{
diff = sum-2*j;
break;
}
}
return diff;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t,n,i,j,k,s=0,d;
cin >> n;
ll a[n];
for(i=0;i<n;i++)
{
cin >> a[i];
s+=a[i];
}
d=findMin(a,n);
cout << (s+d)/2;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vii;
typedef vector<vi> vvi;
typedef vector<pll> vll;
typedef vector<vl> vvl;
#define fori(i, n) for (int i = 0; i < n; i++)
#define ford(i, n) for (int i = n - 1; i >= 0; i--)
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define repd(i, a, b) for (int i = a; i >= b; i--)
#define trav(x, a) for (auto &x : a)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define eb emplace_back
#define endl '\n'
#define sz(a) (int)(a).size()
#define fi first
#define se second
clock_t time_p = clock();
void time_taken()
{
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
const ll mod = 1e9 + 7;
const ll INF = 1e18;
ll modinv(ll a, ll m)
{
assert(m > 0);
if (m == 1)
return 0;
a %= m;
if (a < 0)
a += m;
assert(a != 0);
if (a == 1)
return 1;
return m - modinv(m, a) * m / a;
}
template <int MOD_>
struct modnum
{
private:
int v;
public:
static const int MOD = MOD_;
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD))
{
if (v < 0)
v += MOD;
}
explicit operator int() const { return v; }
friend bool operator==(const modnum &a, const modnum &b) { return a.v == b.v; }
friend bool operator!=(const modnum &a, const modnum &b) { return a.v != b.v; }
modnum operator~() const
{
modnum res;
res.v = modinv(v, MOD);
return res;
}
modnum &operator+=(const modnum &o)
{
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o)
{
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o)
{
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o)
{
return *this *= (~o);
}
friend modnum operator+(const modnum &a, const modnum &b) { return modnum(a) += b; }
friend modnum operator-(const modnum &a, const modnum &b) { return modnum(a) -= b; }
friend modnum operator*(const modnum &a, const modnum &b) { return modnum(a) *= b; }
friend modnum operator/(const modnum &a, const modnum &b) { return modnum(a) /= b; }
};
using num = modnum<998244353>;
vector<num> fact;
vector<num> ifact;
void init()
{
fact = {1};
for (int i = 1; i < 3005; i++)
fact.push_back(i * fact[i - 1]);
for (num x : fact)
ifact.push_back(1 / x);
}
num ncr(int n, int k)
{
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
num powmod(num x, int a)
{
if (a == 0)
return 1;
if (a & 1)
return x * powmod(x, a - 1);
return powmod(x * x, a / 2);
}
const int N = 105;
num dp[N][N][50 * N];
int main()
{
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n;
cin >> n;
init();
vi a(n);
fori(i, n) cin >> a[i];
int sum = accumulate(all(a), 0);
if (sum % 2)
{
cout << 0 << endl;
return 0;
}
dp[0][0][0] = 1;
fori(i, n)
{
fori(j, i + 1)
{
fori(k, min(50 * N, 100 * j + 1))
{
if (dp[i][j][k] == 0)
continue;
dp[i + 1][j][k] += dp[i][j][k];
if (k + a[i] < 50 * N)
dp[i + 1][j + 1][k + a[i]] += dp[i][j][k];
}
}
}
num ans = 0;
sum >>= 1;
fori(i, n + 1){
ans += dp[n][i][sum] * fact[i] * fact[n - i];
}
cout << int(ans) << endl;
time_taken();
return 0;
} |
// #include "pch.h"
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <climits>
#include <string>
#include <cmath>
#include <bitset>
#include <complex>
#include <functional>
#include <ctime>
#include <cassert>
#include <fstream>
#include <stack>
#include <random>
typedef long long ll;
typedef std::pair<int, int> Pii;
typedef std::pair<long long, long long> Pll;
typedef std::pair<double, double> Pdd;
#define rip(i, n, s) for (int i = (s);i < (int)( n ); i++)
#define all(a) a.begin(), a.end()
#define MM << " " <<
template<typename T>
using MaxHeap = std::priority_queue<T>;
template<typename T>
using MinHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template<typename T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template<typename T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<typename T>
void vdeb(std::vector<T> &bb) {
for (int i = 0;i < bb.size();i++) {
if (i == bb.size() - 1) std::cout << bb[i];
else std::cout << bb[i] << ' ';
}
std::cout << '\n';
}
template<typename T>
void vdeb(std::vector<std::vector<T>> &bb) {
for (int i = 0;i < bb.size();i++) {
std::cout << i << ' ';
vdeb(bb[i]);
}
std::cout << '\n';
}
using namespace std;
int main() {
int n; cin >> n;
vector<int> da(n*4, -2), daa(n*2, 0);
rip(i,n,0) {
int a,b; cin >> a >> b;
--a;--b;
if((a>=0 && da[a] != -2) || (b >= 0 &&da[b] != -2) || (a > b && a>= 0 && b >= 0)) {
cout << "No" << endl;
return 0;
}
if(a >= 0 && b >= 0) {
da[a] = b;
da[b] = a;
}
else if(a >= 0) {
da[a] = -1;
daa[a] = i+1;
}
else if(b >= 0) {
da[b] = -3;
daa[b] = i+1;
}
}
vector<vector<bool>> dp(n*2, vector<bool>(n*2));
// vdeb(da);
rip(ii,n+1,1) {
rip(jj,n+1-ii,0) {
int i = jj, j = ii + jj, x = j-i;
bool flg = true;
// cout << i MM j MM x<< endl;
rip(k, x, 0) {
// cout << 2*i+k MM 2*i+k+x << endl;
if(da[2*i+k] == 2*i+k+x || ((da[2*i+k] == -1 || da[2*i+k] == -2) && (da[2*i+k+x] == -2 || da[2*i+k+x] == -3))) {
if(da[2*i+k] == -1 && da[2*i+k+x] == -3) {
flg = false;
break;
}
}
else {
flg = false;
break;
}
}
if(flg) dp[i][j] = true;
else {
rip(k, j, i+1) {
// cout << i MM k MM j << endl;
if(dp[i][k] && dp[k][j]) dp[i][j] = true;
}
}
}
}
// vdeb(dp);
if(dp[0][n]) cout << "Yes" << endl;
else cout << "No" << endl;
}
| #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int N, A[105], B[105];
int out_pos[205];
int IN[205], OUT[205];
bool dp[205];
int check[205];
int tmp_in[205], tmp_out[205];
/*bool IsPossible(int I, int J, int K) {
for (int i = I; i <= J; i++) { check[i] = 0; tmp_in[i] = IN[i]; tmp_out[i] = OUT[i]; }
int id = 105;
for (int i = I; i <= J; i++) {
if (check[i] != 0) { continue; } // すでに出力済み
if (tmp_out[i] != -1) { return false; } // 入力の前に出力があるのは不合理
if (tmp_in[i] > 0) { // 乗る人が確定している場合
if (i + K + 1 > J) { return false; }
else if (out_pos[i]>0) {
if (out_pos[i] != i + K + 1) { return false; }
else { tmp_out[i + K + 1] = tmp_in[i]; check[i + K + 1] = 1; }
}
else if (tmp_in[i+K+1]>0) {
return false;
}
else if (tmp_out[i + K + 1] == -1 || tmp_out[i+K+1]==tmp_in[i]) {
tmp_out[i + K + 1] = tmp_in[i]; check[i + K + 1] = 1;
}
else { return false; }
}
else if (tmp_out[i+K+1]!=-1) { //降りる人が確定している場合
tmp_in[i] = tmp_out[i + K + 1]; check[i + K + 1] = 1;
}
else { // 乗る人も降りる人も未確定の場合
tmp_in[i] = id++;
if (i + K + 1 > J) { return false; }
else {
tmp_out[i + K + 1] = tmp_in[i]; check[i + K + 1] = 1;
}
}
}
return true;
}*/
bool IsPossible(int I, int J, int K) {
for (int i = I; i <= J; i++) { check[i] = 0; tmp_in[i] = IN[i]; tmp_out[i] = OUT[i]; }
for (int i = I; i <= J; i++) {
if (check[i] != 0) { continue; }
if (i + K + 1 > J) { return false; }
if (tmp_in[i] > 0 && tmp_out[i+K+1] > 0) { // 乗る人と降りる人が確定
if (out_pos[i] > 0 && out_pos[i] != i + K + 1) { return false; }
if (tmp_in[i] != tmp_out[i + K + 1]) { return false; }
check[i + K + 1] = 1;
}
else if (tmp_in[i]>0 && tmp_out[i+K+1]==-1) { // 乗る人のみ確定
if (out_pos[i] > 0) { return false; }
if (tmp_in[i + K + 1] > 0) { return false; }
else { check[i + K + 1] = 1; }
}
else if (tmp_in[i] == -1 && tmp_out[i + K + 1] > 0) { // 降りる人のみ確定
check[i + K + 1] = 1;
}
else {//乗る人も降りる人も未確定
if (tmp_in[i + K + 1] > 0) { return false; }
check[i + K + 1] = 1;
}
}
return true;
}
int main(void) {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> A[i] >> B[i];
}
for (int i = 1; i <= 2*N; i++) {
IN[i] = -1; OUT[i] = -1;
}
for (int i = 1; i <= N; i++) {
if (A[i]>0 && B[i]>0 && A[i] >= B[i]) { cout << "No" << endl; return 0; }
if (A[i] > 0) {
if (IN[A[i]] != -1) { cout << "No" << endl; return 0; }
else { IN[A[i]] = i; }
}
if (B[i] > 0) {
if (OUT[B[i]] != -1) { cout << "No" << endl; return 0; }
else { OUT[B[i]] = i; }
}
}
for (int i = 1; i <= 2 * N; i++) {
if (IN[i] > 0 && OUT[i] > 0) { cout << "No" << endl; return 0; }
}
for (int i = 1; i <= 2 * N; i++) { out_pos[i] = -1; }
for (int i = 1; i <= N; i++) {
if (A[i] > 0 && B[i] > 0) { out_pos[A[i]] = B[i]; }
}
for (int i = 1; i <= N*2; i++) { dp[i] = false; }
dp[0] = true;
for (int i = 0; i < N*2; i+=2) {
if (dp[i] == false) { continue; }
for (int j = i + 2; j <= 2 * N; j += 2) {
for (int k = 0; k <= N; k++) {
if (IsPossible(i + 1, j, k)) { dp[j] = true; break; }
}
}
}
if (dp[2 * N] == true) { cout << "Yes" << endl; }
else { cout << "No" << endl; }
return 0;
} |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <map>
#include <queue>
#include <iomanip>
#include <set>
#include <tuple>
#define mkp make_pair
#define mkt make_tuple
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define all(v) v.begin(),v.end()
using namespace std;
typedef long long ll;
const ll MOD=1e9+7;
template<class T> void chmin(T &a,const T &b){if(a>b) a=b;}
template<class T> void chmax(T &a,const T &b){if(a<b) a=b;}
const ll INF=2e18;
bool overf(ll a,ll b){
if(a>INF/b) return true;
return false;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string S;
cin>>S;
ll M;
cin>>M;
ll N=S.size();
int madig=0;
rep(i,N) chmax(madig,S[i]-'0');
auto calc = [&](ll d){
ll milim=1;
bool ng=false;
rep(i,N-1){
if(overf(milim,d)){
ng=true;
break;
}
milim*=d;
}
if(ng) return -INF;
ll num=0;
bool ov=false;
rep(i,N){
if(overf(num,d)){
ov=true;
break;
}
num*=d;
ll c=S[i]-'0';
num+=c;
}
if(ov) return -INF;
if(num>M) return -INF;
return num;
};
if(calc(madig+1)==-INF){
cout<<0<<endl;
return 0;
}
{
ll high=M+1,low=madig+1;
while(abs(high-low)>3){
ll mid=(high+low)/2;
ll prev=calc(mid);
ll nexv=calc(mid+1);
if(prev==-INF) high=mid;
else if(nexv==-INF) high=mid+1;
else if(prev==nexv) high=mid;
else low=mid;
}
for(ll d=low;d<=high;d++){
ll prev=calc(d);
ll nexv=calc(d+1);
if(nexv==-INF||prev==nexv){
cout<<d-madig<<endl;
return 0;
}
}
}
return 0;
}
| #include<bits/stdc++.h>
#include <functional>
using namespace std;
int H, W;
int dp[2009][2009], score[2009][2009];
char c[2009][2009];
int main() {
cin >> H >> W;
for(int i=1; i<=H; i++) {
for(int j=1; j<=W; j++) {
cin >> c[i][j];
if(c[i][j] == '+') score[i][j] = 1;
else score[i][j] = -1;
}
}
for(int i=H; i>=1; i--) {
for(int j=W; j>=1; j--) {
if(i == H && j == W) {
dp[i][j] = 0;
}
// 高橋くん
else if((i+j) % 2 == 0) {
dp[i][j] = -(1 << 30);
if(i + 1 <= H) dp[i][j] = max(dp[i][j], dp[i+1][j] + score[i+1][j]);
if(j + 1 <= W) dp[i][j] = max(dp[i][j], dp[i][j+1] + score[i][j+1]);
}
// 青木くん
else {
dp[i][j] = (1 << 30);
if(i + 1 <= H) dp[i][j] = min(dp[i][j], dp[i+1][j] - score[i+1][j]);
if(j + 1 <= W) dp[i][j] = min(dp[i][j], dp[i][j+1] - score[i][j+1]);
}
}
}
if(dp[1][1] > 0) cout << "Takahashi" << endl;
else if(dp[1][1] < 0) cout << "Aoki" << endl;
else cout << "Draw" << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
__attribute__((constructor))
void fast_io() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
}
int main() {
int r, c;
cin >> r >> c;
vector<int> a(r * (c - 1)), b((r - 1) * c), dist(2 * r * c, INT_MAX);
for (int i = 0; i < r; ++i) for (int j = 0; j < c - 1; ++j) cin >> a[i * (c - 1) + j];
for (int i = 0; i < r - 1; ++i) for (int j = 0; j < c; ++j) cin >> b[i * c + j];
using P = pair<int, int>;
priority_queue<P, vector<P>, greater<P>> pq;
auto update = [&](int id, int d) {
if (dist[id] > d) {
dist[id] = d;
pq.emplace(d, id);
}
};
update(0, 0);
while (!pq.empty()) {
auto [d, id] = pq.top();
pq.pop();
if (dist[id] < d) continue;
if (id >= r * c) {
update(id - r * c, d);
int i = (id - r * c) / c, j = (id - r * c) % c;
if (i > 0) update((i - 1 + r) * c + j, d + 1);
} else {
int i = id / c, j = id % c;
if (j < c - 1) update(i * c + j + 1, d + a[i * (c - 1) + j]);
if (j > 0) update(i * c + j - 1, d + a[i * (c - 1) + j - 1]);
if (i < r - 1) update((i + 1) * c + j, d + b[i * c + j]);
update(id + r * c, d + 1);
}
}
cout << dist[r * c - 1] << '\n';
} | #include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
#include <cstdint>
#include <string>
#include <sstream>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
#define rep(i,n) for (int i = 0; i < (n); ++i)
typedef long long ll;
using P=pair<ll,ll>;
const int INF=1001001001;
const int mod=998244353;
struct mint {
ll x;
mint(ll x=0):x((x%mod+mod)%mod){}
mint operator-() const { return mint(-x);}
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod-a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this;}
mint operator+(const mint a) const { return mint(*this) += a;}
mint operator-(const mint a) const { return mint(*this) -= a;}
mint operator*(const mint a) const { return mint(*this) *= a;}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t>>1);
a *= a;
if (t&1) a *= *this;
return a;
}
mint inv() const { return pow(mod-2);}
mint& operator/=(const mint a) { return *this *= a.inv();}
mint operator/(const mint a) const { return mint(*this) /= a;}
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x;}
ostream& operator<<(ostream& os, const mint& a) { return os << a.x;}
struct combination {
vector<mint> fact, ifact;
combination(int n):fact(n+1),ifact(n+1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n) return 0;
return fact[n]*ifact[k]*ifact[n-k];
}
} c(2000005);
int main() {
int N,K;
cin>>N>>K;
vector<ll>A(N);
rep(i,N){cin>>A[i];}
vector<mint>sum(K+1);//sum[k]=A[0]^k+A[1]^k+A[2]^k+...
rep(i,N){
mint now=1;
rep(j,K+1){
sum[j]+=now;
now*=A[i];
}
}
for(int i=1;i<=K;i++){
mint ans=0;
for(int j=0;j<=i;j++){
ans+=c(i,j)*sum[j]*sum[i-j];
}
ans-=mint(2).pow(i)*sum[i];
ans/=2;
cout<<ans<<endl;
}
return 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 ins insert
#define debug(a) cerr<<(a)<<endl
#define dbrep(a,n) rep(_i,n) cerr<<(a[_i])<<" "; cerr<<endl
#define dbrep2(a,n,m) rep(_i,n){rep(_j,m) cerr<<(a[_i][_j])<<" "; cerr<<endl;}
using namespace std;
template<class A, class B>
ostream &operator<<(ostream &os, const pair<A,B> &p){return os<<"("<<p.fi<<","<<p.se<<")";}
template<class A, class B>
istream &operator>>(istream &is, pair<A,B> &p){return is>>p.fi>>p.se;}
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...));
}
/* Some Libraries */
//-------------------------------------------------
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin>>N;
vi a(2*N);
rep(i,2*N) cin>>a[i];
vector<pi> b;
rep(i,2*N){
b.emplace_back(a[i],i);
}
vector<bool> marked(2*N);
sort(rall(b));
rep(i,N) marked[b[i].se]=true;
stack<bool> st;
string S="";
rep(i,N){
bool f1 = marked[2*i];
bool f2 = marked[2*i+1];
if (f1 xor f2){
S+="()";
}else{
if (!st.empty() && (st.top() xor f1)){
st.pop();
S+="))";
}else{
if (f1) st.push(true);
else st.push(false);
S+="((";
}
}
}
cout<<S<<"\n";
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <utility>
#include <algorithm>
#include <cmath>
#include <map>
using ll=long long;
using namespace std;
int main(){
int N;
cin>>N;
N*=2;
vector<ll> A(N);
for(int i=0;i<N;i++){
cin>>A[i];
}
vector<ll> B = A;
sort(B.begin(), B.end());
map<ll,int> cnt;
for(int i=0;i<N/2;i++){
cnt[B[i]]++;
}
vector<int> col(N,0);
for(int i=0;i<N;i++){
if(cnt[A[i]] > 0){
col[i] = 1;
cnt[A[i]]--;
}
}
vector<int> ans(N,-1);
vector<int> st;
st.push_back(-1);
for(int i=0;i<N;i++){
if(*st.rbegin() == -1){
ans[i] = 0;
st.push_back(col[i]);
}else if(*st.rbegin() == col[i]){
ans[i] = 0;
st.push_back(col[i]);
}else{
ans[i] = 1;
st.pop_back();
}
}
for(int i=0;i<N;i++){
if(ans[i]){
cout<<")";
}else{
cout<<"(";
}
}
cout<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define sz(x) (int) x.size()
#define pb push_back
#define endl '\n'
#define snd second
#define fst first
#define fastio cin.tie(NULL),cout.sync_with_stdio(true)
//typedef long long int ll;
typedef unsigned long long int ull;
typedef vector <int> vi;
typedef pair <int, int> ii;
const int mod = 1e9 + 7;
//const ll INF = 1e18;
const double EPSILON = 1e-10;
const int N = 2005;
char t[N][N];
int l[N][N], c[N][N], d[2][N][N];
vi ll[N], cc[N], dd[2][N];
int add(int a, int b){
a += b;
if(a >= mod)
a -= mod;
return a;
}
int sub(int a, int b){
a -= b;
if(a < 0)
a += mod;
return a;
}
int main(){
fastio;
int n,m;
cin >> n >> m;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
cin >> t[i][j];
for(int i = 0; i < N; i++)
ll[i].pb(0), cc[i].pb(0), dd[0][i].pb(0), dd[1][i].pb(0);
if(n == 1 and m == 1){
cout << 1 << '\n';
return 0;
}
l[1][1] = c[1][1] = d[0][0][1] = 1;
for(int i = 1; i <= n; i++){
for(int j = 1; j <= m; j++){
if(i == 1 and j == 1)continue;
if(t[i][j] == '#'){
ll[i].pb(i);
cc[j].pb(j);
if(i-j >= 0){
dd[0][i-j].pb(i);
}else{
dd[1][j-i].pb(i);
}
}else{
int tmp = 0;
tmp = add(tmp, sub(l[i-1][j], (ll[i][sz(ll[i])-1] > 0 ? l[ ll[i][sz(ll[i])-1] ][j] : 0)));
tmp = add(tmp, sub(c[i][j-1], (cc[j][sz(cc[j])-1] > 0 ? c[i][ cc[j][sz(cc[j])-1] ] : 0)));
if(i-j>=0){
tmp = add(tmp, sub(d[0][i-j][i-1], (dd[0][i-j][sz(dd[0][i-j])-1] > 0 ? d[0][i-j][ dd[0][i-j][sz(dd[0][i-j])-1] ] : 0)));
}else{
tmp = add(tmp, sub(d[1][j-i][i-1], (dd[1][j-i][sz(dd[1][j-i])-1] > 0 ? d[1][j-i][ dd[1][j-i][sz(dd[1][j-i])-1] ] : 0)));
}
if(i == n and j == m){
cout << tmp << '\n';
}
l[i][j] = add(l[i-1][j], tmp);
c[i][j] = add(c[i][j-1], tmp);
if(i-j >= 0){
d[0][i-j][i] = add(d[0][i-j][i-1], tmp);
}else{
d[1][j-i][i] = add(d[1][j-i][i-1], tmp);
}
}
}
}
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/trie_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#define int long long
#define ll long long
#define all(v) v.begin(), v.end()
#define intvect vector<int>
#define pii pair<int, int>
#define mii map<int, int>
#define fo(i, n) for (int i = 0; i < n; ++i)
#define Fo(i, k, n) for (int i = k; i < n; ++i)
#define ld long double
#define deb(x) cout << #x << " " << x << endl;
#define pb push_back
#define pob pop_back
#define lcm(a, b) (a / __gcd(a, b) * b)
#define F first
#define S second
#define ull unsigned long long
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const ll mod = 1e9 + 7;
const ll N = (ll)2e3 + 4;
template <typename... T>
void read(T &... args)
{
((cin >> args), ...);
}
template <typename... T>
void write(T &&... args)
{
((cout << args), ...);
}
void vjudge()
{
#ifndef RTE
if (fopen("input.txt", "r"))
{
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
string s[N];
int dp[N][N];
int phor[N][N];
int pver[N][N];
int pdig[N][N];
bool wall(int x, int y)
{
if (s[x - 1][y - 1] == '#')
return 1;
return 0;
}
void solve()
{
int h, w;
cin >> h >> w;
for (int i = 1; i < h + 1; i++)
cin >> s[i - 1];
dp[1][1] = 1;
pdig[1][1] = 1;
pver[1][1] = 1;
phor[1][1] = 1;
for (int i = 1; i < h + 1; i++)
{
for (int j = 1; j < w + 1; j++)
{
if ((i == 1 and j == 1) or wall(i, j))
continue;
dp[i][j] = (phor[i][j - 1] + pver[i - 1][j] + pdig[i - 1][j - 1]) % mod;
phor[i][j] = (dp[i][j] + phor[i][j - 1]) % mod;
pver[i][j] = (dp[i][j] + pver[i - 1][j]) % mod;
pdig[i][j] = (dp[i][j] + pdig[i - 1][j - 1]) % mod;
}
}
cout << dp[h][w];
}
int32_t main()
{
clock_t start, end;
start = clock();
vjudge();
int t = 1;
// cin >> t;
while (t--)
solve();
end = clock();
double waste = double(end - start) / double(CLOCKS_PER_SEC);
cerr << "Time wasted by program is : " << fixed
<< waste << setprecision(15);
cerr << " sec " << endl;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
vector<vector<ll>> prod_mat(vector<vector<ll>> a1, vector<vector<ll>> a2){
vector<vector<ll>> m(3, vector<ll>(3));
for(int i=0; i<3; ++i){
for(int j=0; j<3; ++j){
for(int k=0; k<3; ++k){
m[i][j] += a1[i][k] * a2[k][j];
}
}
}
return m;
}
vector<ll> prod_vec(vector<vector<ll>> a1, vector<ll> vec){
vector<ll> ret(3, 0);
for(int i=0; i<3; ++i){
for(int j=0; j<3; ++j){
ret[i] += a1[i][j] * vec[j];
}
}
return ret;
}
int main(){
ll N;
cin >> N;
vector<ll> X(N), Y(N);
for(int i=0; i<N; ++i) cin >> X[i] >> Y[i];
ll M;
cin >> M;
vector<int> op;
map<int, ll> cood;
for(int i=0; i<M; ++i){
int o;
cin >> o;
op.push_back(o);
if(o >= 3){
cin >> o;
cood[i] = o;
}
}
int Q;
cin >> Q;
vector<ll> A(Q), B(Q);
for(int i=0; i<Q; ++i) cin >> A[i] >> B[i];
vector<vector<vector<ll>>> stat_matrix(M+1, vector<vector<ll>>(3, vector<ll>(3)));
stat_matrix[0] = {{1,0,0},{0,1,0},{0,0,1}};
for(int i=1; i<M+1; ++i){
vector<vector<ll>> matrix_step(3, vector<ll>(3));
if(op[i-1] == 1)
matrix_step = {{0,1,0},{-1,0,0},{0,0,1}};
else if(op[i-1] == 2)
matrix_step = {{0,-1,0},{1,0,0},{0,0,1}};
else if(op[i-1] == 3){
ll p = cood[i-1];
matrix_step = {{-1,0,p*2},{0,1,0},{0,0,1}};
} else {
ll p = cood[i-1];
matrix_step = {{1,0,0},{0,-1,p*2},{0,0,1}};
}
stat_matrix[i] = prod_mat(matrix_step, stat_matrix[i-1]);
}
for(int i=0; i<Q; ++i){
vector<ll> v = {X[B[i]-1], Y[B[i]-1], 1};
vector<ll> ans = prod_vec(stat_matrix[A[i]], v);
cout << ans[0] << " " << ans[1] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("-O3")
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("fast-math")
//#pragma GCC optimize("no-stack-protector")
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define sz(x) int(x.size())
#define all(x) x.begin(),x.end()
#define PB push_back
#define MP make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pil pair<int, ll>
#define pli pair<ll, int>
#define pdd pair<ld, ld>
#define ft first
#define sd second
#define i2 array<int,2>
#define i3 array<int,3>
#define i6 array<int,6>
#define i4 array<int,4>
#define l2 array<ll,2>
#define l3 array<ll,3>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
template<class T>
using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
const int N = 200100;
const int M = 300100;
const int BIG = int(5e8) + 10;
const int oo = 2e9;
const ll OO = 1e18;
const int md = int(1e9) + 7;
const int PW = 60;
const ld E = 1e-9;
const int MX = 1000100;
vector<l2> qr[N];
l2 ans[N];
ll n, x[N], y[N], op[N], P[N], q, m, ad[2], TP, sgn[2];
mt19937 rnd(chrono::system_clock().now().time_since_epoch().count());
void BAD(){
cout << -1;
exit(0);
}
int mult(int x, int y) { return (1ll * x * y) % md; }
int sum(int x, int y){
x += y;
if (x >= md)
x -= md;
return x;
}
int main(){
#ifdef _LOCAL
freopen("in.txt","r",stdin); // freopen("output.txt","w",stdout);
#else
// freopen("mining.in","r",stdin); freopen("mining.out","w",stdout);
ios_base::sync_with_stdio(0); cin.tie(0);
#endif
cin >> n;
for (int i = 1; i <= n; i++)
cin >> x[i] >> y[i];
cin >> m;
for (int i = 1; i <= m; i++){
cin >> op[i];
if (op[i] > 2)
cin >> P[i];
}
cin >> q;
// sgn == 0 -- + else -
// TP == 0 (X;Y) else (Y;X)
for (int i = 1; i <= q; i++){
int A, B; cin >> A >> B;
qr[A].PB({B, i});
}
for (int i = 0; i <= m; i++){
if (i > 0){
if (op[i] == 1){
TP ^= 1;
swap(sgn[0], sgn[1]);
swap(ad[0], ad[1]);
sgn[1] ^= 1;
ad[1] = -ad[1];
} else if (op[i] == 2){
TP ^= 1;
swap(sgn[0], sgn[1]);
swap(ad[0], ad[1]);
sgn[0] ^= 1;
ad[0] = -ad[0];
} else if (op[i] == 4){
sgn[1] ^= 1;
ad[1] = -ad[1];
ad[1] += P[i] * 2;
} else {
sgn[0] ^= 1;
ad[0] = -ad[0];
ad[0] += P[i] * 2;
}
}
for (l2 cr : qr[i]){
l2 res = {x[cr[0]], y[cr[0]]};
if (TP) swap(res[0], res[1]);
if (sgn[0]) res[0] = -res[0];
if (sgn[1]) res[1] = -res[1];
res[0] += ad[0];
res[1] += ad[1];
ans[cr[1]] = res;
}
}
for (int i = 1; i <= q; i++)
cout << ans[i][0] << " " << ans[i][1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0 ; i < (n); i++)
using namespace std;
int main() {
int n; cin >> n;
int a[n], b[n];
REP(i, n) cin >> a[i] >> b[i];
int res = 1e6+1;
REP(i, n) REP(j, n)
res = min(res, (i==j) ? a[i]+b[j] : max(a[i],b[j]));
cout << res << '\n';
return 0;
}
| #include<iostream>
#include<iomanip>
#include<algorithm>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<vector>
#include<map>
#include<cstdio>
#define pb push_back
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
const int maxN = 1e6 + 1;
const int mod = 1e9 + 7;
ll a, b, w;
inline void FastInput()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
void ReadInput()
{
cin >> a >> b >> w;
}
void Solve()
{
w *= 1000;
if(w % b == 0) cout << w / b << " ";
else
{
int r = b * (w / b + 1) - w;
int mul = w / b + 1;
int diff = b - a;
if(r <= mul * diff) cout << w / b + 1 << " ";
else
{
cout << "UNSATISFIABLE";
return;
}
}
if(w % a == 0) cout << w / a;
else
{
int r = w - (a * w / a);
int mul = w / a;
int diff = b - a;
if(r <= mul * diff) cout << w / a << " ";
else
{
cout << "UNSATISFIABLE";
return;
}
}
}
int main()
{
FastInput();
ReadInput();
Solve();
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a.at(i);
vector<int> p(n+1, 0);
for(auto i : a){
p[i]++;
}
vector<int> mns(n+1, 1001001001);
mns.front() = p.front();
rep2(i, 1, n+1){
mns.at(i) = min(p.at(i), mns.at(i-1));
}
ll ans = 0, now = 0;
rrep(i, n+1){
if(mns.at(i) > now){
ll d = mns.at(i) - now;
ll adc = min((ll)k, d);
ans += (ll)adc*(i+1);
k -= d;
if(k <= 0) break;
now = mns.at(i);
}
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <set>
#include <algorithm>
#define ll long long
using namespace std;
ll mod = 1e9+7;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
ll n,x;
cin >> n >> x;
x*=100;
ll i=1;
ll ans=0;
bool drunk=false;
while(n--){
ll a,b;
cin >> a >> b;
ans+=a*b;
if(ans>x){
drunk=true;
break;
}
i++;
}
if(drunk==true){
cout << i;
}
else{
cout << -1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;//大きなint型
using P = pair<int,int>;//pair型の型エイリアス
#define rep(i,n) for (int i = 0; i < (n); ++i)//iをnまですすめる。
int main(){
int n;
int sum = 0;
cin >> n;
vector<int> a(n),b(n);
rep(i,n){
cin >> a.at(i);
}
rep(i,n){
cin >> b.at(i);
}
rep(i,n){
sum += a.at(i)*b.at(i);
}
if(sum == 0) cout << "Yes" << endl;
else cout << "No" << endl;
} | #include<bits/stdc++.h>
#define ll long long int
#define mod 1000000009
#define pb push_back
#define mp make_pair
#define endl '\n'
#define N 100005
using namespace std;
int a[N],p[N];
//https://www.geeksforgeeks.org/program-decimal-octal-conversion/
int decToOctal(int n)
{
int f= 1;
// array to store octal number
int octalNum[50];
// counter for octal number array
int i = 0;
while (n != 0) {
// storing remainder in octal array
octalNum[i] = n % 8;
n = n / 8;
i++;
}
// printing octal number array in reverse order
for (int j = i - 1; j >= 0; j--)
{
if(octalNum[j] == 7)
f = 0;
}
return f;
}
int dig (int n)
{
int f=1;
while(n){
int d = n%10;
if(d==7) f = 0 ;
n/=10;
}
return f;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
int f1=0,f2=0;
f2 = dig(i);
f1 = decToOctal(i);
if(f1 && f2){
//cout<<i<<' ';
p[i]+=p[i-1]+1;
}
else{
p[i] = p[i-1];
}
}
// cout<<endl;
cout<<p[n]<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ar array
#define ll long long
const int MAX_N = 1e5 + 1;
const ll MOD = 1e9 + 7;
const ll INF = 1e9;
void solve() {
int a,b,c;
cin >> a >> b >> c;
if (a==b){
cout << "=\n";
return;
}
if(c%2==0){
if(abs(a)==abs(b)){
cout << "=\n";
}else if(abs(a)<abs(b)){
cout << "<\n";
}else{
cout << ">\n";
}
}else{
if(a>=0 && b>=0){
if(a==b){
cout << "=\n";
}else if(a>b){
cout << ">\n";
}else{
cout << "<\n";
}
}else if(a<0 && b>=0){
cout << "<\n";
}else if(a>=0 && b<0){
cout << ">\n";
}else{
if(a==b){
cout << "=\n";
}else if(a>b){
cout << "<\n";
}else{
cout << ">\n";
}
}
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int tc = 1;
// cin >> tc;
for (int t = 1; t <= tc; t++) {
// cout << "Case #" << t << ": ";
solve();
}
} | #include<iostream>
#include<cstring>
#include<cmath>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<deque>
#include <algorithm>
using namespace std;
#define mem(a,b) memset(a,b,sizeof a)
#define PII pair<int,int>
#define ll long long
#define ull unsigned long long
#define ft first
#define sd second
#define endl '\n'
#define PI acos(-1.0)
#define lcm(a,b) a/gcd(a,b)*b
#define INF_INT 0x3f3f3f3f
#define debug(a) cout<<#a<<"="<<a<<endl;
#define _for(i,a,b) for( int i=(a); i<(b); ++i)
#define _rep(i,a,b) for( int i=(a); i<=(b); ++i)
//inline void print(__int128 x){if(x<0){putchar('-');x=-x;}if(x>9) print(x/10);putchar(x%10+'0');}
int gcd(int a, int b){return b ? gcd(b, a % b) : a;}
int exgcd(int a, int b, int &x, int &y){if(!b){x = 1; y = 0;return a;}int d = exgcd(b, a % b, y, x);y -= (a/b) * x;return d;}
ll qmi(ll m, ll k, ll p){ll res = 1 % p, t = m;while (k){if (k&1) res = res * t % p;t = t * t % p;k >>= 1;}return res;}
inline int read(){int s=0,x=1;char ch=getchar();while(ch<'0'||ch>'9') {if(ch=='-') x=-1; ch=getchar();}while(ch>='0'&&ch<='9'){s=s*10+ch-'0';ch=getchar(); }return s*x;}
const int NN = 1e6+7;
const int mod = 1e9+7;
int N,M,k;
ll C(int n, int m){
if(n<0||m<0) return 0;
ll res = 1;
_rep(i,1,n+m){
res = (res*i)%mod;
}
_rep(i,2,m){
ll ni = qmi(i,mod-2,mod);
res = (res*ni) %mod;
}
_rep(i,2,n){
ll ni = qmi(i,mod-2,mod);
res = (res*ni) %mod;
}
return res;
}
void solve()
{
cin >> N >> M >> k;
if(N-k-M > 0) puts("0");
else{
cout << (C(N,M)-C(N-k-1,M+k+1)+mod)%mod << endl;
}
}
int main()
{
//ios::sync_with_stdio(0);
int T = 1;
while(T--)
{
solve();
}
return 0;
}
|
/*input
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <iomanip>
#include <climits>
#define mod 1000000007
// templates
#define all(v) v.begin(),v.end()
#define F first
#define S second
#define sz(x) (int)x.size()
#define po(x,y) fixed<<setprecision(y)<<x
#define ss(s) scanf(" %[^\n]%*c", s)
#define ps(s) printf("%s\n",s)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double lld;
void nl() {printf("\n");}
void sc(int&n) {int number; scanf("%d", &number); n = number;}
void sc(ll&n) {ll number; scanf("%lld", &number); n = number;}
void _print(ll t) {printf("%lld ", t);}
void _print(int t) {printf("%d ", t);}
void _print(string t) {cout << t;}
void _print(char t) {printf("%c\n", t);}
void _print(lld t) {cout << t;}
void _print(double t) {cout << t;}
void _print(ull t) {cout << t;}
template <class T, class V> void _print(pair <T, V> p);
template <class T> void _print(vector <T> v);
template <class T> void _print(set <T> v);
template <class T, class V> void _print(map <T, V> v);
template <class T> void _print(multiset <T> v);
template <class T, class V> void _print(pair <T, V> p) {cout << "{"; _print(p.F); cout << ","; _print(p.S); cout << "}";}
template <class T> void _print(vector <T> v) {cout << "vec->[ "; for (T i : v) {_print(i); cout << " ";} cout << "]";}
template <class T> void _print(set <T> v) {cout << "set->[ "; for (T i : v) {_print(i); cout << " ";} cout << "]";}
template <class T> void _print(multiset <T> v) {cout << "multiset->[ "; for (T i : v) {_print(i); cout << " ";} cout << "]";}
template <class T, class V> void _print(map <T, V> v) {cout << "map->[ "; for (auto i : v) {_print(i); cout << " ";} cout << "]";}
const ll inf = (ll)2e18 + 10;
const int N = (int)1e6 + 10;
bool possible(vector<ll>&a, ll val, ll k) {
int n = sz(a);
int l = 0, r = n - 1, ind = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (a[mid] <= val) {
ind = mid;
l = mid + 1;
}
else {
r = mid - 1;
}
}
ll rem = (val - (ind + 1));
if (rem >= k)return true;
return false;
}
void solve()
{
int n, q;
sc(n), sc(q);
std::vector<ll>a(n);
for (int i = 0; i < n; ++i)
{
sc(a[i]);
}
while (q--) {
ll k;
sc(k);
ll l = 1, r = inf, ans = -1;
while (l <= r) {
ll mid = (l + r) / 2;
if (possible(a, mid, k)) {
ans = mid;
r = mid - 1;
}
else {
l = mid + 1;
}
}
_print(ans);
nl();
}
}
int main()
{
//#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
//#endif
int t = 1;
// sc(t);
while (t--) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll x, y, a, b;
cin >> x >> y >> a >> b;
ll exp = 0;
while (x * (a - 1) < b) {
if (x >= LONG_LONG_MAX / a) {
break;
}
x *= a;
if (x >= y) {
cout << exp << endl;
return 0;
}
exp++;
}
exp += (y - x - 1) / b;
cout << exp << endl;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#ifdef ENABLE_DEBUG
#define dump(a) cerr<<#a<<"="<<(a)<<endl
#define dumparr(a,n) cerr<<#a<<"["<<(n)<<"]="<<(a[n])<<endl
#else
#define dump(a)
#define dumparr(a,n)
#endif
#define FOR(i, a, b) for(ll i = (ll)a;i < (ll)b;i++)
#define For(i, a) FOR(i, 0, a)
#define REV(i, a, b) for(ll i = (ll)b-1LL;i >= (ll)a;i--)
#define Rev(i, a) REV(i, 0, a)
#define REP(a) For(i, a)
#define SIGN(a) (a==0?0:(a>0?1:-1))
typedef long long int ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<ll, ll> pll;
typedef pair<ll,pll> ppll;
typedef vector<ll> vll;
typedef long double ld;
typedef pair<ld,ld> pdd;
pll operator+(pll a,pll b){
return pll(a.first+b.first,a.second+b.second);
}
pll operator-(pll a,pll b){
return pll(a.first-b.first,a.second-b.second);
}
pll operator*(ll a,pll b){
return pll(b.first*a,b.second*a);
}
const ll INF=(1LL<<60);
#if __cplusplus<201700L
ll gcd(ll a, ll b) {
a=abs(a);
b=abs(b);
if(a==0)return b;
if(b==0)return a;
if(a < b) return gcd(b, a);
ll r;
while ((r=a%b)) {
a = b;
b = r;
}
return b;
}
#endif
template<class T>
bool chmax(T& a,const T& b){
if(a<b){
a=b;
return true;
}
return false;
}
template<class T>
bool chmin(T& a,const T& b){
if(a>b){
a=b;
return true;
}
return false;
}
template<class S,class T>
std::ostream& operator<<(std::ostream& os,pair<S,T> a){
os << "(" << a.first << "," << a.second << ")";
return os;
}
template<class T>
std::ostream& operator<<(std::ostream& os,vector<T> a){
os << "[ ";
REP(a.size()){
os<< a[i] << " ";
}
os<< "]";
return os;
}
template<class T>
std::ostream& operator<<(std::ostream& os,set<T> a){
os << "{ ";
for(auto itr=a.begin();itr!=a.end();++itr){
os<< *itr << " ";
}
os<< "}";
return os;
}
template<class T>
void ans_array(T begin,T end){
if(begin==end)return;
auto itr=begin;
cout<<*itr;
++itr;
for(;itr!=end;++itr){
cout<<' '<<*itr;
}
cout<<endl;
}
template<class T>
void ans_array_newline(T begin,T end){
if(begin==end)return;
for(auto itr=begin;itr!=end;++itr){
cout<<*itr<<endl;
}
}
const long long MOD = 1000000007;
void solve(long long N, std::vector<long long> A){
vector<vector<ll>> dp(N+1,vector<ll>(N+1));
ll rotated[3001];
dp[0][0]=1;
auto idx2real = [&](ll x,ll j){
return ((x+j+1-rotated[j])%(j+1)+j+1)%(j+1);
};
REP(N-1){
Rev(j,i+1){
ll& tmp=dp[idx2real(A[i+1],j+1)][j+1];
tmp=(tmp+dp[idx2real(0,j)][j])%MOD;
rotated[j]=(rotated[j]+A[i+1])%(j+1);
}
}
ll ans=0;
REP(N){
ans=(ans+dp[idx2real(0,i)][i])%MOD;
}
dump(dp);
cout<<ans<<endl;
}
int main(){
cout<<setprecision(1000);
long long N;
std::scanf("%lld", &N);
std::vector<long long> A(N);
for(int i = 0 ; i < N ; i++){
std::scanf("%lld", &A[i]);
}
solve(N, std::move(A));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template<int M>
struct static_mint {
static_assert(0 < M, "Module must be positive");
int val;
static_mint() : val() {}
static_mint(long long x) : val(x % M) { if (val < 0) val += M; }
static_mint pow(long long n) const {
static_mint ans = 1, x(*this);
for (; n > 0; n /= 2) {
if (n & 1) ans *= x;
x *= x;
}
return ans;
}
static_mint inv() const {
return pow(M - 2);
}
static_mint operator+() const {
static_mint m;
m.val = val;
return m;
}
static_mint operator-() const {
static_mint m;
m.val = (val == 0 ? 0 : M - val);
return m;
}
static_mint &operator+=(const static_mint &m) {
if ((val += m.val) >= M) val -= M;
return *this;
}
static_mint &operator-=(const static_mint &m) {
if ((val -= m.val) < 0) val += M;
return *this;
}
static_mint &operator*=(const static_mint &m) {
val = (long long) val * m.val % M;
return *this;
}
static_mint &operator/=(const static_mint &m) {
val = (long long) val * m.inv().val % M;
return *this;
}
friend static_mint operator+(const static_mint &lhs, const static_mint &rhs) {
return static_mint(lhs) += rhs;
}
friend static_mint operator-(const static_mint &lhs, const static_mint &rhs) {
return static_mint(lhs) -= rhs;
}
friend static_mint operator*(const static_mint &lhs, const static_mint &rhs) {
return static_mint(lhs) *= rhs;
}
friend static_mint operator/(const static_mint &lhs, const static_mint &rhs) {
return static_mint(lhs) /= rhs;
}
friend bool operator==(const static_mint &lhs, const static_mint &rhs) {
return lhs.val == rhs.val;
}
friend bool operator!=(const static_mint &lhs, const static_mint &rhs) {
return lhs.val != rhs.val;
}
static_mint &operator++() {
return *this += 1;
}
static_mint &operator--() {
return *this -= 1;
}
static_mint operator++(int) {
static_mint result(*this);
*this += 1;
return result;
}
static_mint operator--(int) {
static_mint result(*this);
*this -= 1;
return result;
}
template<typename T>
explicit operator T() const {
return T(val);
}
friend std::ostream &operator<<(std::ostream &os, const static_mint &m) {
return os << m.val;
}
friend std::istream &operator>>(std::istream &is, static_mint &m) {
long long x;
return is >> x, m = x, is;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
using mint = static_mint<1000000007>;
int n;
cin >> n;
vector<long long> a(n);
for (auto &x : a) cin >> x;
vector<mint> dp(n + 1);
dp[0] = 1;
mint ans = 0;
for (int i = 1; i <= n; i++) {
vector<mint> new_dp(n + 1), sum_dp(i);
long long sum = 0;
sum_dp[0] = dp[0];
for (int j = 1; j <= n; j++) {
sum += a[j - 1];
new_dp[j] = sum_dp[sum % i];
sum_dp[sum % i] += dp[j];
}
dp.swap(new_dp);
ans += dp.back();
}
cout << ans << '\n';
return 0;
}
|
#include <iostream>
using namespace std;
int main(void)
{
int n, i, j, min2;
int m = 0;
int a[100010], p[100010], x[100010], min[100010];
scanf("%d", &n);
for(i= 0; i < n; i++)
{
scanf("%d%d%d", &a[i], &p[i], &x[i]);
if(x[i] - a[i] > 0)
{
m++;
min[m] = p[i];
}
}
if(m == 0){puts("-1"); return 0;}
min2 = min[1];
for(j = 2; j <= m; j++)
{
if(min[j] < min2)
{
min2 = min[j];
}
}
printf("%d", min2);
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;
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T, typename U> using ordered_map = tree<T, U, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define FOR(i,j,k,in) for(int i=(j); i < (k);i+=in)
#define FORD(i,j,k,in) for(int i=(j); i >=(k);i-=in)
#define REP(i,b) FOR(i,0,b,1)
#define REPD(i,b) FORD(i,b,0,1)
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(x) begin(x), end(x)
#define MANY_TESTS int tcase; cin >> tcase; while(tcase--)
const double EPS = 1e-9;
const int MOD = 1e9+7;
const ll INFF = 1e18;
const int INF = 1e9;
const ld PI = acos((ld)-1);
const vi dy = {1, 0, -1, 0, -1, 1, 1, -1};
const vi dx = {0, 1, 0, -1, -1, 1, -1, 1};
void DBG(){cout << "]" << endl;}
template<typename T, typename ...U> void DBG(const T& head, const U... args){ cout << head << "; "; DBG(args...); }
#define dbg(...) cout << "Line(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__);
#define chk() cout << "Check at line(" << __LINE__ << ") hit." << endl;
template<class T, unsigned int U>
ostream& operator<<(ostream& out, const array<T, U> &v){out << "["; REP(i, U) out << v[i] << ", "; out << "]"; return out;}
template <class T, class U>
ostream& operator<<(ostream& out, const pair<T, U> &par) {out << "[" << par.first << ";" << par.second << "]"; return out;}
template <class T>
ostream& operator<<(ostream& out, const set<T> &cont) { out << "{"; for( const auto &x:cont) out << x << ", "; out << "}"; return out; }
template <class T, class U>
ostream& operator<<(ostream& out, const map<T, U> &cont) {out << "{"; for( const auto &x:cont) out << x << ", "; out << "}"; return out; }
template<class T>
ostream& operator<<(ostream& out, const vector<T> &v){ out << "["; REP(i, v.size()) out << v[i] << ", "; out << "]"; return out;}
template<class T>
istream& operator>>(istream& in, vector<T> &v){ for(auto &x : v) in >> x; return in; }
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int n; cin >> n;
vi a(n), p(n), x(n);
REP(i, n){
cin >> a[i] >> p[i] >> x[i];
}
int mini = INF + 10;
REP(i, n){
if(x[i] - a[i] > 0)
mini = min(mini, p[i]);
}
if(mini == INF + 10){
cout << -1 << "\n";
}
else{
cout << mini << "\n";
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,i,sum=0;
cin >> N;
for(i = 1;sum < N;){
sum += i;
i++;
}
cout << i - 1 << endl;
} | // time-limit: 2000
// problem-url: https://atcoder.jp/contests/abc198/tasks/abc198_a
/*
++[---------->+<]>.-[------>+<]>-.++++++++.+++++.-[->+++++<]>-.-[--->++<]>--.+.[--->+<]>---.[->+++<]>++.++++++.-------.++++++.--[--->+<]>.-[->+++<]>-..+++++++++++++.[----->++<]>.------------.+[----->+<]>.--------.+++++++++++++.-------------.--[--->+<]>-.---[->++++<]>-.++++[->+++<]>.--[--->+<]>-.[->+++<]>++.-.+++.---.-[->+++<]>.-[--->++<]>+.++++.------.[--->+<]>---.+[----->+<]>.------------.+++++++.-------.--[--->+<]>---.+++[->+++<]>++..+++++++++.---------.-[->+++<]>.+[----->+<]>+.-------------.+++++++.+.----[->+++<]>-.
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long big;
#define pbb pair<big, big>
#define pii pair<int, int>
#define fe first
#define se second
#define maxheap priority_queue
#define uset unordered_set
#define umap unordered_map
#define fr(i, s, e) for(big i = s; i < e; i++)
#define revfr(i, s, e) for(big i = s - 1; i >= e; i--)
#define speed ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define debug(text) if(do_debug) {cout << text << endl;}
#define nl "\n"
const big mod = 1000000007;
const big infinity = 1000000000000000000;
bool do_debug = false;
void solve() {
int n;
cin >> n;
cout << n - 1 << nl;
}
int main() {
speed;
int q = 1;
// cin >> q;
while(q-- > 0) {
solve();
}
return 0;
} |
#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
struct person {
ll id;
ll a;
ll b;
};
ll check(ll N, ll start, ll end, vector<ll>& start_end, vector<ll>& start_fix, vector<ll>& end_fix) {
if (end > 2 * N) {
return 0;
}
if (end_fix[start] >= 0) {
return 0;
}
if (start_fix[end] >= 0) {
return 0;
}
if (start_fix[start] >= 0) {
return 2;
}
if (end_fix[end] >= 0) {
return 2;
}
if (start_end[start * 1000 + end] >= 0) {
return 2;
}
return 1;
}
bool recursive1(ll N, ll start, ll cnt, vector<ll>& start_end, vector<ll>& start_fix, vector<ll>& end_fix, ll anypt, vector<ll>& memo) {
//print(cnt, start);
if (memo[start] >= anypt) {
return false;
}
memo[start] = anypt;
if (cnt == N) {
return true;
}
if (start >= 2 * N) {
return false;
}
for (ll end = start + 1; end <= min(start + N, 2 * N); end++) {
bool success = true;
ll anyy = anypt;
for (ll ss = start; ss <= end - 1; ss++) {
if (!success) {
break;
}
ll ee = end - start + ss;
ll result = check(N, ss, ee, start_end, start_fix, end_fix);
// string rmsg = "success";
// if (result == 0) {
// rmsg = "failure";
// }
// if (result == 1) {
// rmsg = "any";
// }
//print(rmsg, ss, ee, "check!");
if (result == 0) {
success = false;
} else if (result == 1) {
anyy--;
if (anyy < 0) {
success = false;
}
} else {
;
}
}
//print(start, end, success);
if (success) {
bool ok = recursive1(N, end + end - start, cnt + (end - start), start_end, start_fix, end_fix, anyy, memo);
if (ok) {
return true;
}
}
}
return false;
}
bool solve(ll N, vector<person>& persons) {
set<ll> duplicate;
for (auto p : persons) {
if (p.a >= 0) {
if (duplicate.count(p.a)) {
return false;
}
duplicate.insert(p.a);
}
if (p.b >= 0) {
if (duplicate.count(p.b)) {
return false;
}
duplicate.insert(p.b);
}
}
vector<ll> start_end(300000, -1);
vector<ll> start_fix(300, -1);
vector<ll> end_fix(300, -1);
ll anypt = 0;
for (auto p : persons) {
if (p.a == -1 && p.b == -1) {
anypt++;
}
if (p.a >= 0 && p.b == -1) {
start_fix[p.a] = p.id;
}
if (p.a == -1 && p.b >= 0) {
end_fix[p.b] = p.id;
}
if (p.a >= 0 && p.b >= 0) {
start_end[p.a * 1000 + p.b] = p.id;
}
}
vector<ll> memo(2 * N + 2, -1);
return recursive1(N, 1, 0, start_end, start_fix, end_fix, anypt, memo);
}
int main() {
ll N;
cin >> N;
vector<person> persons(N);
for (ll i = 0; i < N; i++) {
person p;
cin >> p.a >> p.b;
p.id = i;
persons[i] = p;
}
if (solve(N, persons)) {
print("Yes");
} else {
print("No");
}
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define FastIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define F first
#define S second
typedef long long ll;
typedef vector< int > vi;
typedef vector< ll > V;
typedef unordered_map<int, int > mp;
#define debug cout << -1 << endl;
#define REP(i, a, b) for(int i=a; i<b; i++)
#define pop pop_back
const ll MOD = 1000000007;
int cc = 1;
const int maxN = 2001;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
void solve()
{
int n;
cin >> n;
int arr[n];
REP(i, 0, n) cin >> arr[i];
int mnXOR = INT_MAX;
for(int mask = 0; mask<(1<<n); mask++) {
int ored = 0;
int xored = 0;
for(int i=0; i<n; i++) {
ored |= arr[i];
if(mask & (1<<i)) {
xored ^= ored;
ored = 0;
}
}
xored ^= ored;
mnXOR = min(mnXOR, xored);
}
cout << mnXOR << endl;
}
int main()
{
FastIO;
//freopen("tttt.in", "r", stdin);
//freopen("tttt.out", "w", stdout);
int t;
t = 1;
//cin >> t;
while(t--){
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
#define fi first
#define se second
#define pb push_back
#define pf push_front
#define mp make_pair
const int N = 2e5 + 5;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const int dr4[] = {1, -1, 0, 0};
const int dc4[] = {0, 0, 1, -1};
const int dr8[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dc8[] = {0, 1, 1, 1, 0, -1, -1, -1};
void solve() {
string s; cin >> s;
bool valid = 1;
for(int i = 0; i < s.size(); i++) {
if(i & 1 && ('a' <= s[i] && s[i] <= 'z')) valid = 0;
else if(!(i & 1) && ('A' <= s[i] && s[i] <= 'Z')) valid = 0;
}
cout << (valid ? "Yes\n" : "No\n");
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int T = 1;
// cin >> T;
for(int tc = 1; tc <= T; tc++) {
solve();
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
// your code goes here
ll n;
cin>>n;
set<ll> output;
for(ll i = 1; i*i <= n; i++){
if((n%i)!=0){
continue;
}
else
{
output.insert(i);
output.insert(n/i);
}
}
for(auto itr: output)
cout<<itr<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
string s;
cin >> s;
auto reduce = [&](vector<int> &v) -> void {
for (int i = 1; i < v.size(); i++) {
v[i - 1] = (6 - v[i - 1] - v[i]) % 3;
}
v.pop_back();
};
vector<int> a(s.begin(), s.end());
for (int i = 0; i < n; i++) {
if (s[i] == 'B') a[i] = 0;
else if (s[i] == 'W') a[i] = 1;
else if (s[i] == 'R') a[i] = 2;
}
while (true) {
while (a.size() % 3 != 1) {
reduce(a);
}
if (a.size() == 1) {
break;
}
vector<int> new_a;
new_a.reserve(a.size() / 3 + 1);
for (int i = 0; i < a.size(); i += 3) {
new_a.push_back(a[i]);
}
a.swap(new_a);
}
if (a.front() == 0) cout << 'B' << '\n';
else if (a.front() == 1) cout << 'W' << '\n';
else cout << 'R' << '\n';
return 0;
} | #include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
#pragma GCC optimize("O3","unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC target("avx2")
#define sync ios_base::sync_with_stdio(0); cin.tie(0);
#define all(x) x.begin(),x.end()
#define unq(a) sort(all(a));a.resize(unique(all(a)) - a.begin())
#define ll long long
#define ld long double
#define pb push_back
#define fi first
#define se second
#define endl '\n'
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rng(1);
using pii = pair<int , int>;
int inline max(const int x, const int y){return (x > y ? x : y);}
int inline min(const int x, const int y){return (x < y ? x : y);}
int inline abs(const int x){return (x < 0 ? -x : x);}
const int mxn = 4e5 + 5;
const int mod = 3; // check mod!
vector<ll> fac, inv;
ll power(ll x, ll y){
ll r = 1;
while(y > 0){
if (y & 1){
r = (r * x) % mod;
}
y >>= 1;
x *= x; x %= mod;
}
return r;
}
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
sync
int t = 1;
//cin >> t;
while(t--){
int n;
cin >> n;
string s;
cin >> s;
// bwr
vector<int> e(n);
for (int i = 0; i < n; i++){
if (s[i] == 'B') e[i] = 0;
if (s[i] == 'W') e[i] = 1;
if (s[i] == 'R') e[i] = 2;
}
int sm = 0, cnt = 1;
sm += e[0];
int three = 0;
for (int up, dn, i = 1; i < n; i++){
up = (n - i); dn = i;
while(up % 3 == 0){
up /= 3; three++;
}
while(dn % 3 == 0){
dn /= 3; three--;
}
cnt *= up; cnt *= power(dn, mod - 2);
cnt %= mod;
if (!three){
sm += (cnt * e[i]) % mod; sm %= mod;
}
}
sm *= power(2, n - 1);
sm %= mod;
if (sm == 0){
cout << 'B' << endl;
}
else if (sm == 1){
cout << 'W' << endl;
}
else{
cout << 'R' << endl;
}
}
cerr << "processor time: " << clock() / (double) CLOCKS_PER_SEC << "s ";
return 0;
} |
/*************************************************************************
> File Name: a.cpp
> Author: Amano Sei
> Mail: [email protected]
> Created Time: 2020年11月15日 星期日 21时00分49秒
************************************************************************/
#include <cstdio>
int main(){
int x;
scanf("%d", &x);
if(x >= 0)
printf("%d\n", x);
else
puts("0");
return 0;
}
| #include<bits/stdc++.h>
#define maxn 100005
#define mod 1000000007
using namespace std;
long long check(long long k)
{
return (k+1)*k/2;
}
int main()
{
long long n;
cin>>n;
long long now=0;
for (long long step=1<<30;step>=1;step=step>>1)
if (check(now+step)<=n+1)
now+=step;
cout<<(n+1-now)<<endl;
} |
//header{{{
#pragma GCC optimize("Ofast")
#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>
#include <ext/pb_ds/trie_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define reps(i,n) for(int i=1;i<=(n);++i)
#define all(x) begin(x),end(x)
#define Fixed fixed << setprecision(12)
#define int int_fast64_t
using pii = pair<int,int>;
constexpr int INF = 0x3f3f3f3f;
constexpr long long LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr int mod1 = 1e9+7;
constexpr int mod2 = 998244353;
template <class Func>
class FixPoint : Func {
public:
explicit constexpr FixPoint(Func&& f) noexcept : Func(forward<Func>(f)) {}
template <class... Args>
constexpr decltype(auto) operator()(Args&&... args) const {
return Func::operator()(*this, std::forward<Args>(args)...);
}
};
template <class Func>
static inline constexpr decltype(auto) makeFixPoint(Func&& f) noexcept {
return FixPoint<Func>{forward<Func>(f)};
}
template <class A, class B> inline bool chmax(A &a, const B &b) { return b > a && (a = b, true); }
template <class A, class B> inline bool chmin(A &a, const B &b) { return b < a && (a = b, true); }
template <class T> using min_heap = priority_queue<T,vector<T>,greater<T> >;
template <class T> using max_heap = priority_queue<T>;
template <class A, class B> using umap = unordered_map<A,B>;
template <class T> using Set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <class K, class V> using Umap = gp_hash_table<K, V>;
using Trie = trie<string, null_type, trie_string_access_traits<>, pat_trie_tag, trie_prefix_search_node_update>;
inline int square(int a){ return a * a;}
inline int updiv(int a,int b){ return (a + b - 1) / b; }
constexpr int dx[] = {1,0,-1,0,1,1,-1,-1};
constexpr int dy[] = {0,-1,0,1,1,-1,-1,1};
//}}}
//}}}
signed main(){
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout.setf(ios_base::fixed);
cout.precision(10);
int a, b;
cin >> a >> b;
for(int i = -1000; i <= 1000; ++i){
for(int j = -1000; j <= 1000; ++j){
if(i + j == a && i - j == b){
return cout << i << ' ' << j << '\n', 0;
}
}
}
return 0;
} | #include<iostream>
using namespace std;
int main()
{
int A,B,temp,X=0,Y=0;
cin >> A >> B;
temp = A + B;
X = temp /2;
Y = A - X;
cout << X << " "<< Y <<endl;
return 0;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.