code_file1
stringlengths 87
4k
| code_file2
stringlengths 85
4k
|
|---|---|
#include<bits/stdc++.h>
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i, 0, n)
#define all(x) (x).begin(),(x).end()
const int INF = 1e9+1;
using namespace std;
using ll = long long;
using p = pair<int, int>;
using v = vector<int>;
int main(){
int N, M, T;
cin >> N >> M >> T;
v A(M), B(M);
int n = N;
int t = 0;
REP(i, M) cin >> A[i] >> B[i];
REP(i, M) {
n -= (A[i]-t);
if (n <= 0) {
cout << "No" << endl;
return 0;
}
n = min(N, n+(B[i]-A[i]));
t = B[i];
}
n -= T-t;
if (n <= 0) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | /*
ID: alec3
LANG: C++14
PROG:
/*
*/
#include <bits/stdc++.h>
#define check(x) cout<<(#x)<<": "<<x<<" " << endl;
#define io ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ss second
#define ff first
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define ld long double
#define all(c) (c).begin(), (c).end()
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define mp make_pair
#define line cout << "--------------" << endl;
typedef long long ll;
typedef unsigned long long ull;
int pct(int x) { return __builtin_popcount(x); }
using namespace std;
void setIO(string name) {
freopen((name+".in").c_str(),"r",stdin);
freopen((name+".out").c_str(),"w",stdout);
ios_base::sync_with_stdio(0);
}
int main()
{
io;
int n, x;
cin >> n >> x;
string s; cin >> s;
ll points = x;
for (int i = 0; i < n; i++){
if (s[i] == 'x'){
if (points > 0)
points --;
}
else
points ++;
}
cout << points << endl;
return 0;
}
|
#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;
}
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;
}
| #include<bits/stdc++.h>
////////////////////////////dbug/////////////////////////////////////////////////////////////////////////
#define dbug(a) cerr<<"==> "<<a<<endl;
#define dbug_ok cerr<<"==> ok"<<endl;
#define dbug_2d(a,n,m) {cerr<<"********"<<endl;for(int i=0;i<n;i++){for(int j=0;j<m;j++)cerr<<a[i][j]<<" "; cerr<<endl;}cerr<<"********"<<endl; }
#define dbug_1d(a,n) {cerr<<"********"<<endl;for(int i=0;i<n;i++)cerr<<a[i]<<" "; cerr<<endl;cerr<<"********"<<endl;}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////fill//////////////////////////////////////////////////////////////////////////
#define fill(a,n) memset(a,n,sizeof(n))
#define fill_2d(a,n,m,v) {for(int i=0;i<n;i++)for(int j=0;j<m;j++)a[i][j]=v;}
#define fill_3d(a,n,m,l,v) {for(int i=0;i<n;i++)for(int j=0;j<m;j++)for(int k=0;k<l;k++)a[i][j][k]=v;}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////loops/////////////////////////////////////////////////////////////////////////
#define fr(i,n) for(int i=0;i<n;i++)
#define fi(i,l,r) for(int i=l;i<=r;i++)
#define frfr(i,n,j,k) for(int i=0;i<n;i++)for(int j=0;j<k;j++)
#define fifi(i,l,r,j,l1,r1) for(int i=l;i<=r;i++)for(int j=l1;j<=r1;j++)
/////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////types////////////////////////////////////////////////////////////////////////
#define ll long long
#define pp pair<int,int>
#define pll pair<ll,ll>
#define T1 first
#define T2 second
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////print///////////////////////////////////////////////////////////////////////
#define _YES puts("YES")
#define _Yes puts("Yes")
#define _yes puts("yes")
#define _no puts("no")
#define _No puts("No")
#define _NO puts("NO")
/////////////////////////////////////////////////////////////////////////////////////////////////////////
using namespace std;
void solve()
{
ll c,n,t,a,b,s=0,p=0,an=1;
cin>>c>>n>>t;
s=c;
while(n--)
{cin>>a>>b;
s-=(a-p);
if(s<=0){an=0;}
s=min(s+(b-a),c);
p=b;
}
dbug(p);
dbug(s);
s-=(t-p);dbug(s);
if(s<=0){an=0;}
an?_Yes:_No;
}
int main()
{
cin.tie(nullptr);
ios::sync_with_stdio(false);
solve();
}
|
#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define test() int t; cin>>t; while(t--)
#define all(v) v.begin(),v.end()
#define st(v) sort(all(v))
#define stA(arr,n) sort(arr,arr+n)
#define dp(n,c) vector<vector<ll>> dp(n,vector<ll>(c,0))
#define vc(v,n,f) vector<ll> v(n,f)
#define vct(v) vector<ll> v
#define findInVec(v,key) (find(all(v),key)!=v.end())
#define findInSet(v,key) (v.find(key) != v.end())
#define findInStr(s,key) (s.find(key) != string::npos)
#define findInMap(m,key) (mp.find(key) != mp.end())
#define prt(i) cout<<i<<"\n"
#define fos(v) for(auto x:v)
#define fo(m,n,i) for(int i=m;i<n;i++)
#define Fo(m,n,i) for(int i=m;i>n;i--)
#define setbit(i) __builtin_popcount(i)
#define del(v,pos) v.erase(v.begin()+pos)
#define cnt(v,key) (count(all(v),key))
#define cnts(s,key) (s.count(key))
#define sumArr(a,s,e,sum)(accumulate(a+s,a+e,sum))
typedef long long ll;
using namespace std;
ll stringToLong(string s){stringstream raaz(s);ll x = 0;raaz >> x;return x;}
string longToString(ll k){stringstream ss;ss<<k;string s; ss>>s; return s;}
bool isPowerOfTwo(int n){if(n==0) return false; return (ceil(log2(n)) == floor(log2(n)));}
void scanArr(int *arr,int n){fo(0,n,i) cin>>arr[i];}
void printArr(int *arr,int n){fo(0,n,i) cout<<arr[i]<<" ";}
void scanVector(vector<ll> &v,int n){fo(0,n,i){int temp;cin>>temp;v.push_back(temp);}}
void printVector(vector<ll> v){fos(v) cout<<x<<" ";}
int main()
{
IOS
vc(v,3,0);
fo(0,3,i)
cin>>v[i];
st(v);
if(v[2]-v[1]==v[1]-v[0])
prt("Yes");
else
prt("No");
return 0;
} | #include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <numeric>
#include <list>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <tuple>
#include <deque>
#include <complex>
#include <bitset>
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<long long, long long> pll;
typedef vector<pll> vpll;
typedef long double ld;
typedef vector<ld> vld;
typedef vector<bool> vb;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, n) for (ll i = 1; i <= (n); i++)
#define rrep(i, n) for (ll i = (n) - 1; i >= 0; i--)
#define rreps(i, n) for (ll i = (n); i >= 1; i--)
#define all(v) (v).begin(), (v).end()
template <class T> void chmin(T& a, T b) { a = min(a, b);}
template <class T> void chmax(T& a, T b) { a = max(a, b);}
constexpr int INF = 1 << 30;
constexpr ll INFL = 1LL << 60;
constexpr ll MOD = 1000000007;
constexpr ld EPS = 1e-12;
ld PI = acos(-1.0);
void solve() {
ll n, m;
cin >> n >> m;
if(n == 1) {
if(m == 0) {
cout << "1 2" << endl;
return;
}
else {
cout << -1 << endl;
return;
}
}
if(m < 0 || m >= n - 1) {
cout << -1 << endl;
return;
}
vll l(n), r(n);
for(int i = 0; i < m + 1; ++i) {
l[i] = 2 * i + 2;
r[i] = l[i] + 1;
}
l[m + 1] = 1;
r[m + 1] = r[m] + 1;
for(int i = m + 2; i < n; ++i) {
l[i] = 2 * (i - m - 2) + r[m + 1] + 1;
r[i] = l[i] + 1;
}
rep(i, n) {
cout << l[i] << ' ' << r[i] << endl;
}
return;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
solve();
} |
#include<fstream>
#include<iostream>
#include<sstream>
#include<vector>
#include<stack>
#include<string>
#include<algorithm>
#include<cmath>
#include<map>
#include<queue>
#include<tuple>
#include<iomanip>
#include<stdio.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using graph = vector<vector<int>>;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
using ll = long long;
using P = pair<int, int>;
int h,w;
bool used[16][16];
ll dfs(int i,int j,int a,int b){
if(a<0||b<0) return 0;
if(j==w){
j = 0;i ++;
}
if(i==h) return 1;
if(used[i][j]) return dfs(i,j+1,a,b);
used[i][j] = true;
ll res = 0;
res += dfs(i,j+1,a,b-1);
if(j+1<w&&!used[i][j+1]){
used[i][j+1] = true;
res += dfs(i,j+1,a-1,b);
used[i][j+1] = false;
}
if(i+1<h&&!used[i+1][j]){
used[i+1][j] = true;
res += dfs(i,j+1,a-1,b);
used[i+1][j] = false;
}
used[i][j] = false;
return res;
}
int main(){
cin >> h >> w;
int a,b;cin >> a >> b;
cout << dfs(0,0,a,b) <<endl;
}
| #include <bits/stdc++.h>
using namespace std;
#include<limits>
#define endl '\n'
#define ll long long int
#define ld long double
#define fl float
#define vi vector<int>
#define vll vector<ll>
#define sll set<ll>
#define null NULL
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define infinity (ll)100000000000
#define mod (ll)1000000007
#define pb push_back
#define test ll t; cin >> t; while(t--)
#define srtv(a)sort(a.begin(),a.end())
#define srtrev(a)sort(a.begin(),a.end(),greater<int>())
#define loop(i,n)for(int i=0;i<n;i++)
#define loopx(i,x,n)for(int i=x;i<n;i++)
#define looprev(i,n)for(ll i=n-1;i>=0;i--)
#define lcm(a,b)(a*b/gcd(a,b))
#define max3(a,b,c)max(a,max(b,c))
#define min3(a,b,c)min(a,min(b,c))
#define sz(a)a.size()
#define p1(x)cout<<x<<endl
#define p2(x,y)cout<<x<<" "<<y<<endl
#define p3(x,y,z)cout<<x<<" "<<y<<" "<<z<<endl
#define p4(x,y,z,a)cout<<x<<" "<<y<<" "<<z<<" "<<a<<endl
#define pn1(x)cout<<x<<" "
#define pn2(x,y)cout<<x<<" "<<y<<" "
#define pn3(x,y,z)cout<<x<<" "<<y<<" "<<z<<" "
#define sv(a)loop(i,a.size())cin>>a[i]
#define pv(a)for(auto x:a)cout<<x<<" ";cout<<endl;
#define flush cin.ignore(numeric_limits<streamsize>::max(),'\n')
vll primefactors;vll fact;
void getPrimeFactors(ll n){primefactors.clear();for(ll i=2;i*i<=n;i++){if(n%i==0){primefactors.pb(i);while(n%i==0)n=n/i;}}if(n!=1)primefactors.pb(n);}
int binomialCoeff(int n,int k){int C[n+1][k+1];for(int i=1;i<=n;i++){for(int j=0;j<=k&&j<=i;j++){if(j==0||j==i)C[i][j]=1;else C[i][j]=(C[i-1][j-1]+C[i-1][j]);}}return C[n][k];}//nCk=n-1Ck-1+n-1Ck
ll pwr(ll base,ll exp){if(exp==0)return 1;ll x;if(exp%2==0){x=pwr(base,(exp)/2);return(x*x)%mod;}else{return(base*pwr(base,exp-1))%mod;}}
ll pwrm(ll a,ll b,ll m){a%=m;ll res=1;while(b>0){if(b&1)res=res*a%m;a=a*a%m;b>>=1;}return res;}
int gcd(int a,int b){if(b==0){return a;}return gcd(b,a%b);}
void printstack(stack<int>b){while(!b.empty()){cout<<b.top()<<" ";b.pop();}cout<<endl;}
void getFactorial(ll n){fact.pb(1);for(ll i=1;i<=n;i++)fact.pb((i*1ll*fact[i-1])%mod);}
bool isPrime(ll n){if(n<2)return false;for(ll i=2;i*i<=n;i++)if(n%i==0)return false;return true;}
int fib(int n) {double phi = (1 + sqrt(5)) / 2;return round(pow(phi, n) / sqrt(5));}
//----------------------------------------------Code below----------------------------------------------------------//
//ctrl+a+k+f
vector<vi>c(17,vi(17,0));
int coun=0;
void recursion(int h,int w,int a,int b,int i,int j)
{
if(i==h)
{
if(a==0 && b==0)
{
coun++;
}
return;
}
int x=0;
if((j+1)%w==0)
{
x++;
}
if(j+1<w && c[i][j]==0 && c[i][j+1]==0 && a>0)
{
c[i][j]=1;c[i][j+1]=1;
recursion(h,w,a-1,b,i+x,(j+1)%w);
c[i][j]=0;c[i][j+1]=0;
}
if(i+1<h && c[i][j]==0 && c[i+1][j]==0 && a>0)
{
c[i+1][j]=1;c[i][j]=1;
recursion(h,w,a-1,b,i+x,(j+1)%w);
c[i+1][j]=0;c[i][j]=0;
}
if(c[i][j]==0 && b>0)
{
c[i][j]=1;
recursion(h,w,a,b-1,i+x,(j+1)%w);
c[i][j]=0;
}
recursion(h,w,a,b,i+x,(j+1)%w);
}
int main()
{
fast;
int h,w;
int a,b;
cin>>h>>w>>a>>b;
recursion(h,w,a,b,0,0);
p1(coun);
return 0;
}
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long int
#define mp(a,b) make_pair(a,b)
#define vi vector<int>
#define mii map<int,int>
#define mpi map<pair<int,int>,int>
#define msi map<string,int>
#define vp vector<pair<int,int> >
#define pb(a) push_back(a)
#define fr(i,n) for(i=0;i<n;i++)
#define rep(i,a,n) for(i=a;i<n;i++)
#define F first
#define S second
#define endl "\n"
#define Endl "\n"
#define fast std::ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define mod 1000000007
#define dom 998244353
#define sl(a) (int)a.length()
#define sz(a) (int)a.size()
#define all(a) a.begin(),a.end()
#define pii pair<int,int>
#define mini 2000000000000000000
#define time_taken 1.0 * clock() / CLOCKS_PER_SEC
//const long long INF=1e15;
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//auto dist=uniform_int_distribution<int>(0,INF);
//const long double pi = acos(-1);
//primes for hashing 937, 1013
typedef tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
template<typename T, typename U> static inline void amin(T &x, U y)
{
if (y < x)
x = y;
}
template<typename T, typename U> static inline void amax(T &x, U y)
{
if (x < y)
x = y;
}
void shikhar7s(int cas)
{
int n,i;
cin>>n;
vp v;
int x,y;
fr(i,n)
{
cin>>x>>y;
v.pb(mp(y,x));
}
sort(all(v));
vi a,b,aa,ba;
i=0;
int l=mini,r=-mini;
while(i<n&&v[i].F==v[0].F)
{
a.pb(v[i].S);
l=min(l,v[i].S);
r=max(r,v[i].S);
i++;
}
sort(all(a));
aa.resize(sz(a));
int j;
fr(j,sz(a))
{
if(l>=0)
aa[j]=2*r-a[j];
else if(a[j]>0)
aa[j]=2*(r-l)-a[j];
else if(r>0)
aa[j]=2*(r-l)+a[j];
else
aa[j]=a[j]-2*l;
}
rep(i,i,n)
{
int j=i,l=mini,r=-mini;
while(j<n&&v[j].F==v[i].F)
{
b.pb(v[j].S);
l=min(l,v[j].S);
r=max(r,v[j].S);
j++;
}
i=j-1;
sort(all(b));
ba.resize(sz(b),mini);
fr(j,sz(b))
{
int k=lower_bound(all(a),r)-a.begin();
if(k<sz(a))
ba[j]=min(ba[j],aa[k]+a[k]+b[j]-2*l);
k--;
if(k>=0)
ba[j]=min(ba[j],aa[k]+2*(r-l)+b[j]-a[k]);
k=lower_bound(all(a),l)-a.begin();
if(k<sz(a))
ba[j]=min(ba[j],aa[k]+2*(r-l)+a[k]-b[j]);
k--;
if(k>=0)
ba[j]=min(ba[j],aa[k]+2*r-a[k]-b[j]);
// cout<<b[j]<<" "<<ba[j]<<endl;
}
a=b;
aa=ba;
b.clear();
ba.clear();
}
int ans=mini;
fr(i,sz(a))
{
ans=min(ans,aa[i]+abs(a[i]));
}
cout<<ans;
}
signed main()
{
fast;
//freopen("input.txt", "rt", stdin);
//freopen("output.txt", "wt", stdout);
int t=1;
//cin>>t;
int cas=1;
while(cas<=t)
{
//cout<<"Case #"<<cas<<": ";
shikhar7s(cas);
cas++;
}
return 0;
} | #include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<list>
#include<bitset>
#include<stack>
#include<memory>
#include<numeric>
#include <utility>
using namespace std;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
#define REP(i, n) for(int i = 0;i < (n);i++)
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/
const llint mod=998244353;
const llint inf=2.19e15;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-10;
template <class T,class U>bool chmin(T& a,U b){if(a>b){a=b;return true;}return false;}
template <class T,class U>bool chmax(T& a,U b){if(a<b){a=b;return true;}return false;}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){if(a==0){return b;}return a/gcd(a,b)*b;}
template<class T> void SO(T& ve){sort(ve.begin(),ve.end());}
template<class T> void REV(T& ve){reverse(ve.begin(),ve.end());}
template<class T>llint LBI(T in,const vector<T>&ar){return lower_bound(ar.begin(),ar.end(),in)-ar.begin();}
template<class T>llint UBI(T in,const vector<T>&ar){return upper_bound(ar.begin(),ar.end(),in)-ar.begin();}
int main(void){
cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);
int n,i,j;cin>>n;
vector<llint>xL(n+2,inf);
vector<llint>xR(n+2,-inf);
xL[0]=0;xR[0]=0;
for(i=0;i<n;i++){
llint x;int c;cin>>x>>c;
chmin(xL[c],x);
chmax(xR[c],x);
}
xL[n+1]=0;xR[n+1]=0;
llint L=0,R=0,b=0;
for(i=1;i<=n+1;i++){
if(xL[i]==inf){continue;}
llint sa=xR[i]-xL[i];
llint nL=min(L+abs(xL[b]-xR[i]),R+abs(xR[b]-xR[i]))+sa;
llint nR=min(L+abs(xL[b]-xL[i]),R+abs(xR[b]-xL[i]))+sa;
L=nL;R=nR;b=i;
}
cout<<min(L,R)<<endl;
return 0;
}
|
/*
JAI SHREE RAM
*/
#include<bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define fo(i,n) for(i=0;i<n;i++)
#define foi(i,k,n) for(i=k;i<n;i++)
#define wt long t; cin>>t; while(t--)
#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define vl vector<long>
#define vll vector<long long>
#define mii map<int,int>
#define pqi priority_queue<int>
#define pr(a) cout<<a<<" ";
#define pra(a) for(i=0;i<a.size();i++){cout<<a[i]<<" ";}
#define pry cout<<"YES\n"
#define prn cout<<"NO\n"
#define endl cout<<endl;
bool p[1000000]={0};
vl v;
void primeFacTillN(ll n)
{
p[0]=1;
p[1]=1;
// int i=0;
for(ll i=2;i<=n;i++)
{
if(!p[i])
{
for(ll j=2*i;j<=n;j+=i)
p[j]=1;
}
}
for(ll i=2;i<=n;i++)
{
if(!p[i])
v.pb(i);
}
}
//base any number
long long baseN(long long a,long long n){
if(a<n)
return a;
else{
return(a%n + 10*baseN((a/n),n));
}
}
ll binarySearch(ll arr[], ll l, ll r, ll x)
{ ll count=0;
while (l <= r) {
ll m = l + (r - l) / 2;
count++;
// Check if x is present at mid
if (arr[m] == x)
return count;
// If x greater, ignore left half
if (arr[m] < x)
l = m + 1;
// If x is smaller, ignore right half
else
r = m - 1;
}
// if we reach here, then element was
// not present
return -1;
}
ll binarySearch2(ll a[],ll l,ll h,ll k)
{
ll count=0;
while(l<=h)
{
ll mid= (l+h)>>1;
count++;
if(a[mid]>mid)
l=mid+1;
else if (a[k]<mid)
h=mid-1;
else return mid;
}
return -1;
}
ll GCD(ll A, ll B) {
if(B==0)
return A;
else
return GCD(B, A % B);
}
ll isprime(ll x)
{
ll i;
for(i=2;i*i<=x;i++)
{
if(x%i==0)
return 1;
}
return 0;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("outputhelp2.txt", "w", stdout);
#endif
ll n,i;
cin>>n;
n= pow(2,n);
vll v(n);
for(ll i=0;i<n;i++)
cin>>v[i];
vll w(n);
for(i=0;i<n;i++)
w[i]=v[i];
while(v.size()>2){
for(i=0;i<=v.size()-2;i+=2)
{
if(v[i]>v[i+1])
{v.erase(v.begin()+i+1);
i--;
}
else
{v.erase(v.begin()+i);
i--;
}
}}
ll x = *min_element(v.begin(), v.end());
for(i=0;i<n;i++)
{
if(x== w[i])
{
cout<<i+1;
break;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
int c = 1 << n;
vector<int> a(c);
for (int i = 0; i < c; i++) {
cin >> a[i];
}
map<int, int> mp;
for (int i = 0; i < c; i++) {
mp[a[i]] = i + 1;
}
while (a.size() > 2) {
vector<int> na;
for (int i = 0; i < a.size(); i += 2) {
na.push_back(max(a[i], a[i + 1]));
}
swap(a, na);
}
int ans = min(a[0], a[1]);
cout << mp[ans] << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a) for(int i = 0; i < (int) a; i++)
#define PB push_back
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define F first
#define S second
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int main(){
ios::sync_with_stdio(false); cin.tie(0);
int n; cin >> n;
int ans = 1e9+7;
FOR(i, n){
int a, b, c; cin >> a >> b >> c;
if(c > a) ans = min(ans, b);
}
if(ans == 1e9+7) cout << "-1\n";
else cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
using ll = long long;
const ll mod = 10;
int main(){
int n;
cin >> n;
vector<tuple<int,int,int>> pax(n);
for(int i = 0; i < n; i++){
int a, p, x;
cin >> a >> p >> x;
pax[i] = make_tuple(p,a,x);
}
sort(pax.begin(),pax.end());
for(int i = 0; i < n; i++){
if(get<1>(pax[i])<get<2>(pax[i])){
cout << get<0>(pax[i]) << endl;
return 0;
}
}
cout << -1 << endl;
}
|
#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);
}
ll bitree[4][225816];
int t[225816],x[225816];
ll y[225816],a[2][225816];
std::vector<ll> v;
void update(int x, ll ret, int k){
++x;
while(x<225816){
bitree[k][x] += ret;
x += (x&(-x));
}
}
ll query(int x, int k){
ll ret = 0ll;
++x;
while(x){
ret += bitree[k][x];
x -= (x&(-x));
}
return ret;
}
int main(void){
int n,m,q,i,l,r,p;
ll ans = 0ll;
std::cin >> n >> m >> q;
v.push_back(0ll);
update(0,n,0); update(0,m,1);
for(i=0; i<q; ++i){
std::cin >> t[i] >> x[i] >> y[i];
--t[i]; --x[i];
v.push_back(y[i]);
}
std::sort(v.begin(),v.end());
for(i=0; i<q; ++i){
r = (int)(std::lower_bound(v.begin(),v.end(),a[t[i]][x[i]])-v.begin());
ans -= query(r,(1^t[i]))*a[t[i]][x[i]] + query(q+1,(3^t[i]))-query(r,(3^t[i]));
update(r,-1ll,t[i]);
update(r,-a[t[i]][x[i]],t[i]+2);
a[t[i]][x[i]] = y[i];
r = (int)(std::lower_bound(v.begin(),v.end(),y[i])-v.begin());
ans += query(r,(1^t[i]))*a[t[i]][x[i]] + query(q+1,(3^t[i]))-query(r,(3^t[i]));
update(r,1ll,t[i]);
update(r,y[i],t[i]+2);
std::cout << ans << std::endl;
}
return 0;
}
| #include <iostream>
#include <cstdlib>
#include <algorithm>
#include <string>
#define MOD 1000000007
using namespace std;
int main() {
long long T; cin >> T;
for (int i = 0; i < T; i++){
long long N, A, B; cin >> N >> A >> B;
if (N < A + B){
cout << 0 << endl;
continue;
}
long long p = ((N - A - B + 1) * (N - A - B + 2) * 2) % MOD;
long long q = (N - A + 1) * (N - B + 1) % MOD;
long long ans = (p * q) % MOD;
long long r = (N - A - B + 1) * (N - A - B + 2) % MOD;
ans -= (r * r) % MOD;
ans = ((ans % MOD) + MOD) % MOD;;
cout << ans << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int> pp;
const int mxn=10000;
vector<int>visited(mxn,0);
vector<int>adj[mxn];
int prime[mxn];
int M=1e9+7;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void sieve(int ending)
{
for(int i=2;i<ending;i++)
prime[i]=1;
for(int i=2;i*i<=ending;i++)
{
if(prime[i]==1)
{
for(int j=2*i;j<=ending;j=j+i)
{
prime[j]=0;
}
}
}
prime[1]=0;
}
int ncrmodp(int num,int r)
{
vector<int>C(r+1,0);
int i,j;
C[0]=1;
for(i=1;i<=num;i++)
{
for(j=min(i,r);j>0;j--)
{
C[j]=((C[j])%M+(C[j-1])%M)%M;
}
}
return C[r];
}
int power(int x,int y)
{
int res = 1;
x = x % M;
while (y > 0)
{
if (y & 1)
res = (res*x) % M;
y = y>>1; // y = y/2
x = (x*x) % M;
}
return res;
}
void solve()
{
}
signed main()
{
boost();
int t;
cin>>t;
int ans=0;
for(int i=0;i<t;i++){
int a,b;
cin>>a>>b;
int sum1=(a-1)*(a)/2;
int sum2=b*(b+1)/2;
ans+=sum2-sum1;
}
cout<<ans<<endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
int n; cin >> n;
long long ans = 0;
while (n--) {
int l, r; cin >> l >> r;
ans += (long long) r * (r + 1) / 2 - (long long) (l - 1) * l / 2;
}
cout << ans << '\n';
return 0;
}
|
// #pragma GCC optimize(3,"Ofast","inline")
// #pragma GCC optimize(2)
// #pragma GCC optimize("-Ofast","-funroll-all-loops")
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <list>
#include <cstdlib>
#include <bitset>
#include <assert.h>
#include <time.h>
#include <iomanip>
#include <functional>
#include <unordered_map>
#include <unordered_set>
// #define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
// char buf[(1 << 21) + 1], * p1 = buf, * p2 = buf;
// #define int long long
#define lowbit(x) (x & (-x))
#define lson root << 1, l, mid
#define rson root << 1 | 1, mid + 1, r
typedef unsigned long long ull;
typedef long long ll;
typedef std::pair<int, int> pii;
typedef std::pair<ll, ll> pll;
typedef std::vector<ll> VI;
#define rg register
#define rep(i, a, n) for (int i = a; i < n; ++i)
#define SZ(x) ((int)((x).size()))
#define bug puts("BUG")
#define ALL(x) x.begin(),x.end()
const long long INF = 2e18; //0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-10;
void err(){puts("");}
template<typename T,typename... Args>void err(const T& arg,const Args&... args){
std::cout << arg << ' ';
err(args...);
}
template<typename T> void read(T &x){
x = 0;char ch = getchar();ll f = 1;
while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
read(first);
read(args...);
}
template<typename T>void chmax(T& a,T b){
if (b > a)
a = b;
}
template<typename T>void chmin(T& a,T b){
if (b < a)
a = b;
}
#ifdef LOCAL
#define dbg(x...) do{std::cout<<#x<<" -> ";err(x);}while(0)
FILE *_INPUT = freopen("input.txt", "r", stdin);
// FILE *_OUTPUT = freopen("output.txt", "w", stdout);
#else
#define dbg(x...) ;
#endif
using namespace std;
const int maxn = 2e5 + 10;
const int DEG = 20;
int fa[maxn][20];
int deep[maxn], son[maxn], len[maxn];
vector<int> G[maxn];
int lca(int u,int v)
{
if (deep[u] < deep[v])
swap(u, v);
int x = deep[u] - deep[v];
for (int i = 0; i < DEG && x; ++i)
{
if (x & 1)
u = fa[u][i];
x >>= 1;
}
if (u == v)
return u;
for (int i = 0; i < DEG; ++i)
{
if (fa[u][i] == fa[v][i])
continue;
u = fa[u][i];
v = fa[v][i];
}
return fa[u][0];
}
void dfs(int u, int pre)
{
son[u] = 0;
len[u] = 0;
deep[u] = deep[pre] + 1;
fa[u][0] = pre;
for (int i = 1; i < DEG; ++i)
{
fa[u][i] = fa[fa[u][i - 1]][i - 1];
}
for (int v : G[u])
{
if (v == pre)
continue;
dfs(v, u);
len[u] = max(len[u], len[v] + 1);
if (len[v] > len[son[u]])
son[u] = v;
}
}
ll ans[maxn];
int las = 0;
void dfs2(int u, int pre)
{
ans[u] = ans[las] + deep[u] + deep[las] - 2 * deep[lca(u, las)];
las = u;
for (int v : G[u])
{
if (v == pre || v == son[u])
continue;
dfs2(v, u);
}
if(son[u])
dfs2(son[u], u);
}
int main()
{
int n;
int u, v;
read(n);
for (int i = 1; i < n; ++i)
{
read(u, v);
G[u].emplace_back(v);
G[v].emplace_back(u);
}
dfs(1, 0);
int R = 0;
for (int i = 1; i <= n; ++i)
{
if (deep[i] > deep[R])
R = i;
}
dfs(R, 0);
dfs2(R, 0);
for (int i = 1; i <= n; ++i)
printf("%lld%c", ans[i], " \n"[i == n]);
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int n;
vector<vector<int>> e;
P longest(int v, int per){
P mx=P(0, v);
for(int u : e[v]) if(u!=per){
P p=longest(u, v);
mx=max(mx, P(p.first+1, p.second));
}
return mx;
}
vector<int> p;
void setp(int v, int per){
p[v]=per;
for(int u : e[v]) if(u!=per) setp(u, v);
}
vector<int> ans;
int c;
void setans(int v, int per){
ans[v]=c++;
if(p[v]==-1) return;
for(int u : e[v]) if(u!=per && u!=p[v]) setans(u, v);
if(p[v]!=per) setans(p[v], v);
c++;
}
int main(){
cin>>n;
e=vector<vector<int>>(n);
rep(i, n-1){
int a, b;
cin>>a>>b; a--; b--;
e[a].push_back(b);
e[b].push_back(a);
}
int a=longest(0, -1).second;
int b=longest(a, -1).second;
p=vector<int>(n, -1);
setp(a, -1);
ans=vector<int>(n);
c=1;
setans(b, -1);
for(int e : ans) cout<<e<<" ";
cout<<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>
#include <iomanip>
#define ll long long int
#define inf 1000000000000
#define mod 1000000007
// templates
#define all(v) v.begin(),v.end()
#define fi first
#define se second
#define sz(x) (int)x.size()
#define ps(x,y) fixed<<setprecision(y)<<x
#define fo(i,a,b) for(int i=a;i<b;i++)
#define ro(i,a,b) for(int i=a;i>=b;i--)
#define vi vector<int>
#define vl vector<ll>
#define sc(n) scanf("%d",&n)
#define sl(n) scanf("%lld",&n)
#define pr(n) printf("%d\n",n)
#define pl(n) printf("%lld\n",n)
#define prs(n) printf("%d ",n)
#define pls(n) printf("%lld ",n)
using namespace std;
ll GCD(ll a, ll b, ll& x, ll& y) {
if (b == 0) {
x = 1LL;
y = 0LL;
return a;
}
ll x1, y1;
ll d = GCD(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * 1LL * (a / b);
return d;
}
void solve()
{
ll n, s, k;
sl(n), sl(s), sl(k);
ll x, y;
ll gc = __gcd(n, k);
if (s % gc) {
pl(-1LL);
}
else {
// y->loops x->moves x*k+s=y*n => (x*k-y*n=-s)
n /= gc, s /= gc, k /= gc;
gc = GCD(k, n, x, y);
ll mod_inv = (x % n + n) % n; // k inverse
ll ans = ((-s * mod_inv) % n + n) % n;
pl(ans);
}
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t = 1;
scanf("%d", &t);
while (t--) {
solve();
}
} | #include <iostream>
#include <bits/stdc++.h>
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ull unsigned long long
#define int long long
#define pre(a,b) cout<<fixed<<setprecision(a)<<b<<"\n";//a for precision b for answer
//#define mp make_pair
#define max3(x,y,z) max(x,max(y,z))
#define min3(x,y,z) min(x,min(y,z))
#define pb push_back
#define min(a,b) (a<b?a:b)
#define forn(n) for(ll i=0;i<n;i++)
#define ff first
#define ss second
#define MAX 1e18;
#define all(x) (x).begin(),(x).end()
#define lb lower_bound
#define ub upper_bound
#define vmin *min_element
#define vmax *max_element
#define pii pair<int,int>
const int mod = 1e9 + 7;
const int N=1e6+1;
const int N2 = 1e5+1;
#define pi 3.141592653589793238
using namespace std;
vector<int>v(100002);
unsigned long long power(unsigned long long x,
int y, int p)
{
unsigned long long res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool key(string s, int b,int m)
{
int k = 0;
int n = s.size();
for(int i=0; i<s.size(); i++)
{
if(pow(b,n-1-i)<0)
return false;
k+=s[i]*pow(b,n-1-i);
}
return (k>m);
}
int bsa(int low, int high, int m, string s)
{
int mid;
int ans;
while (low < high) {
mid = (high + low) / 2;
// cout<<mid<<endl;
if ( key(s,mid,m)) {
high = mid;
}
else {
low = mid+1;
}
}
return low;
}
int ordertrip(int n)
{
int c =0;
for(int i=1; i*i<=n; i++)
{
if(n%i==0)
{
if(i==n/i)
{
c++;
}
else
{
c+=2;
}
}
}
return c;
}
void solve()
{
int k;
cin>> k;
int ans = 0;
vector<int>dp(k+1);
dp[1] = 1;
for(int i =2; i<=k;i++)
{
dp[i] = dp[i-1] + ordertrip(i);
}
for(int i=1; i<=k; i++)
{
ans+= dp[k/i];
}
cout<<ans;
}
signed main()
{
IOS;
//memset(dp,-1,sizeof(dp));
// freopen("input.txt","r",stdin);
// freopen("new.txt","w",stdout);
int t = 1;
//cin>>t;
while(t--)
{
IOS;
solve();
cout<<endl;
}
}
//cccccccccccccccccccccccccccccccccccccccc
|
#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
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
//#pragma GCC optimize("O3")
using namespace std;
using namespace __gnu_pbds;
auto random_address = [] { char *p = new char; delete p; return uint64_t(p); };
const uint64_t SEED = chrono::steady_clock::now().time_since_epoch().count() * (random_address() | 1);
mt19937_64 rng(SEED);
typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
ll a,b;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>a>>b;
cout<<2*a+100-b;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int h, w;
cin >> h >> w;
bool grid[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) {
char c;
cin >> c;
grid[i][j] = c == '#';
}
int vertices = 0;
for (int i = 0; i < h - 1; i++) {
for (int j = 0; j < w - 1; j++) {
int sum = grid[i][j] +
grid[i + 1][j] +
grid[i][j + 1] +
grid[i + 1][j + 1];
vertices += sum == 1 || sum == 3;
}
}
cout << vertices << endl;
return 0;
} |
#include <bits/stdc++.h>
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#endif
using namespace std;
using ll = long long;
struct Edge
{
ll to;
ll cost;
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, ll>;
#define mp make_pair
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ALL(v) (v).begin(), v.end()
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = LLONG_MAX;
const int MAX = 510000;
bool graph[nmax][nmax];
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++)
{
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(int n, int k)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<vector<ll>> dist = vector<vector<ll>>(nmax, vector<ll>(nmax, INF));
void warshall_floyd(ll n)
{
for (size_t i = 0; i < n; i++)
{
for (size_t j = 0; j < n; j++)
{
for (size_t k = 0; k < n; k++)
{
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
}
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b)
{
ll g = gcd(a, b);
return a / g * b;
}
ll mulMod(ll a, ll b)
{
return (((a % MOD) * (b % MOD)) % MOD);
}
ll powMod(ll a, ll p)
{
if (p == 0)
{
return 1;
}
else if (p % 2 == 0)
{
ll half = powMod(a, p / 2);
return mulMod(half, half);
}
else
{
return mulMod(powMod(a, p - 1), a);
}
}
ll ceil(ll a, ll b)
{
return (a + b - 1) / b;
}
void solve(long long N, long long M)
{
if(N==1 && M == 0){
cout << "1 2" << endl;
return;
}
ll r_max = 1000000000;
// Mが正の時を考える
if (M < 0 || N - 1 <= M)
{
cout << -1 << endl;
return;
}
vector<pair<ll, ll>> ans;
ll l = 1, r = r_max / 2;
// 青木くんの個数を1とする
ll cnt = 0;
ans.push_back(P(l, r));
cnt++;
// 高橋くんがM+1個選べるように選択する
ll tmp_l = (l+r)/2;
ll tmp_r = tmp_l+1;
while (cnt <= M + 1)
{
ans.push_back(P(tmp_l, tmp_r));
cnt++;
tmp_l += 2;
tmp_r += 2;
}
tmp_r += r;
tmp_l -=(l+r)/2;
while (cnt < N)
{
ans.push_back(P(tmp_l, tmp_r));
cnt++;
tmp_l++;
tmp_r++;
}
for (auto &&i : ans)
{
cout << i.first << " " << i.second << endl;
}
}
int main()
{
long long N;
scanf("%lld", &N);
long long M;
scanf("%lld", &M);
solve(N, M);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template<class T>
void debug(T itr1, T itr2) { auto now = itr1; while(now<itr2) { cout << *now << " "; now++; } cout << endl; }
#define repr(i,from,to) for (ll i=(ll)from; i<(ll)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i,N) repr(i,0,N)
#define per(i,N) for (ll i=(ll)N-1; i>=0; i--)
#define popcount __builtin_popcount
const ll LLINF = pow(2,61)-1;
const ll INF = pow(2,30)-1;
ll gcd(ll a, ll b) { if (a<b) swap(a,b); return b==0 ? a : gcd(b, a%b); }
ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
struct num {
ll n, i;
num operator+ (const num &x) const { return (num){n+x.n, i+x.i}; }
num operator- (const num &x) const { return (num){n-x.n, i-x.i}; }
};
struct SegTree {
ll size;
vector<num> pos;
SegTree(ll N) { size = 1; while(size<N) size<<=1; pos.resize(2*size,(num){0,0}); }
num operator[](const ll &x) const { return pos[x+size]; }
void set(ll x, const num v) { pos[x+size] = v; }
void update(ll x, const num v) { set(x,v); x+=size; while (x>>=1) operate(x); }
num query(ll a, ll b) {
num L = {0,0}, R = {0,0};
for (a+=size, b+=size; a<b; a>>=1, b>>=1) {
if (a&1) { L = q(L,pos[a]); a++; }
if (b&1) { b--; R = q(pos[b],R); }
}
return q(L,R);
}
void operate(ll i) { pos[i] = q(pos[i*2], pos[i*2+1]); }
num q(num x, num y) { return x + y; }
};
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
int main() {
ll N, M, Q; cin >> N >> M >> Q;
ll T[Q], X[Q], Y[Q]; rep(i,Q) { cin >> T[i] >> X[i] >> Y[i]; X[i]--; }
set<ll> nset; rep(i,Q) nset.insert(Y[i]); nset.insert(0);
vector<ll> nv; for (auto x: nset) nv.push_back(x);
map<ll, ll> nv_idx; rep(i,nv.size()) nv_idx[nv[i]] = i;
// debug(all(nv));
ll now_row[N] = {}, now_col[M] = {};
ll nvs = nv.size();
SegTree st_row(nvs); st_row.update(0,{0,N});
SegTree st_col(nvs); st_col.update(0,{0,M});
ll result = 0;
rep(i,Q) {
if (T[i]==1) {
ll fp = nv_idx[now_row[X[i]]], tp = nv_idx[Y[i]];
ll sum_from = st_col.query(0,fp).i * now_row[X[i]] + st_col.query(fp,nvs).n;
ll sum_to = st_col.query(0,tp).i * Y[i] + st_col.query(tp,nvs).n;
result += sum_to - sum_from;
st_row.update(fp, st_row[fp] - (num){now_row[X[i]],1});
st_row.update(tp, st_row[tp] + (num){Y[i],1});
now_row[X[i]] = Y[i];
}
else {
ll fp = nv_idx[now_col[X[i]]], tp = nv_idx[Y[i]];
ll sum_from = st_row.query(0,fp).i * now_col[X[i]] + st_row.query(fp,nvs).n;
ll sum_to = st_row.query(0,tp).i * Y[i] + st_row.query(tp,nvs).n;
result += sum_to - sum_from;
st_col.update(fp, st_col[fp] - (num){now_col[X[i]],1});
st_col.update(tp, st_col[tp] + (num){Y[i],1});
now_col[X[i]] = Y[i];
}
cout << result << endl;
}
return 0;
} |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int a,b,c;
int main()
{
scanf("%d%d%d",&a,&b,&c);
if(!c)puts(a>b?"Takahashi":"Aoki");
else puts(a<b?"Aoki":"Takahashi");
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int n,m,c;
bool flag;
while(cin>>n>>m>>c)
{
if(c==0)
{
flag=true;
}
else{
flag=false;
}
if(flag&&n==0)
{
printf("Aoki\n");
continue;
}
else if(!flag&&m==0)
{
printf("Takahashi\n");
continue;
}
while(n!=0&&m!=0)
{
if(flag)
{
n--;
flag=!flag;
if(n<=0)
{
printf("Aoki\n");
break;
}
}
else{
m--;
flag=!flag;
if(m<=0)
{
printf("Takahashi\n");
break;
}
}
}
}
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define rrep(i, a, b) for (ll i = b - 1; a <= i; i--)
ll MOD = 1000000007;
ll N, K, A[800][800];
int main () {
cin >> N >> K;
rep (i, 0, N) rep (j, 0, N) cin >> A[i][j];
// 中央値がx以下の区画が存在する
// <=> ある区画aが存在して、aのマスの内高さがxより大きいものがfloor(K^2 / 2)個以下存在
// cnt[i][j] : 右下のマスが(i,j)であるような区画に存在する高さがより大きいマスの個数
// (i < K-1 || j < K-1)の場合、はみ出す部分は無視する
ll l = -1, r = 1e9;
while (r - l > 1) {
ll x = (l + r) / 2;
ll cnt[N][N];
rep (i, 0, N) rep (j, 0, N) {
cnt[i][j] = (A[i][j] > x);
if (0 <= i - 1) cnt[i][j] += cnt[i-1][j];
if (0 <= j - 1) cnt[i][j] += cnt[i][j-1];
if (0 <= i - 1 && 0 <= j - 1) cnt[i][j] -= cnt[i-1][j-1];
if (0 <= i - K) cnt[i][j] -= (A[i-K][j] > x);
if (0 <= j - K) cnt[i][j] -= (A[i][j-K] > x);
if (0 <= i - K && 0 <= j - K) cnt[i][j] += (A[i-K][j-K] > x);
}
// ---プリントデバッグ用---
// cout << "---\n";
// cout << "x = " << x << endl;
// rep (i, 0, N) {
// rep (j, 0, N) {
// cout << left << setw(3) << cnt[i][j];
// }
// cout << endl;
// }
// ---
bool b = false;
rep (i, K - 1, N) {
rep (j, K - 1, N) {
if (cnt[i][j] <= floor(K * K / 2)) {
b = true;
break;
}
}
if (b) break;
}
if (b) r = x;
else l = x;
}
cout << r;
}
| #include <cstdio>
#include <cstring>
#include <algorithm>
#define rep(a,b,c) for(int a=b;a<=c;a++)
#define per(a,b,c) for(int a=b;a>=c;a--)
#define int long long
const int N=1e6+5;
const int p=998244353;
template<class T>inline void read(T &x) {
T f=1;x=0;char s=getchar();
while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
x*=f;
}
int fac[5001],inv[5001];
inline int ksm(int a,int b) { int ans=1; for(;b;b>>=1,(a*=a)%=p) if(b&1) (ans*=a)%=p; return ans; }
inline int C(int a,int b) { return fac[a]*inv[b]%p*inv[a-b]%p; }
int f[5001],g[5001];
int n,m;
signed main() {
fac[0]=1; inv[0]=1;
rep(i,1,5000) (fac[i]=fac[i-1]*i%p),inv[i]=ksm(fac[i],p-2);
read(n); read(m);
f[0]=1;
rep(nw,0,12) {
memset(g,0,sizeof(g));
rep(i,0,m) {
rep(j,0,n) {
if((i+(1<<nw)*j*2)>m) break;
(g[i+(1<<nw)*j*2]+=f[i]*C(n,j*2)%p)%=p;
}
}
rep(i,0,m) f[i]=g[i];
}
printf("%lld\n",f[m]);
} |
// ============================================================================
// || ||
// || International University of Business,Agriculture ||
// || And Technology ||
// || Redwan Ahmed Khan ||
// || Bismillah-ir-Rahman-ir-Rahim ||
// || ||
// ============================================================================
#include<bits/stdc++.h>
#define int long long
#define ld long double
#define ull unsigned long long int
#define chr char
#define st string
#define pb push_back
#define pp pop_back
#define mp make_pair
#define vin vector<int>
#define vch vector<char>
#define vst vector<string>
#define pii pair<int,int>
#define triplet pair<ll,pair<ll,ll>>
#define mpin map<int,int>
#define mod 1000000007
#define pi 2 * acos (0.0)
#define mx1 320000
#define print(x) printf("%lld\n",x)
#define input(x) scanf("%lld",&x)
#define stringin scanf(" %[^\n]%*c", a)
#define sz(x) (x).size()
#define read(x) int x; cin >> x;
#define loj(case_no,result) cout<<"Case "<<case_no<<": "<<result<<endl
#define loj2(case_no,result) cout<<"Case "<<case_no<<":"<<endl<<result<<endl
#define fr(a,b) for(int i = a; i < b; i++)
#define frc(a,b) for(int i = a; i > b; i--)
#define rep(i,a,b) for(int i = a; i < b; i++)
#define testcase(t) int t ; cin>>t ; while(t--)
#define all(x) (x).begin(), (x).end()
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define prDouble(x) cout << fixed << setprecision(10) << x<<endl
#define lcm(a,b) (a*b)/__gcd(a,b);
#define erase(a,b) a.erase(a.begin()+(b-1))
#define mem(a, b) memset(a, b, sizeof(a))
#define trv(x) ((x).begin(),(x).end())
#define db(x) cout<<#x <<"=" <<x<<endl
#define time cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
#define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL)
using namespace std;
void solve()
{ testcase(t)
{
read(n);
int c = 0;
while (n && n % 2 == 0)
{
c++;
n /= 2;
}
if (c == 1)cout << "Same" << endl;
else if (c == 0)cout << "Odd" << endl; \
else cout << "Even" << endl;
}
}
void init_code() {
fast_io;
#ifndef ONLINE_JUDGE()
(void)!freopen("input.txt", "r", stdin);
(void)!freopen("output.txt", "w", stdout);
#endif
}
int32_t main()
{
init_code();
solve();
time;
return 0;
}
// Alhamdulillah. I have solved this problem by the grace of the Almighty Allah | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define pb push_back
#define ll long long
#define int ll
#define mod 1000000007
#define DEBUG cout<<"Hello1\n";
#define all(v) (v).begin(),(v).end()
#define deb(...) debug(#__VA_ARGS__, __VA_ARGS__);
const int N = 1e6 + 5;
const ll inf = 1e18 + 5;
typedef pair<int, int> pii;
void fileIO();
template<class T> void print_container(T &container);
template<class T> void print_pair_container(T &container);
template<class T> void printArr(T &a, int n);
template<typename T> void debug(string s, T x);
template<typename T, typename... Args>
void debug(string s, T x, Args... args);
int n, m;
void solve(int tc = 0) {
cin >> n;
if (n % 2) {
cout << "Odd\n";
} else {
if ((n / 2) % 2 == 0) {
cout << "Even\n";
} else {
cout << "Same\n";
}
}
}
int32_t main()
{
fileIO();
int t = 1; cin >> t; for (int i = 1; i <= t; i++)
solve();
return 0;
}
void fileIO() {
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
}
template<typename T> void debug(string s, T x)
{
cout << s << " = " << x << "\n";
}
template<typename T, typename... Args> void debug(string s, T x, Args... args)
{
cout << s.substr(0, s.find(',')) << " = " << x << " | ";
debug(s.substr(s.find(',') + 2), args...);
}
template<class T> void print_container(T &container)
{
for (auto &t : container)
{
cout << t << " ";
}
cout << endl;
}
template<class T> void print_pair_container(T &container)
{
for (auto &t : container)
{
cout << t.first << " " << t.second << endl;
}
cout << endl;
}
template<class T> void printArr(T &a, int n)
{
for (int i = 0; i < n; i++)
{
cout << a[i] << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep1(i, n) for(int i = 1; i < n+1; i++)
#define all(A) A.begin(),A.end()
typedef long long ll;
int gcd(int a,int b){
if(b == 0) return a;
else return gcd(b,a%b);
}
int main(){
int n;
cin >> n;
ll ans = 0;
rep(i,n){
int a;
cin >> a;
if(i == 0){
ans = a;
}
else{
ans = gcd(ans,a);
}
}
cout << ans << endl;
} | #include<stdio.h>
#include<iostream>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<algorithm>
#include<string.h>
#include<functional>
#include<limits.h>
#include<stdlib.h>
#include<string>
#include<unordered_map>
#include <iomanip>
using namespace std;
#define intmax INT_MAX
#define lmax LONG_MAX
#define uintmax UINT_MAX
#define ulmax ULONG_MAX
#define llmax LLONG_MAX
#define ll long long
#define rep(i,a,N) for((i)=(a);(i)<(N);(i)++)
#define rrp(i,N,a) for((i)=(N)-1;(i)>=(a);(i)--)
#define llfor ll i,j,k
#define sc(a) cin>>a
#define pr(a) cout<<a<<endl
#define pY puts("YES")
#define pN puts("NO")
#define py puts("Yes")
#define pn puts("No")
#define pnn printf("\n")
#define sort(a) sort(a.begin(),a.end())
#define reverse(a) reverse(a.begin(),a.end())
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define sizeoof(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
/*繰り上げ除算*/ll cei(ll x,ll y){ll ans=x/y;if(x%y!=0)ans++;return ans;}
/*最大公約数*/ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*最小公倍数*/ll lcm(ll x,ll y){return x/gcd(x,y)*y;}
/*n乗*/ll llpow(ll x,ll n){ll i,ans=1;rep(i,0,n)ans*=x;return ans;}
/*階乗*/ll fact(ll x){ll i,ans=1;rep(i,0,x)ans*=(x-i);return ans;}
/*nCr*/ll ncr(ll n,ll r){return fact(n)/fact(r)/fact(n-r);}
/*nPr*/ll npr(ll n,ll r){return fact(n)/fact(n-r);}
/*primejudge*/bool prime(ll a){if(a<=1)return false;ll i;for(i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
ll ans=0;llfor;///////////////////////////////////////////////////////////
int digit(int n){
if(n < 10) return n;
return digit(n/10) + n%10;
}
int main(){
int K;
ll N;
cin>>N>>K;
for(int i=0;i<K;i++){
if(N%200==0) N/=200;
else N=N*1000+200;
}
cout<<N;
return 0;}
|
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define ld long double
#define eb emplace_back
#define pb push_back
#define qwerty1 first
#define qwerty2 second
#define qwerty3 -> first
#define qwerty4 -> second
#define umap unordered_map
#define uset unordered_set
#define pii pair < int , int >
#define pq priority_queue
#define dbg(x) cerr << #x << ": " << x << '\n'
#define FastIO ios_base::sync_with_stdio(false) , cin.tie(0) , cout.tie(0)
#define FILES freopen("in" , "r" , stdin) , freopen("out" , "w" , stdout)
namespace FastRead
{
char buff[5000];int lg = 0 , p = 0;
char nc()
{
if(lg == p){lg = fread(buff , 1 , 5000 , stdin);p = 0;if(!lg) return EOF;}
return buff[p++];
}
template<class T>void read(T&x)
{
T sgn = 1; char c;while(!isdigit(c = nc()))if(c == '-')sgn = -1;
x = c - '0';while(isdigit(c = nc()))x = x * 10 + c - '0';x *= sgn;
}
}
using namespace FastRead;
using namespace std;
const int N = 1e5 + 10;
const int M = 1e9 + 7;
const ld PI = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
char a[70];
int fr[4];
signed main()
{
#ifndef ONLINE_JUDGE
FastIO , FILES;
#endif
cin >> a + 1;
for(int i = 1 ; i <= strlen(a + 1) ; i++)
++fr[ (a[i] - '0') % 3 ];
int sum = fr[1] + 2 * fr[2];
sum %= 3;
int val = 0;
if(sum == 1 && fr[1])
val = 1;
else if(sum == 1 && fr[2] > 1)
val = 2;
else if(sum == 1)
val = strlen(a + 1);
if(sum == 2)
{
if(fr[2])
val = 1;
else if(fr[1] > 1)
val = 2;
else val = strlen(a + 1);
}
if(val == strlen(a + 1))
cout << -1;
else cout << val;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define PRINT(a) cout << (a) << endl
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define debug(x) cerr << x << " " << "(L:" << __LINE__ << ")" << '\n';
using ll = long long int;
using P = pair<int,int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
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 int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
const int mod = 1000000007;
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 {
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;
}
};
mint mpow(int x, int n){
if(n==0)return 1;
mint y = mpow(x, n/2);
y *= y;
if(n%2==1) y *=x;
return y;
}
struct combination {
vector<mint> fact, ifact;
combination(int n):fact(n+1),ifact(n+1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n) return 0;
return fact[n]*ifact[k]*ifact[n-k];
}
};
int di[4] ={-1,1,0,0};
int dj[4] ={0,0,1,-1};
int main(){
int h,w;
cin >> h >> w;
vector<string> s(h);
REP(i,h)cin >> s[i];
int cnt=0;
REP(i,h)REP(j,w)if(s[i][j]=='.')cnt++;
vvi a(h,vi(w,0));
vvi b(h,vi(w,0));
REP(i,h){
int c=0;
REP(j,w){
if(s[i][j]=='.'){
c++;
}else{
REP(k,c){
a[i][j-1-k] = c;
}
c=0;
}
}
REP(k,c){
a[i][w-1-k] = c;
}
}
REP(i,w){
int c=0;
REP(j,h){
if(s[j][i]=='.'){
c++;
}else{
REP(k,c){
b[j-1-k][i] = c;
}
c=0;
}
}
REP(k,c){
b[h-1-k][i] = c;
}
}
// REP(i,h)REP(j,w){
// cout << a[i][j] << (j==w-1 ? "\n" : " ");
// }
// REP(i,h)REP(j,w){
// cout << b[i][j] << (j==w-1 ? "\n" : " ");
// }
mint all=mpow(2,cnt);
// cout << all.x << endl;
mint ans=0;
REP(i,h)REP(j,w){
if(s[i][j]=='#')continue;
// int c=1;
// REP(k,4){
// int ni = i;
// int nj = j;
// while(true){
// ni += di[k];
// nj += dj[k];
// if(ni < 0 || ni >= h || nj < 0 ||nj >= w)break;
// if(s[ni][nj]=='#')break;
// c++;
// }
// }
// cout << c << endl;
int c = a[i][j] + b[i][j] - 1;
ans += (mpow(2,c)-1) * mpow(2,cnt-c);
// cout << ((mpow(2,c)-1) * mpow(2,cnt-c)).x << endl;
}
cout << ans.x << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int x,y,z;
cin>>x>>y;
if(x==y) z=y;else{
if((x==0&&y==1)||(x==1&&y==0))z=2;
if((x==0&&y==2)||(x==2&&y==0))z=1;
if((x==2&&y==1)||(x==1&&y==2))z=0;
}
cout<<z<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define MP make_pair
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int,int>pi;
int main(){
ios::sync_with_stdio(0);cin.tie(0);
int x , y ;
cin >> x >> y ;
if( x == y ) cout << x << "\n";
else cout << 3 - x - y << '\n' ;
return 0;
}
|
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#include<bits/stdc++.h>
using namespace std;
#define rep(i,s,t) for(ll i = (ll)(s); i < (ll)(t); i++)
#define rrep(i,s,t) for(ll i = (ll)(s-1);(ll)(t) <= i; i--)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> Pll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
constexpr ll INF = numeric_limits<ll>::max()/4;
constexpr ll n_max = 2e5+10;
#define int ll
const long double pi = 3.14159265358979323846;
const long double eps = 1e-12;
template <typename A, typename B>
string to_string(pair<A, B> p);
string to_string(const string &s) {return '"' + s + '"';}
string to_string(const char *c) {return to_string((string) c);}
string to_string(bool b) {return (b ? "true" : "false");}
template <size_t N>
string to_string(bitset<N> v){
string res = "";
for(size_t i = 0; i < N; i++) res += static_cast<char>('0' + v[i]);
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for(const auto &x : v) {
if(!first) res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p){return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
void debug_out() {cerr << endl;}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
template<class T>
bool chmax(T &a, T b){if(a < b){a = b; return true;} return false;}
template<class T>
bool chmin(T &a, T b){if(a > b){a = b; return true;} return false;}
signed main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
ll n,T; cin >> n >> T;
vector<ll> a(n);
for(int i = 0; i < n; i++) cin >> a[i];
vector<ll> one, two, a1, a2;
ll m = n / 2;
rep(i,0,n){
if (i < m) a1.emplace_back(a[i]);
else
a2.emplace_back(a[i]);
}
rep(i,0, 1LL << m){
ll t = 0;
rep(j, 0, m) {
if((i >> j) & 1){
t += a1[j];
}
}
if(t <= T){
one.emplace_back(t);
}
}
m = n - m;
rep(i,0,1LL << m){
ll t = 0;
rep(j,0,m){
if((i >> j) & 1){
t += a2[j];
}
}
if (t <= T) two.emplace_back(t);
}
sort(all(one));
sort(all(two));
debug(one, two);
ll ans = 0;
m = two.size();
for (auto i : one) {
ll id = upper_bound(all(two), T - i) - two.begin();
if(id)chmax(ans, i + two[id-1]);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
template <typename T> using vt = vector<T>;
template <typename T> using oset = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define pb push_back
#define SZ(x) ((int)((x).size()))
#define EACH(x, a) for (auto& x: a)
#define FOR(i,s,n) for (ll i = (s); (i) < (n); ++i)
#define FORD(i,s,l) for (ll i = (s); (i) >= l; --i)
#define F first
#define S second
#define TC int __tc; cin >> __tc; FOR(case_num,1,__tc+1)
#define TEST(x,i) ((x)&(1ll<<(i)))
#define SET(x,i) ((x)|(1ll<<(i)))
#define FLIP(x,i) ((x)^(1ll<<(i)))
#define CLEAR(x,i) ((x)&~(1ll<<(i)))
const double pi = 4 * atan(1);
using ll = long long;
using pll = pair<ll, ll>;
mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) {
return uniform_int_distribution<ll>(a, b)(mt_rng);
}
template<class T> bool umin(T& a, const T& b) {
return b<a?a=b, 1:0;
}
template<class T> bool umax(T& a, const T& b) {
return a<b?a=b, 1:0;
}
template<class ForwardIterator> void print_vec(ForwardIterator first,
ForwardIterator last, string sep = " ", string end = "\n") {
bool ft = true;
while (first != last) {
if (!ft) {cout << sep;} else {ft = false;}
cout << (*first);
++first;
}
cout << end;
}
template<typename T1, typename T2>
std::ostream& operator<<(std::ostream &o, const pair<T1, T2> &p) {
return o << p.F << " " << p.S;
}
inline ll floorDiv(ll x, ll y) {
ll d = x / y;
ll r = x % y;
return r ? (d - ((x < 0) ^ (y < 0))) : d;
}
ll ceilDiv(ll x, ll y) {
return -floorDiv(-x, y);
}
ll bin_search(ll lo, ll hi, function<bool(ll)> predicate) {
int sign = lo < hi ? 1 : -1;
lo *= sign;
hi *= sign;
hi++;
while (lo < hi) {
ll mid = lo + floorDiv(hi-lo, 2);
if (!predicate(sign * mid)) {
lo = mid + 1;
} else {
hi = mid;
}
}
return sign * lo;
}
const ll MOD = 1000000007;
const int MAXN = 200005;
vector<ll> part[2];
ll sums[2][(1<<20)+5];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
ll t;
cin >> t;
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
part[(int)(i >= n/2)].pb(x);
}
int sizes[] = {n/2,n-n/2};
for (int p = 0; p <= 1; p++) {
int limit = 1 << sizes[p];
for (int j = 0; j < limit; j++) {
ll s = 0;
for (int i = 0; i < sizes[p]; i++) {
if (TEST(j,i)) {
s+=part[p][i];
}
}
sums[p][j]=s;
}
}
sort(sums[1], sums[1]+(1 << sizes[1]));
int limit0 = 1 << sizes[0];
ll best = 0;
for (int i = 0; i < limit0; i++) {
ll value = sums[0][i];
if (value == t) {
cout << t << "\n";
return 0;
}
if (value > t) {
continue;
}
best = max(best,value);
ll left = t - value;
auto it = upper_bound(sums[1], sums[1]+(1 << sizes[1]), left);
if (it == sums[1]) continue;
it--;
best = max(best, value + *it);
}
cout << best << "\n";
}
|
#include<bits/stdc++.h>
#define ll long long
#define re register
#define INF 2147483647
using namespace std;
inline int read()
{
int f=1,x=0;char s=getchar();
while(s<'0'||s>'9')
{
if(s=='-') f=-1;
s=getchar();
}
while(s>='0'&&s<='9')
{
x=x*10+s-48;
s=getchar();
}
return f*x;
}
const int N=2005;
int a[N],b[N],dp[N][N];
int main()
{
int n=read(),m=read();
for(int i=1;i<=n;i++) a[i]=read();
for(int i=1;i<=m;i++) b[i]=read();
memset(dp,0x3f,sizeof(dp));
dp[0][0]=0;
for(int i=1;i<=n;i++) dp[i][0]=i;
for(int i=1;i<=m;i++) dp[0][i]=i;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
if(a[i]==b[j]) dp[i][j]=dp[i-1][j-1];
dp[i][j]=min(dp[i][j],1+min(min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1]));
}
printf("%d\n",dp[n][m]);
return 0;
} | //Bismillahir Rahmanir Raheem
#ifdef ONLINE_JUDGE
#include<bits/stdc++.h>
#endif
#include<iostream>
#include<numeric>
#include<tuple>
#include<iomanip>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<map>
#include<unordered_map>
#include<math.h>
#include<vector>
#include<climits>
#include<algorithm>
#include<string>
#include<sstream>
#include<string.h>
#include<deque>
#include<set>
using namespace std;
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define clr(cnt, x) memset((cnt), (x), sizeof(cnt))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pair<int,int> > vii;
typedef pair<int, int> pii;
typedef vector<bool> vbl;
typedef vector<pair<ll,ll> > vll;
typedef pair<ll, ll> pll;
#define PQ priority_queue
#define ff first
#define ss second
#define MP make_pair
#define MT make_tuple
#define mxN (int)2e5 + 2
#define sz(n) (int)(n).size()
#define fasterIO ios::sync_with_stdio(0); cin.tie(0);
#define forc(cn) for(auto &x : (cn))
#define findc(cn, x) ((cn).find(x) != (cn).end())
#define PI 2*acos(0)
#define forc(cn) for(auto &x : (cn))
#define MAXN 300010
#define torad ((2*acos(0))/180.0)
const int inf = INT_MAX;
int n, m;
vi a, b;
int dp[1010][1010];
int f(int i, int j) {
if(i == n || j == m) {
return max(n - i, m - j);
}
int &ret = dp[i][j];
if(ret != -1) return ret;
ret = inf;
if(a[i] != b[j]) {
ret = min(ret, f(i + 1, j) + 1);
ret = min(ret, f(i, j+1) + 1);
}
ret = min(ret, f(i+1, j+1) + (a[i] != b[j]));
return ret;
}
void solve()
{
clr(dp, -1);
cin >> n >> m;
a = vi(n);
b = vi(m);
forc(a) cin >> x;
forc(b) cin >> x;
cout << f(0, 0) << endl;
}
int main()
{
//fasterIO
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t = 1;
//cin >> t;
while(t--) {
solve();
}
return 0;
}
|
#include<iostream>
#include<map>
using namespace std;
const int BUF = 300005;
int nVal;
int val[BUF];
void read() {
cin >> nVal;
for (int i = 0; i < nVal; ++i) {
cin >> val[i];
}
}
void work() {
map<int, int> v2cnt;
for (int i = 0; i < nVal; ++i) {
++v2cnt[val[i]];
}
long long sum = 0;
for (map<int, int>::iterator it = v2cnt.begin(); it != v2cnt.end(); ++it) {
sum += 1LL * it->second * (nVal - it->second);
}
cout << sum / 2 << endl;
}
int main() {
read();
work();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll linf = (1ll << 60);
int N, M;
int X[50];
bool notprime[51];
int prime[50];
int main() {
cin >> N;
for(int i = 2; i <= 50; i++) {
if(notprime[i]) continue;
prime[M++] = i;
for(int j = i; j <= 50; j += i) {
notprime[j] = 1;
}
}
for(int i = 0; i < N; i++) cin >> X[i];
ll ans = linf;
for(int bit = 0; bit < (1 << M); bit++) {
bool found = false;
for(int i = 0; i < N; i++) {
bool g = false;
for(int j = 0; j < M; j++) {
if(!(bit & (1 << j))) continue;
if(X[i] % prime[j] == 0) g = true;
}
if(!g) found = true;
}
if(!found) {
ll tmp = 1;
for(int j = 0; j < M; j++) {
if(!(bit & (1 << j))) continue;
tmp *= prime[j];
}
ans = min(ans, tmp);
}
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
#define pri(str) cout << str << endl
using ll = long long;
using P = pair<int, int>;
const ll MX = 1e18;
const long double PI = acos(-1);
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main()
{
int n;
cin >> n;
int l = 0;
int r = 1005;
rep(i,n)
{
int a;
cin >> a;
if(l < a)
l = a;
}
rep(i,n)
{
int a;
cin >> a;
if(a < r)
r = a;
}
if( r-l < 0 )
pri(0);
else
pri(r-l+1);
return 0;
} | // *** Though I am not John Snow, yet I know nothing ***
#include <bits/stdc++.h>
using namespace std;
#define F(i, a, b) for (int i = a; i < b; i++)
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n];
#define range(a, b) substr(a, b - a + 1)
#define w(x) \
int x; \
cin >> x; \
while (x--)
#define trace(x) cerr << #x << ": " << x << " " << endl;
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
void solve()
{
string s;
cin >> s;
string ans;
int i = 0, n = s.size();
while (i < n && s[i] != '.')
{
ans.push_back(s[i]);
i++;
}
cout << ans;
}
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
FIO;
solve();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int matrix[50][50];
int n, k;
long long MOD = 998244353LL;
vector<int> comp;
long long fact (long long i) {
long long ans = 1;
while (i > 1ll) {
ans = (i * ans) % MOD;
i--;
}
return ans;
}
void update (vector<int>* g) {
bool vis[n];
memset(vis, 0, sizeof vis);
for (int i = 0; i < n; i++) {
if (vis[i]) { continue; }
int cont = 0;
queue<int> q;
q.push(i);
vis[i] = true;
while (!q.empty()) {
int x = q.front(); q.pop();
cont++;
for (int &y: g[x]) {
if (vis[y]) { continue; }
vis[y] = true;
q.push(y);
}
}
comp.push_back(cont);
}
}
int main () {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &matrix[i][j]);
}
}
vector<int> g_rows[n];
vector<int> g_cols[n];
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
bool faro_row = true, faro_col = true;
for (int l = 0; l < n; l++) {
if (matrix[i][l] + matrix[j][l] > k) {
faro_row = false;
}
if (matrix[l][i] + matrix[l][j] > k) {
faro_col = false;
}
}
if (faro_row) {
g_rows[i].push_back(j);
g_rows[j].push_back(i);
}
if (faro_col) {
g_cols[i].push_back(j);
g_cols[j].push_back(i);
}
}
}
update(g_rows);
update(g_cols);
long long ans = 1;
for (int& i: comp) {
ans = (ans * fact(i * 1ll)) % MOD;
}
printf("%lld\n", ans);
return 0;
}
| #include<bits/stdc++.h>
#define PI 3.14159265358979323846264338327950288419716939937510
#define eps 1e-15
using namespace std;
typedef long long ll;
typedef long double db;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<db,db> pdd;
int vis[1005][1005],n,m;
char c[1005][1005];
vector<int> a[1005],b[1005];
void bfs(int sx,int sy){
queue<pii> q;
q.push({sx,sy});
vis[sx][sy]=1;
while(q.size()){
int x=q.front().first,y=q.front().second;q.pop();
for(auto j:a[x]){
q.push({x,j});vis[x][j]=1;
}
for(auto j:b[y]){
q.push({j,y});vis[j][y]=1;
}
a[x].clear();b[y].clear();
}
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
cin>>c[i][j];
}
}
c[1][1]='#';c[1][m]='#';
c[n][1]='#';c[n][m]='#';
int h=0,s=0;
for(int i=1;i<=n;i++){
int t=0;
for(int j=1;j<=m;j++){
if(c[i][j]=='#'){t=1;break;}
}
h+=t;
}
for(int i=1;i<=m;i++){
int t=0;
for(int j=1;j<=n;j++){
if(c[j][i]=='#'){t=1;break;}
}
s+=t;
}
int num=min(m-s,n-h),v=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(c[i][j]=='#'){
a[i].push_back(j);
b[j].push_back(i);
}
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(vis[i][j]) continue;
if(c[i][j]!='#') continue;
bfs(i,j);v++;
}
}
cout<<num+v-1<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int N, M;
int board[105][105];
bool vis[105][105];
int dy[4] = {-1, 1, 0, 0};
int dx[4] = {0, 0, -1, 1};
int X, Y;
bool valid(int y, int x) {
return 1<=y && y<=N && 1<=x && x<=M;
}
int main() {
cin.tie(nullptr); ios::sync_with_stdio(false);
cin >> N >> M >> Y >> X;
for(int i=1;i<=N;++i) {
string s; cin >> s;
for(int j=1;j<=M;++j) {
board[i][j] = s[j-1] == '#';
}
}
int ans = 0;
for(int i=0;i<4;++i) {
int y = Y;
int x = X;
while(valid(y, x) && board[y][x] == 0) {
if(!vis[y][x]) {
vis[y][x] = true;
++ans;
}
y += dy[i];
x += dx[i];
}
}
cout << ans << '\n';
return 0;
} | #include<bits/stdc++.h>
using namespace std;
using ll=long long int;
using Int=__int128;
template<typename T1,typename T2> bool chmin(T1 &a,T2 b){if(a<=b)return 0; a=b; return 1;}
template<typename T1,typename T2> bool chmax(T1 &a,T2 b){if(a>b)return 0; a=b; return 1;}
#define bitUP(x,a) ((x>>a)&1)
int dx[4]={0,1,0,-1}, dy[4]={1,0,-1,0};
long double EPS = 1e-6;
long double PI = acos(-1);
const ll INF=(1LL<<62);
const int MAX=(1<<30);
constexpr ll MOD=1000000000+7;
inline void bin101(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
}
using pii=pair<int,int>;
using pil=pair<int,ll>;
using pli=pair<ll,int>;
using pll=pair<ll,ll>;
using psi=pair<string,int>;
using pis=pair<int,string>;
using psl=pair<string,ll>;
using pls=pair<ll,string>;
using pss=pair<string,string>;
using Graph=vector<vector<int>>;
template<typename T >
struct edge {
int to;
T cost;
edge()=default;
edge(int to, T cost) : to(to), cost(cost) {}
};
template<typename T>
using WeightGraph=vector<vector<edge<T>>>;
//1-indexed vector cin
template<typename T>
inline void vin1(vector<T> &v){
for(size_t i=1;i<v.size();i++) cin>>v[i];
}
//0-indexed vector cin
template<typename T>
inline void vin0(vector<T> &v){
for(size_t i=0;i<v.size();i++) cin>>v[i];
}
//1-indexed vector<vector> cin
template<typename T>
inline void vin1(vector<vector<T>> &v){
for(size_t i=1;i<v.size();i++){
for(size_t j=1;j<v[i].size();j++) cin>>v[i][j];
}
}
//0-indexed vector<vector> cin
template<typename T>
inline void vin0(vector<vector<T>> &v){
for(size_t i=0;i<v.size();i++){
for(size_t j=0;j<v[i].size();j++) cin>>v[i][j];
}
}
//要素数n 初期値x
template<typename T>
inline vector<T> vmake(size_t n,T x){
return vector<T>(n,x);
}
//a,b,c,x data[a][b][c] 初期値x
template<typename... Args>
auto vmake(size_t n,Args... args){
auto v=vmake(args...);
return vector<decltype(v)>(n,move(v));
}
//pair cout
template<typename T, typename U>
inline ostream &operator<<(ostream &os,const pair<T,U> &p) {
os<<p.first<<" "<<p.second;
return os;
}
//pair cin
template<typename T, typename U>
inline istream &operator>>(istream &is,pair<T,U> &p) {
is>>p.first>>p.second;
return is;
}
//ソート
template<typename T>
inline void vsort(vector<T> &v){
sort(v.begin(),v.end());
}
//逆順ソート
template<typename T>
inline void rvsort(vector<T> &v){
sort(v.rbegin(),v.rend());
}
//1ビットの数を返す
inline int popcount(int x){
return __builtin_popcount(x);
}
//1ビットの数を返す
inline int popcount(ll x){
return __builtin_popcountll(x);
}
ll modpow(ll x,ll N,ll mod){
ll ret=1;
while(N>0){
if(bitUP(N,0)) ret=ret*x%mod;
x=x*x%mod;
N>>=1;
}
return ret;
}
void solve(){
ll A,B,C;
cin>>A>>B>>C;
vector<int> v;
v.push_back(A%10);
bool fi=true;
while(not (fi==false and v.back()==v[0])){
v.push_back(v.back()*A%10);
fi=false;
}
v.pop_back();
ll size=v.size();
ll x=modpow(B,C,size);
x--;
if(x==-1) x=size-1;
cout<<v[x]<<endl;
}
int main(){
bin101();
int T=1;
//cin>>T;
while(T--) solve();
}
|
#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_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
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);
}
ll gcd(ll a, ll b, ll& x, ll& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll x1, y1;
ll d = gcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
bool find_any_solution(ll a, ll b, ll c, ll &x0, ll &y0, ll &g) {
g = gcd(abs(a), abs(b), x0, y0);
if (c % g) {
return false;
}
x0 *= c / g;
y0 *= c / g;
if (a < 0) x0 = -x0;
if (b < 0) y0 = -y0;
return true;
}
void shift_solution(ll & x, ll & y, ll a, ll b, ll cnt) {
x += cnt * b;
y -= cnt * a;
}
ll find_all_solutions(ll a, ll b, ll c, ll minx, ll miny) {
ll x, y, g;
if (!find_any_solution(a, b, c, x, y, g))
return inf;
a /= g;
b /= g;
ll sign_a = a > 0 ? +1 : -1;
ll sign_b = b > 0 ? +1 : -1;
shift_solution(x, y, a, b, (minx - x) / b);
if (x < minx)
shift_solution(x, y, a, b, sign_b);
ll lx1 = x;
shift_solution(x, y, a, b, -(miny - y) / a);
if (y < miny)
shift_solution(x, y, a, b, -sign_a);
ll lx2 = x;
return max(lx1, lx2);
}
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 >> t;
while (t--) {
ll p, q;
cin >> x >> y >> p >> q;
ll a = 2 * (x + y), b = -(p + q);
ll mn = inf;
for (i = x; i < x + y; i++) {
for (j = p; j < p + q; j++) {
ll c = j - i;
z = find_all_solutions(a, b, c, 0ll, 0ll);
if (z != inf) {
mn = min(mn, a * z + i);
}
}
}
if (mn == inf) cout << "infinity\n";
else cout << mn << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Pld = pair<ld, ld>;
using Vec = vector<ll>;
using VecP = vector<P>;
using VecB = vector<bool>;
using VecC = vector<char>;
using VecD = vector<ld>;
using VecS = vector<string>;
using Graph = vector<VecP>;
#define REP(i, m, n) for(ll (i) = (m); (i) < (n); ++(i))
#define REPR(i, m, n) for(ll (i) = (m); (i) > (n); --(i))
#define rep(i, n) REP(i, 0, n)
#define repr(i, n) REPR(i, n, 0)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define in(a) insert(a)
#define P(p) cout<<(p)<<endl;
#define ALL(x) (x).begin(),(x).end()
#define ALLR(x) (x).rbegin(),(x).rend()
#define SORT(a) sort((a).begin(), (a).end())
#define RSORT(a) sort((a).rbegin(), (a).rend())
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vp;
typedef long long ll;
typedef pair<ll, ll> pll;
void sonic(){ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);}
void setp(const ll n){cout << fixed << setprecision(n);}
const ll INF = 1e9+1;
const ll LINF = 1e18+1;
const ll MOD = 998244353;
const ld PI = acos(-1);
template<typename T> void co(const vector<T>& v){for(const auto& e : v)
{ cout << e << " "; } cout << "\n";}
const ld EPS = 1e-11;
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return true;}return false;}
template<class T>bool chmin(T &a,const T &b){if(a>b){a=b;return true;}return false;}
template<typename T> void co(T e){cout << e << "\n";}
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
inline ll ksm(ll a,ll b,const ll m=MOD) {
int ans = 1;
while (b) {
if (b & 1) ans = 1ll * ans * a % m;
a = 1ll * a * a % m;
b >>= 1;
}
return ans;
}
set<int> divisor(int* n) {
set<int> ret;
for (int i = 1; i * i <= *n; i++) {
if (*n % i == 0) {
ret.insert(i);
if (i * i != *n) ret.insert(*n / i);
}
}
// sort(ret.begin(), ret.end()); // 昇順に並べる
return ret;
}
int f(int i){
int ret=0;
while(i!=0){
ret+=i%10;
i/=10;
}
return ret;
}
int main(){
ll n,ret=0,cnt=0;
cin>>n;
vll A;
rep(i,n){
ll a,b;
cin>>a>>b;
A.push_back(a*2+b);
ret+=a;
}
RSORT(A);
rep(i,n){
ret-=A[i];
cnt+=1;
if(ret<0)break;
}
co(cnt);
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
int N;
int A[3010], B[3010], C[3010], D[3010], E[3010];
bool dp[3010][100][10];
bool unit(int mid)
{
memset(dp, false, sizeof(dp));
rep(i, N)
{
int bit = 0;
bit |= (1LL << 0) * (A[i] >= mid);
bit |= (1LL << 1) * (B[i] >= mid);
bit |= (1LL << 2) * (C[i] >= mid);
bit |= (1LL << 3) * (D[i] >= mid);
bit |= (1LL << 4) * (E[i] >= mid);
dp[0][0][0] = true;
rep(j, (1LL << 5))rep(k, 3 + 1)
{
dp[i + 1][j][k] |= dp[i][j][k];
dp[i + 1][j | bit][k + 1] |= dp[i][j][k];
}
}
rep(i, 4)if(dp[N][(1LL << 5) - 1][i])return true;
return false;
}
signed main()
{
cin >> N;
rep(i, N)cin >> A[i] >> B[i] >> C[i] >> D[i] >> E[i];
int l = 0, r = 1e10;
rep(_, 100)
{
int mid = (l + r) / 2;
if(unit(mid))l = mid;
else r = mid;
}
cout << l << endl;
return 0;
} | #include<cmath>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<bitset>
#include<cstring>
#include<ctime>
#include<deque>
#include<iomanip>
#include<list>
#include<map>
#include<deque>
#include<queue>
#include<set>
#include<stack>
#include<vector>
#include<string>
#include<sstream>
#include<climits>
#include<chrono>
#include<random>
#include<unordered_set>
#include<unordered_map>
#include<ctype.h>
#include<cassert>
#include<numeric>
#include<functional>
using namespace std;
typedef long long ll; typedef unsigned long long ull; typedef long double ldb; typedef double db;typedef pair<ll, ll> pll; typedef pair<int, int> pii; typedef pair<ll, int> pli;
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define Debug cout<<"\nRight Here\n";
const double Pi = acos(-1.0); constexpr int inf = 1 << 29, Mod = 1e9 + 7, N = 1e5 + 3; constexpr ll INF = 1ll << 60;
ll qpow(ll a, ll b, ll mod = Mod, ll ans = 1) {
for (; b; b >>= 1, a = (a * a + mod) % mod)if (b & 1)ans = (ans * a + mod) % mod;
return ans;
}
ll gcd(ll a, ll b) { return (b ? gcd(b, a % b) : a); }; ll lcm(ll a, ll b) { return a * b / (gcd(a, b)); }
pii EXgcd(int x, int y) { //return.first ny
if (!y) { return { 1,0 }; }pii a = EXgcd(y, (x + y) % y);
return { a.second, a.first - a.second * (x / y) };
}
inline bool Ezisprime(const int n) {
if (n <= 1)return 0; if (n <= 3)return 1;
vector<int> ezp{ 5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97 };
for (int i = 0; i < ezp.size(); i++)if (n == ezp[i])return 1;
for (int i = 2; i <= sqrt(n); i++)if (n % i == 0)return 0;
return 1;
}
pll Fib(ll n) {
if (n == 0) return { 0, 1 };
auto p = Fib(n >> 1);
ll c = p.first * ((p.second) << 1 - p.first), d = p.first * p.first + p.second * p.second;
if (n & 1)return { d, c + d }; else return { c, d };
}
inline vector<ll> EuSieve(const ll& n) {
vector<ll> prime; vector<bool>is_prime(n + 1, 1);
for (ll i = 2; i <= n; ++i) {
if (is_prime[i])prime.emplace_back(i);
for (auto& p : prime) {
if (i * p > n)break;
is_prime[i * p] = 0;
if (i % p == 0)break;
}
}
return prime;
}
inline ll Digsum(ll n, ll ans = 0) {
for (; n; n /= 10)ans += n % 10;
return ans;
}
inline void modize(ll& n, const ll add, const ll mod = Mod) { n = ((n + add) % mod + mod) % mod; }
inline bool cmp(const pii a, const pii b) { //default more and more larger
return a.second < b.second;
}
//partial_sum(begin,end,place,minus<int>()) adjacent_differece(begin,end,place)
//count(begin(),end(),char=='x') count_if(begin(),end(),boolcmp) vector<int> p(n);iota(p.begin(), p.end(), 0);
//|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| Code follows ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\\
int main()
{
ios::sync_with_stdio(0); cin.tie(0), cout.tie(0);
int n; cin >> n;
vector<vector<ll>>a(n, vector<ll>(5));
for (auto& i : a)for (auto& j : i)cin >> j;
int l = 0, r = 1e9 + 1;
auto check = [&](int x)->bool
{
set<int>s;
for (auto i : a)
{
int bit = 0;
for (auto j : i)
{
bit <<= 1;
bit |= j >= x;
}
s.insert(bit);
}
for (auto i : s)for (auto j : s)for (auto k : s)if ((i | j | k) == 31)return 1;
return 0;
};
while (r - l > 1)
{
int mid = (l + r) >> 1;
(check(mid) ? l : r )= mid;
// cout << "l= " << l << " r= " << r << '\n';
}
cout << l << '\n';
}
/*
*/
|
#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
#define MAXN 1000005
#define lowbit(x) (x&-x)
#define reg register
#define mp make_pair
#define fir first
#define sec second
typedef long long LL;
typedef unsigned long long uLL;
const int INF=0x7f7f7f7f;
const int jzm=233;
const int mo=1e9+7;
const int zero=200;
const double Pi=acos(-1.0);
typedef pair<int,int> pii;
const double PI=acos(-1.0);
template<typename _T>
_T Fabs(_T x){return x<0?-x:x;}
template<typename _T>
void read(_T &x){
_T f=1;x=0;char s=getchar();
while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
while('0'<=s&&s<='9'){x=(x<<3)+(x<<1)+(s^48);s=getchar();}
x*=f;
}
LL k,n,dp[5][MAXN*3];
signed main(){
read(n);read(k);
for(LL i=1;i<=n;i++)dp[1][i]=1LL,dp[1][i]+=dp[1][i-1];
for(LL i=n+1;i<=3*n;i++)dp[1][i]=dp[1][n];
for(LL i=2;i<=2*n;i++)dp[2][i]+=dp[1][i-1]-dp[1][max(0LL,i-n-1LL)],dp[2][i]+=dp[2][i-1];
for(LL i=2*n+1;i<=3*n;i++)dp[2][i]=dp[2][2*n];
for(LL i=3;i<=3*n;i++)dp[3][i]+=dp[2][i-1]-dp[2][max(0LL,i-n-1LL)];
for(LL i=3;i<=3*n;i++){
//printf("%lld %lld %lld %lld\n",k,dp[3][i],dp[2][i]-dp[2][i-1],dp[1][i]-dp[1][i-1]);
if(k<=dp[3][i]){
for(LL j=1;j<=n;j++){
if(i-j>2*n)continue;
LL down=max(1LL,i-j-n),up=min(n,i-j-1);
//printf("%lld:%lld %lld\n",j,up,down);
if(k>up-down+1LL)k-=(up-down+1LL);
else{
printf("%lld %lld %lld\n",j,down+k-1LL,i-j-down-k+1LL);
return 0;
}
}
}
else k-=dp[3][i];
}
return 0;
}
/*
3:1
4:3
5:3
6:1
*/ | #include <bits/stdc++.h>
using namespace std;
int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; }
int __fastio = fastio();
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
typedef long long ll;
typedef pair<ll, ll> ii;
#define fi first
#define se second
#define sz(x) (int((x).size()))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
int main(){
ll n;
cin >> n;
ll res = 1;
set<ll> can;
// sqrtN
for(ll i=2;i*i<=n;i++) {
if(can.count(i)) continue;
ll cur = i;
// logN
while(cur*i <= n) {
cur *= i;
can.insert(cur);
}
}
cout << n - can.size() << "\n";
}
|
#include <bits/stdc++.h>
#define ll int
const ll maxx=1e9;
using namespace std;
ll func(string s[],vector<vector<ll>> &dp,ll x,ll y,ll h,ll w){
if(dp[x][y]!=maxx)
return dp[x][y];
if((x+y)%2==1){
ll val=maxx;
if(x<h-1)
val=min(val,func(s,dp,x+1,y,h,w));
if(y<w-1)
val=min(val,func(s,dp,x,y+1,h,w));
if(x==h-1 and y==w-1)
val=0;
if(x!=0 or y!=0){
if(s[x][y]=='-')
val-=1;
else
val+=1;
}
dp[x][y]=val;
}
else{
ll val=-maxx;
if(x<h-1)
val=max(val,func(s,dp,x+1,y,h,w));
if(y<w-1)
val=max(val,func(s,dp,x,y+1,h,w));
if(x==h-1 and y==w-1)
val=0;
if(x!=0 or y!=0){
if(s[x][y]=='-')
val+=1;
else
val-=1;
}
dp[x][y]=val;
}
return dp[x][y];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int h,w;
cin>>h>>w;
string s[h];
for(int i=0;i<h;i++)
cin>>s[i];
vector<vector<ll>> dp;
for(ll i=0;i<h;i++){
vector<ll> v;
for(ll j=0;j<w;j++)
v.push_back(maxx);
dp.push_back(v);
}
ll val=func(s,dp,0,0,h,w);
if(val==0)
cout<<"Draw";
else if(val>0)
cout<<"Takahashi";
else
cout<<"Aoki";
return 0;
} | //我的代码：
#include<bits/stdc++.h>
#define N 2005
using namespace std;
int n,m,c[N][N],t[N][N],a[N][N],ted[N][N],aed[N][N];
//ted/aed[i][j]分别表示t/a[i][j]是否已经计算完毕
char ch;
string s;
int A(int x,int y);
int T(int x,int y);
int main(){
cin>>n>>m,getline(cin,s);//读入
for(int i=1;i<=n;getline(cin,s),i++)
for(int j=1;j<=m;j++)c[i][j]=(ch=getchar()=='+')*2-1;
ted[n][m]=aed[n][m]=1;//初始化
if(T(1,1)<A(1,1))cout<<"Aoki"<<endl;
else if(T(1,1)>A(1,1))cout<<"Takahashi"<<endl;
else cout<<"Draw"<<endl;
// for(int i=1;i<=n;cout<<endl,i++)
// for(int j=1;j<=m;j++)cout<<T(i,j)-A(i,j)<<" ";//调试语句
return 0;
}
int T(int x,int y){//A的最优化
if(ted[x][y])return t[x][y];//记忆化
ted[x][y]=1;
if((x+y)&1)return A(x,y),t[x][y];//无操作权，交给对方转移
if(x==n)return aed[x][y]=1,a[x][y]=A(x,y+1),t[x][y]=T(x,y+1)+c[x][y+1];//只能向右走
if(y==m)return aed[x][y]=1,a[x][y]=A(x+1,y),t[x][y]=T(x+1,y)+c[x+1][y];//只能向下走
if(T(x,y+1)+c[x][y+1]-A(x,y+1)>T(x+1,y)+c[x+1][y]-A(x+1,y))//决策下和右哪个更优
return aed[x][y]=1,a[x][y]=A(x,y+1),t[x][y]=T(x,y+1)+c[x][y+1];
else return aed[x][y]=1,a[x][y]=A(x+1,y),t[x][y]=T(x+1,y)+c[x+1][y];
}
int A(int x,int y){//B的最优化
if(aed[x][y])return a[x][y];//记忆化
aed[x][y]=1;
if(!((x+y)&1))return T(x,y),a[x][y];//无操作权，交给对方转移
if(x==n)return ted[x][y]=1,t[x][y]=T(x,y+1),a[x][y]=A(x,y+1)+c[x][y+1];//只能向右走
if(y==m)return ted[x][y]=1,t[x][y]=T(x+1,y),a[x][y]=A(x+1,y)+c[x+1][y];//只能向下走
if(A(x,y+1)+c[x][y+1]-T(x,y+1)>A(x+1,y)+c[x+1][y]-T(x+1,y))//决策下和右哪个更优
return ted[x][y]=1,a[x][y]=A(x,y+1)+c[x][y+1],t[x][y]=T(x,y+1);
else return ted[x][y]=1,a[x][y]=A(x+1,y)+c[x+1][y],t[x][y]=T(x+1,y);
}
|
//112c.cpp created at 02/13/21 03:48:55
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "qpwoeirut/debug.h"
#else
#define debug
#define debug1
#define debug2
#define debug3
#endif
#define PB push_back
#define INS insert
#define FI first
#define SE second
#define sz(obj) ((int)(obj.size()))
#define all(obj) begin(obj), end(obj)
#define LB lower_bound
#define UB upper_bound
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef unsigned long long ull;
typedef long double dbl;
typedef pair<int,bool> pib;
typedef pair<ll,bool> plb;
typedef pair<dbl,dbl> pdd;
typedef map<int,int> mii;
typedef map<ll,ll> mll;
typedef map<char,int> mci;
typedef map<string,int> msi;
typedef map<string,string> mss;
ll gcd(ll a, ll b) {return b ? gcd(b, a%b) : a;}
template <class T1,class T2> struct cmpf {
bool rev;
inline bool operator()(const pair<T1,T2>& a, const pair<T1,T2>& b) const {return (a.first<b.first)^rev;}
cmpf(bool b=false) {rev=b;}
};
template <class T1,class T2> struct cmps {
bool rev;
inline bool operator()(const pair<T1,T2>& a, const pair<T1,T2>& b) const {return (a.second<b.second)^rev;}
cmps(bool b=false) {rev=b;}
};
ll binpow(ll x, ll p, const ll& mod) {assert(mod>0);
ll ret = 1;
for(; p>0; p>>=1, x = x*x % mod) if(p & 1) ret = ret*x % mod;
return ret;
}
template <class T> bool chmn(T& a, const T& b) {return (greater<T>()(a, b) ? (a=b, true) : false);}
template <class T> bool chmx(T& a, const T& b) {return (less<T>()(a, b) ? (a=b, true) : false);}
void setIO(const string& filename = "") {
if (filename.size() > 0) {
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
cin.tie(0)->sync_with_stdio(0);
}
int chr[8] = {-1, 0, 1, 0, -1, -1, 1, 1};
int chc[8] = {0, 1, 0, -1, -1, 1, -1, 1};
const ll MOD = 1e9+7; //998244353 //1e9+9 //1e9+21 // 1e9+33;
const int INIT = 1001001001;
const int MN = 1001001;
const ll INF = 2e18 + 1;
ll N, M, K, Q;
ll A[MN]; //, B[MN];
//ll G[MN][MN];
set<ll> adj[MN];
void process(const int u) {
A[u] = 1;
for (const int v: adj[u]) {
process(v);
A[u] += A[v];
}
}
int dp[MN];
void dfs(const int u) {
dp[u] = 1;
if (adj[u].empty()) {
return;
}
multiset<pii> keep, change;
for (const int v: adj[u]) {
dfs(v);
const int taker = dp[v];
const int mover = A[v] - dp[v];
if (A[v] & 1) {
change.emplace(taker - mover, v);
} else {
keep.emplace(taker - mover, v);
}
}
while (keep.size() > 0 && keep.begin()->FI <= 0) {
dp[u] += (A[keep.begin()->SE] + keep.begin()->FI) >> 1;
keep.erase(keep.begin());
}
bool flip = false;
while (change.size() > 0) {
if (!flip) {
dp[u] += (A[change.begin()->SE] + change.begin()->FI) >> 1;
} else {
dp[u] += A[change.begin()->SE] - ((A[change.begin()->SE] + change.begin()->FI) >> 1);
}
change.erase(change.begin());
flip = !flip;
}
while (keep.size() > 0) {
if (!flip) {
dp[u] += (A[keep.begin()->SE] + keep.begin()->FI) >> 1;
} else {
dp[u] += A[keep.begin()->SE] - ((A[keep.begin()->SE] + keep.begin()->FI) >> 1);
}
keep.erase(keep.begin());
}
}
void solve(int testcase) {
cin >> N;
for (int i=1; i<N; ++i) {
int p;
cin >> p;
--p;
adj[p].insert(i);
}
process(0);
dfs(0);
cout << dp[0] << endl;
}
int main() {
setIO();
ll T = 1;
for (int t=1; t<=T; ++t) {
solve(t);
}
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
typedef unsigned int unt;
std::vector<std::vector<unt>> adj;
int solve(unt v) {
std::vector<int> odd_difs;
int pos_even_dif_sum = 0, neg_even_dif_sum = 0;
for (auto u : adj[v]) {
int dif = solve(u);
if (dif % 2) { odd_difs.push_back(dif); }
else if (dif > 0) { pos_even_dif_sum += dif; }
else if (dif < 0) { neg_even_dif_sum += dif; }
}
std::sort(odd_difs.begin(), odd_difs.end());
bool par = true;
int a = 0;
for (auto d : odd_difs) {
if (par) { a += d; }
else { a -= d; }
par = !par;
}
return 1 + neg_even_dif_sum + a + (par ? pos_even_dif_sum : -pos_even_dif_sum);
}
int main() {
unt n;
std::cin >> n;
adj.resize(n);
for (unt i = 1u; i < n; i++) {
unt c;
std::cin >> c;
adj[c-1u].push_back(i);
}
int dif = solve(0);
std::cout << (int(n) + dif) / 2 << '\n';
} |
#include <iostream>
#include <iomanip>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <tuple>
#include <string>
#include <list>
#include <map>
#include <unordered_map>
using namespace std;
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
int n;
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for(int i = 0; i < N; i++) par[i] = i;
n=N;
}
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につける
n-=1;
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
int groupnumber(void){
return n;
}
};
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;
}
// a^{-1} mod を計算する
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
/*
sort(b.begin(),b.end(),[](const vector<int> &alpha,const vector<int> &beta){return alpha[0] < beta[0];});
第一成分で昇順
sort(r.begin(),r.end(),[](const vector<int> &alpha,const vector<int> &beta){return alpha[1] > beta[1];});
第二成分で降順
setprecision(15)
double型の表示桁数
*/
// 返り値: a と b の最大公約数
// ax + by = gcd(a, b) を満たす (x, y) が格納される
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a%b, y, x);
y -= a/b * x;
return d;
}
long long int gcd(long long int a, long long int b)
{
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
return b ? gcd(b, a % b) : a;
}
long long int lcm(long long int a, long long int b)
{
return a * b / gcd(a, b);
}
int main(){
long long int N,M,ans;
cin>>N>>M;
ans=modpow(10LL,N,M*M);
ans=ans/M;
cout<<ans%M<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define mkp make_pair
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
#define lin(x) ll x; cin>>x;
#define stin(x) string x; cin>>x;
#define yn(x) if(x) { cout<<"Yes"<<endl; } else { cout<<"No"<<endl; }
#define YN(x) if(x) { cout<<"YES"<<endl; } else { cout<<"NO"<<endl; }
#define co(x) cout<<x<<endl;
using ll=long long;
using ld=long double;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll mod=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template <typename T> inline bool chmax(T &a, T b) {
return ((a < b) ? (a = b, true) : (false));
}
template <typename T> inline bool chmin(T &a, T b) {
return ((a > b) ? (a = b, true) : (false));
}
ll powmod(ll n, ll k, ll m) {
ll r=1;
for(; k>0; k >>=1) {
if(k&1) r=(r*n)%m;
n=(n*n)%m;
}
return r;
}
ll fact(ll n) {
ll a=1;
rep(i,n) {
a=a*(n-i);
}
return a;
}
ll pow(ll a, ll b) {
ll x=1;
rep(i,b) {
x=x*a;
}
return x;
}
int main() {
lin(N);
lin(M);
ll x=powmod(10,N,M*M);
ll y=(x/M)%M;
co(y);
}
|
#include <bits/stdc++.h>
#define INF 1e9
#define INFLL 1ull<<60u
using namespace std;
#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(a) (a).begin(),(a).end()
#define endl "\n"
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
typedef long long ll;
using vi = vector<ll>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vpii = vector<pair<ll,ll>>;
vvi matrix_product(vvi a,vvi b) {
vvi matrix(3,vi(3,0));
REP(i,3)REP(j,3)REP(k,3) {
matrix[i][j] += a[i][k] * b[k][j];
}
return matrix;
}
void solve() {
const auto op1 = []()-> vvi {
vvi matrix(3,vi(3,0));
matrix[0][1] = 1;
matrix[1][0] = -1;
matrix[2][2] = 1;
return matrix;
}();
const auto op2 = []()-> vvi {
vvi matrix(3,vi(3,0));
matrix[0][1] = -1;
matrix[1][0] = 1;
matrix[2][2] = 1;
return matrix;
}();
const auto gen_op4 = [](int p)-> vvi {
vvi matrix(3,vi(3,0));
matrix[0][0] = 1;
matrix[1][1] = -1;
matrix[1][2] = 2 * p;
matrix[2][2] = 1;
return matrix;
};
const auto gen_op3 = [](int p)-> vvi {
vvi matrix(3,vi(3,0));
matrix[0][0] = -1;
matrix[0][2] = 2 * p;
matrix[1][1] = 1;
matrix[2][2] = 1;
return matrix;
};
int N; cin >> N;
vpii pieces(N);
REP(i,N) {
int X,Y; cin >> X >> Y;
pieces[i] = make_pair(X,Y);
}
vvi matrix(3,vi(3,0));
// 正則行列にする。
REP(i,3) matrix[i][i] = 1;
int M; cin >> M;
// x回目の累積積
vvvi states(M+1,vvi(3,vi(3,0)));
states[0] = matrix;
FOR(i,1,M+1) {
int op; cin >> op;
if (op == 1) states[i] = matrix_product(op1,states[i-1]);
else if (op == 2) states[i] = matrix_product(op2,states[i-1]);
else if (op == 3) {
int p; cin >> p;
states[i] = matrix_product(gen_op3(p),states[i-1]);
}
else if (op == 4) {
int p; cin >> p;
states[i] = matrix_product(gen_op4(p),states[i-1]);
}
else assert(false);
}
int Q; cin >> Q;
REP(_,Q) {
int A,B; cin >> A >> B; --B;
vvi piece_matrix(3,vi(3,0));
piece_matrix[0][0] = pieces[B].first;
piece_matrix[1][0] = pieces[B].second;
piece_matrix[2][0] = 1;
auto ans = matrix_product(states[A],piece_matrix);
cout << ans[0][0] << " " << ans[1][0] << endl;
}
}
int main() {
solve();
return 0;
} |
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <queue>
#include <string>
using namespace std;
typedef long long int ll;
int gcd(int a, int b)
{
while (a>0 && b>0)
{
if (a>b)
{
int c=b;
b=a%b;
a=c;
}
else
{
int c=a;
a=b%c;
b=c;
}
}
return max(a,b);
}
int n,m;
int counter;
vector<vector<int>> r;
vector<int> used;
void dfs(int v)
{
used[v]=1;
counter++;
for (auto x : r[v])
if (used[x]==0)
dfs(x);
}
void inputdirgr()
{
cin>>n>>m;
r.resize(n);
for (int i=0; i<m; i++)
{
int a,b;
cin>>a>>b;
a--;
b--;
r[a].push_back(b);
}
}
int t[100];
int a[100][200001];
int main()
{
int x,y;
int n;
cin>>n;
int T=0;
for (int i=0; i<n; i++)
{
cin>>t[i];
T+=t[i];
}
for (int i=0; i<n; i++)
for (int q=0; q<200001; q++)
a[i][q]=T+1;
a[0][100000+t[0]]=t[0];
a[0][100000-t[0]]=t[0];
for (int i=1; i<n; i++)
for (int q=-T; q<=T; q++)
if (a[i-1][100000+q]!=T+1)
{
if (q<0)
{
int ttt=a[i-1][100000+q];
int t1=max(q+t[i]+ttt,ttt);
int q1=q+t[i];
int t2=t[i]+ttt;
int q2=q-t[i];
a[i][100000+q1]=min(a[i][100000+q1],t1);
a[i][100000+q2]=min(a[i][100000+q2],t2);
}
else
{
int ttt=a[i-1][100000+q];
int t1=t[i]+ttt;
int q1=q+t[i];
int t2=max(-q+t[i]+ttt,ttt);
int q2=q-t[i];
a[i][100000+q1]=min(a[i][100000+q1],t1);
a[i][100000+q2]=min(a[i][100000+q2],t2);
}
}
int mint=T;
for (int i=0; i<200001; i++)
if (a[n-1][i]<mint)
mint=a[n-1][i];
cout<<mint;
/*counter=0;
for (int i=0; i<n; i++)
{
used.assign(n,0);
dfs(i);
}
cout<<counter;*/
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define mems(p) memset(p,-1,sizeof(p))
#define pb push_back
#define eb emplace_back
#define nl "\n"
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define allr(x) x.rbegin(), x.rend()
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using vd = vector<double>;
using vc = vector<char>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
using vvb = vector<vector<bool>>;
using vvd = vector<vector<double>>;
using vvc = vector<vector<char>>;
using vvpi = vector<vector<pi>>;
using vvpl = vector<vector<pl>>;
using vvvi = vector<vector<vector<int>>>;
using vvvl = vector<vector<vector<ll>>>;
using vvvb = vector<vector<vector<bool>>>;
using vvvd = vector<vector<vector<double>>>;
using vvvc = vector<vector<vector<char>>>;
using vvvpi = vector<vector<vector<pi>>>;
using vvvpl = vector<vector<vector<pl>>>;
const int mxN = 8e5 + 100;
const ll MOD = 1e9 + 7;
void fast()
{ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);}
ll gcd(ll a, ll b) {
return b ? gcd(b, a%b) : a;
}
vl factorial;
ll expo(ll x, ll exp, ll mod = MOD) {
if (exp <= 0) return 1;
ll tmp = (x*x) % mod;
if (exp%2) {
return (expo(tmp, exp/2, mod) * x) % mod;
}
return (expo(tmp, exp/2, mod)) % mod;
}
ll choice(ll n, ll r, ll mod = MOD) {
if (n < r) return 0;
ll numer = factorial[n];
ll denom = (factorial[r] * factorial[n-r]) % mod;
return numer * expo(denom, mod - 2, mod) % mod;
}
ll phi(ll n) {
ll result = n;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0)
n /= i;
result -= result / i;
}
}
if (n > 1)
result -= result / n;
return result;
}
int main() {
fast();
ll n, ans;
cin >> n;
ans = n;
map<ll, int> mp;
for (ll i = 2; i*i <= n; ++i)
{
ll cur = i*i;
if (mp[cur]) continue;
while (cur <= n) {
if (!mp[cur]) --ans;
mp[cur] = true;
cur *= i;
}
}
cout << ans << nl;
}
| #include <iostream>
#include <unordered_set>
using namespace std;
using ll = int64_t;
int main(){
ll N;
cin >> N;
unordered_set<ll> s;
for(ll a = 2; a * a <= N; a++){
ll x = a * a;
while(x <= N){
s.insert(x);
x *= a;
}
}
cout << N - s.size() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n;
void solve()
{
for(int i=0;i<n;++i){
cout<<(2*i)%n+1<<' '<<(2*i+1)%n+1<<'\n';
}
}
int main()
{
cin >> n;
solve();
} | #include <cstdio>
#include <cstring>
#include <algorithm>
#define reg register
const int N=400002;
long long ans;
bool cmp(const int &i,const int &j) {
return i>j;
}
struct heap{
int h[N],n;
void push(reg int x) {
h[++n]=x;
std::push_heap(h+1,h+1+n,cmp);
}
void pop() {
std::pop_heap(h+1,h+1+n,cmp);
--n;
}
int top() {
return h[1];
}
}q;
int a[N];
int R()
{
reg int x=0; reg bool f=0; reg char ch=getchar();
for(;ch<48||ch>57;ch=getchar()) f|=ch=='-';
for(;ch>=48&&ch<=57;ch=getchar()) x=x*10+ch-48;
return f?-x:x;
}
int main()
{
reg int n=R(),i;
for(i=1;i<=n<<1;++i) ans+=a[i]=R();
for(i=1;i<=n;++i) q.push(a[n+i]),q.push(a[n-i+1]),ans-=q.top(),q.pop();
printf("%lld",ans);
} |
#include <iostream>
#include <vector>
#include <array>
#include <map>
#include <set>
#include <cmath>
std::array<int, 2> cog(const std::vector < std::array<int, 2>>& ps)
{
std::array<int, 2> result = { 0,0 };
for (auto& e : ps)
{
result[0] += e[0];
result[1] += e[1];
}
result[0] /= (int)ps.size();
result[1] /= (int)ps.size();
return result;
}
void counter_tranlate_all(std::vector<std::array<int,2>>& ps, const std::array<int,2>& m)
{
for (auto& e : ps)
{
e[0] -= m[0];
e[1] -= m[1];
}
}
bool test_rot(
std::map<int, std::set<double>> ss_polar,
std::map<int, std::set<double>> ts_polar,
double rot)
{
for (auto&& d : ts_polar)
{
auto x = ss_polar[d.first];
auto y = ts_polar[d.first];
if (x.size() != y.size()) { return false; }
if(d.first == 0 )
{
continue;
}
std::set<double> mov_y;
for (auto e : y)
{
mov_y.insert(e + rot);
}
for (auto& y : mov_y)
{
bool ok = false;
for (auto& e : x)
{
if (std::remainder(y - e, 360.) < 1e-6)
{
ok = true;
break;
}
}
if (!ok) { return false; }
}
}
return true;
}
int main()
{
int N;
std::cin >> N;
std::vector<std::array<int, 2>> ss(N);
for (auto& e : ss)
{
std::cin >> e[0] >> e[1];
e[0] *= N;
e[1] *= N;
}
std::vector<std::array<int, 2>> ts(N);
for (auto& e : ts)
{
std::cin >> e[0] >> e[1];
e[0] *= N;
e[1] *= N;
}
auto cog_ss = cog(ss);
auto cog_ts = cog(ts);
counter_tranlate_all(ss, cog_ss);
counter_tranlate_all(ts, cog_ts);
int dist2_ss = 0;
for (auto& e : ss)
{
int d = e[0] * e[0] + e[1] * e[1];
if (dist2_ss < d) { dist2_ss = d; }
}
int dist2_ts = 0;
for (auto& e : ts)
{
int d = e[0] * e[0] + e[1] * e[1];
if (dist2_ts < d) { dist2_ts = d; }
}
if (dist2_ss != dist2_ts)
{
std::cout << "No" << std::endl;
return 0;
}
double PI = 3.14159265359;
std::map<int, std::set<double>> ss_polar;
for (auto& e : ss)
{
int d = e[0] * e[0] + e[1] * e[1];
ss_polar[d].insert(std::atan2(e[1],e[0])*180 /PI);
}
std::map<int, std::set<double>> ts_polar;
for (auto& e : ts)
{
int d = e[0] * e[0] + e[1] * e[1];
ts_polar[d].insert(std::atan2(e[1], e[0]) * 180 / PI);
}
std::set<double> moves;
{
double b = *ss_polar[dist2_ss].begin();
for (auto& t : ts_polar[dist2_ss])
{
moves.insert(b - t);
}
}
for (auto& e : moves)
{
auto ret = test_rot(ss_polar, ts_polar, e);
if (ret)
{
std::cout << "Yes" << std::endl;
return 0;
}
}
std::cout << "No" << std::endl;
return 0;
}
| //#include <atcoder/all>
#include <iostream>
#include <numeric>
#include <cmath>
#include <limits>
#include <stdio.h>
#include <iomanip>
#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
using namespace std;
//using namespace atcoder;
using ll = long long;
#define all(A) A.begin(),A.end()
using vll = vector<ll>;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
using Graph = vector<vector<pair<ll, ll>>>;
vector<ll> fact, factinv, inv;
ll mod = 1e9 + 7;
int main() {
ll N;
cin >> N;
vector<pair<ll, ll>> S(N), T(N);
vll La(N), Ra(N);
set<pair<ll, ll>> TP;
rep(i, N) {
ll L, R;
cin >> L >> R;
S[i] = make_pair(L, R);
}
rep(i, N) {
ll L, R;
cin >> L >> R;
T[i] = make_pair(L, R);
TP.insert(T[i]);
}
if (N == 1) {
cout << "Yes" << endl;
return 0;
}
if (N == 2) {
if ((S[0].first - S[1].first) * (S[0].first - S[1].first) + (S[0].second - S[1].second) * (S[0].second - S[1].second) == (T[0].first - T[1].first)
* (T[0].first - T[1].first) + (T[0].second - T[1].second) * (T[0].second - T[1].second)) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
}
rep(i, N) {
//S[0]→T[i]
rep(j, N) {
//S[1]→T[j]
if (i == j)continue;
if ((S[0].first - S[1].first) * (S[0].first - S[1].first) + (S[0].second - S[1].second) * (S[0].second - S[1].second) != (T[i].first - T[j].first)
* (T[i].first - T[j].first) + (T[i].second - T[j].second) * (T[i].second - T[j].second)) {
continue;
}
ll r = (S[0].first - S[1].first) * (S[0].first - S[1].first) + (S[0].second - S[1].second) * (S[0].second - S[1].second);
bool c = true;
for (ll k = 2; k < N; k++) {
ll dx1 = -S[0].first + S[1].first;
ll dy1 = -S[0].second + S[1].second;
ll dx = -S[0].first + S[k].first;
ll dy = -S[0].second + S[k].second;
ll dx2 = -T[i].first + T[j].first;
ll dy2 = -T[i].second + T[j].second;
ll tx = (dx * dx1 + dy1 * dy) * dx2 - (-dx * dy1 + dy * dx1) * dy2;
ll ty = (dx * dx1 + dy1 * dy) * dy2 + (-dx * dy1 + dy * dx1) * dx2;
tx /= r;
ty /= r;
if (!TP.count(make_pair(tx+ T[i].first, ty+ T[i].second))) {
c = false;
}
}
if (c) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
} |
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int t,n,a[100005];
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
int flag=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
sort(a+1,a+n+1);
if(n%2==1) printf("Second\n");
else
{
for(int i=2;i<=n;i+=2)
{
if(a[i]!=a[i-1]) flag=1;
}
if(!flag) printf("Second\n");
else printf("First\n");
}
}
return 0;
} | #include<bits/stdc++.h>
#include<iostream>
#include<set>
#include<map>
#include<iterator>
#define ll long long
#define lli long long int
#define pb push_back
#define RIP(i,n) for(int i=0; i<n; i++)
#define F(i,a,b) for(int i=a; i<b; i++)
#define RIP1(i,n) for(int i=n-1; i>=0; i--)
#define FOR(i,a,b) for(int i=a;i<(b); i++)
#define FOR1(i,a,b) for(int i=a; i>=(b); i--)
#define sc(a) scanf("%lld",&a)
#define SC(a) scanf("%d",&a)
#define cin(a) cin >> a
#define cout(a) cout << a
#define pi acos(-1)
#define pr(a) printf("%lld\n",a)
#define PR(a) printf("%lld ",a)
#define s(a,b) sort(a,b)
#define sz(x) (int)(x).size()
#define nl '\n'
#define Max 110
#define mod 1e9 + 7
using namespace std;
void c_p_c()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
/*#ifdef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif*/
}
int main()
{
int n;
cin >> n;
int x[n],y[n];
RIP(i,n)
{
cin >> x[i] >> y[i];
}
bool yes=false;
RIP(i,n)
{
F(j,0,i)
{
F(k,0,j)
{
int x1=x[i];
int y1=y[i];
int x2=x[j];
int y2=y[j];
int x3=x[k];
int y3=y[k];
x1-=x3;
x2-=x3;
y1-=y3;
y2-=y3;
if(x1*y2==x2*y1)
{
yes=true;
break;
}
}
if(yes)
{
break;
}
}
if(yes)
{
break;
}
}
if(yes)
{
cout << "Yes" << nl;
}
else
{
cout << "No" << nl;
}
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <queue>
#include <bitset>
#include <vector>
#include <stack>
#include <cstdlib>
#include <set>
#define mp make_pair
#define pb push_back
#define mem(i,a) memset(i,a,sizeof(i))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double db;
#define pii pair<ll,ll>
const ll INF=1000000007;
const ll DMAX=1000000+15;
const ll MOD=10000007;
template<class T> inline void read(T &x){
x=0;
T f=1;
char ch=getchar();
while(ch<'0' || ch>'9'){
if(ch=='-'){
f=-1;
}
ch=getchar();
}
while(ch<='9' && ch>='0'){
x=x*10+(ch-'0');
ch=getchar();
}
x*=f;
}
template<class T> void print(T x){
if(x<0){
putchar('-');
x=-x;
}
int a[20];
int cnt=0;
do{
a[++cnt]=x%10;
x/=10;
}while(x>0);
for(int i=cnt;i>=1;i--){
putchar(a[i]+'0');
}
puts("");
}
int n;
ll a[2002];
map<ll,ll> ma;
ll lp[DMAX],cnt=0;
int main(){
read(n);
ll mx=INF;
for(int i=1;i<=n;i++){
read(a[i]);
mx=min(mx,a[i]);
}
ma.clear();
for(int i=1;i<=n;i++){
for(int j=1;j<=sqrt(a[i]);j++){
if(a[i]%j==0){
if(ma[j]==0){
ma[j]=a[i];
lp[++cnt]=j;
}
else{
ma[j]=__gcd(ma[j],a[i]);
}
ll plo=a[i]/j;
if(ma[plo]==0){
ma[plo]=a[i];
lp[++cnt]=plo;
}
else{
ma[plo]=__gcd(ma[plo],a[i]);
}
}
}
}
ll ans=0;
for(int i=1;i<=cnt;i++){
if(ma[lp[i]]==lp[i] && lp[i]<=mx){
ans++;
}
}
print(ans);
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;
//最大公約数
ll gcd(ll x,ll y){
x = abs(x);
y = abs(y);
if(x < y){
swap(x,y);
}
if(y == 0){
return x;
}else{
return gcd(y,x%y);
}
}
map<ll,ll> MAP;
void func(ll num,ll base){
auto at = MAP.find(base);
if(at == MAP.end()){
MAP[base] = num;
}else{
ll tmp = MAP[base];
MAP[base] = gcd(tmp,num);
}
}
int main(){
int N;
scanf("%d",&N);
ll A;
ll mini = HUGE_NUM;
for(int i = 0; i < N; i++){
scanf("%lld",&A);
mini = min(mini,A);
for(ll k = 1; k*k <= A; k++){
if(A%k != 0)continue;
func(A,k);
func(A,A/k);
}
}
int ans = 1;
for(auto at = MAP.begin(); at != MAP.end(); at++){
if(at->first < mini && at->first == at->second){
ans++;
}
}
printf("%d\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,m,n) for(int i=(m);i<(n);++i)
#define rep(i,n) REP(i,0,n)
int main(){
int N;
cin >> N;
vector<vector<int>> vs;
rep(i,N){
int a,b,c;
cin >> a >> b >> c;
vector<int> tmp={a,b,c};
vs.push_back(tmp);
}
long long INF=10000000000000000;
long long DP[N][1<<N];
rep(i,N){
rep(j,(1<<N)){
DP[i][j]=INF;
}
}
DP[0][0]=0;
rep(t,N){
rep(i,N){
int a,b,c;
a=vs[i][0];
b=vs[i][1];
c=vs[i][2];
rep(j,N){
if(i==j){
continue;
}
int p,q,r;
p=vs[j][0];
q=vs[j][1];
r=vs[j][2];
int cost1=abs(p-a)+abs(q-b)+max(0,r-c);
int cost2=abs(a-p)+abs(b-q)+max(0,c-r);
rep(k,(1<<N)){
DP[j][k|(1<<i)]=min(DP[j][k|(1<<i)],DP[i][k]+cost1);
}
rep(k,(1<<N)){
DP[i][k|(1<<j)]=min(DP[i][k|(1<<j)],DP[j][k]+cost2);
}
}
}
}
cout << DP[0][(1<<N)-1] << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
#define all(v) v.begin(),v.end()
#define rep(i,a,b) for(int i = a; i <=b; i++)
#define rep2(i,a,b) for(int i = a; i>=b; i--)
#define PB push_back
#define MP make_pair
#define db long double
#define trace1(x) cerr<<#x<<": "<<x<<endl
#define trace2(x, y) cerr<<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl
#define trace3(x, y, z) cerr<<#x<<":" <<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl
#define trace4(a, b, c, d) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<endl
#define trace5(a, b, c, d, e) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<< ": "<<e<<endl
#define trace6(a, b, c, d, e, f) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<< ": "<<e<<" | "<<#f<<": "<<f<<endl
#define cases int testcases;cin>>testcases; while(testcases--)
#define INF 2000000000
const double PI = acos(-1);
const int N = 100005;
#define eps 1e-6
#define MOD 1000000007
int32_t main()
{
IOS
int n,k,m;
cin >> n >> k >> m;
m*=(n);
int arr[n];
int sum = 0;
for(int i = 1; i <= n-1; i++)
{
cin >> arr[i];
sum += arr[i];
}
int l = max(0LL,m-sum);
if(l > k)
{
l = -1;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c;
cin >> a >> b >> c;
if (a == b == c) {
cout << c;
}
else if (a == b) {
cout << c;
}
else if (b == c) {
cout << a;
}
else if (a == c) {
cout << b;
}
else {
cout << 0;
}
}
| #include<iostream>
#include<math.h>
using namespace std;
int main() {
float R, X, Y;
cin >> R >> X >> Y;
float d = sqrt(X * X + Y * Y);
int a = ceil(d / R);
if (d < R) cout << 2 << endl;
else cout << a << endl;
} |
#include "bits/stdc++.h"
#define int long long
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = (1LL << 61);
ll mod = 1000000007;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
reverse(s1.begin(), s1.end());
reverse(s2.begin(), s2.end());
reverse(s3.begin(), s3.end());
int n1 = s1.size(), n2 = s2.size(), n3 = s3.size();
map<char, int>mp;
for (int i = 0; i < n1; i++) {
mp[s1[i]]++;
}
for (int i = 0; i < n2; i++) {
mp[s2[i]]++;
}for (int i = 0; i < n3; i++) {
mp[s3[i]]++;
}
map<char, int>tmp;
int now = 0;
for (auto p : mp) {
tmp[p.first] = now;
now++;
}
mp = tmp;
int S = mp.size();
if (S > 10) {
cout << "UNSOLVABLE" << endl; return 0;
}
vector<int>pe;
for (int i = 0; i < 10; i++) {
pe.push_back(i);
}
do {
bool ok = true;
int t = 1;
int ans1 = 0, ans2 = 0, ans3 = 0;
for (int i = 0; i < n1; i++) {
int nv = pe[mp[s1[i]]];
if (i == n1 - 1 && nv == 0)ok = false;
ans1 += nv * t;
t *= 10;
}
t = 1;
for (int i = 0; i < n2; i++) {
int nv = pe[mp[s2[i]]];
if (i == n2 - 1 && nv == 0)ok = false;
ans2 += nv * t;
t *= 10;
}
t = 1;
for (int i = 0; i < n3; i++) {
int nv = pe[mp[s3[i]]];
if (i == n3 - 1 && nv == 0)ok = false;
ans3 += nv * t;
t *= 10;
}
if (ans1 + ans2 != ans3)ok = false;
if (ok) {
cout << ans1 << endl;
cout << ans2 << endl;
cout << ans3 << endl;
return 0;
}
} while (next_permutation(pe.begin(), pe.end()));
cout << "UNSOLVABLE" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i < (b); ++i)
#define per(i, a, b) for(int i = (b)-1; i >= (a); --i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define pb push_back
#define eb emplace_back
#define mp make_pair
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; }
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pii> vii;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
int n, k;
cin >> n >> k;
vi cnt(n+1);
rep(i,0,n) {
int x;
cin >> x;
++cnt[x];
}
int tot = min(cnt[0], k);
ll ans = 0;
rep(i,1,n+1) {
if (tot == 0) break;
// how many i do we have
int nxt = min(tot, cnt[i]);
int rm = tot-nxt;
ans += ll(i) * ll(rm);
tot = nxt;
}
cout << ans << '\n';
} |
#include<bits/stdc++.h>
using namespace std;
void p(){cout<<"Yes"<<endl;};
void q(){cout<<"No"<<endl;};
int main(){
int N;cin>>N;
vector<int> A(N);
for(int i=0;i<N;i++){
int a;cin>>a;
A.at(i)=a%200;
}
//sort(A.begin(),A.end());
//set<int> s;
map<int,vector<int>> X;
/*for(int i=0;i<N;i++){
if(s.count(A[i].first)){
p();
cout<<1<<' '<<A[i].second<<endl;
cout<<X[A[i].first].size()<<' ';
for(auto x:X[A[i].second]) cout<<x;
cout<<endl;
return 0;
}
else{
s.insert(i);
X[A[i].first].push_back(A[i].second);
}
}*/
int n=min(N,16),cnt=0,y=0;
int l=pow(2,n),m=0;
//cout<<l<<endl;
vector<int> Y;
for(int i=1;i<l;i++){
Y.clear();
m=i;
y=0;
cnt=0;
while(m>0){
if(m&1){
y+=A[cnt];
Y.push_back(cnt+1);
}
m=m>>1;
cnt++;
}
y%=200;
sort(Y.begin(),Y.end());
if(X.count(y)){
p();
cout<<X[y].size()<<' ';
for(auto x:X[y]) cout<<x<<' ';
cout<<endl;
cout<<Y.size()<<' ';
for(auto z:Y) cout<<z<<' ';
cout<<endl;
return 0;
}
else X[y]=Y;
}
q();
return 0;
} | #include <iostream>
#include <vector>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <climits>
#include <cmath>
#include <algorithm>
#include <stack>
using namespace std;
typedef long long ll;
#define debuglist(x) for(int i = 0; i < x.size(); ++i) { cout << x[i] << " "; } cout << endl;
void solve(){
int n;
cin >> n;
vector<int> ar(n+1, 0);
for(int i = 0; i < n; ++i){
cin >> ar[i];
}
stack<pair<int, int>> st;
int maxOrange = 0;
for(int i = 0; i < n+1; ++i){
if(st.empty()) {
st.push({ar[i], i});
} else {
int first_idx = -1;
int first_min = INT_MAX;
while(!st.empty() && ar[i] < st.top().first) {
auto [val, idx] = st.top(); st.pop();
int orange = val*(i-idx);
maxOrange = max(orange, maxOrange);
first_idx = idx;
first_min = min(val, first_min);
}
if(first_idx != -1) {
st.push({ar[i], first_idx});
} else {
st.push({ar[i], i});
}
}
}
cout << maxOrange << "\n";
}
int main() {
// int cas;
// cin >> cas;
//
// while (cas--) {
// solve();
// }
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
const long long MOD = 1000000007;
int main(){
long double ax,ay,bx,by;
cin >> ax >> ay >> bx >> by;
if(ax==bx) cout << ax << endl;
else{
cout << fixed << setprecision(10);
if(ax<bx){
cout<<ax+(bx-ax)*(ay/(ay+by))<<endl;
}
else{
cout<<bx+(ax-bx)*(by/(ay+by))<<endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
using ll = long long;
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
int n;
vector<int> t,l,r;
void solve() {
ll ans = 0;
REP(i,n) {
int left = l[i], right = r[i];
int left_kai = 0, right_kai = 0;
if (t[i] == 1) {
} else if (t[i] == 2) {
right_kai = 1;
} else if (t[i] == 3) {
left_kai = 1;
} else {
right_kai = 1;
left_kai = 1;
}
for(int j = i+1; j < n; j++) {
int leftj = l[j], rightj = r[j];
int leftj_kai = 0, rightj_kai = 0;
if (t[j] == 1) {
} else if (t[j] == 2) {
rightj_kai = 1;
} else if (t[j] == 3) {
leftj_kai = 1;
} else {
rightj_kai = 1;
leftj_kai = 1;
}
if (right_kai && leftj_kai) {
if (right <= leftj) continue;
}
if (!right_kai && leftj_kai) {
if (right <= leftj) continue;
}
if (right_kai && !leftj_kai) {
if (right <= leftj) continue;
}
if (!right_kai && !leftj_kai) {
if (right < leftj) continue;
}
if (rightj_kai && left_kai) {
if (rightj <= left) continue;
}
if (!rightj_kai && left_kai) {
if (rightj <= left) continue;
}
if (rightj_kai && !left_kai) {
if (rightj <= left) continue;
}
if (!rightj_kai && !left_kai) {
if (rightj < left) continue;
}
ans++;
}
}
cout << ans << endl;
return;
}
int main() {
cin >> n;
t.resize(n);
l.resize(n);
r.resize(n);
REP(i,n) cin >> t[i] >> l[i] >> r[i];
solve();
return 0;
} |
//#define _GLIBCXX_DEBUG
//#include "atcoder/all"
//using namespace atcoder;
#include <bits/stdc++.h>
#define int long long
#define ll long long
using ull = unsigned long long;
using namespace std;
#define Dump(x) \
if (dbg) { \
cerr << #x << " = " << (x) << endl; \
}
#define overload4(_1, _2, _3, _4, name, ...) name
#define FOR1(n) for (ll i = 0; i < (n); ++i)
#define FOR2(i, n) for (ll i = 0; i < (n); ++i)
#define FOR3(i, a, b) for (ll i = (a); i < (b); ++i)
#define FOR4(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define FOR(...) overload4(__VA_ARGS__, FOR4, FOR3, FOR2, FOR1)(__VA_ARGS__)
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define bit(n, k) (((n) >> (k)) & 1) /*nのk bit目*/
namespace mydef {
const int INF = 1ll << 60;
const int MOD = 1e9 + 7;
template <class T>
bool chmin(T& a, const T& b) {
if (a > b) {
a = b;
return 1;
} else
return 0;
}
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
} else
return 0;
}
void Yes(bool flag = true) {
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void No(bool flag = true) {
Yes(!flag);
}
void YES(bool flag = true) {
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void NO(bool flag = true) {
YES(!flag);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T& val) {
std::fill((T*)array, (T*)(array + N), val);
}
bool dbg = true;
} // namespace mydef
using namespace mydef;
#define pb push_back
//#define mp make_pair
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define SZ(x) ((int)(x).size())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vp vector<pair<int, int>>
#define vvp vector<vector<pair<int, int>>>
#define pi pair<int, int>
//#define P pair<int, int>
//#define V vector<int>
//#define S set<int>
#define asn ans
int N, A[101010], B[101010];
void solve() {
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int SUM = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
SUM += A[i] * B[i];
}
Yes(SUM == 0);
solve();
return 0;
}
| #include<iostream>
#include<algorithm>
#include<vector>
#include<math.h>
#include<functional>
#include<utility>
using namespace std;
int main(void){
int n;
cin >> n;
vector<int> a(n), b(n);
for(int i = 0; i < n; ++i){
cin >> a[i];
}
for(int i = 0; i < n; ++i){
cin >> b[i];
}
int product = 0;
for(int i = 0; i < n; ++i){
product += a[i] * b[i];
}
if(product == 0){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
} |
#include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
// #include <atcoder/all>
// using namespace atcoder;
// @@ !! LIM()
int main(/* int argc, char *argv[] */) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(20);
ll a, b, c, d; cin >> a >> b >> c >> d;
cout << b - c << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll>pll;
typedef pair<ll,pair<ll,ll>>plll;
#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));
#define vll(v) v.begin(),v.end()
#define all(x) x.rbegin(),x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define sf(a) scanf("%d",&a)
#define pf(a) printf("%d",a);
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int,vector<int>,greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))
#define bug cout<<"BUG"<<endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI =3.141592653589793238463;
bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.first > b.first);
}
ll lcm(ll a,ll b)
{
if(a==0 || b==0)return 0;
return a/__gcd(a,b)*b;
}
void input(ll ara[],ll n)
{
for(ll i=0; i<n; i++)cin>>ara[i];
}
void print(ll ara[],ll n)
{
for(ll i=0; i<n; i++)
cout<<ara[i]<<" ";
cout<<endl;
}
int main()
{
fastread();
ll i,j,n,m,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r,ans=0;
bool flag=false;
string str;
cin>>a>>b>>c>>d;
ans=a-c;
ans=max(ans,a-d);
ans=max3(ans,b-c,b-d);
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,n,m) for(int i=(int)(n); i<=(int)(m); i++)
#define RFOR(i,n,m) for(int i=(int)(n); i>=(int)(m); i--)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define RITR(x,c) for(__typeof(c.rbegin()) x=c.rbegin();x!=c.rend();x++)
#define setp(n) fixed << setprecision(n)
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
#define ll long long
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll,ll>
#define pi pair<int,int>
#define all(a) (a.begin()),(a.end())
#define rall(a) (a.rbegin()),(a.rend())
#define fi first
#define se second
#define pb push_back
#define ins insert
#define debug(a) cerr<<(a)<<endl
#define dbrep(a,n) rep(_i,n) cerr<<(a[_i])<<" "; cerr<<endl
#define dbrep2(a,n,m) rep(_i,n){rep(_j,m) cerr<<(a[_i][_j])<<" "; cerr<<endl;}
using namespace std;
template<class A, class B>
ostream &operator<<(ostream &os, const pair<A,B> &p){return os<<"("<<p.fi<<","<<p.se<<")";}
template<class A, class B>
istream &operator>>(istream &is, pair<A,B> &p){return is>>p.fi>>p.se;}
template<class T>
vector<T> make_vec(size_t a){
return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
/* Some Libraries */
//-------------------------------------------------
bool dp[201][201][201][2];
using P = tuple<int,int,int,int>;
P prv[201][201][201][2];
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin>>N;
vll a(N);
rep(i,N) cin>>a[i], a[i]%=200;
dp[0][0][0][0] = true;
rep(i,N)rep(j,200)rep(k,200)rep(l,2){
if (!dp[i][j][k][l]) continue;
{
int nj = (j+a[i])%200;
dp[i+1][nj][k][1] = true;
prv[i+1][nj][k][1] = P(i,j,k,l);
}
{
int nk = (k+a[i])%200;
dp[i+1][j][nk][1] = true;
prv[i+1][j][nk][1] = P(i,j,k,l);
}
{
int nj = (j+a[i])%200;
int nk = (k+a[i])%200;
dp[i+1][nj][nk][l] = true;
prv[i+1][nj][nk][l] = P(i,j,k,l);
}
}
int s=-1,t=-1;
rep(i,200){
if (dp[N][i][i][1]){
s=i, t=i;
break;
}
}
if (s==-1){
cout<<"No\n";
return 0;
}
vi B,C;
P cur(N,s,t,1);
// fprintf(stderr, "%d %d %d %d\n", N,s,t,1);
while(true){
int i,j,k,l;
tie(i,j,k,l) = cur;
if (i==0) break;
P p = prv[i][j][k][l];
int ni,nj,nk,nl;
tie(ni,nj,nk,nl) = p;
if (nl==0 && l==1){
if ((nj+a[ni])%200==j){
B.pb(i);
}else{
C.pb(i);
}
}else{
if ((nj+a[ni])%200==j) B.pb(i);
if ((nk+a[ni])%200==k) C.pb(i);
}
// fprintf(stderr, "%d %d %d %d\n", ni,nj,nk,nl);
cur = p;
}
reverse(all(B));
reverse(all(C));
cout<<"Yes\n";
cout<<B.size();
rep(i,B.size()) cout<<" "<<B[i]; cout<<"\n";
cout<<C.size();
rep(i,C.size()) cout<<" "<<C[i]; cout<<"\n";
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define FastIO ios_base::sync_with_stdio(false); cin.tie(0);
#define ll long long
#define ull unsigned long long
#define pb push_back
#define All(x) (x).begin(),(x).end()
#define mp make_pair
#define nl "\n"
typedef pair<int,int>ii;
typedef vector<int>vi;
typedef vector<ii>vii;
typedef vector<vi>vvi;
typedef vector<long long>vl;
typedef vector <vl>vvl;
template<class T>
void print(T& a)
{
for(auto x:a)
cout<<x<<" ";
cout<<"\n";
}
int main()
{
FastIO
int n;
cin>>n;
int a[n];
for(int i=0; i<n; i++)cin>>a[i];
vvi v(205);
int len=pow(2,min(n,8));
for(int i=1; i<len; i++)
{
ll sum=0;
vi vv;
for(int j=0; j<min(n,8); j++)
{
if((1<<j)&i)
{
vv.pb(j+1);
sum+=a[j];
sum%=200;
}
}
if(!v[sum].empty())
{
cout<<"Yes\n";
cout<<v[sum].size()<<" ";
print(v[sum]);
cout<<vv.size()<<" ";
print(vv);
return 0;
}
else v[sum]=vv;
}
cout<<"No\n";
return 0;
} |
#include <iostream>
#include <vector>
#include <set>
using ll = long long;
int const nmax = 200000;
int v[1 + nmax * 2];
int main() {
std::ios::sync_with_stdio(0);
int n;
std::cin >> n;
for(int i = 1;i <= 2 * n; i++)
std::cin >> v[i];
std::multiset<int> myset;
ll result = 0;
for(int i = 1; i <= n; i++) {
myset.insert(v[i]);
myset.insert(v[2 * n - i + 1]);
result += *myset.rbegin();
std::multiset<int>::iterator it = myset.end();
it--;
myset.erase(it);
}
std::cout << result;
return 0;
}
| #pragma GCC optimize ("O2")
#pragma GCC target ("avx2")
//#include<bits/stdc++.h>
//#include<atcoder/all>
//using namespace atcoder;
#include<iostream>
#include<cstring>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int IM = 2e9;
int dat[400004];
const int CM = 1 << 17, CL = 12;
char cn[CM + CL], * ci = cn + CM + CL, * owa = cn + CM, ct;
const ll ma0 = 1157442765409226768;
const ll ma1 = 1085102592571150095;
const ll ma2 = 71777214294589695;
const ll ma3 = 281470681808895;
const ll ma4 = 4294967295;
inline int getint() {
if (ci - owa > 0) {
memcpy(cn, owa, CL);
ci -= CM;
fread(cn + CL, 1, CM, stdin);
}
ll tmp = *(ll*)ci;
if ((tmp & ma0) ^ ma0) {
int dig = 68 - __builtin_ctzll((tmp & ma0) ^ ma0);
tmp = tmp << dig & ma1;
tmp = tmp * 10 + (tmp >> 8) & ma2;
tmp = tmp * 100 + (tmp >> 16) & ma3;
tmp = tmp * 10000 + (tmp >> 32) & ma4;
ci += (72 - dig >> 3);
}
else {
tmp = tmp & ma1;
tmp = tmp * 10 + (tmp >> 8) & ma2;
tmp = tmp * 100 + (tmp >> 16) & ma3;
tmp = tmp * 10000 + (tmp >> 32) & ma4;
ci += 8;
if ((ct = *ci++) >= '0') {
tmp = tmp * 10 + ct - '0';
if (*ci++ == '0') {
tmp = tmp * 10;
ci++;
}
}
}
return tmp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N = getint();
dat[0] = -IM;
ll kotae = -IM * ll(N);
for (int i = N + 1; i > 1; i--) {
dat[i] = getint();
kotae += dat[i];
}
for (int i = 2; i < N + 2; i++) {
int p = 2 + (dat[2] > dat[3]);
int v = dat[i] - IM;
while (v > dat[p]) {
dat[p >> 1] = dat[p];
p <<= 1;
p += dat[p] > dat[p + 1];
}
dat[p >> 1] = v;
int a = getint();
kotae += a;
p = i;
v = a - IM;
while (v < dat[p >> 1]) dat[p] = dat[p >> 1], p >>= 1;
dat[p] = v;
kotae -= dat[1];
}
co(kotae);
Would you please return 0;
} |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int arr[4];
int a;
for(int i=0;i<4;i++){
cin>>a;
arr[i]=a;
}
cout << *min_element(arr,arr+4) << endl;
return 0;
} | // https://atcoder.jp/contests/abc185/tasks/abc185_a
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n - 1; i >= 0; i--)
#define ALL(x) x.begin(), x.end()
using str = string;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvl = vector<vector<ll>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
int main() {
int ans = 100;
rep(i, 4) {
int a;
cin >> a;
ans = min(ans, a);
}
cout << ans << endl;
}
|
#include <iostream>
#include <cmath>
#include <iomanip>
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <map>
#include <set>
#include <bitset>
#include <string>
#include <algorithm>
#include <iterator>
#include <unordered_map>
#include <unordered_set>
#include <sstream>
#include <fstream>
#include <numeric>
#include <tuple>
#include <ctime>
#include <random>
using namespace std;
#define fori(t) for(int i = 0; i < t; ++i)
#define forj(n) for(int j = 0; j < n; ++j)
#define fork(n) for(int k = 0; k < n; ++k)
#define forai(a) for(auto& i : a)
#define foraj(a) for(auto& j : a)
#define forak(a) for(auto& k : a)
#define forp(s, n, d) for(int p = s; p < n; p += d)
#define fast cin.tie(0); cout.tie(0); std::ios_base::sync_with_stdio(0);
#define pb(a) push_back(a);
#define pob(a) pop_back(a);
#define sorti(a) sort((a).begin(), (a).end());
#define sortm(a, n) sort(a, a + n);
#define reversi(a) reverse((a).begin(), (a).end());
#define all(a) (a).begin(), (a).end()
#define fi first
#define se second
#define yes cout << "Yes\n";
#define no cout << "No\n";
#define ans(a) cout << a << '\n';
#define endl cout << '\n';
#define res(a, n) (a).resize(n);
#define read(a, n) (a).resize(n); fori(n) cin >> a[i];
#define print(a) for (auto i : a) cout << i << ' ';
#define clear(a) (a).clear();
//#define int long long
//#define double long double
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<long long, long long> llll;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<pair<int, int>> vii;
typedef vector<pair<int, pair<int, int>>> viii;
typedef pair<int, pair<int, int>> iii;
typedef vector<pair<long long, long long>> vllll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvll;
typedef vector<bool> vb;
typedef pair<char, char> cc;
typedef pair<pair<char, char>, char> ccc;
typedef vector<char> vc;
typedef pair<int, char> ic;
typedef pair<ii, char> iic;
typedef vector<bool> vb;
typedef set<int> si;
typedef vector<vector<ii>> vvii;
typedef vector<vector<iii>> vviii;
typedef vector<vector<llll>> vvllll;
const int INF = 2147483647;
const ll LONGINF = 9223372036854775807;
const ll MOD = 1e9 + 7;
string s;
list<char> help;
void solve()
{
int n;
cin >> n >> s;
string est = "";
fori(n) help.push_back(s[i]);
auto i = help.begin();
while (i != help.end())
{
est += *i;
if (est.size() == 3)
{
if (est == "fox")
{
auto first = i, last = i;
--first;
--first;
++last;
auto next = help.erase(first, last);
if (next != help.begin()) --next;
if (next != help.begin()) --next;
i = next;
est = "";
}
else
{
string temp = est;
est = "";
est += temp[1];
est += temp[2];
++i;
}
}
else ++i;
}
ans(help.size())
}
signed main()
{
fast
bool mult = false;
if (mult)
{
int t;
cin >> t;
while (t--) solve();
}
else solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef double T;
T EPS = 1e-7;
int cmp(T x, T y = 0) {
return (x <= y + EPS) ? (x + EPS < y) ? -1 : 0 : 1;
}
struct point {
T x, y;
int id;
point(T x_ = 0, T y_ = 0, int id_ = -1): x(x_), y(y_), id(id_) {}
point operator + (const point& b) const { return point(x + b.x, y + b.y); }
point operator - (const point& b) const { return point(x - b.x, y - b.y); }
point operator * (T c) { return point(x*c, y*c); }
point operator / (T c) { return point(x/c, y/c); }
};
inline T escalar(point a, point b) {
return a.x * b.x + a.y * b.y;
}
inline T vetorial(point a, point b) {
return a.x * b.y - a.y * b.x;
}
T angle(point p, point q, point o) {
point u = p - o, v = q - o;
return atan2(vetorial(u, v), escalar(u, v));
}
point rot(point p, double a) {
return {p.x*cos(a) - p.y*sin(a), p.x*sin(a) + p.y*cos(a)};
}
int n, nmatch[110];
point p1[110], p2[110], tmp;
int main() {
scanf("%d", &n);
for(int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
p1[i] = point(x, y);
}
for(int i = n-1; i >= 0; i--)
p1[i] = p1[i] - p1[0];
for(int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
p2[i] = point(x, y);
}
if(n == 1) {
puts("Yes");
return 0;
}
for(int i = 0; i < n; i++) {
point dif = p1[0] - p2[i];
for(int j = 0; j < n; j++) {
if(j == i) continue;
T ang = angle(p2[j]+dif, p1[1], p1[0]);
int flag = 0;
for(int k = 0; k < n; k++) {
tmp = rot(p2[k] + dif, ang);
for(int l = 0; l < n; l++) {
if(escalar(tmp - p1[l], tmp - p1[l]) < EPS) {
if(nmatch[l]++ == 0) flag++;
}
}
}
if(flag == n) {
puts("Yes");
return 0;
}
memset(nmatch, 0, sizeof nmatch);
}
}
puts("No");
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <tuple>
#include <numeric>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define exrep(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
int main() {
ll a, b;
cin >> a >> b;
cout << (a+b)/2 << " " << (a-b)/2 << endl;
re0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define mkp make_pair
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
#define lin(x) ll x; cin>>x;
#define stin(x) string x; cin>>x;
#define yn(x) if(x) { cout<<"Yes"<<endl; } else { cout<<"No"<<endl; }
#define YN(x) if(x) { cout<<"YES"<<endl; } else { cout<<"NO"<<endl; }
#define co(x) cout<<x<<endl;
using ll=long long;
using ld=long double;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll mod=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template <typename T> inline bool chmax(T &a, T b) {
return ((a < b) ? (a = b, true) : (false));
}
template <typename T> inline bool chmin(T &a, T b) {
return ((a > b) ? (a = b, true) : (false));
}
ll powmod(ll n, ll k, ll m) {
ll r=1;
for(; k>0; k >>=1) {
if(k&1) r=(r*n)%m;
n=(n*n)%m;
}
return r;
}
ll fact(ll n) {
ll a=1;
rep(i,n) {
a=a*(n-i);
}
return a;
}
ll pow(ll a, ll b) {
ll x=1;
rep(i,b) {
x=x*a;
}
return x;
}
int main() {
lin(N);
lin(M);
ll x=powmod(10,N,M*M);
ll y=(x/M)%M;
co(y);
}
|
#include <bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
using namespace std;
#define P 1000000007
#define rep(i,n) for(i=0;i<n;++i)
#define re(i,a,n) for(i=a;i<=n;++i)
#define repr(i,a,n) for(i=a;i>=n;--i)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define endl "\n"
#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 mset(a,val) memset(a,val,sizeof(a));
#define at(s,pos) *(s.find_by_order(pos))
#define set_ind(s,val) s.order_of_key(val)
#define PI 3.14159265
/*#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
#include <functional> // for less
#include <iostream>
// Important header files
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;*/
ll binpowmod(ll a, ll b, ll m) {
a %= m;
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int findMin(vector<int> arr, int n)
{
// Calculate sum of all elements
int sum = 0;
for (int i = 0; i < n; i++)
sum += arr[i];
// Create an array to store results of subproblems
bool dp[n+1][sum+1];
// Initialize first column as true. 0 sum is possible
// with all elements.
for (int i = 0; i <= n; i++)
dp[i][0] = true;
// Initialize top row, except dp[0][0], as false. With
// 0 elements, no other sum except 0 is possible
for (int i = 1; i <= sum; i++)
dp[0][i] = false;
// Fill the partition table in bottom up manner
for (int i=1; i<=n; i++)
{
for (int j=1; j<=sum; j++)
{
// If i'th element is excluded
dp[i][j] = dp[i-1][j];
// If i'th element is included
if (arr[i-1] <= j)
dp[i][j] |= dp[i-1][j-arr[i-1]];
}
}
// Initialize difference of two sums.
int diff = sum;
// Find the largest j such that dp[n][j]
// is true where j loops from sum/2 t0 0
for (int j=sum/2; j>=0; j--)
{
// Find the
if (dp[n][j] == true)
{
diff = sum-j;
break;
}
}
return diff;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t,i,j,f,e,x,y,mid,z,w,d,c,b,h,a,k,q,p;
ll t1,t2,t3,ans=0,tc,t4,m,l,n ;
cin >> n >> m;
vector<vector<pair<ll,pair<ll,ll>>>> adj(n+1);
rep(i,m)
{
cin >> x >> y >> a >> b ;
adj[x].pb({y,{a,b}});
adj[y].pb({x,{a,b}});
}
vector<ll> dist(n+1,1e18);
dist[1]=0;
set<pair<ll,ll>> s;
s.insert({0,1});
while(!s.empty())
{
auto u=*s.begin();
s.erase(s.begin());
for(auto v:adj[u.se])
{
ll x = ceil(sqrt(v.se.se));
if(u.fi>=x)
{
if(dist[v.fi]>u.fi+v.se.fi+(v.se.se)/(u.fi+1))
{
s.erase({dist[v.fi],v.fi});
dist[v.fi]=u.fi+v.se.fi+(v.se.se)/(u.fi+1) ;
s.insert({dist[v.fi],v.fi});
}
}
else
{
t1=u.fi+v.se.fi+x-u.fi-1;
//cout << t1 << endl ;
t1+=(v.se.se)/x;
//cout << t1 << endl ;
if(dist[v.fi]>t1)
{
s.erase({dist[v.fi],v.fi});
dist[v.fi]=t1 ;
s.insert({dist[v.fi],v.fi});
}
}
}
}
if(dist[n]==1e18) cout << -1 ;
else cout << dist[n] ;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define mod 1000000007
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
ll binpow(ll x,ll y)/* (x^y)%p in O(log y) */{ll res=1;while (y > 0){if(y&1)res=(res*x);y = y>>1;x=(x*x);}return res;}
ll binpowmod(ll x,ll y,ll p)/* (x^y)%p in O(log y) */{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 mod_inverse(ll n,ll p)/* Returns n^(-1) mod p */{return binpowmod(n,p-2,p);}
ll gcd(ll x,ll y)
{
if(y==0)
return x;
return gcd(y,x%y);
}
bool comp_pairs_by_s(pair<ll,ll> &x ,pair<ll,ll> &y)
{
return x.second<y.second;
}
bool isPowerOfTwo (ll x)
{
/* First x in the below expression is for the case when x is 0 */
return x && (!(x&(x-1)));
}
class cmp //comrootator for priority_queue
{ //declaration: priority_queue<int,vector<int>,cmp>
public:
bool operator()(pair<ll,ll>& A, pair<ll,ll>& B)
{
// if(A.first == B.first)
// return A.second < B.second;
return A.first > B.first;
}
};
void swap(int &x,int &y){
int temp=x;
x=y;
y=temp;
}
unsigned int onesComplement(unsigned int n)
{
// Find number of bits in the given integer
int number_of_bits = floor(log2(n))+1;
// XOR the given integer with poe(2,
// number_of_bits-1 and print the result
return ((1 << number_of_bits) - 1) ^ n;
}
bool comp1(pair<int,int> x,pair<int,int> y)
{
return x.second<y.second;
}
const int N = 1e5 + 10;
struct node {
int to;
int c;
int d;
};
vector<node> g[N];
void solve(){
int n, m;
cin >> n >> m;
for(int i = 0; i < m; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
g[a].push_back({b, c, d});
g[b].push_back({a, c, d});
}
priority_queue<pair<ll,ll>, vector<pair<ll,ll>>, cmp> pq;
vector<ll> ans(n + 1, 1LL * 1000 * 1000 * 1000 * 1000 * 1000 * 10);
ans[1] = 0;
pq.push({0, 1});
while(!pq.empty()) {
auto e = pq.top();
pq.pop();
int from = e.second; ll cost = e.first;
if(ans[from] < cost)
continue;
for(node to: g[from]) {
ll min_cost = cost + 1LL * to.c + to.d / (cost + 1);
int sqr = int(sqrt(to.d));
for(int i = max(0, sqr - 3); i <= sqr + 3; ++i) {
min_cost = min(min_cost,
cost + i * 1LL + 1LL * to.c + to.d / (cost + i * 1LL + 1LL)
);
}
if(ans[to.to] > min_cost) {
ans[to.to] = min_cost;
pq.push({min_cost, to.to});
}
}
}
if(ans[n] == 1LL * 1000 * 1000 * 1000 * 1000 * 1000 * 10) {
cout << -1;
}
else
cout << ans[n];
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
// int t;
// cin >> t;
// while(t--){
// solve();
// }
solve();
} |
#include <bits/stdc++.h>
using namespace std;
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__(d) for (auto blockTime = make_pair(chrono::high_resolution_clock::now(), true); blockTime.second; debug("%s: %.5lf s\n", d, chrono::duration_cast<chrono::milliseconds>(chrono::high_resolution_clock::now() - blockTime.first).count() / 1000.0), blockTime.second = false)
template <typename T>
std::string NumberToString(T Number)
{
std::ostringstream ss;
ss << Number;
return ss.str();
} // Usages NumberToString(3)
template <typename T>
T StringToNumber(const string &Text)
{
istringstream ss(Text);
T result;
return ss >> result ? result : 0;
} // StringToNumber<int>("3")
string StrCpy(string str, long long int start, long long int end)
{
string temp = "";
for (long long int i = start; i <= end; i++)
{
temp += str[i];
}
return temp;
}
#define ull unsigned long long int
#define ll long long int
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) ((a * b) / gcd(a, b))
int solve() {
ll x;
cin >> x;
while(x>=100){
x = x - 100;
}
cout << 100 - x << endl;
return 0;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
/*
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
*/
// time__("programm time")
//{
solve();
// }
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin>>a;
cout<<100-a%100;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 10, mod = 1e9 + 7;
void solve() {
ll n; cin >> n;
for (ll i = 1; i; ++i) {
if (i * (i + 1 ) / 2 >= n) {
cout << i ;
return ;
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
solve();
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const int MaxN=1e9;
char Nss[20];
int main(){
while(scanf("%s",Nss)!=EOF){
int i, L=strlen(Nss)-1;
while(L>=0 and Nss[L]=='0')
L-=1;
for(i=0; i<=(L>>1) and Nss[i]==Nss[L-i]; i+=1);
puts( (L==-1 or i>(L>>1))? "Yes": "No");
}
} |
// Author: old_school
// Created: 16.01.2021 17:30:16
#include<bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
using namespace std;
#define lld long long int
#define ld long double
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define F first
#define S second
#define nl '\n'
#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
#define sz(c) (c).size()
#define tr(x,a) for(auto &a : x)
#define psnt(x,a) (x).find(a)!=(x).end()
#define vpsnt(x,a) find(all(x),a)!=(x).end()
#define MOD 1000000007
#define tod 1
#define pi 3.1415926536
#define itr(i,a,b) for(lld i=a;i<=b;i++)
#define itrn(i,a,b) for(lld i=a;i>=b;i--)
#define iot(n) for(lld i=0;i<n;i++)
#define pls(n,arr) lld arr[n]; iot(n) cin>>arr[i];
#define bye fflush(stdout)
typedef pair<lld,lld> pii;
typedef pair<string,lld> psi;
template <typename T>
bool mycomp(T x,T y){
return (x==y); //give your condition here
}
bool paircomp(const pair<lld,lld> &x,const pair<lld,lld> &y){
return x.second<y.second;
}
void solve(){
lld n,k; cin>>n>>k;
lld hash[n+5]={0};
pls(n,a);
itr(i,0,n-1) hash[a[i]]++;
lld sumr=0;
lld z=k,i=0;
while(z!=0&&i<n){
if(hash[i]>=z) ;
else{
sumr+=(z-hash[i])*i;
z=hash[i];
}
i++;
}
cout<<sumr;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
lld t=1; //cin>>t;
while(t--){
solve();
cout<<endl;
}
}
| #include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <cstdlib>
using namespace std;
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define li long long
#define pii pair<int, int>
#define vi vector<int>
#define li long long
#define forn(i, n) for (int i = 0; i < (int)n; i++)
#define fore(i, b, e) for (int i = (int)b; i <= (int)e; i++)
int main() {
int tests;
scanf("%d", &tests);
forn(test, tests) {
int l, r;
scanf("%d%d", &l, &r);
li ans = 0;
if (2 * l <= r) {
li len = r - 2 * l + 1;
ans = len * (len + 1) / 2;
}
cout << ans << endl;
}
} |
#include <bits/stdc++.h>
#include <algorithm>
#include <unordered_map>
#define ull unsigned long long
#define int long long
#define ll long long
#define fr(i, n) for (int i = 0; i < n; i++)
#define frf(i, j, n) for (int i = j; i <= n; i++)
#define frd(i, n) for (int i = n; i >= 0; i--)
#define mp(i, j) make_pair(i, j)
#define pb(x) push_back(x)
#define INF 1e18
#define all(x) (x).begin(), x.end()
#define int64_t 64
using namespace std;
typedef pair<int, int> pi;
const int MAX = 1e6 + 1;
// typedef vector<vector<ll>> matrix;
const ll PRIME = 1e9 + 7;
// typedef pair<int, pair<int, int>> ppi;
// const ll MAX = 1e6 + 1;
int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
char s[1505][1505];
int ans[1502][1502];
void solve()
{
int h, w, n, m;
cin >> h >> w >> n >> m;
fr(i, n)
{
int a, b;
cin >> a >> b;
a--, b--;
s[a][b] = '.';
}
fr(i, m)
{
int a, b;
cin >> a >> b;
a--, b--;
s[a][b] = '#';
}
fr(i, h)
{
bool chk = 0;
fr(j, w)
{
if (s[i][j] == '.')
chk = 1;
else if (s[i][j] == '#')
chk = 0;
if (chk)
ans[i][j] = 1;
}
chk = 0;
frd(j, w- 1)
{
if (s[i][j] == '.')
chk = 1;
else if (s[i][j] == '#')
chk = 0;
if (chk)
ans[i][j] = 1;
}
}
fr(j, w)
{
bool chk = 0;
fr(i, h)
{
if (s[i][j] == '.')
chk = 1;
if (s[i][j] == '#')
chk = 0;
if (chk)
ans[i][j] = 1;
}
chk = 0;
frd(i, h - 1)
{
if (s[i][j] == '.')
chk = 1;
else if (s[i][j] == '#')
chk = 0;
if (chk)
ans[i][j] = 1;
}
}
int cnt=0;
fr(i,h)
{
fr(j,w)
{
if(ans[i][j]==1)
{
cnt++;
}
}
}
cout<<cnt;
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
t = 1;
// cin >> t;
// int k=1;
while (t--)
{
// cout << "Case " << k++ << ":\n";
solve();
}
} | #include <vector>
#include <iostream>
#include <utility>
#include <cstdio>
using namespace std;
#define EMPTY 0
#define BULB 1
#define BLOCK 2
#define LIGHT 3
int H,W,N,M;
vector<pair<int, int>> bulbs;
vector<vector<int>> grid;
int main() {
cin >> H >> W >> N >> M;
grid = vector<vector<int>>(H, vector<int>(W, EMPTY));
int a, b, c, d;
for(int i = 0; i < N; i++) {
cin >> a >> b;
bulbs.push_back({a-1, b-1});
grid[a-1][b-1] = BULB;
}
for(int i = 0; i < M; i++) {
cin >> c >> d;
grid[c-1][d-1] = BLOCK;
}
// visited[i][j][index] grid[i][j]位置的灯的index方向是否被访问过
vector<vector<vector<int>>> visited(H, vector<vector<int>>(W, vector<int>(4, 0)));
// printf("H:%d, W:%d, N:%d, M:%d\n", H, W, N, M);
// for(int i = 0; i < N; i++) {
// printf("%d %d\n", bulbs[i].first, bulbs[i].second);
// }
vector<int> dirs{0, 1, 0, -1, 0};
int r, h, tr, th;
// 循环每个灯，向上下左右扩展，直到扩展到block
// 每次扩展时记录当前灯和扩展到的灯的方向是否访问过，便于缩小复杂度
for(int i = 0; i < N; i++) {
for(int index = 0; index < 4; index++) {
r = bulbs[i].first;
h = bulbs[i].second;
if(visited[r][h][index]) {
continue;
}
visited[r][h][index] = true;
int tr = r + dirs[index];
int th = h + dirs[index+1];
while(tr >= 0 && tr < H && th >= 0 && th < W) {
if(grid[tr][th] == BLOCK) {
break;
}
if(grid[tr][th] == BULB) {
visited[tr][th][index] = true;
}
if(grid[tr][th] == EMPTY) {
grid[tr][th] = LIGHT;
}
tr += dirs[index];
th += dirs[index+1];
}
}
}
int ans = 0;
for(int i = 0; i < H; i++) {
for(int j = 0; j < W; j++) {
if(grid[i][j] == BULB || grid[i][j] == LIGHT) {
ans++;
}
}
}
printf("%d", ans);
return 0;
} |
// clang-format off
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using pii = pair<int,int>;
using vi = vector<int>;
using vvi = vector<vi>;
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define fore(x, c) for(auto &&x : c)
#define rep(i, a, n) for(int i = a, i##len = (int)(n); i < i##len; ++i)
#define rrep(i, a, n) for(int i = (int)(n - 1); i >= a; --i)
#define sz(c) ((int)c.size())
#define contains(c, x) (c.find(x) != end(c))
#define inseg(l, x, r) ((l) <= (x) && (x) < (r))
#define dump(...)
#define pb push_back
#define eb emplace_back
#define _ 0
const signed INF_ = 1001001001; const long long INF = 1001001001001001001LL;
const int DX[9] = {0,1,0,-1,1,1,-1,-1,0}, DY[9] = {-1,0,1,0,-1,1,1,-1,0};
template<class T> ostream& operator<<(ostream &os, const vector<T> &v) {
for (auto i = begin(v); i != end(v); i++) os<<*i<<(i==end(v)-1?"":" ");return os;}
template<class T> istream& operator>>(istream &is, vector<T> &v) {
for (auto i = begin(v); i != end(v); i++) is>>*i;return is;}
template<class T,class U> istream& operator>>(istream &is, pair<T,U> &p) {
is>>p.first>>p.second;return is;}
template<class T, class U> bool chmax(T &a, const U &b){return a<b?a=b,1:0;}
template<class T, class U> bool chmin(T &a, const U &b){return a>b?a=b,1:0;}
template <class T> void psum(T& c) {partial_sum(begin(c), end(c), begin(c));}
template<class T> using heap = priority_queue<T, deque<T>, greater<T>>;
struct before_main_function {
before_main_function() {
cin.tie(nullptr); ios::sync_with_stdio(false);
cout << setprecision(15) << fixed;
}
} before_main_function;
// clang-format on
//------------------8<------------------------------------8<--------------------
template <int mod>
class ModInt {
public:
ModInt() : v(0) {}
ModInt(int x) : v((x + mod) % mod) {}
int value() const { return v; }
const ModInt operator+(const ModInt &r) const {
return ModInt(this->v + r.v);
}
const ModInt operator-(const ModInt &r) const {
return ModInt(this->v + mod - r.v);
}
const ModInt operator*(const ModInt &r) const {
return ModInt(this->v * r.v);
}
const ModInt operator/(const ModInt &r) const { return (*this * (~r)); }
const ModInt operator^(int k) const { return ModInt(bpow(this->v, k)); }
const ModInt operator~() const { return ModInt(bpow(this->v, mod - 2)); }
bool operator==(const ModInt &r) const { return this->v == r.v; }
bool operator!=(const ModInt &r) const { return this->v != r.v; }
ModInt &operator+=(const ModInt &r) { return *this = *this + r; }
ModInt &operator-=(const ModInt &r) { return *this = *this - r; }
ModInt &operator*=(const ModInt &r) { return *this = *this * r; }
ModInt &operator/=(const ModInt &r) { return *this = *this * (~r); }
private:
int v;
int bpow(int a, int b) const {
int ret = 1;
while (b > 0) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
};
using Mint = ModInt<998244353>;
signed main() {
int A, B, C;
cin >> A >> B >> C;
Mint a = Mint(A * (A + 1) / 2);
Mint b = Mint(B * (B + 1) / 2);
Mint c = Mint(C * (C + 1) / 2);
cout << (a * b * c).value() << endl;
}
| #include<cstdio>
#include<cstring>
using namespace std;
int main()
{
long long a,b,c;scanf("%lld%lld%lld",&a,&b,&c);
a=a*(a+1)/2%998244353;
b=b*(b+1)/2%998244353;
c=c*(c+1)/2%998244353;
printf("%lld\n",a*b%998244353*c%998244353);
return 0;
} |
#include <bits/stdc++.h>
// clang-format off
using namespace std; using ll=long long; using ull=unsigned long long; using pll=pair<ll,ll>; const ll INF=4e18;
void print0(){}; template<typename H,typename... T> void print0(H h,T... t){cout<<h;print0(t...);}
void print(){print0("\n");}; template<typename H,typename... T>void print(H h,T... t){print0(h);if(sizeof...(T)>0)print0(" ");print(t...);}
void perr0(){}; template<typename H,typename... T> void perr0(H h,T... t){cerr<<fixed<<setprecision(10)<<h;perr0(t...);}
void perr(){perr0("\n");}; template<typename H,typename... T>void perr(H h,T... t){perr0(h);if(sizeof...(T)>0)perr0(" ");perr(t...);}
void ioinit() { cout << fixed << setprecision(15); ios_base::sync_with_stdio(0); cin.tie(0); }
// clang-format on
ll n;
ll msb(ll v) {
// assert v > 0
return 64 - __builtin_clzll(v);
}
// ダブリング: 各ノードから 2^i 回、根に向かって移動をして到達する場所 (-1は移動不可とする)
vector<ll> parent(200005);
vector<vector<ll>> depth(200005);
vector<ll> depth0(200005);
vector<ll> depthid(200005);
vector<vector<ll>> edgmap(200005);
void doubling_mv_to_root(vector<vector<ll>> &dbl) {
ll logn = dbl.size();
for (ll i = 0; i < logn; i++) {
for (ll j = 0; j < n; j++) {
if (i == 0) {
dbl[i][j] = parent[j];
} else if (dbl[i - 1][j] >= 0) {
dbl[i][j] = dbl[i - 1][dbl[i - 1][j]];
}
}
}
}
ll ancestor_at_depth(ll u, ll diff, vector<vector<ll>> &dbl) {
ll logn = dbl.size();
while (diff > 0) {
// 2^i 回の移動をしてもdiffが0以上残る最大のi
ll i = msb(diff) - 1;
ll pow2i = (1ULL << i);
diff -= pow2i;
u = dbl[i][u];
}
return u;
}
void dfs(ll u, ll dep) {
depth[dep].push_back(u);
depthid[u] = -1 + depth[dep].size();
depth0[u] = dep;
for (auto v : edgmap[u]) {
dfs(v, dep + 1);
}
}
int main() {
ioinit();
cin >> n;
for (ll i = 1; i < n; i++) {
ll p;
cin >> p;
parent[i] = p - 1;
edgmap[parent[i]].push_back(i);
}
ll q;
cin >> q;
vector<pll> queries(q);
for (ll i = 0; i < q; i++) {
ll u, d;
cin >> u >> d;
u--;
queries[i] = {u, d};
}
dfs(0, 0);
ll logn = 24;
vector<vector<ll>> dbl(logn, vector<ll>(n, -1));
doubling_mv_to_root(dbl);
for (auto query : queries) {
ll u = query.first;
ll d = query.second;
ll diff = d - depth0[u];
if (diff == 0) {
print(1);
continue;
}
if (diff < 0) {
print(0);
continue;
}
ll k = depthid[u];
ll mx = -10 * n - 10;
{
// diff回上に上がってdepthidがk以下になる最大
ll right = depth[d].size() - 1;
ll left = 0;
while (left <= right) {
ll mid = (left + right) / 2;
ll did = depthid[ancestor_at_depth(depth[d][mid], diff, dbl)];
if (did <= k) {
mx = max(mid, mx);
left = mid + 1;
} else {
right = mid - 1;
}
}
}
ll mn = 10 * n + 10;
{
// diff回上に上がってdepthidがk以上になる最小
ll right = depth[d].size() - 1;
ll left = 0;
while (left <= right) {
ll mid = (left + right) / 2;
ll did = depthid[ancestor_at_depth(depth[d][mid], diff, dbl)];
if (did >= k) {
mn = min(mid, mn);
right = mid - 1;
} else {
left = mid + 1;
}
}
}
ll ans = mx - mn + 1;
if (ans < 0) ans = 0;
print(ans);
}
}
| #include <bits/stdc++.h>
using namespace std;
#define deb(k) cerr << #k << ": " << k << "\n";
#define size(a) (int)a.size()
#define fastcin cin.tie(0)->sync_with_stdio(0);
#define st first
#define nd second
#define pb push_back
#define mk make_pair
#define int long long
typedef long double ldbl;
typedef double dbl;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef map<int, int> mii;
typedef vector<int> vint;
#define MAXN 300100
#define MAXLG 20
const int inf = 0x3f3f3f3f;
const ll mod = 1000000007;
const ll linf = 0x3f3f3f3f3f3f3f3f;
const int N = 300100;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vint g[N];
int ans[N];
vector<pii>qr[N];
int f[N];
vint aux[N];
void dfs(int x, int p = -1, int d = 0){
for(int v : g[x]){
for(auto e : qr[v]){
int i = e.nd, j = e.st;
aux[j].pb(f[j]);
f[j] = 0;
}
dfs(v, x, d+1);
for(auto e : qr[v]){
int i = e.nd, j = e.st;
f[j] += aux[j].back();
aux[j].pop_back();
}
}
f[d]++;
for(auto e : qr[x]){
int i = e.nd, j = e.st;
ans[i] = f[j];
}
}
void solve(){
int n;
cin>>n;
for(int i=2;i<=n;i++){
int x;
cin>>x;
g[x].pb(i);
}
int q;
cin>>q;
for(int i=0;i<q;i++){
int a,b;
cin>>a>>b;
qr[a].pb({b, i});
}
dfs(1);
for(int i=0;i<q;i++) cout<<ans[i]<<"\n";
// Have you read the problem again?
// Maybe you understood the wrong problem
}
int32_t main(){
fastcin;
int t_ = 1;
//cin>>t_;
while(t_--)
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long lint;
#define rep(i,n) for(lint (i)=0;(i)<(n);(i)++)
#define repp(i,m,n) for(lint (i)=(m);(i)<(n);(i)++)
#define repm(i,n) for(lint (i)=(n-1);(i)>=0;(i)--)
#define INF (1ll<<60)
#define all(x) (x).begin(),(x).end()
const lint MOD =1000000007;
//const lint MOD=998244353;
const lint MAX = 4000000;
using Graph =vector<vector<lint>>;
typedef pair<lint,lint> P;
typedef map<lint,lint> M;
#pragma GCC optimize("Ofast")
#define chmax(x,y) x=max(x,y)
#define chmin(x,y) x=min(x,y)
lint fac[MAX], finv[MAX], inv[MAX];
void COMinit()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (lint i = 2; i < MAX; i++)
{
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(lint n, lint k)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint primary(lint num)
{
if (num < 2) return 0;
else if (num == 2) return 1;
else if (num % 2 == 0) return 0;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
{
return 0;
}
}
return 1;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
lint lcm(lint a,lint b){
return a/__gcd(a,b)*b;
}
lint gcd(lint a,lint b){
return __gcd(a,b);
}
int main(){
lint h,w,a,b;
cin>>h>>w>>a>>b;
lint t[h][w];
vector<pair<P,P>> cd;
rep(i,h){
rep(j,w-1){
cd.push_back({{i,j},{i,j+1}});
}
}
rep(i,h-1){
rep(j,w){
cd.push_back({{i,j},{i+1,j}});
}
}
lint aa=cd.size();
lint g=1<<aa;
lint ans=0;
rep(bit,g){
bool d[aa];
fill(d,d+aa,false);
lint count=0;
rep(i,aa){
if((1<<i)&bit){
d[i]=true;
count++;
}
}
if(count!=a)continue;
rep(i,h)rep(j,w)t[i][j]=0;
rep(i,aa){
if(d[i]){
t[cd[i].first.first][cd[i].first.second]++;
t[cd[i].second.first][cd[i].second.second]++;
}
}
bool isp=true;
rep(i,h)rep(j,w)if(t[i][j]>1)isp=false;
if(isp)ans++;
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define PB push_back
#define MP make_pair
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define INF (1 << 30)
#define LLINF (1LL << 60)
#define MOD 998244353
//#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, j, n) for (int i = j; i < n; i++)
#define llrep(i, n) for (ll i = 0; i < n; i++)
using ll = long long;
typedef pair<ll, ll> P;
int h, w;
bool used[16][16];
ll dfs(int i, int j, int a, int b)
{
if(a<0||b<0){
return 0;
}
if (j == w) {
j = 0;
i++;
}
if(i==h){
return 1;
}
if (used[i][j]) {
return dfs(i, j + 1, a, b);
}
ll res = 0;
used[i][j] = true;
res += dfs(i, j + 1, a, b - 1);
if (j + 1 < w && !used[i][j + 1]) {
used[i][j + 1] = true;
res += dfs(i, j + 1, a - 1, b);
used[i][j + 1] = false;
}
if (i + 1 < h && !used[i + 1][j]) {
used[i + 1][j] = true;
res += dfs(i, j + 1, a - 1, b);
used[i + 1][j] = false;
}
used[i][j] = false;
return res;
}
int main()
{
cin >> h >> w;
int a, b;
cin >> a >> b;
cout<<dfs(0, 0, a, b)<<endl;
return 0;
} |
#include <iostream>
using namespace std;
int main(void){
int v,t,s,d;
cin >> v >> t >> s >> d;
if(v*t <= d && v*s >= d){
cout << "No" << endl;
}
else cout << "Yes" << endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define w(x) int x; cin>>x; while(x--)
int32_t main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
//fsolve();
int v,t,s,d;
cin>>v>>t>>s>>d;
//int g=d/v;
if(d<v*t || d>v*s){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
return 0;
} |
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <utility>
#include <algorithm>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <unordered_map>
#include <map>
#include <unordered_set>
#include <set>
#include <tuple>
#include <cassert>
#include <cmath>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
#define read_int(X) \
ll X; \
scanf("%lld\n", &X);
#define read_two_int(X, Y) \
ll X, Y; \
scanf("%lld %lld\n", &X, &Y);
#define read_three_int(X, Y, Z) \
ll X, Y, Z; \
scanf("%lld %lld %lld\n", &X, &Y, &Z);
#define read_four_int(X, Y, Z, W) \
ll X, Y, Z, W; \
scanf("%lld %lld %lld %lld\n", &X, &Y, &Z, &W);
int main()
{
read_int(N);
ll ans0 = 0;
ll ans1 = 0;
ll ans2 = 0;
for (ll i = 0; i < N; i++)
{
ll x;
scanf("%lld", &x);
ans0 += abs(x);
ans1 += x * x;
ans2 = max(abs(x), ans2);
}
printf("%lld\n%.15Lf\n%lld\n", ans0, sqrt((long double)ans1), ans2);
}
| #include <bits/stdc++.h>
// #include <atcoder/all>
// using namespace atcoder;
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define inrange(a, x, b) (a <= x && x <= b)
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using vc = vector<char>;
using vcvc = vector<vc>;
using pll = pair<ll, ll>;
template<class T> void print(T x,bool cl=1){cout<<(cl?"\x1b[36m":"")<<x<<(cl?"\x1b[39m":"")<<'\n';}
template<class T> void print1d(T x,ll n=-1,bool cl=true){if(n==-1)n=x.size();rep(i,0,n){cout<<(cl?"\x1b[36m":"")<<x[i]<<(i==n-1?'\n':' ');}cout<<(cl?"\x1b[39m":"");}
template<class T> void print2d(T x,ll r=-1,ll c=-1,bool cl=1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c,cl);}
template<class T, class U> bool isin(T el, U container) { return find(all(container), el) != container.end(); }
template<class T> bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
template<class T> bool even(T n) { return ! (n & 1); }
template<class T> bool odd(T n) { return n & 1; }
template<class T> ll rup(T a, T b) { return a % b ? a / b + 1 : a / b; }
template<class T> ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T> ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
const long double pi = M_PI;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
ll intpow(ll a, ll n, ll _mod=numeric_limits<ll>::max()) { ll p=1; while (n) { if (n&1) p=p*a%_mod; a=a*a%_mod; n>>=1; } return p; }
ll modc(ll a, char op, ll b, ll _mod=mod)
{
a %= _mod; b %= _mod; ll res = 1;
switch (op) {
case '+': res = (a + b) % _mod; break;
case '-': res = (a - b) % _mod; break;
case '*': res = a * b % _mod; break;
case '/': res = modc(a, '*', modc(b, '^', _mod-2, _mod), _mod); break;
case '^': res = intpow(a, b, _mod); break;
case 'P': rep(i, a-b+1, a+1) res = modc(res, '*', i, _mod); break;
case 'C': res = modc(modc(a, 'P', b, _mod), '/', modc(b, 'P', b, _mod)); break;
}
if (res < 0) { res += _mod; } return res;
}
int main()
{
ll N;
cin >> N;
vll x(N);
rep(i, 0, N) cin >> x[i];
ll a = 0;
rep(i, 0, N) a += abs(x[i]);
ld b = 0.0;
rep(i, 0, N) b += abs(x[i]) * abs(x[i]);
b = sqrt(b);
ll c = -inf;
rep(i, 0, N) {
if (abs(x[i]) > c) {
c = abs(x[i]);
}
}
cout << setprecision(21) << a << '\n' << b << '\n' << c << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long i = 1;
while(n>0) {
n -= i;
i += 1;
}
cout<<i-1<<endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define REP(i,m,n) for (int i = (m); i < (n); ++i)
#define rrep(i,n) for (int i = (n)-1; i >= 0; --i)
#define RREP(i,m,n) for (int i = (n)-1; i >= (m); ++i)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
using namespace std;
using ll = long long int;
using vec = vector<int>;
using P = pair<int,int>;
const int INF = 1e9+7;
int main() {
int n; cin >> n;
int x = 1;
while (x * (x+1) < 2 * n) {
x++;
}
cout << x << endl;
}
|
#include<iostream>
#include<set>
#include<cstring>
using namespace std;
const int aa=2e5+7;
bool a[aa];
int main()
{
memset(a,0,sizeof(a));
int N;
cin>>N;
int sum=0;
for(int i=0;i<N;i++)
{
int m;
cin>>m;
a[m]=1;
while(a[sum]==1)
{
sum++;
}
cout <<sum<<'\n';
}
return 0;
} | // Jai Shree Ram
#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for(int i=a;i<n;i++)
#define ll long long
#define int long long
#define pb push_back
#define all(v) v.begin(),v.end()
#define endl "\n"
#define x first
#define y second
#define gcd(a,b) __gcd(a,b)
#define mem1(a) memset(a,-1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
#define sz(a) (int)a.size()
#define pii pair<int,int>
#define hell 1000000007
#define elasped_time 1.0 * clock() / CLOCKS_PER_SEC
template<typename T1,typename T2>istream& operator>>(istream& in,pair<T1,T2> &a){in>>a.x>>a.y;return in;}
template<typename T1,typename T2>ostream& operator<<(ostream& out,pair<T1,T2> a){out<<a.x<<" "<<a.y;return out;}
template<typename T,typename T1>T maxs(T &a,T1 b){if(b>a)a=b;return a;}
template<typename T,typename T1>T mins(T &a,T1 b){if(b<a)a=b;return a;}
int solve(){
int n; cin >> n;
vector<int>a(n+1),p1(n+1),p2(n+1);
rep(i,1,n+1){
cin >> a[i];
if(i%2)p1[i] = a[i];
else p2[i] = a[i];
p1[i] += p1[i-1];
p2[i] += p2[i-1];
}
int ans = 0;
map<int,int>mp;
int l = 0;
for(int i = 1; i <= n; i++){
ans += mp[p1[i] - p2[i]];
mp[p1[l]-p2[l]]++;
l++;
}
cout << ans << endl;
return 0;
}
signed main(){
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#ifdef SIEVE
sieve();
#endif
#ifdef NCR
init();
#endif
int t=1;//cin>>t;
while(t--){
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define mp make_pair
#define pb push_back
#define pf push_front
#define F first
#define S second
#define MOD 1000000007
#define MAXN 1000001
#define MODA 998244353
#define all(a) (a).begin(),(a).end()
#define allr(a) (a).rbegin(),(a).rend()
ll power(ll a,ll b){
ll result=1;
while(b>0){
int lastbit=(b&1);
if(lastbit){
result=(result*a);
}
a=(a*a);
b=b>>1;
}
return result;
}
ll power2(ll a,ll b,ll p){
ll result=1;
while(b>0){
int lastbit=(b&1);
if(lastbit){
result=(result*a)%p;
}
a=(a*a)%p;
b=b>>1;
}
return result%p;
}
ll gcd(ll a, ll b){
if (b == 0)
return a;
return gcd(b, a % b);
}
vector<ll> Sieve(int n){
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++){
if (prime[p] == true){
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
vector<ll>v;
for (int p=2; p<=n; p++)
if (prime[p]) v.pb(p);
return v;
}
vector<ll> SeiveOfEratosthenes(int n){
vector<ll>v(n+1,0);
for(int i=0;i<=n;i++){
v[i]=i;
}
for (int p=2; (p*p)<=n; p++){
if (v[p] == p){
v[p]=p;
for (int i=p*p; i<=n; i += p) {
v[i] = p;
}
}
}
return v;
}
vector<ll> SmallestPrimeFactors(int n){
vector<ll>spf(n+1,0);
spf[1] = 1;
for (int i=2; i<=n; i++){
spf[i] = i;
}
for (int i=4; i<=n; i+=2){
spf[i] = 2;
}
for (int i=3; (i*i)<=n; i++){
if (spf[i] == i){
for (int j=i*i; j<MAXN; j+=i) {
if (spf[j] == j){
spf[j] = i;
}
}
}
}
return spf;
}
void shortest(map<int,vector<pair<int,ll>>>m,int src,int n,ll *dist){
bool visited[n+1];
set<pair<ll,int>>s;
for(int i=0;i<=n;i++){
dist[i]=-1;
visited[i]=false;
}
s.insert(mp(0ll,src));
dist[src]=0;
while(!s.empty()){
auto t=s.begin();
ll dis=(*t).F;
int u=(*t).S;
s.erase(t);
if(visited[u]){
continue;
}
visited[u]=true;
for(auto tt:m[u]){
int v=tt.F;
ll w=tt.S;
if(!visited[v]){
if(dist[v]!=-1 && dist[v]>dis+w){
s.erase(mp(dist[v],v));
dist[v]=dis+w;
s.insert(mp(dist[v],v));
}else if(dist[v]==-1){
dist[v]=dis+w;
s.insert(mp(dist[v],v));
}
}
}
}
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int ttttt=1;
// cin>>ttttt;
for(int tttt=1;tttt<=ttttt;tttt++){
ll n;
cin>>n;
string x="";
while(n>0){
x+=(n%10+'0');
n/=10;
}
reverse(all(x));
n=x.size();
if(n%2){
ll a[12]={0,0,0,9,0,99,0,999,0,9999,0,99999};
cout<<a[n];
}else{
int t=n/2;
int j=0;
ll first=0;
ll po=t;
ll second=0;
while(t<n){
ll y=power(10ll,po-1);
first+=((x[j]-'0')*y);
second+=((x[t]-'0')*y);
t++;
j++;
po--;
}
ll ans=first-1;
if(second>=first){
ans++;
}
cout<<ans;
}
cout<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i) = 0; (i) <(n); (i)++)
#define so(v) sort(v.begin(),v.end())
using ll = long long;
using vi=vector<int>;
using vvi=vector<vi>;
const int MAX = 510000;
const int MOD = 1000000007;
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);
}
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long com(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int h,w,x,y;
cin>>h>>w>>x>>y;
x--,y--;
string s[h];
rep(i,h)cin>>s[i];
int yoko=0;
rep(i,w){
if(s[x][i]=='.')yoko++;
else{
if(i>y)break;
yoko=0;
}
}
int tate=0;
rep(i,h){
if(s[i][y]=='.')tate++;
else{
if(i>x)break;
tate=0;
}
}
cout<<tate+yoko-1<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x,y;
cin >> x >> y;
if (x==y) cout << x << endl;
else cout << 3-x-y << endl;
}
| #include "bits/stdc++.h"
using namespace std;
#define int long long
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int x, y;
cin >> x >> y;
int mov[3] = {0};
mov[x]++; mov[y]++;
if(x==y){
cout << x << "\n";
}
else{
for(int i=0; i<3; i++){
if(!mov[i]) cout << i << "\n";
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)//iをaからn
#define per(i,n,a) for (int i=a-1;i>=n;i--)//iをnからa
#define db(x) cout << #x << " = " << x << endl
#define db2(x, y) cout << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")\n"; //デバッグ用
#define all(x) (x).begin(), (x).end()
#define INF 1000000000000 //10^12:∞
#define MOD 1000000007 //10^9+7:合同式の法
#define pb push_back
#define F first
#define S second
typedef long long ll;
//sort(all(a)); ソート
//sort(all(a),greater<int>()); 逆順ソート
//a.erase(unique(all(a)), a.end()); ソート後に重複を削除
//cout<< std::fixed << std::setprecision(15)<<0.000001<<endl; 小数点以下を表示させる
int main() {
ll a,b,w;
cin>>a>>b>>w;
ll minans=INF,maxans=0;
ll kosuu=1;
bool flag=false;
while(true){
if(kosuu*a<=w*1000&&w*1000<=kosuu*b){
minans=kosuu;
flag=true;
while(true){
maxans=max(maxans,kosuu);
kosuu++;
if(kosuu*a>w*1000){
break;
}
}
}
kosuu++;
if(kosuu*a>w*1000){
break;
}
}
if(flag){
cout<<minans<<" "<<maxans<<endl;
}else{
cout<<"UNSATISFIABLE"<<endl;
}
return 0;
} | #include <bits/stdc++.h>
int main() {
std::vector<int> a(3);
std::cin >> a[0] >> a[1] >> a[2];
std::sort(a.begin(), a.end());
if (a[1] - a[0] == a[2] - a[1]) {
std::cout << "Yes" << std::endl;
} else {
std::cout << "No" << std::endl;
}
}
|
#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<cctype>
#include<cstdlib>
#include<algorithm>
#include<vector>
#define fs(i,x,y) for(int i=(x),_=(y);i<=_;++i)
#define fn(i,x,y) for(int i=(x),_=(y);i>=_;--i)
#define tor(i,v,x) for(int i=head[x],v=to[i];i;i=nxt[i],v=to[i])
#define Li inline
#define R register int
#define ls(x) ch[x][0]
#define rs(x) ch[x][1]
#define mpi(x,y) make_pair(x,y)
#define pi pair<int,int>
//#define int ll
using namespace std;
typedef long long ll;
template<typename T>
void read(T &x){
x=0;char ch=getchar();bool f=0;
while(ch<'0'||ch>'9'){
if(ch=='-')f=1;
ch=getchar();
}
while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
x=f?-x:x;
}
const int N=2e5+7;
int n,m;
int a[N],b[N],p[N],id[N],q[N];
vector<pi>v;
bool cmp(int lhs,int rhs){
return b[lhs]>b[rhs];
}
signed main(){
read(n);
fs(i,1,n)read(a[i]);
fs(i,1,n)id[i]=i,read(b[i]);
fs(i,1,n)read(p[i]),q[p[i]]=i;
sort(id+1,id+n+1,cmp);
fs(i,1,n){
int x=id[i];
if(q[x]==x)continue;
if(a[q[x]]>b[x]&&a[x]>b[p[x]]){
v.push_back(mpi(q[x],x));
p[q[x]]=p[x];
q[p[x]]=q[x];
}else{
printf("-1");return 0;
}
}
int len=v.size();
printf("%d\n",len);
fs(i,0,len-1){
printf("%d %d\n",v[i].first,v[i].second);
}
return 0;
}
| typedef long long ll;
typedef long double ld;
#include <bits/stdc++.h>
using namespace std;
int main() {
ll n;
std::cin >> n;
vector<ll> a(n),b(n),p(n);
priority_queue<pair<ll,ll>,vector<pair<ll,ll>>> pq;
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
for (int i = 0; i < n; i++) {
std::cin >> b[i];
pq.push({b[i],i});
}
vector<ll> f(n);
for (int i = 0; i < n; i++) {
std::cin >> p[i];
p[i]--;
f[p[i]]=i;
}
vector<string> ans;
while(!pq.empty()){
// 重さ、荷物番号
auto [weight, index] = pq.top();pq.pop();
auto current_owner = f[index];
auto current_bag = index;
auto true_owner = index;
if(current_owner == true_owner)continue;
auto true_owner_bag = p[true_owner];
if(a[current_owner]>b[current_bag]&&a[true_owner]>b[true_owner_bag]){
ans.push_back(to_string(current_owner+1)+" "+to_string(true_owner+1));
f[true_owner_bag] = current_owner;
f[current_bag] = true_owner;
p[current_owner] = true_owner_bag;
p[true_owner] = current_bag;
}else{
std::cout << -1 << std::endl;
return 0;
}
}
std::cout << ans.size() << std::endl;
for (auto e : ans) {
std::cout << e << std::endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define N 600007
signed main(){
int n;
cin>>n;
int arr[n];
map<int , int> m;
for(int i = 0 ; i < n ; i++){
cin>>arr[i];
m[arr[i]]=i;
}
int st = 0;
int l = 0;
vector<int> ans;
for(int i = 1 ; i <= n ;i++){
int temp = m[i];
for(int j = m[i] ; j > st ; j--){
m[arr[j]]-=1;
m[arr[j-1]]+=1;
swap(arr[j] , arr[j-1]);
ans.push_back(j);
l++;
// cout<<"indices of "<<arr[j]<<" is "<< m[arr[j]]<<endl;
// cout<<"index of "<<arr[j-1]<<" is "<< m[arr[j-1]]<<endl;
}
// cout<<st<<" se "<<temp<<"tk"<<endl;
st = temp;
bool ok = false;
while(i < n && m[i+1] < st){
i++;
ok = true;
}
}
// cout<<"arr: "<<endl;
// for(auto it:arr){
// cout<<it<<" ";
// }
// cout<<endl;
if(l <= n-1){
bool ok = true;
for(int i = 0 ; i < n-1 ; i++){
if(arr[i] > arr[i+1]){
ok = false;
break;
}
}
if(ok){
for(auto it:ans){
cout<<it<<endl;
}
return 0;
}
else{
cout<<"-1"<<endl;
return 0;
}
}
else{
cout<<"-1"<<endl;
return 0;
}
} | //----------BHAVIK DIWANI(PICT_COMP)---------------
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define test ll t; cin>>t; while(t--)
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define mod 1000000007
#define ll long long
#define int long long
#define ull unsigned long long
#define MAX 1000005
#define pb push_back
#define mkp make_pair
#define vi vector<int>
#define pii pair<int,int>
#define endl '\n'
#define vs vector<string>
#define mii map<int,int>
#define msi map<string,int>
#define vpii vector< pair<int, int > >
#define vpsi vector< pair< string ,int > >
#define forci(p,q) for(int i=p;i<q;i++)
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);}
ull power(ull a, ull b) {a %= mod; ull res = 1; while (b > 0) { if (b & 1) res = res * a % mod; a = a * a % mod; b >>= 1; } return res%mod; }
ll modmul(ll x, ll y){return (x*y)%mod;}
ll modadd(ll x, ll y){return (x+y)%mod;}
ll modsub(ll x, ll y){return (x-y+mod)%mod;}
ll fact[1000007]={0};
void facto() {fact[0]=1;fact[1]=1;for(int i=2;i<1000007;i++)fact[i]=(fact[i-1]*i)%mod;}
ll ncr(ll n,ll r) {ll res=1; res=fact[n]; res=(res*(power(fact[r],mod-2)))%mod; res=(res*(power(fact[n-r],mod-2)))%mod; return res;}
ll npr(ll n,ll r) {ll res=1; res=fact[n]; res=(res*(power(fact[n-r],mod-2)))%mod; return res;}
inline long long toint(const std::string &s) {std::stringstream ss; ss << s; long long x; ss >> x; return x;}
inline std::string tostring(long long number) {std::stringstream ss; ss << number; return ss.str();}
inline std::string tobin(long long x) {return std::bitset<63>(x).to_string();}
/*bool prime[MAX];
ull sieve(){memset(prime,true,sizeof(prime));for(ull p=2;p*p<MAX;p++){if(prime[p]==true){for(ull i=2*p;i<MAX;i+=p){prime[i]=false;}}}prime[0]=0;prime[1]=0;
}*/
/*
int inv[1000001]={0};int invf[1000001]={0};
void findinverse(){
inv[0]=1;
inv[1] = 1;
for(int i = 2; i <=1e6 ; ++i)
inv[i] = (mod - (mod/i) * inv[mod%i] % mod) % mod;
invf[0]=1;invf[1]=1;
for(int i=2;i<=1e6;i++){
invf[i]=invf[i-1]*inv[i]%mod;
}
}*/
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> orderedSet;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag, tree_order_statistics_node_update> orderedMultiset;
int solve()
{
int n=4;
int a[4];
cin>>a[0]>>a[1]>>a[2]>>a[3];
int mask=1<<n;
int tot=a[0]+a[1]+a[2]+a[3];
for(int i=0;i<mask;i++){
int sum=0;
for(int j=0;j<n;j++){
if(i & (1<<j))
sum+=a[j];
}
if(sum==tot-sum){
cout<<"Yes";
return 0;
}
}
cout<<"No";
return 0;
}
signed main()
{
fastio;
// test
solve();
}
|
#include<bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define ini(x, y) memset(x, y, sizeof(x));
#define pb push_back
#define fi first
#define se second
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int MOD = (int)1e9 + 7;
const int MAX = (int)2e9;
const double PI = acos(-1);
int prime[1001];
vector<int> P;
int l, r;
ll sol(vector<int>& fac, int i) {
ll res = 0;
for (int sub = (1 << sz(fac)) - 1; sub; sub = (sub - 1) & (1 << (sz(fac))) - 1) {
int val = 1;
int cnt = 0;
for (int j = 0; j < sz(fac); j++) {
if ((1 << j) & sub) {
val *= fac[j];
cnt++;
}
}
if (val != 1) {
int k = r / val - i / val;
if (cnt % 2) res += k;
else res -= k;
}
}
return res;
}
int main(void) {
ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
//freopen("input.txt", "r", stdin);
for (int i = 2; i <= 1000; i++) {
if (prime[i] == 0) {
P.pb(i);
for (int j = 2; j * i <= 1000; j++) {
prime[i * j] = 1;
}
}
}
ll ans = 0;
cin >> l >> r;
for (int i = max(2, l); i < r; i++) {
int k = i;
vector<int> fac;
int idx = 0;
for (int i = 0; i < sz(P); i++) {
if (k == 1) break;
if (k % P[i] == 0) {
fac.pb(P[i]);
while (k % P[i] == 0) k /= P[i];
}
}
if (k > 1) fac.pb(k);
ans += sol(fac, i);
ans -= r / i - 1;
}
cout << ans*2;
} | #include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<utility>
#include<set>
#include<stack>
#include<list>
#include<deque>
#include<bitset>
#include<iomanip>
#include<cstring>
#include<sstream>
#include<cstdio>
#include<cstdlib>
#include<climits>
#include<cmath>
#include<cctype>
#define pb push_back
#define mp make_pair
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define ren(i,a,b) for(int i=a;i>=b;i--)
#define ff first
#define ss second
#define pll pair<long long int,long long int>
#define pii pair<int,int>
#define vll vector<long long int>
#define vii vector<int>
#define gi(n) scanf("%d",&n)
#define gll(n) scanf("%lld",&n)
#define gstr(n) scanf("%s",n)
#define gl(n) cin >> n
#define oi(n) printf("%d",n)
#define oll(n) printf("%lld",n)
#define ostr(n) printf("%s",n)
#define ol(n) cout << n
#define os cout<<" "
#define on cout<<"\n"
#define o2(a,b) cout<<a<<" "<<b
#define all(n) n.begin(),n.end()
#define present(s,x) (s.find(x) != s.end())
#define cpresent(s,x) (find(all(s),x) != s.end())
#define tr(container, it) for(__typeof(container.begin()) it = container.begin(); it != container.end(); it++)
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef long double ld;
typedef vector<vector<ll> > mat;
int main()
{ios_base::sync_with_stdio(false);
cin.tie(0);
int n,k;
cin>>n>>k;
vll c(n+5,0);
rep(i,0,n-1)
{
int x;
cin>>x;
c[x]++;
}
ll cnt=min(c[0],1ll*k);
ll ans=cnt;
rep(i,1,n)
{
cnt=min(cnt,c[i]);
ans+=cnt;
}
ol(ans);
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 2 "main.cpp"
int N,A[100010],B[100010];
bool used[50010];
int main(){
std::cin>>N;
rep(i,N)std::cin>>A[i];
rep(i,N)std::cin>>B[i];
std::vector<P> vec[2];
lint ans=0;
for(int i=0;i<N;i+=2){
int memo=std::max(A[i]+A[i+1],B[i]+B[i+1]);
ans+=memo;
vec[0].emplace_back(A[i]+B[i+1]-memo,i/2);
vec[1].emplace_back(A[i+1]+B[i]-memo,i/2);
}
std::sort(all(vec[0]),std::greater<P>());
std::sort(all(vec[1]),std::greater<P>());
int now[2]={};
while(true){
while(now[0]<N/2&&used[vec[0][now[0]].second])now[0]++;
while(now[1]<N/2&&used[vec[1][now[1]].second])now[1]++;
if(now[0]==N/2||now[1]==N/2)break;
if(vec[0][now[0]].first+vec[1][now[1]].first<=0)break;
ans+=vec[0][now[0]].first+vec[1][now[1]].first;
used[vec[0][now[0]].second]=true;
used[vec[1][now[1]].second]=true;
now[0]++;now[1]++;
}
std::cout<<ans<<std::endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define per(i,a,b) for(int i=(b)-1;i>=a;i--)
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define de(x) cout<<#x<<" = "<<x<<"\n"
#define dd(x) cout<<#x<<" = "<<x<<" "
#define mes(p) memset(p,0,sizeof(p))
#define all(x) x.begin(),x.end()
#define rson mid+1,r,rt<<1|1
#define sz(x) (int)x.size()
#define lson l,mid,rt<<1
#define mp make_pair
#define pb push_back
#define ls (rt<<1)
#define rs (ls|1)
#define se second
#define fi first
typedef pair <int ,int > pii;
typedef vector <int > vi;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const int mod = 1e9+7;
const int maxn= 1e5+5;
const int N = 1e6 + 6;
int n;
int a[maxn], b[maxn];
vi v[4];
int main(){
scanf("%d", &n);
ll ans = 0;
rep(i,0,n)scanf("%d", &a[i]), ans+=a[i];
rep(i,0,n) scanf("%d", &b[i]), b[i] -= a[i], v[i&1].pb(b[i]);
rep(i,0,2) sort(all(v[i])), reverse(all(v[i]));
rep(i,0,n/2){
if(v[0][i] + v[1][i] > 0)
ans += 1ll*v[0][i] + v[1][i];
}
cout << ans;
return 0;
}
|
/* Great things never come from comfort zones,
"whatever the mind of a man can conceive and believe,it can achieve." */
#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
using namespace std;
// using namespace __gnu_pbds;
// using ordered_set = tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>;
void my_dbg() { cout << endl; }
template<typename Arg, typename... Args> void my_dbg(Arg A, Args... B)
{ cout << ' ' << A; my_dbg(B...); }
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", my_dbg(__VA_ARGS__)
#define ll long long
#define dd double
#define scf(n) scanf("%d",&n)
#define lscf(n) scanf("%lld",&n)
#define lpri(n) printf("%lld ",n)
#define pri(n) printf("%d ",(int)n)
#define prin(n) printf("%d\n",(int)n)
#define lprin(n) printf("%lld\n",n)
#define rep(i,ini,n) for(int i=ini;i<(int)n;i++)
#define show(a) for(auto xy: a) pri(xy); printf("\n");
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(),x.end()
#define SET(a,b) memset(a,b,sizeof(a))
#define tc int tt; scf(tt); while(tt--)
#define inf INT_MAX
#define ninf INT_MIN
#define gcd __gcd
#define bitcount(n) __builtin_popcount(n)
const ll mod=1e9+7;
const int N = 1e6+7;
int main()
{
int n; scf(n);
int a[n],b[n];
rep(i,0,n)scf(a[i]);
rep(i,0,n)scf(b[i]);
int x=0;
rep(i,0,n)x+=(a[i]*b[i]);
if(x==0)printf("Yes\n");
else
printf("No\n");
}
| #include <bits/stdc++.h>
using namespace std;
void __print(int x) {cout << x;}
void __print(long x) {cout << x;}
void __print(long long x) {cout << x;}
void __print(unsigned x) {cout << x;}
void __print(unsigned long x) {cout << x;}
void __print(unsigned long long x) {cout << x;}
void __print(float x) {cout << x;}
void __print(double x) {cout << x;}
void __print(long double x) {cout << x;}
void __print(char x) {cout << '\'' << x << '\'';}
void __print(const char *x) {cout << '\"' << x << '\"';}
void __print(const string &x) {cout << '\"' << x << '\"';}
void __print(bool x) {cout << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cout << '{'; __print(x.first); cout << ','; __print(x.second); cout << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cout << '{'; for (auto &i: x) cout << (f++ ? "," : ""), __print(i); cout << "}";}
void _print() {cout << "]"<<endl;}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cout << ", "; _print(v...);}
#define deb(x...) cout << #x << " = ["; _print(x)
template<typename T,typename T1>T amax(T &a,T1 b){if(b>a)a=b;return a;}
template<typename T,typename T1>T amin(T &a,T1 b){if(b<a)a=b;return a;}
// =================
#define f(i, k, n) for (int i = k; i < n; i++)
#define r(i, k, n) for (int i = k; i >= n; i--)
#define ll long long
// #define int ll
#define pb push_back
#define fr first
#define sc second
#define len(s) s.size()
#define all(v) v.begin(), v.end()
#define tr(it, v) for (auto &it : v)
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef map<int, int> mii;
typedef vector<pii> vpii;
typedef vector<string> vs;
typedef vector<vi> vvi;
// =================
const int mod = 1e9+7;
const int N = 3e5 + 1;
void solve()
{
int n,k;
cin>>n>>k;
ll cnt=0;
int sum=max(k+2,2);
while (sum<=2*n)
{
int req=sum-k;
int r1=min(n,sum-1),l1=max(sum-r1,1);
int r2=min(n,req-1) , l2= max(req-r2,1);
// deb(sum,req);
sum++;
// deb(l1,r1,l2,r2);
if(max(l1,r1)>n || max(l2,r2)>n || min(l1,r1)<1 || min(l2,r2)<1) continue;
cnt+= 1ll*(abs(r1-l1) + 1)*(abs(r2- l2) + 1);
// deb(cnt);
}
cout<<cnt;
}
signed main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--)
solve();
// cerr<<(1000*clock())/CLOCKS_PER_SEC<<"ms";
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N; cin >> N;
vector<double> a(N),b(N),c(N),d(N);
for(int _=0; _<2; _++){
for(int i=0; i<N; i++) cin >> a[i] >> b[i];
int x = 0, y = 0;
for(int i=0; i<N; i++){
x += a[i];
y += b[i];
a[i] *= N;
b[i] *= N;
}
for(int i=0; i<N; i++){
a[i] -= x;
b[i] -= y;
}
swap(a,c);
swap(b,d);
}
for(int i=0; i<N; i++){
if(a[i]!=0 || b[i]!=0){
swap(a[i],a[0]);
swap(b[i],b[0]);
}
}
string ans = "No";
const double eps = 1e-6;
for(int i=0; i<N; i++){
double angle = atan2(d[i],c[i])-atan2(b[0],a[0]);
bool flag = true;
for(int j=0; j<N; j++){
double A = a[j]*cos(angle)-b[j]*sin(angle);
double B = a[j]*sin(angle)+b[j]*cos(angle);
bool flag2 = false;
for(int k=0; k<N; k++){
if(std::abs(A-c[k])<=eps && std::abs(B-d[k])<=eps) flag2 = true;
}
flag &= flag2;
}
if(flag) ans = "Yes";
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector <string> vs;
typedef vector<vector<int>> vvi;
typedef pair<int,int> pi;
//#define int ll
#define forl(i,a,b) for (int i = a; i < b; i++)
#define rfor(i,b,a) for (int i = b; i >= a; i--)
#define f first
//#define s second
#define pb push_back
#define mp make_pair
#define srt(x) sort(x.begin(), x.end())
#define sumup(x) accumulate(x.begin(), x.end(), 0)
#define PI 3.141592653589793238
// #define MOD 1000000007
#define rep(i,n) for(int i=0; i<n; i++)
#define rep1(i,n) for(int i=1; i<=n; i++)
#define rrep(i,n) for(int i = n-1; i >= 0; i--)
#define rrep1(i,n) for(int i=n; i>=1; i--)
#define YES cout<<"YES\n"
#define NO cout<<"NO\n"
const ll M=1e9+7;
long long mod(long long x){
return ((x%M + M)%M);
}
long long add(long long a, long long b){ //(a+b)%M
return mod(mod(a)+mod(b));
}
long long mul(long long a, long long b){ //(a*b)%M
return mod(mod(a)*mod(b));
}
long long modPow(int x, int y){ //(x^y)%M
if(y==0) return 1LL;
if(y==1) return mod(x);
long long res=1;
while(y){
if(y%2==1)
res=mul(res,x);
x=mul(x,x);
y/=2;
}
return res;
}
const int N=2e5+2;
int fact[N];
void precalc(){
fact[0]=1;
for(int i=1;i<N;i++){
fact[i]=mul(fact[i-1],i);
}
}
ll inv(ll x){
return modPow(x,M-2);
}
ll divide(ll a, ll b){
return mul(a,inv(b));
}
ll nCr(ll n, ll r){
return divide(fact[n],mul(fact[r],fact[n-r]));
}
void io() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
}
// number of partition sticks.. from 0 to n-1
// loop from 1 to n for first partition
// recurse on the left part for partitions-1; until no patition
void solve() {
int n; cin>>n;
vl a(n);
rep(i,n) cin>>a[i];
if(n==1) {
cout<<a[0]<<"\n"; return;
}
ll range = (1<<(n-1))-1;
ll ans = INT_MAX;
for(ll j=0; j<range; j++) {
// convert to binary digits and do partitions alongwith
vector<ll> b;
ll total = 0;
for(ll i=0; i<n; i++) {
total |= a[i];
if(j&(1<<i)) {
b.push_back(total);
total = 0;
}
}
if(total) b.push_back(total);
ll cal = 0;
for(auto el: b) cal ^= el;
ans = min(ans, cal);
}
cout<<ans;
return;
}
int32_t main() {
io();
int t=1;
//cin>>t;
while(t--) {
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(0), ios::sync_with_stdio();
int n, mn = 1001, mx = -1, x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
mx = max(mx, x);
}
for (int i = 0; i < n; i++) {
cin >> x;
mn = min(mn, x);
}
if (mx > mn) cout << "0\n";
else
cout << mn - mx + 1 << '\n';
}
| #include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; i++)
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
int main(void){
int N;
cin >> N;
int A[N], B[N];
vector<int> x;
rep(i, N) cin >> A[i];
rep(i, N) cin >> B[i];
rep(i, N){
if(i==0){
for(int j=A[i]; j<=B[i]; j++){
if(A[i]<=j && B[i]>=j) x.push_back(j);
}
}else{
rep(j, x.size()){
if(x[j]<A[i] || x[j]>B[i]){
x.erase(x.begin()+j);
j--;
}
}
}
}
cout << x.size() << endl;
return 0;
} |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
ll a,b,c,d;
cin>>a>>b>>c>>d;
ll count=0;
ll cyan=a;
ll red=0;
while(cyan>red)
{
if(count>100000)
{
cout<<-1<<endl;
return 0;
}
cyan+=b;
red+=c;
count++;
if(cyan<=red*d)
break;
}
cout<<count<<endl;
} | #include <iostream>
#include <vector>
#include <unordered_map>
#include <deque>
#include <list>
#include <set>
#include <random>
#include <deque>
#include <unordered_set>
using namespace std;
using ll = long long;
const ll BIG = 1000000007;
int main() {
ll x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
if(x1 == x2 && y1 == y2){
cout << 0 << endl;
}
else if((x1 + y1) == (x2 + y2) || (x1 - y1) == (x2 - y2) || (abs(x1 - x2) + abs(y1 - y2)) <= 3){
cout << 1 << endl;
}
else{
if((x1 + y1) % 2 == (x2 + y2) % 2){
cout << 2 << endl;
}
else{
for(ll x = x1 - 3;x <= x1 + 3;++x){
for(ll y = y1 - 3;y <= y1 + 3;++y){
if((abs(x - x1) + abs(y - y1)) <= 3){
if(((x + y) == (x2 + y2)) || ((x - y) == (x2 - y2))){
cout << 2 << endl;
return 0;
}
}
}
}
cout << 3 << endl;
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
void dfs(vector<vector<int > > &g,int s,int &n,int &m,int &ans,vector<int > &vis)
{
if(vis[s])
return;
vis[s]=1;
for(unsigned int i=0;i<g[s].size();i++)
{
if(!vis[g[s][i]])
{ ans++;
dfs(g,g[s][i],n,m,ans,vis);
}
}
return ;
}
int main()
{
int n;
int m;
cin>>n>>m;
vector<vector<int> > g(n);
for(int i=0;i<m;i++)
{
int x,y;
cin>>x>>y;
x=x-1;
y=y-1;
g[x].push_back(y);
}
int ans= n;
for(int i=0;i<n;i++)
{ vector<int> vis;
for(int j=0;j<n;j++)
vis.push_back(0);
int a=0;
dfs(g,i,n,m,a,vis) ;
ans+=a;
// ans+=(long long int) (a );
// cout<<"i"<<i<<" "<<a<<endl;
}
cout<<ans<<endl;
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++)
using Graph = vector<vector<int>>;
ll ans = 0;
vector<bool> seen;
void dfs(Graph &g,int v){
seen.at(v) = true;
ans++;
for(auto nv:g.at(v)){
if(!seen.at(nv)){
dfs(g,nv);
}
}
return;
}
int main(){
int n,m;
cin >> n >> m;
Graph g(n);
rep(i,m){
int a,b;
cin >> a >> b;
a--; b--;
g.at(a).push_back(b);
}
rep(i,n){
seen.assign(n, false);
dfs(g,i);
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int MOD = (int)1e9 + 7;
int binpow(int a, int b) {
a %= MOD;
int res = 1;
while (b > 0) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
int inverse(int x){
return binpow(x, MOD - 2);
}
void solve()
{
int N, Q;
cin >> N >> Q;
vector<int> A(N);
for(int i = 0; i < N; i++) cin >> A[i];
sort(A.begin(), A.end());
auto search = [&](int K){
int l = 0, r = N - 1;
while(l <= r){
int mid = (l + r) / 2;
int num = A[mid] - (mid + 1);
if(num == K){
if(mid > 0 && ((A[mid - 1] - mid) == K)){
r = mid - 1;
continue;
}
return A[mid] - 1;
}
if(num < K) l = mid + 1;
else if(K < num) r = mid - 1;
}
if(r < 0) return K;
int less = A[r] - (r + 1);
K -= less;
return A[r] + K;
};
while(Q--){
int K;
cin >> K;
cout << search(K) << "\n";
}
}
signed main()
{
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
solve();
cerr << "Time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n ";
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
map <string, int> str; // map のデータ構造を用意する。
string s[200010];
int main() {
int n;
cin >> n;
rep(i, n) {
cin >> s[i];
if (s[i].at(0)=='!'){
if (str[s[i]]==1){
cout << s[i].substr(1) << endl;
return 0;
}
str[s[i]]=10;
}else{
if (str['!'+s[i]]==10){
cout << s[i] << endl;
return 0;
}
str['!'+s[i]]=1;
}
}
cout << "satisfiable" << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define ll long long int
#define sd(x) scanf("%lld",&x)
#define sdi(x) scanf("%d",&x)
#define sdc(c) scanf("%c",&c)
#define inf 1000000000000000000ll
#define pll pair<ll,ll>
#define pii pair<int,int>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define bits(x) __builtin_popcountll(x)
#define ld long double
#define test() ll test; cin>>test; while(test--)
#define fi first
#define se second
#define all(x) x.begin(),x.end()
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
inline ll GCD(ll x, ll y) {
if(x<y) swap(x,y);
if(x==0) return y;
if(y==0) return x;
return GCD(x%y,y);
}
ll phi(ll n) {
ll result = n;
for (ll i = 2; i * i <= n; i++) {
if(n % i == 0) {
while(n % i == 0)
n /= i;
result -= result / i;
}
}
if(n > 1)
result -= result / n;
return result;
}
ll power(ll x, ll n, ll mod) {
ll res = 1;
x %= mod;
while(n) {
if(n&1) {
res = ((res*x)%mod+mod)%mod;
}
x = ((x*x)%mod+mod)%mod;
n>>=1;
}
return res;
}
const int MOD = 1e9+7;
inline ll add(ll x, ll y, ll MOD) {
x %= MOD;
y %= MOD;
ll ans = (x+y)%MOD;
return ans;
}
inline ll mul(ll x,ll y, ll MOD) {
x %= MOD;
y %= MOD;
ll ans = ((x*y)%MOD+MOD)%MOD;
return ans;
}
ll N,M;
ll adj[20][20]={0};
int main() {
fastio;
cin>>N>>M;
/*if(M==0) {
cout<<"N"<<endl;
return 0;
}*/
ll x,y;
for(int i=1;i<=M;i++) {
cin>>x>>y;
adj[x][y] = 1;
adj[y][x] = 1;
}
ll MX = (1<<N);
ll BT = MX-1;
vector<ll> v;
bool check=false;
vector<ll> dp(MX+1,0);
dp[0]=1;
ll ans = 0;
for(ll i=1;i<MX;i++) {
// if(bits(i)==1) continue;
v.clear();
for(int j=0;j<N;j++) {
if((i>>j)&1) {
v.pb(j+1);
}
}
check=true;
for(int j=0;j<v.size();j++) {
for(int k=j+1;k<v.size();k++) {
if(!adj[v[j]][v[k]]) {
check=false;
break;
}
}
}
if(check) {
dp[i] = 1;
}
}
vector<ll> G(MX+1,inf);
G[0]=0;
for(ll i=1;i<MX;i++) {
if(dp[i]) {
G[i] = 1;
continue;
}
for(ll mask = i;mask>0;mask = (i&(mask-1))) {
G[i] = min(G[i],G[mask]+G[i^mask]);
}
}
ans = G[BT];
cout<<ans<<endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define all(x) x.begin(),x.end()
#define pll pair <long long,long long>
#define ss second
#define ff first
#define inf (ll)1e18
#define mod 998244353
#define ld long double
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);
#define bug(x) cout << #x <<": " << x << '\n';
#define endl "\n"
#define size sz
const ll N=101 ;
ll n ;
vector<pair<ld,ld>>v ;
vector<ll>adj[N] ;
ld get_dist(ll i,ll j)
{
return (v[i].ff-v[j].ff)*(v[i].ff-v[j].ff)+(v[i].ss-v[j].ss)*(v[i].ss-v[j].ss) ;
}
bool check(ld r)
{
ll vis[n] ;
for(ll i=0;i<n;i++) vis[i]=false ;
queue<ll>q ;
for(ll i=0;i<n;i++)
{
if(100.0-v[i].ss<2.0*r)
{
vis[i]=true ;
q.push(i) ;
}
}
while(!q.empty())
{
ll node=q.front() ;
if(v[node].ss+100.0<2.0*r) return false ;
q.pop() ;
for(ll child:adj[node])
{
if(vis[child]==false)
{
vis[child]=true ;
q.push(child) ;
}
}
}
return true ;
}
int main(){
fast ;
cin>>n ;
for(ll i=0;i<n;i++){
ld x,y ;
cin>>x>>y ;
v.pb({x,y}) ;
}
ld low=0.0,high=100.0,ans=1.0 ;
while((high-low)>=0.000000001){
ld mid=(low+high)/2.0 ;
for(ll i=0;i<N;i++) adj[i].clear() ;
for(ll i=0;i<n;i++){
for(ll j=i+1;j<n;j++){
ld dist=get_dist(i,j) ;
if(dist<4.0*mid*mid) adj[i].pb(j), adj[j].pb(i);
}
}
if(check(mid)) ans=mid,low=mid ;
else high=mid ;
}
cout<<fixed<<setprecision(10)<<ans ;
}
|
#include <bits/stdc++.h>
#define br cout << "\n";
#define pb push_back
#define ll long long
#define ff first
#define ss second
#define all(x) x.begin(),x.end()
#define in(a , idx , n ) for (int i = idx ; i < n ; ++i)cin >>a[i];
#define fix() cout <<fixed << std::setprecision(10)
using namespace std;
const int MOD = 1000*1000*1000 + 7 ;
const int MAXN = 1000*1000 +10 ;
const ll INF = 1e18 ;
void solve(){
string s , t ;
cin >> s >> t ;
if ( s[0] == 'Y')
cout<<((char)((int)t[0]-32));
else
cout << t[0];
br
}
int main (){
int t = 1 ;
// cin >> t ;
while (t--){
solve() ;
}
return 0 ;
}
| #line 1 "C.cpp"
#include <bits/stdc++.h>
using namespace std::literals::string_literals;
using i64 = std::int_fast64_t;
using std::cout;
using std::cerr;
using std::endl;
using std::cin;
#if defined(DONLINE_JUDGE)
#define NDEBUG
#elif defined(ONLINE_JUDGE)
#define NDEBUG
#endif
template<typename T> std::vector<T> make_v(size_t a){return std::vector<T>(a);}
template<typename T, typename... Ts> auto make_v(size_t a, Ts... ts){
return std::vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
int main() {
int h, w; scanf("%d%d", &h, &w);
std::vector<std::string> s(h);
for(auto& v: s) std::cin >> v;
int ans = 0;
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
if(s[i][j] == '.') {
if(i - 1 >= 0 and j - 1 >= 0 and s[i - 1][j] == '#' and s[i][j - 1] == '#') ans++;
if(i - 1 >= 0 and j + 1 < w and s[i - 1][j] == '#' and s[i][j + 1] == '#') ans++;
if(i + 1 < h and j - 1 >= 0 and s[i + 1][j] == '#' and s[i][j - 1] == '#') ans++;
if(i + 1 < h and j + 1 < w and s[i + 1][j] == '#' and s[i][j + 1] == '#') ans++;
} else {
if(s[i - 1][j] == '.' and s[i][j - 1] == '.') ans++;
if(s[i - 1][j] == '.' and s[i][j + 1] == '.') ans++;
if(s[i + 1][j] == '.' and s[i][j - 1] == '.') ans++;
if(s[i + 1][j] == '.' and s[i][j + 1] == '.') ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;using vl=vector<ll>;
using vi=vector<int>;using vs=vector<string>;using vc=vector<char>;
using vvl=vector<vl>;using pl=pair<ll,ll>;using vvc=vector<vc>;
using vd=vector<double>;using vpl=vector<pl>;using vb=vector<bool>;
#define rep(i,r) for(ll i=0;i<(r);i++)
#define Rep(i,l,r) for(ll i=(l);i<(r);i++)
#define print(n) cout<<(n)<<endl
#define all(a) (a).begin(),(a).end()
#define sortp(d) sort(all(d))
#define sortm(d) sort(d.rbegin(),d.rend())
//cout<<fixed<<setprecision(15)<<
//priority_queue<pl,vpl,greater<pl>>
void yn(bool b){print(b?"Yes":"No");exit(0);}
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/gcd(a,b)*b;}
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 modinv(ll a,ll mod){return modpow(a, mod - 2, mod);}
ll p=0,q=0,r=0,inf=100000000000000000,mod=1000000007;
ll dx[8]={1,0,-1,0,1,-1,-1,1},dy[8]={0,1,0,-1,1,1,-1,-1};
//ここから本質←ほんまか？
double pi=3.141592653589793238462643383279;
ll fac[10000001],inv[10000001],facinv[10000001];
void cominit(ll max){fac[0]=1;fac[1]=1;inv[1]=1;facinv[0]=1;facinv[1]=1;
for(int i=2;i<=max;i++){fac[i]=(fac[i-1]*i)%mod;
inv[i]=mod-inv[mod%i]*(mod/i)%mod;facinv[i]=facinv[i-1]*inv[i]%mod;}}
ll com(ll n,ll k){return fac[n]*(facinv[k]*facinv[n-k]%mod)%mod;}
int main()
{
ll z,m;cin>>z>>m;
mod=998244353;
cominit(z+m);
Rep(i,1,m+1)
{
ll n=i;
q=1;
for(ll div=2;div*div<=n;div++)
{
if(n%div!=0)continue;
ll tmp=0;
while(n%div==0)n/=div,tmp++;
//div^tmpが素因数
/*any*/
q*=com(z+tmp-1,tmp);
q%=mod;
}
if(n!=1){/*any*/q*=z;q%=mod;}
p+=q;
p%=mod;
}
print(p);
}
//中１水コーダーになりたいんです...お願いします...後輩にカッコつけたいんです...マジで...
//てかもう中１終わるの流石にバグだろ
//↑それな
//劇団ひとり定期
//さみし()
//そういえばコーヒーは美味しいですね。魔剤なんか飲むなら黙ってコーヒー
//コメントの使い方ってこういう感じですよね！？ | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
#define setIO(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)
#define closefile fclose(stdin), fclose(stdout)
#define m_p make_pair
#define sz(x) (int)x.size()
#define see(x) cerr << x << " "
#define seeln(x) cerr << x << endl
#define out(x) cerr << #x << " = " << x << " "
#define outln(x) cerr << #x << " = " << x << endl
#define outarr(x, l, r) {cerr<< #x"[" << l << " ~ " << r << "] = "; for (int _i = l; _i <= r; ++_i) cerr << x[_i] << " "; cerr << endl;}
using namespace std;
typedef long long ll;
typedef pair <int, int> pii;
#define gc() getchar()
//#define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T> void read(T &x)
{
x = 0; int c = gc(); int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = gc();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) +(c ^ 48), c = gc();
if (flag) x = -x;
}
template <class T> T _max(T a, T b){return b < a ? a : b;}
template <class T> T _min(T a, T b){return a < b ? a : b;}
template <class T> bool checkmax(T &a, T b){return a < b ? a = b, 1 : 0;}
template <class T> bool checkmin(T &a, T b){return b < a ? a = b, 1 : 0;}
const int N = 200005, mod = 998244353;
void add(int &a, int b){a += b; (a >= mod) && (a -= mod);}
void sub(int &a, int b){a -= b; (a < 0) && (a += mod);}
void mul(int &a, int b){a = (ll)a * b % mod;}
int Add(int a, int b){a += b; return a >= mod ? a - mod : a;}
int Sub(int a, int b){a -= b; return a < 0 ? a + mod : a;}
int Mul(int a, int b){return (ll)a * b % mod;}
int qpow(int a, int b){int ans = 1; while (b) {if (b & 1) ans = (ll)ans * a % mod; a = (ll)a * a % mod; b >>= 1;} return ans;}
vector<int> f[N];
int n, m, lim;
int ans = 0;
int fac[N], ifac[N];
void init()
{
read(n); read(m);
for (int i = 1; i <= m; ++i) for (int j = i; j <= m; j += i) if (i > 1) f[j].push_back(i);
fac[0] = 1; for (int i = 1; i <= n; ++i) fac[i] = Mul(fac[i - 1], i);
ifac[n] = qpow(fac[n], mod - 2); for (int i = n - 1; i >= 0; --i) ifac[i] = Mul(ifac[i + 1], i + 1);
}
const int K = 448;
int cnt = 0;
void dfs(int x, int s, int co, int num)
{
if (m < (ll)x * s) x = K + 1;
if (x > K)
{
add(ans, Mul(fac[n], Mul(ifac[n - num], co)));
if (K + 1 <= m / s && num < n)
{
int pq = m / s - K;
add(ans, Mul(Mul(fac[n], pq), Mul(ifac[n - 1 - num], co)));
}
return;
}
int now = s, lim = m / x;
for (int i = 0; i <= n - num; ++i)
{
dfs(x + 1, now, Mul(co, ifac[i]), num + i);
if (now > lim) break;
now *= x;
}
}
void solve()
{
dfs(2, 1, 1, 0);
outln(cnt);
printf("%d\n", ans);
}
int main()
{
init();
solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int m,h;
cin>>m>>h;
if(h%m==0){
cout<<"Yes\n";
}
else{
cout<<"No\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
typedef long long ll;
#define F first
#define S second
#define YES(n)cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
int main(){
int M,H;
cin>>M>>H;
Yes(H%M==0);
return 0;
} |
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<iomanip>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;
#define DEBUG(x) cout<<#x<<"="<<x<<endl
#define DEBUG2(x,y) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<endl
typedef long long ll;
const int MAXN=1;
const ll MOD=1;
ll _gcd(ll a,ll b){if(b==0)return a;return _gcd(b,a%b);}
ll gcd(ll a,ll b){a=abs(a),b=abs(b);if(a<b)swap(a,b);return _gcd(a,b);}
ll qpow(ll a,ll n){ll rt=1;while(n){if(n&1)rt=(rt*a)%MOD;a=a*a%MOD;n>>=1;}return rt;}
ll factor[MAXN];
ll inv[MAXN];
void cal_factor(){factor[0]=1;for(int u=1;u<MAXN;u++){factor[u]=(factor[u-1]*u)%MOD;}}
void cal_factor_inv(){inv[0]=1;inv[MAXN-1]=qpow(factor[MAXN-1],MOD-2);for(int u=MAXN-2;u>=1;u--){inv[u]=inv[u+1]*(u+1)%MOD;}}
void init_factor(){cal_factor();cal_factor_inv();}
ll C(ll n,ll k){if(n<k)return 0;return factor[n]*qpow(factor[n-k],MOD-2)%MOD*qpow(factor[k],MOD-2)%MOD;}
struct mat{
ll m[3][3];
mat(){
memset(m,0,sizeof(m));
}
mat(ll a[3][3]){
memcpy(m,a,sizeof(m));
}
mat operator * (const mat mt){
//m (3,3)
mat tmp;
for(int u=0;u<3;u++){
for(int v=0;v<3;v++){
for(int k=0;k<3;k++){
tmp.m[u][v]+=m[u][k]*mt.m[k][v];
}
}
}
return tmp;
}
mat operator *=(const mat &mt){
return *this=(*this)*mt;
}
friend ostream& operator<<(ostream &out,const mat &m){
for(int u=0;u<3;u++){
for(int v=0;v<3;v++){
cout<<m.m[u][v]<<" ";
}
cout<<"\n";
}
return out;
}
};
ll pat[][3][3]={
{0,1,0,-1,0,0,0,0,1},
{0,-1,0,1,0,0,0,0,1},
{-1,0,0,0,1,0,0,0,1},
{1,0,0,0,-1,0,0,0,1}
};
mat get_mat(int op,int p){
if(op==1||op==2){
return mat(pat[op-1]);
}else if(op==3){
pat[op-1][0][2]=2*p;
return mat(pat[op-1]);
}else if(op==4){
pat[op-1][1][2]=2*p;
return mat(pat[op-1]);
}
}
pair<ll,ll> pt_trans(pair<ll,ll>pt,mat &m){
ll x,y;
x=m.m[0][0]*pt.first+m.m[0][1]*pt.second+m.m[0][2];
y=m.m[1][0]*pt.first+m.m[1][1]*pt.second+m.m[1][2];
return {x,y};
}
void solve(){
// ll a1[3][3]={2,0,0,0,2,0,0,0,2},
// a2[3][3]={1,2,3,4,5,6,7,8,9};
// mat m1(a1),m2(a2);
vector<mat>macc;
vector<pair<ll,ll>>pts;
int n;
cin>>n;
for(int u=0;u<n;u++){
ll x,y;
cin>>x>>y;
pts.push_back({x,y});
}
int m;
cin>>m;
for(int t=0;t<m;t++){
int op,p;
cin>>op;
if(op==3||op==4)cin>>p;
if(t==0){
macc.push_back(get_mat(op,p));
}else {
macc.push_back(get_mat(op,p)*macc.back());
}
}
int q;
cin>>q;
while(q--){
int a,b;
cin>>a>>b;
b--;
if(a==0){
cout<<pts[b].first<<" "<<pts[b].second<<"\n";
continue;
}
a--;
auto p=pt_trans(pts[b],macc[a]);
cout<<p.first<<" "<<p.second<<"\n";
}
}
// #define LOCAL
int main()
{
#ifdef LOCAL
freopen("in.txt","r",stdin);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
solve();
} | #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());
}
ll rand_int(ll l, ll r) //[l, r]
{
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
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);
}
const int maxn=1e4+7;
const int mod=998244353;
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin>>n;
vi a(n);
for(int i=0;i<n;i++) cin>>a[i];
vc<vi> dp(n+1,vi(maxn));
int sum=0;
dp[0][0]=1;
for(int i=1;i<=n;i++)
{
sum+=a[i-1];
for(int j=n-1;j>=0;j--)
{
for(int k=a[i-1];k<maxn;k++)
dp[j+1][k]=(dp[j+1][k]+dp[j][k-a[i-1]])%mod;
}
}
if(sum%2!=0) print(0);
else{
ll ans=0;
for(int i=0;i<=n;i++)
{
ll cur=dp[i][sum/2];
//dbg(i,cur);
for(int j=1;j<=i;j++) cur=cur*j%mod;
for(int j=1;j<=n-i;j++) cur=cur*j%mod;
ans=(ans+cur)%mod;
}
print(ans);
}
} |
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
int n,m;
int sa;
int ans1,ans2;
int ksm(ll ta,int tp){
int s=1;
for(;tp;ta=ta*ta%mod,tp>>=1) if(tp&1) s=ta*s%mod;
return s;
}
int main(){
scanf("%d %d",&n,&m);
m+=n;
for(int i=1,a;i<=n;i++){
scanf("%d",&a); sa+=a;
}
sa+=n;
ans1=ans2=1;
if(m<sa){
printf("0\n");
return 0;
}
for(int i=1;i<=sa;i++) ans1=1ll*ans1*i%mod;
for(int i=1;i<=sa;i++) ans2=1ll*ans2*(m-i+1)%mod;
printf("%lld\n",1ll*ans2*ksm(ans1,mod-2)%mod);
return 0;
}
| #include <bits/extc++.h>
using namespace std;
using namespace __gnu_cxx;
template<typename T>
int ex(T p){
T a = 1;
if(p == 0){
return a;
}
else{
for(T i = 1; i <= p; i++){
a = a*i%1000000007;
}
return a;
}
}
template<typename T>
int eq(T p, T q){
T r,s = 0,nextp,prevp = 0,prev2p = 1;
if(q != 1){
while(s != 1){
r = p/q; s = p%q;
nextp = prevp;
prevp = prev2p - r * prevp;
prev2p = nextp;
p = q; q = s;
}
return prevp;
}
else{
return 0;
}
}
template<typename T>
int com(T p,T q){
T a,b,c,mod = 1000000007;
a = ex(p);
b = ex(q);
for(T i = 1; i <= p-q; i++){
b = b*i%mod;
}
if(b != 1){
c = ((1 - eq(mod,b)*mod )/b + mod) %mod;
}
else{
c = 1;
}
return a*c%mod;
}
template<typename T>
int gcd(T p,T q){
T s;
while(q != 0){
s = p%q;
p = q; q = s;
}
return p;
}
template<typename T>
int point(const vector<T> &P){
T sum = 0;
for(T i = 1; i < 10; i++){
if(P[i] == 0){
sum += i;
}
else{
T t = 1;
for(T j = 0; j < P[i]; j++){
t*=10;
}
sum += i*t;
}
}
return sum;
}
int main() {
int a,b;
cin >> a >> b;
cout << 2*a-b+100 << endl;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define all(x) (x).begin(),(x).end()
#define uniq(v) (v).erase(unique(all(v)),(v).end())
#define sz(x) (int)((x).size())
#define fr first
#define sc second
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int,int>
#define mii map<pii,int>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define el '\n'
void solve()
{
int a,b;
cin>>a>>b;
if(a>=b){
int cnt=0;
rep(i,1,a+1){
cout<<i<<' ';
cnt+=i;
}
rep(i,1,b){
cout<<-1*i<<' ';
cnt-=i;
}
cout<<-1*cnt<<el;
}
else{
int cnt=0;
rep(i,1,b+1){
cout<<-1*i<<' ';
cnt+=i;
}
rep(i,1,a){
cout<<1*i<<' ';
cnt-=i;
}
cout<<1*cnt<<el;
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t=1;
// cin>>t;
while(t--) solve();
return 0;
}
| #include <iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<math.h>
#include<climits>
using namespace std;
int main() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("ou.txt", "w", stdout);
#endif
int a, b; cin >> a >> b;
vector<int> v, v1;
if (a > b) {
int sum = 0, sum1 = 0;
for (int i = 1; i <= a; i++) {
v.push_back(i);
sum += i;
}
for (int i = 1; i <= b - 1; i++) {
v1.push_back(-i);
sum1 += i;
}
v1.push_back(sum1 - sum);
}
else if (a < b) {
int sum = 0, sum1 = 0;;
for (int i = 1; i <= b; i++) {
v1.push_back(-i);
sum += i;
}
for (int i = 1; i <= a - 1; i++) {
v.push_back(i);
sum1 += i;
}
v.push_back((sum - sum1));
}
else {
for (int i = 1; i <= a; i++) {
v1.push_back(-i);
v.push_back(i);
}
}
for (int i = 0; i < v.size(); i++)
cout << v[i] << " ";
for (int i = 0; i < v1.size(); i++)
cout << v1[i] << " ";
} |
#include <iostream>
#include <iomanip>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
using ll = long long int;
int main(){
int a, b; cin >> a >> b;
cout << (a+b)/2 << " " << (a-b)/2 << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ll N, M;
cin >> N >> M;
if ((M > 0 && M >= N - 1) || M < 0) {
cout << -1 << endl;
return 0;
}
vector<P> ans(N);
rep(i, N) { ans[i] = make_pair(3 * (i + 1), 3 * (i + 1) + 1); }
if (M > 0) ans[N - 1].first = 3 * ((N - 1) - (M + 1) + 1) - 1;
rep(i, N) { cout << ans[i].first << " " << ans[i].second << 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>
#include <utility>
#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
const integer mod = 998244353;
integer ml(integer a, integer b) {
return (a * 1ll * b) % mod;
}
integer add(integer a, integer b) {
integer rt = a + b;
if (rt < mod) return rt;
return rt - 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, ll p) {
if (p == 0) return 1;
if (p & 1) return ml(b, b_p(b, p - 1));
return sq(b_p(b, p >> 1));
}
const ll inf = 1e18 + 231;
#define solvsh
//#define multi
#ifdef solvsh
void precalc() {}
const int INF = 2e9;
const int MAXN = 1e4 + 32;
const int MAXM = 2e5 + 32;
pair<pair<ll, pair<ll, ll>>, pair<ll, pair<ll, ll>>> eqs[MAXM];
void solve() {
int n;
cin >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
v.push_back({x, y});
}
eqs[0] = {{1, {0, 0}},
{0, {1, 0}}};
int m;
cin >> m;
for (int i = 1; i <= m; ++i) {
int p;
cin >> p;
if (p == 1) {
eqs[i] = {
eqs[i - 1].second,
{-eqs[i - 1].first.first, {-eqs[i - 1].first.second.first, -eqs[i - 1].first.second.second}}
};
} else if (p == 2) {
eqs[i] = {
{-eqs[i - 1].second.first, {-eqs[i - 1].second.second.first, -eqs[i - 1].second.second.second}},
eqs[i - 1].first
};
} else if (p == 3) {
int x;
cin >> x;
eqs[i] = {
{-eqs[i - 1].first.first, {-eqs[i - 1].first.second.first, 2 * x - eqs[i - 1].first.second.second}},
eqs[i - 1].second
};
} else {
int y;
cin >> y;
eqs[i] = {
eqs[i - 1].first,
{-eqs[i - 1].second.first,
{-eqs[i - 1].second.second.first, 2 * y - eqs[i - 1].second.second.second}}
};
}
}
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
--b;
auto eq = eqs[a];
ll x = v[b].first;
ll y = v[b].second;
cout << eq.first.first * x + eq.first.second.first * y + eq.first.second.second << " "
<< eq.second.first * x + eq.second.second.first * y + eq.second.second.second << "\n";
}
}
#else
void precalc() {}
void solve() {}
#endif
void multisolve() {
precalc();
int t;
cin >> t;
int i = 1;
while (t--) {
solve();
i++;
}
}
void singlesolve (){
precalc();
solve();
}
#ifndef ONLINE_JUDGE
void gen() {
}
#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
singlesolve();
// gen();
#endif
} | /**
* Author: Daniel
* Created Time: 2021-04-03 10:23:06
**/
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define ER erase
#define IS insert
#define PI acos(-1)
#define PB pop_back
#define MP make_pair
#define MT make_tuple
#define LB lower_bound
#define UB upper_bound
#define EB emplace_back
#define lowbit(x) (x & -x)
#define SZ(x) ((int)x.size())
#define ALL(x) x.begin(), x.end()
#define RALL(x) x.rbegin(), x.rend()
#define SOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);cout<<fixed<<setprecision(10)
typedef long long LL;
typedef vector<LL> VL;
typedef vector<int> VI;
typedef vector<bool> VB;
typedef pair<LL, LL> PLL;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef unsigned long long ULL;
typedef pair<double, double> PDD;
typedef vector<pair<LL, LL> > VPLL;
typedef vector<pair<int, int> > VPII;
template <typename A> using VE = vector<A>;
template <typename A> using USET = unordered_set<A>;
template <typename A> using HEAP = priority_queue<A>;
template <typename A, typename B> using PA = pair<A, B>;
template <typename A, typename B> using UMAP = unordered_map<A, B>;
template <typename A> using RHEAP = priority_queue<A, vector<A>, greater<A> >;
template <typename A> A MAX(const A &a) { return a; }
template <typename A> A MIN(const A &a) { return a; }
template <typename A> A MAX(const A *a, const A *b) { return *max_element(a, b); }
template <typename A> A MIN(const A *a, const A *b) { return *min_element(a, b); }
template <typename A, typename... B> A MAX(const A &a, const B&... b) { return max(a, MAX(b...)); }
template <typename A, typename... B> A MIN(const A &a, const B&... b) { return min(a, MIN(b...)); }
template <typename A, typename B = typename std::iterator_traits<A>::value_type> B MAX(A a, A b) { return *max_element(a, b); }
template <typename A, typename B = typename std::iterator_traits<A>::value_type> B MIN(A a, A b) { return *min_element(a, b); }
mt19937 rng((unsigned int)chrono::steady_clock::now().time_since_epoch().count());
///////////////////////////////////////////////////////////////////////////
//////////////////// DO NOT TOUCH BEFORE THIS LINE ////////////////////////
///////////////////////////////////////////////////////////////////////////
// check the limitation!!!
const int N = 100010, M = 1010;
// read the question carefully!!!
int main()
{
SOS;
int n;
cin >> n;
VPLL a(n);
for (auto &[x, y] : a) cin >> x >> y;
int m;
cin >> m;
bool flag = false;
LL sx = 1, sy = 1;
LL cx = 0, cy = 0;
VE<tuple<bool, LL, LL, LL, LL>> op;
op.EB(MT(flag, sx, cx, sy, cy));
for (int i = 0; i < m; i ++ )
{
int t;
cin >> t;
if (t == 1)
{
flag = !flag;
sx = -sx;
cx = -cx;
swap(sx, sy);
swap(cx, cy);
}
else if (t == 2)
{
flag = !flag;
sy = -sy;
cy = -cy;
swap(sx, sy);
swap(cx, cy);
}
else if (t == 3)
{
LL p;
cin >> p;
sx = -sx;
cx = 2 * p - cx;
}
else if (t == 4)
{
LL p;
cin >> p;
sy = -sy;
cy = 2 * p - cy;
}
else assert(false);
op.EB(MT(flag, sx, cx, sy, cy));
}
int q;
cin >> q;
for (int i = 0; i < q; i ++ )
{
int c, b;
cin >> c >> b;
b -- ;
LL x, y;
auto [flag, sx, cx, sy, cy] = op[c];
if (!flag) x = sx * a[b].F + cx, y = sy * a[b].S + cy;
else x = sx * a[b].S + cx, y = sy * a[b].F + cy;
cout << x << ' ' << y << '\n';
}
return 0;
}
// GOOD LUCK!!!
|
#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<math.h>
using namespace std;
typedef long long ll;
#define int long long
#define double long double
typedef vector<int> VI;
typedef pair<int, int> pii;
typedef vector<pii> VP;
typedef vector<string> VS;
typedef priority_queue<int> PQ;
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 fore(i,a) for(auto &i:a)
#define REP(i,n) for(int i=0;i<n;i++)
#define eREP(i,n) for(int i=0;i<=n;i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define eFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define SORT(c) sort((c).begin(),(c).end())
#define rSORT(c) sort((c).rbegin(),(c).rend())
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
#define eps 1e-12
//priority_queue<int,vector<int>, greater<int> > q2;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int S, P; cin >> S >> P;
int n = P;
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);
}
}
}
int ans = 0;
SORT(ret);
int s = 0, t = ret.size() - 1;
while (t >= 0) {
if (ret[s] + ret[t] == S)ans++;
s++;
t--;
}
if (ans) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
//#pragma GCC optimize("Ofast,unroll-loops")
//#pragma GCC target("avx,avx2,sse,sse2")
using namespace std;
void solve(){
int64_t s, p;
cin >> s >> p;
vector<int64_t> div;
for (int64_t i = 1; i*i <= p; i++)
{
if(i*i == p) div.push_back(i);
else if(p % i == 0) {
div.push_back(i);div.push_back(p/i);
}
}
sort(div.begin(), div.end());
int d = div.size();
string ans = "No\n";
for (int i = 0; i < d; i++)
{
if(div[i] + p / div[i] == s){
ans = "Yes\n";
}
}
cout << ans;
}
int32_t main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
int32_t tt = 1;
//cin >> tt;
while(tt-->0) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define BE(x) x.begin(), x.end()
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
for (auto &x : s) cin >> x;
vector<bitset<2>> cnt;
for (int j = 0; j < w; j++) {
bitset<2> bs;
int jj = j;
for (int i = 0; jj >= 0 && i < h; i++, jj--) {
if (s[i][jj] == 'R') bs[0] = true;
else if (s[i][jj] == 'B') bs[1] = true;
}
cnt.push_back(bs);
}
for (int i = 1; i < h; i++) {
bitset<2> bs;
int ii = i;
for (int j = w-1; ii < h && j >= 0; ii++, j--) {
if (s[ii][j] == 'R') bs[0] = true;
else if (s[ii][j] == 'B') bs[1] = true;
}
cnt.push_back(bs);
}
ll ans = 1;
for (auto &x : cnt) {
if (x[0] && x[1]) {
cout << 0 << endl;
return 0;
}
else if (!(x[0] || x[1])) {
ans = ans * 2LL % 998244353LL;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int64_t inf = 998244353;
int main() {
int H, W, HW, k=1;
int64_t ans = 1;
cin >> H >> W;
HW = H + W - 1;
string S, AllS;
vector<int> vec(HW);
bool f = true;
cin >> S;
AllS = S;
for(int i = 1; i < H; i++){
cin >> S;
if(!f) continue;
for(int j = 0; j < W-1; j++){
if(S.at(j) == '.') continue;
if(AllS.at(j+k) == '.'){
AllS.at(j+k) = S.at(j);
continue;
}
if(S.at(j) != AllS.at(j+k)){
ans = 0;
f = false;
break;
}
}
AllS += S.at(W-1);
k++;
}
if(!f) cout << '0' << endl;
else{
for(auto c: AllS){
if(c == '.'){
ans = (ans*2)%inf;
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin >> n >> k;
vector<pair<unsigned long long int,unsigned long long int>> f(n);
for(int i=0; i<n; i++){
cin >> f[i].first >> f[i].second;
}
sort(f.begin(),f.end());
unsigned long long int money = k;
unsigned long long int cur = 0;
for(int i=0; i<n; i++){
unsigned long long int tmp = f[i].first - cur;
if(tmp<=money){
money -= tmp;
money += f[i].second;
cur = f[i].first;
}else{
break;
}
}
unsigned long long int ans = cur + money;
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
#define LL long long
#define ULL long long unsigned
#define LD long double
#define ff first
#define ss second
#define FOR(i,n) for(int i=0;i<n;i++)
#define FLR(i,n) for(LL i=0;i<n;i++)
#define RFOR(i,n) for(int i=n-1;i>=0;i--)
#define RFLR(i,n) for(LL i=n-1;i>=0;i--)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define repl(i,a,b) for(LL i=a;i<=b;i++)
#define fast ios_base::sync_with_stdio(0);cin.tie(0);
#define all(a) a.begin(),a.end()
#define ABS(x) ((x)<0?-(x):(x))
#define NL "\n"
#define pb push_back
#define mk make_pair
#define pi acos(-1.0)
#define prec(n) fixed << setprecision(n)
#define sq(a) (a)*(a)
int main()
{
fast;
LL i,j,k,a,b,n,ans=0,prev=0,sum=0;
map<LL,LL>mp;
cin>>n>>k;
//ans=k;
FOR(i,n){
cin>>a>>b;
mp[a]+=b;
}
sum+=k;
for(auto it:mp){
if(it.ff<=sum){
k-=(it.ff-prev);
k+=it.ss;
prev=it.ff;
sum+=it.ss;
}
else {
ans=prev+k;
//cout<<sum<<endl;
//cout<<ans;
//return 0;
break;
}
}
ans=prev+k;
cout<<sum;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,x;
long long sum=0;
cin>>n>>x;
for(int i=1;i<=n;i++)
{
int v,p;
cin>>v>>p;
sum+=(v*p);
if(sum>x*100)
{
cout<<i;
break;
}
}
if(sum<=x*100)
cout<<-1;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define f(i,j,n) for(int i = j; i <= n; i++)
#define r(i,n,j) for(int i = n; i >= j; i--)
#define all(container) container.begin() , container.end()
#define sz(container) (int)container.size()
#define T int ttt; cin >> ttt; while(ttt--)
#define fast ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
int32_t main()
{
fast
int n,k,ans=0; cin>>n>>k;
int ff=1e15;
f(i,1,n){
int x,y; cin>>x>>y;
ans+= x*y;
if(ans>k*100){
cout<<i;
exit(0);
}
}
cout<<"-1";
} |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long li;
#define rep(i,n) for(int i=0;i<(n);i++)
#define df 0
template<class T> void print(const T& t){ cout << t << "\n"; }
template<class T, class... Ts> void print(const T& t, const Ts&... ts) { cout << t; if (sizeof...(ts)) cout << " "; print(ts...); }
int main(){
string s; cin >>s;
reverse(s.begin(),s.end());
vector<int> cnt(26,0);
int n=s.size();
int pre=-1,past=-1;
li ans=0;
rep(i,n){
int a=s[i]-'a';
if(pre==a){
ans+=i-cnt[a];
for(int& x:cnt)x=0;
cnt[a]=i+1;
}else cnt[a]++;
pre=a;
}
print(ans);
}
|
#pragma GCC optimize ("-O3")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> p32;
typedef pair<ll,ll> p64;
typedef pair<double,double> pdd;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int> > vv32;
typedef vector<vector<ll> > vv64;
typedef vector<vector<p64> > vvp64;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
ll MOD = 998244353;
#define forn(i,e) for(ll i = 0; i < e; i++)
#define forsn(i,s,e) for(int i = s; i < e; i++)
#define rforn(i,s) for(ll i = s; i >= 0; i--)
#define rforsn(i,s,e) for(ll i = s; i >= e; i--)
#define ln "\n"
#define dbg(x) cout<<#x<<" = "<<x<<ln
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define INF 1e18
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
ll mpow(ll a, ll b){
if(b >= (MOD-1)) b %= (MOD-1);
if(b==0) return 1;
ll t1 = mpow(a,b/2);
t1 *= t1;
t1 %= MOD;
if(b%2) t1 *= a;
t1 %= MOD;
return t1;
}
ll mpow(ll a, ll b, ll p){
if(b==0) return 1;
ll t1 = mpow(a,b/2,p); t1 *= t1;
t1 %= p;
if(b%2) t1 *= a;
t1 %= p;
return t1;
}
ll modinverse(ll a, ll m){
ll m0 = m;
ll y = 0, x = 1;
if (m == 1) return 0;
while (a > 1){
ll q = a / m;
ll t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
ll range(ll l, ll r){
return l + rand()%(r-l+1);
}
int main()
{
ll t=1;
//cin>>t;
while(t--)
{
string s;
cin>>s;
ll ans=0,pp=-1;
char pc = '*';
vector<ll>ps(26,0);
ll n = s.length();
ps[s[n-1]-'a']++;
ps[s[n-2]-'a']++;
for(ll i=s.length()-3;i>=0;i--)
{
ps[s[i]-'a']++;
if(s[i]==s[i+1])
{
ans += s.length()-i-ps[s[i]-'a'];
for(ll j=0;j<26;j++)ps[j]=0;
ps[s[i]-'a'] = n-i;
}
//cout<<ans<<" ";
}
//cout<<endl;
cout<<ans<<endl;
}
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long int lld;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define trav(a,v) for(auto a:v)
#define MOD 998244353
lld DP[10000][10000];
lld calc(int a, int b){
//cout<<a<<" "<<b<<endl;
if(a<0 || b<0 || a<b)return 0;
//out<<a<<" "<<b<<endl;
if(DP[a][b]!=-1)return DP[a][b];
//cout<<a<<" "<<b<<endl;
DP[a][b]=0;
DP[a][b]+=calc(a-1,b-1);
DP[a][b]+=calc(a,2*b);
DP[a][b]%=MOD;
return DP[a][b];
}
/*lld manual(int a, int b){
int cnt=0;
rep(i,0,a+1){
rep(j,0,a+1){
rep(k,0,a+1){
rep(l,0,a+1){
rep(m,0,a+1){
rep(n,0,a+1){
if(i+j+k+l+m+n==a && (i+2*j+4*k+8*l+16*m+32*n)==b*32)cnt++;
}
}
}
}
}
}
return cnt;
}*/
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n,k;
cin>>n>>k;
rep(i,0,n+1){
rep(j,0,n+1){
DP[i][j]=-1;
if(i==0)DP[i][j]=0;
if(j==0)DP[i][j]=0;
}
}
DP[0][0]=1;
cout<<calc(n,k)<<endl;
/*rep(i,0,n+1){
rep(j,0,k+1){
if(manual(i,j)!=calc(i,j))cout<<i<<" "<<j<<" "<<calc(i,j)<<" "<<manual(i,j)<<endl;
}
}*/
return 0;
} | #include<bits/stdc++.h>
#define ll long long
#define dbg(x) cout<<#x<<": "<<x<<endl;
#define N 200005
#define M 1000000007
#define pii pair<ll,ll>
#define fast ios_base::sync_with_stdio(0);cin.tie(0);
using namespace std;
ll bigmod(ll a,ll n)
{
if(n==0)
return 1;
ll ans=bigmod(a,n/2);
ans=(ans*ans)%M;
if(n%2)
ans=(ans*a)%M;
return ans;
}
ll f[20];
ll inv[20];
string s;
ll k;
vector<char>all;
ll C(ll n,ll r)
{
if(n<r)
return 0;
return f[n]*inv[r]%M*inv[n-r]%M;
}
ll dp[N][17][17];
ll run(int idx,int k1,int k2)
{
if(idx==0)
{
return k1==0;
}
if(dp[idx][k1][k2]!=-1)
return dp[idx][k1][k2];
ll ans=0;
if(k1>0)
{
ans+=1LL*k1*run(idx-1,k1-1,k2+1);
ans%=M;
}
if(k2>0)
{
ans+=1LL*k2*run(idx-1,k1,k2);
ans%=M;
}
return dp[idx][k1][k2]=ans;
}
int check(string s)
{
int c=0,f=0;
set<int>w;
for(char p:s)
{
if(f)
{
w.insert(p);
}
else if(p!='0')
{
w.insert(p);
f=1;
}
}
return w.size();
}
main()
{
memset(dp,-1,sizeof dp);
f[0]=inv[0]=1;
for(ll i=1; i<20; i++)
{
f[i]=f[i-1]*i%M;
inv[i]=bigmod(f[i],M-2);
}
for(char x='0'; x<='9'; x++)
all.push_back(x);
for(char x='A'; x<='F'; x++)
all.push_back(x);
cin>>s>>k;
set<char>upto;
ll ans=0;
for(ll i=0; i<s.size(); i++)
{
ll till=upto.size();
for(char u:all)
{
if(u<s[i])
{
if(i==0&&u=='0')
continue;
set<char>temp=upto;
temp.insert(u);
ll already=temp.size();
ll baki=k-already;
if(baki>=0)
{
ll temp=1;
temp*=C(16-already,baki)*run(s.size()-i-1,baki,already);
ans+=temp;
//cout<<i<<' '<<u<<' '<<temp<<endl;
ans%=M;
}
}
}
upto.insert(s[i]);
}
for(ll i=1; i<s.size(); i++)
{
for(char u:all)
{
if(u=='0')
continue;
ll already=1;
ll baki=k-already;
if(baki>=0)
{
ll temp=1;
temp*=C(16-already,baki)*run(s.size()-1-i,baki,already);
ans+=temp;
//cout<<i<<' '<<u<<' '<<temp<<endl;
ans%=M;
}
}
}
if(upto.size()==k) ans++;
ans%=M;
cout<<ans;
}
|
#include <bits/stdc++.h>
long long extGCD(long long a, long long b, long long c, long long &x, long long &y){
long long a_gcd = a;
long long b_gcd = b;
std::vector< long long > A, B;
A.push_back(a_gcd);
B.push_back(b_gcd);
while(b_gcd != 0){
long long tmp = a_gcd % b_gcd;
a_gcd = b_gcd;
b_gcd = tmp;
A.push_back(a_gcd);
B.push_back(b_gcd);
}
if(c % a_gcd != 0){
x = -1e18;
y = -1e18;
return -1;
}
std::vector< long long > X(A.size()), Y(A.size());
X[A.size() - 1] = c / a_gcd;
Y[A.size() - 1] = 0;
for(int i=A.size()-2; i>=0; i--){
X[i] = Y[i+1];
Y[i] = X[i+1] - (A[i] / B[i]) * X[i];
}
x = X[0];
y = Y[0];
b /= a_gcd;
if(x >= 0){
return x % b;
}else{
long long ret;
ret = b - std::abs(x) % b;
if(ret == b){
ret = 0;
}
return ret;
}
}
int main(){
int T;
std::cin >> T;
std::vector< long long > ans(T);
for(int t=0; t<T; t++){
long long X, Y, P, Q;
std::cin >> X >> Y >> P >> Q;
long long min = 9223372036854775807;
for(int p=P; p<P+Q; p++){
for(int x=X; x<X+Y; x++){
long long ret1, ret2;
long long tmp = extGCD(P+Q, 2*(X+Y), x-p, ret1, ret2);
if(tmp != -1){
min = std::min(min, p + (P+Q) * tmp);
}
}
}
ans[t] = min;
}
for(int i=0; i<T; i++){
if(ans[i] == 9223372036854775807){
std::cout << "infinity" << std::endl;
}else{
std::cout << ans[i] << std::endl;
}
}
return 0;
}
| #include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <numeric>
#include <ctime>
#include <complex>
#include <bitset>
#include <random>
#include <climits>
#include <stack>
using namespace std;
typedef long long ll;
typedef long double ld;
#define int ll
#define double ld
#define loop(i, n) for(int i = 0; i < (int)n; ++i)
#define loop1(i, n) for(int i = 1; i <= (int)n; ++i)
#define F first
#define S second
#define pb push_back
#define pi pair <int, int>
#define all(x) begin(x), end(x)
#define ti tuple <int, int, int>
#define Point Vect
#define no {cout << "NO"; return;}
#define yes {cout << "Yes"; return;}
#define mkp make_pair
#define mkt make_tuple
#define cerr if(0) cerr
const int INF = 3e18;
int phi(int n) {
int result = n;
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) {
while (n % i == 0)
n /= i;
result -= result / i;
}
if (n > 1)
result -= result / n;
return result;
}
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int binpow(int x, int d, int mod) {
int ans = 1;
while (d) {
if (d & 1)
ans = ans * x % mod;
x = x * x % mod;
d >>= 1;
}
return ans;
}
int rev_mod(int a, int b, int m) {
int d = gcd(a, m);
if (b % d)
return -1;
a /= d, b /= d, m /= d;
return binpow(a, phi(m) - 1, m) * b % m;
}
void solve() {
int x, y, p, q;
cin >> x >> y >> p >> q;
int ans = INF, m = 2 * (x + y);
for (int r1 = x; r1 < x + y; ++r1) {
int cur = rev_mod(p + q, (r1 - p % m + m) % m, m);
if (cur >= 0)
ans = min(ans, cur * (p + q) + p);
}
for (int r2 = p; r2 < p + q; ++r2) {
int cur = rev_mod(p + q, (x - r2 % m + m) % m, m);
if (cur >= 0)
ans = min(ans, cur * (p + q) + r2);
}
if (ans == INF)
cout << "infinity\n";
else
cout << ans << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t; cin >> t; loop(i, t)
solve();
return 0;
} |
#include<bits/stdc++.h>
#define int long long
#define rint regester int
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
using std::ios;
using std::cin;
using std::cout;
using std::max;
using std::min;
using std::sort;
using std::unique;
using std::lower_bound;
using std::swap;
using std::abs;
using std::acos;
using std::queue;
using std::map;
using std::string;
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, a[maxn], sum, p1;
double minn = 99824435353535.0;
signed main(){
n = read();
for(int i = 1; i <= n; i++)a[i] = read(), sum += a[i];
sort(a + 1, a + 1 + n);
for(int i = 1; i <= n; i++){
double x = 0;
p1 += a[i];
if(2 * i - n > 0){
x = a[i] / 2.0;
}else
x = a[i + 1] / 2.0;
minn = min(minn, (double)(2 * i - n) * x - p1 + sum);
}
printf("%.19lf", (double)minn / n);
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define int long long
#define IOS std::ios::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL);
#define pb push_back
#define mod 1000000007
//#define lld long double
#define mii map<int, int>
#define mci map<char, int>
#define msi map<string, int>
#define pii pair<int, int>
#define ff first
#define ss second
#define bs(yup,x) binary_search(yup.begin(),yup.end(),x) //it will return bollean value
#define lb(yup,x) lower_bound(yup.begin(),yup.end(),x) //it will return the adress of the number which is equal to or just greater than x ,and if it is equal to yup.end() than their in no such number exist
#define ub(yup,x) upper_bound(yup.begin(),yup.end(),x)
#define all(x) (x).begin(), (x).end()
#define rep(i,x,y) for(int i=x; i<y; i++)
#define fill(a,b) memset(a, b, sizeof(a))
#define vi vector<int>
#define setbits(x) __builtin_popcountll(x)
using namespace std;
const long long N=262144, INF=2000000000000000000;
const long double EPS= 0.000000000001;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> order_set;
//order_of_key(x) --> will return number of numbers that are strictly less than x in set
//find_by_order(x) --> will return (x+1)th element in the set
//both are log(n) time
int power(int a, int b, int p)
{
if(a==0)
return 0;
int res=1;
a%=p;
while(b>0)
{
if(b&1)
res=(res*a)%p;
b>>=1;
a=(a*a)%p;
}
return res;
}
vi prime;
bool isprime[N];
void pre()
{
for(int i=2;i<N;i++)
{
if(isprime[i])
{
for(int j=i*i;j<N;j+=i)
isprime[j]=false;
prime.pb(i);
}
}
return;
}
/*
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int getRand(int l, int r)
{
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
*/
int32_t main()
{
IOS;
//fill(isprime, true);
//pre();
int wertt=1;
//cin>>wertt;
for(int pppp=1;pppp<=wertt;pppp++)
{
int n;
cin>>n;
long double a[n];
for(int i=0;i<n;i++) cin>>a[i];
sort(a,a+n);
long double x=(a[n/2]/2.0);
long double ans=0;
for(int i=0;i<n;i++)
{
ans+=(x+a[i]-min(x+x,a[i]));
}
ans=ans/((long double)(n));
cout<<fixed << setprecision(15)<<ans;
}
}
|
#define IOS ios::sync_with_stdio(false);
#define rep(i, a, n) for(ll i=a;i<=n;i++)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define endl "\n"
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
ll n, m, t, k, ans, cnt, sum, flag;
ll arr[N], vis[N];
char s[20][20];
int main() {
IOS;
cin >> n >> m;
rep(i, 0, n-1) cin>>s[i];
rep(i,0,n-2){
rep(j,0,m-2){
cnt=0;
if(s[i][j]=='.') cnt++;
if(s[i+1][j]=='.') cnt++;
if(s[i][j+1]=='.') cnt++;
if(s[i+1][j+1]=='.') cnt++;
if(cnt==1||cnt==3) ans++;
}
}
cout<<ans<<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>
#include <climits>
#include <cstring>
#include <cassert>
using namespace std;
//using namespace atcoder;
#define REP(i, n) for (int i=0; i<(n); ++i)
#define RREP(i, n) for (int i=(int)(n)-1; i>=0; --i)
#define FOR(i, a, n) for (int i=(a); i<(n); ++i)
#define RFOR(i, a, n) for (int i=(int)(n)-1; i>=(a); --i)
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(),(x).end()
#define DUMP(x) cerr<<#x<<" = "<<(x)<<endl
#define DEBUG(x) cerr<<#x<<" = "<<(x)<<" (L"<<__LINE__<<")"<<endl;
template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
REP(i, SZ(v)) {
if (i) os << ", ";
os << v[i];
}
return os << "]";
}
template<class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << " " << p.second << ")";
}
template<class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template<class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvll = vector<vll>;
const ll MOD = 1e9 + 7;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
const ld eps = 1e-9;
// edit
void solve() {
int H, W;
cin >> H >> W;
vector<vector<char>> S(H + 2, vector<char>(W + 2, '.'));
REP(i, H) {
REP(j, W) {
cin >> S[i + 1][j + 1];
}
}
int ans = 0;
for (int i = 0; i <= H; ++i) {
for (int j = 0; j <= W; ++j) {
int cnt = 0;
for (int di = 0; di <= 1; ++di) {
for (int dj = 0; dj <= 1; ++dj) {
if (S[i + di][j + dj] == '#') cnt++;
}
}
if (cnt % 2) {
ans++;
}
// cerr << i << " " << j << " " << cnt << endl;
}
}
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
solve();
return 0;
}
|
//To debug : g++ -g file.cpp -o code
//to flush output : fflush(stdout) or cout.flush()
//cout<<setprecision(p)<<fixed<<var
//use 1LL<<i to for 64 bit shifting , (ll)2 because by default 2 is ll
//take care of precedence rule of operators
//do not forget to change the sizes of arrays and value of contants and other things after debugging
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,a,n) for(i=a;i<n;++i)
#define irep(i,n,a) for(i=n;i>a;--i)
#define mod 1000000007
#define pb push_back
#define big 9223372036854775807
#define big1 LONG_MAX
#define big2 ll_MAX
#define big3 1000000000
#define sma1 LONG_MIN
#define sma2 ll_MIN
#define sma3 -1000000000
#define mp make_pair
#define dub double
#define ivec vector<ll>
#define lvec vector<long long>
#define cvec vector<char>
#define svec vector<string>
#define mt make_tuple
#define MOD 998244353
#define ld long double
#define pi acos(-1.0)
#define SZ(x) (ll)(x.size())
//comment the below if not required
/*
#define ss second.second
#define ff first.first
#define f first
#define s second
#define sf second.first
#define fs first.second
*/
#define IOS std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
//cout<<"Case #"<<c<<": "<<ans<<"\n" ;
ll n,N,ans,i,val,ind1,ind2,val1,val2;
int main()
{
IOS;
cin>>n;
N = 1<<n;
ll a[N];
for(i=1;i<=N;++i)
cin>>a[i];
for(i=1;i<=(N/2);++i)
{
if(a[i]>val1)
{
val1 = a[i];
ind1 = i;
}
if(a[i+N/2]>val2)
{
val2 = a[i+N/2];
ind2 = i+N/2;
}
}
if(val1>val2)
cout<<ind2<<"\n";
else
cout<<ind1<<"\n";
return 0;
} | //
// Created by Bottomline2sky on 1/10/2021.
//
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll result(vector<pair<ll,ll>>&p){
if((ll)p.size() == 2){
if(p[0].first>p[1].first){
return p[1].second;
}
else{
return p[0].second;
}
}
else{
vector<pair<ll,ll>> q;
for(ll i=0;i<p.size();i=i+2){
// cout<<p[i].first<<" "<<p[i+1].first<<" ";
if(p[i].first>p[i+1].first){
q.push_back(p[i]);
}
else{
q.push_back(p[i+1]);
}
}
return result(q);
}
}
int main(){
int n;
cin>>n;
vector<pair<ll,ll>> arr;
for(ll i=0;i<pow(2,n);i++){
ll q;
cin>>q;
arr.push_back(make_pair(q,i+1));
}
ll coffn = result(arr);
cout<<coffn<<endl;
} |
#include <bits/stdc++.h>
//#include "atcoder/all"
using namespace std;
using ll = long long;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
using pii = pair<int, int>;
const ll mod = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<vector<ll>> dp(65, vector<ll>(2));
dp[0][0] = 1;
dp[0][1] = 1;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s == "OR") {
dp[i + 1][0] = dp[i][0];
dp[i + 1][1] = dp[i][0] + 2 * dp[i][1];
} else {
dp[i + 1][0] = dp[i][0] * 2 + dp[i][1];
dp[i + 1][1] = dp[i][1];
}
}
cout << dp[n][1] << endl;
} | /* Author : Kaustubh Gangwar
Institute : IIITA */
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define gcd __gcd
#define vi vector<int>
#define vll vector<long long>
#define all(x) (x).begin(), (x).end()
#define f(i, a, b) for (int i = a; i < b; i++)
#define fe(i, a, b) for (int i = a; i <= b; i++)
#define sz(x) (int)((x).size())
#define CODING ios_base::sync_with_stdio(false);
#define SAMRAT cin.tie(0), cout.tie(0);
#define mll map<ll, ll>
#define nl '\n'
#define lb lower_bound
#define ub upper_bound
typedef long long ll;
typedef pair<ll, ll> pll;
ll bpow(ll a, ll b)
{
a = a;
ll ans = 1;
while (b)
{
if (b & 1)
ans = ans * a;
a = a * a;
b >>= 1;
}
return ans;
}
int32_t main()
{
CODING SAMRAT
int test = 1;
//cin >> test;
while (test--)
{
ll n;
cin>>n;
ll ans[n+5]={0};
f(i,1,n+4)
{
ll temp=i;
int flag=0;
while(temp)
{ if(temp%10==7)
flag=1;
temp=temp/10;
}
temp=i;
while(temp)
{ if(temp%8==7)
flag=1;
temp=temp/8;
}
if(flag)
{
ans[i]=ans[i-1];
}
else
ans[i]=ans[i-1]+1;
}
cout<<ans[n];
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<ll> a(n), b(n);
for (auto &e : a) cin >> e;
for (auto &e : b) cin >> e;
for (int i = 0; i + 1 < n; i++) a[i + 1] = max(a[i + 1], a[i]);
ll r = 0;
for (int i = 0; i < n; i++) cout << (r = max(r, a[i] * b[i])) << endl;
}
| #pragma GCC optimize(2)
#pragma GCC optimize(3)
#include <bits/stdc++.h>
using namespace std;
#define IO std::ios::sync_with_stdio(false); cin.tie(0)
#define ll long long
#define ull unsigned long long
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, l, r) for (int i = l; i >= r; i--)
#define mset(s, _) memset(s, _, sizeof(s))
#define pb push_back
#define pii pair <int, int>
#define mp(a, b) make_pair(a, b)
#define debug(x) cerr << #x << " = " << x << '\n';
#define pll pair <ll, ll>
#define fir first
#define sec second
#define INF 0x3f3f3f3f
#define int ll
inline int read() {
int x = 0, neg = 1; char op = getchar();
while (!isdigit(op)) { if (op == '-') neg = -1; op = getchar(); }
while (isdigit(op)) { x = 10 * x + op - '0'; op = getchar(); }
return neg * x;
}
inline void print(int x) {
if (x < 0) { putchar('-'); x = -x; }
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
const int maxn = 2e5 + 10;
int n,a[maxn],b[maxn],c[maxn];
signed main() {
IO;
cin >> n;
rep(i,1,n) cin >> a[i];
rep(i,1,n) cin >> b[i];
int mx = 0;
rep(i,1,n){
mx = max(mx,a[i]);
c[i] = max(c[i-1],b[i] * mx);
}
rep(i,1,n) cout << c[i] << '\n';
return 0;
} |
#include <iostream>
#include <chrono>
#include <string>
#include <vector>
#include <algorithm>
class DNA {
private:
char base[20][20];
public:
void inputV(const int& i, const int& j, const std::string& s) {
for (int k = 0; k < (int)s.size(); k++) {
if (i + k < 20) base[i + k][j] = s[k];
else base[i + k - 20][j] = s[k];
}
}
void inputH(const int& i, const int& j, const std::string& s) {
for (int k = 0; k < (int)s.size(); k++) {
if (j + k < 20) base[i][j + k] = s[k];
else base[i][j + k - 20] = s[k];
}
}
void output() {
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 20; j++) {
std::cout << base[i][j];
}
std::cout << std::endl;
}
}
//constructor
DNA() {
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 20; j++) {
base[i][j] = '.';
}
}
}
};
int main() {
DNA alien;
int m;
std::cin >> m >> m;
std::vector<std::pair<int, std::string>> sequences(m, { 0, "" });
for (int i = 0; i < m; i++) {
std::cin >> sequences[i].second;
sequences[i].first = (int)sequences[i].second.size();
}
sort(sequences.begin(), sequences.end());
int now = 0;;
int k = 0;
while(now < 20) {
for (int i = 0; i < 20; i++) {
alien.inputH(i, now + 1, sequences[i].second);
}
k++;
now += sequences[k * 20 - 1].first;
}
alien.output();
return 0;
}
| #include <stdio.h>
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <random>
#include <fstream>
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 n,m;
std::string s[888];
char ans[22][22][22];
bool nochange[22][22][22],already[22][888];
void check(int t){
int i,j,k,l;
bool flag;
for(k=0; k<m; ++k){
if(already[t][k]){
continue;
}
for(i=0; i<n; ++i){
for(j=0; j<n; ++j){
flag = true;
for(l=0; l<s[k].l_ength(); ++l){
if(ans[t][i][(j+l)%n] != s[k][l]){
flag = false;
break;
}
}
if(flag){
already[t][k] = true;
for(l=0; l<s[k].l_ength(); ++l){
nochange[t][i][(j+l)%n] = true;
}
break;
}
flag = true;
for(l=0; l<s[k].l_ength(); ++l){
if(ans[t][(i+l)%n][j] != s[k][l]){
flag = false;
break;
}
}
if(flag){
already[t][k] = true;
for(l=0; l<s[k].l_ength(); ++l){
nochange[t][(i+l)%n][j] = true;
break;
}
break;
}
}
if(already[t][k]){
break;
}
}
}
}
int main(void){
int i,j,c[22],k,t,score=0;
std::random_device seed_gen;
std::default_random_engine engine(seed_gen());
std::uniform_int_distribution<> rnd('A','H');
std::cin >> n >> m;
for(i=0; i<m; ++i){
std::cin >> s[i];
}
for(t=0; t<20; ++t){
for(k=0; k<40; ++k){
for(i=0; i<n; ++i){
for(j=0; j<n; ++j){
if(!nochange[t][i][j]){
ans[t][i][j] = rnd(engine);
}
}
}
check(t);
}
c[t] = 0;
for(i=0; i<m; ++i){
if(already[i]){
++c[t];
}
}
score = std::max(score,c[t]);
}
for(t=0; t<20; ++t){
if(score < c[t]){
continue;
}
for(i=0; i<n; ++i){
for(j=0; j<n; ++j){
std::cout << ans[t][i][j];
}
std::cout << std::endl;
}
break;
}
return 0;
}
|
#include <bits/stdc++.h>
#include <string>
//#include <boost/multiprecision/cpp_int.hpp>
#define FAST ios_base::sync_with_stdio(false); cin.tie(NULL);
#define ll long long
#define fp cout<<fixed<<setprecision(9);
#define ifor(j,n) for(int i=j ;i<n;i++)
#define jfor(k,n) for(ll j=k ;j<n;j++)
#define pb push_back
#define mod 1000000007
#define all(x) x.begin(),x.end()
using namespace std;
//using namespace boost::multiprecision;
//Compiler version g++ 6.3.0
int search (vector <long long> v,long long m,int n)
{
int start = 0;
int ans = -1;
while (start <=n)
{
int mid = (start + n) / 2;
if (v[mid] <= m)
start = mid + 1;
else
{
ans = mid;
n = mid - 1;
}
}
return ans;
}
int main()
{
FAST
int t=1;
//in>>t;
while(t--)
{
int n,k,b;
cin>>n>>k>>b;
cout<<n-k+b;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int N,A,B;
cin >> N >> A >> B;
cout << N - A + B << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll unsigned long long
#define pb push_back
map<string, bool> visited;
vector<vector<string>> adj;
/*void dfs(string s, ll &k)
{
visited[s] = 1;
ll len = adj[a].size();
for (int i = 0; i < len; i++)
{
if (!visited[adj[a][i]])
{
k++;
dfs(adj[a][i], k);
}
}
}*/
int main()
{
ll n, k;
cin >> n >> k;
map<ll, ll> m;
vector<pair<ll, ll>> v;
priority_queue<ll, vector<ll>, std::greater<ll>> q;
ll x, y;
for (int i = 0; i < n; i++)
{
cin >> x >> y;
if (m[x] != 0)
m[x] += y;
else
{
m[x] = y;
q.push(x);
}
}
ll pos = 0;
k += m[0];
while (k > 0){
pos += k;
k=0;
while(!q.empty()&&q.top() <= pos){
k += m[q.top()];
q.pop();
}
}
cout << pos << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
using ll = long long;
const int INF = 1001001001;
const ll LINF = 1002003004005006007ll;
vector<int> G[2000];
void solve(){
int n,m;cin >> n >> m;
int a,b;
rep(i,m){
cin >> a >> b;
a--;b--;
G[a].push_back(b);
}
ll cnt = 0;
queue<int> Q;
rep(i,n){
Q.push(i);
vector<bool> memo(n,0);
memo[i] = 1;
while(!Q.empty()){
auto p = Q.front();Q.pop();cnt++;
rep(j,G[p].size()){
if(memo[G[p][j]]==0){
memo[G[p][j]] = 1;
Q.push(G[p][j]);
}
}
}
}
cout << cnt << endl;
return;
}
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(16);
solve();
return 0;
} |
# pragma GCC optimize ("O3")
# pragma GCC optimize ("Ofast")
# pragma GCC optimize ("unroll-loops")
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#define rep(i,a,b) for(int i = (a); i < (b); i++)
#define rep2(i,a,b) for(int i = (b) - 1; i >= (a); i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define pb push_back
#define x first
#define y second
using namespace std;
using ll = long long;
using tl = tuple<ll, ll, ll, ll>;
using pl = pair<ll, ll>;
using pi = pair<int, int>;
using ld = long double;
const int MOD = 998244353;
template<class T> struct mi {
T val;
mi() { val = 0; }
mi(const ll& v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0) val += MOD;
}
mi operator + (const mi& m) {
T tmp = (val + m.val) % MOD;
return tmp + (tmp < 0 ? MOD : 0);
}
mi operator - (const mi& m) {
T tmp = (val - m.val) % MOD;
return tmp + (tmp < 0 ? MOD : 0);
}
mi operator * (const mi& m) {
T tmp = (val * m.val) % MOD;
return tmp;
}
mi& operator += (const mi& m) {
if ((val += m.val) >= MOD) val -= MOD;
return *this;
}
mi& operator -= (const mi& m) {
if ((val -= m.val) < 0) val += MOD;
return *this;
}
mi& operator *= (const mi& m) {
val = (val * m.val) % MOD;
return *this;
}
};
ll N, M;
mi<ll> ans, mpow[5001][5001];
int main() {
cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(false);
cin >> N >> M;
rep(i, 0, M + 1) mpow[i][0] = 1;
rep(i, 0, M + 1) rep(j, 1, N + 1) mpow[i][j] = mpow[i][j - 1] * i;
ans = mpow[M][N] * N;
rep(s, 1, N){
mi<ll> tmp(0);
rep(x, 1, M + 1) tmp += mpow[M - x][s - 1];
ans -= tmp * mpow[M][N - s - 1] * (N - s);
}
cout << ans.val << endl;
}
| #include "bits/stdc++.h"
#define int long long
#define endl '\n'
using namespace std;
typedef long long ll;
typedef long double ld;
#define db(x) cerr << #x << ": " << x << '\n';
#define read(a) int a; cin >> a;
#define reads(s) string s; cin >> s;
#define readb(a, b) int a, b; cin >> a >> b;
#define readc(a, b, c) int a, b, c; cin >> a >> b >> c;
#define readarr(a, n) int a[(n) + 1] = {}; FOR(i, 1, (n)) {cin >> a[i];}
#define readmat(a, n, m) int a[n + 1][m + 1] = {}; FOR(i, 1, n) {FOR(j, 1, m) cin >> a[i][j];}
#define print(a) cout << a << endl;
#define printarr(a, n) FOR (i, 1, n) cout << a[i] << " "; cout << endl;
#define printv(v) for (int i: v) cout << i << " "; cout << endl;
#define printmat(a, n, m) FOR (i, 1, n) {FOR (j, 1, m) cout << a[i][j] << " "; cout << endl;}
#define all(v) v.begin(), v.end()
#define sz(v) (int)(v.size())
#define rz(v, n) v.resize((n) + 1);
#define pb push_back
#define fi first
#define se second
#define vi vector <int>
#define pi pair <int, int>
#define vpi vector <pi>
#define vvi vector <vi>
#define setprec cout << fixed << showpoint << setprecision(20);
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORD(i, a, b) for (int i = (a); i >= (b); i--)
const ll inf = 1e18;
const ll mod = 998244353;
const ll N = 2e5 + 1;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int power (int a, int b = mod - 2)
{
int res = 1;
while (b > 0) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
readb(n, m);
int one[n + 1][m + 1] = {}, zer[n + 1][m + 1] = {};
int onesum[n + 1][m + 1] = {}, zersum[n + 1][m + 1] = {};
int precalc[m + 1][n + 1] = {};
FOR (i, 1, m) precalc[i][0] = 1;
FOR (i, 1, m)
FOR (j, 1, n)
precalc[i][j] = i*precalc[i][j - 1] % mod;
FOR (i, 1, n)
FOR (j, 1, m)
{
one[i][j] = (one[i][j - 1] + onesum[i - 1][j - 1] + zersum[i - 1][j - 1] + precalc[j][i] - precalc[j - 1][i]) % mod;
zer[i][j] = (one[i][j] + onesum[i - 1][j] + zersum[i - 1][j]) % mod;
onesum[i][j] = (onesum[i - 1][j]*(j + 1) + one[i][j]) % mod;
zersum[i][j] = (zersum[i - 1][j]*j + zer[i][j]) % mod;
}
print((one[n][m] + 5*mod) % mod);
}
|
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int T, n;
string s1, s2, s3;
int main()
{
std::ios::sync_with_stdio(0);
cin >> T;
while (T--) {
cin >> n;
cin >> s1 >> s2 >> s3;
for (int i = 1; i <= n; i++) cout << '0';
for (int i = 1; i <= n; i++) cout << '1';
cout << "0\n";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll,ll>
#define FOR(I,A,B) for(ll I = ll(A); I < ll(B); ++I)
#define FORR(I,A,B) for(ll I = ll((B)-1); I >= ll(A); --I)
#define TO(x,t,f) ((x)?(t):(f))
#define SORT(x) (sort(x.begin(),x.end())) // 0 2 2 3 4 5 8 9
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin()) //xi>=v x is sorted
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin()) //xi>v x is sorted
#define NUM(x,v) (POSU(x,v)-POSL(x,v)) //x is sorted
#define REV(x) (reverse(x.begin(),x.end())) //reverse
ll gcd_(ll a,ll b){if(a%b==0)return b;return gcd_(b,a%b);}
ll lcm_(ll a,ll b){ll c=gcd_(a,b);return ((a/c)*b);}
#define NEXTP(x) next_permutation(x.begin(),x.end())
const ll INF=ll(1e16)+ll(7);
const ll MOD=1000000007LL;
#define out(a) cout<<fixed<<setprecision((a))
//tie(a,b,c) = make_tuple(10,9,87);
#define pop_(a) __builtin_popcount((a))
ll keta(ll a){ll r=0;while(a){a/=10;r++;}return r;}
#define num_l(a,v) POSL(a,v) //v未満の要素数
#define num_eql(a,v) POSU(a,v) //v以下の要素数
#define num_h(a,v) (a.size() - POSU(a,v)) //vより大きい要素数
#define num_eqh(a,v) (a.size() - POSL(a,v)) //v以上の要素数
// static_cast< long long ll >
int N = 30*30;
int L = 30;
// (i,j) i個下 , j個右
int ind(int a,int b){
return a*L + b;
}
//vector< vector<string> > S(N,vector<string>(N));
vector<vector<long double>> H(L,vector<long double>(L,5000.0));
vector<vector<long double>> V(L,vector<long double>(L,5000.0));
// 上は下より(i,j)のiが小さい 右は左より(i,j)のjが大きい
// 順路正の向きで
const int From_U = 0;//上から来た
const int From_D = 1;//下から来た
const int From_L = 2;//左から来た
const int From_R = 3;//右から来た
// 復元
string make_char = "DURL";
const int dy[] = {-1,1,0,0};
const int dx[] = {0,0,-1,1};
int main(){
int sy,sx,ty,tx;
int s,t;
FOR(k,0,1000){
cin >> sy >> sx >> ty >> tx;
int dir_y = 1;
int dir_x = 1;
if(sy > ty) dir_y = -1;
if(sx > tx) dir_x = -1;
// (i,j) には (i - dir_y , j) or (i , j - dir_x) から行く
vector< vector<long double> > score(L,vector<long double>(L,INF));
vector< vector<int> > from(L,vector<int>(L,-1));
score[sy][sx] = 0;
for(int y=sy;(y-dir_y)!=ty;y+=dir_y){
for(int x=sx;(x-dir_x)!=tx;x+=dir_x){
//cout << y << " " << x << endl;
if(y==sy && x==sx) continue;
long double a = INF,b = INF;
if(y != sy) a = score[y-dir_y][x] + H[min(y-dir_y,y)][x];
if(x != sx) b = score[y][x-dir_x] + V[y][min(x,x-dir_x)];
if(a < b){
from[y][x] = (dir_y == 1 ? From_U : From_D );
score[y][x] = a;
}else{
from[y][x] = (dir_x == 1 ? From_L : From_R );
score[y][x] = b;
}
}
}
//return 0;
//cout << "95" << endl;
string T;
int y=ty,x=tx;
while(y!=sy || x!=sx){
int a = from[y][x];
T += make_char[a];
assert(0 <= a && a <= 3);
y += dy[a];
x += dx[a];
//cout << "from[" << y << "][" << x << "] = " << a << endl;
}
//cout << "106" << endl;
//cout << T << endl;
REV(T);
/*{ // チェック
assert(T.size() == (abs(sy-ty)+abs(sx-tx)));
int ud=0,lr=0;
for(auto c:T){
if(c == 'U' || c == 'D') ud++;
if(c == 'L' || c == 'R') lr++;
}
assert(abs(sy-ty) == ud);
assert(abs(sx-tx) == lr);
}*/
cout << T << endl;
cout << flush;
long double score_now,r;
cin >> score_now;
r = pow( score_now / score[ty][tx] , 1.0 - 1.0*(abs(sy-ty) + abs(sx-tx)) / 115.0 );
y=ty,x=tx;
while(y!=sy || x!=sx){
int a = from[y][x];
int by = y + dy[a],bx = x + dx[a];
if(by != y){
H[min(by,y)][x] *= r;
}else{
V[y][min(bx,x)] *= r;
}
y += dy[a];
x += dx[a];
}
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.