code_file1
stringlengths 87
4k
| code_file2
stringlengths 85
4k
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
typedef vector <int> vi;
typedef pair <int, int> pii;
typedef vector <long long> vll;
typedef pair <long long, long long> pll;
#define pb push_back
#define all(c) c.begin(), c.end()
#define For(i, a, b) for (long long i = a; i < b; ++i)
#define Forr(i, a, b) for (long long i = a; i > b; --i)
#define um unordered_map
#define F first
#define S second
#define ll long long
#define endl "\n"
#define min(a,b) (a < b ? a : b)
#define max(a,b) (a > b ? a : b)
#define fast_io() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char* name, Arg1&& arg1) {cout << name << " : " << arg1 << endl;}
template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) {const char* comma = strchr(names + 1, ',');cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);}
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
void solve() {
int n, x; cin >> n >> x;
string s; cin >> s;
for (char c : s) {
if (c == 'x') x = max(x-1, 0);
else ++x;
}
cout << x << endl;
}
int main() {
fast_io();
int t = 1;
// cin >> t;
while (t--) solve();
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define pb push_back
typedef long double ld;
#define fi first
#define se second
#define PI 3.14159265358979323846264338327950288419716939937510
#define mp make_pair
#define vvl vector<vector<ll>>
#define vll vector<ll>
#define vpll vector<pll>
/*
#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>
*/
ll inf = 1e18;
ll p = 998244353 ;
ll power(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll pwr(ll x, ll y)
{
ll res = 1;
x = x ;
while (y > 0)
{
if (y & 1)
res = (res * x) ;
y = y >> 1;
x = (x * x) ;
}
return res;
}
ll modInverse(ll n, ll p)
{
return power(n, p - 2, p);
}
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll i, y, x, z, g, key, h, n, m, t, a, b, c, j, k, d;
ll t2, t3, t4, t1, t5, t6;
string s, s2;
ll l, r;
//cin >> t;
t = 1;
while (t--)
{
cin >> n >> x;
cin >> s;
ll ans = x;
for (i = 0; i < n; i++)
{
if (s[i] == 'o')
ans++;
else
{
if (ans > 0)
ans--;
}
}
cout << ans;
}
return 0;
}
|
/* --------------------
| LOSER |
| ~NOOBOSS~ |
--------------------
*/
#include <bits/stdc++.h>
using namespace std;
#define mxx LLONG_MAX
#define mnn LLONG_MIN
#define Y() cout<< "YES" <<endl
#define N() cout << "NO"<<endl
#define endl "\n"
#define Ceil(x,y) ((x+y-1)/y)
#define sz(s) (int)s.size()
#define angle(x) double(x * acos(-1) / 180.0)
#define max_3(a,b,c) max(a, max(b,c))
#define min_3(a,b,c) min(a, min(b,c))
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*b)/gcd(a,b)
#define loser return 0
#define ll long long
#define PI acos(-1)
#define mem(a,v) memset(a,v,sizeof(a))
#define all(v) v.begin(),v.end()
#define SORT(v) sort(v.begin(),v.end())
#define SRV(v) sort(v.rbegin(),v.rend())
#define REV(v) reverse(v.begin(),v.end())
#define B begin()
#define E end()
#define V vector
#define F first
#define S second
#define PSB push_back
#define MP make_pair
#define flash cout.flush()
#define InTheNameOfGod ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);
constexpr ll MOD = 998244353;
constexpr ll mod = 1e9 + 7;
int dx[] = {0,0,1,-1};
int dy[] = {1,-1,0,0};
/*-----*/
#define bug1(a) cerr<<a<<endl;
#define bug2(a,b) cerr<<a<<" "<<b<<endl;
#define bug3(a,b,c) cerr<<a<<" "<<b<<" "<<c<<endl;
/*----*/
const ll N=3e5+5;
vector<ll> adj[N];
ll power(ll n,ll p){if(p==0) return 1;if(p==1)return n;if(p%2)return power(n,p-1)*n;else{ll x=power(n,p/2);return x*x;}}
ll modpow(ll a,ll b,ll m){ll ans=1;while(b){if(b&1)ans=(ans*a)%m;b/=2;a=(a*a)%m;}return ans;}
ll nsum(ll num){return (num*(num+1))/2;}
void edge (ll u,ll v) {adj[u].PSB(v) ;adj[v].PSB(u);}
/*------------------START---------------------*/
/*-----*/
void solve(){
ll n,m;
string s;
cin>>n>>m;
if(m==0){
ll bal=1;
for(ll i=0;i<n;i++){
cout<<bal<<' '<<bal+1<<endl;
bal+=2;
}
return;
}
ll bal=abs(m);
if((abs(n-m)<=1) || m<0){
cout<<"-1";
return;
}
ll k=2;
if(m>0){
cout<<"1"<<' '<<1000000000<<endl;
for(ll i=0;i<m;i++){
cout<<k<<' '<<k+1<<endl;
k+=2;
}
n-=m+1;
ll l=1000000,r=100000000;
//cout<<k<<' '<<1000000<<endl;
// k=1000000;
//n--;
for(ll i=0;i<n;i++){
cout<<l<<' '<<r<<endl;
r++; l++;
}
}
}
/*-----*/
int main(){
InTheNameOfGod
ll Test=1;
//cin>>Test;
while(Test--){
solve();
}
loser;
}
/////// C O D I N G I S L I F E ///////
| #include <bits/stdc++.h>
using namespace std;
int main(){
int N, M; cin >> N >> M;
if(abs(M) == N){
cout << -1 << endl; return 0;
}
if(M == 0){
for(int i = 1; i <= N; i++){
cout << i * 2 << " " << i * 2 + 1 << "\n";
}
return 0;
}
if(abs(M) == N-1 || M < 0){
cout << -1 << endl; return 0;
}
else{
for(int i = 0; i < N-1; i++){
cout << i * 4 + 2 << " " << i * 4 + 4 << "\n";
}
if(M > 0){
cout << 1 << " " << 3 + 4 * M << "\n";
}
}
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
int main(){
int N, A, B;
cin >> N >> A >> B;
cout << N-A+B << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// input
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__); // __VA_ARGS__可変引数マクロ
template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }
template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest& ...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& R:c)for(auto& w:R)std::cin>>w;
// output
template<typename T>void MACRO_OUT(const T t) { std::cout << t; }
template<typename First, typename...Rest>void MACRO_OUT(const First first, const Rest...rest) { std::cout << first << " "; MACRO_OUT(rest...); }
#define OUT(...) MACRO_OUT(__VA_ARGS__);
#define FOUT(n, dist) std::cout<<std::fixed<<std::setprecision(n)<<(dist); // std::fixed 浮動小数点の書式 / setprecision 浮動小数点数を出力する精度を設定する。
#define SP std::cout<<" ";
#define TAB std::cout<<"\t";
#define BR std::cout<<"\n";
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define ENDL std::cout<<std::endl;
#define FLUSH std::cout<<std::flush;
// utility
#define ALL(a) (a).begin(),(a).end()
#define FOR(w, a, n) for(int w=(a);w<(n);++w)
#define REP(w, n) for(int w=0;w<int(n);++w)
#define IN(a, x, b) (a<=x && x<b)
template<class T> inline T CHMAX(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }
template<class T> using V = std::vector<T>;
template<class T> using VV = V<V<T>>;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = (1 << 30) - 1; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double eps = 1e-7;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template<class T, size_t N> void FILL(T(&a)[N], const T & val) { for (auto& x : a) x = val; } // int a[5] = {1,2,3,4,5}; FILL(a,10);
template<class ARY, size_t N, size_t M, class T> void FILL(ARY(&a)[N][M], const T & val) { for (auto& b : a) FILL(b, val); } // ２次元配列でもそのまま使える
template<class T> void FILL(std::vector<T> & a, const T & val) { for (auto& x : a) x = val; } // 使い方 vector<int> a(3); FILL(a,10);
template<class ARY, class T> void FILL(std::vector<std::vector<ARY>> & a, const T & val) { for (auto& b : a) FILL(b, val); } // ２次元配列でもそのまま使える
// ------------>8------------------------------------->8------------
int main() {
INIT;
VAR(int,n,a,b)
OUT(n-a+b)
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,tune=native")
#define mp make_pair
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}
#define eb emplace_back
typedef pair< int, int > pii;
typedef pair< long long, long long > pll;
typedef long long ll;
typedef unsigned long long ull;
typedef vector< int > vi;
typedef vector< vi > vvi;
typedef vector< ll > vll;
typedef vector< vll > vvll;
typedef vector< pii > vpii;
typedef vector< vpii > vvpii;
typedef vector< pll > vpll;
typedef long double ld;
typedef vector< ld > vld;
typedef unsigned int uint;
template <uint MD> struct ModInt {
using M = ModInt;
const static M G;
uint v;
ModInt(ll _v = 0) { set_v(uint(_v % MD + MD)); }
M& set_v(uint _v) {
v = (_v < MD) ? _v : _v - MD;
return *this;
}
explicit operator bool() const { return v != 0; }
M operator-() const { return M() - *this; }
M operator+(const M& r) const { return M().set_v(v + r.v); }
M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
M operator*(const M& r) const { return M().set_v(uint(ull(v) * r.v % MD)); }
M operator/(const M& r) const { return *this * r.inv(); }
M& operator+=(const M& r) { return *this = *this + r; }
M& operator-=(const M& r) { return *this = *this - r; }
M& operator*=(const M& r) { return *this = *this * r; }
M& operator/=(const M& r) { return *this = *this / r; }
bool operator==(const M& r) const { return v == r.v; }
const bool operator<(const M& o) const {return v < o.v; }
M pow(ll n) const {
M x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
M inv() const { return pow(MD - 2); }
friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};
using Mint = ModInt<998244353>;
int main() {
#ifdef BLAT
freopen("stdin", "r", stdin);
freopen("stderr", "w", stderr);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vi v(n);
for(auto &x : v) cin >> x;
Mint ans = 0;
vector< Mint > sp(n + 1);
sort(all(v));
for(int i = n-1; ~i; --i) {
sp[i] = sp[i+1] + sp[i+1] + v[i];
ans += sp[i+1] * v[i];
ans += Mint(v[i]) * v[i];
}
cout << ans << '\n';
#ifdef BLAT
cerr << "\n\nConsumed " << clock() / (double)CLOCKS_PER_SEC << '\n';
#endif
return 0;
}
| #include<bits/stdc++.h>
typedef long long int ll;
using namespace std;
#define sz 200009
#define mod 998244353
#define inf 1e9
#define f first
#define s second
#define pa pair<ll,ll>
ll arr[sz],brr[sz];
long long binpow(long long a, long long b) {
a %= mod;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int main()
{
/// ios_base::sync_with_stdio(0);cin.tie(0);
int test_case=1;
//scanf("%d",&test_case);
for(int cs=1;cs<=test_case;cs++)
{
ll n;
scanf("%lld",&n);
for(int i=1;i<=n;i++)
{
scanf("%lld",&arr[i]);
}
brr[0]=1;
for(int i=1;i<=n;i++)
brr[i]=(brr[i-1]*2)%mod;
ll ans=0,sum=0;
sort(arr+1,arr+n+1);
for(int i=1;i<=n;i++)
{
ans=(ans+(arr[i]*arr[i])%mod)%mod;
if(i>1)
sum=(sum+(brr[i-2]*arr[i])%mod)%mod;
}
// printf("%lld\n",sum);
ll a1=binpow(2,mod-2);
for(int i=1;i<n;i++)
{
ans=(ans+(sum*arr[i])%mod)%mod;
sum=(sum-arr[i+1]+mod)%mod;
sum=(sum*a1)%mod;
}
printf("%lld\n",ans);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mem(x,y) memset(x,y,sizeof(x))
const int M=2e5+10;
const int inf=1<<30;
const ll mod=1e9+7;
const int bit=32;
const double pi=acos(-1.0);
double dp[M];
int main(){
int n;
scanf("%d",&n);
dp[n]=0;
for(int i=n-1;i>=1;i--){
dp[i]=dp[i+1]+1.0*n/(n-i);
}
printf("%.10lf\n",dp[1]);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
cin.tie(nullptr)->sync_with_stdio(false);
string s;
cin >> s;
string t = "ZONe";
int ans = 0;
for(int i = 0; i<9; i++){
if(s.substr(i,4)==t)ans++;
}
cout << ans << "\n";
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define rint register int
#define ll long long
#define rll register long long
const int N=4e5+10;
int a[N],pos[N];
map<int,int> cnt;
int main(){
rint n;
scanf("%d",&n);n<<=1;
for(rint i=1;i<=n;i++)
scanf("%d",&a[i]),cnt[a[i]]++;
rint s=0;
for(auto &v:cnt){
v.second+=s;
s=v.second;
}
for(rint i=1;i<=n;i++)
pos[i]=cnt[a[i]]--;
rint now=0;
for(rint i=1;i<=n;i++){
if(pos[i]<=n/2){
if(now>=0)putchar('(');
else putchar(')');
now++;
}else {
if(now<=0)putchar('(');
else putchar(')');
now--;
}
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN=400005;
const ll mod=998244353;
ll n,tag[MAXN];
pair<ll,ll> p[MAXN];
int main(){
scanf("%lld",&n);
for(ll i=1;i<=2*n;i++){
scanf("%lld",&p[i].first);
p[i].second=i;
}
sort(p+1,p+2*n+1);
for(ll i=n+1;i<=2*n;i++){
tag[p[i].second]=1;
}
ll cntl=0,cntr=0;
for(ll i=1;i<=2*n;i++){
if(tag[i]==0){
if(cntl==0&&cntr==0){
cntl++;
printf("(");
}
else if(cntl>0&&cntr==0){
cntl++;
printf("(");
}
else if(cntl==0&&cntr>0){
cntr--;
printf(")");
}
}
else if(tag[i]==1){
if(cntl==0&&cntr==0){
cntr++;
printf("(");
}
else if(cntl>0&&cntr==0){
cntl--;
printf(")");
}
else if(cntl==0&&cntr>0){
cntr++;
printf("(");
}
}
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <cstring>
#include <bits/stdc++.h>
#define IOS ios:: sync_with_stdio(false), cin.tie(NULL);
#define pb push_back
#define mp make_pair
#define ll long long int
#define ld long double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vii vector<int>
#define vll vector<ll>
#define sll set<ll>
#define vvll vector<vll>
#define vpll vector<pll>
#define vpii vector<pii>
#define all(V) V.begin(),V.end()
#define allr(A) V.rbegin(),V.rend()
#define ff first
#define ss second
#define forz(i,n) for(int i=0;i<n;i++)
#define fora(i,a,n) for(int i=a;i<n;i++)
#define mod 1000000007
using namespace std;
vector < ll > fib(100,0);
void precalculate(){
fib[0] = fib[1] = 1;
fora(i,2,90){
fib[i] = fib[i-1] + fib[i-2];
//cout<<" i:"<<i<<" fib:"<<fib[i]<<" ";
}
//fib[87]>10^18
}
int main()
{
IOS
ll N,n,i=86,imx = 0;
cin>>N;
vector < int > v,ind;
n = N;
if(n==1){cout<<"1\n1\n";return 0;}
else if(n==2){cout<<"2\n1\n1\n";return 0;}
precalculate();
/*v.pb(1);
v.pb(2);
while(n && i>=0){
if(n>=fib[i]){n-=fib[i];ind.pb(i);imx = max(imx,i);i-=2;cout<<"check n:"<<n<<" i:"<<i<<endl;}
else i--;
//cout<<" n:"<<n<<endl;
}
int total = imx + ind.size(),j=0;
cout<<total<<"\n1\n2\n";
for( int i = 0; i<=imx; i++){
if(j<ind.size() && imx-i==ind[j])cout<<(ind[j]%2?"2\n":"1\n");
if(imax%2)cout<<(i%2?"3\n":"4\n");
else if(imax%2==0)cout<<(i%2?"4\n":"3\n");
}*/
int f[100] = {}, maxi = 0;
for (int i = 88; i >= 0; i--) {
if (N >= fib[i]) {
f[i] = 1;
N -= fib[i];
if (maxi == 0) maxi = i;
}
}
vector<int> ans;
for (int i = maxi; i >= 1; i--) {
if (f[i]) ans.pb(1 + (i % 2));
ans.pb(4 - (i % 2));
}
cout<<ans.size()<<endl;
for(auto q:ans)cout<<q<<" ";
cout<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define pll pair<int , int>
#define int long long int
#define endl "\n"
#define ALL(v) v.begin(),v.end()
#define ALLR(v) v.rbegin(),v.rend()
#define pii 3.14159265358979323
#define inf LLONG_MAX
#define ones(x) __builtin_popcount(x)
#define fill(a,b) memset(a,b,sizeof(a))
#define mod 1000000007
#define hell 998244353
ll mod_pow(ll a,ll b,ll m)
{
ll res = 1;
while(b)
{
if(b&1)
{
res=(res*a) % m;
}
a=(a*a) % m;
b>>=1;
}
return res;
}
ll mod_inverse(int a , int m)
{
return mod_pow(a , m - 2 , m);
}
void solve()
{
ll n;
cin >> n;
ll ans = 0;
for(ll i=1;i<=1e6;i++)
{
ll len = to_string(i).length();
ll j = i + i*pow(10,len);
if(j <= n)
ans++;
else
break;
}
cout << ans;
}
signed main() {
fast;
int t = 1;
//cin >> t;
int cur = 1;
while(t--) {
// cout << "Case #" << cur++ << ": ";
solve();
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define int long long
#define w(x) int x; cin>>x; while(x--)
#define mii map<int,int>
#define endl ("\n")
#define vi vector<int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define pii pair<int,int>
#define f(i, a, n) for(int i=a; i<n; i++)
#define fd(i, a, n, d) for(int i=a; i<n; i+=d)
#define in(a,n) f(i,0,n){cin>>a[i];}
#define pb push_back
#define yy cout<<"YES\n"
#define nn cout<<"NO\n"
#define kk cout<<"-1\n"
#define inf (long long)1e18
#define mod 1000000007LL
#define cc(r) cout<<r<<" "
#define ce(r) cout<<r<<endl
#define out(a,n) f(i,0,n){cc(a[i]);}
//No use
void inout()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
}
//No use
void ovector_n() {
ce(1);
}
int32_t main()
{
inout();
int T = clock();
int n, k, a, b;
cin >> n >> k;
mii m;
int tb = k;
f(i, 0, n) {
cin >> a >> b;
m[a] += b;
}
for (auto it : m) {
//cc(a);
//ce(b);
a = it.ff;
b = it.ss;
if (tb < a)
break;
tb += b;
}
ce(tb);
}
| #include <bits/stdc++.h>
typedef long long ll;
#define _GLIBCXX_DEBUG
#define int long long
using namespace std;
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPR(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MAXIN(x) max_element(ALL(x)) - x.begin();
#define MIN(x) *min_element(ALL(x))
#define MININ(x) min_element(ALL(x)) - x.begin();
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000 //10^5:配列の最大のrange(素数列挙などで使用)
#define PI 3.14159265358979323846
using namespace std;
signed main() {
int n, k;
cin >> n >> k;
vector<int> A(n);
vector<int> B(n);
vector<pair<int, int>> S(n);
REP(i, n) {
cin >> S[i].first;
cin >> S[i].second;
}
sort(ALL(S));
int ns = 0;
for (int i = 0; i < n; i++) {
if (k - S[i].first >= 0) { //友達の島までつくか
k += S[i].second;
} else {
ns += k;
goto end;
}
}
if (k > 0) {
ns += k;
}
end:
cout << ns << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#ifndef ONLINE_JUDGE
#define dbg(x...) do{cout << "\033[32;1m" << #x << "->" ; err(x);} while(0)
void err(){cout << "\033[39;0m" << endl;}
template<template<typename...> class T,typename t,typename... A>
void err(T<t> a,A... x){for (auto v:a) cout << v << ' '; err(x...);}
template<typename T,typename... A>
void err(T a,A... x){cout << a << ' '; err(x...);}
#else
#define dbg(...)
#endif
typedef long long ll;
typedef pair<int,int> pi;
typedef vector<int> vi;
template<class T> using vc=vector<T>;
template<class T> using vvc=vc<vc<T>>;
template<class T> void mkuni(vector<T>&v)
{
sort(v.begin(),v.end());
v.erase(unique(v.begin(),v.end()),v.end());
}
template<class T>
void print(T x,int suc=1)
{
cout<<x;
if(suc==1) cout<<'\n';
else cout<<' ';
}
template<class T>
void print(const vector<T>&v,int suc=1)
{
for(int i=0;i<v.size();i++)
print(v[i],i==(int)(v.size())-1?suc:2);
}
int main() {
int n, m;
cin >> n >> m;
if(n > m) {
for(int i = 1; i <= n; ++i) {
cout << i << " ";
}
for(int i = 1; i <= m - 1; ++i) {
cout << -i << " ";
}
cout << -1ll * (1 + n) * n / 2ll + 1ll * m * (m - 1) / 2ll << endl;
}
else {
for(int i = 1; i <= m; ++i) {
cout << -i << " ";
}
for(int i = 1; i <= n - 1; ++i) {
cout << i << " ";
}
cout << -1ll * ( n - 1) * n / 2ll + 1ll * m * (m + 1) / 2ll << endl;
}
} | #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 h, w;
cin >> h >> w;
vector< string > as(h);
cin >> as;
auto dp = make_vector(h, w, -inf);
function<int(int, int, int)> f = [&](int y, int x, int s) {
if (y == h - 1 and x == w - 1) return 0;
int &res = dp[y][x];
if (res != -inf) return res;
if (y + 1 < h) {
int d = (as[y + 1][x] == '+' ? 1 : -1);
chmax(res, -f(y + 1, x, -(s + d)) + d);
}
if (x + 1 < w) {
int d = (as[y][x + 1] == '+' ? 1 : -1);
chmax(res, -f(y, x + 1, -(s + d)) + d);
}
return res;
};
int r = f(0, 0, 0);
if (r == 0) cout << "Draw" << endl;
else if (r > 0) cout << "Takahashi" << endl;
else cout << "Aoki" << endl;
}
signed main() {
solve();
}
|
#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
string s, t;
cin >> s >> t;
int ans = 0;
int x = 0;
for (int i = 0; i < n; i++) {
int c = s[i] - '0' + (t[i] - '0') * 2;
switch (c) {
case 0: x != 0 && ans++; break;
case 1: ++x <= 0 && ans++; break;
case 2: --x >= 0 && ans++; break;
}
}
cout << (x == 0 ? ans : -1) << endl;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
#define rep2(i,x,n) for(int i=x; i<(n); i++)
#define ALL(n) begin(n),end(n)
using namespace std;
using P = pair<int, int>;
using ll = long long;
int main()
{
ll n;
cin >> n;
string s, t;
cin >> s >> t;
vector<ll> a, b;
rep(i,n){
if(s[i]=='0')a.emplace_back(i);
if(t[i]=='0')b.emplace_back(i);
}
if(a.size() != b.size()){
cout << -1 << endl;
}else{
ll ans = 0;
rep(i,a.size()){
if(a[i]!=b[i]) ans++;
}
cout << ans << endl;
}
return 0;
} |
/*
“The only way that we can live is if we grow.
The only way we can grow is if we change.
The only way we can change is if we learn.
The only way we can learn is if we are exposed.
And the only way that we are exposed is if we throw ourselves into the open.”
*************************************** ************************ **********************************
*/
#include <bits/stdc++.h>
using namespace std;
//---------------------mishra ka idea------------------
#define int long long
#define double long double
#define pb push_back
#define pf push_front
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pii>
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define x first
#define y second
#define endl '\n'
#define sz(x) (int)(x).size()
#define ull unsigned long long
//------------------------mishra ka idea-------------------
//-------------------------alsi hu mai-----------------------
#define fo(i,l,u) for(i=l;i<u;i++)
#define rfo(i,l,u) for(i=l;i>=u;i--)
#define allfo(s) for(auto it=(s).begin();it!=(s).end();it++)
#define _init(b) memset(b,-1,sizeof(b))
#define _init0(b) memset(b,0,sizeof(b))
#define MOD 1000000007
#define hell 998244353
#define output(x) cout << (x ? "YES" : "NO")<<endl;
#define Output(x) cout << (x ? "Yes" : "No")<<endl;
//-------------------------alsi hu mai-----------------------
//--------------------het se uthaya---------------------
#define MOD2 (998244353)
#define MOD3 (1000000009)
#define PI acos(-1)
#define eps (1e-8)
#define INF (1e18)
template<class A,class B>ostream&operator<<(ostream&out,const pair<A,B>&a){return out<<"("<<a.first<<","<<a.second<<")";}
template<class A>ostream&operator<<(ostream&out,const vector<A>&a){for(const A &it:a)out<<it<<" ";return out;}
template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}
ifstream cinn("in.txt");ofstream coutt("out.txt");
int poww(const int &a,int b,const int &m=MOD){if(b==0)return 1;int x=poww(a,b/2,m);x=x*x%m;if(b&1)x=x*a%m;return x;}
//--------------------het se uthaya-------------------------------------------------------------------
int gcd(int a, int b) {if(a>b)swap(a,b) ; if (a == 0) return b; return gcd(b % a, a); }
int rint(int l , int r){return rand()%(r-l+1) + l ;}
//---------------------------aab code dekho bahut template dekh liya---------------------------------
signed main()
{
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int i,j,x;
int n , m ;
cin>>n>>m;
int grid[n+1][m+1];
string s;
fo(i,0,n){
cin>>s;
fo(j,0,m){
if(s[j]=='.'){
grid[i][j]=0;
}
else{
grid[i][j]=1;
}
// cout<<grid[i][j]<<" ";
}
//cout<<endl;
}
int ans=0;
fo(i,0,n){
fo(j,0,m-1){
if(grid[i][j]==0 && grid[i][j+1]==0)ans++;
}
}
fo(i,0,m){
fo(j,0,n-1){
if(grid[j][i]==0 && grid[j+1][i]==0){
//cout<<i<<j<<" ";
ans++;
}
}
}
cout<<ans<<endl;
return 0;
}
//----------------abc tez kar liya iska matlab ye nahi tum legend ho kya pata hagdo aage ------------------ | #include <iostream> // cout, endl, cin
#include <string> // 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 <functional>
#include <numeric>
#include <math.h>
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main(void) {
int H, W;
cin >> H >> W;
vector<string> vec(H);
for (int i = 0; i < H; i++) {
cin >> vec.at(i);
}
int ans = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W - 1; j++) {
string str = vec.at(i);
if (str[j] == '.' && str[j + 1] == '.') ans++;
}
}
for (int i = 0; i < H - 1; i++) {
for (int j = 0; j < W; j++) {
string str1 = vec.at(i);
string str2 = vec.at(i + 1);
if (str1[j] == '.' && str2[j] == '.') ans++;
}
}
cout << ans << endl;
return 0;
} |
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define rep(i,N) for(int i=0;i<(int)N;i++)
static inline void PUT(char c)
{
static char buf[1<<15],*ptr=buf;
if(ptr==buf+strlen(buf)||c==0){fwrite(buf,1,ptr-buf,stdout),ptr=buf;}*ptr++=c;
}
static inline long IN(void)
{
long x=0,f=0,c=getchar();while(c<48||c>57){f^=c==45,c=getchar();}
while(c>47&&c<58){x=x*10+c-48,c=getchar();}return f?-x:x;
}
static inline void OUT(long a)
{
if(a<0)PUT('-'),a=-a;
int d[40],i=0;do{d[i++]=a%10;}while(a/=10);
while(i--){PUT(d[i]+48);}PUT('\n');
}
int main(void)
{
int sz=0;long N=IN(),temp[5000],keep;
for(long i=0;i*i<(long)N;i++){if(N%(i+1)==0){OUT(i+1);keep=i+1;if(i+1<N/(i+1)){temp[sz++]=N/(i+1);}}}
rep(i,sz-1){if(keep==temp[sz-1-i]){continue;}OUT(temp[sz-1-i]);}
if(N!=1){OUT(N);}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int ans = n%2;
if(ans==1)
cout << "Black" << endl;
else
cout << "White" << endl;
}
|
#include <iostream>
#include <vector>
#include <tuple>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#define ll long long
#define rep(i,n) for(int i = 0;i < (int)n;i ++)
using namespace std;
int main(void){
ll n;
cin >> n;
n = (n*108/100);
if(n < 206){
cout << "Yay!" << endl;
}else if(n == 206){
cout << "so-so" << endl;
}else{
cout << ":(" << endl;
}
return 0;
} | /* In The Name Of ALLAH
Author:- Ibrahim adnan Tanim */
#include <bits/stdc++.h> // This will work only for g++ compiler.
#define for0(i, n) for (int i = 0; i < (int)(n); ++i) // 0 based indexing
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i) // 1 based indexing
#define forc(i, l, r) for (int i = (int)(l); i <= (int)(r); ++i) // closed interver from l to r r inclusive
#define forr0(i, n) for (int i = (int)(n) - 1; i >= 0; --i) // reverse 0 based.
#define forr1(i, n) for (int i = (int)(n); i >= 1; --i) // reverse 1 based
//short hand for usual tokens
#define pb push_back
#define fi first
#define se second
// to be used with algorithms that processes a container Eg: find(all(c),42)
#define all(x) (x).begin(), (x).end() //Forward traversal
#define rall(x) (x).rbegin, (x).rend() //reverse traversal
// traversal function to avoid long template definition. Now with C++11 auto alleviates the pain.
#define tr(c,i) for(__typeof__((c)).begin() i = (c).begin(); i != (c).end(); i++)
// find if a given value is present in a container. Container version. Runs in log(n) for set and map
#define present(c,x) ((c).find(x) != (c).end())
//find version works for all containers. This is present in std namespace.
#define cpresent(c,x) (find(all(c),x) != (c).end())
// Avoiding wrap around of size()-1 where size is a unsigned int.
#define sz(a) int((a).size())
#define optimize() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl '\n'
using namespace std;
// Shorthand for commonly used types
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef double ld;
int main() {
optimize();
int n;
cin>>n;
n=n+(n*.08);
if(n<206)
cout<<"Yay!";
else if(n>206)
cout<<":(";
else
cout<<"so-so";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pint;
typedef pair<ll,ll> pll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<string> vstr;
typedef vector<pint> vpint;
typedef vector<pll> vpll;
#define vint2(v,n,m,init) vector<vector<int>> v(n, vector<int>(m, init))
#define vll2(v,n,m,init) vector<vector<ll>> v(n, vector<ll>(m, init))
#define rep(i,n) for(ll i=(ll)0; i<(ll)n; i++)
#define REP(i,m,n) for(ll i=(ll)m; i<(ll)n; i++)
#define arr(var, n) vint var(n); rep(i,n){cin >> var[i];}
#define arrll(var, n) vll var(n); rep(i,n){cin >> var[i];}
#define arrst(var, n) vstr var(n); rep(i,n){cin >> var[i];}
#define ALL(var) (var).begin(), (var).end()
#define sortall(var) sort(ALL(var))
#define uniqueall(v) v.erase(unique(v.begin(), v.end()), v.end());
#define prt(var) cout << (var) << "\n"
#define prt2(v1, v2) cout << (v1) << " " << (v2) << "\n"
#define prt3(v1, v2, v3) cout << (v1) << " " << (v2) << " " << (v3) << "\n"
#define prtd(n, var) cout << fixed << setprecision(n) << (var) << "\n"
#define prtfill(n, var) cout << setw(n) << setfill('0') << (var);
#define prtall(v) rep(i,v.size()){cout<<v[i]<<(i!=v.size()-1?" ":"\n");}
template <typename T>
bool chmax(T &a, const T& b){if(a<b){a=b; return true;} return false;}
template <typename T>
bool chmin(T &a, const T& b){if(a>b){a=b; return true;} return false;}
ll gcd(ll a, ll b){ return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b){ return a/gcd(a,b)*b;}
//----------------------------------------------------------------------------
int main(void) {
ll n;
cin >> n;
vector<double> h(n+1);
h[1] = 1.0;
REP(i,1,n){
h[i+1] = h[i] + 1.0/double(i+1);
}
prtd(10,double(n)*(h[n])-1.0);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1<<24;
const ll INFL = (1ll << 60);
//cout << setprecision(20) <<
int n;
int coord[17][3];
int dp[1 << 17][17];
int rec(int S, int v) {
if (dp[S][v] >= 0) {
return dp[S][v];
}
if (S == (1 << n) - 1 && v == 0) {
return dp[S][v] = 0;
}
int res = INF;
for (int u = 0; u < n; u++) {
if (!(S >> u & 1)) {
int a, b, c, p, q, r;
a = coord[v][0];
b = coord[v][1];
c = coord[v][2];
p = coord[u][0];
q = coord[u][1];
r = coord[u][2];
int dist = abs(a - p) + abs(b - q) + max(r - c, (int)0);
res = min(res, rec(S | 1 << u, u) + dist);
}
}
return dp[S][v] = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
ll x, y, z; cin >> x >> y >> z;
coord[i][0] = x;
coord[i][1] = y;
coord[i][2] = z;
}
memset(dp, -1, sizeof(dp));
cout << rec(0, 0) << endl;
} |
#include<bits/stdc++.h>
using namespace std ;
#define Next( i, x ) for( register int i = head[x]; i; i = e[i].next )
#define rep( i, s, t ) for( register int i = (s); i <= (t); ++ i )
#define drep( i, s, t ) for( register int i = (t); i >= (s); -- i )
#define re register
int gi() {
char cc = getchar() ; int cn = 0, flus = 1 ;
while( cc < '0' || cc > '9' ) { if( cc == '-' ) flus = - flus ; cc = getchar() ; }
while( cc >= '0' && cc <= '9' ) cn = cn * 10 + cc - '0', cc = getchar() ;
return cn * flus ;
}
const int N = 100 + 5 ;
const int M = 1e5 + 5 ;
struct E {
int to, next ;
} e[M] ;
int n, cnt, head[N], vis[N], D[N] ;
char s[N] ;
void add( int x, int y ) {
e[++ cnt] = (E){ y, head[x] }, head[x] = cnt;
}
void dfs(int x) {
if( vis[x] ) return ;
vis[x] = 1 ;
Next( i, x ) {
int v = e[i].to ;
dfs(v) ;
}
}
signed main()
{
n = gi() ;
rep( i, 1, n ) {
scanf("%s", s + 1 ) ;
rep( j, 1, n ) if(s[j] == '1') add(i, j) ;
}
rep( i, 1, n ) {
rep( j, 1, n ) vis[j] = 0 ;
dfs(i) ;
rep( j, 1, n ) D[j] = D[j] + vis[j] ;
}
long double ans = 0 ;
rep( i, 1, n ) ans = (ans + 1.0 / (1.0 * D[i])) ;
printf("%.12Lf\n", ans ) ;
return 0 ;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef pair<int, int>pi;
typedef pair<long long, long long>pl;
#define F first
#define S second
#define pb push_back
#define all(x) x.begin() , x.end()
#define mp make_pair
#define FOR(i,a,b) for(i=a;i<=b;i++)
#define mem(a) memset(a , 0 ,sizeof a)
#define memn(a) memset(a , -1 ,sizeof a)
int main()
{
ll n, i, m, x, y, j, k, mn = INT_MAX, ans = 0;
cin >> n >> m;
ll a[m + 3];
a[0] = 0;
for (i = 1; i <= m; i++)
{
cin >> a[i];
}
a[m + 1] = n + 1;
vector<ll>v;
sort(a, a + m + 2);
for (i = 1; i <= m + 1; i++)
{
x = a[i] - a[i-1] - 1;
if(x!=0)
{
v.pb(x);
}
}
sort(all(v));
if(v.size()==0)
{
cout<<"0"<<endl;
return 0;
}
mn=v[0];
//cout<<mn<<endl;
for (i = 0; i < v.size(); i++)
{
ans += ceil(double((v[i]*1.00) / mn));
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll n,m;
map<ll,ll> p;
ll dfs(ll x,ll c)
{
if(p.find(x)!=p.end())return p[x];
if(x<=c)return c-x;
p[x]=x-c;
if(x&1)p[x]=min(p[x],min(dfs(x-1,c),dfs(x+1,c))+1);
else p[x]=min(p[x],dfs(x/2,c)+1);
return p[x];
}
int main()
{
cin>>n>>m;
cout<<dfs(m,n);
} | //@ikung
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fast ios_base::sync_with_stdio(0);cin.tie(0);
#define f(i,k) for(int i=0;i<k;i++)
#define F first
#define dbg(x) cout<<#x<<" "<<x<<endl;
#define S second
#define endl "\n"
#define rep(i,n) for(int i=1;i<=n;i++)
#define rew(i,a,b) for(int i=a;i<=b;i++)
#define mod 1000000007
const int inf = 1e18;
const int N=200005;
int n,X,Y;
map<int, int> m;
int rechx(int y)
{
if(y==X)
{
return 0;
}
if(y==1)
{
return abs(X - y);
}
if(m[y]!=0)
return m[y];
if(y%2)
return m[y]=min({abs(X - y), rechx((y + 1) / 2) + 2, rechx((y - 1) / 2) + 2});
else
return m[y]=min({abs(X - y), rechx((y) / 2) + 1});
}
void solve()
{
int i, j, k;
cin >> X >> Y;
if(Y<X)
{
cout << X - Y << endl;
return;
}
else
{
cout << rechx(Y)<<endl;
}
return;
}
signed main()
{
fast
int t = 1, i, j, k;
//cin >> t;
while (t--)
{
solve();
}
return 0;
} |
#include "bits/stdc++.h"
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ub upper_bound
#define lb lower_bound
#define isrt insert
#define clr clear
#define rsz resize
#define ff first
#define ss second
#define lli long long int
#define pb push_back
#define pf push_front
#define mkp make_pair
#define pii pair<lli,lli>
#define vi vector<int>
#define mii map<lli,lli>
#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 1e9
#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 all(v) v.begin(),v.end()
#define endl "\n"
const double PI = acos(-1);
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
lli maxm(lli a, lli b)
{
return (a >= b ? a : b);
}
lli minm(lli a, lli b)
{
return (a <= b ? a : b);
}
lli power(lli x, lli y, lli p)
{
lli res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
lli nCrmodp(lli n, lli r, lli p)
{
if (r == 0)
return 1;
if (r == 1)
return n;
lli pro = 1, k = n;
while (k > r)
{
pro *= k;
pro %= p;
--k;
}
k = 2;
while (k <= (n - r))
{
pro *= power(k, (p - 2), p);
pro %= p;
++k;
}
return pro;
}
lli first_big(lli n, lli k, vector<lli> arr)
{
lli l, r, ans = n;
l = 0;
r = n - 1;
while (l <= r) {
lli m = l + (r - l) / 2;
if (arr[m] > k) {
ans = m;
r = m - 1;
}
else
l = m + 1;
}
return ans;
}
lli last_small(lli n, lli k, vector<lli> arr)
{
lli l, r, ans = -1;
l = 0;
r = n - 1;
while (l <= r)
{
lli mid = (l + r) / 2;
if (arr[mid] <= k)
{
ans = mid;
l = mid + 1;
}
else
r = mid - 1;
}
return ans;
}
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
}
void sub_sum(set<lli>&v, vector<lli>a, lli n, lli T)
{
for (lli i = 0; i < pow(2, n); ++i)
{
lli s = 0, x = i;
for (lli j = 0; j < n; ++j)
{
if (x % 2 == 1)
s += a[j];
x /= 2;
}
if (s <= T)
v.isrt(s);
}
}
int main()
{
c_p_c();
lli T, n;
cin >> n >> T;
if (n <= 20)
{
vector<lli>a(n);
for (lli i = 0; i < n; ++i)
cin >> a[i];
set<lli>v;
sub_sum(v, a, n, T);
cout << *(prev(v.end())) << endl;
}
else
{
vector<lli>a(20);
vector<lli>b(n - 20);
for (lli i = 0; i < 20; ++i)
cin >> a[i];
for (lli j = 0; j < (n - 20); ++j)
cin >> b[j];
set<lli>v1;
set<lli>v2;
sub_sum(v1, a, 20, T);
sub_sum(v2, b, n - 20, T);
lli ans = 0;
for (auto it : v1)
{
lli k = (T - it);
auto itr = v2.upper_bound(k);
--itr;
ans = maxm(ans, it + *itr);
}
for (auto it : v2)
{
lli k = (T - it);
auto itr = v1.upper_bound(k);
--itr;
ans = maxm(ans, it + *itr);
}
cout << ans << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define PI acos(-1)
#define pb push_back
#define int long long
#define ld long double
#define sp fixed<<setprecision
#define bp __builtin_popcountll
#define all(x) x.begin(),x.end()
#define pii pair<long long,long long>
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
const int M = (1e9)+7;
const int N = 105;
signed main()
{
FAST
int tc=1;
//cin>>tc;
for(int ti=1;ti<=tc;ti++)
{
int n,t;
cin>>n>>t;
int a[n];
for(int i=0;i<n;i++)cin>>a[i];
if(n == 1)
{
cout<<(a[0] <= t ? a[0] : 0)<<endl;
return 0;
}
set<int> l,r;
int m = n/2;
for(int i=0;i<(1LL<<m);i++)
{
int tot = 0;
for(int j=0;j<m;j++)if((i>>j)&1LL)tot += a[j];
if(tot <= t)l.insert(tot);
}
m = n - m;
for(int i=0;i<(1LL<<m);i++)
{
int tot = 0;
for(int j=0;j<m;j++)if((i>>j)&1LL)tot += a[(n/2) + j];
if(tot <= t)r.insert(tot);
}
int ans = 0;
if(l.size())ans = max(ans, *l.rbegin());
if(r.size())ans = max(ans, *r.rbegin());
for(int x:l)
{
int need = t - x;
auto it = r.lower_bound(need);
if(it != r.end() && *it > need)
{
if(it != r.begin())
{
it--;
ans = max(ans, x + *it);
}
}
else if(it == r.end())
{
if(it != r.begin())
{
it--;
ans = max(ans, x + *it);
}
}
else ans = t;
}
cout<<ans<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
#define G getchar()
int read()
{
int x=0; bool flg=false; char ch=G;
for (;!isdigit(ch);ch=G) if (ch=='-') flg=true;
for (;isdigit(ch);ch=G) x=(x<<3)+(x<<1)+(ch^48);
return flg?-x:x;
}
#undef G
#define fi first
#define se second
typedef long long ll;
/*
const int mod=;
inline int upd(const int &x){return x+(x>>31&mod);}
inline void add(int &x,int y){x=upd(x+y-mod);}
inline void iadd(int &x,int y){x=upd(x-y);}
int qpow(int x,int y){
int res=1;
for (;y;y>>=1,x=1LL*x*x%mod)
if (y&1) res=1LL*res*x%mod;
return res;
}
*/
/*
typedef pair<int,int> P;
*/
#define rep(i,l,r) for (int i(l);i<=(r);i++)
#define per(i,l,r) for (int i(r);i>=(l);i--)
int n;
void solve(){
n=read();
printf("%d\n",(1<<n)-1);
rep(i,1,(1<<n)-1){
rep(j,0,(1<<n)-1) putchar("AB"[__builtin_parity(i&j)]);
puts("");
}
}
int main()
{
for (int T=1;T--;) solve();
} | #include<bits/stdc++.h>
#define int long long
using namespace std;
vector<vector<bool>>se(50,vector<bool>(50));
vector<vector<int>>sc(50,vector<int>(50));
vector<vector<int>>pe(50,vector<int>(50));//タイプ
vector<bool>ty(2505);//色
int pmax=0;
string smax;
int kaisu=0;
int ti=clock();
void dfs(int nx,int ny,int P,string S){//今のx,今のy,スコア,ルート
if(pmax<P){
pmax=P;smax=S;
}
kaisu++;
//cout<<(long double)(clock())/(long double)(CLOCKS_PER_SEC)<<" "<<pmax<<endl;
se[nx][ny]=true;
ty[pe[nx][ny]]=true;
if(nx!=0&&!se[nx-1][ny]&&!ty[pe[nx-1][ny]]){
dfs(nx-1,ny,P+sc[nx-1][ny],S+'U');
if(kaisu>14600000)return;
se[nx-1][ny]=false;
ty[pe[nx-1][ny]]=false;
}
if(nx!=49&&!se[nx+1][ny]&&!ty[pe[nx+1][ny]]){
dfs(nx+1,ny,P+sc[nx+1][ny],S+'D');
if(kaisu>14600000)return;
se[nx+1][ny]=false;
ty[pe[nx+1][ny]]=false;
}
if(ny!=0&&!se[nx][ny-1]&&!ty[pe[nx][ny-1]]){
dfs(nx,ny-1,P+sc[nx][ny-1],S+'L');
if(kaisu>14600000)return;
se[nx][ny-1]=false;
ty[pe[nx][ny-1]]=false;
}
if(ny!=49&&!se[nx][ny+1]&&!ty[pe[nx][ny+1]]){
dfs(nx,ny+1,P+sc[nx][ny+1],S+'R');
if(kaisu>14600000)return;
se[nx][ny+1]=false;
ty[pe[nx][ny+1]]=false;
}
}
signed main(){
int I,J;cin>>I>>J;
ty.assign(2505,false);
for(int X=0;X<50;X++){
for(int Y=0;Y<50;Y++){
cin>>pe[X][Y];
}
}
for(int X=0;X<50;X++){
for(int Y=0;Y<50;Y++){
cin>>sc[X][Y];
se[X][Y]=false;
}
}
dfs(I,J,sc[I][J],"");
cout<<smax<<endl;
} |
#include<cstdio>
#include <algorithm>
#include <string>
#include <string.h>
#include <math.h>
#include <map>
#include<vector>
#include <iostream>
using namespace std;
#define ll long long
#define mod 998244353
ll a[200005];
ll mul(ll a,ll n)
{
ll sum=1;
while(n)
{
if(n%2) sum=sum*a%mod;
a=a*a%mod;
n/=2;
}
return sum;
}
ll get(ll p)
{
return mul(p,mod-2);
}
int main()
{
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
}
sort(a+1,a+n+1);
ll sum=0;
ll ans=0;
for(int i=n;i>=1;i--)
{
ans=(ans+a[i]*a[i]%mod+sum*a[i]%mod)%mod;
sum=(sum*2+a[i])%mod;
}
printf("%lld\n",ans);
return 0;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <utility>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <cstdio>
#include <limits>
#define rep(i,n) for(int i = 0; i < n; ++i)
#define rep1(i,n) for(int i = 1; i <= n; ++i)
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if(a < b){ a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if(a > b){ a = b; return 1; } return 0; }
template<class T> inline int sz(T &a) { return a.size(); }
using ll = long long; using ld = long double;
using pi = pair<int,int>; using pl = pair<ll,ll>;
using vi = vector<int>; using vvi = vector<vi>;
using vl = vector<ll>; using vvl = vector<vl>;
const int inf = numeric_limits<int>::max();
const ll infll = numeric_limits<ll>::max();
// Modint
// modint<MOD> で宣言
template<long long MOD>
struct modint{
long long x;
long long mod = MOD;
modint(long long x=0):x(x%MOD){}
modint& operator+=(const modint a){
if((x+=a.x)>=MOD) x-=MOD;
return *this;
}
modint& operator-=(const modint a){
if((x += MOD-a.x)>=MOD) x-=MOD;
return *this;
}
modint& operator*=(const modint a){
(x*=a.x)%=MOD;
return *this;
}
modint operator+(const modint a) const{
modint res(*this);
return res+=a;
}
modint operator-(const modint a) const{
modint res(*this);
return res-=a;
}
modint operator*(const modint a) const{
modint res(*this);
return res*=a;
}
modint pow(long long t) const{
if(!t) return 1;
modint a = pow(t>>1);
a*=a;
if(t&1) a*=*this;
return a;
}
//for prime mod
modint inv() const{
return pow(MOD-2);
}
modint& operator/=(const modint a){
return (*this) *= a.inv();
}
modint operator/(const modint a) const{
modint res(*this);
return res/=a;
}
};
using mint = modint<998244353>;
const int NMAX=1000010; // we can calculate nCk until n is equal to NMAX
mint fact[NMAX],infac[NMAX];
void Make_Fact(){
fact[0]=fact[1]=1;
for(int i=2;i<=NMAX-1;++i){
fact[i]=fact[i-1]*(mint)i;
}
}
void Make_InvFact(){
infac[0]=infac[1]=1;
for(int i=2;i<=NMAX-1;++i){
infac[i]=infac[i-1]/(mint)i;
}
}
mint Comb(int n,int k){
if(n<0||k<0||n-k<0) return 0;
return fact[n]*infac[k]*infac[n-k];
}
int main()
{
int n; cin >> n;
vector<mint> pow2(n+1);
pow2[0].x = 1;
rep(i,n) pow2[i+1] = pow2[i] * mint(2);
vi a(n);
rep(i,n) cin >> a[i];
sort(a.begin(),a.end());
mint res;
mint sum;
rep1(i,n-1) {
sum += mint(a[i]) * pow2[i-1];
}
rep(i,n) {
res += mint(a[i]) * sum;
res += mint(a[i]) * mint(a[i]);
if(i+1 < n) {
sum -= a[i+1];
sum /= mint(2);
}
}
cout << res.x << "\n";
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <numeric>
#include <cmath>
#include <queue>
#include <map>
#include <iomanip>
#include <time.h>
using namespace std;
int64_t mod = 998244353 ;
int64_t min(int64_t a,int64_t b) {
if (a > b)
{
return b ;
}else
{
return a ;
}
}
vector<int> getprime(int n){
vector<int> p(0) ;
vector<bool> table(n+1,0) ;
for (int i = 2; i <= n; i++)
{
if (table.at(i) == 0)
{
p.push_back(i) ;
for (size_t j = 2; j < n/i ; j++)
{
table.at(i*j) = 1 ;
}
}
}
return p ;
}
int getnum(vector<int> &array, vector<char> &c, char a){
for (int i = 0; i < c.size(); i++)
{
if (a == c.at(i))
{
return array.at(i) ;
}
}
}
int64_t repeatmod(int64_t n, int64_t pow, int64_t p){
if (pow == 1)
{
return n%p ;
}
if (pow % 2)
{
return (repeatmod(n, pow-1,p) * n) % p ;
}else
{
return (repeatmod(n,pow/2,p) * repeatmod(n,pow/2,p)) % p ;
}
}
int main(){
int64_t n,p ;
cin >> n >> p ;
if (n == 1)
{
cout << p-1 << endl ;
return 0 ;
}
int64_t mod = 1000000007 ;
int64_t ans = ( (p-1) * repeatmod(p-2,n-1,mod) ) % mod ;
cout << ans << endl ;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = (ll)1e9 + 7;
ll n, p;
ll pow_(ll high)
{
if (high==0)return 1;
ll val = pow_(high / 2);
if (high % 2==0)return val * val % MOD;
return val * val % MOD * (p-2)% MOD;
}
int main(void)
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> p;
ll val = (p-1)*pow_(n-1)%MOD;
cout << val;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
#define all(v) begin(v), end(v)
#define sz(v) v.size()
#define INF 1e17
#define EPSILON 1e-14
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;
}
//浮動小数点はなるべく使うな、powも気をつけろ
int main()
{
ll N;
cin >> N;
vector<ll> A(N);
rep(i, N) cin >> A.at(i);
vector<ll> acc(N+1, 0);
rep(i, N){
acc.at(i+1) = acc.at(i) + A.at(i);
}
ll ans = 0;
rep(i, N){
ans += A.at(i)*A.at(i);
}
ans *= N-1;
rep(i, N-1){
ans -= 2 * A.at(i) * (acc.at(N)-acc.at(i+1));
}
cout << ans << '\n';
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> P;
typedef vector<ll> VI;
typedef vector<VI> VVI;
#define REP(i,n) for(ll i=0;i<(n);i++)
#define ALL(v) v.begin(),v.end()
constexpr ll MOD=1000000007;
constexpr ll INF=2e18;
int main(){
int n; cin >> n;
VI p[3];
ll a; char c;
REP(i,n*2){
cin >> a >> c;
if(c=='R')
p[0].push_back(a);
else if(c=='G')
p[1].push_back(a);
else
p[2].push_back(a);
}
if(p[0].size()%2==0&&p[1].size()%2==0&&p[2].size()%2==0){
cout << 0 << endl;
return 0;
}
REP(i,3){
sort(ALL(p[i]));
}
VI x, y, z; bool f=0;
REP(i,3){
if(p[i].size()%2==1){
if(!f)
x=p[i];
else
y=p[i];
f=1;
}
else
z=p[i];
}
ll ans=INF;
for(auto i:x){
auto it=lower_bound(ALL(y),i);
if(it!=y.end())
ans=min(ans,abs(i-*it));
if(it!=y.begin())
ans=min(ans,abs(i-*(it-1)));
}
for(auto i:y){
auto it=lower_bound(ALL(x),i);
if(it!=x.end())
ans=min(ans,abs(i-*it));
if(it!=x.begin())
ans=min(ans,abs(i-*(it-1)));
}
if(z.size()>0){
vector<P> xmxs, ymxs;
REP(i,z.size()){
ll xmx=INF, ymx=INF;
auto it=lower_bound(ALL(x),z[i]);
if(it!=x.end())
xmx=min(xmx,abs(z[i]-*it));
if(it!=x.begin())
xmx=min(xmx,abs(z[i]-*(it-1)));
auto it2=lower_bound(ALL(y),z[i]);
if(it2!=y.end())
ymx=min(ymx,abs(z[i]-*it2));
if(it2!=y.begin())
ymx=min(ymx,abs(z[i]-*(it2-1)));
xmxs.push_back({xmx,i});
ymxs.push_back({ymx,i});
}
sort(ALL(xmxs));
sort(ALL(ymxs));
if(xmxs[0].second!=ymxs[0].second)
ans=min(ans,xmxs[0].first+ymxs[0].first);
else{
ans=min(ans,xmxs[0].first+ymxs[1].first);
ans=min(ans,xmxs[1].first+ymxs[0].first);
}
}
cout << ans << endl;
return 0;
} |
#include<bits/stdc++.h>
#define pb push_back
#define pl pair<ll,ll>
#define pll pair<ll,pair<ll,ll>>
#define ll long long
#define vl vector<ll>
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL);
#define mp make_pair
#define w(t) int t;cin>>t;while(t--)
#define inf 1e18
#define fi(a,n) for(ll i=a;i<n;i++)
#define fr(i,a,b) for(ll i=a;i>=b;i--)
#define fj(a,n) for(ll j=a;j<n;j++)
#define k(a,n) for(ll k=a;k<n;k++)
#define endl "\n"
#define all(v) (v).begin(),(v).end()
#define set1(x) __builtin_popcount(x)
#define gcd(a,b) __gcd(a,b)
#define mem1(a) memset(a,-1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
using namespace std;
const ll mod= 1000000007;
const ll N =1000005;
void solve()
{
double a,b;
cin>>a>>b;
double x=100;
cout<<(a*b)/x<<endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
// w(t)
solve();
} | #include <bits/stdc++.h>
using namespace std;
typedef bool boool;
typedef long long ll;
#define vl vector<ll>
#define vb vector<boool>
#define vs vector<string>
#define vp vector<pair<ll, ll>>
#define vvl vector<vector<ll>>
#define vvp vector<vector<pair<ll, ll>>>
#define mod 998244353
#define all(x) x.begin(), x.end()
#define rep1(i, n) for (long long i=0; i<(long long)(n); i++)
#define rep2(i, s, e) for (long long i=(s); i<(long long)(e); i++)
#define GET_MACRO(_1,_2,_3,NAME,...) NAME
#define rep(...) GET_MACRO(__VA_ARGS__, rep2, rep1)(__VA_ARGS__)
template<int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0) val += MOD;
}
constexpr int getmod() const { return MOD; }
constexpr Fp operator - () const noexcept {
return val ? MOD - val : 0;
}
constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
constexpr Fp& operator += (const Fp& r) noexcept {
val += r.val;
if (val >= MOD) val -= MOD;
return *this;
}
constexpr Fp& operator -= (const Fp& r) noexcept {
val -= r.val;
if (val < 0) val += MOD;
return *this;
}
constexpr Fp& operator *= (const Fp& r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp& operator /= (const Fp& r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b, swap(a, b);
u -= t * v, swap(u, v);
}
val = val * u % MOD;
if (val < 0) val += MOD;
return *this;
}
constexpr bool operator == (const Fp& r) const noexcept {
return this->val == r.val;
}
constexpr bool operator != (const Fp& r) const noexcept {
return this->val != r.val;
}
friend constexpr istream& operator >> (istream& is, Fp<MOD>& x) noexcept {
is >> x.val;
x.val %= MOD;
if (x.val < 0) x.val += MOD;
return is;
}
friend constexpr ostream& operator << (ostream& os, const Fp<MOD>& x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> mpow(const Fp<MOD>& r, long long n) noexcept {
if (n == 0) return 1;
if (n < 0) return mpow(minv(r), -n);
auto t = mpow(r, n / 2);
t = t * t;
if (n & 1) t = t * r;
return t;
}
friend constexpr Fp<MOD> minv(const Fp<MOD>& r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b, swap(a, b);
u -= t * v, swap(u, v);
}
return Fp<MOD>(u);
}
};
using mint = Fp<mod>;
int main() {
ll n, k;
cin >> n >> k;
vl vec(n);
rep(i, n) cin >> vec[i];
vector<mint> fac(k+1);
fac[0] = 1;
rep(i, 1, k+1) fac[i] = fac[i-1]*i;
vector<vector<mint>> table(k+1, vector<mint>(n+1, 1));
table[0][n] = n;
rep(i, 1, k+1){
mint tmp(0);
rep(j, n){
table[i][j] = table[i-1][j] *= vec[j];
tmp += table[i][j];
}
table[i][n] = tmp;
}
rep(i, 1, k+1){
mint ans(0);
rep(j, i+1){
mint denom = fac[j]*fac[i-j];
mint num = fac[i] * minv(denom);
num *= table[j][n];
num *= table[i-j][n];
ans += num;
}
mint dup = mpow(mint(2), i) * table[i][n];
ans -= dup;
ans /= 2;
cout << ans << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define all(s) s.begin(), s.end()
#define FOR0(i, a) for (int i = 0; i < a; i++)
#define FOR(i, a, b) for (int i = a; i < b; i++)
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<bool> vb;
int main (void) {
cin.tie(0), cout.tie(0)->sync_with_stdio(0);
int n;
cin >> n;
ll max1, max2;
max1 = max2 = 0;
ll max1Ind = 0, max2Ind = 0;
int N = pow(2, n);
FOR(i, 1, N + 1) {
ll temp;
cin >> temp;
if (i <= N/2) {
if (temp > max1) {
max1 = temp;
max1Ind = i;
}
}
else {
if (temp > max2) {
max2 = temp;
max2Ind = i;
}
}
}
//cout << max1 << " " << max1Ind << " " << max2 << " " << max2Ind << "\n";
if (max1 > max2) {
cout << max2Ind << "\n";
}
else {
cout << max1Ind << "\n";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int A[3];
for(int i = 0; i < 3; i++){
cin >> A[i];
}
for(int i = 0; i < 2; i++){
for(int j = 0; j < 2 - i; j++){
if(A[j] < A[j + 1]){
int tmp = A[j + 1];
A[j + 1] = A[j];
A[j] = tmp;
}
}
}
if(A[0] - A[1] == A[1] - A[2]){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
bool p=0;
for(int i=0;i<s.size();i+=2)
if(s[i]>'z'||s[i]<'a')
p=1;
for(int i=1;i<s.size();i+=2)
if(s[i]>'Z'||s[i]<'A')
p=1;
if(p==0)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
} | #include <bits/stdc++.h>
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
typedef long long ll;
typedef long double ld;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define mod 1000000007
#define pii pair<ll,ll>
#define inf 1000000000000000000
#define bpc(x) __builtin_popcountll(x)
#define autoit(x,it) for(auto it = x.begin(); it != x.end(); it++)
#define autoitr(x,it) for(auto it = x.rbegin(); it != x.rend(); it++)
#define rep(n) for(ll i = 0; i < n; i++)
#define repi(i,n) for(ll i = 0; i < n; i++)
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<ll, null_type,less<ll>, rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
int main()
{
FAST/**/
string s;
cin>>s;
rep(s.length())
{
if(i%2 == 0 && isupper(s[i]))
{
cout<<"No\n";
return 0;
}
if(i%2 == 1 && islower(s[i]))
{
cout<<"No\n";
return 0;
}
}
cout<<"Yes\n";
return 0;
}
|
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define cinf(n,x) for(int i=0;i<(n);i++)cin>>x[i];
#define ft first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(),(v).end()
#define LB(a,x) lb(all(a),x)-a.begin()
#define UB(a,x) ub(all(a),x)-a.begin()
#define mod 1000000007
//#define mod 998244353
#define FS fixed<<setprecision(15)
using namespace std;
typedef long long ll;
const double pi=3.141592653589793;
template<class T> using V=vector<T>;
using P=pair<ll,ll>;
typedef unsigned long long ull;
typedef long double ldouble;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline void out(T a){ cout << a << '\n'; }
void YN(bool ok){if(ok) cout << "Yes" << endl; else cout << "No" << endl;}
//void YN(bool ok){if(ok) cout << "YES" << endl; else cout << "NO" << endl;}
const ll INF=1e18;
const int mx=200005;
class UnionFind{
public:
vector<ll> par,num;
int find(ll v){
return (par[v]==v)? v: (par[v]=find(par[v]));
}
explicit UnionFind(ll N):par(N),num(N,1){
iota(par.begin(),par.end(),0);
}
void unite(ll u,ll v){
u=find(u),v=find(v);
if(u==v)return ;
if(num[u]<num[v])swap(u,v);
num[u] += num[v];
par[v] = u;
}
bool same(ll u,ll v){
return find(u) == find(v);
}
bool ispar(ll v){
return v=find(v);
}
ll size(ll v){
return num[find(v)];
}
};
//arc111
int main(){
//オーバーフローは大丈夫ですか？？
cin.tie(0);ios::sync_with_stdio(false);
int n;
cin>>n;
V<int> a(n),b(n);
UnionFind uf(400000);
V<bool> used(400000,0);
rep(i,n){
cin>>a[i]>>b[i];
a[i]--;b[i]--;
used[a[i]]=1;
used[b[i]]=1;
uf.unite(a[i],b[i]);
}
V<bool> seen(400000,0);
V<int> cnt(400000,0);
rep(i,n){
int x=uf.find(a[i]);
cnt[x]++;
}
int ans=0;
rep(i,400000){
if(!used[i]) continue;
int x=uf.find(i);
if(seen[x]) continue;
seen[x]=1;
if(uf.size(i)-cnt[x]==1) ans+=uf.size(i)-1;
else ans+=uf.size(i);
}
out(ans);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef vector<vector<long long>> VVL;
typedef pair<int,int> Pair;
typedef tuple<int,int,int> tpl;
#define ALL(a) (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define EXIST(m,v) (m).find((v)) != (m).end()
#define LB(a,x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a,x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)
#define en "\n"
constexpr double EPS = 1e-9;
constexpr double PI = 3.1415926535897932;
constexpr int INF = 2147483647;
constexpr long long LINF = 1LL<<60;
constexpr long long MOD = 1000000007; // 998244353;
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;}
void Main(){
int N; cin >> N;
VVI edge(400400);
REP(i,N){
int a,b; cin >> a >> b; a--; b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
int ans = 0;
vector<bool> vis(400400,false);
REP(i,400400){
if(vis[i]) continue;
stack<Pair> s({Pair(i,0)});
int nv = 0, ne = 0;
while(!s.empty()){
auto [v,ptr] = s.top(); s.pop();
if(!vis[v]){
vis[v] = true;
nv++;
}
for(int j=ptr; j<(int)edge[v].size(); j++){
ne++;
if(vis[edge[v][j]]) continue;
s.emplace(v,j+1);
s.emplace(edge[v][j],0);
break;
}
}
ne /= 2;
if(nv == ne+1) ans += nv-1;
else ans += nv;
}
cout << ans << en;
return;
}
int main(void){
cin.tie(0);cout.tie(0);ios_base::sync_with_stdio(0);cout<<fixed<<setprecision(15);
int t=1; //cin>>t;
REP(_,t) Main();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
const int mod = 1e9 + 7;
//const int mod = 998244353;
const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
template< typename T1, typename T2 >
ostream &operator<<(ostream &os, const 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 >
ostream &operator<<(ostream &os, const vector< T > &v) {
for(int i = 0; i < (int) v.size(); i++) {
os << v[i] << (i + 1 != 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 >
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) {
if(b < 0)b *= -1;
return a > b && (a = b, true);
}
template< typename T = int64 >
vector< T > make_v(size_t a) {
return vector< T >(a);
}
template< typename T, typename... Ts >
auto make_v(size_t a, Ts... ts) {
return vector< decltype(make_v< T >(ts...)) >(a, make_v< T >(ts...));
}
template< typename T, typename V >
typename enable_if< is_class< T >::value == 0 >::type fill_v(T &t, const V &v) {
t = v;
}
template< typename T, typename V >
typename enable_if< is_class< T >::value != 0 >::type fill_v(T &t, const V &v) {
for(auto &e : t) fill_v(e, v);
}
template< typename F >
struct FixPoint : F {
FixPoint(F &&f) : F(forward< F >(f)) {}
template< typename... Args >
decltype(auto) operator()(Args &&... args) const {
return F::operator()(*this, forward< Args >(args)...);
}
};
template< typename F >
inline decltype(auto) MFP(F &&f) {
return FixPoint< F >{forward< F >(f)};
}
int main() {
int N;
cin >> N;
vector< int > A(N);
cin >> A;
sort(begin(A), end(A));
int64 ans = 1LL * N * (N - 1) / 2;
int pre = -1, cnt = 0;
for(int i = 0; i <= N; i++) {
if(i == N or A[i] != pre) {
ans -= 1LL * cnt * (cnt - 1) / 2;
if(i != N) pre = A[i];
cnt = 0;
}
++cnt;
}
cout << ans << "\n";
} | /**
* author: mahfuzz
* created: 24.06.2021
**/
#include <bits/stdc++.h>
using namespace std;
#define debug(x) cout << '>' << #x << ':' << x << endl;
#define all(p) p.begin(),p.end()
typedef long long ll;
int main(int argc, char* argv[]){
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
ll n; cin >> n;
map<ll, ll> mp;
ll cnt = 0;
for(ll i = 1; i <= n; i++){
ll x; cin >> x;
mp[x]++;
cnt += (i - mp[x]);
}
cout << cnt << "\n";
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); while (n) { if (n & 1) ans *= x; x *= x; n /= 2; } return ans; }
static_mint inv() const { return pow(M - 2); }
friend static_mint pow(const static_mint &m, long long n) { return m.pow(n); }
friend static_mint inv(const static_mint &m) { return m.inv(); }
static_mint operator+() const { static_mint m; m.val = val; return m; }
static_mint operator-() const { static_mint m; m.val = 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; is >> x; m = x;
return is;
}
};
template <typename>
struct is_mint : public std::false_type { };
template <int M>
struct is_mint<static_mint<M>> : public std::true_type { };
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
using mint = static_mint<998244353>;
int n;
cin >> n;
vector<int> f(n);
for (auto &x : f) cin >> x, --x;
int cycles = 0;
vector<bool> visited(n);
vector<int> in_cycle(n);
for (int i = 0, v; i < n; i++) {
if (visited[i])
continue;
for (v = i; !visited[v]; v = f[v]) {
visited[v] = true;
}
if (in_cycle[v] == 0) {
for (; in_cycle[v] == 0; v = f[v]) {
in_cycle[v] = 1;
}
cycles += 1;
}
for (v = i; in_cycle[v] == 0; v = f[v]) {
in_cycle[v] = -1;
}
}
cout << mint(2).pow(cycles) - 1 << '\n';
return 0;
} | #pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include<stdio.h>
#include<algorithm>
constexpr unsigned long long MOD = 998244353;
constexpr unsigned long long IM = 18479187003;
constexpr unsigned long long MOD32 = 665496236;
char f[5000][5000];
unsigned long long dp[5000];
int main(){
int H=0, W=0, K=0;
char c=getchar_unlocked();
while(c<='9'&&c>='0') {H=(H<<1)+(H<<3)+c-'0'; c=getchar_unlocked();}
c=getchar_unlocked();
while(c<='9'&&c>='0') {W=(W<<1)+(W<<3)+c-'0'; c=getchar_unlocked();}
c=getchar_unlocked();
while(c<='9'&&c>='0') {K=(K<<1)+(K<<3)+c-'0'; c=getchar_unlocked();}
unsigned long long y = H * W - K;
while(--K>=0){
int h=0, w=0;
c=getchar_unlocked();
while(c<='9'&&c>='0') {h=(h<<1)+(h<<3)+c-'0'; c=getchar_unlocked();}
c=getchar_unlocked();
while(c<='9'&&c>='0') {w=(w<<1)+(w<<3)+c-'0'; c=getchar_unlocked();}
f[h-1][w-1] = getchar_unlocked();
getchar_unlocked();
}
--H; --W;
dp[0] = 1;
for(int i = 0; i < H; ++i){
for (int j = 0; j < W; ++j){
switch(f[i][j]) {
case 'R':
dp[j + 1] += dp[j];
dp[j] = 0;
break;
case '\0':{
dp[j] *= MOD32;
#ifdef _MSC_VER
unsigned long long x;
_umul128(dp[j], IM, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(dp[j])*IM) >> 64);
#endif
dp[j] = dp[j] - x * MOD+MOD;
}
case 'X':
dp[j + 1] += dp[j];
}
}
switch(f[i][W]) {
case 'R':
dp[W] = 0;
break;
case '\0':{
dp[W] *= MOD32;
#ifdef _MSC_VER
unsigned long long x;
_umul128(dp[W], IM, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(dp[W])*IM) >> 64);
#endif
dp[W]= dp[W] - x * MOD+MOD;
}
}
}
for (int j = 0; j < W; ++j){
switch(f[H][j]) {
case '\0':{
dp[j] *= MOD32;
#ifdef _MSC_VER
unsigned long long x;
_umul128(dp[j], IM, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(dp[j])*IM) >> 64);
#endif
dp[j] = dp[j] - x * MOD+MOD;
}
case 'R':
case 'X':
dp[j + 1] += dp[j];
}
}
unsigned long long x = 3;
while(y) {
if(y & 1) {
dp[W] *= x;
#ifdef _MSC_VER
unsigned long long x2;
_umul128(dp[W], IM, &x2);
#else
unsigned long long x2 =
(unsigned long long)(((unsigned __int128)(dp[W])*IM) >> 64);
#endif
dp[W] = dp[W] - x2 * MOD+MOD;
}
{
x *= x;
#ifdef _MSC_VER
unsigned long long x2;
_umul128(x, IM, &x2);
#else
unsigned long long x2 =
(unsigned long long)(((unsigned __int128)(x)*IM) >> 64);
#endif
x = x- x2 * MOD + MOD;}
y >>= 1;
}
printf("%d", dp[W] % MOD);
return 0;
}
|
// C - Duodecim Ferra
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
#define vec vector
#define rp(i,s,e) for(ll i=(s);i<(e);++i)
// 素数と個数を求める
vector<pair<ll,ll>> factorize(ll n){
vec<pair<ll,ll>> res;
for(ll i=2L; 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,1L);
return res;
}
ll nCr(ll n, ll r){
if(n-r < r) r = n - r;
vec<int> c(n+1);
ll ret = 1;
for(ll i=n; i>=n-r+1; --i){
auto pc = factorize(i);
for(auto x:pc) c[x.first] += x.second;
}
rp(i, 1, r+1){
auto pc = factorize(i);
for(auto x:pc) c[x.first] -= x.second;
}
rp(p, 1, n+1){
if(c[p] > 0){
while(c[p]--) ret *= p;
}
}
return ret;
}
int main() {
ll L; cin>>L;
cout<< nCr(L-1, 11) <<endl;
}
| //#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("fast-math")
//#pragma GCC optimize("section-anchors")
//#pragma GCC optimize("profile-values,profile-reorder-functions,tracer")
//#pragma GCC optimize("vpt")
//#pragma GCC optimize("rename-registers")
//#pragma GCC optimize("move-loop-invariants")
//#pragma GCC optimize("unswitch-loops")
//#pragma GCC optimize("function-sections")
//#pragma GCC optimize("data-sections")
//#pragma GCC optimize("branch-target-load-optimize")
//#pragma GCC optimize("branch-target-load-optimize2")
//#pragma GCC optimize("btr-bb-exclusive")
#include <iostream>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <bitset>
#include <queue>
#include <algorithm>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <cassert>
#include <random>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
solve();
}
#define int long long
const int N = 5e5 + 100, K = 3e5, A = 2e5 + 100, MOD = 1e9 + 7, base = 131, INF = 1e18;
int n;
vector < string > s;
set < string > se;
void solve() {
cin >> n;
s.resize(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
se.insert(s[i]);
}
for (int i = 0; i < n; i++) {
if (se.count("!" + s[i])) {
cout << s[i];
return;
}
}
cout << "satisfiable";
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
long long lcm2(long long a, long long b) {
long long d = gcd(a, b);
return a / d * b;
}
long long lcm(const vector<long long> &vec) {
long long l = vec[0];
for (int i = 0; i < vec.size() - 1; i++) {
l = lcm2(l, vec[i + 1]);
}
return l;
}
long long int mypow(long long int a,long long int b){
long long int i=0,ans;
for(i=0;i<b;i++)
{
if(i==0)
{
ans=a;
}
else
{
ans*=a;
}
}
return ans;
}
struct UnionFind{
int n;
vector<int> par; // 親の番号
vector<int> siz; // サイズを表している。
// 初期化する。parは自身を指す（iotaは 0 ~ nまでの数字を順に入れていく）
// size(siz) は最初はすべて１
UnionFind(int n) : n(n){
par.resize(n);
iota(par.begin(),par.end(),0);
siz.assign(n,1);
}
// 頂点の親を求める。
// 再帰関数を使っており、経路圧縮もしている。
int root(int x){
// ここは親の処理。
if (par[x] == x){
return x;
}
//経路圧縮をしながら値を返す。
// par[x] = root(par[x]);
// return par[x];
// と同じ意味。
return par[x] = root(par[x]);
}
// unite :: a と bを同じグループに入れる。
// もし初めから同じなら何もしない。
void unite(int a,int b){
int ra = root(a);
int rb = root(b);
if(ra == rb){
return;
}
// サイズの大きい方にサイズの小さいほうを合成するので、swapしている。
if (siz[ra] < siz[rb]){
swap(ra,rb);
}
// サイズが大きい方に小さいのを合体
// 小さいほうの親は大きい方の親になる。
siz[ra] += siz[rb];
par[rb] = ra;
}
// 同じグループかどうか判定するには、親が一緒かどうかをみたらよい
bool same(int x,int y){
return root(x) == root(y);
}
// 頂点が含まれるグループの頂点を求める。
int get_size(int x){
return siz[root(x)];
}
};
long long int facctorialMethod(int k){
long long int sum = 1;
for (int i = 1; i <= k; ++i)
{
sum *= i;
}
return sum;
}
#define PI 3.14159265359
int main()
{
[[maybe_unused]]long long int i=0,j=0,b,c,n=0;
[[maybe_unused]]double ab,bc;
string s1;
cin >> b >> c;
if(b<0)
{
n=1;
}
b=abs(b);
if(b==0)
{
cout << c;
}
else if(b*2+2>=c && c>=3 && n==1)
{
cout << (c-2)*2+3;
return 0;
}
else if(b*2>=c && c>=3 && n==0)
{
cout << (c-2)*2+3;
return 0;
}
else if(b*2+2<c && c>=3 && n==1)
{
cout << b*2+c;
return 0;
}
else if(b*2<c && c>=3 && n==0)
{
cout << b*2+c-1;
return 0;
}
else
{
cout << c+1;
}
return 0;
} | #include <cstdio>
#include <algorithm>
long long b, c;
int main() {
scanf("%lld%lld", &b, &c);
if(b == 0) printf("%lld", (c-1)/2 + 1 + c/2);
else if(b > 0) printf("%lld", std::min(c/2, b) + std::min((c-1)/2, b-1) + (c-1)/2 + 1 + std::max(c/2-1, 0ll) + 1);
else printf("%lld", std::min(std::max(c/2-1, 0ll), -b-1) + std::min((c-1)/2+1, -b+1) + 1 + c/2 + (c-1)/2);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ar array
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define mx *max_element
#define mn *min_element
#define endl "\n"
#define fo(i,n) for(ll i=0;i<n;i++)
#define all(x) x.begin(),x.end()
#define sortall(x) sort(all(x))
#define precision cout<<fixed<<setprecision(10)
#define w(t) ll t;cin>>t;while(t--)
#define setbits(x) __builtin_popcountll(x)
const double pi=3.1415926535897932384626;
//const ll mod = 998244353;
const ll mod=1e9+7;
int main()
{
IOS
ll x,y,a,b;
cin>>x>>y>>a>>b;
ll c=0;
while(1){
if(x>1e9) break;
if(x*a>x+b||(x*a)>=y)
break;
c++;
x=x*a;
}
if(x>=y)
cout<<c<<endl;
else{
ll p=(y-x);
if(p%b==0)
c+=(p/b-1);
else
c+=(p/b);
cout<<c;
}
return 0;
} | #include <stdio.h>
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
using ll = long long int;
const int INF = (1<<30);
const ll INFLL = (1ll<<60);
const ll MOD = (ll)(1e9+7);
#define l_ength size
void mul_mod(ll& a, ll b){
a *= b;
a %= MOD;
}
void add_mod(ll& a, ll b){
a = (a<MOD)?a:(a-MOD);
b = (b<MOD)?b:(b-MOD);
a += b;
a = (a<MOD)?a:(a-MOD);
}
int main(void){
int n=1000,i,j,sx,sy,gx,gy,d;
for(i=0; i<n; ++i){
std::cin >> sx >> sy >> gx >> gy;
if(gx > sx){
for(j=sx; j<gx; ++j){
std::cout << "D";
}
}else{
for(j=gx; j<sx; ++j){
std::cout << "U";
}
}
if(gy > sy){
for(j=sy; j<gy; ++j){
std::cout << "R";
}
}else{
for(j=gy; j<sy; ++j){
std::cout << "L";
}
}
std::cout << std::endl;
std::cin >> d;
}
return 0;
}
|
#include <stdio.h>
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
using ll = long long int;
const int INF = (1<<30);
const ll INFLL = (1ll<<60);
const ll MOD = (ll)(1e9+7);
#define l_ength size
void mul_mod(ll& a, ll b){
a *= b;
a %= MOD;
}
void add_mod(ll& a, ll b){
a = (a<MOD)?a:(a-MOD);
b = (b<MOD)?b:(b-MOD);
a += b;
a = (a<MOD)?a:(a-MOD);
}
int main(void){
int q,n,k;
bool flag;
std::string s;
std::cin >> q;
while(q--){
std::cin >> s;
flag = false;
n = s.l_ength();
if(s > "atcoder"){
std::cout << 0 << std::endl;
continue;
}
for(k=1; k<n; ++k){
if(s[k]>'a'){
flag = true;
break;
}
}
if(!flag){
std::cout << (-1) << std::endl;
continue;
}
if(s[k]>'t'){
std::cout << k-1 << std::endl;
}else{
std::cout << k << std::endl;
}
}
return 0;
}
| #pragma GCC optimize("Ofast","inline","-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
#include<bits/stdc++.h>
#define int long long
#define pb push_back
#define pf push_front
#define F first
#define S second
#define SS stringstream
#define sqr(x) ((x)*(x))
#define m0(x) memset(x,0,sizeof(x))
#define m1(x) memset(x,63,sizeof(x))
#define CC(x) cout << (x) << endl
#define AL(x) x.begin(),x.end()
#define pw(x) (1ull<<(x))
#define NMSL cout << "NMSL" << endl;
#define debug(x) cout << #x << ": " << x << endl;
#define debug2(x, y) cout <<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl;
#define debug3(x, y, z) cout <<#x<<": "<<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl;
#define debug4(a, b, c, d) cout <<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<endl;
#define fio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define in128 __int128_t
using namespace std;
const int N = 1e5+10;
const int INF = 0x7f7f7f7f;
const double EPS = 1e-3;
const long double PI = 3.14159265358979323846;
int a[N];
signed main()
{
fio
int T;
string ss;
string at="atcoder";
cin>>T;
while(T--)
{
cin>>ss;
string sk=ss;
sort(sk.begin(),sk.end());
reverse(sk.begin(),sk.end());
if(sk<=at)
{
cout<<-1<<endl;
continue;
}
int ans=INF;
if(ss>at)ans=0;
else if(ss==at)ans=1;
else
{
for(int i=0;i<ss.length();++i)
{
for(int j=i+1;j<ss.length();++j)if(ss[j]>at[i]){ans=min(ans,j-i);break;}
if(ss[i]<at[i])break;
}
}
cout<<ans<<endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
int main()
{
int h = 0, w = 0, futon_counter = 0;
std::string room = "";
std::cin >> h >> w;
for(int i = 0; i < h; ++i)
{
std::string tmp = "";
std::cin >> tmp;
room += tmp;
}
for(int i = 0; i < h * w; ++i)
{
if(room[i] == '#') continue;
if(room[i + 1] == '.' && ( i + 1 < h * w) && ((i + 1) % w != 0)) ++futon_counter;
if(room[i + w] == '.' && (i + w < h * w)) ++futon_counter;
}
std::cout << futon_counter << std::endl;
return 0;
} | #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const long long mod = 1000000007;
int cnt[4][2000][2000];
int main(void){
int h, w;
string s[2000];
cin >> h >> w;
for(int i=0;i<h;i++) cin >> s[i];
vector< long long > p(h*w+1, 0);
p[0] = 1;
for(int i=1;i<=h*w;i++) p[i] = p[i-1]*2 % mod;
int k = 0;
for(int i=0;i<h;i++) for(int j=0;j<w;j++) if(s[i][j] == '.') k++;
for(int i=0;i<h;i++){
cnt[0][i][0] = 0;
for(int j=1;j<w;j++){
if(s[i][j] == '#') continue;
if(s[i][j-1] == '#'){
cnt[0][i][j] = 0;
}else{
cnt[0][i][j] = cnt[0][i][j-1] + 1;
}
}
cnt[1][i][w-1] = 0;
for(int j=w-2;j>=0;j--){
if(s[i][j] == '#') continue;
if(s[i][j+1] == '#'){
cnt[1][i][j] = 0;
}else{
cnt[1][i][j] = cnt[1][i][j+1] + 1;
}
}
}
for(int j=0;j<w;j++){
cnt[2][0][j] = 0;
for(int i=1;i<h;i++){
if(s[i][j] == '#') continue;
if(s[i-1][j] == '#'){
cnt[2][i][j] = 0;
}else{
cnt[2][i][j] = cnt[2][i-1][j] + 1;
}
}
cnt[3][h-1][j] = 0;
for(int i=h-2;i>=0;i--){
if(s[i][j] == '#') continue;
if(s[i+1][j] == '#'){
cnt[3][i][j] = 0;
}else{
cnt[3][i][j] = cnt[3][i+1][j] + 1;
}
}
}
long long ans = 0;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(s[i][j] == '#') continue;
int c = 1;
for(int l=0;l<4;l++) c += cnt[l][i][j];
ans += p[k-c] * (p[c] - 1) % mod;
}
}
cout << ans%mod << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll N; cin>>N;
ll ans=LLONG_MAX;
ll b=0;
ll pow2=1;
while(pow2<=N) {
ans=min(ans,N/pow2+N%pow2+b);
pow2*=2;
b++;
}
cout<<ans<<endl;
}
| #include<bits/stdc++.h>
using namespace std;
string s;
int main(){
cin>>s;
for(int i=s.size()-1;i>=0;i--){
if(s[i]=='6')cout<<9;
else if(s[i]=='9')cout<<6;
else cout<<s[i];
}
} |
// author: Halit
#include <bits/stdc++.h>
int main() {
std::string str; int k;
std::cin >> str >> k;
auto is_multiple_of_200 = [&]() {
int size = str.size();
if (size < 3) {
return false;
} if (str[size-1] != '0' || str[size-2] != '0') {
return false;
} if ( int(str[size-3]-'0')&1) {
return false;
} else return true;
};
for (int i = 0;i < k; ++i) {
if (is_multiple_of_200()) {
str.pop_back(); str.pop_back();
str = std::to_string(std::stoll(str)/2);
} else str += "200";
}
std::cout << str;
} | #include <iostream>
using namespace std;
long int N,K;
int main(){
cin>>N>>K;
for(int i=0; i<K;i++){
if(N%200==0){
N=N/200;
}
else{
N=N*1000+200;
}
}
cout<<N<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#define getchar_unlocked getchar
int A[100005];
int B[100005];
int offset[100005];
int minLevel1[100005];
int minLevel2[100005];
int N, L;
inline int nextInt(){
int x=0;
char ch=0;
do{
ch=getchar_unlocked();
}while(ch<'0'||ch>'9');
while(ch>='0'&&ch<='9'){
x=10*x+(ch-'0');
ch=getchar_unlocked();
}
return x;
}
int main(){
N = nextInt();
L = nextInt();
for(int i = 1; i <= N; i ++){
A[i] = nextInt();
offset[i] = A[i]-i;
}
for(int i = 1; i <= N; i ++){
B[i] = nextInt();
}
for(int i = 1; i <= N; i ++){
minLevel1[i] = 0;
minLevel2[i] = 0;
//printf("offset[%d]=%d\n", i, offset[i]);
}
long long ans = 0;
int lo = 1;
int hi2 = 1;
for(int i = 1; i <= N; i ++){
if(A[i] == B[i]){continue;}
if(B[i] == i || B[i] == L-N+i){
ans ++;
}else{
while(lo < N+2 && offset[lo] < B[i]-i){
lo ++;
}
if((lo == N+2) || (offset[lo] != B[i]-i)){
printf("-1");
return 0;
}
hi2 = max(hi2, lo);
while(hi2 < N+2 && offset[hi2] <= B[i]-i){
hi2 ++;
}
int hi = hi2-1;
//int hi = upper_bound(offset+1, offset+(1+N), B[i]-i) - offset - 1;
if(lo > i){
minLevel2[lo] = max(minLevel2[lo], lo - i);
}else{
minLevel1[hi] = max(minLevel1[hi], i - hi);
}
//printf("i=%d [%d, %d]\n", i, lo, hi);
//ans += min(abs(lo - i), abs(hi - i));
}
}
for(int i = 1; i <= N; i ++){
ans += minLevel1[i] + minLevel2[i];
}
printf("%lld\n", ans);
return 0;
}
| #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#include <bits/stdc++.h>
using namespace std;
template<class t> inline t read(t &x){
char c=getchar();bool f=0;x=0;
while(!isdigit(c)) f|=c=='-',c=getchar();
while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
if(f) x=-x;return x;
}
template<class t,class ...A> inline void read(t &x,A &...a){
read(x);read(a...);
}
template<class t> inline void write(t x){
if(x<0) putchar('-'),write(-x);
else{if(x>9) write(x/10);putchar('0'+x%10);}
}
const int N=1e5+5;
int n,m,tp[N],a[N],b[N];
long long ans;
void GG(){
write(-1);
exit(0);
}
signed main(){
read(n,m);
for(int i=1;i<=n;i++) read(tp[i]),a[i]=tp[i]-tp[i-1]-1;a[n+1]=m-tp[n];
for(int i=1;i<=n;i++) read(tp[i]),b[i]=tp[i]-tp[i-1]-1;b[n+1]=m-tp[n];n++;
for(int i=1,j=1;i<=n;i++) if(b[i]){
while(!a[j]) j++;
int cur=0,l=j;
while(j<=n&&cur<b[i]) cur+=a[j++];
if(cur>b[i]) GG();
ans+=max(i-l,0)+max(j-1-i,0);
}
write(ans);
} |
#include <bits/stdc++.h>
#include <random>
using namespace std; typedef unsigned long long _ulong; typedef long long int lint; typedef long double ld; typedef pair<lint, lint> plint; typedef pair<ld, ld> pld;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define FOR(i, begin, end) for(lint i=(begin),i##_end_=(end);i<i##_end_;++i)
#define IFOR(i, begin, end) for(lint i=(end)-1,i##_begin_=(begin);i>=i##_begin_;--i)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
#define endk '\n'
#define fi first
#define se second
struct fast_ios { fast_ios() { cin.tie(nullptr), ios::sync_with_stdio(false), cout << fixed << setprecision(20); }; } fast_ios_;
template<class T> auto add = [](T a, T b) -> T { return a + b; };
template<class T> auto f_max = [](T a, T b) -> T { return max(a, b); };
template<class T> auto f_min = [](T a, T b) -> T { return min(a, b); };
template<class T> using V = vector<T>;
using Vl = V<lint>; using VVl = V<Vl>;
template< typename T > ostream& operator<<(ostream& os, const vector< T >& v) {
for (int i = 0; i < (int)v.size(); i++) os << v[i] << (i + 1 != v.size() ? " " : "");
return os;
}
template< typename T >istream& operator>>(istream& is, vector< T >& v) {
for (T& in : v) is >> in;
return is;
}
template<class T> bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
lint gcd(lint a, lint b) { if (b == 0) return a; else return gcd(b, a % b); }
lint ceil(lint a, lint b) { return (a + b - 1) / b; }
lint digit(lint a) { return (lint)log10(a); }
lint e_dist(plint a, plint b) { return abs(a.fi - b.fi) * abs(a.fi - b.fi) + abs(a.se - b.se) * abs(a.se - b.se); }
lint m_dist(plint a, plint b) { return abs(a.fi - b.fi) + abs(a.se - b.se); }
void Worshall_Floyd(VVl& g) { REP(k, SZ(g)) REP(i, SZ(g)) REP(j, SZ(g)) chmin(g[i][j], g[i][k] + g[k][j]); }
const lint MOD1000000007 = 1000000007, MOD998244353 = 998244353, INF = 1e18;
lint dx[8] = { 1, 0, -1, 0, 1, -1, 1, -1 }, dy[8] = { 0, 1, 0, -1, -1, -1, 1, 1 };
bool YN(bool flag) { cout << (flag ? "YES" : "NO") << endk; return flag; } bool yn(bool flag) { cout << (flag ? "Yes" : "No") << endk; return flag; }
struct Edge {
lint from, to;
lint cost;
Edge(lint u, lint v, lint c) {
cost = c;
from = u;
to = v;
}
bool operator<(const Edge& e) const {
return cost < e.cost;
}
};
struct WeightedEdge {
lint to;
lint cost;
WeightedEdge(lint v, lint c = 1) {
to = v;
cost = c;
}
bool operator<(const WeightedEdge& e) const {
return cost < e.cost;
}
};
using WeightedGraph = V<V<WeightedEdge>>;
typedef pair<lint, plint> tlint;
typedef pair<plint, tlint> qlint;
typedef pair<string, lint> valstring;
lint A, B, C, D;
int main() {
cin >> A >> B >> C >> D;
yn(!(A * B <= D && D <= A * C));
} | #define _USE_MATH_DEFINES
#include <cmath>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
using namespace std;
// printf("%d\n", x); =>
// cout << x << "\n";
// scanf("%d", &x); =>
// cin >> x;
int main(int argc, char **argv) {
int v, t, s, d;
scanf("%d%d%d%d", &v, &t, &s, &d);
if (d >= v * t && d <= v * s) {
printf("No\n");
return 0;
}
printf("Yes\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define gok ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
//#define endl "\n"
# define int long long
#define pb push_back
const int N = 3005,mod = 1e9 + 7;
int n;
int a[20];
int help(int id,int orr,int xr)
{
if(id==n)
return (xr^orr);
int op1=1e12,op2=1e12;
op1 = help(id+1,(orr|a[id]),xr);
op2 = help(id+1,a[id],(xr^orr));
return min(op1,op2);
}
signed main(){
gok
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
cout<<help(0,0,0);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// #define LOCAL // 提出時はコメントアウト
#define DEBUG_
typedef long long ll;
const double EPS = 1e-9;
const ll INF = ((1LL<<62)-(1LL<<31));
typedef vector<ll> vecl;
typedef pair<ll, ll> pairl;
template<typename T> using uset = unordered_set<T>;
template<typename T, typename U> using mapv = map<T,vector<U>>;
template<typename T, typename U> using umap = unordered_map<T,U>;
#define ALL(v) v.begin(), v.end()
#define REP(i, x, n) for(int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define sz(x) (ll)x.size()
ll llceil(ll a,ll b) { return (a+b-1)/b; }
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; }
template<class T> vector<vector<T>> genarr(ll n, ll m, T init) { return vector<vector<T>>(n,vector<T>(m,init)); }
///// DEBUG
#define DUMPOUT cerr
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
template<typename T>istream&operator>>(istream&is,vector<T>&vec){for(T&x:vec)is>>x;return is;}
template<typename T,typename U>ostream&operator<<(ostream&os,pair<T,U>&pair_var){os<<"("<<pair_var.first<<", "<<pair_var.second<<")";return os;}
template<typename T>ostream&operator<<(ostream&os,const vector<T>&vec){os<<"{";for(int i=0;i<vec.size();i++){os<<vec[i]<<(i+1==vec.size()?"":", ");}
os<<"}";return os;}
template<typename T,typename U>ostream&operator<<(ostream&os,map<T,U>&map_var){os<<"{";repi(itr,map_var){os<<*itr;itr++;if(itr!=map_var.end())os<<", ";itr--;}
os<<"}";return os;}
template<typename T>ostream&operator<<(ostream&os,set<T>&set_var){os<<"{";repi(itr,set_var){os<<*itr;itr++;if(itr!=set_var.end())os<<", ";itr--;}
os<<"}";return os;}
void dump_func(){DUMPOUT<<endl;}
template<class Head,class...Tail>void dump_func(Head&&head,Tail&&...tail){DUMPOUT<<head;if(sizeof...(Tail)>0){DUMPOUT<<", ";}
dump_func(std::move(tail)...);}
#ifndef LOCAL
#undef DEBUG_
#endif
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" \
<< endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
//////////
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
int solve(ostringstream &cout) {
#ifdef LOCAL
ifstream in("../../Atcoder/input.txt");
cin.rdbuf(in.rdbuf());
#endif
ll N;
cin>>N;
ll ans = 0;
vecl A(N);
rep(i,N) cin>>A[i], ans ^= A[i];
dump(ans);
if (N == 1) {
cout << ans << endl;
return 0;
}
ll e = 0;
// ll ans = INF;
rep(i,1<<(N-1)) {
if (i == 0) continue;
ll s = 0;
vecl OR;
ll current = e;
rep(j,N-1) {
if (i & (1<<j)) { // i - i + 1
current = current | A[j];
OR.push_back(current);
current = e;
s = i + 1;
}
else {
current = current | A[j];
}
}
OR.push_back(current | A[N-1]);
ll sub = 0;
for (auto x : OR) sub ^= x;
dump(i,sub,OR);
chmin(ans,sub);
}
cout << ans << endl;
return 0;
}
int main() {
ostringstream oss;
int res = solve(oss);
cout << oss.str();
return res;
}
|
#define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/stack:512000000")
#include<utility>
#include<iostream>
#include<fstream>
#include<vector>
#include<array>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<ctime>
#include<functional>
#include<random>
#include<climits>
#include<queue>
#include<stack>
#include<deque>
#include<bitset>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<cassert>
#include<ccomplex>
#include<chrono>
#include<iomanip>
#ifdef ONLINE_JUDGE
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("unroll-loops")
#define int128 __int128
#else
#define int128 long long
#endif
#define all(x) x.begin(), x.end()
#define make_unique(x) sort(all((x))); (x).resize(unique(all((x))) - (x).begin())
#define mp make_pair
#define X first
#define Y second
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937_64 gen(time(nullptr));
namespace {
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template<typename T, typename F>
using HashMap = unordered_map<T, F, custom_hash>;
template<typename T>
using HashSet = unordered_set<T, custom_hash>;
}
ll mod = 1e9 + 7;
namespace {
ll mul(ll a, ll b) {
ll val = a * b - (ll)((ld)a * b / mod) * mod;
if (val < 0) val += mod;
if (val >= mod) val -= mod;
return val;
}
ll poww(ll a, ll b) {
ll val = 1;
a %= mod;
while (b > 0) {
if (b % 2) val = mul(a, val);
a = mul(a, a);
b >>= 1;
}
return val % mod;
}
ll inv(ll a) {
return poww(a, mod - 2);
}
ll gcd(ll a, ll b) {
return (a == 0 ? b : gcd(b % a, a));
}
ll gcdex(ll a, ll b, ll& x, ll& y) {
if (a == 0) {
x = 0; y = 1;
return b;
}
ll x1, y1;
ll d = gcdex(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
ll inv_eu(ll a, ll m) {
ll x, y;
ll g = gcdex(a, m, x, y);
if (g != 1)
assert(0);
else {
x = (x % m + m) % m;
return x;
}
}
}
ll const inf = 1e11 + 9;
ll const maxk = 22;
ll const maxn = 3e5 + 5;
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ld sx, sy, gx, gy;
cin >> sx >> sy >> gx >> gy;
ld len = gx - sx;
cout << fixed << setprecision(15);
cout << (sx + len / (1 + gy / sy));
return 0;
}
/*
1
8
1 2 7 3 2 1 2 3
1
7
4 1 5 2 6 3 7
*/ | /******** All Required Header Files ********/
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
using namespace std;
/******* All Required define Pre-Processors and typedef Constants *******/
#define SCD(t) scanf("%d",&t)
#define SCLD(t) scanf("%ld",&t)
#define SCLLD(t) scanf("%lld",&t)
#define SCC(t) scanf("%c",&t)
#define SCS(t) scanf("%s",t)
#define SCF(t) scanf("%f",&t)
#define SCLF(t) scanf("%lf",&t)
#define MEM(a, b) memset(a, (b), sizeof(a))
#define FOR(i, j, k, in) for (int i=j ; i<k ; i+=in)
#define RFOR(i, j, k, in) for (int i=j ; i>=k ; i-=in)
#define REP(i, j) FOR(i, 0, j, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define IN(A, B, C) assert( B <= A && A <= C)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
const double pi=acos(-1.0);
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int,int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
/****** Template of some basic operations *****/
template<typename T, typename U> inline void amin(T &x, U y) { if(y < x) x = y; }
template<typename T, typename U> inline void amax(T &x, U y) { if(x < y) x = y; }
/**********************************************/
/****** Template of Fast I/O Methods *********/
template <typename T> inline void write(T x)
{
int i = 20;
char buf[21];
// buf[10] = 0;
buf[20] = '\n';
do
{
buf[--i] = x % 10 + '0';
x/= 10;
}while(x);
do
{
putchar(buf[i]);
} while (buf[i++] != '\n');
}
template <typename T> inline T readInt()
{
T n=0,s=1;
char p=getchar();
if(p=='-')
s=-1;
while((p<'0'||p>'9')&&p!=EOF&&p!='-')
p=getchar();
if(p=='-')
s=-1,p=getchar();
while(p>='0'&&p<='9') {
n = (n<< 3) + (n<< 1) + (p - '0');
p=getchar();
}
return n*s;
}
/************************************/
/******* Debugging Class Template *******/
#define DEBUG
#ifdef DEBUG
#define debug(args...) (Debugger()) , args
class Debugger
{
public:
Debugger(const std::string& _separator = " - ") :
first(true), separator(_separator){}
template<typename ObjectType> Debugger& operator , (const ObjectType& v)
{
if(!first)
std:cerr << separator;
std::cerr << v;
first = false;
return *this;
}
~Debugger() { std:cerr << endl;}
private:
bool first;
std::string separator;
};
#else
#define debug(args...) // Just strip off all debug tokens
#endif
#define ll long long
#define MAX_PRIME 100005
vector<int> primes;
void sieve(){
bool composite[MAX_PRIME];
composite[0] = true;
composite[1] = true;
for(int i=2; i*i<MAX_PRIME; i++){
if(!composite[i]){
primes.push_back(i);
for(int j=2*i; j<MAX_PRIME; j+=i) composite[j]=true;
}
}
}
void solve(){
ll sx, sy, gx, gy;
cin>>sx>>sy>>gx>>gy;
double ans=(double)(sy*gx+gy*sx)/(double)(sy+gy);
cout<<std::fixed;
cout.precision(9);
cout<<ans<<"\n";
}
int main()
{
int t=1;
// cin>>t;
while(t--){
solve();
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int fn(int ii)
{
int a=0;
for(int i=0;i<20;i++)
{
if(((1 << i) & ii)!=0)
a++;
}
return a;
}
int gn(map<int,int> mp,int i)
{
vector<int> vc;
for(int j=0;j<20;j++)
{
if(((1 << j) & i)!=0)
vc.push_back(j+1);
}
for(auto ii : mp)
{
int k=0;
for(int j=0;j<vc.size();j++)
{
if(vc[j]<=ii.first) k++;
}
if(k>ii.second)
return 0;
}
return 1;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n,m;
cin>>n>>m;
map<int,int> a[n];
for(int i=0;i<m;i++)
{
int x,y,z;
cin>>x>>y>>z;
x--;
if(a[x].find(y)==a[x].end())
a[x][y]=z;
else a[x][y]=min(a[x][y],z);
}
int sz=(1 << n);
long long int dp[sz];
for(int i=0;i<sz;i++)
dp[i]=0;
dp[0]=1;
for(int i=1;i<sz;i++)
{
//to arrange bit'th no of elemnts
int k=fn(i);
if(gn(a[k-1],i)==1)//has conditions
{
for(int j=0;j<n;j++)
{
if(((1 << j) & i)!=0)
dp[i]+=dp[i-(1 << j)];
}
}
}
cout<<dp[sz-1];
return 0;
} | #pragma region
#ifdef LOCAL
#include "pch.h"
#else
#include <bits/stdc++.h>
#endif
// debug
template<typename ... Types>
void __read(Types& ... args) {
((std::cin >> args), ...);
}
#define read(type, ...) type __VA_ARGS__; __read(__VA_ARGS__)
template <typename Type, typename... Types>
auto print(Type const &arg, Types const &... args) {
std::cout << arg, ((std::cout << " " << args), ...), std::cout << std::endl;
}
template <typename Type, typename... Types>
auto print_debug(Type const &arg, Types const &... args) {
std::cout << arg, ((std::cout << " | " << args), ...), std::cout << std::endl;
}
#ifdef LOCAL
#define debug(...) do{std::cout << __LINE__ << ": [" << #__VA_ARGS__ << "]: ", print_debug(__VA_ARGS__);}while(0)
#else
#define debug(...) 1
#endif
#define __DEF_PRINTER(container) \
template<typename T> \
std::ostream& operator<<(std::ostream& out, container<T> const& a) \
{ \
size_t len = a.size(); \
for(auto x : a) out << x << " \n"[len--==0]; \
return out; \
}
__DEF_PRINTER(std::vector)
__DEF_PRINTER(std::set)
__DEF_PRINTER(std::unordered_set)
// end debug
#define ALL(container) std::begin(container), std::end(container)
#define RANGE(container, lo, hi) std::begin(container)+(lo), std::begin(container)+(hi)
const char nl = '\n';
using std::cout;
using std::cin;
template <typename T>
void minmax(T k1, T k2, T& min, T& max) {
min = std::min(k1, k2);
max = std::max(k1, k2);
}
std::vector<int> iota(int size) {
std::vector<int> res(size);
std::iota(res.begin(), res.end(), 0);
return res;
}
template <typename Iter>
auto counter(Iter from, Iter to) {
std::map<typename Iter::value_type, int> res;
while(from != to) res[*from++]++;
return res;
}
const long long mod = 1e9+7;
long long reduce_mod(long long a) {
return (a % mod + mod) % mod;
}
long long add(long long a, long long b) {
return reduce_mod(a + b);
}
long long mult(long long a, long long b) {
return reduce_mod(a * b);
}
std::string yn(bool yes) {
return yes ? "yes" : "no";
}
#pragma endregion
int main() {
cin.tie(0)->sync_with_stdio(false);
read(int, n, m);
std::vector<int> x(m), y(m), z(m);
for(int i = 0; i < m; i++) {
read(int, xi, yi, zi);
x[i] = xi, y[i] = yi, z[i] = zi;
}
std::vector<long long> dp(1<<n);
dp[0] = 1;
for (int mask = 0; mask < 1<<n; mask++) {
int c = __builtin_popcount(mask);
#if 1 // v2
int rest = (((1<<n)-1) & ~mask);
while(rest) {
int mask2 = mask|(rest&-rest);
rest-=rest&-rest;
int valid = 1;
for (int k = 0; k < m; k++) {
if (x[k] == c+1 && __builtin_popcount(mask2 & ((1<<y[k])-1)) > z[k]) {
valid = 0;
break;
}
}
if (valid) {
dp[mask2] += dp[mask];
}
}
#else
for (int j = 0; j < n; j++) {
if (mask&(1<<j)) continue;
int mask2 = mask|(1<<j);
int valid = 1;
for (int k = 0; k < m; k++) {
if (x[k] == c+1 && __builtin_popcount(mask2 & ((1<<y[k])-1)) > z[k]) {
valid = 0;
break;
}
}
if (valid) {
dp[mask2] += dp[mask];
}
}
#endif
}
print(dp[(1<<n)-1]);
} |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define all(x) (x).begin(),(x).end()
ll power(ll x , ll n,ll mod){
if(n == 0) return 1ll;
ll cur = power(x, n >> 1,mod);
if(n & 1) return (cur % mod * cur % mod * x) % mod ;
return (cur % mod * cur % mod) % mod ;
}
const int maxx = 200005;
const int mod = 1000000007;
ll a[maxx];
void solve()
{
ll n , m ; cin >> n >> m;
if(m == 0){
cout << 1;
return ;
}
for(ll i = 1; i <= m ; ++i) cin >> a[i];
sort(a + 1,a + 1 + m);
ll ans = ((a[1] - 1) == 0 ? 1e9 : a[1] - 1);
for(ll i = 2; i <= m ; ++i){
if(a[i] - a[i - 1] - 1 != 0)ans = min(ans , a[i] - a[i - 1] - 1);
}
if(n - a[m] != 0) ans = min(ans,n - a[m]);
if(n == m){
cout << 0;
return ;
}
//cout << ans << '\n';
ll res = ( (a[1] - 1ll) % ans == 0 ? (a[1] - 1ll) / ans : (a[1] - 1ll) / ans + 1);
for(ll i = 2; i <= m ; ++i){
ll cur = (a[i] - a[i - 1] - 1ll) / ans;
res += ( (a[i] - a[i - 1] - 1ll) % ans == 0 ? cur : cur + 1);
}
res += ( (n - a[m]) % ans == 0 ? (n - a[m]) / ans : (n - a[m]) / ans + 1);
cout << res;
}
signed main()
{
//freopen("t.inp","r",stdin);freopen("t.out","w",stdout);
ios_base::sync_with_stdio(false);cin.tie(nullptr);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fw(p) for(int w=0;w<(p);w++)
#define fx(p) for(int x=0;x<(p);x++)
#define fy(p) for(int y=0;y<(p);y++)
#define fz(p) for(int z=0;z<(p);z++)
#define fyg(p,g) for(int y=(g);y<(p);y++)
#define fzg(p,g) for(int z=(g);z<(p);z++)
#define ce(d) cout<<d<<endl;
#define vecp(p) int aa;cin>>aa;(p).push_back(aa);
#define vecpl(p) long long aa;cin>>aa;(p).push_back(aa);
#define vecps(p) string aa;cin>>aa;(p).push_back(aa);
#define vecp2(p) cin>>aa;(p).push_back(aa);
#define vecpl2(p) long long a b;cin>>ab;(p).push_back(ab);
#define vecps2(p) string ab;cin>>ab;(p).push_back(ab);
#define sorts(c) sort((c).begin(),(c).end());
#define reverses(c) reverse((c).begin(),(c).end());
#define vec(b) vector<int> (b);
#define vecl(b) vector<long long> (b);
#define vecs(b) vector<string> (b);
#define pb(b,a) (b).push_back((a));
#define doublece(a,b) cout<<(a)<<' '<<(b)<<endl;
#define pairs(s) vector<pair<int,int>> (s);
#define pairsp(s) int aa,bb;cin>>aa>>bb;(s).push_back(make_pair(aa,bb));
#define MOD 1000000007
#define cey ce("Yes")
#define cen ce("No")
#define ceY ce("YES")
#define ceN ce("NO")
int main()
{
int N, M;
cin >> N >> M;
vec(A);
pb(A, 0);
pb(A, N + 1);
fx(M) {
vecp(A);
}
sorts(A);
int k = INT_MAX;
fx(A.size()-1) {
if (A[x + 1] - A[x] - 1==0) {
continue;
}
k = min(k, max(A[x + 1] - A[x]-1,1));
}
int ans = 0;
fx(A.size()-1) {
ans += (A[x + 1] - A[x] + k - 2) / k;
}
ce(ans)
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
if(a==b){
cout<<c<<endl;
}else if(a==c){
cout<<b<<endl;
}else if(b==c){
cout<<a<<endl;
}else{
cout<<0<<endl;
}
} | #include "bits/stdc++.h"
using namespace std;
using ll=int64_t;
using ld=long double;
using ull=unsigned long long;
template <class T>
using grid=vector<vector<T>>;
#define ALL(x) x.begin(),x.end()
#define rep(iter,from,to) for(ll iter=from;iter<to;++iter)
const ll MOD=1e9+7;
const ll INF=1e17;
//#######################################################################
vector<vector<ll>> input(ll N, ll width){
string str;
vector<vector<ll>> vec(N,vector<ll>(width));
for(ll i=0;i<N;++i){
cin>>str;
reverse(ALL(str));
for(ll j=0;j<width;++j){
vec[i][j]=str.back();
str.pop_back();
}
}
return vec;
}
void op(vector<ll> vec){
ll size=(ll)vec.size();
for(ll i=0;i<size-1;++i) cout<<vec[i]<<" ";
cout<<vec.back()<<endl;
}
void op(vector<vector<ll>> vec){
ll height=(ll)vec.size();
ll width=(ll)vec[0].size();
for(ll i=0;i<height;++i) {
for(ll j=0;j<width-1;++j) cout<<vec[i][j]<<" ";
cout<<vec[i].back()<<endl;
}
}
//########################################################################
int solve(){
ll a,b,c;
cin>>a>>b>>c;
if((a==b)) cout<<c<<endl;
else if(a==c) cout<<b<<endl;
else if(b==c) cout<<a<<endl;
else cout<<"0"<<endl;
return 0;
}
int main(void){
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
solve();
}
|
#include <cmath>
#include <deque>
#include <algorithm>
#include <iterator>
#include <list>
#include <tuple>
#include <map>
#include <unordered_map>
#include <queue>
#include <set>
#include <unordered_set>
#include <stack>
#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <functional>
#include <numeric>
#include <iomanip>
#include <stdio.h>
//eolibraries
#define lnf 3999999999999999999
#define inf 999999999
#define PI 3.14159265359
#define endl "\n"
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define ll long long
#define all(c) (c).begin(),(c).end()
#define sz(c) (int)(c).size()
#define mkp(a,b) make_pair(a,b)
#define make_unique(a) sort(all(a)),a.erase(unique(all(a)),a.end())
#define rsz(a,n) a.resize(n)
#define pii pair <int,int>
#define rep(i,n) for(int i = 0 ; i < n ; i++)
#define drep(i,n) for(int i = n-1 ; i >= 0 ; i--)
#define crep(i,x,n) for(int i = x ; i < n ; i++)
#define vi vector <int>
#define vec(s) vector<s>
#define rsz(a,n) a.resize(n)
#define rszv(a,n,v) a.resize(n,v)
#define fcin ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0);
//eodefine
const int max_n = 300000;
using namespace std;
void slv(vi a){
int n=sz(a);
int op=1;
vi ans;
rep(t,max_n){
int x=0,j=0;
rep(i,n-1) {
if(a[i]>a[i+1]){ x=max(x,a[i]); j=i;}
}
if(x==0) break;
std::function<void(int)> odo1 = [&](int idx){
swap(a[idx],a[idx+1]);
ans.pb(idx);
op++;
};
std::function<void(int)> odo2 = [&](int idx){
int v = a[idx];
crep(k,idx,n-1) {
if(a[k+1]>v) break;
odo1(k);
}
};
std::function<void(int)> inodo1 = [&](int idx){
odo1(idx-1);
odo1(idx);
odo1(idx-1);
odo2(idx);
};
std::function<void(int)> inodo2 = [&](int idx){
odo1(idx+1);
odo1(idx);
odo2(idx+1);
};
if(op%2!=0) {
if(j%2==0) {
odo2(j);
} else {
if(j-1>=0 and j+1<n) inodo1(j);
else if(j+2<n) inodo2(j);
else { odo1(j-1); inodo2(j-1); }
}
} else {
if(j%2==0) {
if(j-1>=0 and j+1<n) inodo1(j);
else if(j+2<n) inodo2(j);
else { odo1(j-1); inodo2(j-1); }
} else {
odo2(j);
}
}
//dbgstrt
// cout << x << " " << j << "\n";
// for(auto y : a) cout << y << " ";
// cout<<"\n\n";
// if(t==3) break;
//dbgend
}
cout << sz(ans) << "\n";
for(auto x : ans) cout << x + 1 << " ";
cout << "\n";
}
// bool ok(pair <int,vi> p) {
// if(p.fi > sz(p.se)*sz(p.se)) return 0;
// vi tmp=p.se;
// sort(all(tmp));
// if(tmp!=p.se)return 0;
// return 1;
// }
int main(){
fcin;
int t;
cin>>t;
rep(_,t){
int n;
cin>>n;
vi a;
rep(i,n){int x;cin>>x;a.pb(x);}
slv(a);
}
// srand(time(NULL));
// while(true) {
// int n=20;
// vi usd(510,0);
// vi a;
// rep(i,n) {
// int x=0;
// while(true) {
// x=rand()%n+1;
// if(usd[x]==1) continue;
// else break;
// }
// usd[x]=1;
// a.pb(x);
// }
// cout << n << "\n";
// for(auto x : a) cout << x << " ";
// cout<<"\n";
// slv(a);
// // if(ok(slv(a)) == 0) {
// // cout << "whaaat\n";
// // return 0;
// // }
// }
/*
*/
return 0;
} | #include<bits/stdc++.h>
using namespace std ;
//mint
using ll = long long ;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
//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 ;
cin >> N ;
vector<long long> A(N) ;
for(int i = 0 ; i < N ; i++) cin >> A.at(i) ;
A.insert(A.begin(),0) ;
mint cnt = 1 ;
sort(A.begin() , A.end()) ;
for(int i = 0 ; i < N ; i++){
cnt *= A.at(i+1) - A.at(i) + 1 ;
}
cout << cnt << endl;
} |
/*
これを入れて実行
g++ code.cpp
./a.out
*/
#include <iostream>
#include <cstdio>
#include <stdio.h>
#include <vector>
#include <string>
#include <cstring>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <math.h>
#include <tuple>
#include <iomanip>
#include <bitset>
#include <functional>
#include <cassert>
#include <random>
#define all(x) (x).begin(),(x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 60;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int>& f, const pair<int, int>& s){
return f.second > s.second;
}
ll gcd(ll a, ll b){
if (b == 0)return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b){
return a / gcd(a, b) * b;
}
ll conbinationMemo[100][100];
void cmemoInit(){
rep(i, 100){
rep(j, 100){
conbinationMemo[i][j] = -1;
}
}
}
ll nCr(ll n, ll r){
if(conbinationMemo[n][r] != -1) return conbinationMemo[n][r];
if(r == 0 || r == n){
return 1;
} else if(r == 1){
return n;
}
return conbinationMemo[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r){
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--) ret *= i;
return ret;
}
//-----------------------ここから-----------
int main(void){
ios_base::sync_with_stdio(false); cin.tie(nullptr);
ll n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
ll ma = 0;
ll ans = 0;
for(ll i = 2; i <= 1000; i++){
ll cnt = 0;
rep(j, n){
if(a[j] % i == 0) cnt++;
}
if(ma < cnt){
ma = cnt;
ans = i;
}
}
cout << ans << endl;
} | #pragma region my_template
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
#define range(i, l, r) for(int i = (int)(l); i < (int)(r); i++)
#define rrange(i, l, r) for(int i = (int)(r)-1; i >= (int)(l); i--)
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) rrange(i, 0, n)
#define len(a) ((int)(a).size())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sum(a) accumulate(all(a), 0)
#define uni(a) (a).erase(unique(all(a)), (a).end());
#define append push_back
#define mp make_pair
#define elif else if
constexpr int MOD = 1e9+7;
//constexpr int MOD = 998244353;
constexpr int INF = 1e9;
constexpr ll LINF = 1e18;
template<typename T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<typename T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return 1; } return 0; }
#pragma endregion
constexpr int K = 1000;
void solve() {
rep(i, K) {
int sy, sx, ty, tx;
cin >> sy >> sx >> ty >> tx;
string ans;
if (sy > ty) {
rep(_, sy-ty) ans.append('U');
} else {
rep(_, ty-sy) ans.append('D');
}
if (sx > tx) {
rep(_, sx-tx) ans.append('L');
} else {
rep(_, tx-sx) ans.append('R');
}
cout << ans << endl;
int t; cin >> t;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
//cout << fixed << setprecision(15);
solve();
return 0;
}
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 4000000000000000000 //オーバーフローに注意
//#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define SIZE 5005
#define MOD 998244353
ll dp[SIZE][SIZE];
char base_map[SIZE][SIZE];
ll mod_pow(ll x,ll count, ll mod){
if(count == 0)return 1;
ll ret = mod_pow((x*x)%mod,count/2,mod);
if(count%2 == 1){
ret = (ret*x)%mod;
}
return ret;
}
ll extgcd(ll a,ll b,ll &x,ll &y){
ll d = a;
if(b != 0){
d = extgcd(b,a%b,y,x);
y -= (a/b)*x;
}else{
x = 1;
y = 0;
}
return d;
}
ll mod_inverse(ll a,ll m){
ll x,y;
extgcd(a,m,x,y);
return (m+x%m)%m;
}
int main(){
ll H,W,K;
scanf("%lld %lld %lld",&H,&W,&K);
for(ll row = 0; row < H; row++){
for(ll col = 0; col < W; col++){
base_map[row][col] ='@';
dp[row][col] = 0;
}
}
int tmp_row,tmp_col;
char buf[2];
for(ll i = 0; i < K; i++){
scanf("%d %d %s",&tmp_row,&tmp_col,buf);
tmp_row--;
tmp_col--;
base_map[tmp_row][tmp_col] = buf[0];
}
ll MULT = 2*mod_inverse(3,MOD);
MULT %= MOD;
dp[0][0] = 1;
for(ll row = 0; row < H; row++){
for(ll col = 0; col < W; col++){
if(row-1 >= 0 && base_map[row-1][col] != 'R'){
if(base_map[row-1][col] == '@'){
dp[row][col] += dp[row-1][col]*MULT;
dp[row][col] %= MOD;
}else{
dp[row][col] += dp[row-1][col];
dp[row][col] %= MOD;
}
}
if(col-1 >= 0 && base_map[row][col-1] != 'D'){
if(base_map[row][col-1] == '@'){
dp[row][col] += dp[row][col-1]*MULT;
dp[row][col] %= MOD;
}else{
dp[row][col] += dp[row][col-1];
dp[row][col] %= MOD;
}
}
}
}
printf("%lld\n",(dp[H-1][W-1]*mod_pow(3,H*W-K,MOD))%MOD);
return 0;
}
| #include <bits/stdc++.h>
// #include <atcoder/all> // NOTE: AtCoderライブラリ
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define dbg(x) cerr << #x << ": " << x << endl;
#define dbg2(x, y) cerr << #x << ": " << x << ", " << #y << ": " << y << endl;
#define dbg3(x, y, z) cerr << #x << ": " << x << ", " << #y << ": " << y << ", " << #z << ": " << z << endl;
#define nl() cout << "========================================" << endl;
using namespace std;
// using namespace atcoder; // NOTE: AtCoderライブラリ
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vl;
typedef vector<vector<long long>> vvl;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const long long LINF = 1001002003004005006ll;
const int INF = 1001001001;
template<typename T> void chmin(T &a, T b) { if (a > b) a = b; }
template<typename T> void chmax(T &a, T b) { if (a < b) a = b; }
#define yn { puts("Yes"); } else{ puts("No"); } // 使い方: if (条件) yn;
// 拡張ユークリッドの互除法
ll extGcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1; y = 0;
return a;
}
ll s, t;
ll d = extGcd(b, a % b, s, t);
x = t;
y = s - a / b * x;
return d;
}
// aの逆元(mod p)
ll modinv(ll a, ll p) {
ll x, y;
extGcd(a, p, x, y);
while (x < 0) x += p;
x %= p;
return x;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
const ll MOD = 998244353;
int main() {
ll H, W, K; cin >> H >> W >> K;
vector<vc> G(H, vc(W, '?'));
rep(i, K) {
int x, y; cin >> x >> y; char c; cin >> c;
x--; y--;
G[x][y] = c;
}
vvl dp(H, vl(W, 0));
dp[0][0] = 1;
rep(i, H) {
rep(j, W) {
switch (G[i][j]) {
case 'D':
if (i + 1 < H) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j] %= MOD;
}
break;
case 'R':
if (j + 1 < W) {
dp[i][j + 1] += dp[i][j];
dp[i][j + 1] %= MOD;
}
break;
case 'X':
if (i + 1 < H) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j] %= MOD;
}
if (j + 1 < W) {
dp[i][j + 1] += dp[i][j];
dp[i][j + 1] %= MOD;
}
break;
default:
if (i + 1 < H) {
dp[i + 1][j] += 2 * dp[i][j] * modinv(3, MOD);
dp[i + 1][j] %= MOD;
}
if (j + 1 < W) {
dp[i][j + 1] += 2 * dp[i][j] * modinv(3, MOD);
dp[i][j + 1] %= MOD;
}
}
}
}
ll res = modpow(3, H * W - K, MOD) * dp[H - 1][W - 1] % MOD;
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define ceil(x) static_cast<ll>(ceil(x))
#define floor(x) static_cast<ll>(floor(x))
#define pow(x, y) static_cast<ll>(pow(x, y))
#define gcd(x, y) static_cast<ll>(__gcd(x, y))
#define lcm(x, y) static_cast<ll>(a * (b / gcd(x, y)))
#define F first
#define S second
#define eb emplace_back
#define mp make_pair
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define FI(i, a, b) for (ll i{a}; i <= b; i++)
#define FD(i, a, b) for (ll i{a}; i >= b; i--)
typedef long long ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<pair<ll, ll>> vpii;
typedef pair<ll, ll> pi;
const ll mod{static_cast<ll>(1e9) + 7};
const ld Pi{3.14159265358979323846};
auto int_from(istream &in) -> int
{
int x;
in >> x;
return x;
}
auto lng_from(istream &in) -> ll
{
ll x;
in >> x;
return x;
}
auto str_from(istream &in) -> string
{
string x;
in >> x;
return x;
}
auto chr_from(istream &in) -> char
{
char x;
in >> x;
return x;
}
int main()
{
IOS;
ll a{lng_from(cin)}, b{lng_from(cin)}, c{lng_from(cin)};
if (c % 2)
{
if (a > b)
{
cout << ">\n";
}
else if (a < b)
{
cout << "<\n";
}
else
{
cout << "=\n";
}
}
else
{
a = abs(a);
b = abs(b);
if (a > b)
{
cout << ">\n";
}
else if (a < b)
{
cout << "<\n";
}
else
{
cout << "=\n";
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
double a, b;
cin >> a >> b;
cout << a * (b / 100) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define __ <<" "<<
#define ___ <<" "
#define bash push_back
#define ALL(x) x.begin(),x.end()
// #define int long long
struct IoSetup {
IoSetup() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(3);
cerr << fixed << setprecision(10);
}
}IoSetup;
using Int = __int128_t;
using ll = long long;
using pii = pair<int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr long long LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr int SMOD = 1000000007;
constexpr int NMOD = 998244353;
constexpr int dx[]={1,0,-1,0,1,1,-1,-1};
constexpr int dy[]={0,-1,0,1,-1,1,-1,1};
inline bool inside(int x,int y,int w,int h){return (x>=0 && y>=0 && x<w && y<h);}
template<class T>bool chmax(T &a, const T&b){if(a<b)return(a=b,1);return 0;}
template<class T>bool chmin(T &a, const T&b){if(b<a)return(a=b,1);return 0;}
signed main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << a * d - b * c << endl;
return 0;
} | ///Code by: Luis Alejandro
///Handle: Sekai
///Country: Cuba
#include <bits/stdc++.h>
#define endl '\n'
///Pragmas:
/*
#pragma GCC optimize("Ofast","unroll-loops","omit-frame-pointer","inline")
#pragma GCC option("arch=native","tune=native","no-zero-upper")
#pragma GCC target("avx2")
*/
using namespace std;
///Red-Black-Tree:
///*name.find_by_order(k-th position)
///name.order_of_key(key)
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<int,int,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_statistics;
*/
typedef unsigned long long ull;
typedef long long lld;
typedef long double ld;
typedef pair<int,int> pii;
const int MAXN=1e5+5;
const int MOD=1e9+7;
const int INF=1e9;
const ld PI=acos(-1);
const ld EPS=1e-9;
#define logx(a,b) (log(a)/log(b))
#define lcm(a,b) a/__gcd(a,b)*b
#define lg2(x) __lg(x)
int mod_pow(int a, int b){
if(!b)return 1;
if(b&1)return mod_pow(a,b-1)*a%MOD;
int power=mod_pow(a,b>>1);
return power*power%MOD;
}
int modular_inverse(int a){
return mod_pow(a,MOD-2);
}
vector<int> movy={0,0,1,-1};
vector<int> movx={1,-1,0,0};
void solve(){
int mat[2][2];
for(int i=0;i<2;i++)for(int j=0;j<2;j++)cin>>mat[i][j];
cout<<mat[0][0]*mat[1][1]-mat[0][1]*mat[1][0]<<endl;
}
int main()
{
#ifndef ONLINE_JUDGE
//freopen("IN.txt","r",stdin);
//freopen("OUT.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
} |
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <string>
#include <iomanip>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <complex>
#include <ctime>
#include <bitset>
// #include <atcoder/all>
#include <fstream>
#include <random>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>
//namespace mp = boost::multiprecision;
using namespace std;
// using namespace atcoder;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef int itn;
const ll LINF = 1e16;
const int INF = 1e9;
//マクロ定義
#define vvint(vec,n,m,l) vector<vector<int>> vec(n, vector<int>(m,l)); // lで初期化
#define vvll(vec,n,m,l) vector<vector<ll>> vec(n,vector<ll>(m,l));
#define vint vector<int>
#define pint pair<int,int>
#define rep(i,a) for(ll i=0;i<(a);i++)
#define all(x) (x).begin(),(x).end()
#define debug system("pause") //デバッグ用
#define ret return 0
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
#define ketasitei setprecision(15) //15桁表示
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
const long double PI = 3.1415926535897932;
using Graph = vector<vector<ll>>;
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << ketasitei;
ll n;
cin >> n;
vector<ll> a(n), b(n), c(n), d(n), e(n);
ll ma, mb, mc, md, me;
ma = 0; mb = 0; mc = 0; md = 0; me = 0;
ll an, bn, cn, dn, en;
rep(i, n)
{
cin >> a[i] >> b[i] >> c[i] >> d[i] >> e[i];
if (ma < a[i])
{
ma = a[i];
an = i;
}
if (mb < b[i])
{
mb = b[i];
bn = i;
}
if (mc < c[i])
{
mc = c[i];
cn = i;
}
if (md < d[i])
{
md = d[i];
dn = i;
}
if (me < e[i])
{
me = e[i];
en = i;
}
}
ll aa, bb, cc, dd, ee;
ll ans = 0;
for (int i = 0; i < n-1; i++)
{
for (int j = i + 1; j < n; j++)
{
aa = max(a[i], a[j]);
bb = max(b[i], b[j]);
cc = max(c[i], c[j]);
dd = max(d[i], d[j]);
ee = max(e[i], e[j]);
ll check = 0;
if (aa == min({ aa,bb,cc,dd,ee }))
{
check = an;
}
if (bb == min({ aa,bb,cc,dd,ee }))
{
check = bn;
}
if (cc == min({ aa,bb,cc,dd,ee }))
{
check = cn;
}
if (dd == min({ aa,bb,cc,dd,ee }))
{
check = dn;
}
if (ee == min({ aa,bb,cc,dd,ee }))
{
check = en;
}
aa = max(aa, a[check]);
bb = max(bb, b[check]);
cc = max(cc, c[check]);
dd = max(dd, d[check]);
ee = max(ee, e[check]);
ans = max(ans, min({ aa,bb,cc,dd,ee }));
}
}
cout << ans << endl;
return 0;
} | #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>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__);fflush(stderr);
#else
#define eprintf(...) 42
#endif
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template<typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
return (ull)rng() % B;
}
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
const ll MOD = 998244353;
ll add(ll x, ll y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
ll mult(ll x, ll y) {
return (x * y) % MOD;
}
ll bin_pow(ll x, ll p) {
if (p == 0) return 1;
if (p & 1) return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
ll rev(ll x) {
return bin_pow(x, MOD - 2);
}
const int N = 101;
const int C = 10101;
int n;
int S;
int dp[N][C];
int f[N];
int main()
{
startTime = clock();
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
scanf("%d", &n);
dp[0][0] = 1;
S = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
for (int j = i; j >= 0; j--)
for (int y = 0; y <= S; y++)
dp[j + 1][y + x] = add(dp[j + 1][y + x], dp[j][y]);
S += x;
}
if (S & 1) {
printf("0\n");
return 0;
}
f[0] = 1;
for (int i = 1; i < N; i++)
f[i] = mult(f[i - 1], i);
int ans = 0;
S /= 2;
for (int k = 0; k <= n; k++)
ans = add(ans, mult(mult(f[k], f[n - k]), dp[k][S]));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define f1 first
#define s2 second
#define fastio ios :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define debug(x...) cerr << "[" << #x << "]: " << x << "\n";
using ll = long long;
using ld = long double;
using ii = pair<int, int>;
using pl = pair<ll, ll>;
ld const PI = 4*atan((ld)1);
int main()
{
fastio;
int n, s, d;
cin >> n >> s >> d;
int x, y;
bool res = false;
for (int i = 0; i < n; ++i)
{
cin >> x >> y;
if (x < s && y > d) res = true;
}
cout << (res ? "Yes\n" : "No\n");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define reps(i, a, n) for (int i = (a); i < (n); ++i)
#define rep(i, n) reps(i, 0, n)
#define deps(i, a, n) for (int i = (a); i >= (n); --i)
#define dep(i, n) deps(i, n, 0)
#define inf 2147483647
#define int long long
signed main(void)
{
int v, t, s, d; cin >> v >> t >> s >> d;
if (v * t > d) cout << "Yes" << endl;
else if (v * s < d) cout << "Yes" << endl;
else cout << "No" << endl;
}
|
#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define DEBUG
#ifdef DEBUG
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ',' << p.second << ')';
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
for(int i = 0; i < (int)v.size(); i++) {
if(i) { os << ','; }
os << v[i];
}
os << '}';
return os;
}
void debugg() { cerr << endl; }
template <class T, class... Args>
void debugg(const T &x, const Args &... args) {
cerr << " " << x;
debugg(args...);
}
#define debug(...) \
cerr << __LINE__ << " [" << #__VA_ARGS__ << "]: ", debugg(__VA_ARGS__)
#define dump(x) cerr << __LINE__ << " " << #x << " = " << (x) << endl
#else
#define debug(...) (void(0))
#define dump(x) (void(0))
#endif
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef pair<int,int> pii;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(int i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 4020000;
int dy[8] = {0,1,0,-1,1,-1,-1,1};
int dx[8] = {-1,0,1,0,1,-1,1,-1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
if(a>b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
if(a<b){
a = b; return true;
}
else return false;
}
template<typename T> inline void print(T &a){
int sz = a.size();
for(auto itr = a.begin(); itr != a.end(); itr++){
cout << *itr;
sz--;
if(sz) cout << " ";
}
cout << "\n";
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){
cout << a << " " << b << "\n";
}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << "\n";
}
void mark() {cout << "#" << "\n";}
ll pcount(ll x) {return __builtin_popcountll(x);}
const int mod = 1e9 + 7;
//const int mod = 998244353;
int main(){
ll b,c; cin >> b >> c;
ll ans = 1;
if(b > 0){
ans += (c-2) / 2;
ans += (c-1) / 2;
ans += min(b,c/2);
ans += min(b-1,(c-1)/2);
ans++;
}else if(b < 0){
b = abs(b);
ans += (c-1) / 2;
ans += c / 2;
ans += min(b,(c-1)/2);
ans += min(b-1,(c-2)/2);
ans++;
}else{
ans += c / 2;
ans += (c-1) / 2;
}
cout << ans << "\n";
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define all(a) a.begin(),a.end()
typedef pair<ll,ll> pi;
//__builtin_popcountll(2) (the number of ones in the binary representation)
//__builtin_clz(2) (number of leading zeroes)
//__builtin_ctz(2) (number of trailing zeroes)
/*#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>*/
// s.find_by_order(k)(returns iterator to kth element), s.order_of_key(k)(number of elements less than number)
ll mod = 1e9+7;
vector<ll> fact(1);
/*vector<ll> spf(10000005), cntPrime(10000005);
void spff(){
int i;
for(i=1;i<10000005;i++) spf[i] = i;
for(i=2;i*i<10000005;i++)
{
if(spf[i] != i) continue;
for(int j = i*i; j < 10000005; j+= i){
if(spf[j]==j) spf[j] = i;
}
}
for(i=1;i<10000005;i++){
if(spf[i] != spf[i/spf[i]]){
cntPrime[i] = cntPrime[i/spf[i]]+1;
}
else cntPrime[i] = cntPrime[i/spf[i]];
}
}
while(spf[a[i]]!=a[i]){
z=spf[a[i]];
while(a[i]%z==0) a[i]/=z;
m[z]++;
}
if(a[i]>1) m[a[i]]++;*/
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll power(ll x, ll y)
{
ll temp;
if( y == 0)
return 1;
temp = power(x, y/2);
if (y%2 == 0)
return temp*temp;
else
return x*temp*temp;
}
ll power(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll modInv(ll n, ll p)
{
return power(n, p - 2, p);
}
ll ncr(ll n, ll r) {return (n>=r?(fact[n]*modInv(fact[r],mod))%mod*modInv(fact[n-r],mod)%mod:0);}
ll add(ll a, ll b) {ll z=a+b; if(z>=mod) z -= mod; return z;}
ll mul(ll a, ll b) { return (a*b)%mod;}
ll sub(ll a, ll b) { return (a-b+mod)%mod;}
// LLONG_MAX
int main()
{
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
ll t=1,i,j;
db z,n;
//cin>>t;
//fact[0]=1;
//for(i=1;i<300003;i++)fact[i]=(fact[i-1]*i)%mod;
while(t--)
{
cin>>z>>n;
ll b=z;
z=z/100;
ll c=ceil(n/z);
//cout<<c<<' ';
cout<<(ll)(c+n-1);
}
}
|
#include<bits/stdc++.h>
using namespace std;
using i64 = long long;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int n;
cin >> n;
vector<int> v(2*n);
for(int i = 0; i < 2*n; ++i){
cin >> v[i];
}
multiset<int> s;
int l = 0;
int r = 2*n -1;
i64 ans = 0;
while(l<r){
s.insert(v[l]);
s.insert(v[r]);
auto it = prev(s.end());
ans += *it;
s.erase(it);
l += 1;
r -= 1;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<bool> vbl;
typedef vector<vector<bool>> vvbl;
void INX(){}
template<typename Head, typename... Tail>
void INX(Head&& head, Tail&&... tail)
{
cin >> head;
INX(forward<Tail>(tail)...);
}
void OUTX(){}
template<typename Head, typename... Tail>
void OUTX(Head&& head, Tail&&... tail)
{
cout << head << endl;
OUTX(forward<Tail>(tail)...);
}
void OUTX2(){cout << endl;}
template<typename Head, typename... Tail>
void OUTX2(Head&& head, Tail&&... tail)
{
cout << head << ' ';
OUTX2(forward<Tail>(tail)...);
}
#define ADD emplace_back
#define MP make_pair
#define __LONG_LONG_MIN__ (-__LONG_LONG_MAX__ - 1)
#define MOD 998244353
//setprecision(10)
class UnionFind
{
private:
vll parent;
public:
UnionFind(ll N) : parent(N)
{
for (ll i = 0; i < N; i++) parent[i] = i;
}
ll GetParent(ll x)
{
return (parent[x] == x ? x : (parent[x] = GetParent(parent[x])));
}
void Unite(ll x, ll y)
{
ll rx = GetParent(x);
ll ry = GetParent(y);
if(rx != ry) parent[rx] = ry;
}
bool IsUnited(ll x, ll y)
{
return GetParent(x) == GetParent(y);
}
};
int main()
{
ll N;
INX(N);
vll f(N);
UnionFind uf(N);
for (ll i = 0; i < N; i++)
{
INX(f[i]);
f[i]--;
uf.Unite(i, f[i]);
}
set<ll> s;
for (ll i = 0; i < N; i++)
{
s.emplace(uf.GetParent(i));
}
ll result = 1;
for (ll i = 0; i < s.size(); i++)
{
result <<= 1;
result %= MOD;
}
result = (result == 0 ? MOD : result) - 1;
OUTX(result);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int a[310000];
int main()
{
int n;
cin>>n;
long long s=0;
bool xiangtong=1;
for(int i=1;i<=n;i++)
{
cin>>a[i];
s+=a[i];
if(a[i]!=a[i-1])
xiangtong=0;
}
if(xiangtong==1)
{
cout<<0;
return 0;
}
long long sum=0;
for(int i=1;i<=n;i++)
sum+=(a[i]*(s-a[i]));
long long dev=0;
for(int i=1;i<=n;i++)
dev+=(a[i]*a[i]);
dev*=(n-1);
long long a=dev-sum;
cout<<a;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define int long long
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
int sq=0 , sum=0;
int n = t;
while (t--){
int temp ;
cin >> temp;
sq += (temp*temp);
sum += temp;
}
int ans = (n*sq) - (sum*sum);
cout << ans << endl;
} |
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define deb(x) cout << #x << " " << x << endl;
#define mod 1000000007
#define fast std::ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
#define endl "\n"
#define all(x) (x).begin(), (x).end()
#define rall(v) v.rbegin(), v.rend()
const ll INF = 1e18;
//const ll NEGINF = -1 * INF;
const ll N = 1e6 + 1;
ll gcd(ll a, ll b)
{
if (b == 0)
{
return a;
}
return gcd(b, a % b);
}
ll my_pow(ll a, ll n, ll m = INF)
{
ll res = 1;
while (n)
{
if (n % 2)
{
res = (res * a) % m;
n--;
}
a = (a * a) % m;
n /= 2;
}
return res;
}
void solve()
{
ll N;
cin >> N;
vector<pair<ll, ll>> edge(N - 1);
vector<vector<ll>> g(N);
for (ll i = 0; i < N - 1; i++)
{
ll a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
edge[i] = {a, b};
}
vector<ll> depth(N, -1);
depth[0] = 0;
vector<ll> q = {0};
while (q.size())
{
ll at = q.back();
q.pop_back();
for (ll i : g[at])
if (depth[i] == -1)
{
depth[i] = depth[at] + 1;
q.push_back(i);
}
}
vector<ll> s(N);
ll Q;
cin >> Q;
while (Q--)
{
ll t, e, x;
cin >> t >> e >> x;
auto [a, b] = edge[e - 1];
if (depth[a] > depth[b])
{
swap(a, b);
t ^= 3;
}
if (t == 1)
{
s[0] += x;
s[b] -= x;
}
else
s[b] += x;
}
q = {0};
while (q.size())
{
ll at = q.back();
q.pop_back();
for (ll i : g[at])
if (depth[at] < depth[i])
{
s[i] += s[at];
q.push_back(i);
}
}
for (ll i : s)
cout << i << endl;
}
int main()
{
fast;
#ifndef ONLINE_JUDGE
freopen("/home/kalit/Desktop/Data Structures-Algo-Competitive/src/codeforces/input.txt", "r", stdin);
freopen("/home/kalit/Desktop/Data Structures-Algo-Competitive/src/codeforces/output.txt", "w", stdout);
#endif
int T = 1;
while (T--)
{
solve();
}
//cout<< "Done in " << clock() / CLOCKS_PER_SEC <<"sec"<< endl;
return 0;
} | #include<algorithm>
#include<bitset>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for(ll i=0;i<(ll)(n);i++)
#define RREP(i, n) for(ll i=(ll)(n-1);i>=0;i--)
#define FOR(i, a, b) for(ll i=(ll)(a); i<=(ll)(b); i++)
#define RFOR(i, a, b) for(ll i=(ll)(a);i>=(ll)(b); i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define INF 1000000000000
#define MOD 1000000007 // 10^9+7
#define PB push_back
#define MP make_pair
#define F first
#define S second
typedef struct Node{
int depth;
vector<int> adj;
ll val;
bool imos;
}Node;
void det_depth(vector<Node> &tree, int id, int depth){
if(tree[id].depth != -1)return;
tree[id].depth = depth;
for(auto v : tree[id].adj){
det_depth(tree, v, depth+1);
}
}
void imos(vector<Node> &tree, int id, ll sum){
if(tree[id].imos)return;
tree[id].imos = true;
tree[id].val += sum;
for(auto v : tree[id].adj){
imos(tree, v, tree[id].val);
}
}
signed main()
{
int N;
cin >> N;
vector<pair<int, int>> edge(N);
vector<Node> tree(N);
REP(i, N-1){
int a, b;
cin >> a >> b;
edge[i] = (MP(a-1, b-1));
tree[i].val = 0;
tree[i].depth = -1;
tree[i].imos = false;
tree[a-1].adj.PB(b-1);
tree[b-1].adj.PB(a-1);
}
tree[N-1].val = 0;
tree[N-1].depth = -1;
tree[N-1].imos = false;
det_depth(tree, 0, 0);
int Q;
cin >> Q;
REP(i, Q){
int t, e, x;
cin >> t >> e >> x;
int a = edge[e-1].F, b = edge[e-1].S;
if(tree[b].depth<tree[a].depth){
int tmp = a;
a = b;
b = tmp;
if(t == 1){
t = 2;
}else{
t = 1;
}
}
if(t == 1){
tree[0].val += x;
tree[b].val -= x;
}else{
tree[b].val += x;
}
}
imos(tree, 0, 0);
for(auto v : tree){
cout << v.val << endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int N;
unsigned long long X;
unsigned long long A[50];
unsigned long long Amul[49];
long long base[50];
void A_to_Amul() {
Amul[0] = A[0];
for (int i = 0; i < N-1; i++) {
Amul[i] = A[i+1] / A[i];
}
}
void X_to_base(unsigned long long X) {
for (int i = 0; i < N - 1; i++) {
base[i] = X % Amul[i];
X = (X - base[i]) / Amul[i];
}
base[N-1] = X;
}
void print_Amul() {
for (int i = 0; i < N-1; i++) {
cout << Amul[i] << " ";
}
cout << endl;
}
void print_base() {
for (int i = 0; i < N; i++) {
cout << base[i] << " ";
}
cout << endl;
}
unsigned long long ans[50];
int main() {
cin >> N >> X;
for (int i = 0; i < N; i++) cin >> A[i];
A_to_Amul();
// print_Amul();
X_to_base(X);
// print_base();
vector<int> vld_fsts, vld_lsts;
for (int i = 0; i < N-1; i++) {
if (base[i] > 0) vld_lsts.push_back(i);
}
for (int i = 1; i < N-1; i++) {
if (base[i] < Amul[i] - 1) vld_fsts.push_back(i);
}
vld_fsts.push_back(N-1);
// cout << "fst = ";
// for (int i = 0; i < vld_fsts.size(); i++) {
// cout << vld_fsts[i] << " ";
// }
// cout << endl;
//
// cout << "lst = ";
// for (int i = 0; i < vld_lsts.size(); i++) {
// cout << vld_lsts[i] << " ";
// }
// cout << endl;
ans[0] = 0;
for (int f = 1; f < N; f++) {
ans[f] = ans[f-1];
auto it_fst = find(vld_fsts.begin(), vld_fsts.end(), f);
if (it_fst == vld_fsts.end()) {
continue;
}
for (int l = f-1; l >= 0; l--) {
auto it_lst = find(vld_lsts.begin(), vld_lsts.end(), l);
if (it_lst != vld_lsts.end()) {
ans[f] += 1 + (l >= 1 ? ans[l-1] : 0);
}
}
}
// for (int i = 0; i < N; i++) {
// cout << ans[i] << " ";
// }
// cout << endl;
cout << ans[N-1] + 1;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
#define DEBUG
#ifdef DEBUG
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ',' << p.second << ')';
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
for(int i = 0; i < (int)v.size(); i++) {
if(i) { os << ','; }
os << v[i];
}
os << '}';
return os;
}
void debugg() { cerr << endl; }
template <class T, class... Args>
void debugg(const T &x, const Args &... args) {
cerr << " " << x;
debugg(args...);
}
#define debug(...) \
cerr << __LINE__ << " [" << #__VA_ARGS__ << "]: ", debugg(__VA_ARGS__)
#define dump(x) cerr << __LINE__ << " " << #x << " = " << (x) << endl
#else
#define debug(...) (void(0))
#define dump(x) (void(0))
#endif
struct Setup {
Setup() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
} __Setup;
using ll = long long;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define repl(i, a, b) for(int i = a; i < int(b); i++)
#define rep(i, n) repl(i, 0, n)
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
constexpr int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
int main() {
int N;
ll X;
cin >> N >> X;
vector<ll> a(N);
rep(i, N) cin >> a[i];
vector<map<ll, ll>> dp(60);
dp[0][X] = 1;
rep(i, N) {
for(const auto &[j, val] : dp[i]) {
if(i < N - 1) {
ll r = j % a[i + 1];
dp[i + 1][j - r] += val;
if(r > 0) dp[i + 1][j + a[i + 1] - r] += val;
} else {
dp[i + 1][0] += val;
}
}
}
cout << dp[N][0] << "\n";
} |
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <bits/stdc++.h>
using namespace __gnu_pbds;
using namespace std;
using ll = long long;
using ld = long double;
typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
#define mp make_pair
const int MOD = 998244353;
int mul(int a, int b) {
return (1LL * a * b) % MOD;
}
int add(int a, int b) {
int s = (a+b);
if (s>=MOD) s-=MOD;
return s;
}
int sub(int a, int b) {
int s = (a+MOD-b);
if (s>=MOD) s-=MOD;
return s;
}
int po(int a, ll deg)
{
if (deg==0) return 1;
if (deg%2==1) return mul(a, po(a, deg-1));
int t = po(a, deg/2);
return mul(t, t);
}
int inv(int n)
{
return po(n, MOD-2);
}
mt19937 rnd(time(0));
/*
const int LIM = 1e6 + 5;
vector<int> facs(LIM), invfacs(LIM);
void init()
{
facs[0] = 1;
for (int i = 1; i<LIM; i++) facs[i] = mul(facs[i-1], i);
invfacs[LIM-1] = inv(facs[LIM-1]);
for (int i = LIM-2; i>=0; i--) invfacs[i] = mul(invfacs[i+1], i+1);
}
int C(int n, int k)
{
if (n<k) return 0;
if (n<0 || k<0) return 0;
return mul(facs[n], mul(invfacs[k], invfacs[n-k]));
}*/
/*struct DSU
{
vector<int> sz;
vector<int> parent;
void make_set(int v) {
parent[v] = v;
sz[v] = 1;
}
int find_set(int v) {
if (v == parent[v])
return v;
else
{
auto par = find_set(parent[v]);
parent[v] = par;
return par;
}
}
void union_sets(int a, int b) {
find_set(a);
find_set(b);
a = find_set(a);
b = find_set(b);
if (a != b) {
if (sz[a] < sz[b])
swap(a, b);
parent[b] = a;
sz[a] += sz[b];
};
}
DSU (int n)
{
parent.resize(n);
sz.resize(n);
for (int i = 0; i<n; i++) make_set(i);
}
};*/
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int n, m; cin>>n>>m;
vector<vector<int>> degs(m+1, vector<int>(n+1));
for (int i = 1; i<=m; i++)
{
degs[i][0] = 1;
for (int j = 1; j<=n; j++) degs[i][j] = mul(degs[i][j-1], i);
}
ll tot = mul(n, degs[m][n]);
for (int len = 1; len<=n-1; len++)
{
int sum = 0;
for (int val = 1; val<=m; val++)
{
if (val==m && len>1) continue;
//probability = 1/m^2 + (m - val)^(len-1)
int cnt = degs[m][n - len - 1];
if (len>=2) cnt = mul(cnt, degs[m - val][len-1]);
sum = add(sum, cnt);
}
tot = sub(tot, mul(sum, n-len));
}
cout<<tot;
}
/*
f(n, m) = f(n, m-1) + //Case when there are several ones
*/ | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1LL<<60;
const double PI = acos(-1.0);
/*const double PI = atan2(0.0,-1.0)*/
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; }
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define rep1(i,aa,n) for(ll i = aa; i <= (ll)(n); i++)
#define ALL(a) (a).begin(),(a).end()
#define ar_init(aa,val) rep(i,aa.size()) aa[i]=val;
#define v2d(aa,val1,val2,ini) vector<vector<ll>> aa(val1,vector<ll>(val2,ini));
#define pqe priority_queue<ll>
#define pqeg priority_queue<ll,vector<ll>,greater<ll>>
#define lcin(...) ll __VA_ARGS__;CINT(__VA_ARGS__)
#define eout(...) COU(__VA_ARGS__);
#define sout(...) SCOU(__VA_ARGS__);
#define scin(...) string __VA_ARGS__;CINT(__VA_ARGS__)
#define lb(aa,val) lower_bound(ALL(aa),val)
#define pb push_back
#define mkp make_pair
#define si size()
void CINT(){}
template <class Head,class... Tail>
void CINT(Head&& head,Tail&&... tail){
cin>>head;
CINT(move(tail)...);
}
void COU(){}
template <class Head,class... Tail>
void COU(Head&& head,Tail&&... tail){
cout<<head<<endl;
COU(move(tail)...);
}
void SCOU(){}
template <class Head,class... Tail>
void SCOU(Head&& head,Tail&&... tail){
cout<<head<<" ";
SCOU(move(tail)...);
}
template <class T = ll>
T IN(){T x;cin>>x;return (x);}
using pii = pair<ll,ll>;
using v2 = vector<vector<ll>>;
using v1 = vector<ll>;
using v2p = vector<vector<pii>>;
using v1p = vector<pii>;
//ll mo=1000000007;
ll mo=998244353;
ll mod_pow(ll N,ll n){
if(n==0) return 1;
ll pp,hh;
pp=n/2;
hh=n%2;
int tt=mod_pow(N,n/2);
if(hh==0)return tt%mo*tt%mo;
else {return tt%mo*tt%mo*N%mo;}
}
ll pp[6000][6000];
int main(){
//cout<<fixed<<setprecision(15);
lcin(n,m);
rep1(i,1,m){
pp[i][0]=1;
rep1(k,1,n){
pp[i][k]=pp[i][k-1]*i;
pp[i][k]%=mo;
}
}
ll res=0;
rep1(i,1,m){
rep1(k,1,n){
if(k+2<=n){res+=pp[m][n-k-2]*(pp[m-i+1][k]-pp[m-i][k])%mo*max((ll)0,n-k+1-2)*(i-1)%mo*(i-1)%mo;
}
if(k!=n){res+=2*pp[m][max((ll)0,n-k-1)]*(pp[m-i+1][k]-pp[m-i][k])%mo*(i-1)%mo;
}
if(k==n){res+=pp[m-i+1][k]-pp[m-i][k];
res%=mo;
}
}
}
eout(res);
} |
#line 1 "main_a.cpp"
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
/* template start */
#line 2 "/home/imperi/cp-library/lib/utility/type_alias.hpp"
#line 4 "/home/imperi/cp-library/lib/utility/type_alias.hpp"
using u64 = std::uint64_t;
using u32 = std::uint32_t;
using u16 = std::uint16_t;
using u8 = std::uint8_t;
using i64 = std::int64_t;
using i32 = std::int32_t;
using i16 = std::int16_t;
using i8 = std::int8_t;
using usize = std::size_t;
using isize = std::ptrdiff_t;
constexpr i64 operator"" _i64(unsigned long long num) { return i64(num); }
constexpr u64 operator"" _u64(unsigned long long num) { return u64(num); }
#line 33 "main_a.cpp"
#define rep(i, a, b) for (i64 i = (a); (i) < (b); (i)++)
#define all(i) i.begin(), i.end()
#ifdef LOCAL
#define debug(...) \
std::cerr << "LINE: " << __LINE__ << " [" << #__VA_ARGS__ << "]:", \
debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head h, Tail... t) {
std::cerr << " " << h;
if (sizeof...(t) > 0) std::cerr << " :";
debug_out(t...);
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, std::pair<T1, T2> pa) {
return os << pa.first << " " << pa.second;
}
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T> vec) {
for (std::size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T1, typename T2>
inline bool chmax(T1& a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2>
inline bool chmin(T1& a, T2 b) {
return a > b && (a = b, true);
}
template <typename Num, typename Func = std::multiplies<Num>>
constexpr Num mypow(Num a, u64 b, Num id = 1, Func mul = Func()) {
if (b == 0) return id;
Num x = id;
while (b > 0) {
if (b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
/* template end */
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
i64 t,n;
std::cin>>t>>n;
n--;
std::set<i64> set;
rep(i,0,100+t)set.emplace(i);
rep(i,0,100){
set.erase((100+t)*i/100);
}
i64 ans = 0;
i64 m = set.size();
ans += (100+t) * (n/m);
n%=m;
auto itr = set.begin();
std::advance(itr,n);
ans+=*itr;
std::cout<<ans<<"\n";
return 0;
}
| //#define MULTICASES
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(i=(a);i<=(b);++i)
#define per(i,a,b) for(i=(a);i>=(b);--i)
#define REP(i,a,b) for(i=(a);i< (b);++i)
#define PER(i,a,b) for(i=(a);i> (b);--i)
#define ERR(...) fprintf(stderr,__VA_ARGS__)
inline void ac();
int main(){
#ifdef MULTICASES
int t;scanf("%d",&t);while(t--)ac();
#else
ac();
#endif
return 0;
}
inline void ac(){
int t,n;
scanf("%d%d",&t,&n);
ll a=((n-1)/t)*100ll;
ll b=((n-1)/t)*(t+100ll);
n-=(n-1)/t*t;
ERR("%lld %lld %d\n",a,b,n);
do{
++a;
do{
if((++b)==a*(t+100ll)/100ll)break;
if(!(--n)){printf("%lld\n",b);return;}
}while(true);
}while(true);
}
/*
0. int overflow, array bounds
1. special cases (n=1? n=0?)
2. do smth instead of nothing and stay organized
3. WRITE STUFF DOWN
4. DON'T GET STUCK ON ONE APPROACH
5. STAY CALM AND DON'T GET EXPLODED
*/ |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, m, n) for (ll i = m; i < n; i++)
#define rrep(i, m, n) for (ll i = m - 1; i >= n; i--)
#define pb(n) push_back(n)
#define UE(N) N.erase(unique(N.begin(), N.end()), N.end());
#define Sort(n) sort(n.begin(), n.end())
#define Rev(n) reverse(n.begin(), n.end())
#define HOUT(S) cout << setprecision(50) << S << endl
#define pint pair<ll, ll>
#define paf(L, R) pair<L, R>
#define mod 998244353
#define MAX 10000010
#define endl "\n"
#define ALL(a) a.begin(), a.end()
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U& u, const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U& u, const V... v) {
for (auto& e : u) fill_v<T>(e, v...);
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string S;
cin >> S;
bool flag = true;
rep(i, 0, S.size()) {
if(i % 2 == 0) {
if(S[i] < 'a') flag = false;
}
else {
if(S[i] >= 'a') flag = false;
}
}
if(flag) cout << "Yes" << endl;
else cout << "No" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int main () {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
int sol = 2e9;
for (int msk = 0; msk < (1<<n); msk++) {
vector<int> cur;
int a = 0;
for (int i = 0; i < n; i++) {
a |= ar[i];
if ((msk>>i) & 1) {
cur.push_back(a);
a = 0;
}
}
cur.push_back(a);
int b = 0;
for (auto x : cur) b ^= x;
sol = min(sol, b);
}
cout << sol << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MOD int(1e9+7)
#define INF int(1e9+7)
#define LINF ll(1e18+7)
#define PI acos(-1)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define P pair<ll,ll>
#define chmax(x,y) (x = max(x,y))
#define chmin(x,y) (x = min(x,y))
int n;
int x[20];
int y[20];
int z[20];
int dp[1<<20][20];
int c[20][20];
int main(){
cin>>n;
rep(i,n) cin>>x[i]>>y[i]>>z[i];
rep(i,n)rep(j,n){
c[i][j]=abs(x[j]-x[i])+abs(y[j]-y[i])+max(z[j]-z[i],0);
}
rep(i,1<<n)rep(j,n) dp[i][j]=INF;
dp[1][0]=0;
for(int S=2; S<(1<<n); S++){
rep(i,n){
if(S>>i&1){
int T=S-(1<<i);
rep(j,n){
if(T>>j&1) chmin(dp[S][i],dp[T][j]+c[j][i]);
}
}
}
}
int ans=INF;
rep(i,n) chmin(ans,dp[(1<<n)-1][i]+c[i][0]);
cout<<ans<<endl;
} | #include<bits/stdc++.h>
#define ll long long int
#define db long double
#define ull unsigned long long int
// #define mp make_pair
#define pii pair<ll,ll>
#define F first
#define S second
#define pb push_back
#define rep(i,a,b) for(ll i=a;i<=b;i++)
#define all(a) a.begin(),a.end()
#define Nmax 1000005
#define INF 1000000000000000000
#define MOD 1000000007
#define MAXN 10000
#define time cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
using namespace std;
ll mod=1e7+7;
ll expo(ll base,ll exponent,ll mod){
ll ans=1;
while(exponent!=0){
if(exponent&1) ans=(1LL*ans*base)%mod;
base=(1LL*base*base)%mod;
exponent>>=1;
}
return ans%mod;
}
ll seg[2000005];
ll lazy[2000005];
map<ll,ll>cod;
void push(ll v)
{
if(lazy[v]==0) return;
seg[2*v]+=lazy[v];
lazy[2*v]+=lazy[v];
seg[2*v+1]+=lazy[v];
lazy[2*v+1]+=lazy[v];
lazy[v]=0;
}
void update(ll v,ll tl,ll tr,ll l,ll r,ll val)
{
if(l>tr || r<tl) return;
if(l<=tl && tr<=r)
{
seg[v]+=val;
lazy[v]+=val;
return;
}
push(v);
ll tm=(tl+tr)/2;
update(2*v,tl,tm,l,r,val);
update(2*v+1,tm+1,tr,l,r,val);
seg[v]=min(seg[2*v],seg[2*v+1]);
}
ll query(ll v,ll tl,ll tr,ll l,ll r)
{
if(tl>r || l>tr) return INF;
// push(v);
if(l<=tl && tr<=r)
{
return seg[v];
}
push(v);
ll tm=(tl+tr)/2;
return min(query(2*v,tl,tm,l,r),query(2*v+1,tm+1,tr,l,r));
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tests=1;
// cin>>tests;
while(tests--)
{
ll i,j,n;
cin>>n;
vector<ll>a(n);
rep(i,0,n-1) cin>>a[i];
map<ll,ll>mpp;
rep(i,0,n-1) mpp[a[i]]++;
while(mpp.size()>1)
{
ll mn,mx;
ll secmx;
auto itr=mpp.begin();
mn=itr->first;
itr=mpp.end();
itr--;
mx=itr->first;
// mpp[mx]--;
// ll cnt=mpp[mx];
mpp.erase(mx);
// mpp[mx-mn]++;
itr--;
secmx=itr->first;
ll tmp=(mx-secmx+mn-1)/mn;
mx=mx-tmp*mn;
mpp[mx]++;
}
cout<<mpp.begin()->first;
}
time
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using pld = pair<ld,ld>;
using vi = vector<int>;
using vll = vector<ll>;
using vld = vector<ld>;
#define _GLIBCXX_DEBUG
#define rep(j, m) for (int j = 0; j < (int)(m); j++)
#define rep2(i, l, n) for (int i = l; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
const ld PI = 3.1415926535897932;
const ll MOD = 1000000007;
int main() {
ll N;
cin >> N;
vll W(N);
rep(i,N) {cin >> W[i];}
vll V(N);
ll sum = 0;
rep(i,N) {
V[i] = W[i] - i - 1;
sum += abs(V[i]);
}
if (sum == (N - 1)*2) {
ll flag = 0;
vll X = V;
vll Y(N - 1,0);
rep(i,N - 1) {
ll a = i;
while(a >= 0 && X[a] > 0 && X[a + 1] < 0) {
swap(X[a],X[a + 1]);
X[a]++;
X[a + 1]--;
Y[a]++;
a--;
}
}
rep(i,N - 1) {if (X[i] != 0 || Y[i] != 1) {flag++;}}
if (flag != 0) {cout << -1 << endl;}
else {
rep(i,N - 1) {
ll a = i;
while(a >= 0 && V[a] > 0 && V[a + 1] < 0) {
swap(V[a],V[a + 1]);
V[a]++;
V[a + 1]--;
cout << a + 1 << endl;
a--;
}
}
}
}
else {cout << -1 << endl;}
}
| #include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <cmath>
#include <string>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#include <stack>
#define REP(i,N) for(int (i)=0;(i)<(N);(i)++)
#define REP2(i,a,N) for(int (i)=(a);(i)<(N);(i)++)
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#include <iomanip>
using namespace std;
using ll = long long;
ll gcd(ll x, ll y) {
if (y == 0)return x;
return gcd(y, x % y);
}
ll lcm(ll x, ll y) {
return ll(x / gcd(x, y)) * y;
}
vector< int > divisor(int n) {
vector< int > ret;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
return ret;
}
template<class T>
auto comp_idx(T& ptr) {
return [ptr](int l_idx, int r_idx) {
return ptr[l_idx] < ptr[r_idx];
};
}
//std::sort(IndA.begin(), IndA.end(), comp_idx(A));
int main() {
string N;
cin >> N;
int index = N.size()-1;
for (int i = N.size() - 1; i >= 0; i--) {
if (N[i] == '0') {
index--;
}
else break;
}
if (index == 0) {
cout << "Yes";
return 0;
}
for (int i = 0; i < N.size() / 2; i++) {
if (N[i] != N[index - i]) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define FOR(i,a,b) for(int i = a;i<=b;i++)
using namespace std;
const double e = 1e-9;
int n;
typedef pair<int,int> ii ;
ii A[105] ;
vector<int> G[200] ;
int dd[200] ;
double dist(ii a,ii b){
return sqrt( (a.fi-b.fi)*(a.fi-b.fi) + (a.se-b.se)*(a.second-b.second) ) ;
}
void dfs(int u){
dd[u] = 1;
for(int v:G[u]) if(!dd[v]) dfs(v) ;
}
bool check(double R)
{
FOR(i,0,n+1) G[i].clear() ,dd[i] = 0 ;
// 0 and n+1
FOR(i,1,n) {
if(100-A[i].se < R*2) {
G[0].push_back(i) ;
G[i].push_back(0) ;
}
if(A[i].se + 100 < R*2) {
G[n+1].push_back(i) ;
G[i].push_back(n+1) ;
}
}
FOR(i,1,n)
FOR(j,i+1,n) {
if(dist(A[i],A[j]) < 2.0*R) {
G[i].push_back(j);
G[j].push_back(i);
}
}
dfs(0) ;
if(dd[n+1]==1) return false;
return true ;
}
int main()
{
//freopen("input.txt", "r", stdin);
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i].fi >> A[i].se ;
double L =0 , R = 100,res = 0;
while(L<R-e)
{
double mid = (L+R)/2.0 ;
if(check(mid)) res = mid , L = mid ;
else R = mid ;
}
cout << res ;
}
| #include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
const int kMaxN = 101;
struct P {
double d;
int x, y;
bool b;
} p[kMaxN];
int n, s;
double ans = 1e9;
double D(int i, int j) {
return sqrt(pow(p[i].x - p[j].x, 2) + pow(p[i].y - p[j].y, 2));
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i].x >> p[i].y;
p[i].d = p[i].y + 100;
}
for (int i = 1; i <= n; i++) {
s = 0;
for (int j = 1; j <= n; j++) {
if (!p[j].b) {
if (!s || p[s].d > p[j].d) {
s = j;
}
}
}
p[s].b = 1;
for (int j = 1; j <= n; j++) {
if (!p[j].b) {
p[j].d = min(p[j].d, max(p[s].d, D(s, j)));
}
}
}
for (int i = 1; i <= n; i++) {
ans = min(ans, max(p[i].d, 100.0 - p[i].y));
}
cout << setprecision(8) << fixed << ans / 2;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<bool> vb;
typedef map<int, int> mii;
typedef pair<int, int> ii;
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f
#define each(x, s) for(auto& x : s)
#define loop(x) for(int i = 0;i < x;i++)
#define vloop(v, x) for(int v = 0;v < x;v++)
#define avg(l, r) l + (r - l) / 2
#define iter(a) a.begin(), a.end()
#define riter(a) a.rbegin(), a.rend()
#define endl "\n"
const ll mod = 1000000007;
const double EPS = 1e-7;
const double PI = acos(-1);
struct dsu {
vector<mii> y;
vi id, sz;
dsu(int n) : y(n), id(n), sz(n, 1) {
loop(n) {
int c;
cin >> c;
y[i][c] = 1;
id[i] = i;
}
}
int find(int x) {
return x == id[x] ? x : id[x] = find(id[x]);
}
bool join(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return false;
if (sz[a] > sz[b]) swap(a, b);
id[a] = id[b];
sz[b] += sz[a];
for (auto& [k, v] : y[a]) {
y[b][k] += v;
}
y[a].clear();
return true;
}
};
int main() {
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
int n, q;
cin >> n >> q;
dsu uf(n);
int op, a, b;
loop(q) {
cin >> op >> a >> b;
if (op == 1) uf.join(a - 1, b - 1);
else cout << uf.y[uf.find(a - 1)][b] << endl;
}
return 0;
}
| #pragma GCC optimize("Ofast")
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
using namespace std;
#define int long long
//UF
struct UnionFind {
vector<int> par, siz;
// 初期化
UnionFind(int n) : par(n, -1) , siz(n, 1) { }
int root(int x) {
if (par[x] == -1) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
par[y] = x;
siz[x] += siz[y];
return true;
}
int size(int x) {
return siz[root(x)];
}
};
signed main(){
int N,Q;cin>>N>>Q;
vector<map<int,int>>mp(N);
for(int i=0;i<N;i++){
int a;cin>>a;
mp[i][a-1]=1;
}
UnionFind uf(N);
while(Q--){
int a,b,c;cin>>a>>b>>c;
b--;c--;
if(a==1){
int d=uf.root(b),e=uf.root(c);
if(d!=e){
uf.unite(d,e);
int f=uf.root(d);
if(d!=f){
swap(d,e);
}
for(auto j:mp[e]){
mp[d][j.first]+=j.second;
}
}
}
else{
cout<<mp[uf.root(b)][c]<<endl;
}
}
} |
#include <bits/stdc++.h>
#include <string>
#include <cmath>
using namespace std;
#define ll long long int
#define pb push_back
#define CR7 ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define pii pair<ll, ll>
#define mod 1000000007
#define vi vector<ll>
#define vii vector<pii>
#define mi map<ll, ll>
//RRMMMMMMMMMRRRRRRRRRR!!
int main()
{
CR7;
ll t;
cin>>t;
while (t--)
{
ll a,b;
cin>>a>>b;
ll d = 2*a;
if(d>b)
cout<<"0\n";
else
{
if(d==b)
cout<<"1\n";
else
{
if(b%2)
{
b=b-1;
ll p = d/2;
ll r = b/2;
ll dif = r - p + 1;
ll w = (2*dif) -1;
cout<<((w*(w+1))/2) + w+1<<endl;
}
else
{
ll p = d/2;
ll r = b/2;
ll dif = r - p + 1;
ll w = (2*dif) -1;
cout<<((w*(w+1))/2)<<endl;
}
}
}
}
return 0;
} | #include <cstdio>
#include <cmath>
#include <iostream>
#include <set>
#include <algorithm>
#include <vector>
#include <map>
#include <cassert>
#include <string>
#include <cstring>
#include <queue>
using namespace std;
#define rep(i,a,b) for(int i = a; i < b; i++)
#define S(x) scanf("%d",&x)
#define S2(x,y) scanf("%d%d",&x,&y)
#define P(x) printf("%d\n",x)
#define all(v) v.begin(),v.end()
#define FF first
#define SS second
#define pb push_back
#define mp make_pair
typedef long long int LL;
typedef pair<int, int > pii;
typedef vector<int > vi;
const int N = 1001;
int A[N], B[N];
int dp[N][N];
int n,m;
int solve(int x, int y) {
if(x == n) {
return m - y;
}
if(y == m) {
return n - x;
}
int &res = dp[x][y];
if(res != -1) {
return res;
}
res = n + m - x - y;
res = min(res, 1 - (A[x] == B[y]) + solve(x + 1, y + 1));
res = min(res, 1 + solve(x, y + 1));
res = min(res, 1 + solve(x + 1, y));
return res;
}
int main() {
S2(n,m);
rep(i,0,n) S(A[i]);
rep(i,0,m) S(B[i]);
memset(dp, -1, sizeof(dp));
int ans = solve(0, 0);
P(ans);
}
|
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double db;
#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>;
#define pll pair<ll,ll>
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define ub(v,val) upper_bound(v.begin(),v.end(),val)
#define np(str) next_permutation(str.begin(),str.end())
#define lb(v,val) lower_bound(v.begin(),v.end(),val)
#define sortv(vec) sort(vec.begin(),vec.end())
#define rev(p) reverse(p.begin(),p.end());
#define v vector
#define pi 3.14159265358979323846264338327950288419716939937510
#define len length()
#define repc(i,s,e) for(ll i=s;i<e;i++)
#define fi first
#define se second
#define mset(a,val) memset(a,val,sizeof(a));
#define mt make_tuple
#define repr(i,n) for(i=n-1;i>=0;i--)
#define rep(i,n) for(i=0;i<n;i++)
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define at(s,pos) *(s.find_by_order(pos))
#define set_ind(s,val) s.order_of_key(val)
long long int M = 1e9 + 7 ;
long long int inf = 9 * 1e18;
//CLOCK
ll begtime = clock();
#define time() cout << "\n\nTime elapsed: " << (clock() - begtime)*1000/CLOCKS_PER_SEC << " ms\n\n";
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//CLOCK ENDED
ll n, m;
// modular exponentiation
ll binpow(ll val, ll deg)
{
if (deg < 0)
return 0;
if (!deg)
return 1 % M;
if (deg & 1)
return binpow(val, deg - 1) * val % M;
ll res = binpow(val, deg >> 1);
return (res * res) % M;
}
//binomial
ll modinv(ll n) {
return binpow(n, M - 2);
}
v<v<ll>> adj;
int main() {
// your code goes here
IOS;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll i, j, t, k, x, y, z, N;
cin >> n >> m;
adj.resize(n);
rep(i, m) {
cin >> x >> y;
x--; y--;
adj[x].pb(y);
adj[y].pb(x);
}
cin >> k;
ll c[k];
rep(i, k) {cin >> c[i]; c[i]--;}
ll dis[k][n];
rep(i, k) {
rep(j, n) {
dis[i][j] = inf;
}
}
rep(i, k) {
dis[i][c[i]] = 0;
queue<ll> q;
v<ll> used(n, 0);
ll s = c[i];
q.push(s);
used[s] = 1;
while (!q.empty())
{
ll V = q.front();
q.pop();
for (ll u : adj[V])
{
if (!used[u])
{
used[u] = 1;
dis[i][u] = dis[i][V] + 1;
q.push(u);
}
}
}
}
ll cost[1LL << k][k];
// cout << k;
rep(i, 1LL << k) {
rep(j, k) {
cost[i][j] = inf;
}
}
rep(i, k) {
cost[1LL << i][i] = 0;
}
for (i = 1LL; i < (1LL << k); i++) {
v<ll> vec;
rep(j, k) {
if ((1LL << j)&i)vec.pb(j);
}
rep(j, k) {
if (!((1 << j)&i)) {
for (auto u : vec) {
if (dis[u][c[j]] != inf && cost[i][u] != inf)
cost[i | (1LL << j)][j] = min(cost[i | (1LL << j)][j], dis[u][c[j]] - 1LL + cost[i][u]);
}
}
}
}
ll mn = inf;
rep(i, k) {
mn = min(mn, cost[(1LL << k) - 1LL][i]);
}
if (mn == inf)cout << -1LL;
else {
cout << mn + k;
}
return 0;
}
| #include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <cmath>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <sstream>
#include <iomanip>
using namespace std;
using VI = vector <int>;
using VVI = vector <VI>;
using VVVI = vector <VVI>;
using VLL = vector <long long>;
using VVLL = vector <VLL>;
using VVVLL = vector <VVLL>;
using UMI = unordered_map<int, int>;
using UMLL = unordered_map<long long, long long>;
struct Que {
int now;
long long dist;
Que (int pn, long long pd) : now(pn), dist(pd) {}
bool operator<(const Que& q) const {
return dist > q.dist;
}
};
long long lowVal(long long val, long long target) {
if (target == 0) {
return val+1;
}
long long low = 1;
long long up = val;
long long ret = val;
while (low <= up) {
long long mid = (low+up) / 2;
long long d = val / mid;
if (d >= target) {
low = mid+1;
ret = mid;
} else {
up = mid-1;
}
}
return ret;
}
int main() {
int N;
int M;
cin >> N >> M;
VVVLL adja(N);
for (int i = 0; i < M; ++i) {
int a;
int b;
int c;
int d;
cin >> a >> b >> c >> d;
--a;
--b;
adja[a].push_back({b, c, d});
adja[b].push_back({a, c, d});
}
const long long INF = 1000000000LL * 100000000LL;
VLL dp(N, INF);
VI used(N);
priority_queue <Que> pq;
dp[0] = 0;
pq.push(Que(0, 0));
while (!pq.empty()) {
Que tq = pq.top();
int now = tq.now;
pq.pop();
// cout << "DEBUG " << now << " " << dp[now] << endl;
if (used[now]) {
continue;
}
used[now] = 1;
long long nt = dp[now];
for (int i = 0; i < adja[now].size(); ++i) {
int nextv = adja[now][i][0];
long long C = adja[now][i][1];
long long D = adja[now][i][2];
// cost = dt + (C + (D/(nt+1+dt)))
long long low = 0;
long long up = nt ? D/nt : D;
auto costCal = [&nt, &C, &D](long long dt) { return nt+dt+(C+D/(nt+1+dt)); };
long long best = costCal(0);
// 0 = 1 - D/(nt+1+dt)^2
// D = (nt+1+dt)^2
// sqrt(D)-nt-1
long long base = sqrt(D)-nt-1;
for (long long vdt = max(0LL, base-10); vdt <= base+10; ++vdt) {
best = min(best, costCal(vdt));
}
// cerr << now << " " << nextv << " BEST " << best << endl;
if (best < dp[nextv]) {
dp[nextv] = best;
pq.push(Que(nextv, best));
}
}
}
cout << (dp[N-1] == INF ? -1 : dp[N-1]) << endl;
return 0;
} |
//Awwawa! Dis cold yis ratten buy tEMMIE!
#include <bits/stdc++.h>
#define ll long long
#define maxn 200005 /*rem*/
#define mod 998244353
#define db double
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define pi pair<int, int>
#define fi first
#define se second
template <typename T> bool chkmax(T &x,T y){return x<y?x=y,true:false;}
template <typename T> bool chkmin(T &x,T y){return x>y?x=y,true:false;}
using namespace std;
ll ksm(ll a, ll b) {
if (!b) return 1;
ll ns = ksm(a, b >> 1);
ns = ns * ns % mod;
if (b & 1) ns = ns * a % mod;
return ns;
}
int a[maxn], b[maxn];
map<int, int> s[2];
vi tot;
int ask(int l) {
int pl = lower_bound(tot.begin(), tot.end(), l + 1) - tot.begin();
return pl;
}
int ask(int l, int r) {
// cout << l << ' ' << r << ' ' << ask(r) << ' ' << ask(l - 1) << endl;
return ask(r) - ask(l - 1);
}
int main() {
int n, l;
cin >> n >> l;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
a[0] = 0, a[n + 1] = l + 1;
for (int i = 1; i <= n; i++)
scanf("%d", &b[i]);
b[0] = 0, b[n + 1] = l + 1;
vi tr;
for (int i = 0; i <= n + 1; i++)
b[i] -= i, a[i] -= i,
s[0][a[i]]++, s[1][b[i]]++,
tr.pb(a[i]), tr.pb(b[i]);
sort(tr.begin(), tr.end());
tr.erase(unique(tr.begin(), tr.end()), tr.end());
for (auto v : tr) {
if (s[1][v] && !s[0][v]) {
cout << -1 << endl;
return 0;
}
if (s[0][v] && s[1][v])
tot.pb(v);
}
ll ans = 0;
for (int i = 0; i <= n + 1; i++) {
// cout << a[i] << ' ' << b[i] << ' ' << ans << endl;
if (a[i] > b[i])
ans += ask(b[i], a[i] - 1);
else ans += ask(a[i] + 1, b[i]);
}
cout << ans << endl;
return 0;
}
| /** これを翻訳している間、あなたはあなたの人生のいくつかの貴重な瞬間を無駄にしました **/
#include<bits/stdc++.h>
using namespace std;
#ifdef Zoro
#include "headers/debug.h"
#else
#define debug(x...)
#define deb(x...)
#endif
#define rep(i,x,y) for(int i=x;i<y;i++)
#define repr(i,x,y) for(int i=x;i>=y;i--)
#define int long long
#define pb push_back
#define ff first
#define ss second
#define sz(x) ((int)x.size())
#define all(x) begin(x), end(x)
#define memo(x,y) memset((x),(y),sizeof((x)))
#define line cout<<"[At "<<__LINE__<<"]"<<endl;
using pii = pair<int, int>;
using vi = vector<int>;
using vii = vector<pair<int, int>>;
constexpr int mod = 1e9 + 7, N = 2e5 + 5;
constexpr long long inf = 1e18;
constexpr long double eps = 1e-6;
void Onigiri() {
int n,m;
cin>>n>>m;
deque<pii> v(m);
rep(i,0,m){
cin>>v[i].ff>>v[i].ss;
}
sort(all(v));
unordered_set<int> cols;
cols.insert(n);
while(sz(v)){
int cx = v.front().ff;
vi cy;
while(sz(v) && v.front().ff == cx) {
cy.pb(v.front().ss);
v.pop_front();
}
vi addList,removeList;
for(auto &x:cy){
if(cols.find(x-1)!=cols.end()){
addList.push_back(x);
}else if(cols.find(x+1)!= cols.end()){
addList.push_back(x);
}else{
removeList.push_back(x);
}
}
deb(cx,addList,removeList);
for(auto &x:removeList){
if(cols.find(x)!=cols.end()) cols.erase(x);
}
for(auto &x:addList){
if(cols.find(x)==cols.end()) cols.insert(x);
}
}
cout<<sz(cols);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
//cout.precision(10);cout<<fixed;
#ifdef Zoro
freopen("/home/pritish/Competitive/io/in", "r", stdin);
freopen("/home/pritish/Competitive/io/out", "w", stdout);
#endif
int t = 1;
//cin >> t;
while(t--) {
Onigiri();
cout << "\n";
}
cerr << "\n" << (float)clock() / CLOCKS_PER_SEC * 1000 << " ms" << endl;
return 0;
} |
#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>
using namespace std;
#define int long long
#define all(arr) arr.begin(),arr.end()
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define vi vector<int>
#define vstr vector<string>
#define vbool vector<bool>
#define vvi vector<vector<int> >
#define mii map<int,int>
#define pb push_back
#define pii pair<int,int>
#define vpair vector<pii >
#define mkp make_pair
#define scan(a,n) for(int i =0 ; i<n ; i++) cin>>a[i]
#define print(a,n) for(int i = 0 ; i < n ; i++) {cout<<a[i]<<' ';}cout<<'\n'
#define mem(a,v) memset(a,v,sizeof(a))
#define loop(i,a,b) for (int i = a; i < b; i++)
#define loope(i,a,b) for (int i = a; i <= b; i++)
#define FastIO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define PRECISION std::cout.unsetf ( std::ios::fixed );std::cout.precision(9)
#define PI 3.14159265
#define S second
#define F first
#define CHECK cout<<"CHEDEDWB"<<endl
#define br '\n'
int mod = 1e9+7;
/*int inf = 1e18;
int m_inf = INT_MIN;
int MOD = 100001;*/
void solve()
{
string X;
cin>>X;
for(char c:X)
{
if(c=='.')
break;
cout<<c;
}
cout<<endl;
}
int32_t main()
{
FastIO; PRECISION;
int t = 1;
//cin>>t;
while(t--)
solve();
return 0;
} | /*
I love the sound you make when you shut up.
*/
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace __gnu_pbds;
/*-------typedefs------*/
template<class T> using ordered_set = tree<T, null_type , less<T> , rb_tree_tag , tree_order_statistics_node_update> ;
using ll = long long;
using pi = pair<int, int>;
/*-----in and out--------*/
#define pf(a) cout << a << endl
#define forIn(arr, num) for(int i = 0; i < num; i++) cin >> arr[i];
#define vpnt(ans) for(int i = 0; i < int(ans.size()); i++) cout << ans[i] << (i + 1 < int(ans.size()) ? ' ' : '\n');
/*---useful defines------*/
#define sz(x) (int)(x).size()
#define pb push_back
#define mem(a, b) memset(a,(b), sizeof(a))
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
/*----- the binary answer of life-----*/
#define no cout << "NO" << endl
#define yes cout << "YES" << endl
/*---checking and pushing-----*/
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; }
/*---- FAST I/O and file read ---*/
void go() {
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
}
/*-------- test-case stuff--------------*/
#define ssolve solve();
#define msolve int T;cin >> T;while(T--) {solve();}
#define mcsolve int T;cin >> T;for(int tt = 1;tt <= T;tt++) {cout << "Case #" << tt << ": ";solve();}
/*-------- movement in a 2D array ------*/
const int d4i[4]={-1, 0, 1, 0}, d4j[4]={0, 1, 0, -1};
const int d8i[8]={-1, -1, 0, 1, 1, 1, 0, -1}, d8j[8]={0, 1, 1, 1, 0, -1, -1, -1};
/*----------------------------------------------------------------*/
const int MOD = 1e9 + 7;
const int N = 2e5 + 5;
/*-------------- Push your limits here ---------------------------*/
void solve() {
string s;
cin >> s;
string res = "";
for(int i = 0;i < sz(s);i++) {
if(s[i] == '.') break;
res += s[i];
}
pf(res);
}
int main() {
go();
ssolve
return 0;
}
|
#line 2 "/Users/kaage/Desktop/ProgrammingWorkspace/library/other/template.hpp"
#define _CRT_SECURE_NO_WARNINGS
#pragma target("avx2")
#pragma optimize("O3")
#pragma optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define all(V) V.begin(),V.end()
typedef unsigned int uint;
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
typedef std::pair<lint, lint> LP;
constexpr int INF = INT_MAX/2;
constexpr lint LINF = LLONG_MAX/2;
constexpr double eps = DBL_EPSILON;
constexpr double PI=3.141592653589793238462643383279;
template<class T>
class prique :public std::priority_queue<T, std::vector<T>, std::greater<T>> {};
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b; b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) {
return a / gcd(a, b) * b;
}
bool isprime(lint n) {
if (n == 1)return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)return false;
}
return true;
}
template<typename T>
T mypow(T a, lint b) {
T res(1);
while(b){
if(b&1)res*=a;
a*=a;
b>>=1;
}
return res;
}
lint modpow(lint a, lint b, lint m) {
lint res(1);
while(b){
if(b&1){
res*=a;res%=m;
}
a*=a;a%=m;
b>>=1;
}
return res;
}
template<typename T>
void printArray(std::vector<T>& vec) {
rep(i, vec.size()){
std::cout << vec[i];
std::cout<<(i==(int)vec.size()-1?"\n":" ");
}
}
template<typename T>
void printArray(T l, T r) {
T rprev = std::prev(r);
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
LP extGcd(lint a,lint b) {
if(b==0)return {1,0};
LP s=extGcd(b,a%b);
std::swap(s.first,s.second);
s.second-=a/b*s.first;
return s;
}
LP ChineseRem(const lint& b1,const lint& m1,const lint& b2,const lint& m2) {
lint p=extGcd(m1,m2).first;
lint tmp=(b2-b1)*p%m2;
lint r=(b1+m1*tmp+m1*m2)%(m1*m2);
return std::make_pair(r,m1*m2);
}
template<typename F>
inline constexpr decltype(auto) lambda_fix(F&& f){
return [f=std::forward<F>(f)](auto&&... args){
return f(f,std::forward<decltype(args)>(args)...);
};
}
#line 3 "/Users/kaage/Desktop/ProgrammingWorkspace/library/graph/UnionFind.hpp"
class UnionFind {
protected:
std::vector<int> par, size;
public:
UnionFind(){}
UnionFind(int size) {init(size);}
void init(int size){
par.resize(size); this->size.resize(size, 1);
rep(i, size) {
par[i] = i;
}
}
int find(int n) {
if (par[n] == n)return n;
return par[n] = find(par[n]);
}
void unite(int n, int m) {
n = find(n);
m = find(m);
if (n == m)return;
int a=n,b=m;
if(size[a]>size[b])std::swap(a,b);
par[a] = b;
size[b] += size[a];
}
bool same(int n, int m) {
return find(n) == find(m);
}
int getsize(int n) {
return size[find(n)];
}
};
#line 3 "main.cpp"
int N,M,a[200010],b[200010];
lint s[200010][2];
int main(){
std::cin>>N>>M;
REP(i,N)std::cin>>a[i];
REP(i,N)std::cin>>b[i];
UnionFind uf(N+1);
rep(i,M){
int c,d;
std::cin>>c>>d;
uf.unite(c,d);
}
REP(i,N){
s[uf.find(i)][0]+=a[i];
s[uf.find(i)][1]+=b[i];
}
REP(i,N){
if(s[i][0]!=s[i][1]){
puts("No");
return 0;
}
}
puts("Yes");
return 0;
} | #include <bits/stdc++.h> //Header Files
#define ll long long int
#define endl "\n"
using namespace std;
ll dfs(vector<vector<int>> &gr, int v, ll a[], ll b[], vector<bool> &vis, ll past)
{
vis[v] = true;
a[v] += past;
ll val = a[v] - b[v];
a[v] = b[v];
for (int adj : gr[v])
{
if (!vis[adj])
{
ll temp = dfs(gr, adj, a, b, vis, val);
a[v] += temp;
val = a[v] - b[v];
a[v] = b[v];
}
}
return val;
}
void runTest()
{
int n, m;
cin >> n >> m;
ll a[n + 1], b[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++)
cin >> b[i];
vector<vector<int>> gr(n + 1);
for (int i = 1; i <= m; i++)
{
int u, v;
cin >> u >> v;
gr[u].push_back(v);
gr[v].push_back(u);
}
vector<bool> vis(n + 1, false);
for (int i = 1; i <= n; i++)
{
if (vis[i])
continue;
ll valu = dfs(gr, i, a, b, vis, 0);
if (valu != 0)
{
cout << "No" << endl;
return;
}
}
cout << "Yes" << endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
runTest();
return 0;
} |
#include <bits/stdc++.h>
#ifdef LILY
#include "Debug.h"
#else
#define var(...) (0)
#define dbg(...) (0)
#endif
using int32 = int;
using int64 = long long;
using namespace std;
class Solution
{
#define int int64
#define sfor(i, n) for (int i = 1; i <= (n); ++i)
#define tfor(i, n) for (int i = 0; i < (n); ++i)
#define INF 0x3f3f3f3f
#define EPS 1e-5
#define M 1000000007
int n;
int p;
int pow(int base, int ex)
{
int ret = 1;
while (ex)
{
if (ex & 1) ret = ret * base % M;
ex >>= 1;
base = base * base % M;
}
return ret;
}
void reals()
{
}
public:
Solution()
{
cin >> n >> p;
int t = pow(p - 2, n - 1);
cout << t * (p - 1) % M << endl;
}
#undef int
#undef tfor
#undef sfor
};
int32 main()
{
#ifdef LILY
while (1)
#endif
Solution();
return 0;
}
| #include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long
using namespace std;
int main(){
int a,b;
cin >> a >> b;
cout << a/100.0*b << endl;
} |
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
/*
execution in cmd for windows: g++ p1.cpp -op1
p1
execution in terminal for linux: g++ p1.cpp
./a.out
*/
typedef long double dd;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define nl <<"\n"
#define con continue
#define br break
#define vll vector<ll>
#define vpll vector<pair<ll,ll> >
ll mx=INT_MAX;
ll mi=INT_MIN;
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define all(v) v.begin(), v.end()
#define fsort(v) sort(all(v))
#define rsort(v) sort(v.rbegin(),v.rend())
#define rev(v) reverse(all(v))
#define maxc(v) *max_element(all(v))
#define minc(v) *min_element(all(v))
#define sumv(v,x) accumulate(v.begin(),v.end(),x);
const ll mod = 998244353;
const ll inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;
const ll MOD = 1000000007;
#define pi 3.14159265
#define io { ios :: sync_with_stdio(false); cin.tie(0); cout.tie(0); }
#define cer cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
#define cs ll t;cin>>t;while(t--)
#define cs1 ll t;t=1;while(t--)
#define input(v) for(i=0;i<v.size();i++) cin>>v[i];
#define output(v) for(i=0;i<v.size();i++) cout<<v[i]<<" ";
#define dbg(n) cout<<"[ "<<n<<" ]" nl;
int main()
{
#ifndef ONLINE_JUDGE
ifstream cin("in.in");
ofstream cout("out.out");
#endif
io;
//////////////////////////////////
cs1{
ll i, j, s = 0, c, k = 0, q = 0, o=0, m = 0, e = -1, x, y, f=-1, ans = INF, p = 0, r=0, a, b, d=0, len, ct = 0, id, n;
cin>>n;
vll v(n);
vll vv(1000,0);
for(i=0;i<n;i++) {
cin>>v[i];
v[i]+=200;
for(j=0;j<=400;j++){
s=s+vv[j]*(v[i]-j)*(v[i]-j);
}
vv[v[i]]++;
}
cerr<<s nl;
cout<<s nl;
}
//////////////////////////////////
cer;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL ans, sum;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
LL a;
cin >> a;
ans += a * a * (n - 1);
ans -= 2 * a * sum;
sum += a;
}
cout << ans;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int n,m;
int sum[30];
char a[30];
int main()
{
cin>>n>>m;
long long ans=0;
for(int i=1;i<=n;i++)
{
scanf("%s",a+1);
int t=0;
for(int j=1;j<=m;j++)
{
if(a[j]=='1') t++;
}
if(t%2==1) ans+=sum[2],sum[1]++;
else ans+=sum[1],sum[2]++;
}
// puts("");
// for(int i=1;i<=m;i++) cout<<b[i]<<' ';
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define rep2(i,x,n) for(int i=x; i<(n); i++)
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define rng(v) v.begin(),v.end()
#define rngr(v) v.rbegin(),v.rend()
const long long INF = 1LL << 60;
using namespace std;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
using P3 = tuple<int, int, int>;
#define vi vector<int>
#define vvi vector<vi>
#define vll vector<ll>
#define vs vector<string>
using vp = vector<P>;
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; }
using CP = complex<double>;
double dot( const CP &z, const CP &w ){ return (z.real()*w.real() + z.imag()*w.imag()); }
double cross( const CP &z, const CP &w ){ return (z.real()*w.imag() - z.imag()*w.real()); }
int main()
{
int n, m;
cin >> n >> m;
ll a = 0;
ll b = 0;
rep(i, n) {
string s;
cin >> s;
int c = 0;
for(auto j : s) if(j-'0' == 1) c++;
(c%2 == 0 ? a : b)++;
}
cout << a*b << endl;
return 0;
}
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-12;
//int N, M, K, T, H, W, L, R;
long long int N, M, K, T, H, W, L, R;
long long int power(long long int x, long long int n, long long int M) {
long long int ret = 1;
long long int by = x;
while (n) {
if (n & 1) {
ret *= by;
ret %= M;
}
by *= by;
by %= M;
n >>= 1;
}
return ret;
}
long long by[2222222];
long long inv[2222222];
long long ncr(long long n, long long r) {
if (r<0 || r>n)return 0;
return by[n] * inv[n - r] % MOD * inv[r] % MOD;
}
void Solve(int a, int b, int c) {
long long ans = ncr(a + b, a);
ans += MOD - ncr(a + b, a - (c + 1));
ans %= MOD;
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
by[0] = by[1] = inv[0] = inv[1] = 1;
for (int i = 2; i < 2222222; i++) {
by[i] = by[i - 1] * i % MOD;
}
inv[2222221] = power(by[2222221], MOD - 2, MOD);
for (int i = 2222220; i > 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % MOD;
}
cin >> N >> M >> K;
if (N - M > K) {
cout << 0 << endl;
return 0;
}
Solve(N, M, K);
} | // Problem: E - White and Black Balls
// Contest: AtCoder - AtCoder Beginner Contest 205
// URL: https://atcoder.jp/contests/abc205/tasks/abc205_e
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
using namespace std;
#define SPEED ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define int long long
#define endl '\n'
#define vi vector<int>
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define fill(a,b) memset(a, b, sizeof(a))
#define setbits(x) __builtin_popcountll(x) //count number of 1
#define zrobits(x) __builitin_ctzll(x) //count number of zero before 1st 1 ex- (110000)2 ->4
const int inf=0x3f3f3f3f3f3f3f3f, mod = 1e9 + 7;
int dx[]={0,1,1,1,0,-1,-1,-1};
int dy[]={1,1,0,-1,-1,-1,0,1};
// <--------------------Code Begins Here-------------------->
const int N = 2e6 + 1;
int a[N];
int power(int a, int b, int p){
int res = 1;
while(b != 0) {
if(b & 1)
res = (res % p * a % p) % p;
a = (a%p * a%p)%p;
b /= 2;
}
return res%p;
}
int fact[N],inv[N];
void pre(int p) {
fact[0]=1;
inv[0]=1;
for(int i=1;i<N;i++)
fact[i]=(i*fact[i-1])%p;
for(int i=1;i<N;i++)
inv[i]=power(fact[i], p - 2, p);
}
int nCr(int n, int r, int p) {
if(r>n)
return 0;
if(n==r)
return 1;
if(r==0)
return 1;
return (((fact[n]*inv[r]) % p )*inv[n-r])%p;
}
int32_t main() {
SPEED;
int t = 1;
// cin>>t;
pre(mod);
while(t--) {
int n, m, k;
cin>>n>>m>>k;
if(n > (m + k)) {
cout<<0;
return 0;
}
int ans = nCr(n + m, n, mod);
ans -= nCr(n + m, m + k + 1, mod);
ans %= mod;
if(ans < 0)ans += mod;
cout<<ans;
}
return 0;
} |
#include <iostream>
int main() {
int a, b, c;
std::cin >> a >> b >> c;
int result = 0;
if (a == b) {
result = c;
} else if (b == c) {
result = a;
} else if (c == a) {
result = b;
}
std::cout << result << std::endl;
return 0;
}
| #pragma GCC optimize("Ofast", "unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
using pii = pair<int, int>;
template<typename T>
using Prior = std::priority_queue<T>;
template<typename T>
using prior = std::priority_queue<T, vector<T>, greater<T>>;
#define X first
#define Y second
#define eb emplace_back
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
#define fastIO() ios_base::sync_with_stdio(0), cin.tie(0)
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int getRand(int L, int R) {
if (L > R) swap(L, R);
return (int)(rng() % ((uint64_t)R - L + 1) + L);
}
template<typename T1, typename T2>
ostream& operator << (ostream &os, pair<T1, T2> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template<typename T>
ostream& operator << (ostream &os, vector<T> &vec) {
for (int i = 0; i < vec.size(); ++i) {
if (i) os << " ";
os << vec[i];
}
return os;
}
void solve() {
int a, b, c; cin >> a >> b >> c;
cout << (set<int>{a, b, c}.size() == 3 ? (int)0 : (a^b^c)) << "\n";
}
int32_t main() {
fastIO();
int t = 1; // cin >> t;
for (int _ = 1; _ <= t; ++_) {
// cout << "Case #" << _ << ": ";
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
#define int long long int
#define vi vector<int>
#define ff first
#define ss second
#define pb push_back
#define MOD 1000000007
//const int nax = 1e6+5;
#define inf 4e18
#define Graph vector<vi>
#define Graphw vector<vector<pair<int,int>>>
#define sz(x) (int)x.size()
#define pr pair<int,int>
#define display(v) for(int i =0;i<(int)v.size();++i)cout << v[i] << " "
#define all(v) v.begin(),v.end()
#define read(a) for(int i = 0;i<(int)a.size();++i)cin>>a[i]
#define show(x) cout << #x << " is " << x << "\n";
// typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ind_si;
// typedef tree<int,null_type,less_equal<int>,rb_tree_tag,tree_order_statistics_node_update> ind_msi;
#define show_arr(a) cout << #a << "\n"; display(a) ; cout << "\n";
inline int add(int a, int b){ int c = (a%MOD) + (b%MOD); if(c >= MOD) c -= MOD; return c; }
inline int mul(int a, int b){ return ((a%MOD) * 1ll * (b%MOD)) % MOD; }
inline int sub(int a, int b){ int c = (a%MOD) - (b%MOD); if(c < 0) c += MOD; return c; }
const int nax = 200*1000 + 10;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//#define ook order_of_key
//#define fbo find_by_order
// order_of_key(x) -> number of elements less than x.
// * find_by_order(x) -> gives the element at index x (0 - indexing)
void test_case();
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1; //cin>>t;
while(t--){
test_case();
}
return 0;
}
int n;
string s ,x;
int dp[nax][8];
int vis[nax][8];
bool f(int id , int cur){
if(id >= n){
return (cur == 0);
}
if(vis[id][cur]){
return dp[id][cur];
}
vis[id][cur] = 1;
int cur1 = (cur * 3)%7 + (s[id] - '0')%7;
bool f1 = f(id + 1, cur1%7);
int cur2 = cur * (3);
bool f2 = f(id + 1 , cur2%7);
//cout << cur1 << " " << cur2 << '\n';
//cout << id << " " <<f1 << ' ' << f2 << '\n';
if(x[id] == 'T'){
if(f1 || f2){
dp[id][cur] = 1;
}
else{
dp[id][cur] = 0;
}
}
else{
if(f1 && f2){
dp[id][cur] = 1;
}
else{
dp[id][cur] = 0;
}
}
return dp[id][cur];
}
void test_case(){
cin>>n;
cin>>s>>x;
if(f(0 , 0)){
cout << "Takahashi";
}
else{
cout << "Aoki";
}
}
// Химаншу
// check overflow
// special case n == 1
// 🍪🍪🍪
| //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T> >;
const int INF = 0xccccccc;
const ll LINF = 0xcccccccccccccccLL;
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {return a < b && (a = b, true);}
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {return a > b && (a = b, true);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}
//head
vector<bitset<256>> pre, now;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int u = 1<<n, v = u/2;
cout << u-1 << endl;
for(int i = 1; i <= n; i++) {
now.clear();
now.emplace_back(bitset<256>(0));
rep(j, 1<<i-1) now[0].set(j);
rep(j, pre.size()) {
now.emplace_back(bitset<256>(0));
now.back() |= pre[j];
now.back() |= (pre[j]<<(1<<i-1));
}
rep(j, pre.size()) {
now.emplace_back(bitset<256>(0));
now.back() |= pre[j];
now.back() |= ((pre[j]^now[0])<<(1<<i-1));
}
now.swap(pre);
}
for(auto bi:pre) {
rep(i, u) {
if(bi.test(i)) cout << 'A';
else cout << 'B';
}
cout << '\n';
}
} |
#include <bits/stdc++.h>
#include <assert.h>
using namespace std;
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
#define logn long
#define lnog long
#define lgon long
#define itn int
typedef long long ll;
typedef pair<long double, long double> P;
const long long INF = 1e18;
int main(){
long long N; cin >> N;
string S; cin >> S;
if (N == 2) {
if (S[0] == S[1]) cout << -1 << endl;
else cout << 1 << endl;
return 0;
}
if (N == 3) {
if (S[0] != S.back()) cout << 1 << endl;
else cout << -1 << endl;
return 0;
}
if (S[0] != S.back()) {
cout << 1 << endl;
return 0;
}
char ch = S[0];
long long ans = 0;
long long pos = 0;
for (long long i = 1; i < N - 1; i++) {
if (S[i] != ch && S[i+1] != ch) {
cout << 2 << endl;
return 0;
}
}
cout << -1 << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main () {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
//cin >> t;
while (t--) {
int n, inf = 1e9 + 7;
string s;
cin >> n >> s;
vector<int> dp(26, inf);
dp[s[n - 1] - 'a'] = 0;
int ans = inf;
for (int i = n - 2; i >= 0; i--) {
vector<int> dp1 = dp;
for (int j = 0; j < 26; j++) {
if (s[i] - 'a' != j && dp1[j] != inf) {
if (i == 0) ans = min(ans, dp1[j] + 1);
else {
dp[s[i - 1] - 'a'] = min(dp[s[i - 1] - 'a'], dp1[j] + 1);
}
}
}
}
if (ans == inf) ans = -1;
cout << ans << '\n';
}
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 4e2+5;
char s[N],t[N];
inline char get(char a,char b){
if(a == b) return a;
if(a == 'P' && b == 'R') return 'P';
if(a == 'R' && b == 'P') return 'P';
if(a == 'S' && b == 'P') return 'S';
if(a == 'P' && b == 'S') return 'S';
if(a == 'R' && b == 'S') return 'R';
if(a == 'S' && b == 'R') return 'R';
}
inline void change(int n){
for(int i = 0;i < n;++i) t[i] = s[i];
for(int i = n;i < n*2;++i) t[i] = s[i-n];
for(int i = 0;i < n;++i)
s[i] = get(t[i*2],t[i*2+1]);
return ;
}
int main()
{
int n,k;
scanf("%d%d",&n,&k);
scanf("%s",s);
while(k){
change(n);
k--;
}
printf("%c",s[0]);
return 0;
}
| //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
const double PI = 3.14159265358979;
#define ALL(x) x.begin(),x.end()
#define RALL(x) x.rbegin(),x.rend()
ll modpow(ll base, ll pow){
ll ret = 1;
while(pow>0){
if(pow & 1) ret = ret * base % MOD;
base = base*base % MOD;
pow >>= 1;
}
return ret;
}
int main(){
ll n, p; cin >> n >> p;
ll ans = modpow(p-2, n-1);
ans = ans * (p-1) % MOD;
cout << ans << endl;
} |
#include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i = (begin); i < (end); i++)
#define FAST_IO ios_base::sync_with_stdio(0); cin.tie(nullptr)
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define SZ(x) ((int)((x).size()))
#define LE(vec) vec[vec.size()-1]
#define TSTS int t; cin >> t; while(t--)solve()
const int INF = 1e9;
const long long LINF = 1e18;
const long double PI = asin(1)/2;
const int MOD = 1e9+7;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef map<int, int> mii;
typedef long long ll;
typedef long double ld;
void setIO()
{
FAST_IO;
}
void setIO (string s) {
setIO();
freopen((s+".in").c_str(),"r",stdin);
freopen((s+".out").c_str(),"w",stdout);
}
const int N = 50;
int n, m, q;
vector<pii> inf;
int x[N];
int fnd(int l, int r)
{
int tot = 0;
set<int> used;
vector<pii> a;
FOR(i, 0, l-1)
{
a.PB(MP(x[i], i));
}
FOR(i, r, m)
{
a.PB(MP(x[i], i));
}
sort(a.begin(), a.end());
for(auto it : a)
{
int mx = -1, mxin = 0;
FOR(j, 0, SZ(inf))
{
if(!used.count(j))
{
if(inf[j].F<=it.F)
{
if(mx<inf[j].S)
{
mx = inf[j].S;
mxin = j;
}
}
}
}
if(mx!=-1)
{
used.insert(mxin);
tot += mx;
}
}
return tot;
}
int main()
{
setIO();
cin >> n >> m >> q;
FOR(i, 0, n)
{
int a, b;
cin >> a >> b;
inf.PB(MP(a, b));
}
FOR(i, 0, m)
{
cin >> x[i];
}
FOR(i, 0, q)
{
int l, r;
cin >> l >> r;
cout << fnd(l, r) << '\n';
}
}
| #include<bits/stdc++.h>
#define ll long long
using namespace std;
ll getmax(vector<int> box, vector<pair<int, int>> &bag, int n){
sort(box.begin(), box.end());
ll result=0;
vector<bool> visit (n, 0);
for(int i=0; i<box.size();i++){
for(int j=0; j<n; j++){
//cout<<bag[j].second<<" "<<box[i];
if(!visit[j]&&bag[j].second<=box[i]){
//cout<<"Hello";
visit[j]=1;
result+=bag[j].first;
break;
}
}
}
return result;
}
int main(){
int N, M, Q;
cin>>N>>M>>Q;
vector<pair<int,int>> bag;
for(int i=0; i<N; i++){
int first, second;
cin>>first>>second;
bag.push_back({second, first});
}
vector<int> box;
for(int i=0; i<M; i++){
int a; cin>>a; box.push_back(a);
}
sort(bag.rbegin(), bag.rend());
for (int i=0; i<Q; i++){
int L, R;
cin>>L>>R; --L; --R;
//cout<<"---------------------";
vector<int> validbox;
for(int j=0; j<M; j++){
if(j<L||j>R) validbox.push_back(box[j]);
}
cout<<getmax(validbox, bag, N)<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std ;
#define i64 int64_t // typecast using i64(x)
#define int int64_t
#define ld long double
#define endl "\n"
#define f(i,a,b) for(int i=int(a);i<int(b);++i)
#define pr pair
#define ar array
#define fr first
#define sc second
#define vt vector
#define pb push_back
#define LB lower_bound
#define UB upper_bound
#define PQ priority_queue
#define sz(x) ((int)(x).size())
#define all(a) (a).begin(),(a).end()
#define allr(a) (a).rbegin(),(a).rend()
#define mem0(a) memset(a, 0, sizeof(a))
#define mem1(a) memset(a, -1, sizeof(a))
template<class A> void rd(vt<A>& v);
template<class T> void rd(T& x){ cin >> x; }
template<class H, class... T> void rd(H& h, T&... t) { rd(h) ; rd(t...) ;}
template<class A> void rd(vt<A>& x) { for(auto& a : x) rd(a) ;}
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; }
template<typename T>
void __p(T a) {
cout<<a;
}
template<typename T, typename F>
void __p(pair<T, F> a) {
cout<<"{";
__p(a.first);
cout<<",";
__p(a.second);
cout<<"}\n";
}
template<typename T>
void __p(std::vector<T> a) {
cout<<"{";
for(auto it=a.begin(); it<a.end(); it++)
__p(*it),cout<<",}\n"[it+1==a.end()];
}
template<typename T, typename ...Arg>
void __p(T a1, Arg ...a) {
__p(a1);
__p(a...);
}
template<typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cout<<name<<" : ";
__p(arg1);
cout<<endl;
}
template<typename Arg1, typename ... Args>
void __f(const char *names, Arg1 &&arg1, Args &&... args) {
int bracket=0,i=0;
for(;; i++)
if(names[i]==','&&bracket==0)
break;
else if(names[i]=='(')
bracket++;
else if(names[i]==')')
bracket--;
const char *comma=names+i;
cout.write(names,comma-names)<<" : ";
__p(arg1);
cout<<" | ";
__f(comma+1,args...);
}
void setIO(string s = "") {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cin.exceptions(cin.failbit);
if(sz(s)){
freopen((s+".in").c_str(),"r",stdin);
freopen((s+".out").c_str(),"w",stdout);
}
}
template<int MOD> struct mint {
static const int mod = MOD ;
int v; explicit operator int() const { return v; }
mint() { v = 0; }
mint(long long _v) { v = int((-MOD < _v && _v < MOD) ? _v : _v % MOD);
if (v < 0) v += MOD; }
friend bool operator==(const mint& a, const mint& b) {
return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) {
return !(a == b); }
friend bool operator<(const mint& a, const mint& b) {
return a.v < b.v; }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this; }
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this; }
mint& operator*=(const mint& m) {
v = int((long long)v*m.v%MOD); return *this; }
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint power(mint a, long long p) {
mint ans = 1; assert(p >= 0);
for (; p; p /= 2, a *= a) if (p&1) ans *= a;
return ans; }
friend mint inv(const mint& a) { assert(a.v != 0);
return power(a,MOD-2); }
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
const int MOD = 998244353 ;
typedef mint<MOD> mi;
signed main(){
setIO() ;
int N, M, K;
rd(N,M,K);
mi ans ;
if(N == 1){
ans = power(mi(K),M);
}else if(M == 1){
ans = power(mi(K),N);
}else{
for(int x=1; x<=K; x++){
mi countB = power(mi(K-x+1),M);
mi countA = power(mi(x),N) - power(mi(x-1),N) ;
ans += countA * countB;
}
}
cout << ans.v ;
}
| #include<bits/stdc++.h>
#define int long long
#define mod 998244353
using namespace std;
inline int read(){
int x=0,f=1;
char ch=getchar();
while(ch<'0'||ch>'9'){
if(ch=='-')
f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
x=(x<<1)+(x<<3)+(ch^48);
ch=getchar();
}
return x*f;
}
int n,m,k,ans;
int ksm(int x,int t,int y=1) {
while(t) {
if(t&1) y=y*x%mod;
x=x*x%mod;
t>>=1;
}
return y;
}
signed main() {
cin>>n>>m>>k;
if(n==1) {
//ö¾Ùa È»ºóÓÐÒ»¸öbºÍËûÒ»Ñù
for(int i=1;i<=k;i++) ans=(ans+ksm(k-i+1,m)-ksm(k-i,m))%mod;
cout<<(ans+mod)%mod<<endl;
}
else if(m==1) { //ö¾Ù×î´óÖµ
for(int i=1;i<=k;i++) ans=(ans+ksm(i,n)-ksm(i-1,n))%mod;
cout<<(ans+mod)%mod<<endl;
}
else {
for(int i=1;i<=k;i++) { //ö¾ÙaµÄ×î´óÖµ
ans=(ans+ksm(k-i+1,m)*(ksm(i,n)-ksm(i-1,n))%mod)%mod;
}
cout<<(ans+mod)%mod<<endl;
}
}
|
#include <bits/stdc++.h>
#define yy cout<<"YES"<<endl;
#define nn cout<<"NO"<<endl;
#define for0(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define forc(i, l, r) for (int i = (int)(l); i <= (int)(r); ++i)
#define forr0(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define forr1(i, n) for (int i = (int)(n); i >= 1; --i)
#define rep(i, a, n) for (int i = a; i < n; i++)
#define mod 1000000007
#define fi first
#define se second
#define int long long
#define w(x) int x; cin>>x; while(x--)
#define endl ("\n")
#define f(i, a, n) for(int i=a; i<n; i++)
#define pb push_back
#define mi(a,b,c) min(a,min(b,c))
#define cc(r) cout<<r<<" "
#define ce(r) cout<<r<<endl
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin, (x).rend()
#define tr(c,i) for(__typeof__((c)).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c,x) ((c).find(x) != (c).end())
#define cpresent(c,x) (find(all(c),x) != (c).end())
#define sz(a) int((a).size())
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef double ld;
int32_t main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(14);
cout << fixed;
int t =1 ;
//cin >> t ;
while (t--)
{
int a, b ,c ;
cin >> a >>b >> c ;
cout << 21- a - b - c ;
}
return 0;
} | #include <bits/stdc++.h>
#include <bits/extc++.h>
#define double long double
#define rbtree __gnu_pbds::tree<int,__gnu_pbds::null_type,less<int>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>
#define int ll
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);
#define pb push_back
#define ALL(X) X.begin(),X.end()
#define F(i,n) FF(i,0,n)
#define F1(i,n) FF(i,1,n+1)
#define FF(i,n,m) for(int i=(int)n;i<(int)m;++i)
#ifndef LOCAL
//#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#else
#endif // LOCOL
//#define mp make_pair
using namespace std;
//using namespace __gnu_pbds;
template<typename T> bool remax(T& a, const T& b) {return b>a?a=b,1:0;}
template<typename T> bool remin(T& a, const T& b) {return b<a?a=b,1:0;}
inline ostream& operator << (ostream& os,__int128_t a){if(a==0) {return (os<<'0');}bool flag=0;if(a<0) {a=-a,flag=1;}string s;while(a){s+=a%10+'0';a/=10;}s+=flag?"-":"";reverse(ALL(s));return os<<s;}
inline istream& operator >>(istream& is,__int128_t& a){string s;cin>>s;a=0;for(auto c:s) a=a*__int128_t(10)+__int128_t(c-'0');return is;}
template<typename T,typename P> inline ostream& operator << (ostream& os,pair<T,P> a){os<<a.first<<" "<<a.second; return os;}
template<typename T,typename P> inline istream& operator >> (istream& is,pair<T,P> &a){is>>a.first>>a.second; return is;}
using ll=long long;
using ull=unsigned long long;
using int128= __int128_t;
using uint128= __uint128_t;
using pii =pair<int,int>;
const double pi=acos(-1);
const int N=1E5+5;
const ll M=1000000000;
const ll INF_64=0x3f3f3f3f3f3f3f3f;
const int INF_32=0x3f3f3f3f;
const int16_t INF_16=0x3f3f;
const int klog=20;
const int mod=1E9+7;//998244353
const double eps=1E-8;
void gen(){
}
vector<int> an;
bool DD(int x,int y){
if(x==0||y==0){
if(an.size()+x+y>130) return false;
while(x--) an.pb(1);
while(y--) an.pb(2);
return true;
}
if(x>=y)
x-=y,an.pb(3);
else y-=x,an.pb(4);
return DD(x,y);
}
int re(){
int x=0,y=0;
F(i,an.size()){
if(an[i]==1) x++;
else if(an[i]==2) y++;
else if(an[i]==3) x+=y;
else if(an[i]==4) y+=x;
}
return x;
}
void sol(){
int n;
cin>>n;
std::random_device rd;
std::default_random_engine gen = std::default_random_engine(rd());
std::uniform_int_distribution<int> dis(n/4,3*n/4);
int tt;
if(n<=130){
cout<<n<<"\n";
F(i,n) cout<<1<<"\n";
return;
}
while(tt=dis(gen)){
an.clear();
an.pb(3);
if(!DD(tt,n-tt)) continue;
//cerr<<tt<<"\n";
cout<<an.size()<<"\n";
reverse(ALL(an));
assert(re()==n);
F(i,an.size()) cout<<an[i]<<"\n";
return;
}
}
int32_t main(){
#ifdef LOCAL
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
#endif // LOCAL
IOS;
int t=1;
gen();
//cin>>t;
FF(i,1,t+1){
//cout<<"Case #"<<i<<": ";
sol();
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define rrep(i,n) for(int i=(n)-1; i>=0; i--)
#define FOR(i,a,b) for(int i=(a); i<(b); i++)
#define RFOR(i,a,b) for(int i=(b-1); i>=(a); i--)
#define 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 pb push_back
using ll = long long;
using D = double;
using LD = long double;
using P = pair<int, int>;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<int mod> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % mod) {
if (val < 0) val += mod;
}
constexpr int getmod() { return mod; }
constexpr Fp operator - () const noexcept {
return val ? mod - val : 0;
}
constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
constexpr Fp& operator += (const Fp& r) noexcept {
val += r.val;
if (val >= mod) val -= mod;
return *this;
}
constexpr Fp& operator -= (const Fp& r) noexcept {
val -= r.val;
if (val < 0) val += mod;
return *this;
}
constexpr Fp& operator *= (const Fp& r) noexcept {
val = val * r.val % mod;
return *this;
}
constexpr Fp& operator /= (const Fp& r) noexcept {
long long a = r.val, b = mod, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
val = val * u % mod;
if (val < 0) val += mod;
return *this;
}
constexpr bool operator == (const Fp& r) const noexcept {
return this->val == r.val;
}
constexpr bool operator != (const Fp& r) const noexcept {
return this->val != r.val;
}
friend constexpr istream& operator >> (istream &is, const Fp<mod>& x) noexcept {
int val; is >> val;
x = Fp<mod>(val);
return is;
}
friend constexpr ostream& operator << (ostream &os, const Fp<mod>& x) noexcept {
return os << x.val;
}
friend constexpr Fp<mod> modpow(const Fp<mod> &a, long long n) noexcept {
if (n == 0) return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1) t = t * a;
return t;
}
};
const int mod = 1e9+7;
using mint = Fp<mod>;
int main(){
int n; cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
if(n == 1){
cout << a[0] << endl;
return 0;
}
vector<mint> v(n), w(n);
v[0] = 1; v[1] = 2;
w[0] = 1; w[1] = 1;
rep(i,n-2) {
v[i+2] = v[i+1] + v[i];
w[i+2] = w[i+1] + w[i];
}
mint ans = 0;
rep(i,n) {
mint p = v[n-1-i]*w[i];
mint m = v[n-1]-p;
ans += (mint)a[i]*(p-m);
}
cout << ans << endl;
}
| /** Created by: Humberto Yusta
Codeforces User: humbertoyusta
Country: Cuba
Copyright�� */
#include<bits/stdc++.h>
using namespace std;
/// Pragmas:
#pragma GCC optimize("Ofast","unroll-loops","omit-frame-pointer","inline") //Optimization flags
//#pragma GCC option("arch=native","tune=native","no-zero-upper") //Enable AVX
//#pragma GCC target("avx2") //Enable AVX
/// Recently stolen pragmas:
//#pragma comment(linker, "/STACK:1024000000,1024000000")
//#pragma GCC optimize ("O3")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/// Macros:
#define int long long
#define f first
#define s second
#define db(x) cerr << #x << ": " << (x) << '\n';
#define pb push_back
#define lb lower_bound
#define up upper_bound
#define all(x) x.begin() , x.end()
#define rall(x) x.rbegin() , x.rend()
typedef pair<int,int> ii;
typedef long double ld;
typedef unsigned long long ull;
typedef long long ll;
/// Constraints:
const int maxn = 100010;
const int mod = 1000000007;
const int mod2 = 998244353;
const ld eps = 1e-9;
const int inf = ((1ll<<31ll)-1ll);
const int INF = 1ll * mod * mod;
const ld pi = acos(-1);
/// Prime Numbers:
// 2, 173, 179, 181, 197, 311, 331, 737, 1009, 2011, 2027, 3079, 4001, 10037, 10079, 20011, 20089;
// 100003, 100019, 100043, 200003, 200017, 1000003, 1000033, 1000037, 1000081;
// 2000003, 2000029, 2000039, 1000000007, 1000000021, 2000000099;
/// rng
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
/// Functions:
#define lg2(x) 63 - __builtin_clzll(x)
#define lgx(x,b) ( log(x) / log(b) )
/// Red-Black Tree Template ---------------------------------
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//typedef tree < long long , null_type , less<long long> , rb_tree_tag , tree_order_statistics_node_update > ordered_set;
/// Quick Pow and Primality Check------------------------------------------------
int qpow(int b,int e){
if( !e ) return 1;
if( e & 1 ) return qpow(b,e-1) * b % mod;
int pwur = qpow(b,e>>1);
return pwur * pwur % mod;
}
int modinv(int x){
return qpow(x,mod-2);
}
bool isprime(int x){
for(int i=2; i*i<=x; i++)
if( x % i == 0 ) return false;
return true;
}
/// My Code -------------------------------------------------
int n, dp[maxn], subt[maxn], cnt[maxn];
vector<int> g[maxn];
void dfs(int u){
for( auto v : g[u] )
dfs(v);
subt[u] = 1;
for( auto v : g[u] ){
subt[u] += subt[v];
cnt[u] += subt[v] % 2;
}
if( subt[u] == 1 ){
dp[u] = 0;
return;
}
if( g[u].size() == 1 ){
dp[u] = dp[g[u][0]];
return;
}
vector<int> vx;
for( auto v : g[u] ){
if( subt[v] & 1 ){
dp[u] += dp[v];
vx.pb(-dp[v]+subt[v]-dp[v]);
}
else{
if( dp[v] >= subt[v] - dp[v] ){
dp[u] += dp[v];
}
else{
if( cnt[u] % 2 ){
dp[u] += subt[v] - dp[v];
}
else{
dp[u] += dp[v];
}
}
}
}
sort(all(vx));
//reverse(all(vx));
for(int i=1; i<vx.size(); i+=2){
dp[u] += vx[i];
}
}
int32_t main(){
ios_base::sync_with_stdio(0); cin.tie(0);
cout.setf(ios::fixed); cout.precision(0);
srand(time(NULL));
//freopen("a.in","r",stdin);
//freopen("a.out","w",stdout);
cin >> n;
for(int i=1; i<=n; i++){
dp[i] = 0;
}
for(int i=2; i<=n; i++){
int u;
cin >> u;
g[u].pb(i);
}
dfs(1);
for(int i=1; i<=n; i++){
;//db(dp[i])
}
cout << n - dp[1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pair<int,int>>
#define mi map<int,int>
#define all(a) (a).begin(),(a).end()
#define F first
#define S second
#define sz(x) (int)x.size()
#define endl '\n'
#define rep(i,a,b) for(i=a;i<b;i++)
#define inf INT_MAX
#define llinf LLONG_MAX
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; }
using namespace std;
void solve()
{
int a[4],i;
rep(i,0,4)cin>>a[i];
sort(a,a+4);
if(a[3]==a[0]+a[1]+a[2] || a[0]+a[2]==a[1]+a[3] || a[0]+a[3]==a[1]+a[2])cout<<"Yes";
else cout<<"No";
}
int main()
{
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
int t=1;
//cin>>t;
while(t--)
{
solve();
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef BOI
#include "debug.h"
#else
#define debug(args...)
#endif
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair <int, int>;
using pli = pair <ll, int>;
using pll = pair <ll, ll>;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
const ll INF = (ll)2e9 + 69;
int main() {
ios_base :: sync_with_stdio(0);
cin.tie(0);
vector <ll> a(4); cin >> a[0] >> a[1] >> a[2] >> a[3];
bool ok = false;
for (int i = 0; i < 16; ++i) {
ll sum = accumulate(all(a), 0);
ll sum1 = 0;
for (int j = 0; j < 4; ++j) {
if (i & (1 << j)) sum1 += a[j];
}
sum -= sum1;
if (sum == sum1) {
ok = true;
break;
}
}
cout << (ok ? "Yes" : "No");
} |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int T, n, cnt, a[N], op[N * N];
int s[10][4] = {
{},
{0, 1, 2, 3},
{0, 1, 3, 2},
{0, 3, 1, 2},
{0, 3, 2, 1},
{0, 2, 3, 1},
{0, 2, 1, 3},
{0, 1, 2, 3}
};
int to[10] = {0, 2, 1, 2, 1, 2, 1};
void out() {
cout << cnt << '\n';
for(int i = 1; i <= cnt; i++) {
cout << op[i] << ' ';
}
cout << '\n';
}
void move(int x) {
int pos = 0;
for(int i = 1; i <= n; i++) {
if(a[i] == x) {
pos = i;
break;
}
}
while(pos != x) {
// cout << pos << ' ' << cnt << '\n';
if(pos % 2 == (cnt + 1) % 2) {
swap(a[pos], a[pos + 1]);
op[++cnt] = pos;
++pos;
} else {
if(pos >= x - 2) {
op[++cnt] = pos - 1;
op[++cnt] = pos;
op[++cnt] = pos - 1;
op[++cnt] = pos;
op[++cnt] = pos - 1;
swap(a[pos], a[pos + 1]);
++pos;
} else {
op[++cnt] = pos + 1;
swap(a[pos + 2], a[pos + 1]);
}
}
}
}
bool eq(int x) {
for(int i = 1; i <= 3; i++) {
if(a[i] != s[x][i]) return false;
}
return true;
}
void work() {
if(n == 2) {
if(a[1] == 2) op[cnt = 1] = 1;
out();
} else {
for(int i = n; i >= 4; i--) {
move(i);
}
for(int i = 1; i <= 7; i++) {
if(eq(i)) {
if(i == 1 || i == 7) break;
if((cnt + 1) % 2 == to[i] % 2)
for(int j = i; j < 7; j++) op[++cnt] = to[j];
else
for(int j = i - 1; j >= 1; j--) op[++cnt] = to[j];
break;
}
}
out();
}
}
int main() {
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
#ifdef ONLINE_JUDGE
ios::sync_with_stdio(false); cin.tie(0);
#endif
cin >> T;
while(T--) {
cnt = 0;
cin >> n;
for(int i = 1; i <= n; i++) {
cin >> a[i];
}
work();
}
return 0;
} | #include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstdlib>
#include<queue>
#include<set>
#include<cstdio>
#include<map>
#include<cassert>
using namespace std;
#define ll long long
#define reps(i, a, b) for(int i = a; i < b; i++)
#define rreps(i, a, b) for(int i = a-1; i >= b; i--)
#define rep(i, n) reps(i, 0, n)
#define rrep(i, n) rreps(i, n, 0)
#define P pair<int, int>
#define vec vector<int>
#define mat vector<vector<int> >
const ll mod = 1000000007;
const int INF = 1001001001;
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 {
mint res(*this);
return res+=a;
}
mint operator-(const mint a) const {
mint res(*this);
return res-=a;
}
mint operator*(const mint a) const {
mint res(*this);
return res*=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 {
mint res(*this);
return res/=a;
}
};
istream& operator>>(istream& is, const mint& a){ return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a){ return os << a.x; }
int main(){
int n;
cin >> n;
vec a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
mint ans;
ans = a[0] + 1;
rep(i, n-1){
ans *= a[i+1] - a[i] + 1;
}
cout << ans << endl;
} |
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("O2")
//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
////
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define allp(x) (x)->begin(), (x)->end()
#define pb push_back
using namespace std;
void dout() { cerr << endl; }
//typedef long long ll;
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << H << ' ';
dout(T...);
}
using ll = long long;
//#ifdef __int128
//using hll = __int128;
//#endif
using pii = pair<ll, ll>;
using ld = long double;
template <typename T>
void do_uniq(vector<T> &vec){
sort(all(vec));
vec.resize(unique(all(vec)) - vec.begin());
}
#ifndef ONLINE_JUDGE
clock_t timestamp_start = clock();
void time_calc()
{
cerr << (ld)(clock() - timestamp_start) / CLOCKS_PER_SEC << "\n";
}
#endif
#ifdef _getchar_nolock
#else
# define _getchar_nolock getchar_unlocked
#endif
#define integer int
integer mod = 1e9 + 7;
integer ml(integer a, integer b) {
return (a * 1ll * b) % mod;
}
integer add(integer a, integer b) {
return (a + b) % mod;
}
integer sub(integer a, integer b) {
return add(a, mod - b);
}
integer sq(integer a) {
return ml(a, a);
}
integer b_p(integer b, integer p) {
if (p == 0) return 1;
if (p & 1) return ml(b, b_p(b, p - 1));
return sq(b_p(b, p >> 1));
}
#define solvsh
//#define multi
#ifdef solvsh
void precalc() {
}
const int MAXN = 112;
int getbg(int k) {
if (k > 30) return 1e9;
return 1 << k;
}
char getwin(char l, char r) {
if (l == 'R') {
if (r == 'S') return l;
return r;
} else if (l == 'P') {
if (r == 'R') return l;
return r;
} else {
if (r == 'P') return l;
return r;
}
}
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
while (k) {
string news = "";
if (s.size() % 2 == 1) {
s = s + s;
}
for (int i = 0; i < s.size(); i += 2) {
news += getwin(s[i], s[i + 1]);
}
--k;
int lenn = getbg(k);
while (news.size() > lenn) news.pop_back();
s = news;
}
cout << s << "\n";
}
#else
#endif
void multisolve() {
// precalc();
int t;
cin >> t;
int i = 1;
while (t--) {
solve();
i++;
}
}
#ifndef ONLINE_JUDGE
void gen() {
int n = 2000;
cout << n << "\n";
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == 0 && j == 0) {
cout << "S";
continue;
}
if (i == n - 1 && j == n - 1) {
cout << "G";
continue;
}
cout << char('a' + (rand() % 26)) << "";
}
cout << "\n";
}
}
#endif
#define int int
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(20);
#ifdef multi
// gen();
multisolve();
#else
solve();
// gen();
#endif
// time_calc();
}
| #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
char win(char a,char b){
if (a == 'R' && b == 'P') return b;
if (a == 'P' && b == 'S') return b;
if (a == 'S' && b == 'R') return b;
else return a;
}
int main(){
int n,k;
cin >> n >> k;
string s;
cin >> s;
while(k--){
s += s;
string t;
for(int i = 0;i<2*n;i+= 2){
t += win(s[i],s[i+1]);
}
s = t;
}
cout << s[0] << endl;
}
|
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
#include<cmath>
#include<vector>
#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 fi first
#define se second
#define mp make_pair
#define all(x) x.begin(),x.end()
#define debug(x) cout<<# x <<" is "<<x<<endl;
using namespace std;
typedef long long ll;
typedef pair<ll,ll> PII;
const ll maxn=2e2+10,inf=0x3f3f3f3f3f3f3f3f,mod=1e9+7;
vector<int> ans[maxn];
bool vis[maxn];
int a[maxn];
int main()
{
int N;cin>>N;
rep(i,1,N) {cin>>a[i]; a[i]%=200;}
//sort(a+1,a+1+N);
vis[0]=1;
vector<int> flag1,flag2;
rep(i,1,N){
vector<int> t;
rep(j,0,199){
if(vis[j]){
int tar=(j+a[i])%200;
if((tar!=0&&vis[tar])||(tar==0&&!ans[0].empty())){
flag1=ans[tar];
flag2=ans[j];
flag2.push_back(i);
break;
}
else{
ans[tar]=ans[j];
ans[tar].push_back(i);
t.push_back(tar);
}
}
}
if(!t.empty()) rep(i,0,t.size()-1) vis[t[i]]=true;
}
if(flag1.empty()) cout<<"No"<<endl;
else {
cout<<"Yes\n";
cout<<flag1.size()<<' ';
rep(i,0,flag1.size()-1)
cout<<flag1[i]<<' ';
putchar('\n');
cout<<flag2.size()<<' ';
rep(i,0,flag2.size()-1)
cout<<flag2[i]<<' ';
putchar('\n');
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
int main(){
ll n,a;
cin>>n;
vector<ll> A(n),bit200(200,0);
vector<set<ll>> bit200s(200);
for(ll i=0;i<n;i++) {
cin>>a;
A.at(i)=(a%200);
}
ll N8=n>8?8:n;
set<ll> s1,s2;
bool boo=false;
for(ll i=1;i<(1<<N8);i++){
set<ll> s;
ll sum=0;
for(ll j=0;j<N8;j++) if((1<<j)&i) {
//cout<<j<<endl;
sum+=A.at(j);
//cout<<j<<endl;
s.insert(j);
}
if(bit200.at(sum%200)==1){
s1=s;
s2=bit200s.at(sum%200);
boo=true;
break;
}
else {
bit200.at(sum%200)=1;
bit200s.at(sum%200)=s;
}
}
if(!boo){
cout<<"No"<<endl;
}
else{
cout<<"Yes"<<endl;
cout<<s1.size();
for(auto si:s1){
cout<<" "<<si+1;
}
cout<<endl;
cout<<s2.size();
for(auto si:s2){
cout<<" "<<si+1;
}
cout<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, k, m;
int total=0,ans=0;
cin >> n >> k >> m;
int ar[n];
int sum = 0;
for(int i = 0; i < n - 1; i++)
{
cin >> ar[i];
sum = sum+ar[i];
}
total = (n * m - sum);
if (total <= 0) ans = 0;
else if(total <= k) ans = total;
else ans = -1;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define t_times int t; cin >> t; while(t--)
#define _parr(a, n) for(int __i = 0; __i < (int )n; __i++) cout << a[__i] << ' '; cout << '\n'
#define fr(i, p, n) for(int i = (int )p; i < (int )n; i++)
#define frn(i, p, n) for(int i = (int )p; i <= (int )n; i++)
#define rev(i, n, p) for(int i = (int )n; i >= (int )p; i--)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).begin(), (c).end()
#define sci(n) scanf("%d", &n)
#define scl(n) scanf("%lld", &n)
#define prin(n) printf("%d\n", n)
#define prln(n) printf("%lld\n", n)
#define mp make_pair
#define F first
#define S second
#define pb push_back
typedef long long int LL;
typedef unsigned long long ULL;
typedef unsigned int uint;
typedef pair< int, int> ii;
typedef vector< int> vi;
const int mod = 1e9 + 7;
const LL INF = 9e18 + 2e17;
const int inf = 2e9;
const int N = 2e5 + 22;
const double eps = 1e-10;
int n, m, k;
void _solve() {
cin >> n >> k >> m;
int x, sum = 0;
fr(i, 1, n) cin >> x, sum += x;
int z = m * n;
if(z > sum && (z - sum) > k) cout << -1;
else if(z > sum) cout << z - sum;
else cout << 0;
}
int main() {
fastio;
//t_times
_solve();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
vector<int> cnt(10);
for (char c : s) ++cnt[c - '0'];
bool ok = false;
for (int i = 8; i < 1000; i += 8) {
vector<int> cnt2(cnt);
for (char c : to_string(i)) --cnt2[c - '0'];
if (s.size() <= 3) ok or_eq all_of(cnt2.begin(), cnt2.end(), [](int x) { return x == 0; });
else ok or_eq to_string(i).size() == 3 and to_string(i).find('0') == string::npos and all_of(cnt2.begin(), cnt2.end(), [](int x) { return x >= 0; });
}
cout << (ok ? "Yes" : "No") << "\n";
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 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 INF 1000000000000 //10^12:∞
#define MOD 1000000007 //10^9+7:合同式の法
signed main(){
string S;
cin >> S;
vector<ll> bucket(10, 0);
if(S.length() == 1) {
if(S == "8") {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
if(S.length() == 2) {
ll num1 = (S.at(0) - '0') * 10 + (S.at(1) - '0');
if(num1 % 8 == 0) {
cout << "Yes" << endl;
return 0;
} else {
ll num2 = (S.at(1) - '0') * 10 + (S.at(0) - '0');
if(num2 % 8 == 0) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
REP(i, S.length()) {
ll index = (S.at(i) - '0');
bucket.at(index)++;
}
for(ll i = 104; i <= 992; i += 8) {
ll x = i;
vector<ll> bucket2(10, 0);
while(x != 0) {
bucket2.at(x % 10)++;
x /= 10;
}
bool flag = true;
REP(j, 10) {
if(bucket.at(j) < bucket2.at(j)) {
flag = false;
break;
}
}
if(flag) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
} |
#include <bits/stdc++.h>
#define ll long long
#define map unordered_map
#define set unordered_set
#define l_l pair<ll, ll>
#define P pair<ll, ll>
#define vll vector<ll>
#define mll map<ll, ll>
#define mp make_pair
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rev(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define revs(i, n) for (int i = ((int)(n)); i > 0; --i)
// template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
// template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using namespace std;
const ll MOD = 1000000007LL;
const ll INF = (1LL << 60LL);
ll H, W;
// template <class T> void plus_mod(T &a, const T &b) {a = (a + b) % MOD;}
ll grid[2005][2005];
ll dp[2005][2005];
ll TE;
ll calc(ll y, ll x) {
if (dp[y][x] != INF) return dp[y][x];
ll te = y + x;
bool is_taka = (te % 2 == 0);
ll plus = is_taka ? grid[y][x] : -grid[y][x];
if (y == H - 1 && x == W - 1) {
dp[y][x] = -plus;
return -plus;
}
ll v;
if (x < W - 1 && y < H - 1) {
//
ll v1 = calc(y, x + 1);
ll v2 = calc(y + 1, x);
if (is_taka) {
v = max(v1, v2);
} else {
v = min(v1, v2);
}
} else if (x < W - 1) {
v = calc(y, x + 1);
} else if (y < H - 1) {
v = calc(y + 1, x);
}
v -= plus;
dp[y][x] = v;
return v;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
void show_table(ll I, ll J) {
rep(i, I) {
rep(j, J) { cout << dp[i][j] << " "; }
cout << "" << endl;
}
cout << "" << endl;
}
int main() {
// std::cout << std::fixed << std::setprecision(10);
Fill(dp, INF);
// + 青
// - 赤
scanf("%lld %lld", &H, &W);
rep(y, H) {
string line;
cin >> line;
rep(x, W) {
char ch = line[x];
if (ch == '-') grid[y][x] = -1;
if (ch == '+') grid[y][x] = 1;
}
}
// cout << (calc(1, 0)) << endl;
if (H == 1 && W == 1) {
cout << ("Draw") << endl;
return 0;
}
ll TE = H + W - 2;
ll c = calc(0, 0);
ll v;
if (W >= 2 && H >= 2) {
ll v1 = dp[0][1];
ll v2 = dp[1][0];
v = max(v1, v2);
} else if (W >= 2) {
v = dp[0][1];
} else {
v = dp[1][0];
}
// cout << "v:" << (v) << endl;
if (v == 0) {
cout << ("Draw") << endl;
} else if (v >= 1) {
cout << ("Takahashi") << endl;
} else {
cout << ("Aoki") << endl;
}
// show_table(H, W);
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vll = vector<long long>;
using vb = vector<bool>;
using vd = vector<double>;
using vc = vector<char>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long>>;
using vvc = vector<vector<char>>;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template<typename T> using graph = vector<vector<pair<T, int>>>;// pair of weight and vertex
template<typename T> inline bool chmax(T& a, const T b){ if(a < b){ a = b; return true; } return false; }
template<typename T> inline bool chmin(T& a, const T b){ if(a > b){ a = b; return true; } return false; }
void my_answer(){
// 本質的にはミニマックス法と同じだが、dpの定義が通常とは違ってしまっているっぽい
// dp[i][j] := if (i+j) % 2 == 0: Score(Takahashi) - Score(Aoki)の最大値
// elif: Score(Aoki) - Score(Takahashi)の最大値
int h, w;
cin >> h >> w;
vvc fi(h, vc(w));
for(auto& y: fi) for(auto& x: y) cin >> x;
vvi dp(h, vi(w, INT32_MIN));
dp[h-1][w-1] = 0;
for(int y = h-1; y >= 0; --y){
for(int x = w-1; x >= 0; --x){
if(y+1 <= h-1) chmax(dp[y][x], -dp[y+1][x] + (fi[y+1][x] == '+' ? 1 : -1));
if(x+1 <= w-1) chmax(dp[y][x], -dp[y][x+1] + (fi[y][x+1] == '+' ? 1 : -1));
}
}
if(dp[0][0] == 0){
cout << "Draw" << endl;
}else if(dp[0][0] > 0){
cout << "Takahashi" << endl;
}else{
cout << "Aoki" << endl;
}
}
void best_answer(){
// ミニマックス法（模範解答）
// dp[i][j] := Score(Takahashi) - Score(Aoki)
// if (i+j) % 2 == 0: Takahashiスタート。dp[i][j]を最大化しようとする。入る得点はTakahashiのものとして考えるので、+で計算。
// elif: Aokiスタート。dp[i][j]を最小化しようとする。入る得点はAokiのものとして考えるので、-で計算。
int h, w;
cin >> h >> w;
vvc fi(h, vc(w));
for(auto& y: fi) for(auto& x: y) cin >> x;
vvi dp(h, vi(w, 0));
for(int y = h-1; y >= 0; --y){
for(int x = w-1; x >= 0; --x){
if((y + x) % 2 == 0){
// Takahashi start
if(y+1 <= h-1 || x+1 <= w-1) dp[y][x] = INT32_MIN;
if(y+1 <= h-1) chmax(dp[y][x], dp[y+1][x] + (fi[y+1][x] == '+' ? 1 : -1));
if(x+1 <= w-1) chmax(dp[y][x], dp[y][x+1] + (fi[y][x+1] == '+' ? 1 : -1));
}else{
// Aoki start
if(y+1 <= h-1 || x+1 <= w-1) dp[y][x] = INT32_MAX;
if(y+1 <= h-1) chmin(dp[y][x], dp[y+1][x] - (fi[y+1][x] == '+' ? 1 : -1));
if(x+1 <= w-1) chmin(dp[y][x], dp[y][x+1] - (fi[y][x+1] == '+' ? 1 : -1));
}
}
}
if(dp[0][0] == 0){
cout << "Draw" << endl;
}else if(dp[0][0] > 0){
cout << "Takahashi" << endl;
}else{
cout << "Aoki" << endl;
}
}
int main(){
// my_answer();
best_answer();
}
|
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
int32_t main()
{
string s;
cin>>s;
bool ok=true;
for(int i=0;i<s.length();i++)
{
if(i%2==1)
{
if(islower(s[i]))
ok=false;
}
else if(i%2==0)
{
if(isupper(s[i]))
ok=false;
}
}
if(ok)
cout<<"Yes"<<"\n";
else
cout<<"No"<<"\n";
}
| #include <bits/stdc++.h>
using namespace std;
void DBG() { cerr << endl; }
template<class Head, class... Tail>
void DBG(Head H, Tail... T) { cerr << ' ' << H; DBG(T...); }
#define dbg(...) cerr << "(" << (#__VA_ARGS__) << "):", DBG(__VA_ARGS__)
using ll = long long;
using ld = long double;
#define sqr(a) ll(a) * (a)
#define siz(a) int(a.size())
#define ints(a...) int a; read(a)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define trav(i, v) for (const auto i : v)
#define fill(a, b) memset(a, b, sizeof(a))
#define rep(i, b, n) for (auto i = b; i < n; i++)
#define per(i, b, n) for (auto i = b; i >= n; i--)
#define unify(a) sort(all(a)); a.resize(unique(all(a)) - a.begin())
template <class T> using vec = vector<T>;
template <class... Args> inline void read(Args&... args) { ((cin >> args), ...); }
template <class... Args> inline void show(Args... args) { ((cout << args << " "), ...); }
template <class T1, class T2> inline bool ckmin(T1 &a, T2 b) { return a > b ? a = b, 1 : 0; }
template <class T1, class T2> inline bool ckmax(T1 &a, T2 b) { return a < b ? a = b, 1 : 0; }
template <class T> inline void operator>> (istream& in, vector<T>& v) { rep(i, 0, siz(v)) in >> v[i]; }
template <class T> inline void operator<< (ostream& out, const vector<T>& v) { rep(i, 0, siz(v)) out << v[i] << " \n"[i + 1 == siz(v)]; }
const int MOD = 998244353;
struct Mod {
template<typename T>
T add(int64_t a, T b) { a += b; if (a >= MOD) a -= MOD; return a; }
template<typename T>
T sub(T a, T b) { a = a - b; if (a < 0) a += MOD; return a; }
template<typename T>
T mul(T a, T b) { return 1ll * a * b % MOD; }
int64_t pow_n(int64_t a, int64_t p, const int mod = MOD) {
int64_t ans = 1;
a %= mod;
while (p > 0) {
if (p & 1) ans = ans * a % mod;
a = a * a % mod;
p >>= 1;
}
return ans;
}
template<typename T>
T inv(T a) { return pow_n(a, MOD - 2); }
template<typename T>
T div(T a, T b) { return mul(a, inv(b)); }
} M;
void solve() {
vec<ll> v(3);
cin >> v;
ll res = 1;
rep(i, 0, 3) {
ll a = v[i];
ll b = v[i] + 1;
if (a % 2 == 0)
a /= 2;
else
b /= 2;
res = M.mul(res, M.mul(a, b));
}
cout << res << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(12);
cerr << fixed << setprecision(12);
int _ = 1;
// cin >> _;
rep(i, 1, _ + 1) {
// printf("Case %d: ", i);
solve();
}
return 0;
} |
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
//#pragma GCC optimization ("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> pll;
typedef vector<ll> vl;
#define pb push_back
#define MAXN 500005
const ll N=60;
#define INF (ll)1e18
#define mod 1000000007
//#define mod 998244353
#define fi first
#define se second
#define mkp make_pair
#define sze(x) ((ll)x.size())
#define all(v) v.begin(),v.end()
#define endl '\n'
#define level 20
ll timer,cc,cc1;
void boost()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
ll dp[MAXN],b[N];
vl V[MAXN];
map<pll,ll> mp;
void dfs(ll cur,ll prev)
{
ll j;
j=mp[mkp(cur,prev)];
dp[cur]=dp[prev]^j;
for(auto x : V[cur])
{
if(x!=prev)
{
dfs(x,cur);
}
}
}
int main()
{
boost();
ll i,t,n,q,l,r,ans,mid,c=0,j,k,z,tc;
ll h,m,u,mm,w,mx,x,y,l1,r1,d=0,mask;
ld f,f1;
cin>>n;
for(i=0;i<(n-1);i++)
{
cin>>x>>y>>z;
V[x].pb(y);
V[y].pb(x);
mp[mkp(x,y)]=z;
mp[mkp(y,x)]=z;
}
dfs(1,0);
ans=0;
for(i=0;i<60;i++)
{
c=0;
d=0;
for(j=1;j<=n;j++)
{
if((1LL<<i)&dp[j])
{
c++;
}
else
d++;
}
z=c*d;
l=(1LL<<i);
l%=mod;
z=z%mod;
z=z*l;
z%=mod;
ans+=z;
ans%=mod;
}
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define INF (int)2e9
#define mod 1000000007
#define PI 3.141592653589793238
#define all(a) (a).begin(),(a).end()
#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 repz(i,b) for(int i=0; i<b; ++i)
#define repdz(i,b) for(int i=b; i>=0; --i)
#define trav(i,a) for(auto &i: a)
#define pb push_back
#define pf push_front
#define nl '\n'
#define sp ' '
#define sz(a) a.size()
#define read(p) repz(i,sz(p)) cin>>p[i]
typedef long long ll;
typedef vector<vector<int>> vvi;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<int, int> pii;
typedef vector<vector<pair<ll ,ll>>> vvp;
typedef vector<pair<ll, ll>> vpl;
typedef pair<ll, ll> pll;
int n;
vvp adj;
ll paths;
pll dfs(ll v, ll prev, int b){
vpl paritypaths;
ll tx=0, ty=0;
trav(p, adj[v]){
if(p.first==prev) continue;
pii np=dfs(p.first, v, b);
if(p.second&((ll)1<<b)) swap(np.first, np.second);
tx+=np.first; ty+=np.second;
tx%=mod; ty%=mod;
if(p.second&((ll)1<<b)) {
ty++; np.second++;
}else {
tx++; np.first++;
}
paritypaths.pb({np.first, np.second});
}
paths+=ty;
paths%=mod;
trav(p,paritypaths){
paths+=p.first*(ty-p.second);
paths%=mod;
}
return {tx,ty};
}
ll ppow(ll n, ll m){
if(m==0) return 1;
ll tmp=ppow(n,m/2);
tmp = tmp * tmp % mod;
return m%2 ? tmp*n % mod : tmp;
}
void solve(){
cin>>n;
adj.assign(n, vpl());
repz(i, n-1){
ll u, v, w; cin>>u>>v>>w; u--; v--;
adj[u].pb({v,w}); adj[v].pb({u,w});
}
ll ans=0;
repz(b,60){
paths=0;
dfs(0,0,b);
ans+=paths*ppow(2,b);
ans%=mod;
// cout<<paths<<sp<<ans<<nl;
}
cout<<ans;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.precision(10);
int ts=1;
//cin>>ts;
while(ts--){
solve();
}
return 0;
}
|
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<string.h>
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define NDEBUG
#define eprintf(...) do {} while (0)
#endif
#include<cassert>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(),i##_end=(c).end();i!=i##_end;++i)
template<class T> inline void amin(T &x, const T &y) { if (y<x) x=y; }
template<class T> inline void amax(T &x, const T &y) { if (x<y) x=y; }
#define rprintf(fmt, begin, end) do { const auto end_rp = (end); auto it_rp = (begin); for (bool sp_rp=0; it_rp!=end_rp; ++it_rp) { if (sp_rp) putchar(' '); else sp_rp = true; printf(fmt, *it_rp); } putchar('\n'); } while(0)
int N;
void MAIN() {
scanf("%d", &N);
int ans =0 ;
for (int i=1; i<=N; i++) {
bool ok = true;
{
int m = i;
while (m) {
if (m % 10 == 7) {
ok = false;
break;
}
m /= 10;
}
}
if (ok) {
int m = i;
while (m) {
if (m % 8 == 7) {
ok = false;
break;
}
m /= 8;
}
}
if (ok) ans++;
}
printf("%d\n", ans);
}
int main() {
int TC = 1;
// scanf("%d", &TC);
REP (tc, TC) MAIN();
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll n,arr[1006];
cin>>n;
for(int i=0; i<n; i++)
{
cin>>arr[i];
}
sort(arr,arr+n);
int x=0,c,max_c=0,flag=0;
for(int i=2;i<=1000;i++)
{
c=0;
for(int j=0;j<n;j++)
{
if(arr[j]%i==0)
{
c++;
}
}
if(c>max_c)
{
max_c=c;
x=i;
flag=1;
}
}
if(flag==1)
{
cout<<x<<endl;
}
else
{
cout<<"0"<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define vll vector<ll>
#define mp make_pair
#define pb push_back
#define pll pair<ll,ll>
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
#define F(i,a,n) for(ll i=a;i<n;i++)
#define fil(ar, val) memset(ar, val, sizeof(ar))
using namespace std;
const int mod = 1000000007;
ll gcd(ll a, ll b) {return (b == 0) ? a : gcd(b, a % b);}
ll lcm(ll a, ll b) {return ((a * b) / (gcd(a, b)));}
ll binpow(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;
}
res %= mod;
return res;
}
ll counter(ll n)
{
ll ct = 0;
while (n)
{
n /= 10;
ct++;
}
return ct;
}
bool prime[10000005];
vector<ll>v;
unordered_map<ll, bool>cp;
void sieve()
{
memset(prime, 1, sizeof(prime));
for (ll i = 2; i * i <= 10000001; i++)
{
if (prime[i] == 1)
{
for (ll j = i * i; j <= 10000001 ; j += i)
{
prime[j] = 0;
}
}
}
prime[1] = 0;
F(i, 3, 2000005) // n prime : 1000003
{
if (prime[i])
{
v.pb(i);
cp[i] = true;
}
}
}
vll vis(2005, 0);
vector<ll>adj[2005];
vector<ll>dis(2005, 0);
ll ct = 0;
void dfs(ll node)
{
ct++;
vis[node] = 1;
for (auto i : adj[node])
{
if (!vis[i])
{
dfs(i);
}
}
}
void bfs(ll node)
{
vis[node] = 1;
queue<ll>q;
q.push(node);
while (!q.empty())
{
ll src = q.front();
q.pop();
for (auto i : adj[src])
{
if (!vis[i])
{
dis[i] = dis[src] + 1;
vis[i] = 1;
q.push(i);
}
}
}
}
void i_p()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("op.txt", "w", stdout);
#endif
}
// luba luba dub dub
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
i_p();
int t;
t = 1;
// cin >> t;
while (t--)
{
// easy way:
ll n, m;
cin >> n >> m;
F(i, 1, n + 1)
{
vis[i] = 0;
}
ll x, y;
F(i, 0, m)
{
cin >> x >> y;
adj[x].pb(y);
}
ll ans = 0;
F(i, 1, n + 1)
{
ct = 0;
dfs(i);
ans += ct;
// cout << ct << "\n";
F(i, 1, n + 1)
{
vis[i] = 0;
}
}
cout << ans << "\n";
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define oo 1000000000
typedef long long int lli;
typedef pair<int,int> pii;
typedef pair<char,int> pci;
int n;
string st,str;
int main(){
cin >> n;
cin >> str;
int cnt =0;
for(int tam = 2;tam<=n;tam++){
//cout << "\n" << tam << "\n";
int at=0,cg=0;
for(int i=0;i<n;i++){
//cout << ini << " "
if(str[i]=='A'){
at++;
}
if(str[i]=='T'){
at--;
}
if(str[i]=='C'){
cg++;
}
if(str[i]=='G'){
cg--;
}
if(i>=tam){
if(str[i-tam]=='A'){
at--;
}
if(str[i-tam]=='T'){
at++;
}
if(str[i-tam]=='C'){
cg--;
}
if(str[i-tam]=='G'){
cg++;
}
}
//cout << at << " " << cg << "\n";
if((i>=tam-1) && (at == 0 && cg == 0)){
cnt++;
}
}
}
cout << cnt << "\n";
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <complex>
#include <vector>
#include <set>
#include <list>
#include <cmath>
#include <queue>
#include <map>
#include <stack>
#include <bitset>
#include <numeric> //lcm
#include <iomanip> //double精度 setprecision
#include <chrono>
#include <random>
#include <cassert>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = (n)-1; i >= 0; --i)
#define rep1(i,n) for(int i = 1; i <= (n); ++i)
#define rrep1(i,n) for(int i = (n); i >= 1; --i)
#define REP(i,n,m) for(int i = (n); i < (m); ++i)
#define all(vec) (vec).begin(),(vec).end()
#define debug(a) { cerr << #a << " = " << a << endl;}
#define debugV(vec) { cerr << #vec << " : "; for(auto v : vec) cerr << v << " "; cerr << endl; }
#define debug2D(vec2D, w) { cerr << #vec2D << endl; for(auto vec : vec2D) { for (auto v : vec) cerr << setw(w) << v << " "; cerr << endl; } }
#define debugVP(vec) { cerr << #vec << " : "; for(auto v : vec) cerr << "(" << v.first << "," << v.second << ") "; cerr << endl;}
#define debug2DP(vec2D) { cerr << #vec2D << endl; for(auto vec : vec2D) { for (auto v : vec) cerr << "(" << v.first << "," << v.second << ") "; cerr << endl; } }
typedef long long ll;
constexpr ll INF = 1001001001; //32 ~2*10^10 //64 ~9*10^19
//constexpr ll MOD = 998244353;
constexpr ll MOD = 1000000007;
const double EPS = round(1e-6);
const char en = '\n';
/*
struct Edge {
Edge(int _s, int _t, ll _cost = 1) : from(_s), to(_t), cost(_cost) {};
int from, to;
ll cost;
//ll fee;
};
*/
typedef ll Edge;
/*
struct Edge {
int id;
int from, to;
Edge() { id = from = to = -1; };
Edge(int a, int b, int c) : id(a), from(b), to(c) {};
};
*/
typedef vector<vector<Edge>> Graph;
/*
void add_edge(Graph& g, int from, int to, ll cost = 1) {
g[from].push_back(Edge(from, to, cost));
}
*/
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } else return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } else return false; }
void solve() {
ll b, c; cin >> b >> c;
ll l1 = (b - c / 2), l2 = (-b - (c - 1) / 2), r1 = (b + (c - 2) / 2), r2 = (-b + (c - 1) / 2);
if (c == 1) {
if (b == 0) cout << 1 << endl;
else cout << 2 << endl;
}
else if (c == 2) {
if (b == 0) cout << 2 << endl;
else cout << 3 << endl;
}
else if (b == 0) {
cout << r1 - l1 + 1 << endl;
}
else if (b < 0) {
if (r1 >= l2) {
cout << r2 - l1 + 1 << endl;
}
else {
cout << r1 - l1 + r2 - l2 + 2 << endl;
}
}
else {
if (r2 >= l1) {
cout << r1 - l2 + 1 << endl;
}
else {
cout << r1 - l1 + r2 - l2 + 2 << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
//rep(i,3)
solve();
} | #include<bits/stdc++.h>
using namespace std;
const int maxn = 2005;
const long long inf = 1e18+10;
int n, m;
vector<pair<long long,int> > g[maxn];
void dijkstra(int v) {
long long d[n+1];
for(int i=0; i<=n; i++) d[i] = inf;
long long ans = inf;
d[v] = 0;
priority_queue<pair<long long,int> > pq;
pq.push({0, v});
bool p[n+1];
memset(p, 0, sizeof p);
while(!pq.empty()) {
int cur = pq.top().second;
pq.pop();
if(p[cur]) continue;
p[cur] = 1;
for(int u=0; u<g[cur].size(); ++u) {
long long b = g[cur][u].first, w = g[cur][u].second;
//cout << b << " " << w << endl;
if(b==v) {
ans = min(ans, d[cur]+w);
}
else if(d[cur]+w<d[b]) {
d[b] = d[cur]+w;
pq.push({-d[b], b});
}
}
}
if(ans==inf) ans = -1;
cout << ans << " ";
}
void Run_Case() {
cin >> n >> m;
for(int i=1; i<=m; i++) {
int u, v, w; cin >> u >> v >> w;
g[u].push_back({v, w});
}
for(int i=1; i<=n; i++) {
dijkstra(i);
}
}
int main() {
Run_Case();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, a[maxn], b[maxn], perm[maxn], c[maxn];
long long ans;
map<int, vector<int>> mp;
map<int, int> id;
void add(int p, int v) {
for (; p <= n; p += p & -p) c[p] += v;
}
int query(int p) {
int s = 0;
for (; p; p -= p & -p) s += c[p];
return s;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), a[i] += i;
mp[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]), b[i] += i;
}
for (int i = 1; i <= n; i++) {
if (mp[b[i]].size() == id[b[i]]) puts("-1"), exit(0);
perm[i] = mp[b[i]][id[b[i]]++];
ans += i - 1 - query(perm[i]), add(perm[i], 1);
}
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
using ll = long long;
using pii = pair<int, int>;
int main() {
int N;
cin >> N;
vector<vector<int>> to(N);
vector<int> a(N-1), b(N-1);
rep(i,N-1) {
cin >> a[i] >> b[i];
a[i]--; b[i]--;
to[a[i]].push_back(b[i]); to[b[i]].push_back(a[i]);
}
// for(auto&x:to[0])cout<<x;cout<<endl;
vector<ll> c(N,0);
vector<pii> dag;
vector<int> depth(N,-1);
queue<int> q;
q.push(0); depth[0]=0;
while (!q.empty()) {
int x=q.front(); q.pop();
for (auto& y:to[x]) {
if (depth[y] != -1) continue;
depth[y] = depth[x] + 1;
dag.push_back(pii(x,y));
q.push(y);
}
}
// for (auto&[x,y]:dag)cout<<"["<<x<<","<<y<<"],";
int Q;
cin >> Q;
rep(i,Q) {
int t,e,x;
cin >> t >> e >> x;
e--;
int va=a[e], vb=b[e];
if (t==2) swap(va, vb);
if (depth[va]>depth[vb]) c[va] += x;
else {c[0] += x; c[vb] -= x;}
}
for (auto& [x,y]:dag) {
c[y] += c[x];
}
for (auto& x:c) printf("%ld\n",x);
}
|
#include <bits/stdc++.h>
#define ln '\n'
#define all(dat) dat.begin(), dat.end()
#define loop(i, to) for (__typeof(to) i = 0; i < to; ++i)
#define cont(i, to) for (__typeof(to) i = 1; i <= to; ++i)
#define circ(i, fm, to) for (__typeof(to) i = fm; i <= to; ++i)
#define foreach(i, dat) for (__typeof(dat.begin()) i = dat.begin(); i != dat.end(); ++i)
typedef long long num;
using namespace std;
const int nsz = 74;
const int hsz = int(1e7) + 39, esz = 2e6;
bitset<nsz> g[nsz + 5];
int vis[nsz + 5], pw[nsz + 5];
num n, fm, to, ans = 1, a[nsz + 5];
struct hash_table {
int sz, hd[hsz + 5];
struct node {
int nxt;
bitset<nsz> w;
node() {}
node(int nxt, bitset<nsz> w): nxt(nxt), w(w) {}
} e[esz + 5];
int inline to_key(const bitset<nsz> &w) {
int u = 0;
cont (i, n) u = (u * 2 + w[i]) % hsz;
return u;
}
void inline ins(const bitset<nsz> &w, int u) {
e[++sz] = node(hd[u], w), hd[u] = sz;
}
bool inline qry(const bitset<nsz> &w, int u) {
for (int i = hd[u]; i; i = e[i].nxt) {
if (e[i].w == w) return 1;
}
return 0;
}
};
hash_table dat;
num gcd(num a, num b) {
return !b ? a : gcd(b, a % b);
}
void bfs(int s, int &sz, int *nd) {
static int q[nsz + 5];
int ql = 0, qr = 0;
for (q[qr++] = s, vis[s] = s; ql != qr;) {
int u = q[ql++];
nd[sz++] = u;
cont (v, n) if (g[u][v] && !vis[v]) q[qr++] = v, vis[v] = s;
}
}
num inline calc(int s) {
static int nd[nsz + 5], d[esz + 5];
static bitset<nsz> q[esz + 5], p[esz + 5];
int sz = 0, ql = 0, qr = 1, cnt = 0;
bfs(s, sz, nd);
if (sz == 1) return 2;
for (; ql != qr; ++cnt) {
bitset<nsz> cur = q[ql], ban = p[ql], nban;
int key = d[ql]; ++ql;
loop (i, sz) if (!ban[nd[i]]) {
int v = nd[i], nkey = (key + pw[v]) % hsz;
cur[v] = 1, nban = ban | g[v];
if (!dat.qry(cur, nkey)) {
q[qr] = cur, p[qr] = nban, d[qr] = nkey; ++qr;
dat.ins(cur, nkey);
}
cur[v] = 0;
}
}
return cnt;
}
void inline init() {
pw[0] = 1;
cont (i, n) pw[i] = pw[i - 1] * 2 % hsz;
}
int main() {
scanf("%lld%lld", &fm, &to);
n = to - fm + 1;
circ (i, fm, to) a[num(i) - fm + 1] = i;
cont (u, n) cont (v, u) g[u][v] = g[v][u] = gcd(a[u], a[v]) > 1;
init();
cont (u, n) if (!vis[u]) ans *= calc(u);
printf("%lld\n", ans);
} |
// Problem: A - Health M Death
// Contest: AtCoder - Panasonic Programming Contest (AtCoder Beginner Contest 195)
// URL: https://atcoder.jp/contests/abc195/tasks/abc195_a
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
/* Author : Atahar Islam Shihab
ICT'16th Batch,MBSTU
*/
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
#define ll long long
#define maxele(v) *max_element(v.begin(),v.end())
#define minele(v) *min_element(v.begin(),v.end())
#define deb(x) cout << #x << " -> " << x << endl
#define deb2(x, y) cout << #x << " -> " << x << " || " << #y << " -> " << y << endl
#define fast (ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0))
#define all(v) v.begin(),v.end()
#define sz(x) x.size();
#define clr(x) memset(x, 0, sizeof(x))
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
const int mxn = 100005;
int main()
{
fast;
int tc ;
int n,m;
cin >> n >> m;
cout << (m%n==0?"Yes\n":"No\n");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define Rep(i,n) for(int i=0;i<=(int)n;i++)
const ll mod = 1e9+7 ;
const ll INF = 1e18 ;
ll gcd(long long a,long long b){if(b==0) return a ; return gcd(b,a%b) ;}
ll lcm(long long a,long long b){return a/gcd(a,b)*b ;}
int main(){
ll t, n;
cin >> t >> n;
vector<bool> a(100 + t,true);
rep(i,100) a.at(i * (100 + t) /100) = false;
vector<int> b;
rep(i,100 + t) if(a.at(i)) b.push_back(i);
ll count = n % b.size() - 1;
if(count == -1) {
cout << (n / b.size() - 1) * (100 + t) + b.at(b.size() - 1)<< endl;
return 0;
}
cout << (n / b.size()) * (100 + t) + b.at(count) << 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;
#define mp make_pair
#define pb(x) push_back(x)
#define vll vector<long long>
#define pll pair<long long, long long>
#define mll map<long long, long long>
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define gcd __gcd
#define clr(x) memset(x, 0, sizeof(x))
#define mod 1000000007LL
#define mod2 998244353LL
#define INF 1e18
typedef long long ll;
typedef long double ld;
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> o_tree;
void solve()
{
ll n,k;
cin>>n>>k;
vector<vll> a(n,vll(n));
ll i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cin>>a[i][j];
}
}
function<bool(ll)> good = [&](ll x)
{
vector<vll> dp(n,vll(n,0));
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(a[i][j] <= x)dp[i][j] = 1;
}
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i>0&&j>0)dp[i][j]-=dp[i-1][j-1];
if(i>0)dp[i][j]+=dp[i-1][j];
if(j>0)dp[i][j]+=dp[i][j-1];
}
}
for(i=0;i+k-1<n;i++)
{
for(j=0;j+k-1<n;j++)
{
ll sx = i,sy = j;
ll ex = i+k-1,ey = j+k-1;
ll count = dp[ex][ey];
if(sx > 0)count-=dp[sx-1][ey];
if(sy > 0)count-=dp[ex][sy-1];
if(sx > 0 && sy > 0)count+=dp[sx-1][sy-1];
if(count >= (k*k+1)/2 )return true;
}
}
return false;
};
ll l = 0,r = 1e10;
ll fans = -1;
while(l<=r)
{
ll mid = l+(r-l)/2;
if(good(mid))
{
fans = mid;
r = mid-1;
}
else{
l = mid+1;
}
}
cout<<fans<<"\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt","r" ))
{
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
cout<<setprecision(20);
ll t=1;
// cin>>t;
while(t--)
{
solve();
}
return 0;
} |
#include <bits/stdc++.h>
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define ll long long
#define pb push_back
using namespace std;
int main()
{
int n;
cin>>n;
int data[n];
for (int i=0;i<n;i++) {
cin>>data[i];
}
int ans = 2;
int maks = 0;
for (int i=2; i<=1000; i++) {
int cnt=0;
for (int j=0; j<n; j++) {
if (data[j] % i == 0) cnt++;
}
if (cnt >= maks) {
maks = cnt;
ans = i;
}
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef tabr
#include "library/debug.cpp"
#else
#define debug(...)
#endif
template <long long mod>
struct modular {
long long value;
modular(long long x = 0) {
value = x % mod;
if (value < 0) value += mod;
}
modular& operator+=(const modular& other) {
if ((value += other.value) >= mod) value -= mod;
return *this;
}
modular& operator-=(const modular& other) {
if ((value -= other.value) < 0) value += mod;
return *this;
}
modular& operator*=(const modular& other) {
value = value * other.value % mod;
return *this;
}
modular& operator/=(const modular& other) {
long long a = 0, b = 1, c = other.value, m = mod;
while (c != 0) {
long long t = m / c;
m -= t * c;
swap(c, m);
a -= t * b;
swap(a, b);
}
a %= mod;
if (a < 0) a += mod;
value = value * a % mod;
return *this;
}
modular operator+(const modular& rhs) const { return modular(*this) += rhs; }
modular operator-(const modular& rhs) const { return modular(*this) -= rhs; }
modular operator*(const modular& rhs) const { return modular(*this) *= rhs; }
modular operator/(const modular& rhs) const { return modular(*this) /= rhs; }
modular& operator++() { return *this += 1; }
modular& operator--() { return *this -= 1; }
modular operator++(int) {
modular res(*this);
*this += 1;
return res;
}
modular operator--(int) {
modular res(*this);
*this -= 1;
return res;
}
modular operator-() const { return modular(-value); }
bool operator==(const modular& rhs) const { return value == rhs.value; }
bool operator!=(const modular& rhs) const { return value != rhs.value; }
bool operator<(const modular& rhs) const { return value < rhs.value; }
};
template <long long mod>
string to_string(const modular<mod>& x) {
return to_string(x.value);
}
template <long long mod>
ostream& operator<<(ostream& stream, const modular<mod>& x) {
return stream << x.value;
}
template <long long mod>
istream& operator>>(istream& stream, modular<mod>& x) {
stream >> x.value;
x.value %= mod;
if (x.value < 0) x.value += mod;
return stream;
}
constexpr long long mod = 998244353LL;
using mint = modular<mod>;
mint power(mint a, long long n) {
mint res = 1;
while (n > 0) {
if (n & 1) {
res *= a;
}
a *= a;
n >>= 1;
}
return res;
}
vector<mint> fact(1, 1);
vector<mint> finv(1, 1);
mint C(int n, int k) {
if (n < k || k < 0) {
return mint(0);
}
while ((int) fact.size() < n + 1) {
fact.emplace_back(fact.back() * (int) fact.size());
finv.emplace_back(mint(1) / fact.back());
}
return fact[n] * finv[k] * finv[n - k];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int m = accumulate(a.begin(), a.end(), 0);
if (m % 2 == 1) {
cout << 0 << '\n';
return 0;
}
m /= 2;
vector<vector<mint>> dp(n + 1, vector<mint>(m + 1));
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i; j >= 0; j--) {
for (int k = 0; k + a[i] <= m; k++) {
dp[j + 1][k + a[i]] += dp[j][k];
}
}
}
mint ans = 0;
C(n, 0);
for (int i = 1; i < n; i++) {
ans += dp[i][m] * fact[i] * fact[n - i];
}
cout << ans << '\n';
return 0;
} |
/*
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <map>
*/
#include <bits/stdc++.h>
#define rep(i,cc,n) for(int i=cc;i<=n;++i)
#define drep(i,cc,n) for(int i=cc;i>=n;--i)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const long long INF = 1LL <<60;
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (b==0) return a;
else return gcd(b, a%b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
ll choose2(ll n){
return n*(n-1)/2;
}
int main(){
ll n,x;
cin >> n >> x;
string s;
cin >> s;
rep(i,0,n-1){
if(s[i] == 'x'){
if(x > 0){
x--;
}
}
else x++;
}
cout << x << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<ll mod>
struct Mint {
ll x;
Mint(ll x = 0) : x((x %= mod) < 0 ? x + mod : x) { }
Mint& operator+=(Mint rhs) { return (x += rhs.x) >= mod ? x -= mod : 0, *this; }
Mint& operator-=(Mint rhs) { return (x -= rhs.x) < 0 ? x += mod : 0, *this; }
Mint& operator*=(Mint rhs) { return (x *= rhs.x) %= mod, *this; }
Mint& operator/=(Mint rhs) { return *this *= rhs.power(-1); }
Mint power(ll p) const {
p %= mod - 1;
if (p < 0) p += mod - 1;
Mint res = 1;
for (Mint y = *this; p; p >>= 1, y *= y) if (p & 1) res *= y;
return res;
}
bool operator==(Mint rhs) const { return x == rhs.x; }
bool operator<(Mint rhs) const { return x < rhs.x; }
friend Mint operator+(Mint lhs, Mint rhs) { return lhs += rhs; }
friend Mint operator-(Mint lhs, Mint rhs) { return lhs -= rhs; }
friend Mint operator*(Mint lhs, Mint rhs) { return lhs *= rhs; }
friend Mint operator/(Mint lhs, Mint rhs) { return lhs /= rhs; }
friend ostream& operator<<(ostream& out, Mint a) { return out << a.x; }
friend istream& operator>>(istream& in, Mint& a) {
ll x;
in >> x;
a = Mint(x);
return in;
}
};
constexpr ll mod = 998244353;
using mint = Mint<mod>;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
const int Wmax = 100;
vector<vector<mint>> dp(N + 1, vector<mint>(N * Wmax + 1));
dp[0][0] = 1;
int sum = 0;
for (int i = 0; i < N; ++i) {
int W;
cin >> W;
for (int k = N - 1; k >= 0; --k) {
for (int x = N * Wmax - W; x >= 0; --x) {
dp[k + 1][x + W] += dp[k][x];
}
}
sum += W;
}
mint ans = 0;
if (sum % 2 == 0) {
vector<mint> f(N + 1, 1);
for (int x = 1; x <= N; ++x) {
f[x] = x * f[x - 1];
}
for (int k = 1; k <= N; ++k) {
ans += dp[k][sum / 2] * f[k] * f[N - k];
}
}
cout << ans << endl;
exit(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;}
int primes[] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71};
ll dp[80][1<<20];
//-------------------------------------------------
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
ll A,B; cin>>A>>B;
ll N = B-A+1;
debug(N);
vll v(N);
rep(i,N){
rep(j,20){
if ((A+i)%primes[j]==0){
v[i]|=1<<j;
}
}
}
// rep(i,N){
// rep(j,20)if(v[i]>>j&1){
// cout<<1<<" ";
// }else{
// cout<<0<<" ";
// }
// cout<<endl;
// }
dp[0][0]=1;
rep(i,N)rep(j,1<<20){
dp[i+1][j]+=dp[i][j];
if ((j&v[i])==0){
dp[i+1][j|v[i]]+=dp[i][j];
}
}
ll ans=0;
rep(j,1<<20){
ans+=dp[N][j];
}
cout<<ans<<"\n";
return 0;
}
| #include <bits/stdc++.h>
//#pragma GCC optimize(2)
using namespace std;
#define int long long
typedef long long LL;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int inf = 1e18;
const int mod = 998244353;
//const int mod = 1e9 + 7;
const int maxn = 2e5 + 10;
const int N = 25e5 + 100;
int dp[1<<20];
int p[20]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71};
void solve() {
int a,b;
cin>>a>>b;
dp[0]=1;
for (int i = a; i <=b; ++i) {
int res=0;
for (int j = 0; j < 20; ++j) {
if (i%p[j]==0) res|=1<<j;
}
for (int j = 0; j < 1 << 20; ++j) {
if (!(res&j)){
dp[j|res]+=dp[j];
}
}
}
int ans=0;
for (int k = 0; k < 1 << 20; ++k) {
ans+=dp[k];
}
cout<<ans<<"\n";
}
signed main() {
// ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int _ = 1;
// cin >> _;
while (_--) {
solve();
}
return 0;
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int T;cin>>T;
for(int X=0;X<T;X++){
int L,R;cin>>L>>R;
if(L*2>R)cout<<0<<endl;
else cout<<(R-L*2+1)*(R-L*2+2)/2<<endl;
}
} | #include <bits/stdc++.h>
#define ll long long int
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define vi vector<int>
#define vvi vector<vector<int> >
#define mii map<int,int>
#define pb push_back
#define pii pair<int,int>
#define mkp make_pair
#define scan(a,n) for(int i =0 ; i<n ; i++) cin>>a[i]
#define print(a,n) for(int i = 0 ; i < n ; i++) cout<<a[i]<<' '
#define mem(a,v) memset(a,v,sizeof(a))
#define loop(i,n) for (int i = 0; i < n; i++)
#define loop1(i,n) for (int i = 1; i < n; i++)
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define PRECISION std::cout.unsetf ( std::ios::floatfield );std::cout.precision(15)
#define PI 3.14159265
#define endl '\n'
using namespace std;
int mod = 1000000007;
int m_inf = INT_MIN;
void init_code()
{
fast;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
}
void solve()
{
ll l,r;
cin>>l>>r;
ll minm=l,maxm=r-l;
if(minm>maxm)
cout<<0<<endl;
else
{
ll a=r-maxm-l+1;
ll b=r-minm-l+1;
ll ans=(a+b)*(b-a+1)/2;
cout<<ans<<endl;
}
}
int main()
{
init_code();
int t=1;
cin>>t;
while(t--)
{
solve();
}
} |
#include <bits/stdc++.h>
#define repd(i, a, b) for (ll i = (a); i < (b); i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define rep(i, n) repd(i, 0, n)
using namespace std;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
const ul mod = 1000000007;
struct edge {
ll to, cost;
edge(ll to = 0, ll cost = 0) : to(to), cost(cost) {}
};
// p : (cost, position)
using p = pair<ll, ll>;
void djikstra(vector<ll> &d, vector<vector<edge>> &g, ll start) {
ll inf = 1LL << 60;
fill(d.begin(), d.end(), inf);
d[start] = 0;
priority_queue<p, vector<p>, greater<p>> q;
q.push(p(0, start));
while (!q.empty()) {
p now = q.top();
q.pop();
ll now_cost = now.first, now_position = now.second;
if (d[now_position] < now_cost)
continue;
for (edge e : g[now_position]) {
if (d[e.to] > d[now_position] + e.cost) {
d[e.to] = d[now_position] + e.cost;
q.push(p(d[e.to], e.to));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
vector<ll> w(n);
rep(i, n) { cin >> w[i]; }
vector<p> vl(m);
rep(i, m) {
ll l, v;
cin >> l >> v;
vl[i] = p(v, l);
}
sort(vl.begin(), vl.end(), [](const p &a, const p &b) {
if (a.first == b.first) {
return a.second > b.second;
}
return a.first < b.first;
});
ll l_max = vl[0].second;
rep(i, m) {
l_max = max(l_max, vl[i].second);
vl[i].second = l_max;
}
ll ans = mod * mod;
sort(w.begin(), w.end());
if (w[n - 1] > vl[0].first) {
cout << -1 << endl;
return 0;
}
do {
vector<ll> sum(n + 1);
sum[0] = 0;
rep(i, n) { sum[i + 1] = sum[i] + w[i]; }
vector<ll> d(n);
vector<vector<edge>> g(n);
rep(i, n) {
repd(j, i + 1, n) {
ll weight = sum[j + 1] - sum[i];
if (weight < vl[0].first) {
g[i].push_back(edge(j, 0));
continue;
}
if (weight == vl[0].first) {
g[i].push_back(edge(j, 0));
continue;
}
ll length = 0;
auto iter_lower =
upper_bound(vl.begin(), vl.end(), p(weight, 0));
length = (iter_lower - 1)->second;
g[i].push_back(edge(j, -length));
}
}
djikstra(d, g, 0);
ll temp = -d[n - 1];
ans = min(ans, temp);
} while (next_permutation(w.begin(), w.end()));
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define st first
#define nd second
#define pii pair<int,int>
#define mp make_pair
#define pll pair<long long,long long>
using namespace std;
const int nax = 105;
int n;
char s[nax];
int a[nax];
vector<vector<int> > cols;
void solve(){
cin >> n;
string x; cin >> x;
for(int i=1;i<=n;i++) s[i] = x[i - 1];
for(int i=0;i<=n;i++) cin >> a[i];
int ile = 1e9;
for(int i=1;i<=n;i++){
ile = min(ile, abs(a[i] - a[i - 1]));
}
vector<int> fi;
for(int i=1;i<=ile;i++){
fi.pb(a[0] / ile);
if(i <= a[0] % ile) fi.back()++;
}
cols.pb(fi);
for(int i=1;i<=n;i++){
if(s[i] == '<'){
// jestesmy wieksi
vector<int> last = cols.back();
vector<int> now;
int rest = a[i];
for(int j=1;j<=ile;j++){
now.pb(last[j - 1] + 1);
rest -= (last[j - 1] + 1);
}
int prefix = -1;
if(now[0] == now[ile - 1]) prefix = ile - 1;
else{
for(int j=1;j<ile;j++){
if(now[j] < now[j - 1]){
prefix = j - 1;
break;
}
}
}
while(rest--){
prefix++;
if(prefix == ile) prefix = 0;
now[prefix]++;
}
cols.pb(now);
}
else{
vector<int> last = cols.back();
vector<int> now;
int rest = a[i];
for(int j=1;j<=ile;j++){
now.pb(last[j - 1] - 1);
rest -= (last[j - 1] - 1);
}
int prefix = -1;
if(now[0] == now[ile - 1]) prefix = ile - 1;
else{
for(int j=1;j<ile;j++){
if(now[j] < now[j - 1]){
prefix = j - 1;
break;
}
}
}
while(rest < 0){
rest++;
now[prefix]--;
prefix--;
if(prefix == -1) prefix = ile - 1;
}
cols.pb(now);
}
}
cout << ile <<"\n";
for(int j=0;j<ile;j++){
for(int i=0;i<=n;i++){
cout << cols[i][j] <<" " ;
}
cout << "\n";
}
}
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
int tt = 1;
// cin >> tt;
while(tt--) solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
double a, b, c;
cin >> a >> b >> c;
double x = ceil((b * c) / a);
cout << (int)x - 1;
}
| #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define fori(a) for(auto i : a )
#define all(a) begin(a), end(a)
#define set(a,b) memset(a,b,sizeof(a))
#define sz(a) a.size()
double pi=acos(-1);
#define ll long long
#define ull unsigned long long
#define pb push_back
#define PF push_front //deque
// #define mp make_pair
#define pq priority_queue
const ll mod=1000000007;
#define f first
#define s second
#define pii pair< ll, ll >
#define vi vector<int>
#define vpii vector<pii>
#define debug(v) for(auto i:v) cout<<i<<" ";
#define tc int t; cin >> t; while(t--)
// using namespace boost::multiprecision;
using namespace std;
void optimizeIO(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int N=1000005;
ll fact[N],invfact[N];
ll power(ll x,ll y){
if(y<=0) return 1LL;
ll z=power(x,y/2);
if(y%2) return (((z*z)%mod)*x)%mod;
return (z*z)%mod;
}
void pre(){
fact[0]=invfact[0]=invfact[1]=fact[1]=1;
rep(i,2,N) fact[i]=(i*fact[i-1])%mod;
rep(i,2,N) invfact[i]=(invfact[i-1]*power(i,mod-2))%mod;
}
ll nCr(ll n,ll k){ return (((fact[n]*invfact[n-k])%mod)*invfact[k])%mod; }
const int N1=1e6+1;
vector<int> isprime(N1,1),prime;
void seive(){
rep(i,2,sqrt(N1)+1){
if(isprime[i]){
for(int j=i*i;j<N1;j+=i) isprime[j]=0;
prime.pb(i);
}
}
rep(i,sqrt(N1)+1,N1) if(isprime[i]) prime.pb(i);
}
struct dsu {
vector<int> par, rank;
dsu(int n): par(n+1), rank(n+1) {
for (int i = 0; i <= n; i++) {
par[i] = i;
rank[i]= 1;
}
}
int root(int a) {
if (a == par[a]) return a;
return par[a] = root(par[a]);
}
void merge(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
if (rank[a] > rank[b]) swap(a, b);
par[b] = a;
}
set<int> parent(int n){
set<int> s;
for(int i=1;i<=n;i++){
s.insert(root(i));
}
return s;
}
};
void solve(){
int y,x,z;
cin>>x>>y>>z;
cout<<(y*z-1)/x<<endl;
}
int main(){
optimizeIO();
int r=1;
{solve();}
}
|
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
//#pragma GCC optimize ("-O3")
using namespace std;
void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
int mod = 1000000007;
int add(int x, int y) { return (x += y) >= mod ? x - mod : x; }
template<class... T> int add(int x, T... y) { return add(x, add(y...)); }
int mul(int x, int y) { return 1LL * x * y % mod; }
template<class... T> int mul(int x, T... y) { return mul(x, mul(y...)); }
int sub(int x, int y) { return add(x, mod - y); }
int modpow(int a, long long b) {
int ret = 1; while (b > 0) {
if (b & 1) ret = 1LL * ret * a % mod; a = 1LL * a * a % mod; b >>= 1;
} return ret;
}
int modinv(int a) { return modpow(a, mod - 2); }
typedef vector<int> Vec;
typedef vector<Vec> Mat;
Vec mulMatVec(Mat a, Vec b)
{
int n = b.size(); Vec ret(n, 0);
rep(i, 0, n) rep(j, 0, n) ret[i] = add(ret[i], mul(a[i][j], b[j]));
return ret;
}
Mat mulMatMat(Mat a, Mat b)
{
int n = a.size(); Mat ret(n, Vec(n, 0));
rep(i, 0, n) rep(j, 0, n) rep(k, 0, n) ret[i][j] = add(ret[i][j], mul(a[i][k], b[k][j]));
return ret;
}
Mat fastpow(Mat x, ll n)
{
Mat ret(x.size(), Vec(x.size(), 0));
rep(i, 0, x.size()) ret[i][i] = 1;
while (0 < n) { if ((n % 2) == 0) { x = mulMatMat(x, x); n >>= 1; } else { ret = mulMatMat(ret, x); --n; } }
return ret;
}
void printVec(Vec a) { cout << "[\t"; rep(i, 0, a.size()) cout << a[i] << "\t"; cout << "]" << endl; }
void printMat(Mat a) { rep(i, 0, a.size()) printVec(a[i]); }
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i @hamayanhamayan0
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
int N, M, K, A[101];
int X[10101], Y[10101];
int cnt[101];
bool E[101][101];
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> N >> M >> K;
rep(i, 0, N) cin >> A[i];
rep(i, 0, M) cin >> X[i] >> Y[i], X[i]--, Y[i]--;
Mat Ma(N, Vec(N));
rep(i, 0, M) {
cnt[X[i]]--;
cnt[Y[i]]--;
E[X[i]][Y[i]] = E[Y[i]][X[i]] = true;
}
rep(to, 0, N) {
int cnt = M;
rep(from, 0, N) if (to != from) {
if (E[to][from]) {
Ma[to][to] = add(Ma[to][to], mul(modinv(M), modinv(2)));
Ma[to][from] = add(Ma[to][from], mul(modinv(M), modinv(2)));
cnt--;
}
}
Ma[to][to] = add(Ma[to][to], mul(cnt, modinv(M)));
}
Vec v(N, 0);
rep(i, 0, N) v[i] = A[i];
Ma = fastpow(Ma, K);
v = mulMatVec(Ma, v);
rep(i, 0, N) cout << v[i] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
typedef vector<int> VI;
typedef long long ll;
typedef pair<int,int> PII;
typedef double db;
mt19937 mrand(random_device{}());
const ll mod=1000000007;
int rnd(int x) { return mrand() % x;}
ll powmod(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;}
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
// head
const int N = 110;
struct Mat {
int t[N][N];
};
int n, m, k;
int a[N], ans[N], sz[N];
Mat mul(Mat a, Mat b) {
Mat c;
for(int i=1; i<=n; i++) {
for(int j=1; j<=n; j++) {
c.t[i][j] = 0;
for(int k=1; k<=n; k++) {
c.t[i][j] = (c.t[i][j]+(ll)a.t[i][k]*b.t[k][j])%mod;
}
}
}
return c;
}
Mat qpow(Mat a, int b) {
Mat res;
for(int i=1; i<=n; i++) {
for(int j=1; j<=n; j++) {
if(i==j)
res.t[i][j] = 1;
else
res.t[i][j] = 0;
}
}
while(b) {
if(b&1)
res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for(int i=1; i<=n; i++)
scanf("%d", &a[i]);
int inv = powmod(2*m, mod-2);
Mat A;
memset(A.t, 0, sizeof(A.t));
for(int i=1; i<=m; i++) {
int u, v;
scanf("%d%d", &u, &v);
sz[u]++; sz[v]++;
A.t[u][v] = A.t[v][u] = inv;
}
for(int i=1; i<=n; i++)
A.t[i][i] = (ll)(m*2-sz[i])*inv%mod;
// for(int i=1; i<=n; i++) {
// for(int j=1; j<=n; j++) {
// printf("%d ", A.t[i][j]);
// }
// printf("\n");
// }
A = qpow(A, k);
// for(int i=1; i<=n; i++) {
// for(int j=1; j<=n; j++) {
// printf("%d ", A.t[i][j]);
// }
// printf("\n");
// }
// printf("val=%lld\n", powmod(2, mod-2));
for(int i=1; i<=n; i++) {
for(int j=1; j<=n; j++) {
ans[j] = (ans[j]+(ll)A.t[i][j]*a[i])%mod;
}
}
for(int i=1; i<=n; i++)
printf("%d\n", ans[i]);
// printf("\n");
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N=1e5+2;
int n,m,cn[2];
long long ans;
int main()
{
scanf("%d%d",&n,&m);
for(int x;n;--n)
{
int val=0;
for(int j=m-1;~j;--j)
{
scanf("%1d",&x);
val^=x;
}
ans+=cn[!val];
++cn[val];
}
printf("%lld",ans);
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define Rrep(i,n) for (ll i = n - 1; i >= 0;i--)
#define ll long long int
#define INF 1000000007
#define llINF 1000000000000000007
#define v(i) vector<i>
#define vv(i) vector<vector<i>>
// int num = atoi(string.c_str()); 文字列の整数変換
// sort(a,a+n,greater<int>()); 昇順ソートif(ans>llINF/a&&a !=0)return 0;
int digit(ll n){int ans=0;while(n>0){n /= 10; ans++;}return ans;}//桁数
ll _pow(ll a,ll b){ll ans = 1;rep(i,b){ans = a * ans;}return ans;}//階乗
ll _modpow(ll a, ll n, ll mod) {ll res = 1;while (n > 0) {if (n & 1){ res = res * a % mod;}a = a * a % mod;n >>= 1;}return res;}
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 * b / gcd(a, b);} //最小公倍数
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 cmb(ll n, ll r){ll X = 1;for(int i = n; i >= n - r + 1;i--){X = X * i % INF;}ll Y = 1;for(int i = r;i > 0 ;i--){Y = Y * i % INF;}Y = _modpow(Y,(ll)INF-2,(ll)INF);return X * Y % INF;}
int main(){
ll n;cin>>n;
int M;cin>>M;
string s[n];
ll g = 0,k = 0;
rep(i,n){
cin>>s[i];
ll cnt = 0;
rep(j,M){
if(s[i][j] == '1')cnt++;
}
if(cnt%2 == 0)g++;
else k++;
}
cout<<g*k<<endl;
return 0;
}
|
Subsets and Splits