text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
#define fast_io {ios::sync_with_stdio(0); cin.tie(0);}
#define all(v) v.begin(),v.end()
#define pb push_back
#define pf push_front
#define bs binary_search
#define popb pop_back
#define F first
#define S second
#define ccc cout<<1<<" ";
#define prin(v) {forn(i,v.size()) cout<<v[i]<<" "; cout<<endl;}
#define forn(i,n) for(int i=0;i<(n);i++)
#define len() length()
typedef long long ll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<bool> vbool;
typedef vector<double> vdouble;
typedef pair<double,double> pdd;
typedef pair<bool,bool> pbb;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int INF = INT_MAX;
const ll MOD = 1e9+7;
const ll MOD_2 = 998244353;
int N = 1e5 + 10;
ll binpow(ll a, ll y)
{
ll res = 1;
while(y > 0)
{
if(y & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
y /= 2;
}
return res;
}
int main()
{
ll n; cin >> n;
vll a(n);
ll s = 0;
forn(i,n){
cin >> a[i];
s += a[i];
}
if(s % n > 0){
cout << 0;
return 0;
}
vll fact(N);
fact[0] = 1;
for(ll i = 1; i < N; i++)
{
fact[i] = (fact[i-1] * i) % MOD;
}
map < ll, ll > mp;
ll mn = 0, sr = 0, mx = 0;
forn(i,n)
{
if(a[i] < s / n) mn++;
if(a[i] > s / n) mx++;
if(a[i] == s / n) sr++;
mp[a[i]]++;
}
ll d = 1;
for(auto u : mp)
{
d = (d * fact[u.S]) % MOD;
}
ll ans = (fact[mn] * fact[mx]) % MOD;
if(mn <= 1 || mx <= 1)
{
ans = fact[n];
ans = (ans * binpow(d, MOD - 2)) % MOD;
cout << ans;
return 0;
}
ll z = (fact[sr] * fact[n - sr]) % MOD;
ll C = (fact[n] * binpow(z, MOD - 2)) % MOD;
ans = (ans * C) % MOD;
ans = (ans * fact[sr]) % MOD;
ans = (ans * binpow(d, MOD - 2)) % MOD;
ans = (ans * 2) % MOD;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n,cnt;
map<int,int> mp;
long long jie[100010],a[100010];
long long mod=1e9+7;
long long ksm(long long x,long long y)
{
long long res=1;
while(y)
{
if(y&1)
res=res*x%mod;
x=x*x%mod;
y>>=1;
}
return res;
}
int main()
{
scanf("%d",&n);
long long s=0;
for(int i=1;i<=n;++i)
{
scanf("%lld",&a[i]);
mp[a[i]]++;
s+=a[i];
}
if(s%n!=0)
{
printf("0\n");
return 0;
}
if(n==1)
{
printf("1\n");
return 0;
}
long long num=0,shu=0;
for(int i=1;i<=n;++i)
{
if(a[i]>s/n)
++num;
if(a[i]==s/n)
++shu;
}
long long ans=1;
jie[0]=1;
for(long long i=1;i<=n+1;++i)
jie[i]=jie[i-1]*i%mod;
if(num<=1||n-num-shu<=1)
{
ans=jie[n];
for(int i=1;i<=n;++i)
{
if(mp[a[i]])
{
ans=ans*ksm(jie[mp[a[i]]],mod-2)%mod;
mp[a[i]]=0;
}
}
printf("%lld\n",ans);
return 0;
}
/* if()
{
printf("%d\n",n);
return 0;
}*/
if(num==0)
{
printf("1\n");
return 0;
}
ans=jie[num]*jie[n-num-shu]%mod*2%mod;
for(int i=1;i<=n;++i)
{
if(mp[a[i]]&&a[i]!=s/n)
{
// cout<<a[i]<<" "<<mp[a[i]]<<" "<<ksm(mp[a[i]],mod-2)<<endl;
ans=ans*ksm(jie[mp[a[i]]],mod-2)%mod;
mp[a[i]]=0;
}
}
// cout<<1<<endl;
// cout<<ans<<" "<<shu<<endl;
ans=ans*jie[n]%mod*ksm(jie[shu],mod-2)%mod*ksm(jie[n-shu],mod-2)%mod;
printf("%lld\n",ans);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
int mul (int a, int b) {
return a * 1LL * b % mod;
}
int add (int a, int b) {
return a + 0LL + b % mod;
}
int main (){
#ifndef ONLINE_JUDGE
freopen("SuhaibSawalha1","r",stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int N = 1e5;
int fact[N + 1], factInv[N + 1];
fact[0] = 1;
for (int i = 1; i <= N; ++i) {
fact[i] = mul(fact[i - 1], i);
}
factInv[N] = 1;
int p = mod - 2, v = fact[N];
while (p) {
if (p & 1) {
factInv[N] = mul(factInv[N], v);
}
p /= 2;
v = mul(v, v);
}
for (int i = N - 1; ~i; --i) {
factInv[i] = mul(factInv[i + 1], i + 1);
}
int n;
cin >> n;
int a[n];
map<int, int> freq;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++freq[a[i]];
}
long long sum = accumulate(a, a + n, 0LL);
if (sum % n) {
cout << 0;
return 0;
}
int val = sum / n;
int src = 0, snk = 0, done = 0;
for (int i = 0; i < n; ++i) {
++(a[i] > val ? src : a[i] < val ? snk : done);
}
if (src <= 1 || snk <= 1) {
for (auto &e : freq) {
fact[n] = mul(fact[n], factInv[e.second]);
}
cout << fact[n];
return 0;
}
int ans = mul(2, mul(fact[src], fact[snk]));
for (auto &e : freq) {
if (e.first != val) {
ans = mul(ans, factInv[e.second]);
}
}
cout << mul(ans, mul(fact[n], mul(factInv[done], factInv[n - done])));
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const double esp = 1e-2;
typedef long long ll;
const ll mod = 1e9 + 7;
const int N = 1e5 + 4;
ll fac[N],inv[N];
ll qpow(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans*a)%mod;
a = (a * a) % mod;
n >>= 1;
}
return ans;
}
void init() {
fac[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = fac[i - 1] * i % mod;
}
inv[N - 1] = qpow(fac[N - 1], mod-2);
for (ll i = N-2; i >=0; i--) {
inv[i] = inv[i + 1] * (i+1) % mod;
}
}
int main() {
ios::sync_with_stdio(false);
init();
ll n;
cin >> n;
vector<ll> a(n);
ll sum(0);
for(auto & x:a) {
cin >> x;
sum += x;
}
if (sum % n) {
cout << 0<<endl;
return 0;
}
else {
sum /= n;
}
int low(0), up(0),eq(0);
map<ll, ll> LOW, UP,EQ;
for (auto& x : a) {
if (x > sum) {
UP[x]++;
up++;
}
else if (x < sum) {
low++;
LOW[x]++;
}
else {
eq++;
EQ[x]++;
}
}
if (min(low, up) == 0) {
cout << 1 << endl;
}
else if (min(low, up) == 1) {
ll ans = fac[n];
for (auto& x : UP) {
ans *= inv[x.second];
ans %= mod;
}
for (auto& x : LOW) {
ans *= inv[x.second];
ans %= mod;
}
for (auto& x : EQ) {
ans *= inv[x.second];
ans %= mod;
}
cout << ans<< endl;
}
else {
ll ans = 2 * (fac[low] * fac[up] % mod) % mod ;
ll total = low + up;
for (ll i = total + 1; i <= n; i++) {
ans *= i;
ans %= mod;
}
for (auto& x : UP) {
ans *= inv[x.second];
ans %= mod;
}
for (auto& x : LOW) {
ans *= inv[x.second];
ans %= mod;
}
for (auto& x : EQ) {
ans *= inv[x.second];
ans %= mod;
}
cout << ans << endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 1e5 + 5;
const ll mod = 1e9 + 7;
int n;
int a[maxn];
map<int,int> cnt;
ll fac[maxn];
ll mul(ll x, ll y) {
return ((x * y) % mod + mod) % mod;
}
ll inv(ll x, ll y) {
return 1 < x ? y - inv(y % x, x) * y / x : 1;
}
int main() {
scanf("%d", &n);
for(int i=1;i<=n;i++) scanf("%d", &a[i]);
ll sum = 0;
for(int i=1;i<=n;i++) sum += a[i];
if(sum % n != 0) return !printf("0");
int jabb = sum / n;
int sink = 0, source = 0;
for(int i=1;i<=n;i++) cnt[a[i]]++;
for(auto t : cnt) {
int x = t.first, num = t.second;
if(x < jabb) sink += num;
if(x > jabb) source += num;
}
fac[0] = 1;
for(int i=1;i<=n;i++) fac[i] = mul(fac[i-1], i);
ll ans = 1;
if(source <= 1 || sink <= 1) {
ans = fac[n];
for(auto t : cnt) ans = mul(ans, inv(fac[t.second], mod));
printf("%lld\n",ans);
}
else {
ans = mul(2, mul(fac[sink], fac[source]));
for(auto t : cnt) if(t.first != jabb) ans = mul(ans, inv(fac[t.second], mod));
ans = mul(ans, fac[n]);
ans = mul(ans, inv(fac[source + sink], mod));
ans = mul(ans, inv(fac[n - source - sink], mod));
printf("%lld\n",ans);
}
} |
// author: erray
#include <bits/stdc++.h>
using namespace std;
// modular template by tourist
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a; swap(a, m);
u -= t * v; swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
else v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const { return static_cast<U>(value); }
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) { Modular result(*this); *this += 1; return result; }
Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
asm(
"divl %4; \n\t"
: "=a" (d), "=d" (m)
: "d" (xh), "a" (xl), "r" (mod())
);
value = m;
#else
value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type& operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }
template <typename U>
friend const Modular<U>& abs(const Modular<U>& v) { return v; }
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }
template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }
template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
/*
using ModType = int;
struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& md = VarMod::value;
using Mint = Modular<VarMod>;
*/
constexpr int md = (int) 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
vector<Mint> fac(1, 1), inv_fac(1, 1);
void fill_fac(int n) {
while ((int) fac.size() <= n) {
fac.push_back(fac.back() * (int) fac.size());
inv_fac.push_back(1 / fac.back());
}
}
Mint fact(int x) {
assert(x >= 0);
fill_fac(x);
return fac[x];
}
Mint C(int x, int y) {
if (x < 0 || y > x) {
return 0;
}
assert(y >= 0);
fill_fac(x);
return fac[x] * inv_fac[y] * inv_fac[x - y];
}
Mint P(int x, int y) {
if (x < 0 || y > x) {
return 0;
}
assert(y >= 0);
fill_fac(x);
return fac[x] * inv_fac[x - y];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long sum = accumulate(a.begin(), a.end(), 0LL);
if (sum % n != 0) {
return cout << 0, 0;
}
int mid = sum / n;
array<vector<int>, 3> ct;
for (auto e : a) {
ct[(e > mid ? 0 : e < mid ? 1 : 2)].push_back(e);
}
auto Per = [&](vector<int> x) {
Mint res = fact((int) x.size());
map<int, int> cct;
for (auto e : x) {
++cct[e];
}
for (auto[foo, c] : cct) {
res /= fact(c);
}
return res;
};
if (ct[0].size() <= 1 || ct[1].size() <= 1) {
cout << Per(a) << '\n';
} else {
Mint ans = Per(ct[0]) * Per(ct[1]);
ans *= C(n, ct[2].size());
cout << ans * 2 << '\n';
}
} |
#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<vector>
#include<cstring>
#include<map>
#include<set>
#include<cstdlib>
#include<bitset>
using namespace std;
#define FAST ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
typedef long long ll;
ll n,mod=1e9+7;
ll a[100005];
ll fac[100005]={0};
ll qpow(ll a,ll b)
{
if(b==0) return 1;
ll c=qpow(a,b/2);
if(b%2==0) return c*c%mod;
else return c*c%mod*a%mod;
}
int main(void)
{
scanf("%lld",&n);
for(ll i=1;i<=n;i++) scanf("%lld",&a[i]);
fac[0]=1;
for(ll i=1;i<=n;i++) fac[i]=fac[i-1]*i%mod;
ll ans=0;
map<ll,ll> mp;
for(ll i=1;i<=n;i++) ans+=a[i],mp[a[i]]++;
if(ans%n!=0)
{
printf("0");
return 0;
}
ll ok=ans/n;
ans=1;
ll cn1=0,cn2=0;
for(ll i=1;i<=n;i++)
{
if(a[i]<ok) cn1++;
if(a[i]>ok) cn2++;
}
if(cn1<=1||cn2<=1)
{
for(auto x:mp)
{
ans=ans*fac[x.second]%mod;
}
ans=fac[n]*qpow(ans,mod-2)%mod;
}
else
{
ans=2*fac[cn1]%mod*fac[cn2]%mod;
ans=ans*fac[n]%mod*qpow(fac[cn1+cn2]*fac[n-cn1-cn2]%mod,mod-2)%mod;
for(auto x:mp)
{
if(x.first!=ok)
{
ans=ans*qpow(fac[x.second],mod-2)%mod;
}
}
}
cout<<ans;
} |
//#pragma GCC optimize("Ofast,unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long llo;
#define mp make_pair
#define pb push_back
#define a first
#define b second
#define endl '\n'
const llo mod=1e9+7;
llo it[100001];
llo n;
llo pre[100001];
llo ee(llo aa,llo bb){
if(bb==0){
return 1;
}
llo ac=ee(aa,bb/2);
ac=(ac*ac)%mod;
if(bb%2==1){
ac=(ac*aa)%mod;
}
return ac;
}
llo fac[100001];
llo fac2[100001];
//llo pre2[301][301];
llo cal(llo x,llo y){
llo cur=(fac[x]*fac2[y])%mod;
//cout<<x<<":"<<y<<":"<<cur<":"<<fac[x]<<":"<<fac2[y]<<endl;
cur=(cur*fac2[x-y])%mod;
// cout<<x<<":"<<y<<":"<<cur<<endl;
return cur;
}
llo solve(vector<llo> aa){
map<llo,llo> zz;
llo le=aa.size();
for(auto j:aa){
zz[j]++;
}
llo cur=1;
for(auto j:zz){
cur=(cur*cal(le,j.b))%mod;
le-=j.b;
}
return cur;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>n;
fac[0]=1;
for(llo i=1;i<=n;i++){
fac[i]=(fac[i-1]*i)%mod;
}
fac2[n]=ee(fac[n],mod-2);
for(llo i=n-1;i>=0;i--){
fac2[i]=(fac2[i+1]*(i+1))%mod;
}
//cout<<fac2[2]<<endl;
llo su=0;
for(llo i=0;i<n;i++){
cin>>it[i];
su+=it[i];
}
if(su%n==0){
llo aa=su/n;
llo ans=1;
llo co=0;
vector<llo> ss;
for(llo i=0;i<n;i++){
if(it[i]==aa){
co++;
}
else{
ss.pb(it[i]);
}
}
for(llo i=0;i<ss.size();i++){
it[i]=ss[i];
}
llo xx=ss.size();
//split co in xx+1
//
ans=(ans*cal(co+xx+1-1,xx))%mod;
/*for(llo i=1;i<=co;i++){
ans=(ans*(xx+i))%mod;
}*/
n=xx;
if(n==0){
cout<<ans<<endl;
return 0;
}
llo bb=0;
llo cc=0;
vector<llo> dd;
vector<llo> ee;
for(llo i=0;i<n;i++){
if(it[i]<aa){
bb++;
dd.pb(it[i]);
}
else{
cc++;
ee.pb(it[i]);
}
}
if(bb==1){
ans=(ans*solve(ee))%mod;
ans=(ans*n)%mod;
/*for(llo i=1;i<=n;i++){
ans=(ans*i)%mod;
}*/
}
else if(cc==1){
ans=(ans*solve(dd))%mod;
ans=(ans*n)%mod;
/*for(llo i=1;i<=n;i++){
ans=(ans*i)%mod;
}*/
}
else{
ans=(ans*solve(dd))%mod;
ans=(ans*solve(ee))%mod;
/*for(llo i=1;i<=bb;i++){
ans=(ans*i)%mod;
}
for(llo i=1;i<=cc;i++){
ans=(ans*i)%mod;
}*/
ans=(ans*2)%mod;
}
cout<<ans<<endl;
}
else{
cout<<0<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("fast-math")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#define ios ios_base::sync_with_stdio(0);cout.tie(0);cin.tie(0);
#define ll long long
#define len(a) (int)(a).size()
#define SOLVE int t; cin >> t; while(t--) solve();
const ll INF = 2e18;
mt19937 rnd(time(nullptr));
ll facmod(ll n, ll mod){
ll res = 1;
for (int i = 2; i <= n; ++i) {
res *= i;
res %= mod;
}
return res;
}
ll binpowmod(ll n, ll pw, ll mod){
ll res = 1;
while(pw){
if(pw&1) {
res *= n;
res %= mod;
}
n *= n;
n %= mod;
pw >>= 1;
}
return res;
}
void solve() {
int n; cin >> n;
vector<ll> a(n);
ll sum = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
if(sum % n){
cout << 0;
return;
}
ll avg = sum / n;
sort(a.begin(), a.end());
int cntin = 0, cnteq = 0, cntout = 0;
for (int i = 0; i < n; ++i) {
if(a[i] < avg)
++cntin;
else if(a[i] == avg)
++cnteq;
else
++cntout;
}
ll cnt = 1;
ll b = 1;
for (int i = 1; i < n; ++i) {
if(a[i] == a[i-1]){
++cnt;
}else{
cnt = 1;
}
b *= cnt;
b %= (ll)1e9+7;
}
if(cntin == 0 && cntout == 0){
cout << facmod(n, 1e9+7) * binpowmod(b, 1e9+5, 1e9+7) % ((ll)1e9+7);
return;
}
if(cntin == 1 || cntout == 1){
cout << facmod(n, 1e9+7) * binpowmod(b, 1e9+5, 1e9+7) % ((ll)1e9+7);
return;
}
ll ans = facmod(cntin, 1e9+7) * facmod(cntout, 1e9+7) * 2 % ((ll)1e9+7);
for (int i = n-cnteq+1; i <= n; ++i) {
ans *= i;
ans %= (ll)1e9+7;
}
//a * b ** (1e9+5) % (1e9+7)
cout << ans * binpowmod(b, 1e9+5, 1e9+7) % ((ll)1e9+7);
}
signed main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios;
solve();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAXN = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const LL mod = 1e9+7;
int a[MAXN];
int t, n, k;
map<int, int> mmap;
LL fact[MAXN], factinv[MAXN], inv[MAXN];
void init(int n) {
fact[0] = fact[1] = inv[0] = inv[1] = factinv[0] = factinv[1] = 1;
for (int i = 2; i <= n; i++) {
fact[i] = fact[i-1]*i % mod;
inv[i] = inv[mod % i]*(mod - mod/i) % mod;
factinv[i] = factinv[i-1] * inv[i] % mod;
}
}
LL C(int n, int m) {
if (n < m) return 0;
return fact[n] * factinv[m] % mod * factinv[n-m] % mod;
}
int main() {
scanf("%d", &n);
init(n);
LL sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
mmap[a[i]]++;
}
if (sum % n != 0) {
printf("0\n");
return 0;
}
sum /= n;
if (n == 1) {
printf("1\n");
return 0;
}
LL ansl = 1, ansr = 1;
int l = 0, r = 0, cntl = 0, cntr = 0;
for (auto it : mmap) {
int key = it.first, value = it.second;
if (key == sum) continue;
if (key < sum) l += value, ansl = ansl * C(l, value) % mod;
else r += value, ansr = ansr * C(r, value) % mod;
}
LL ans;
if (l == 0) ans = ansr;
else if (r == 0) ans = ansl;
else if (l == 1) ans = ansr*(r+1) % mod;
else if (r == 1) ans = ansl*(l+1) % mod;
else {
ans = ansl*ansr % mod;
ans = ans*2 % mod;
}
ans = ans * C(n, mmap[sum]) % mod;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
#define lowbit(x) x&(-x)
using namespace std;
typedef long long ll;
typedef pair <int,int> PAIR;
const int N = 1e5+5;
const ll M = 1e9+7;
ll f[N],inv[N];
inline ll qpow(ll a,ll b){
ll res = 1ll;
a %= M;
while(b){
if(b & 1) res = (res*a)%M;
a = (a*a)%M;
b >>= 1;
}
return res;
}
inline void init(){
f[0] = 1;
for(int i = 1;i < N;++i) f[i] = (f[i-1]*i)%M;
inv[N-1] = qpow(f[N-1],M-2);
for(int i = N-2;i >= 0;--i) inv[i] = (inv[i+1]*(i+1))%M;
}
int a[N];
map <int,int> mp;
inline ll ncr(int n,int r){
if(r > n || r < 0) return 0;
ll ans = f[n];
ans *= (inv[r]*inv[n-r])%M;
ans %= M;
return ans;
}
int main()
{
init();
int n;
scanf("%d",&n);
ll sum = 0;
for(int i = 1;i <= n;++i) scanf("%d",&a[i]),sum += a[i];
if(sum % n){
printf("0\n");
return 0;
}
int sum1 = 0,sum2 = 0;
for(int i = 1;i <= n;++i){
if(sum/n < a[i]) sum1++,mp[a[i]]++;
if(sum/n > a[i]) sum2++,mp[a[i]]++;
}
if(sum1 == 0 || sum2 == 0){
printf("1\n");
return 0;
}
if(sum1 == 1 || sum2 == 1){
ll ans = f[n];
for(auto x : mp) ans = (ans*inv[x.second]) % M;
ans = (ans*inv[n-sum1-sum2])%M;
printf("%lld\n",ans);
return 0;
}
ll ans = (f[sum1]*f[sum2]*2ll)%M;
for(auto x : mp) ans = (ans*inv[x.second]) % M;
int tot = sum1+sum2;
int left = n-tot;
ans = (ans*ncr(left+tot,tot))%M;
printf("%lld\n",ans);
return 0;
} |
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <assert.h>
using namespace std;
#define int long long
const int N = 1e5 + 5, mod = 1e9 + 7;
int a[N];
map<int, int> cnt;
int A[N], invA[N];
int qpow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
void init() {
A[0] = 1;
for (int i = 1; i < N; i++) A[i] = A[i - 1] * i % mod;
invA[N - 1] = qpow(A[N - 1], mod - 2);
for (int i = N - 2; i >= 0; i--) invA[i] = (invA[i + 1] * (i + 1)) % mod;
//for(int i = 0; i < N; i++) assert(invA[i] == qpow(A[i], mod-2));
}
signed main() {
init();
int n, x = 0;
scanf("%lld", &n);
set<int> S;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
S.insert(a[i]);
cnt[a[i]]++;
x += a[i];
}
if (x % n != 0) {
printf("0\n");
return 0;
}
x = x / n;
set<int> Src, Snk;
int src = 0, snk = 0;
for (int i = 1; i <= n; i++) {
if (a[i] < x) {
Src.insert(a[i]);
src++;
} else if (a[i] > x) {
Snk.insert(a[i]);
snk++;
}
}
int res = 0;
if ((src == 1 || snk == 1) || (src == 0 && snk == 0)) {
res = A[n];
for (auto x : S) {
res = res * invA[cnt[x]] % mod;
}
} else {
res = 2 * A[src] % mod * A[snk] % mod;
//if (n - src - snk != 0) res = res * A[src + snk + 1] % mod * invA[2 * (src + snk) + 1 - n] % mod;
if (n - src - snk != 0) res = res * A[n] % mod * invA[src + snk] % mod * invA[n - src - snk] % mod;
for (auto x : Src) {
res = res * invA[cnt[x]] % mod;
}
for (auto x : Snk) {
res = res * invA[cnt[x]] % mod;
}
}
printf("%lld\n", res);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int inf = 0x3f3f3f3f, mod = 1e9 + 7, maxn = 1e5 + 5;
long long fact[maxn];
long long binpow(long long x, long long n, long long m) {
assert(n >= 0);
x %= m;
long long res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * x % m;
}
x = x * x % m;
n /= 2;
}
return res;
}
long long divide(long long a, long long b) {
return (a * binpow(b, mod - 2, mod)) % mod;
}
long long nCr(long long a, long long b) {
long long res = fact[a];
res = divide(res, fact[b]);
res = divide(res, fact[a - b]);
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin.exceptions(istream::failbit);
fact[0] = 1;
for (int i = 1; i < maxn; ++i) {
fact[i] = (fact[i - 1] * i) % mod;
}
int n;
cin >> n;
vector<int> a(n);
long long sum = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
if (sum % n != 0) {
cout << 0 << "\n";
return 0;
}
long long goal = sum / n;
int source = 0, sink = 0;
for (int i = 0; i < n; ++i) {
if (a[i] > goal) {
++source;
} else if (a[i] < goal) {
++sink;
}
}
if (source == 0 && sink == 0) {
cout << 1 << "\n";
return 0;
}
map<int, int> occ_src, occ_sink;
for (int i = 0; i < n; ++i) {
if (a[i] > goal) {
++occ_src[a[i]];
} else if (a[i] < goal) {
++occ_sink[a[i]];
}
}
if (source == 1 || sink == 1) {
long long ans = fact[n];
for (auto i : occ_sink) {
ans = divide(ans, fact[i.second]);
}
for (auto i : occ_src) {
ans = divide(ans, fact[i.second]);
}
cout << divide(ans, fact[n-source-sink]) << "\n";
return 0;
}
long long si = fact[sink];
for (auto i : occ_sink) {
si = divide(si, fact[i.second]);
}
long long sr = fact[source];
for (auto i : occ_src) {
sr = divide(sr, fact[i.second]);
}
long long sol = (2 * si * sr) % mod;
sol *= nCr(n, source + sink);
cout << sol % mod << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define MAXN 100005
#define lowbit(x) (x&-x)
#define reg register
typedef long long LL;
typedef unsigned long long uLL;
typedef unsigned int uint;
typedef pair<int,int> pii;
const LL INF=0x7f7f7f7f7f7f;
const int mo=1e9+7;
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;
}
int n,a[MAXN],fac[MAXN],f[MAXN],inv[MAXN],b[MAXN],num[MAXN],tot,ans;
int add(int x,int y){return x+y<mo?x+y:x+y-mo;}
void init(){
fac[0]=fac[1]=f[1]=inv[0]=inv[1]=1;
for(int i=2;i<=n;i++)
fac[i]=1ll*i*fac[i-1]%mo,
f[i]=1ll*(mo-mo/i)*f[mo%i]%mo,
inv[i]=1ll*f[i]*inv[i-1]%mo;
}
int C(int x,int y){if(x<0||y<0||x<y)return 0;return 1ll*fac[x]*inv[y]%mo*inv[x-y]%mo;}
signed main(){
LL sum=0;read(n);for(int i=1;i<=n;i++)read(a[i]),sum+=1ll*a[i];init();
if(sum%n){puts("0");return 0;}LL valx=sum/(1ll*n);int sum1=0,sum2=0;
for(int i=1;i<=n;i++)b[++tot]=a[i],sum1+=(a[i]<valx),sum2+=(a[i]>valx);
sort(b+1,b+tot+1);tot=unique(b+1,b+tot+1)-b-1;
for(int i=1;i<=n;i++)a[i]=lower_bound(b+1,b+tot+1,a[i])-b,num[a[i]]++;
if(sum1<2||sum2<2){
ans=fac[n];for(int i=1;i<=tot;i++)ans=1ll*ans*inv[num[i]]%mo;
printf("%d\n",ans);return 0;
}
ans=1ll*C(n,n-sum1-sum2)*fac[sum1]%mo*fac[sum2]%mo;
for(int i=1;i<=tot;i++)if(b[i]!=valx)ans=1ll*ans*inv[num[i]]%mo;
printf("%d\n",add(ans,ans));
return 0;
}
/*
3/4*1+1/4*3
*/
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
const int mod=1e9+7;
ll fac[N];
int a[N];
int num[N];
ll quick_pow(ll x,ll y){
ll res=1;
while(y){
if(y&1) res=res*x%mod;
x=x*x%mod;
y>>=1;
}
return res;
}
int main()
{
fac[0]=1;
for(int i=1;i<=100000;i++){
fac[i]=(fac[i-1]*i)%mod;
}
int n;
scanf("%d",&n);
ll sum=0;
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
sum+=a[i];
}
if(sum%n){
printf("0\n");
return 0;
}
sum/=n;
sort(a+1,a+n+1);
int cnt1=0,cnt2=0;
for(int i=1;i<=n;i++){
if(a[i]<sum){
++cnt1;
}
else if(a[i]==sum){
++cnt2;
}
}
int tot=0;
num[++tot]=1;
for(int i=2;i<=n;i++){
if(a[i]==a[i-1]){
num[tot]++;
}
else{
num[++tot]=1;
}
}
ll ans;
if(cnt1<=1||n-cnt1-cnt2<=1){
ans=fac[n];
}
else{
ans=fac[cnt1]*fac[n-cnt1-cnt2]%mod*fac[cnt2]%mod*2%mod;
ans=(ans*fac[n]%mod*quick_pow(fac[n-cnt2],mod-2)%mod*quick_pow(fac[cnt2],mod-2))%mod;
}
for(int i=1;i<=tot;i++){
ans=ans*quick_pow(fac[num[i]],mod-2)%mod;
}
printf("%lld\n",ans);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll A[210000],B[210000],mod=1e9+7;
ll powe(ll a,ll b)
{
ll ans=1;
while(b)
{
if(b&1)
ans=(ans*a)%mod;
b/=2;
a=(a*a)%mod;
}
return ans;
}
ll C(ll x,ll n)
{
ll ans=(B[n]*powe(B[x],mod-2))%mod;
ans=(ans*powe(B[n-x],mod-2))%mod;
return ans;
}
int main()
{
B[0]=1;
for(ll i=1;i<=200000;i++)
B[i]=(B[i-1]*i)%mod;
ll n;
scanf("%lld",&n);
ll tot=0;
for(ll i=1;i<=n;i++)
{
scanf("%lld",&A[i]);
tot+=A[i];
}
if(tot%n!=0)
{
printf("0\n");
return 0;
}
tot/=n;
ll ans=1;
sort(A+1,A+1+n);
A[n+1]=-1;
ll k=1;
ll t1=0,t2=0,t3=0;
for(ll i=1;i<=n;i++)
{
if(A[i]<tot)
{
if(A[i]==A[i+1])
{
k++;
}else
{
ans=(ans*powe(B[k],mod-2))%mod;
k=1;
}
}else if(A[i]==tot)
{
if(t1==0)t1=i;
t3=i;
}else
{
if(t1==0)t1=i;
if(t2==0)t2=i;
if(A[i]==A[i+1])
{
k++;
}else
{
ans=(ans*powe(B[k],mod-2))%mod;
k=1;
}
}
}
if(t2==0)t2=t3;
if(t1-1!=1&&n-t2+1!=1)
{
ans=((ans*B[t1-1])%mod*C(t2-t1,n))%mod;
ans=(ans*B[n-t2+1])%mod;
ans=(ans*2)%mod;
printf("%lld\n",ans);
}
else if(t1==1&&t2==n)
{
printf("1\n");
}else printf("%lld\n",((ans*B[n])%mod*powe(B[t2-t1],mod-2))%mod);
} |
#include<bits/stdc++.h>
#define fx(l,n) inline l n
#define int long long
using std::cin;
using std::cout;
const int mod=1e9+7,N=998244;
fx(int,gi)(){
char c=getchar();int s=0,f=1;
while(c>'9'||c<'0'){
if(c=='-') f=-f;
c=getchar();
}
while(c<='9'&&c>='0') s=(s<<3)+(s<<1)+(c-'0'),c=getchar();
return s*f;
}
int n,d[N],sum,pj,neg,pos,negn,posn,fac[N],negg[N],poss[N],inv=1,inv2=1;
fx(int,fpow)(int a,int b=mod-2){
int sum=1;
while(b){
if(b&1) (sum*=a)%=mod;
(a*=a)%=mod;
b>>=1;
}
return sum;
}
fx(int,binom)(int up,int down){
if(down>up) return 0;
if(down<0) return 1;
return fac[up]*fpow(fac[down])%mod*fpow(fac[up-down])%mod;
}
signed main(){
n=gi();fac[0]=1;
for(int i=1;i<=n;i++) d[i]=gi(),sum+=d[i];
for(int i=1;i<=n;i++) fac[i]=fac[i-1]*i%mod;
pj=sum/n;
if(sum%n!=0){printf("0\n");return 0;}
std::sort(d+1,d+n+1);
for(int i=1;i<=n;i++) d[i]-=pj;
for(int i=1;i<=n;i++){
if(d[i]<0){
neg+=1;
if(d[i]!=d[i-1]) negn+=1;
negg[negn]+=1;
}
else if(d[i]>0){
pos+=1;
if(d[i]!=d[i-1]) posn+=1;
poss[posn]+=1;
}
}
if(neg==0&&pos==0) printf("1\n");
else if(neg==1){
for(int i=1;i<=posn;i++){
// printf("now: %d %d\n",i,poss[i]);
(inv*=fpow(fac[poss[i]]))%=mod;
}
printf("%lld",fac[n]*inv%mod*fpow(fac[n-pos-1])%mod);
}
else if(pos==1){
for(int i=1;i<=negn;i++){
(inv*=fpow(fac[negg[i]]))%=mod;
}
printf("%lld",fac[n]*inv%mod*fpow(fac[n-neg-1])%mod);
}
else {
for(int i=1;i<=posn;i++){
// printf("now: %d %d\n",i,poss[i]);
(inv*=fpow(fac[poss[i]]))%=mod;
}
for(int i=1;i<=negn;i++){
(inv2*=fpow(fac[negg[i]]))%=mod;
}
// printf("%lld | %lld %lld | %lld %lld\n",binom(n,neg+pos),inv,inv2,fac[pos],fac[neg]);
printf("%lld",2*binom(n,neg+pos)
*fac[pos]%mod*inv%mod
*fac[neg]%mod*inv2%mod);
}
} |
#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
#define N 100010
typedef long long ll;
inline ll read(){
ll x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
map<int,int> mp;
int n,A,B,C,ans;
ll tot;
int fac[N],ifac[N],a[N];
int qpow(int a,int b){
int ans=1;
while(b){
if(b&1)ans=1LL*ans*a%mod;
a=1LL*a*a%mod;
b>>=1;
}
return ans;
}
void init(int n){
fac[0]=1;
for(int i=1;i<=n;++i){
fac[i]=1LL*fac[i-1]*i%mod;
}
ifac[n]=qpow(fac[n],mod-2);
for(int i=n-1;i>=0;--i){
ifac[i]=1LL*ifac[i+1]*(i+1)%mod;
}
}
int main(){
n=read();
init(n);
for(int i=1;i<=n;++i){
a[i]=read();
tot+=a[i];
++mp[a[i]];
}
if(tot%n)return !printf("0\n");
tot/=n;
for(int i=1;i<=n;++i){
if(a[i]==tot)++C;
else if(a[i]<tot)++A;
else ++B;
}
if(C==n)return !printf("1\n");
if(A==1||B==1){
ans=fac[n];
for(auto [x,w]:mp)ans=1LL*ans*ifac[w]%mod;
}
else{
ans=2LL*fac[A]*fac[B]%mod*fac[n]%mod*ifac[n-C]%mod;
for(auto [x,w]:mp)ans=1LL*ans*ifac[w]%mod;
}
printf("%d\n",ans);
return 0;
}
|
#include <iostream>
#include <vector>
#include <map>
using namespace std;
const int MOD = 1e9 + 7, MAX_N = 1e5 + 5;
vector <long long> factorial(MAX_N, 0), inverse_factorial(MAX_N, 0);
long long power_mod(long long x, long long power, long long mod)
{
long long result = 1;
while(power)
{
if(power%2 == 1)
result = (result*x)%mod;
x = (x*x)%mod;
power = power >> 1;
}
return result;
}
void precompute()
{
factorial[0] = 1;
for(int i = 1; i < MAX_N; i++)
{
factorial[i] = (i*factorial[i - 1])%MOD;
}
//i*(i - 1)! = i!
inverse_factorial[MAX_N - 1] = power_mod(factorial[MAX_N - 1], MOD - 2, MOD);
for(int i = MAX_N - 2; i >= 0; i--)
{
inverse_factorial[i] = (i + 1)*inverse_factorial[i + 1];
inverse_factorial[i] %= MOD;
}
}
long long multinomial(vector <long long> &frequency)
{
long long total = 0;
long long numerator = 0, inverse_denominator = 1;
for(int i = 0; i < frequency.size(); i++)
{
total += frequency[i];
inverse_denominator *= inverse_factorial[frequency[i]];
inverse_denominator %= MOD;
}
numerator = factorial[total];
long long answer = (numerator*inverse_denominator)%MOD;
return answer;
}
long long stars_and_bars(long long stars, long long bars)
{
long long numerator = factorial[stars + bars - 1];
long long inverse_denominator = (inverse_factorial[stars]*inverse_factorial[bars - 1])%MOD;
return (numerator*inverse_denominator)%MOD;
}
int main()
{
precompute();
int no_of_elements;
cin >> no_of_elements;
map <int, int> frequency;
long long sum = 0;
vector <int> A(no_of_elements + 1);
for(int i = 1; i <= no_of_elements; i++)
{
cin >> A[i];
sum += A[i];
frequency[A[i]]++;
}
if(sum%no_of_elements != 0)
{
cout << "0\n";
return 0;
}
int final_value = (sum/no_of_elements);
vector <long long> F, source_frequency, sink_frequency;
for(auto it = frequency.begin(); it != frequency.end(); it++)
{
if(it->first > final_value)
{
source_frequency.push_back(it->second);
}
else if(it->first < final_value)
{
sink_frequency.push_back(it->second);
}
F.push_back(it->second);
}
long long answer;
if(source_frequency.size() == 0 || sink_frequency.size() == 0 ||
(source_frequency.size() == 1 && source_frequency[0] == 1) || (sink_frequency.size() == 1 && sink_frequency[0] == 1) )
{
answer = multinomial(F);
cout << answer << "\n";
return 0;
}
long long sources = multinomial(source_frequency), sink = multinomial(sink_frequency);
long long equal_values = frequency[final_value], spaces = no_of_elements - equal_values + 1;
long long remaining = stars_and_bars(equal_values, spaces);
answer = (sources*sink)%MOD;
answer = (answer*remaining)%MOD;
answer = (answer*2)%MOD;;
cout << answer << "\n";
return 0;
} |
/**
* author: fractal
* timus: 288481RF
* created: 04/12/21 09:30
**/
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define speed ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define sz(x) (int)x.size()
#define len(x) (int)strlen(x)
#define all(x) x.begin(), x.end()
#define debug cerr << "OK\n";
#define ub upper_bound
#define lb lower_bound
#define nl printf("\n");
#define clbuff fflush(stdin);
mt19937 bruh(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rofl(chrono::steady_clock::now().time_since_epoch().count());
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef set<int> si;
typedef set<ll> sll;
typedef set<pii> spii;
typedef set<pll> spll;
typedef multiset <int> msi;
typedef multiset <ll> msll;
typedef map <int, int> mi;
typedef map <ll, ll> mll;
const int N = 2e5 + 20;
const int M = 1e5;
const int mod = 1e9 + 7;
const int inf = 2e9 + 3;
const ll INF = 1e18;
const ld pi2 = 2.0 * 3.141592;
const ld pi = 3.141592;
const ld eps = 1e-12;
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
void files(string s = "main") {
#ifndef PC
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
#endif
}
int add(int a, int b) {
if (a + b < 0) return a + b + mod;
if (a + b >= mod) return a + b - mod;
return a + b;
}
int mul(int a, int b) {
return a * 1LL * b % mod;
}
int binpow(int a, int n) {
int ret = 1;
while (n) {
if (n & 1) ret = mul(ret, a);
a = mul(a, a);
n >>= 1;
}
return ret;
}
int n, a[N], A, B, C, fact[N], invf[N];
int Cnk(int n, int k) {
return mul(fact[n], mul(invf[k], invf[n - k]));
}
int main() {
speed;
cin >> n;
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = mul(fact[i - 1], i);
invf[n] = binpow(fact[n], mod - 2);
ll s = 0;
for (int i = n; i >= 1; --i)
invf[i - 1] = mul(invf[i], i);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
s += a[i];
}
if (s % n) {
cout << 0 << '\n';
return 0;
}
s /= n;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
if (a[i] == s)
C++;
if (a[i] > s)
A++;
if (a[i] < s)
B++;
}
int ans = 1;
for (int i = 1, cnt = 0; i <= n; ++i) {
if (a[i - 1] == a[i])
cnt++;
if (a[i - 1] != a[i] || i == n) {
ans = mul(ans, invf[cnt]), cnt = 1;
}
}
if (A == 1 || B == 1) {
cout << mul(fact[n], ans) << '\n';
return 0;
}
if (A && B) ans = mul(ans, 2);
cout << mul(mul(mul(fact[A], fact[B]), mul(fact[C], ans)), Cnk(n, C)) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long modpow(long long a, long long b){
long long ans = 1;
while (b > 0){
if (b % 2 == 1){
ans *= a;
ans %= MOD;
}
a *= a;
a %= MOD;
b /= 2;
}
return ans;
}
long long modinv(long long a){
return modpow(a, MOD - 2);
}
vector<long long> mf = {1};
vector<long long> mfi = {1};
long long modfact(int n){
if (mf.size() > n){
return mf[n];
} else {
for (int i = mf.size(); i <= n; i++){
long long next = mf.back() * i % MOD;
mf.push_back(next);
mfi.push_back(modinv(next));
}
return mf[n];
}
}
long long modfactinv(int n){
if (mfi.size() > n){
return mfi[n];
} else {
return modinv(modfact(n));
}
}
long long modbinom(int n, int k){
if (n < 0 || k < 0 || k > n){
return 0;
} else {
return modfact(n) * modfactinv(k) % MOD * modfactinv(n - k) % MOD;
}
}
int main(){
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++){
cin >> a[i];
}
long long sum = 0;
for (int i = 0; i < n; i++){
sum += a[i];
}
if (sum % n != 0){
cout << 0 << endl;
} else {
int avg = sum / n;
int small = 0, large = 0;
for (int i = 0; i < n; i++){
if (a[i] > avg){
large++;
}
if (a[i] < avg){
small++;
}
}
long long ans = 1;
if (small == 1){
ans = modfact(large + 1);
}
if (large == 1){
ans = modfact(small + 1);
}
if (small >= 2 && large >= 2){
ans = modfact(small) * modfact(large) % MOD * 2 % MOD;
}
ans *= modbinom(n, small + large);
ans %= MOD;
map<int, int> mp;
for (int i = 0; i < n; i++){
mp[a[i]]++;
}
for (auto P : mp){
int cnt = P.second;
if (P.first != avg){
ans *= modfactinv(cnt);
}
ans %= MOD;
}
cout << ans << endl;
}
} |
#include<bits/stdc++.h>
#define ll long long
#define N 200015
#define rep(i,a,n) for (int i=a;i<=n;i++)
#define per(i,a,n) for (int i=n;i>=a;i--)
#define inf 0x3f3f3f3f
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define fi first
#define se second
#define lowbit(i) ((i)&(-i))
#define VI vector<int>
#define all(x) x.begin(),x.end()
#define SZ(x) ((int)x.size())
const int mod = 1e9+7;
using namespace std;
int n,a[N],pos,neg,zer,fac[N],inv[N];
int qpow(int a,int b){
int res = 1;
while(b){
if(b&1) res = 1ll*res*a%mod;
a = 1ll*a*a%mod;
b >>= 1;
}
return res;
}
ll sum;
map<int,int> cnt;
int main(){
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
scanf("%d",&n);
fac[0] = 1;
rep(i,1,n) fac[i] = (1ll*fac[i-1]*i)%mod;
inv[0] = 1;
rep(i,1,n) inv[i] = qpow(fac[i],mod-2);
rep(i,1,n) scanf("%d",&a[i]),sum += a[i];
if(sum%n != 0){
puts("0");
return 0;
}
sum /= n;
rep(i,1,n) {
a[i] -= sum;
if(a[i] == 0) zer++;
else if(a[i] < 0) neg++;
else pos++;
}
rep(i,1,n) cnt[a[i]]++;
if(pos <= 1 || neg <= 1){
int res = fac[n];
for(auto x:cnt){
res = (1ll*res*inv[x.se])%mod;
}
printf("%d\n",res);
}else{
int res = (1ll*fac[pos]*fac[neg])%mod;
for(auto x:cnt){
if(x.fi != 0)
res = (1ll*res*inv[x.se])%mod;
}
// C(n,zer);
res = (1ll*res*fac[n])%mod;
res = (1ll*res*inv[zer])%mod;
res = (1ll*res*inv[n-zer])%mod;
res = (res+res)%mod;
printf("%d\n", res);
}
return 0;
} |
#include <bits/stdc++.h>
#pragma GCC optimize ("O3", "unroll-all-loops")
#pragma GCC target ("sse4.2")
using namespace std;
#define F first
#define S second
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
ifstream in;
ofstream out;
const long long kk = 1000;
const long long ml = kk * kk;
const long long mod = ml * kk + 7;
const long long inf = ml * ml * ml + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll n;
vector<ll> v;
bool viv = false;
ll f(int n) {
ll res = 1;
for (int i = 1; i <= n; i++)
res *= i, res %= mod;
return res;
}
ll bpow(ll val, ll mod, ll st = -1) {
if (st == -1)
st = mod - 2;
if (st == 0)
return 1;
ll res = bpow(val, mod, st >> 1);
res = res * res, res %= mod;
if (st & 1)
res *= val, res %= mod;
return res;
}
ll C(int n, int k) {
ll res = 1;
ll f1 = f(n);
res *= f1, res %= mod;
ll f2 = f(k);
f2 = bpow(f2, mod);
res *= f2, res %= mod;
ll f3 = f(n - k);
f3 = bpow(f3, mod);
res *= f3, res %= mod;
return res;
}
void solve() {
cin >> n;
v.resize(n);
ll sum = 0;
for (auto &i : v)
cin >> i, sum += i;
if (sum % n) {
cout << "0\n";
return;
}
ll mid = sum / n;
int b = 0, s = 0;
for (auto i : v)
b += (i > mid), s += (i < mid);
if (min(b, s) <= 1) {
ll ans = f(n);
map<int, int> mp;
for (auto i : v)
mp[i]++;
for (auto pr : mp) {
ll cf = pr.S;
cf = f(cf);
cf = bpow(cf, mod);
ans *= cf;
ans %= mod;
}
cout << ans << '\n';
return;
}
ll ans = C(n, b + s);
ans *= f(b);
ans %= mod;
ans *= f(s);
ans %= mod;
ans *= f(n - b - s);
ans %= mod;
map<int, int> mp;
for (auto i : v)
mp[i]++;
for (auto pr : mp) {
ll cf = pr.S;
cf = f(cf);
cf = bpow(cf, mod);
ans *= cf;
ans %= mod;
}
ans *= 2;
ans %= mod;
cout << ans << '\n';
}
int main() {
// viv = true;
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll t = 1;
// cin >> t;
while (t--)
solve();
return 0;
} |
#include <stdio.h>
#include <memory.h>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
const int N = 100005;
const int mod = 1000000007;
int a[N] = { 0 }, e[N] = { 0 }, inv[N] = { 0 };
map<int, int> my;
map<int, int>::iterator it;
int po(int x, int y) {
if (!y) return 1;
int now = po(x, y / 2);
now = now * 1LL * now % mod;
if (y & 1) now = now * 1LL * x % mod;
return now;
}
void solve() {
int n = 0, i = 0, gx = 0, gy = 0, ans = 0;
long long s = 0;
scanf("%d", &n);
for (i = 1; i <= n; i ++) {
scanf("%d", a + i);
s += a[i];
}
if (s % n) {
printf("%d\n", 0);
return;
}
s /= n;
e[0] = 1;
for (i = 1; i <= n; i ++) {
e[i] = e[i-1] * 1LL * i % mod;
inv[i] = po(e[i], mod - 2);
}
for (i = 1; i <= n; i ++) {
if (a[i] < s) gx ++;
else if (a[i] > s) gy ++;
my[a[i]] ++;
}
if (gx == 0 || gy == 0) {
printf("%d\n", 1);
return;
}
if (gx == 1 || gy == 1) {
ans = e[n];
for (it = my.begin(); it != my.end(); it ++) {
ans = ans * 1LL * inv[it->second] % mod;
}
printf("%d\n", ans);
return;
}
ans = e[gx] * 2LL * e[gy] % mod;
for (it = my.begin(); it != my.end(); it ++) {
if (it->first != s) {
ans = ans * 1LL * inv[it->second] % mod;
}
else {
ans = ans * 1LL * e[n] % mod * inv[it->second] % mod * inv[n - it->second] % mod;
}
}
printf("%d\n", ans);
}
int main() {
int o = 1;
//scanf("%d", &o);
while (o --) {
solve();
//fflush(stdout);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define io_speed_up ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
template<typename T>void rd(T&x){int f=0,c;while(!isdigit(c=getchar()))f^=!(c^45);x=(c&15);while(isdigit(c=getchar()))x=x*10+(c&15);if(f)x=-x;} //读整型
template<typename T>void pt(T x,int c=10){if(x<0)putchar('-'),x=-x;if(x>9)pt(x/10,-1);putchar(x%10+48);if(c!=-1)putchar(c);}
template<typename T>void umax(T&x,const T&y){if(x<y)x=y;}
template<typename T>void umin(T&x,const T&y){if(x>y)x=y;}
#define for_seq(i,s) for(int i=0;i<(int)s.size();i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define per(i,a,b) for(int i=a;i>=b;i--)
#define for0(i,n) for(int i=0;i<n;i++)
#define ms(a,b) memset(a,b,sizeof a)
#define all(n) (n).begin(), (n).end()
#define sz(x) (int)x.size()
using vi = vector<int>;
using ll = long long;
using ld = long double;
using pii = pair<int,int>;
using pll = pair<long,long>;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5+5;
const int mod = 1e9+7;
int n,a[maxn];
ll jc[maxn],inv[maxn];
ll qp(ll a, ll b) {
ll ans = 1;
while(b) {
if(b&1) ans = ans*a%mod;
b>>=1;
a=a*a%mod;
}
return ans;
}
ll C(int x,int y) {
if(x<y) return 0;
return jc[x]*inv[y]%mod*inv[x-y]%mod;
}
unordered_map<int,int> mp;
int main()
{
cin>>n;
jc[0] = 1;
rep(i,1,n) jc[i] = jc[i-1]*i%mod;
inv[n] = qp(jc[n], mod-2);
per(i,n-1,0) inv[i] = inv[i+1]*(i+1)%mod;
rep(i,1,n) cin>>a[i];
ll sum = accumulate(a+1, a+n+1, 0LL);
if(sum % n != 0) {
cout<<0<<"\n";
return 0;
}
int target = sum/n, cnt0 = 0 ,cnt1 = 0;
rep(i,1,n) {
a[i] -= target, cnt0 += a[i]<0, cnt1 += a[i]>0;
mp[a[i]]++;
}
if(cnt0 == 0 || cnt0 == 1 || cnt1==1) {
ll ans = jc[n];
for(auto [k,v]:mp) ans = ans * inv[v] % mod;
cout<<ans<<"\n";
} else {
ll ans = jc[cnt0] * jc[cnt1] * 2 % mod;
for(auto [k,v]:mp) {
if(k!=0) ans = ans * inv[v] % mod;
}
int num = n - cnt1 - cnt0, h = cnt1 + cnt0;
if(num==0) cout<<ans<<"\n";
else {
ll tmp = 0;
rep(i,1,num) {
tmp = (tmp + C(num-1, i - 1) % mod * C(h+1, i) ) % mod;
}
cout<<ans*tmp%mod<<"\n";
}
}
return 0;
}
/*
a[k] 左边A次， 右边B次
贡献就是 Ak, B(-k) = k (A - B)
*/ |
#ifdef Rahul
#include "RAHUL.h"
#else
#include <bits/stdc++.h>
using namespace std;
#define error(...) 42;
#endif
#define SZ(v) int((v).size())
#define ALL(vec) begin(vec), end(vec)
typedef long long i64;
template<typename T> inline bool uax(T &x, T y) {return (y > x) ? x = y, true : false;}
template<typename T> inline bool uin(T &x, T y) {return (y < x) ? x = y, true : false;}
template<typename T> void kek(T ans) {cout << ans << endl; exit(0);}
#define Luv(...) [&] (auto &&u, auto &&v) { return __VA_ARGS__; }
const int MOD = (int) 1e9 + 7;
const i64 INF = (i64) 1e18 + 42;
inline int add(int a, int b, int mod = MOD) {
a += b; return a >= mod ? a - mod : a;
}
inline int sub(int a, int b, int mod = MOD) {
a -= b; return a < 0 ? a + mod : a;
}
inline int mul(int a, int b, int mod = MOD) {
return int((long long) a * b % mod);
}
inline int mpow(int base, long long ex, int mod = MOD) {
int res = 1;
for (; ex > 0; ex >>= 1) {
if (ex & 1) res = mul(res, base, mod);
base = mul(base, base, mod);
}
return res;
}
inline int inv(int a, int mod = MOD) {
return mpow(a, mod - 2, mod);
}
inline int mdiv(int a, int b, int mod = MOD) {
return mul(a, mpow(b, mod - 2, mod));
}
inline void adds(int &a, int b, int mod = MOD) {
a += b; if (a >= mod) a -= mod;
}
inline void subs(int &a, int b, int mod = MOD) {
a -= b; if (a < 0) a += mod;
}
inline void muls(int &a, int b, int mod = MOD) {
a = int((long long) a * b % mod);
}
inline void mdivs(int &a, int b, int mod = MOD) {
a = mdiv(a, b, mod);
}
vector<int> fac, ifac;
void Prep(int nax = 1e6 + 40) {
fac.resize(nax);
ifac.resize(nax);
fac[0] = 1;
for (int i = 1; i < nax; ++i) fac[i] = mul(i, fac[i - 1]);
ifac[nax - 1] = inv(fac[nax - 1]);
for (int i = nax - 1; i > 0; --i) ifac[i - 1] = mul(i, ifac[i]);
}
inline int Ncr(int n, int r) {
if (n < r || r < 0 || n < 0) return 0;
return mul(fac[n], mul(ifac[n - r], ifac[r]));
}
int main() {
cin.tie(nullptr) -> sync_with_stdio(false);
Prep();
int n; cin >> n;
vector<int> a(n);
i64 s = 0;
for (int &x : a) cin >> x, s += x;
if (s % n) kek(0);
int m = s / n;
array<int, 3> b {};
for (int x : a) {
if (x < m) ++b[0];
else if (x > m) ++b[1];
else ++b[2];
}
if (b[2] == n) kek(1);
if (b[0] == 1 || b[1] == 1) {
int ans = fac[n];
map<int,int> cnt;
for (int x : a) {
cnt[x]++;
}
for (auto &[k, v] : cnt) {
muls(ans, ifac[v]);
}
kek(ans);
}
int ans = mul(fac[b[0]], fac[b[1]]);
muls(ans, 2);
map<int,int> cnt;
for (int x : a) {
cnt[x]++;
}
for (auto &[k, v] : cnt) if (k != m) {
muls(ans, ifac[v]);
}
muls(ans, Ncr(n, b[2]));
kek(ans);
} |
#include<bits/stdc++.h>
#define cerr cout<<"#case:"
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;
const int N = 1e5 + 10;
const int M = 1e5 + 10;
const int INF = 2147483647;
const LL MOD = 1e9 + 7;
int T,n,m;
//LL fac[N],inv[N];
LL gcd(LL x, LL y) {return y == 0 ? x : gcd(y, x % y);}
LL qpow(LL base, LL x) {
LL res = 1;
while(x) {
if(x & 1) res = (res * base) % MOD;
base = (base * base) % MOD;
x >>= 1;
}
return res;
}
/*
LL binom(int n, int k) {
if(k > n) return 0;
return (fac[n] * inv[k] % mod * inv[n - k]) % mod;
}
*/
LL get_inv(LL x) {return qpow(x,MOD - 2) % MOD;}
void solve() {
cin>>n;
vector<LL> a(n + 1),inv(n + 1);
map<int,int> mp,s,b;
for(int i = 0; i < n; i++) cin>>a[i],mp[a[i]]++;
LL sum = accumulate(a.begin(),a.end(),0ll);
if(sum % n) {cout<<0<<endl;return ;}
LL ave = sum / n;
int small = 0,big = 0;
for(int i = 0 ; i < n; i++) {
if(a[i] < ave) small++,s[a[i]]++;
else if(a[i] > ave) big++,b[a[i]]++;
}
inv[0] = inv[1] = 1;
for(int i = 2; i <= n; i++) inv[i] = (MOD - MOD / i) *1ll* inv[MOD % i] % MOD;
if(small <= 1 || big <= 1) {
LL res = 1;
for(int i = 1; i <= n; i++) res = res * i % MOD;
for(auto &[key,value] : mp) {
for(int j = 1; j <= value; j++) res = res * inv[j] % MOD;
}
cout<<res<<endl;
}
else {
LL res = 1;
for(int i = 1; i <= small; i++) res = res * i % MOD;
for(auto &[key,value]: s) {
for(int j = 1; j <= value; j++) res = res * inv[j] % MOD;
}
for(int i = 1; i <= big; i++) res = res * i % MOD;
for(auto &[key,value]: b) {
for(int j = 1; j <= value; j++) res = res * inv[j] % MOD;
}
for(int i = 1; i <= n; i++) res = res * i % MOD;
for(int i = 1; i <= small + big; i++) res = res * inv[i] % MOD;
for(int i = 1; i <= n - (small + big); i++) res = res * inv[i] % MOD;
cout<<2 * res % MOD<<endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
//cin>>T;
T = 1;
while(T--) solve();
return 0;
} |
#include <iostream>
#include <vector>
#include <numeric>
#include <map>
using namespace std;
#define int long long
typedef long long ll;
const ll MOD = 1e9 + 7;
ll binPow(ll a, ll n)
{
ll res = 1;
while (n)
{
if (n & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
n /= 2;
}
return res;
}
signed main()
{
int n;
cin >> n;
vector<int> a(n);
for (int &i : a) cin >> i;
ll sum = accumulate(a.begin(), a.end(), 0ll);
if (sum % n != 0)
{
cout << 0;
return 0;
}
sum /= n;
vector<ll> fact(1e5 + 1);
fact[0] = 1;
for (ll i = 1; i <= 1e5; ++i) fact[i] = (fact[i - 1] * i) % MOD;
int sources = 0, sinks = 0;
for (int i : a)
{
if (i < sum) ++sinks;
if (i > sum) ++sources;
}
ll res = 1;
if (sinks <= 1 || sources <= 1)
{
res = fact[n];
map<int, int> help;
for (int i : a) ++help[i];
for (auto i : help) res = (res * binPow(fact[i.second], MOD - 2)) % MOD;
}
else
{
res = (((((2 * fact[n]) % MOD) * binPow(fact[sources + sinks], MOD - 2)) % MOD) * binPow(fact[n - sources - sinks], MOD - 2)) % MOD;
res = (res * fact[sources]) % MOD;
res = (res * fact[sinks]) % MOD;
map<int, int> help;
for (int i : a) if (i != sum) ++help[i];
for (auto i : help) res = (res * binPow(fact[i.second], MOD - 2)) % MOD;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod = 1e9 + 7;
ll n, sum, ans;
ll a[100001];
ll fac[100001];
ll inv[100001];
ll quick_pow(ll a, ll k)
{
ll ans = 1;
while(k)
{
if(k & 1) ans = ans * a % mod;
a = a * a % mod;
k >>= 1;
}
return ans;
}
ll C(ll n, ll m)
{
return fac[n] * inv[n - m] % mod * inv[m] % mod;
}
int main()
{
scanf("%lld", &n);
fac[0] = 1; for(ll i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
// for(int i = 1; i <= n; ++i) cout << fac[i] << " "; cout << endl;
inv[n] = quick_pow(fac[n], mod - 2); for(ll i = n - 1; i >= 0; --i) inv[i] = inv[i + 1] * (i + 1) % mod;
// for(int i = 1; i <= n; ++i) cout << inv[i] << " "; cout << endl;
for(ll i = 1; i <= n; ++i)
{
scanf("%lld", &a[i]);
sum += a[i];
}
// if(n == 1) {puts("1"); return 0;}
if(sum % n) {puts("0"); return 0;}
sort(a + 1, a + n + 1);
sum /= n;
ll low = 0, equ = 0, high = 0;
for(ll i = 1; i <= n; ++i)
{
if(a[i] < sum) low++;
else if(a[i] == sum) equ++;
else high++;
}
if(low == 1 || high == 1 || equ == n) ans = fac[n];
else ans = 2 * fac[low] % mod * fac[high] % mod * C(n, low + high) % mod * fac[equ] % mod;
ll now = 1;
for(ll i = 2; i <= n; ++i)
if(a[i] == a[i - 1]) now++;
else
{
(ans *= inv[now]) %= mod;
// cout << now << " ";
now = 1;
}
// cout << now << " ";
(ans *= inv[now]) %= mod;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 123;
long long f[N],inv[N];
long long powInv(int x,int y){
if(y == 0) return 1;
if(y == 1) return x % mod;
long long z = powInv(x,y >> 1);
z = (z * z) % mod;
return y & 1 ? (z * x) % mod : z;
}
long long combination(int x,int y){
return (f[y] * inv[x] % mod) * inv[y - x] % mod;
}
long long cal(vector <int> a){
if(a.empty()) return 1;
sort(a.begin(),a.end());
long long res = f[(int)a.size()];
int prev = 0;
for(int i = 0; i < a.size(); ++i){
if(i >= (int)a.size() - 1 || a[i + 1] != a[i]){
res = (res * inv[i - prev + 1]) % mod;
prev = i + 1;
}
}
/*for(int x : a){
cout << x << " / ";
}
cout << "~> " << res << endl;*/
return res;
}
void testcase(){
int n;
cin >> n;
vector <int> a(n);
long long s = 0;
for(int &x: a){
cin >> x;
s += x;
}
if(s % n != 0){
cout << 0 <<"\n";
return ;
}
s /= n;
vector <int> aLess,aEqual,aGreater;
for(int x : a){
if(x < s) aLess.push_back(x);
else if(x > s) aGreater.push_back(x);
else aEqual.push_back(x);
}
if(aLess.empty()){
cout << 1 << "\n";
return ;
}
if((int)aLess.size() == 1 || (int)aGreater.size() == 1){
cout << cal(a) << "\n";
return ;
}
long long res = combination(aEqual.size(),n) * 2 % mod;
res = ((res * cal(aLess)) % mod * cal(aGreater)) % mod;
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
f[0] = inv[0] = 1;
for(int i = 1; i < N; ++i) f[i] = f[i - 1] * i % mod;
inv[N - 1] = powInv(f[N - 1],mod - 2);
for(int i = N - 2; i > 0; --i){
inv[i] = (inv[i + 1] * (i + 1)) % mod;
}
int t = 1;
while(t--){
testcase();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<int M>
struct static_mint {
static_assert(0 < M, "Module must be positive");
int val;
static_mint(): val() {}
static_mint(long long x) : val(x % M) { if (val < 0) val += M; }
static_mint pow(long long n) const { static_mint ans = 1, x(*this); while (n) { if (n & 1) ans *= x; x *= x; n /= 2; } return ans; }
static_mint inv() const { return pow(M - 2); }
friend static_mint pow(const static_mint &m, long long n) { return m.pow(n); }
friend static_mint inv(const static_mint &m) { return m.inv(); }
static_mint operator+() const { static_mint m; m.val = val; return m; }
static_mint operator-() const { static_mint m; m.val = M - val; return m; }
static_mint &operator+=(const static_mint &m) { if ((val += m.val) >= M) val -= M; return *this; }
static_mint &operator-=(const static_mint &m) { if ((val -= m.val) < 0) val += M; return *this; }
static_mint &operator*=(const static_mint &m) { val = (long long) val * m.val % M; return *this; }
static_mint &operator/=(const static_mint &m) { val = (long long) val * m.inv().val % M; return *this; }
friend static_mint operator+ (const static_mint &lhs, const static_mint &rhs) { return static_mint(lhs) += rhs; }
friend static_mint operator- (const static_mint &lhs, const static_mint &rhs) { return static_mint(lhs) -= rhs; }
friend static_mint operator* (const static_mint &lhs, const static_mint &rhs) { return static_mint(lhs) *= rhs; }
friend static_mint operator/ (const static_mint &lhs, const static_mint &rhs) { return static_mint(lhs) /= rhs; }
friend bool operator==(const static_mint &lhs, const static_mint &rhs) { return lhs.val == rhs.val; }
friend bool operator!=(const static_mint &lhs, const static_mint &rhs) { return lhs.val != rhs.val; }
static_mint &operator++() { return *this += 1; }
static_mint &operator--() { return *this -= 1; }
static_mint operator++(int) { static_mint result(*this); *this += 1; return result; }
static_mint operator--(int) { static_mint result(*this); *this -= 1; return result; }
template <typename T> explicit operator T() const { return T(val); }
friend std::ostream &operator<<(std::ostream &os, const static_mint &m) {
return os << m.val;
}
friend std::istream &operator>>(std::istream &is, static_mint &m) {
long long x; is >> x; m = x;
return is;
}
};
template <typename>
struct is_mint : public std::false_type { };
template <int M>
struct is_mint<static_mint<M>> : public std::true_type { };
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
using mint = static_mint<1000000007>;
int n;
cin >> n;
vector<mint> fact(n + 1), inv(n + 1);
fact[0] = inv[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = i * fact[i - 1];
inv[i] = fact[i].inv();
}
vector<int> a(n);
for (auto &x : a) cin >> x;
long long sum = accumulate(a.begin(), a.end(), 0ll);
if (sum % n != 0) {
cout << 0 << '\n';
return 0;
}
int target = sum / n;
map<int, int> mp;
for (int i = 0; i < n; i++) {
mp[a[i]] += 1;
}
mint ans = 1;
int less = 0, more = 0, equal = 0;
for (auto &[x, c] : mp) {
less += c * (x < target);
more += c * (x > target);
equal += c * (x == target);
ans *= inv[c];
}
if (less == 1 || more == 1 || equal == n) {
ans *= fact[n];
} else {
ans *= 2 * fact[less] * fact[more];
ans *= fact[n] * inv[n - equal];
}
cout << ans << '\n';
return 0;
} |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cstdlib>
#define N 200010
#define M 1000000007
#define sup 0x3f3f3f3f
#define inf -0x3f3f3f3f
#define ll long long
using namespace std;
ll n,m,cntm,cnta,tot_mi,tot_ma,f[N],ans,ax,sum,mi[N],ma[N],num_mi[N],num_ma[N],maxid_mi,minid_ma,num_l;
struct Point{
ll id,a;
bool operator <(const Point &rhs)const{
return a<rhs.a;
}
}s[N];
inline int read(){
int x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')f=-f;ch=getchar();
}while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();
}return x*f;
}
void init(){
f[0]=1;
f[1]=1;
for(int i=2;i<=n;i++){
f[i]=(f[i-1]*i)%M;
}
return ;
}
ll pow(ll x,ll y){
ll c=1;
while(y){
if(y&1)c=(c*x)%M;
x=(x*x)%M;
y>>=1;
}return c;
}
bool check(){
if(sum%n)return 0;
sort(s+1,s+1+n);
ax=sum/n;
for(int i=0;i<N;i++){
mi[i]=inf;
ma[i]=inf;
}
for(int i=1;i<=n;i++){
if(s[i].a<ax){
maxid_mi=max(maxid_mi,s[i].id);
if(s[i].a==mi[cntm]){
num_mi[cntm]++;
}
else{
mi[++cntm]=s[i].a;
num_mi[cntm]=1;
}
}
else if(s[i].a>ax){
minid_ma=min(minid_ma,s[i].id);
if(s[i].a==ma[cnta]){
num_ma[cnta]++;
}
else {
ma[++cnta]=s[i].a;
num_ma[cnta]=1;
}
}
else{
num_l++;
}
}
for(int i=1;i<=cnta;i++){
tot_ma+=num_ma[i];
}
for(int i=1;i<=cntm;i++){
tot_mi+=num_mi[i];
}
if(tot_mi<=1 || tot_ma<=1)return true;
return true;
}
int main(){
n=read();
init();
for(int i=1;i<=n;i++){
s[i].a=read();
s[i].id=i;
sum+=s[i].a;
}
if( !check() ){
printf("0\n");
return 0;
}
else{
if(tot_mi<=1 || tot_ma<=1){
ans=1;
for(int i=1;i<=cnta;i++){
ans=ans*pow(f[num_ma[i]],1e9+5)%M;
}
for(int i=1;i<=cntm;i++){
ans=ans*pow(f[num_mi[i]],1e9+5)%M;
}
ans=(ans*f[n])%M*pow(f[num_l],1e9+5)%M;
}
else{
ans=2;
ans=(ans*f[tot_mi]%M*f[tot_ma])%M;
for(int i=1;i<=cnta;i++){
ans=ans*pow(f[num_ma[i]],1e9+5)%M;
}
for(int i=1;i<=cntm;i++){
ans=ans*pow(f[num_mi[i]],1e9+5)%M;
}
ans=ans*f[n]%M*pow(f[tot_ma+tot_mi],1e9+5)%M*pow(f[n-tot_ma-tot_mi],1e9+5)%M;
}
printf("%lld\n",ans);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 10, MOD = 1e9 + 7;
inline int qpow(int x, int n) {
int res = 1;
while (n) {
if (n & 1)res = 1ll * res * x % MOD;
x = 1ll * x * x % MOD, n >>= 1;
}
return res;
}
map<int, int> src, snk;
int cnt[2];
int n, a[N];
ll s;
int f[N], inv[N];
int main() {
scanf("%d", &n);
f[0] = 1;
for (int i = 1; i <= n; i++)f[i] = 1ll * f[i - 1] * i % MOD;
for (int i = 0; i <= n; i++)inv[i] = qpow(f[i], MOD - 2);
for (int i = 1; i <= n; i++)scanf("%d", &a[i]), s += a[i];
if (s % n)return puts("0"), 0;
s /= n;
for (int i = 1; i <= n; i++) {
if (a[i] > s)src[a[i]]++, cnt[0]++;
else if (a[i] < s)snk[a[i]]++, cnt[1]++;
}
int ans;
if (cnt[0] <= 1 || cnt[1] <= 1) {
ans = f[n];
for (auto x:src)ans = 1ll * ans * inv[x.second] % MOD;
for (auto x:snk)ans = 1ll * ans * inv[x.second] % MOD;
ans = 1ll * ans * inv[n - cnt[0] - cnt[1]] % MOD;
} else {
ans = 2ll * f[cnt[0]] * f[cnt[1]] % MOD * f[n] % MOD * inv[n - cnt[0] - cnt[1]] % MOD * inv[cnt[0] + cnt[1]] %
MOD;
for (auto x:src)ans = 1ll * ans * inv[x.second] % MOD;
for (auto x:snk)ans = 1ll * ans * inv[x.second] % MOD;
}
printf("%d\n", ans);
return 0;
} |
//the number of balanced permutations
//codeforces1513E
//https://blog.csdn.net/qq_45074215
#include<iostream>
#include<map>
using namespace std;
const int maxn=2e5+10,mod=1e9+7;
int fact[maxn],infact[maxn];
map<int,int>mp;
int qmi(int a,int b)
{
int res=1;
while(b)
{
if(b&1)
res=1ll*res*a%mod;
a=1ll*a*a%mod;
b>>=1;
}
return res;
}
void init()
{
fact[0]=infact[0]=1;
for(int i=1;i<maxn;i++)
{
fact[i]=1ll*fact[i-1]*i%mod;//n!,every step mod
infact[i]=1ll*infact[i-1]*qmi(i,mod-2)%mod;
}
}
int C(int a,int b)//mod of C(a,b)
{
if(a<b)
return 0;
return 1ll*fact[a]*infact[b]%mod*infact[a-b]%mod;
}
int main()
{
//cout<<C(3,0);
init();
int lans=1,rans=1;
int ans=1;
long long sum=0;
int n;
cin>>n;//case number
for(int i=1;i<=n;i++)//element number
{
int x;
cin>>x;
mp[x]++;
sum+=x;
}
int p=sum/n;//result
if(sum%n)
{
puts("0");
return 0;
}
int lcnt=0,rcnt=0;
for(auto item:mp)//auto
{
int x=item.first;
int cnt=item.second;
if(x<p) lans=1ll*lans*infact[cnt]%mod,lcnt+=cnt;
else if(x>p) rans=1ll*rans*infact[cnt]%mod,rcnt+=cnt;
}
lans=1ll*lans*fact[lcnt]%mod;
rans=1ll*rans*fact[rcnt]%mod;
int cnt=lcnt+rcnt+1;
int k=mp[p];
ans=1ll*lans*rans%mod;
if(lcnt==1)
ans=1ll*ans*(rcnt+1)%mod;
else if(rcnt==1)
ans=1ll*ans*(lcnt+1)%mod;
else if(lcnt&&rcnt)
ans=1ll*ans*2%mod;
ans=1ll*C(cnt+k-1,cnt-1)*ans%mod;
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define MOD 1000000007
#define endl "\n"
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(var) (var).begin(), (var).end()
#define sz(x) (int)x.size()
#define MAXX 9000000000000000000
#define pii pair<int,int>
#define vi vector<int>
#define vvi vector<vector<int> >
#define vpi vector<pair<int,int> >
#define vvpi vector<vector<pair<int,int> > >
int gcdExtended(int a, int b, int *x, int *y)
{
if (a == 0)
{
*x = 0, *y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b/a) * x1;
*y = x1;
return gcd;
}
int modInverse(int a)
{
int x, y;
int g = gcdExtended(a, MOD, &x, &y);
if (g != 1)
{
return -1;
}
else
{
int res = (x % MOD + MOD) % MOD;
return res;
}
}
int fact(int x)
{
int ret = 1;
for(int i=1;i<=x;i++)
{
ret *= i;
ret %= MOD;
}
return ret;
}
const int MAXN = 1000006;
int factorial[MAXN], inverse[MAXN];
int powerMOD(int x, int y)
{
if(y == 0)
{
return 1;
}
int res = 1;
if(y & 1)
{
res = x;
}
x *= x;
y /= 2;
x %= MOD;
return (res * powerMOD(x, y)) % MOD;
}
int nCk(int n, int k)
{
if (k < 0 || k > n)
{
return 0;
}
int ans = factorial[n];
ans = (ans * inverse[n - k]) % MOD;
ans = (ans * inverse[k]) % MOD;
return ans;
}
void preCompute()
{
int fact = 1;
factorial[0] = 1;
inverse[0] = 1;
for (int i = 1 ; i < MAXN ; i++)
{
fact = (fact * i) % MOD;
factorial[i] = fact;
inverse[i] = powerMOD(factorial[i], MOD-2);
}
}
// call perCompute()
// call nCk(n, k)
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n,su=0,x;
preCompute();
vi nos;
cin >> n;
for(int i=0;i<n;i++)
{
cin >> x;
su += x;
nos.pb(x);
}
if(su % n)
{
cout << 0 ;
return 0;
}
su /= n;
int le = 0, gr = 0;
map<int, int> ma;
for(auto it : nos)
{
ma[it] += 1;
if(it < su)
{
le += 1;
}
else if(it > su)
{
gr += 1;
}
}
if(le <= 1 || gr <= 1)
{
int ans = fact(n);
for(auto it : ma)
{
ans *= modInverse(fact(it.ss));
ans %= MOD;
}
cout << ans ;
return 0;
}
int ans = 1;
ans = fact(le);
ans *= fact(gr);
ans %= MOD;
int sam = n - le - gr;
ans *= nCk(n, sam);
ans %= MOD;
for(auto it : ma)
{
if(it.ff != su)
{
ans *= modInverse(fact(it.ss));
ans %= MOD;
}
}
cout << ( ans * 2 ) % MOD;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
ll a[100005], n, fact[100005];
ll pow(ll b, ll e) {
if(e == 0) return 1LL;
if(e%2) return 1LL*b*pow(b, e-1)%mod;
return 1LL*pow(b*b%mod, e/2)%mod;
}
ll inv(ll x) {
return pow(x, mod-2);
}
void solve() {
cin >> n;
for(int i = 1; i <= n; i++)
cin >> a[i];
sort(a+1, a+n+1);
ll s = 0;
for(int i = 1; i <= n; i++)
s += a[i];
if(s%n) {
cout << 0;
return;
}
fact[0] = 1;
for(ll i = 1; i <= n; i++)
fact[i] = fact[i-1]*i%mod;
map<ll, int> smaller, bigger;
ll eq = 0, src = 0, snk = 0;
for(int i = 1; i <= n; i++) {
if(a[i] > s/n) {
bigger[a[i]]++;
src++;
} else if(a[i] < s/n) {
smaller[a[i]]++;
snk++;
} else {
eq++;
}
}
if(src <= 1 || snk <= 1) {
ll ans = fact[n];
for(auto x: smaller) ans = (ans*inv(fact[x.second]))%mod;
for(auto x: bigger) ans = (ans*inv(fact[x.second]))%mod;
ans = (ans*inv(fact[eq]))%mod;
cout << ans;
return;
}
ll ans = 2*fact[src]*fact[snk]%mod;
for(auto x: smaller) ans = (ans*inv(fact[x.second]))%mod;
for(auto x: bigger) ans = (ans*inv(fact[x.second]))%mod;
ans = (((ans*fact[n])%mod)*inv(fact[src+snk])%mod)*inv(fact[n-src-snk])%mod;
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
// cin >> t;
while(t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define pii pair<int,int>
#define pll pair<long long, long long >
#define ll long long
#define lcm(a,b) (a)/__gcd((a),(b))*(b)
#define pb push_back
#define sz size()
#define mp make_pair
#define rep(i,n) for(i=0;i<(n);i++)
#define x first
#define y second
#define gap ' '
#define fastio {ios_base::sync_with_stdio(false);cin.tie(NULL);}
#define eps 1e-9
#define maxn 100000
#define MOD 1000000007
#define pi (2.0*acos(0.0))
#define endl '\n'
#define trace(x) cerr << #x << ": " << x << endl;
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define trace3(x, y, z) cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define trace4(a, b, c, d)cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;
bool equalTo ( double a, double b ){ if ( fabs ( a - b ) <= eps ) return true; else return false; }
bool notEqual ( double a, double b ){if ( fabs ( a - b ) > eps ) return true; else return false; }
bool lessThan ( double a, double b ){ if ( a + eps < b ) return true; else return false; }
bool lessThanEqual ( double a, double b ){if ( a < b + eps ) return true; else return false;}
bool greaterThan ( double a, double b ){if ( a > b + eps ) return true;else return false;}
bool greaterThanEqual ( double a, double b ){if ( a + eps > b ) return true;else return false;}
bool check(int mask,int i){return ((1<<i)&mask);}
int Set(int mask,int i){return mask | (1<<i);}
ll add(ll a, ll b)
{
if(a+b<MOD)return a+b;
return (a+b)%MOD;
}
ll mul(ll a, ll b)
{
if(a*b < MOD)return a*b;
return (a*b)%MOD;
}
ll power(ll a, ll b)
{
if(b == 0)return 1;
if(b==1)return a%MOD;
ll p = power(a,b/2);
p = mul(p,p);
if(b%2==0)return p;
return mul(p,a);
}
int dir8[2][8] = {{1,-1,0,0,1,-1,1,-1},{0,0,1,-1,1,-1,-1,1}};
int dir4[2][4] = {{1,-1,0,0},{0,0,1,-1}};
//TEMPLATE ENDS HERE, SO DOES MY WILL TO LIVE
int m,n,row,col;
ll ara[100005];
ll fact[100005];
ll invFact[100005];
void init()
{
fact[0]=1;
invFact[0]=1;
for(ll i=1;i<100005;i++)
{
fact[i] = mul(fact[i-1], i);
invFact[i] = power(fact[i],MOD-2);
}
}
vector<ll>source,sink;
void solve(int test)
{
scanf("%d",&n);
ll sum=0;
ll avg;
for(int i=0;i<n;i++)scanf("%I64d",&ara[i]),sum+=ara[i];
if(sum%(ll)n==0)
{
avg = sum/(ll)n;
ll avgCnt=0,srcCnt=0,snkCnt=0;
for(int i=0;i<n;i++)
{
if(ara[i]<avg)sink.pb(ara[i]);
else if(ara[i]>avg)source.pb(ara[i]);
else avgCnt++;
}
srcCnt = (ll)source.sz;
snkCnt = (ll)sink.sz;
if(srcCnt<=1 || snkCnt <=1)
{
//ans is n!
ll ans = fact[n];
sort(ara,ara+n);
for(ll i=0;i<n;i++)
{
ll j=i+1;
while(j<n&&ara[j]==ara[i])j++;
ans = mul(ans,invFact[j-i]);
i=j-1;
}
printf("%I64d\n",ans);
}
else
{
sort(source.begin(),source.end());
sort(sink.begin(),sink.end());
ll ans = mul(fact[srcCnt],fact[snkCnt]);
for(ll i=0;i<srcCnt;i++)
{
ll j=i+1;
while(j<srcCnt&&source[j]==source[i])j++;
ans = mul(ans,invFact[j-i]);
i=j-1;
}
for(ll i=0;i<snkCnt;i++)
{
ll j=i+1;
while(j<snkCnt&&sink[j]==sink[i])j++;
ans = mul(ans,invFact[j-i]);
i=j-1;
}
ans = mul(ans, 2ll);
ans = mul(ans,fact[srcCnt+snkCnt+avgCnt]);
ans = mul(ans,invFact[srcCnt+snkCnt]);
ans = mul(ans, invFact[avgCnt]);
printf("%I64d\n",ans);
}
}
else printf("0\n");
}
void test()
{
int t=1;
init();
for(int test=1;test<=t;test++)
{
solve(test);
}
}
int main()
{
//freopen("o.txt","w",stdout);
test();
return 0;
}
|
#include <bits/stdc++.h>
#define forn(i,s,t) for(register int i=(s);i<=(t);++i)
#define form(i,s,t) for(register int i=(s);i>=(t);--i)
using namespace std;
typedef long long LL;
const int N = 1e5 + 3, Mod = 1e9 + 7;
struct Mint {
int res;
Mint() {res = 0;}
Mint(int a) : res(a) {}
friend Mint operator + (Mint A, Mint B) {
return (A.res + B.res >= Mod) ? (A.res + B.res - Mod) : (A.res + B.res);
}
friend Mint& operator += (Mint& A, Mint B) {return A = A + B;}
friend Mint operator - (Mint A, Mint B) {B.res = Mod - B.res; return A + B;}
friend Mint& operator -= (Mint& A, Mint B) {return A = A - B;}
friend Mint operator * (Mint A, Mint B) {return 1ll * A.res * B.res %Mod;}
friend Mint& operator *= (Mint& A, Mint B) {return A = A * B;}
friend Mint operator ~ (Mint A) {
static Mint res; res = Mint(1);
static int k; k = Mod - 2;
for(;k;k>>=1, A*=A) (k&1) && (res = res * A, 0);
return res;
}
};
Mint fac[N], ifac[N];
inline Mint C(int n, int k) {return fac[n] * ifac[k] * ifac[n - k];}
int n, a[N];
int main() {
scanf("%d", &n);
LL sum = 0;
forn(i,1,n) scanf("%d", a + i), sum += a[i];
if(sum % n) return puts("0"), 0;
sort(a + 1, a + n + 1);
LL res = sum / n;
int Lpos, Rpos;
forn(i,1,n) if(a[i] >= res) {Lpos = i - 1; break ;}
form(i,n,1) if(a[i] <= res) {Rpos = i + 1; break ;}
fac[0] = Mint(1);
forn(i,1,n) fac[i] = fac[i - 1] * Mint(i);
ifac[n] = ~fac[n];
form(i,n - 1,0) ifac[i] = ifac[i + 1] * Mint(i + 1);
if(Lpos <= 1 || n - Rpos + 1 <= 1) {
Mint ans = fac[n];
int lst = 1;
forn(i,2,n) if(a[i] != a[i - 1]) ans *= ifac[i - lst], lst = i;
ans *= ifac[n + 1 - lst];
return printf("%d\n", ans.res), 0;
}
Mint ans = Mint(1);
int lst = 1;
forn(i,2,Lpos) if(a[i] != a[i - 1]) ans *= ifac[i - lst], lst = i;
ans *= ifac[Lpos - lst + 1], lst = Rpos;
forn(i,Rpos,n) if(a[i] != a[i - 1]) ans *= ifac[i - lst], lst = i;
ans *= ifac[n - lst + 1], lst = Lpos + 1;
forn(i,Lpos + 1,Rpos - 1) if(a[i] != a[i - 1]) ans *= ifac[i - lst], lst = i;
if(Lpos + 1 <= Rpos - 1) ans *= ifac[Rpos - lst];
ans *= Mint(2) * fac[Lpos] * fac[n - Rpos + 1] * fac[max(Rpos - Lpos - 1, 0)] * C(n, Rpos - Lpos - 1);
printf("%d\n", ans.res);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define scan(x) do{while((x=getchar())<'0'); for(x-='0'; '0'<=(_=getchar()); x=(x<<3)+(x<<1)+_-'0');}while(0)
char _;
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define ALL(a,n) a,a+n
#define ALLV(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=int(b); ++i)
#define rFOR(i,a,b) for(int i=a; i>=int(b); --i)
typedef long long ll;
typedef pair<int,int> pii;
const int maxN = 100005;
const int INF = (int)2e9;
const int mod = 1000000007;
ll fact[maxN], finv[maxN];
ll fast_pow(ll a, ll b){
if(b==0) return 1;
if(b==1) return a;
if(b%2) return (a*fast_pow((a*a)%mod, b/2))%mod;
return fast_pow((a*a)%mod, b/2);
}
void solve(){
int n; cin >> n;
vector<int> a(n);
ll m = 0;
map<int,int> hist;
REP(i, n){
cin >> a[i];
m += a[i];
++hist[a[i]];
}
if(m%n){
cout << "0\n";
return;
}
m /= n;
ll s = 0;
ll b = 0;
ll e = 0;
for(int x : a){
if(x<m) ++s;
else if(x>m) ++b;
else ++e;
}
fact[0] = 1;
FOR(i, 1, n) fact[i] = (fact[i-1]*i)%mod;
finv[n] = fast_pow(fact[n], mod-2);
rFOR(i, n-1, 0) finv[i] = (finv[i+1]*(i+1))%mod;
ll ans = fact[e];
if(b<2 || s<2) ans = (ans*fact[s+b]) % mod;
else{
ans = (ans*fact[s]) % mod;
ans = (ans*fact[b]) % mod;
ans = (ans*2) % mod;
}
ans = (ans*fact[n]) % mod;
ans = (ans*finv[e]) % mod;
ans = (ans*finv[b+s]) % mod;
for(pii p : hist){
ans = (ans*finv[p.second]) % mod;
}
cout << ans << "\n";
}
int main(){
cin.sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 2e5+10;
const int MOD = 1e9+7;
ll fact[N];
ll inv[N];
int a[N];
ll C(int n, int m) {
return fact[n] * inv[m] % MOD * inv[n-m] % MOD;
}
void init() {
fact[0] = inv[0] = 1;
fact[1] = inv[1] = 1;
for (int i = 2; i < N; i++) {
fact[i] = fact[i-1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;
}
for (int i = 2; i < N; i++) {
inv[i] = inv[i] * inv[i-1] % MOD;
assert(inv[i] * fact[i] % MOD == 1);
}
}
void solve() {
int n;
scanf("%d", &n);
ll sum = 0;
for (int i = 1; i <= n; i++) scanf("%d", a+i), sum += a[i];
if (sum % n) {
printf("0\n");
return ;
}
map<int, int> mp;
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= n; i++) {
int t = a[i] - sum/n;
mp[t]++;
cnt1 += (t > 0);
cnt2 += (t < 0);
}
ll ans = 1;
if (cnt1 <= 1 || cnt2 <= 1) {
ans = fact[n];
for (auto i : mp) {
ans = ans * inv[i.second] % MOD;
}
} else {
ans = 2LL * fact[cnt1] * fact[cnt2] % MOD;
for (auto i : mp) {
if (i.first) ans = ans * inv[i.second] % MOD;
}
ans = ans * C(n, cnt1+cnt2) % MOD;
}
printf("%lld\n", ans);
}
int main() {
init();
int T = 1;
// scanf("%d", &T);
while (T--) solve();
} |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9+7;
long long power(long long x, long long y, long long m)
{
if (y == 0)
return 1;
long long p = power(x, y/2, m) % m;
p = (p * p) % m;
return (y%2 == 0)? p : (x * p) % m;
}
long long modInverse(long long a)
{
return power(a, mod-2, mod);
}
long long fact(int n){
long long res = 1;
for(long long i=1;i<=n;i++)
res = (res*i)%mod;
return res;
}
long long perm(vector<int> &v, int arr[])
{
map<int,int> mp;
for(auto i:v)
mp[arr[i]]++;
long long res = fact((int)v.size());
for(auto pr:mp){
res = (res*modInverse(fact(pr.second)))%mod;
}
return res;
}
long long nCr(int n, int r){
long long num = fact(n);
long long denom = fact(r)*fact(n-r)%mod;
return num*modInverse(denom)%mod;
}
int main()
{
int n;
cin>>n;
long long sum = 0;
long long denom = n;
int arr[n];
for(int i=0;i<n;i++)
cin>>arr[i], sum += arr[i];
if(sum%denom != 0)
cout<<0<<endl;
else
{
vector<int> source;
vector<int> sink;
for(int i=0;i<n;i++)
{
if(arr[i] < sum/denom)
sink.push_back(i);
else if(arr[i] > sum/denom)
source.push_back(i);
}
if(sink.size() <= 1 || source.size() <= 1){
vector<int> v(n);
for(int i=0;i<n;i++)
v[i] = i;
cout<<perm(v, arr)<<endl;
} else
{
int c1 = source.size();
int c2 = sink.size();
long long ans = nCr(n,c1+c2);
cout<<2*perm(source, arr)%mod*perm(sink, arr)%mod*ans%mod<<endl;
}
}
return 0;
} |
//頑張って
#include <bits/stdc++.h>
#define ff first
#define ss second
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
#define all(x) x.begin(), x.end()
const int mxn = 1e5 + 10;
const ll mod = 1e9 + 7;
ll fact[mxn] = {1};
ll finv[mxn] = {1};
ll binom(ll n, ll r) {
if (n < r || r < 0) return 0;
return fact[n] * finv[r] % mod * finv[n - r] % mod;
}
ll mod_exp(ll a, ll n) {
if (a < 0ll) return 0;
if (n < 0ll) return 0;
ll res = 1ll;
while (n > 0) {
if (n & 1) res = (res * a) % mod;
a = (a * a) % mod;
n = n >> 1;
}
return res;
}
void solve() {
int n;
cin >> n;
vector <ll> a(n);
for (auto &i : a)
cin >> i;
ll sm = accumulate(all(a), 0ll), p = 0, q = 0, r = 0, res = 0, tm = 1;
if (sm % n != 0) {
cout << 0 << '\n';
return;
}
sm /= n;
map <int, int> pos, neg, zeo;
for (int i = 0; i < n; i++) {
if (a[i] > sm)
pos[a[i]]++, p++;
if (a[i] < sm)
neg[a[i]]++, q++;
if (a[i] == sm)
zeo[a[i]]++, r++;
}
for (auto i : pos)
(tm *= fact[i.ss]) %= mod;
for (auto i : neg)
(tm *= fact[i.ss]) %= mod;
for (auto i : zeo)
(tm *= fact[i.ss]) %= mod;
if (p < 2 || q < 2) {
cout << (fact[p + q + r] * mod_exp(tm, mod - 2)) % mod << '\n';
return;
}
res = (((fact[p] * fact[q]) % mod * fact[r]) % mod * mod_exp(tm, mod - 2)) % mod;
(res *= binom(p + q + r, r)) %= mod;
cout << (res * 2) % mod << '\n';
}
int main() {
#ifndef ONLINE_JUDGE
freopen("inp.txt", "r", stdin); freopen("outp.txt", "w", stdout);
#endif
ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
for (int i = 1; i < mxn; i++)
fact[i] = (fact[i - 1] * i) % mod;
for (int i = 0; i < mxn; i++)
finv[i] = mod_exp(fact[i], mod - 2);
solve();
return 0;
} |
#include <bits/stdc++.h>
#define ull unsigned long long
#define ll long long
#define endl '\n'
#define line cout<<"--------------------------"<<endl
#define dd(x) cout<<#x<<" = "<<x<<' '
#define sz(v) (ll)v.size()
#define srt(v) sort(v.begin(),v.end())
#define rsrt(v) sort(v.rbegin(),v.rend())
#define all(v) v.begin(),v.end()
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)
#define filein freopen("input.txt","r",stdin)
#define fileout freopen("output.txt","w",stdout)
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const ll mx=2e5+5;
void yes() {cout<<"Yes"<<endl; }
ll ara[mx];
ll facto[mx],invfacto[mx];
void pre()
{
facto[0]=1;
for(ll i=1;i<mx;i++) facto[i]=(facto[i-1]*i)%mod;
invfacto[0]=1;
invfacto[1]=1;
for(ll i=2;i<mx;i++)
{
invfacto[i]=mod-(mod/i)*invfacto[mod%i]%mod; ///pre calculate mod inverse i
}
for(ll i=1;i<mx;i++) invfacto[i]=(invfacto[i-1]*invfacto[i])%mod; ///precalculate inverse factorial
}
ll ncr(ll n, ll r)
{
if(r>n) return 0;
ll ans=facto[n]*invfacto[n-r];
ans%=mod;
ans=(ans*invfacto[r])%mod;
return ans;
}
int main()
{
fast;
pre();
ll n;
cin>>n;
ll sum=0;
for(ll i=0;i<n;i++)
{
cin>>ara[i];
sum+=ara[i];
}
if(sum%n) cout<<0<<endl;
else
{
sum/=n;
ll src=0,snk=0;
map<ll,ll> m_src,m_snk,m_nutral;
for(ll i=0;i<n;i++)
{
if(ara[i]>sum) src++,m_src[ara[i]]++;
else if(ara[i]<sum) snk++,m_snk[ara[i]]++;
else m_nutral[ara[i]]++;
}
if(src<=1 or snk<=1)
{
ll ans=facto[n];
for(auto x: m_src)
{
ans=(ans*invfacto[x.second])%mod;
}
for(auto x: m_snk)
{
ans=(ans*invfacto[x.second])%mod;
}
for(auto x: m_nutral)
{
ans=(ans*invfacto[x.second])%mod;
}
cout<<ans<<endl;
}
else
{
ll ans=2*facto[src];
for(auto x: m_src)
{
ans=(ans*invfacto[x.second])%mod;
}
ans=(ans*facto[snk])%mod;
for(auto x: m_snk)
{
ans=(ans*invfacto[x.second])%mod;
}
ans=(ans*ncr(n,src+snk))%mod;
cout<<ans<<endl;
}
}
}
|
#include<bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int,int> pii;
typedef pair<LL,LL> pLL;
typedef pair<double,double> pdd;
const int N=2e5+5;
const int M=2e5+5;
const int inf=1e9+5;
const LL mod=1e9+7;
const double eps=1e-8;
const long double pi=acos(-1.0L);
#define ls (i<<1)
#define rs (i<<1|1)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define mk make_pair
#define mem(a,b) memset(a,b,sizeof(a))
LL read()
{
LL x=0,t=1;
char ch;
while(!isdigit(ch=getchar())) if(ch=='-') t=-1;
while(isdigit(ch)){ x=10*x+ch-'0'; ch=getchar(); }
return x*t;
}
LL g[N],f[N],a[N];
LL fp(LL x,LL y)
{
LL res=1;
while(y)
{
if(y&1) res=res*x%mod;
x=x*x%mod;
y>>=1;
}
return res;
}
void init()
{
int n=1e5;
f[0]=1;
for(int i=1;i<=n;i++) f[i]=i*f[i-1]%mod;
g[n]=fp(f[n],mod-2);
for(int i=n-1;i>=0;i--) g[i]=(i+1)*g[i+1]%mod;
}
int main()
{
init();
int n=read();
for(int i=1;i<=n;i++) a[i]=read();
LL sum=0,s=0,t=0;
for(int i=1;i<=n;i++) sum+=a[i];
if(sum%n) return 0*printf("0\n");
for(int i=1;i<=n;i++)
{
if(a[i]<sum/n) s++;
else if(a[i]>sum/n) t++;
}
LL ans;
sort(a+1,a+n+1);
if(s==0&&t==0) ans=1;
else if(s==1||t==1) {
ans=f[n];
int cnt=0;
for(int i=1;i<=n;i++)
if(a[i]==a[i-1]) cnt++;
else ans=ans*g[cnt]%mod,cnt=1;
ans=ans*g[cnt]%mod;
}
else{
ans=f[s]*f[t]%mod;
int cnt=0;
for(int i=1;i<=n&&a[i]<sum/n;i++)
{
if(a[i]==a[i-1]) cnt++;
else {
ans=ans*g[cnt]%mod;
cnt=1;
}
}
ans=ans*g[cnt]%mod;
cnt=0;
for(int i=n;i&&a[i]>sum/n;i--)
if(a[i]==a[i+1]) cnt++;
else ans=ans*g[cnt]%mod,cnt=1;
ans=ans*g[cnt]%mod;
ans=ans*2%mod*f[n]%mod*g[n-s-t]%mod*g[s+t]%mod;
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long P[300010];
constexpr long long mod = 1e9 + 7;
long long fpow(long long a, long long b)
{
long long z = 1;
while (b)
{
if (b & 1)
z = z * a % mod;
a = a * a % mod;
b >>= 1;
}
return z;
}
long long inv(long long x)
{
return fpow(x, mod - 2);
}
long long C(int t, int b)
{
return P[b] * inv(P[t]) % mod * inv(P[b - t]) % mod;
}
long long A(int t, int b)
{
return P[b] * inv(P[b - t]);
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
P[0] = 1;
for (int i = 1; i < 300005; i++)
{
P[i] = P[i - 1] * i % mod;
}
int n;
cin >> n;
vector<long long> a(n);
long long sum = 0;
for (long long &x : a)
{
cin >> x;
sum += x;
}
if (sum % n != 0)
{
cout << 0 << endl;
return 0;
}
long long ave = sum / n;
int sso = 0, ssi = 0;
map<long long, int> so, si;
for (long long x : a)
{
if (x > ave)
{
so[x]++;
sso++;
}
else if (x < ave)
{
si[x]++;
ssi++;
}
}
if (sso > 1 && ssi > 1)
{
long long ans = P[sso] * P[ssi] % mod;
for (auto [v, k] : so)
{
ans = ans * inv(P[k]) % mod;
}
for (auto [v, k] : si)
{
ans = ans * inv(P[k]) % mod;
}
ans = ans * C(ssi + sso, n) % mod;
cout << 2*ans%mod << endl;
}
else {
long long ans=P[n]%mod;
for (auto [v, k] : so)
{
ans = ans * inv(P[k]) % mod;
}
for (auto [v, k] : si)
{
ans = ans * inv(P[k]) % mod;
}
ans=ans*inv(P[n-ssi-sso])%mod;
cout<<ans<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int p=1e9+7;
const int maxn=2e5+5;
int fact[maxn];
int invf[maxn];
int po(int a,int b)
{
if(b==0) return 1;
if(b==1) return a;
if(b%2==0)
{
int u=po(a,b/2);
return (u*u)%p;
}
else
{
int u=po(a,b-1);
return (a*u)%p;
}
}
int inv(int x) {return po(x,p-2);}
int c(int n,int k)
{
int ans=fact[n];
ans*=invf[k];
ans%=p;
ans*=invf[n-k];
ans%=p;
return ans;
}
int32_t main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int u=1;
for(int i=0;i<maxn;++i)
{
fact[i]=u;
invf[i]=inv(fact[i]);
u*=(i+1);
u%=p;
}
int n;
cin>>n;
int a[n];
int sum=0;
for(int i=0;i<n;++i) {cin>>a[i];sum+=a[i];}
if((sum%n)!=0)
{
cout<<0;
return 0;
}
int c1=0,c2=0;
vector <int> v1,v2;
for(int i=0;i<n;++i)
{
if(a[i]>(sum/n)) {++c1;v1.push_back(a[i]);}
else if(a[i]<(sum/n)) {++c2;v2.push_back(a[i]);}
}
map <int,int> o1;
vector <int> keys1;
for(auto h:v1)
{
if(o1.count(h)) o1[h]++;
else {o1[h]=1;keys1.push_back(h);}
}
map <int,int> o2;
vector <int> keys2;
for(auto h:v2)
{
if(o2.count(h)) o2[h]++;
else {o2[h]=1;keys2.push_back(h);}
}
int res1=1;
for(auto l1:keys1) {res1*=invf[o1[l1]];res1%=p;}
for(auto l2:keys2) {res1*=invf[o2[l2]];res1%=p;}
int o=c(n,c1+c2);
o*=fact[c1];
o%=p;
o*=fact[c2];
o%=p;
o*=res1;
o%=p;
int ans;
if(c1>=2 && c2>=2)
{
ans=2;
}
else if(c1==0 && c2==0)
{
ans=1;
}
else
{
assert(c1!=0 && c2!=0);
ans=(c1+c2);
}
cout<<(ans*o)%p;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<ll, ll, ll> tll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
#define FOR(i, a, b) for (ll (i) = (a); (i) <= (b); (i)++)
#define ROF(i, a, b) for (ll (i) = (a); (i) >= (b); (i)--)
#define REP(i, n) FOR(i, 0, (n)-1)
#define sqr(x) ((x) * (x))
#define all(x) (x).begin(), (x).end()
#define reset(x, y) memset(x, y, sizeof(x))
#define pb push_back
#define eb emplace_back
#define em emplace
#define mp make_pair
#define chkmin(a, b) a = min(a, b)
#define chkmax(a, b) a = max(a, b)
#define FILL0(arr) memset(arr, 0, sizeof(arr))
#define ln cout << endl;
// Can I use this?
#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(...)
#define err(...)
#endif
// end
template <typename T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using MaxHeap = priority_queue<T>;
const ld PI = 3.14159265358979323846;
const ld E = 2.718281828459;
const ll MOD = 1e9+7;
ll M(ll n) {return (n % MOD + MOD) % MOD;}
ll fastPow(ll num, ll exp) {
if (exp == 0) return 1;
if (exp == 1) return num;
else {
ll half = fastPow(num, exp/2);
if (exp % 2 == 1)
return sqr(half)%MOD * num % MOD;
else
return sqr(half)%MOD;
}
}
// number theory
ll getInv(ll y) {return fastPow(y, MOD-2)%MOD;}
// factor precalculation
const ll FAC_SIZE = 1e5+3;
ll fac[FAC_SIZE], inv[FAC_SIZE];
void initFac(ll sz) {
fac[0] = 1, inv[0] = 1;
FOR(i, 1, sz-1) fac[i] = fac[i-1]*i%MOD;
inv[FAC_SIZE-1] = getInv(fac[FAC_SIZE-1]);
ROF(i, sz-2, 1) inv[i] = inv[i+1]*(i+1)%MOD;
}
// combinatorics
ll comb(ll x, ll y) { // select y from x
if (x < y) return 0;
return fac[x] * inv[y]%MOD * inv[x-y]%MOD;
}
int main(int argn, char **argv) {
ios::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
initFac(FAC_SIZE);
int T = 1;
// cin >> T;
REP(I, T) {
ll n; cin >> n;
vl a(n); ll sum = 0;
map<ll, ll> ma;
REP(i, n) {
cin >> a[i];
ma[a[i]]++;
sum += a[i];
}
ll offset = 1;
for (auto [key, val] : ma) {
offset = (offset * inv[val])%MOD;
}
bool can = true; ll avg = sum / n;
if (avg * n != sum) can = false;
const ll SOURCE = 0, SINK = 1, FREE = 2;
ll source = 0, sink = 0, free = 0;
vl stat(n);
REP(i, n) {
if (a[i] > avg) stat[i] = SOURCE, source++;
if (a[i] < avg) stat[i] = SINK, sink++;
if (a[i] == avg) stat[i] = FREE, free++;
}
ll ans;
if (source <= 1 || sink <= 1) {
ans = fac[n];
} else {
ans = (fac[n] * inv[n-free])%MOD;
ans = (ans * fac[source])%MOD;
ans = (ans * fac[sink])%MOD;
ans = (ans * 2)%MOD;
}
if (can) {
cout << (ans * offset)%MOD << endl;
} else {
cout << 0 << endl;
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=100000,mod=1000000007;
int add(int a,int b,int p=mod){return a+b>=p?a+b-p:a+b;}
int sub(int a,int b,int p=mod){return a-b<0?a-b+p:a-b;}
int mul(int a,int b,int p=mod){return 1LL*a*b%p;}
void sadd(int &a,int b,int p=mod){a=add(a,b,p);}
void ssub(int &a,int b,int p=mod){a=sub(a,b,p);}
void smul(int &a,int b,int p=mod){a=mul(a,b,p);}
int n;
LL a[N+9],mid;
map<int,int>mp;
void into(){
scanf("%d",&n);
for (int i=1;i<=n;++i){
scanf("%lld",&a[i]);
mid+=a[i];
++mp[a[i]];
}
}
int inv[N+9],fac[N+9],ifac[N+9];
void Get_inv(){
inv[1]=1;
fac[0]=fac[1]=1;
ifac[0]=ifac[1]=1;
for (int i=2;i<=n;++i){
inv[i]=mul(mod-mod/i,inv[mod%i]);
fac[i]=mul(fac[i-1],i);
ifac[i]=mul(ifac[i-1],inv[i]);
}
}
int Get_c(int n,int m){return n<m||m<0?0:mul(fac[n],mul(ifac[m],ifac[n-m]));}
int ans;
void Get_ans(){
if (mid/n*n^mid) return;
mid/=n;
int c0=0,c1=0,c2=0;
for (int i=1;i<=n;++i) a[i]==mid?++c1:a[i]<mid?++c0:++c2;
if (!c0||!c2) ans=fac[n];
else{
ans=mul(2,mul(fac[c0],fac[c2]));
if (c0==1) sadd(ans,mul(c2-1,fac[c2]));
if (c2==1) sadd(ans,mul(c0-1,fac[c0]));
smul(ans,mul(Get_c(n,c1),fac[c1]));
}
for (map<int,int>::iterator it=mp.begin();it!=mp.end();++it) smul(ans,ifac[it->second]);
}
void work(){
Get_inv();
Get_ans();
}
void outo(){
printf("%d\n",ans);
}
int main(){
int T=1;
//scanf("%d",&T);
for (;T--;){
into();
work();
outo();
}
return 0;
} |
#include<bits/stdc++.h>
#define pb push_back
#define int long long
using namespace std;
const int mod = 1e9+7,siz = 1e6+5;
int t,n,m,x,pos,k,a[siz],fact[siz];
/*
when calculating numbers that are going to be powers mod them with (mod-1)
*/
int bix(int a,int n)
{
if(n == 0) return 1;
if(n&1) return a*bix(a,n-1)%mod;
int x = bix(a,n/2);
return x*x%mod;
}
int div(int x)
{
int ret = bix(x,mod-2);
return ret;
}
void pre()
{
fact[0] = 1;
for(int i = 1;i<siz;i++) fact[i] = (fact[i-1]*i)%mod;
}
int ncr(int n,int r)
{
if(r>n or n<0) return 0;
if(n == 0 and r == 0) return 1;
int ret = fact[n];
(ret*=bix(fact[r],mod-2))%=mod;
(ret*=bix(fact[n-r],mod-2))%=mod;
return ret;
}
int32_t main(){
ios_base::sync_with_stdio(0); cin.tie(0);
pre();
cin>>n;
int x = 0;
for(int i = 1;i<=n;i++) cin>>a[i],x+=a[i];
if(x%n!=0) return cout<<0<<endl,0;
x/=n;
vector<int>pos,neg;
int zer = 0;
for(int i = 1;i<=n;i++)
{
a[i]-=x;
if(a[i]>0) pos.pb(a[i]);
else if(a[i]<0) neg.pb(a[i]);
else zer++;
}
if(zer == n) return cout<<1<<endl,0;
/// handle cases for only 1 pos or only 1 neg
int places = pos.size()+neg.size()+1;
int ways = ncr(n,zer);
map<int,int>mp1,mp2;
for(auto x:pos) mp1[x]++;
for(auto x:neg) mp2[x]++;
if(pos.size() == 1)
{
int cur = 1;
(cur*=fact[neg.size()])%=mod;
for(auto x:mp2) (cur*=div(fact[x.second]))%=mod;
(cur*=(neg.size()+1))%=mod;
(ways*=cur)%=mod; cout<<ways<<endl;
return 0;
}
if(neg.size() == 1)
{
int cur = 1;
(cur*=fact[pos.size()])%=mod;
for(auto x:mp1) (cur*=div(fact[x.second]))%=mod;
(cur*=(pos.size()+1))%=mod;
(ways*=cur)%=mod; cout<<ways<<endl;
return 0;
}
int cur = 1;
cur = fact[pos.size()];
for(auto x:mp1) (cur*=div(fact[x.second]))%=mod;
(cur*=fact[neg.size()])%=mod;
for(auto x:mp2) (cur*=div(fact[x.second]))%=mod;
(cur*=2)%=mod;
(ways*=cur)%=mod;
cout<<ways<<endl;
} |
// Black lives matter
#include <bits/stdc++.h>
/// 500 485 462 A4
using namespace std;
typedef long long int ll;
typedef complex<double> point;
typedef long double ld;
#define pb push_back
#define pii pair < ll , ll >
#define F first
#define S second
//#define endl '\n'
#define int long long
#define sync ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#define kill(x) return cout<<x<<'\n', 0;
const int N=2e5+100;
ll mod=1e9+7;
ll a[N];
ll fac[N],fm[N];
ll power(ll n,ll k){
if (k==0) return 1;
if (k%2==1){
ll x=power(n,k/2);
return x*x%mod*n%mod;
}
ll x=power(n,k/2);
return x*x%mod;
}
ll ent(ll k,ll n){
if (k==0 || k==n) return 1;
return fac[n]*fm[k]%mod*fm[n-k]%mod;
}
map <int,int> mp;
int32_t main(){
sync;
ll n;
cin >> n;
fac[0]=1;
for (int i=1;i<N;i++) fac[i]=fac[i-1]*i%mod,fm[i]=power(fac[i],mod-2);
ll cnt=0;
for (int i=1;i<=n;i++) cin >> a[i],cnt+=a[i];
if (cnt%n!=0) kill(0);
cnt/=n;
ll t=0;
ll v=0,u=0;
for (int i=1;i<=n;i++){
if (a[i]==cnt) t++;
if (a[i]>cnt) v++;
if (a[i]<cnt) u++;
}
ll ans=1;
for (int i=1;i<=n;i++){
mp[a[i]]++;
ans*=power(mp[a[i]],mod-2);
ans%=mod;
}
ans*=ent(t,n)*fac[t]%mod;
if (t==n) kill(1);
ans%=mod;
if (v==1 || u==1){
ans*=(u+v)*fac[u]%mod*fac[v]%mod;
kill(ans%mod);
}
ans*=fac[u]*fac[v]%mod*2%mod;
kill(ans%mod);
}
|
/*AUTHOR - LAKSHYA JAIN*/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define vi vector<int>
#define vl vector<long long>
#define vll vector<pair<long long,long long>>
#define vii vector<pair<int,int>>
#define vvi vector<vector<int>>
#define maxq(x) priority_queue<x>
#define minq(x) priority_queue<x,vector<x>,greater<x>>
#define graph map<int,vi>
#define vvl vector<vector<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 f first
#define s second
#define pii pair<int,int>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i = a;i>=b;i--)
#define mem1(a) memset(a,-1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
#define ppc __builtin_popcount
#define ppcll __builtin_popcountll
# define quick ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
vl fact;
ll fast_mod_exp(ll a, ll b, ll m) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = (res * a) % m;
a = (a * a) % m;
b = b >> 1;
}
return res;
}
ll mod_inverse(ll a, ll m) {
return fast_mod_exp(a, m - 2, m);
}
ll ncr(ll n, ll r, ll p) {
if (r == 0)
return 1;
if(r>n)
return 0;
return ((fact[n] * mod_inverse(fact[n - r], p)) % p * mod_inverse(fact[r], p)) % p;
}
int main()
{
quick
int t = 1;
//cin>>t;
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
while(t--)
{
int n;
cin>>n;
ll a[n];
ll sum = 0;
rep(i,0,n)
{
cin>>a[i];
sum += a[i];
}
if(sum%n)
{
cout<<0;
continue;
}
ll x = sum/n;
int src = 0,snk = 0,perf = 0;
map<int,ll> m1,m2,m3;
ll mod= 1e9 + 7;
fact = vl(n + 1,1);
rep(i,1,n + 1)
fact[i] = fact[i - 1]*i%mod;
rep(i,0,n)
{
if(a[i]>x)
{
src++;
m1[a[i]]++;
}
else if(a[i] == x)
{
perf++;
m3[a[i]]++;
}
else
{
snk++;
m2[a[i]]++;
}
}
if(snk<=1 || src <= 1)
{
ll ans = fact[n];
for(auto x : m1)
ans = (ans*mod_inverse(fact[x.s],mod))%mod;
for(auto x : m2)
ans = (ans*mod_inverse(fact[x.s],mod))%mod;
for(auto x : m3)
ans = (ans*mod_inverse(fact[x.s],mod))%mod;
cout<<ans;
continue;
}
ll A = fact[src];
for(auto x : m1)
{
A = (A*mod_inverse(fact[x.s],mod))%mod;
}
ll B = fact[snk];
for(auto x : m2)
{
B = (B*mod_inverse(fact[x.s],mod))%mod;
}
ll C = ncr(n,perf,mod);
ll ans = ((((2*A)%mod)*C)%mod)*B%mod;
cout<<ans<<endl;
}
return 0;
} |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cassert>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <string>
#include <algorithm>
#include <utility>
#include <complex>
#define rep(x, s, t) for(llint (x) = (s); (x) <= (t); (x)++)
#define reps(x, s) for(llint (x) = 0; (x) < (llint)(s).size(); (x)++)
#define chmin(x, y) (x) = min((x), (y))
#define chmax(x, y) (x) = max((x), (y))
#define sz(x) ((ll)(x).size())
#define ceil(x, y) (((x)+(y)-1) / (y))
#define all(x) (x).begin(),(x).end()
#define outl(...) dump_func(__VA_ARGS__)
#define inf 1e18
using namespace std;
typedef long long llint;
typedef long long ll;
typedef pair<ll, ll> P;
struct edge{
ll to, cost;
edge(){}
edge(ll a, ll b){ to = a, cost = b;}
};
const ll dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
const ll mod = 1000000007;
//const ll mod = 998244353;
struct mint{
ll x = 0;
mint(ll y = 0){x = y; if(x < 0 || x >= mod) x = (x%mod+mod)%mod;}
mint(const mint &ope) {x = ope.x;}
mint operator-(){return mint(-x);}
mint operator+(const mint &ope){return mint(x) += ope;}
mint operator-(const mint &ope){return mint(x) -= ope;}
mint operator*(const mint &ope){return mint(x) *= ope;}
mint operator/(const mint &ope){return mint(x) /= ope;}
mint& operator+=(const mint &ope){
x += ope.x;
if(x >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint &ope){
x += mod - ope.x;
if(x >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint &ope){
x *= ope.x, x %= mod;
return *this;
}
mint& operator/=(const mint &ope){
ll n = mod-2; mint mul = ope;
while(n){
if(n & 1) *this *= mul;
mul *= mul;
n >>= 1;
}
return *this;
}
mint inverse(){return mint(1) / *this;}
bool operator ==(const mint &ope){return x == ope.x;}
bool operator !=(const mint &ope){return x != ope.x;}
};
mint modpow(mint a, ll n){
if(n == 0) return mint(1);
if(n % 2) return a * modpow(a, n-1);
else return modpow(a*a, n/2);
}
istream& operator >>(istream &is, mint &ope){
ll t; is >> t, ope.x = t;
return is;
}
ostream& operator <<(ostream &os, mint &ope){return os << ope.x;}
ostream& operator <<(ostream &os, const mint &ope){return os << ope.x;}
bool exceed(ll x, ll y, ll m){return x >= m / y + 1;}
void mark(){ cout << "*" << endl; }
void yes(){ cout << "Yes" << endl; }
void no(){ cout << "No" << endl; }
ll gcd(ll a, ll b){if(b == 0) return a; return gcd(b, a%b);}
ll digitnum(ll x, ll b = 10){ll ret = 0; for(; x; x /= b) ret++; return ret;}
ll digitsum(ll x, ll b = 10){ll ret = 0; for(; x; x /= b) ret += x % b; return ret;}
template<typename T>
ostream& operator << (ostream& os, vector<T>& vec) {
for(int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
}
return os;
}
template<typename T>
ostream& operator << (ostream& os, deque<T>& deq) {
for(int i = 0; i < deq.size(); i++) {
os << deq[i] << (i + 1 == deq.size() ? "" : " ");
}
return os;
}
template<typename T, typename U>
ostream& operator << (ostream& os, pair<T, U>& pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
template<typename T, typename U>
ostream& operator << (ostream& os, const pair<T, U>& pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
template<typename T, typename U>
ostream& operator << (ostream& os, map<T, U>& map_var) {
for(typename map<T, U>::iterator itr = map_var.begin(); itr != map_var.end(); itr++) {
os << "(" << itr->first << ", " << itr->second << ")";
itr++;
if(itr != map_var.end()) os << ",";
itr--;
}
return os;
}
template<typename T>
ostream& operator << (ostream& os, set<T>& set_var) {
for(typename set<T>::iterator itr = set_var.begin(); itr != set_var.end(); itr++) {
os << *itr;
++itr;
if(itr != set_var.end()) os << " ";
itr--;
}
return os;
}
template<typename T>
ostream& operator << (ostream& os, multiset<T>& set_var) {
for(typename multiset<T>::iterator itr = set_var.begin(); itr != set_var.end(); itr++) {
os << *itr;
++itr;
if(itr != set_var.end()) os << " ";
itr--;
}
return os;
}
template<typename T>
void outa(T a[], ll s, ll t)
{
for(ll i = s; i <= t; i++){ cout << a[i]; if(i < t) cout << " ";}
cout << endl;
}
void dump_func() {cout << endl;}
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&... tail) {
cout << head;
if(sizeof...(Tail) > 0) cout << " ";
dump_func(std::move(tail)...);
}
const int FACT_MAX = 200005;
mint fact[FACT_MAX], fact_inv[FACT_MAX];
void make_fact()
{
mint val = 1;
fact[0] = 1;
for(int i = 1; i < FACT_MAX; i++){
val *= i;
fact[i] = val;
}
fact_inv[FACT_MAX-1] = fact[FACT_MAX-1].inverse();
for(int i = FACT_MAX-2; i >= 0; i--){
fact_inv[i] = fact_inv[i+1] * (i+1);
}
}
mint comb(ll n, ll k)
{
mint ret = 1;
ret *= fact[n];
ret *= fact_inv[k];
ret *= fact_inv[n-k];
return ret;
}
struct UnionFind{
int size;
vector<int> parent;
vector<int> rank;
vector<llint> v, e;
UnionFind(){}
UnionFind(int size){
this->size = size;
parent.resize(size+1);
rank.resize(size+1);
v.resize(size+1);
e.resize(size+1);
init();
}
void init(){
for(int i = 0; i <= size; i++){
parent[i] = i, rank[i] = 0;
v[i] = 1, e[i] = 0;
}
}
int root(int i){
if(parent[i] == i) return i;
return parent[i] = root(parent[i]);
}
bool same(int i, int j){
return root(i) == root(j);
}
void merge(int i, int j){ // j will become new root
parent[i] = j;
v[j] += v[i];
e[j] += e[i] + 1;
}
void unite(int i, int j){
int root_i = root(i), root_j = root(j);
if(root_i == root_j){
e[root_i]++;
return;
}
if(rank[root_i] < rank[root_j]) merge(root_i, root_j);
else merge(root_j, root_i);
if(rank[root_i] == rank[root_j]) rank[root_i]++;
}
};
ll n;
ll a[100005];
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0);
make_fact();
cin >> n;
rep(i, 1, n) cin >> a[i];
ll sum = 0;
rep(i, 1, n) sum += a[i];
if(sum % n){
outl(0);
return 0;
}
map<ll, ll> pmp, nmp;
rep(i, 1, n){
if(a[i] > sum/n) pmp[a[i]]++;
if(a[i] < sum/n) nmp[a[i]]++;
}
mint ans = 1; ll pcnt = 0;
for(auto p : pmp){
pcnt += p.second;
ans /= fact[p.second];
}
ans *= fact[pcnt];
ll ncnt = 0;
for(auto p : nmp){
ncnt += p.second;
ans /= fact[p.second];
}
ans *= fact[ncnt];
if(pcnt <= 1 || ncnt <= 1){
ans *= comb(pcnt+ncnt, pcnt);
ans *= comb(n, pcnt+ncnt);
outl(ans);
return 0;
}
ans *= mint(2);
ans *= comb(n, pcnt+ncnt);
outl(ans);
return 0;
} |
#include <iostream>
#include <map>
constexpr int N = 100005;
constexpr int p = 1000000007;
int mul(int x, int y) { return (long long)x * y % p; }
int power(int x, int y) { int ans = 1; for (; y; y >>= 1) { if (y & 1) ans = mul(ans, x); x = mul(x, x); } return ans; }
int n;
int a[N];
int fac[N], inv[N];
std::map<int, int> cnt;
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(nullptr);
std::cin >> n;
long long sum = 0;
for (int i = 1; i <= n; ++i) std::cin >> a[i], sum += a[i];
if (sum % n) return std::cout << "0\n", 0;
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = mul(fac[i - 1], i);
inv[n] = power(fac[n], p - 2);
for (int i = n; i; --i) inv[i - 1] = mul(inv[i], i);
int x = sum / n;
int cnt0 = 0, cntg = 0, cntl = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] == x) ++cnt0;
else if (a[i] > x) ++cntg;
else ++cntl;
++cnt[a[i]];
}
if (!cntg && !cntl) return std::cout << "1\n", 0;
int ansg = fac[cntg], ansl = fac[cntl];
for (auto [i, k] : cnt)
if (i > x) ansg = mul(ansg, inv[k]);
else if (i < x) ansl = mul(ansl, inv[k]);
if (cntg == 1) return std::cout << mul(mul(fac[n], mul(inv[cnt0], inv[n - cnt0])), mul(ansl, n - cnt0)) << '\n', 0;
if (cntl == 1) return std::cout << mul(mul(fac[n], mul(inv[cnt0], inv[n - cnt0])), mul(ansg, n - cnt0)) << '\n', 0;
std::cout << mul(mul(mul(fac[n], mul(inv[cnt0], inv[n - cnt0])), mul(ansg, ansl)), 2) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#define endl '\n'
#define fi first
#define se second
#define MOD(n,k) ( ( ((n) % (k)) + (k) ) % (k))
#define forn(i,n) for (int i = 0; i < int(n); i++)
#define forr(i,a,b) for (int i = a; i <= b; i++)
#define all(v) v.begin(), v.end()
#define pb push_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
const int MX = 200005, mod = 1000000007;
int n, a[MX];
ll fac[MX], inv[MX];
ll pot (ll b, int p) {
ll res = 1;
while (p) {
if (p & 1) (res *= b) %= mod;
(b *= b) %= mod;
p /= 2;
}
return res;
}
ll comb (int n, int k) {
return fac[n] * inv[k] % mod * inv[n - k] % mod;
}
void solve () {
cin >> n;
ll sum = 0;
forn (i, n) {
cin >> a[i];
sum += a[i];
}
if (sum % n) {
cout << 0 << endl;
return;
}
int x = 0, y = 0, z = 0;
forn (i, n) {
if (a[i] < sum / n) x++;
else if (a[i] > sum / n) y++;
else z++;
}
ll res = 0;
if (x < 2 || y < 2) {
res = fac[n];
} else {
res = 2 * comb(n, z) % mod * fac[x] % mod * fac[y] % mod * fac[z] % mod;
}
map<int, int> mp;
forn (i, n)
mp[a[i]]++;
for (auto it : mp)
(res *= inv[it.se]) %= mod;
cout << res << endl;
}
int main () {
ios_base::sync_with_stdio(0); cin.tie(0);
fac[0] = inv[0] = 1;
for (int i = 1; i < MX; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = pot(fac[i], mod - 2);
assert(fac[i] * inv[i] % mod == 1);
}
int t = 1;
//cin >> t;
while (t--)
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll p=1e9+7;
ll fac(ll n) {
ll ans=1;
while(n) {
ans=(ans*n)%p;
n--;
}
return ans;
}
ll power(ll a, ll x) {
ll ans=1;
while(x) {
if(x&1) {
ans=(ans*a)%p;
}
x=x>>1;
a=(a*a)%p;
}
return ans;
}
ll modInv(ll a) {
return power(a, p-2);
}
void solve() {
int n;
cin>>n;
vector<ll> a(n);
ll total=0;
for(auto &i : a) {
cin>>i;
total+=i;
}
if(total%n) {
cout<<0<<endl;
return;
}
total/=n;
int source=0, sink=0;
map<ll, int> count;
for(auto i : a) {
if(i<total) {
sink++;
}
if(i>total) {
source++;
}
count[i]++;
}
ll ans=fac(n);
for(auto i : count) {
ans=(ans*modInv(fac(i.second)))%p;
}
if(min(source, sink)>1) {
ans=(ans*2)%p;
ans=(ans*fac(source))%p;
ans=(ans*fac(sink))%p;
int filled=source+sink;
ans=(ans*modInv(fac(filled)))%p;
}
cout<<ans<<endl;
return;
}
int main() {
#ifdef bipinpathak
(void)!freopen("input.txt", "r", stdin);
(void)!freopen("output.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for(int i=0; i<t; i++) {
//cout<<"Case #"<<i+1<<": ";
solve();
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define rep(i,a,b) for(int i=a;i<b;i++)
#define pfy cout<<("YES")
#define pfn cout<<("NO")
typedef long long ll;
typedef long double ld;
#define nl cout<<("\n")
#define int ll
typedef vector< int > vi;
typedef vector< vi > vvi;
typedef pair< int,int > ii;
typedef vector< ii > vii;
#define sz(a) int((a).size())
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define tr(c,i) for( auto i = (c).begin(); i != (c).end(); i++)
#define present(c,x) ((c).find(x) != (c).end())
#define cpresent(c,x) (find(all(c),x) != (c).end())
#define F first
#define S second
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');std::cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
const ll hell=1000000007;
/* */
int N=100000;
vector<int> fac(N+1);
vector<int> inv(N+1);
int power(int a, int n){
int res=1;
while(n>0){
if(n&1){
res*=a;
res%=hell;
}
a*=a;
a%=hell;
n>>=1;
}
return res;
}
void precompute(){
fac[0]=1;
for(int i=1;i<=N;i++){
fac[i]=i*fac[i-1];
fac[i]%=hell;
}
inv[0]=1;
for(int i=1;i<=N;i++){
inv[i]=inv[i-1]*power(i,hell-2);
inv[i]%=hell;
}
}
signed solve(){
precompute();
int n; cin>>n;
vector<int> v(n);
int sm=0;
for(int i=0;i<n;i++) {
cin>>v[i];
sm+=v[i];
}
if(sm%n) cout<<0<<endl;
else{
int md=sm/n;
int n1=0,n2=0,n3=0;
map<int,int> m1,m3;
for(auto x:v){
if(x==md) n2++;
else if(x<md) {
m1[x]++;
n1++;
}else{
m3[x]++;
n3++;
}
}
int ans=1;
ans*=fac[n];
ans%=hell;
ans*=inv[n2];
ans%=hell;
for(auto x:m1) {
ans*=inv[x.second];
ans%=hell;
}
for(auto x:m3) {
ans*=inv[x.second];
ans%=hell;
}
if(n1<=1 || n3<=1){
cout<<ans;
return 0;
}
ans*=fac[n1];
ans%=hell;
ans*=fac[n3];
ans%=hell;
ans*=2;
ans%=hell;
ans*=inv[n1+n3];
ans%=hell;
cout<<ans<<endl;
}
return 0;
}
signed main(){
int t=1;
fast; // freopen("input.txt","r",stdin); freopen ("output.txt","w",stdout);
// cin>>t;
while(t--){
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5+50;
const int mod = 1e9+7;
typedef long long ll;
int a[maxn];
map<int,int>vis,vis2;
int qpow(int a,int b,int c){
int ans=1;
while(b){
if(b&1)ans=1ll*ans*a%mod;
b>>=1;
a=1ll*a*a%mod;
}
return ans;
}
int main(){
int n;
scanf("%d",&n);
ll sum=0;
for(int i=1;i<=n;++i)scanf("%d",&a[i]),sum+=a[i],vis[a[i]]++;
vector<int>g;
for(int i=1;i<=n;++i)if(!vis2[a[i]])vis2[a[i]]=1,g.push_back(vis[a[i]]);
int u=1;
for(int i=0;i<g.size();++i){
for(int j=1;j<=g[i];++j){
u=1ll*u*j%mod;
}
}
u=qpow(u,mod-2,mod);
if(sum%n)return printf("0\n"),0;
int ave=sum/n;
int cnt[3]={};
for(int i=1;i<=n;++i){
cnt[0]+=(a[i]<ave);
cnt[1]+=(a[i]==ave);
cnt[2]+=(a[i]>ave);
}
int ans;
if(cnt[0]<=1 || cnt[2]<=1){
ans=1;
for(int i=1;i<=n;++i)ans=1ll*ans*i%mod;
ans=1ll*ans*u%mod;
}else {
ans=1;
for(int i=1;i<=cnt[0];++i)ans=1ll*ans*i%mod;
for(int i=1;i<=cnt[2];++i)ans=1ll*ans*i%mod;
for(int i=1;i<=cnt[1];++i)ans=1ll*ans*(cnt[0]+cnt[2]+i)%mod;
ans=2ll*ans%mod;
ans=1ll*ans*u%mod;
}
printf("%d\n",ans);
} |
#include <bits/stdc++.h>
#define pb push_back
#define ll long long
#define ull unsigned long long
#define mp make_pair
#define si short int
#define speed ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define pill pair<ll,ll>
#define f first
#define s second
#define pilc pair<ll,char>
#define all(a) (a).begin(),(a).end()
#define rep(s,e,step) for(int i = (s); i < (e) ; i += step)
#define vrep(s,e,step) for(int j = (s); j < (e) ; j += step)
#define ex exit(0)
#define sz(a) (ll)(a).size()
#define triple pair<pill, ll>
#define pinode pair<node*, node*>
#define quadra pair<pill, pill>
#define ld long double
using namespace std;
const ll N = 2e5 + 3;
const ll big = 1e14;
const ll hsh2 = 1964325029 ;
const long long mod = 1e9 + 7;
const long double EPS = 1e-20;
const ll block = 1e7;
const ll shift = 2e3;
const ld pi = acos(-1.0);
ll n;
ll a[N];
ll f[N];
ll bp(ll a, ll b) {
ll c = 1ll;
while(b) {
if(b&1ll)
c = c * a % mod;
b >>= 1ll;
a = a * a % mod;
}
return c;
}
int main() {
speed;
cin >> n;
f[0] = 1ll;
for(ll i = 1; i < N; i++)
f[i] = f[i - 1] * i % mod;
ll s = 0;
for(int i = 1; i <= n; i++)
cin >> a[i], s += a[i];
if(s % n) cout << 0, ex;
s /= n;
ll cnt1 = 0, cnt2 = 0, cnt3 = 0;
for(int i = 1; i <= n; i++) {
cnt1 += (a[i] > s);
cnt2 += (a[i] < s);
cnt3 += (a[i] == s);
}
if(cnt1 <= 1 || cnt2 <= 1) {
map<ll, ll> x;
for(int i = 1; i <= n; i++)
x[a[i]]++;
ll ans = f[n];
for(auto u : x)
ans = (ans * bp(f[u.s], mod - 2)) % mod;
cout << ans << '\n', ex;
}
ll ans = 0;
ll inv1 = 1ll, inv2 = 1ll;
map<ll, ll> x[2];
for(int i = 1; i <= n; i++) {
if(a[i] > s)
x[0][a[i]]++;
if(a[i] < s)
x[1][a[i]]++;
}
for(auto u : x[0])
inv1 = inv1 * f[u.s] % mod;
for(auto u : x[1])
inv2 = inv2 * f[u.s] % mod;
inv1 = bp(inv1, mod - 2), inv2 = bp(inv2, mod - 2);
ll h = f[n] * bp(f[cnt1 + cnt2] * f[n - cnt1 - cnt2] % mod, mod - 2) % mod;
h = h * f[cnt1] % mod * f[cnt2] % mod;
cout << 2ll * h % mod * inv1 % mod * inv2 % mod;
}
/*
4
4 6 1 9
2 5 3 2
*/ |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=(a),i##end=(b);i<=i##end;++i)
#define per(i,a,b) for(int i=(a),i##end=(b);i>=i##end;--i)
const int maxn=2e5+10,P=1e9+7;
int n,A[maxn];map<int,int>cnt;
int qp(int a,int k){int res=1;for(;k;k>>=1,a=1ll*a*a%P)if(k&1)res=1ll*res*a%P;return res;}
int inv[maxn],fac[maxn],ifac[maxn];
int binom(int n,int m){return n<m?0:1ll*fac[n]*ifac[m]%P*ifac[n-m]%P;}
void init(){
fac[0]=ifac[0]=inv[1]=fac[1]=ifac[1]=1;
rep(i,2,maxn-1)inv[i]=1ll*(P-P/i)*inv[P%i]%P,fac[i]=1ll*i*fac[i-1]%P,ifac[i]=1ll*inv[i]*ifac[i-1]%P;
}
int main(){
init();
long long su=0;
cin>>n;rep(i,1,n)scanf("%d",A+i),su+=A[i];
if(su%n!=0)return puts("0"),0;
int ct0=0,ct1=0,ct2=0,re=1;
rep(i,1,n){
A[i]-=su/n;
re=1ll*re*(++cnt[A[i]])%P;
ct0+=A[i]==0,ct1+=A[i]>0,ct2+=A[i]<0;
}
re=qp(re,P-2);
int tp=1ll*binom(n,ct0)*fac[ct0]%P;
n-=ct0;
if(ct2<ct1)swap(ct1,ct2);
if(ct1<=1){
cout<<1ll*tp*binom(n,ct1)%P*fac[ct2]%P*re%P<<endl;return 0;
}
cout<<2ll*tp%P*re%P*fac[ct1]%P*fac[ct2]%P<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef double db;
typedef uint32_t u32;
typedef uint64_t u64;
typedef pair<int, int> pii;
typedef pair<int, int> point;
#define fi first
#define se second
#define pb(x) push_back(x)
#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++)
typedef long long ll;
const int mod = 998244353;
int main() {
#ifdef local
freopen("in.txt", "r", stdin);
#endif
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
const int mod = 1e9 + 7;
int n;
cin >> n;
vector<int> a(n);
ll tot = 0;
for(auto &e : a) {
cin >> e;
tot += e;
}
if(tot % n) {
cout << "0\n";
return 0;
}
vector<int> fac(n + 1, 1);
vector<int> ifac(n + 1, 1);
for(int i = 2; i <= n; i++) {
fac[i] = (ll) fac[i - 1] * i % mod;
ifac[i] = (ll) ifac[mod % i] * (mod - mod / i) % mod;
}
for(int i = 2; i <= n; i++) {
ifac[i] = (ll) ifac[i] * ifac[i - 1] % mod;
}
auto C = [&](int n, int m) {
if(n < m || m < 0) return 0ll;
return (ll) fac[n] * ifac[m] % mod * ifac[n - m] % mod;
};
ll avg = tot / n;
vector<int> l, r;
int eq = 0;
for(auto &e : a) {
if(e > avg) {
r.push_back(e);
} else if(e < avg) {
l.push_back(e);
} else {
eq++;
}
}
int ans = 1;
if(l.size() > 1 && r.size() > 1) {
ans = 2;
}
if(l.size() == 1) {
r.push_back(l[0]);
l.clear();
}
if(r.size() == 1) {
l.push_back(r[0]);
r.clear();
}
sort(all(l));
sort(all(r));
int a1 = fac[l.size()];
int a2 = fac[r.size()];
for(int i = 0, j = 0; i < (int) l.size(); i = j) {
while(j < (int) l.size() && l[j] == l[i]) {
j++;
}
a1 = (ll) a1 * ifac[j - i] % mod;
}
for(int i = 0, j = 0; i < (int) r.size(); i = j) {
while(j < (int) r.size() && r[j] == r[i]) {
j++;
}
a2 = (ll) a2 * ifac[j - i] % mod;
}
int a3 = C(n, eq);
ans = (ll) ans * a1 % mod;
ans = (ll) ans * a2 % mod;
ans = (ll) ans * a3 % mod;
cout << ans << '\n';
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1e9 + 7;
const int mxn = 1e5;
int n, a[mxn + 1];
ll fact[mxn + 1];
ll exp(ll x, ll n) {
ll ans = 1;
while (n) {
if (n & 1) {
ans = (ans * x) % mod;
}
x = (x * x) % mod;
n >>= 1;
}
return ans;
}
ll inv(ll n) {
return exp(n, mod - 2);
}
ll ncr(ll n, ll r) {
return fact[n] * inv(fact[n - r]) % mod * inv(fact[r]) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
if (sum % n) {
cout << 0;
return 0;
}
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i % mod;
}
int target = sum / n;
int l = 0, m = 0, h = 0;
unordered_map<int, int> mp;
mp.reserve(n);
for (int i = 0; i < n; i++) {
if (a[i] == target) {
m++;
}
else if (a[i] < target) {
l++;
mp[a[i]]++;
}
else {
h++;
mp[a[i]]++;
}
}
if (l == 0) {
cout << 1;
return 0;
}
ll ways = fact[l] * fact[h] % mod;
for (auto it = mp.begin(); it != mp.end(); it++) {
ways = ways * inv(fact[it->second]) % mod;
}
if (l == 1) {
ways = ways * (h + 1LL) % mod;
}
else if (h == 1) {
ways = ways * (l + 1LL) % mod;
}
else {
ways = ways * 2 % mod;
}
cout << ncr(n, m) * ways % mod;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#ifdef APURBA
#include "DEBUG_TEMPLATE.h"
#else
#define HERE
#define debug(args...)
#endif
const int N = 1e5 +5;
const ll mod = 1e9+7;
typedef pair<int,int> pii;
ll bigmod(ll a, ll b)
{
a%=mod;
ll ans =1;
while(b>0)
{
if(b&1)
{
ans = (ans*a)%mod;
}
a= (a*a)%mod;
b>>=1;
}
return ans;
}
ll fact[N];
void init()
{
fact[0]=1;
for(ll i=1; i<N; i++)
fact[i]= (fact[i-1]*i)%mod;
}
ll gun(ll x, ll y)
{
x%=mod;
y%=mod;
return (x*y)%mod;
}
ll vag(ll x, ll y)
{
x%=mod;
y%=mod;
return (x* bigmod(y,mod-2))%mod;
}
ll perm(vector<ll>&a)
{
ll n = a.size();
if(n==0)
return 1;
map<ll,ll>mp;
for(ll i:a)
{
mp[i]++;
}
ll ans = fact[n];
for(auto it:mp)
{
if(it.second<=1)
continue;
ans = vag(ans, fact[it.second]);
}
return ans;
}
ll getncr(ll n, ll r)
{
if(n<r)
{
//cout<<n<<" "<<r<<endl;
return 0;
}
ll up = fact[n];
ll down = (fact[r]* fact[n-r])%mod;
return (up * bigmod(down,mod-2))%mod;
}
ll add(ll x, ll y)
{
if(x>=mod)
x%=mod;
if(y>=mod)
y%=mod;
x+=y;
if(x>=mod)
x-=mod;
return x;
}
void TEST_CASES(int cas)
{
ll n;
cin>>n;
vector<ll>a(n);
ll sum =0;
for(ll i=0; i<n; i++)
{
cin>>a[i];
sum += a[i];
}
if(sum%n)
{
cout<<"0\n";
return;
}
ll koto = sum/n;
ll src =0, sink =0, no =0;
vector<ll>p,q,r;
for(ll i=0; i<n; i++)
{
if(a[i] < koto)
{
sink++;
p.push_back(a[i]);
}
else if(a[i]>koto)
{
src++;
q.push_back(a[i]);
}
else
{
no++;
r.push_back(a[i]);
}
}
if(src==1 || sink==1)
{
cout<<perm(a)<<"\n";
return;
}
if(src==0 || sink==0)
{
cout<<perm(a)<<"\n";
return;
}
ll bal = r.size()+1;
ll ans = perm(r);
ll sal = gun(perm(p) , perm(q));
ll jaga= p.size() + q.size() + 1;
ans = gun(ans , getncr(jaga + r.size()-1 , r.size()));
ans = gun(ans , sal);
ans = gun(ans, 2);
cout<<ans<<"\n";
}
/*
*/
int32_t main()
{
#ifndef APURBA
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
#endif
//freopen("input.txt","r",stdin);
//freopen("out1.txt","w",stdout);
init();
int t=1,cas=0;
//cin>>t;
while(t--)
{
TEST_CASES(++cas);
}
return 0;
}
|
/* CREATED BY
STREAM_CIPHER
april-2021
*/
#include<bits/stdc++.h>
using namespace std;
void __print(long long x) {cerr << x;}void __print(unsigned long long 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
#define int long long int
#define double long double
#define fix_precision(n) cout<<fixed<<setprecision(n)
#define all(a) a.begin(),a.end()
const double pi=acos(-1.0);
int inf=0x3f3f3f3f3f3f3f3f;
const int mod=1e9+7;
// const int mod=998244353;
const int mx=5*1000000;//5*64M bit ->5*8M byte ->40MB size for long long int (64 bit)
int f[200009];
int inv[200009];
const int MAX=200009;
int power(int x, int y, int p) {
int res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res*x) % p;
y = y>>1;
x = (x*x) % p;
}
return res;
}
void init() {
f[0] = 1;
for(int i=1;i<MAX;i++) f[i] = (f[i-1]*i)%mod;
inv[MAX-1] = power(f[MAX-1], mod-2, mod);
for(int i=MAX-2;i>=0;i--) inv[i] = (inv[i+1]*(i+1)) % mod;
for(int i=0;i<MAX;i++) assert(inv[i]==power(f[i],mod-2,mod));
}
int ncr(int n, int r) {
if(r > n || r < 0) return 0;
int ans = f[n];
ans *= (inv[r] * inv[n -r]) % mod;
ans %= mod;
return ans;
}
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
init();
int n;
cin>>n;
vector<int>a(n);
int sum=0;
map<int,int>cnt;
for(int i=0;i<n;i++){
cin>>a[i];
sum+=a[i];
}
if(sum%n==0){
int less=0,greater=0,equal=0;
int each=sum/n;
debug(each);
for(auto i:a){
if(i>each)
greater++,cnt[i]++;
else if(i<each)
less++,cnt[i]++;
else
equal++;
}
// debug(greater,less,equal);
if(greater==0&&less==0){
cout<<"1\n";
return 0;
}
int ans;
if(greater==1||less==1){
ans=f[n];
for(auto [x,y]:cnt){
ans=(ans*inv[y])%mod;
}
ans*=inv[equal];
ans%=mod;
}
else{
ans=f[less]*f[greater];
ans%=mod;
ans*=2;
ans%=mod;
for(auto [x,y]:cnt){
ans=(ans*inv[y])%mod;
}
// debug(ans);
// debug(nCrModPFermat(n,equal,mod));
ans*=ncr(n,equal);
ans%=mod;
}
cout<<ans<<endl;
}
else{
cout<<"0\n";
}
}
//always use s.lower_bound instead of lower_bound(all(s))
//also whenever there exist an standerd method for stl container prefer that
//otherwise this will happen
//https://codeforces.com/contest/1435/submission/96683823//tle
//https://codeforces.com/contest/1435/submission/96703923//accepted |
#include <bits/stdc++.h>
#ifdef ALGO
#include "el_psy_congroo.hpp"
#else
#define DUMP(...) 1145141919810
#define CHECK(...) (__VA_ARGS__)
#endif
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::istream& reader = std::cin;
const int BIT = 10;
int n;
reader >> n;
std::vector<std::vector<int>> vec(BIT, std::vector<int>(n));
for (int i = 0; i < n; ++i) {
reader >> vec[0][i];
}
auto update = [&](int level, int l) -> void {
CHECK(level > 0);
int r = std::min(n, l + (1 << level)); // [l, r)
int mid = std::min(n, l + (1 << (level - 1)));
const auto& prev = vec[level - 1];
auto& cur = vec[level];
for (int i = l, j = mid, k = l, offset = 0; k < r; ++k) {
if (i == mid || (j < r && prev[i] >= prev[j] - offset)) {
cur[k] = prev[j++] - offset;
} else {
cur[k] = prev[i++];
++offset;
}
}
};
for (int level = 1; level < BIT; ++level) {
for (int i = 0; i < n; i += (1 << level)) {
update(level, i);
}
}
int q;
reader >> q;
while (q--) {
int op, i;
reader >> op >> i; --i;
if (op == 1) {
int x;
reader >> x;
vec[0][i] = x;
for (int level = 1; level < BIT; ++level) {
if (i >> (level - 1) & 1)
i -= 1 << (level - 1);
update(level, i);
}
} else {
int v = vec[0][i];
++i;
while (i < n) {
int level = std::min(BIT - 1, __builtin_ctz(i));
v += std::upper_bound(vec[level].begin() + i, vec[level].begin() + std::min(n, i + (1 << level)), v)
- vec[level].begin() - i;
i += 1 << level;
}
printf("%d\n", n - v);
}
}
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
const int nn = 1e5 + 5;
const int inf = 1e9;
struct node {
int val, lazy, pos;
#define val(p) tree[p].val
#define lazy(p) tree[p].lazy
#define pos(p) tree[p].pos
#define ls (p << 1)
#define rs (p << 1 | 1)
} tree[nn << 3];
void update(int p) {
if (val(ls) < val(rs)) {
val(p) = val(ls);
pos(p) = pos(ls);
} else {
val(p) = val(rs);
pos(p) = pos(rs);
}
}
int c[nn];
void build(int p, int l, int r) {
if (l == r) {
val(p) = c[l];
pos(p) = l;
return;
}
int mid = l + r >> 1;
build(ls, l, mid);
build(rs, mid + 1, r);
update(p);
}
void pushdown(int p) {
if (!lazy(p)) return;
lazy(ls) += lazy(p);
val(ls) += lazy(p);
lazy(rs) += lazy(p);
val(rs) += lazy(p);
lazy(p) = 0;
}
void modify(int p, int l, int r, int pos, int val) {
if (l == r) {
val(p) = val;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (pos <= mid) modify(ls, l, mid, pos, val);
else modify(rs, mid + 1, r, pos, val);
update(p);
}
void add(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
val(p)--; lazy(p)--;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (ql <= mid) add(ls, l, mid, ql, qr);
if (mid < qr) add(rs, mid + 1, r, ql, qr);
update(p);
}
int a[nn], stack[3005][3005], lenth[nn];
void build_b(int p, int l, int r) {
for (int i = 1; i <= 2000; i++)
tree[i] = (node){0, 0, 0};
for (int i = l; i <= r; i++) c[i - l + 1] = a[i];
int len = r - l + 1;
build(1, 1, len);
for (int i = 1; i <= len; i++) {
stack[p][i] = std::max(val(1), stack[p][i - 1]);
int pos = pos(1);
if (pos != len) add(1, 1, len, pos + 1, len);
modify(1, 1, len, pos, inf);
}
stack[p][lenth[p] + 1] = inf;
}
int n, m, block, bl[nn], l[nn], r[nn];
int main() {
scanf("%d", &n);
block = 150;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
bl[i] = (i - 1) / block + 1;
}
for (int i = 1; i <= bl[n]; i++) {
l[i] = i * block - block + 1;
r[i] = std::min(n, i * block);
lenth[i] = r[i] - l[i] + 1;
build_b(i, l[i], r[i]);
}
scanf("%d", &m);
while (m--) {
int opt, x;
scanf("%d %d", &opt, &x);
if (opt == 1) {
scanf("%d", a + x);
build_b(bl[x], l[bl[x]], r[bl[x]]);
} else {
int ans = a[x];
for (int i = x + 1; i <= r[bl[x]]; i++) ans += (ans >= a[i]);
for (int i = bl[x] + 1; i <= bl[n]; i++) {
int pos = std::upper_bound(stack[i] + 1, stack[i] + lenth[i] + 2, ans) - stack[i];
ans += pos - 1;
}
printf("%d\n", n - ans);
}
}
} |
#include<bits/stdc++.h>
using namespace std;const int N=1e5+7;
int L[N],R[N],bl[N],block,a[N],c[N],op,t,tot,n,m,i,j;vector<int>e[N];
void A(int x,int v){while(x<=n)c[x]+=v,x+=x&-x;}
int Q(int t,int ans=0){for(int i=17;i>=0;--i)if(ans+(1<<i)<=n&&c[ans+(1<<i)]<t)ans+=1<<i,t-=c[ans];return ans+1;}
void build(int x){
e[x].clear();for(int i=L[x];i<=R[x];++i)
j=Q(a[i]+1)-1,e[x].push_back(j),A(j+1,1);
for(auto&y:e[x])A(y+1,-1);sort(e[x].begin(),e[x].end());
}
int main(){
for(scanf("%d",&n),block=sqrt(n),i=1;i<=n;++i){
scanf("%d",a+i);tot=bl[i]=i/block+1;A(i,1);
if(!L[tot])L[tot]=i;R[tot]=i;
}
for(i=1;i<=tot;++i)build(i);
for(scanf("%d",&m);m--;){
scanf("%d",&op);
if(op==1)scanf("%d",&i),scanf("%d",a+i),build(bl[i]);
else{
scanf("%d",&i);t=a[i];
for(j=i+1;j<=R[bl[i]];++j)t+=a[j]<=t;
for(j=bl[i]+1;j<=tot;++j)t+=upper_bound(e[j].begin(),e[j].end(),t)-e[j].begin();
printf("%d\n",n-t);
}
}
} |
/** vaziat sorati ghermeze **/
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define all(x) (x).begin(),(x).end()
#define F first
#define S second
#define Mp make_pair
#define SZ(x) (int)x.size()
#define fast_io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define file_io freopen("in.txt" , "r+" , stdin) ; freopen("out.txt" , "w+" , stdout);
const int N = 1e5 + 10;
const ll mod = 1e9 + 7;
const ll mod2 = 998244353;
const ll inf = 8e18;
const int LOG = 17;
const int B = 250;
const int NB = N / B + 5;
ll pw(ll a , ll b, ll M) { return (!b ? 1 : (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M : pw(a * a % M, b / 2, M))); }
int n, q, A[N];
struct segment
{
int fen[N + 5];
void add(int i, int x)
{
for(; i < N; i += i & -i) fen[i] += x;
}
void build(int _n)
{
for(int i = 1; i <= _n; i ++)
{
fen[i] = i & -i;
}
}
void upd(int p, int x)
{
int id = 0, cu = 0;
for(int T = LOG - 1; ~T; T --)
{
if(id + (1 << T) <= n && (cu + fen[id + (1 << T)]) < p)
{
id += 1 << T;
cu += fen[id];
}
}
add(id + 1, x);
}
int get(int i, int ret = 0)
{
for(i; i; i -= i & -i)
{
ret += fen[i];
}
return ret;
}
} S[NB];
int main()
{
scanf("%d", &n);
for(int i = 1; i <= n; i ++)
{
scanf("%d", &A[i]);
}
for(int T = 0; T <= n / B; T ++)
{
S[T].build(n);
int tl = T * B, tr = min(n, tl + B - 1);
tl = max(1, tl);
for(int i = tl; i <= tr; i ++)
{
S[T].upd(i - A[i], 1);
}
}
scanf("%d", &q);
while(q --)
{
int tp, fir, sec;
scanf("%d%d", &tp, &fir);
if(tp == 1)
{
scanf("%d", &sec);
int T = fir / B;
int tl = T * B, tr = min(n, tl + B - 1);
tl = max(1, tl);
for(int i = tr; i >= fir; i --)
{
S[T].upd(i - A[i], -1);
}
A[fir] = sec;
for(int i = fir; i <= tr; i ++)
{
S[T].upd(i - A[i], 1);
}
}
else
{
int Ans = fir - A[fir];
fir ++;
int T = fir / B, tl = T * B, tr = min(n, tl + B - 1);
for(int i = fir; i <= tr; i ++)
{
if(Ans >= i - A[i]) Ans ++;
}
///printf("Ans = %d\n", Ans);
for(int T1 = T + 1; T1 <= n / B; T1 ++)
{
Ans = S[T1].get(Ans);
}
printf("%d\n", Ans);
}
}
return 0;
}
/** test corner cases(n = 1?) watch for overflow or minus indices **/
|
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int B=316;
int n,m,a[100005],fir[100005],b[100005],ft,sum[1000005],c[100005],d[100005],lim;
/*void pushup(int x)
{
sum[x]=sum[x*2]+sum[x*2+1];
}
void modify(int x,int l,int r,int qx,int v)
{
if(l>qx||r<qx) return;
if(l==r)
{
sum[x]=v;
return;
}
int mid=(l+r)/2;
modify(x*2,l,mid,qx,v);
modify(x*2+1,mid+1,r,qx,v);
pushup(x);
}
int query(int x,int l,int r,int k)
{
if(l==r) return l;
int mid=(l+r)/2;
if(sum[x*2]>=k) return query(x*2,l,mid,k);
return query(x*2+1,mid+1,r,k-sum[x*2]);
}*/
inline int lowbit(int x)
{
return x&-x;
}
void modify(int x,int v)
{
// printf("modify:x=%d,v=%d\n",x,v);
for(int i=x;i<=n;i+=lowbit(i))
sum[i]+=v;
}
int query(int k)
{
int x=0;
for(int i=lim;i;i>>=1)
{
// printf("query:x=%d,i=%d,k=%d,sum=%d\n",x,i,k,sum[x+i]);
if(x+i<=n&&sum[x+i]<=k)
{
k-=sum[x+i];
x+=i;
}
}
return x;
}
void build(int x)
{
for(int i=fir[x+1]-1;i>=fir[x];i--)
{
c[i]=query(a[i]-1)+1;
modify(c[i],-1);
}
for(int i=fir[x];i<fir[x+1];i++)
modify(c[i],1),d[i]=c[i];
sort(c+fir[x],c+fir[x+1]);
}
int query(int x,int v)
{
int l=fir[x],r=fir[x+1]-1,mid;
while(l<=r)
{
mid=(l+r)/2;
if(c[mid]-(mid-fir[x]+1)>=v) r=mid-1;
else l=mid+1;
}
return v+r-fir[x]+1;
}
int main()
{
// freopen("CF1540D.in","r",stdin);
// freopen("CF1540D.out","w",stdout);
scanf("%d",&n);
lim=1;
while(lim<=n) lim<<=1;
lim>>=1;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
a[i]=i-a[i];
}
for(int i=1;i<=n;i++)
{
b[i]=(i-1)/B+1;
if(!fir[b[i]]) fir[b[i]]=i,ft++;
}
fir[ft+1]=n+1;
for(int i=1;i<=n;i++)
modify(i,1);
for(int i=1;i<=ft;i++)
build(i);
scanf("%d",&m);
for(int i=1;i<=m;i++)
{
int op,x,y;
scanf("%d%d",&op,&x);
if(op==1)
{
scanf("%d",&y);
a[x]=x-y;
build(b[x]);
}
else
{
int ans=d[x];
for(int j=b[x]+1;j<=ft;j++)
ans=query(j,ans);
printf("%d\n",ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN=100005,B=300,BC=(MAXN/B)+1;
struct BlockCnt
{
int f[MAXN],g[BC];
void add(int p,int d)
{
f[p]+=d;
g[(p-1)/B]+=d;
}
void query(int k,int &p,int &s)
{
s=k;
for (int i=0;;i++)
{
if ((i+1)*B+g[i]>=s)
for (int j=i*B+1;;j++)
{
if (j+f[j]>=s)
{
p=j;
return;
}
s-=f[j];
}
s-=g[i];
}
}
}cnt[BC];
struct TransInfo
{
int v1[MAXN],v2[BC];
void add(int k,int d)
{
v1[k]+=d;
}
void add(int l,int r,int d)
{
int lc=(l-1)/B,rc=(r-1)/B;
if (lc==rc)
for (int i=l;i<=r;i++)
v1[i]+=d;
else
{
for (int i=l;;i++)
{
v1[i]+=d;
if (i%B==0)
break;
}
for (int i=r;;i--)
{
v1[i]+=d;
if (i%B==1)
break;
}
for (int i=lc+1;i<rc;i++)
v2[i]+=d;
}
}
}tr[BC];
int n,b[MAXN],mn[MAXN],rmd[MAXN],f[MAXN],cnt_mod[MAXN];
void build(int k,int l,int r)
{
for (int i=l;i<=r;i++)
{
cnt[k].query(b[i],mn[i],rmd[i]);
if (rmd[i]==0)
exit(1);
tr[k].v1[mn[i]]++;
cnt[k].add(mn[i],1);
}
for (int i=2;i<=n;i++)
tr[k].v1[i]+=tr[k].v1[i-1];
}
int main()
{
#ifdef KeyID
freopen("read.txt","r",stdin);
#endif
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&b[i]);
b[i]=i-b[i];
}
for (int i=1;i<=n;i+=B)
build((i-1)/B,i,min(i+B-1,n));
int m;
scanf("%d",&m);
while (m--)
{
int op;
scanf("%d",&op);
if (op==1)
{
int p,v;
scanf("%d%d",&p,&v);
v=p-v;
if (b[p]==v)
continue;
int k=(p-1)/B,r=min(n,(k+1)*B);
for (int i=r;i>=p;i--)
{
cnt[k].add(mn[i],-1);
f[i]=cnt[k].f[mn[i]-1];
}
int mnp,rmdp;
cnt[k].query(v,mnp,rmdp);
if (rmdp==0)
exit(2);
if (mn[p]==mnp)
for (int i=p;i<=r;i++)
cnt[k].add(mn[i],1);
else if (mn[p]<mnp)
{
tr[k].add(mn[p],mnp-1,-1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt[k].f[mn[i]]-cnt_mod[mn[i]-1]-(mn[p]<mn[i]&&mnp>=mn[i]?1:0);
if (mn[i]+d<rmd[i])
{
rmd[i]-=d;
cnt_mod[mn[i]]++;
tr[k].add(mn[i]++,-1);
}
else
rmd[i]+=cnt_mod[mn[i]-1]+(mn[p]<mn[i]&&mnp>=mn[i]?1:0);
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]-1]=0;
}
else
{
tr[k].add(mnp,mn[p]-1,1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]]+(mn[p]>=mn[i]&&mnp<mn[i]?1:0);
if (mn[i]==1)
if (d>0)
exit(3);
if (mn[i]-1+d>=rmd[i])
{
// if (cnt[k].f[mn[i]-1]-d<0)
// exit(5);
if (mn[i]==1)
{
printf("%d %d\n",rmd[i],d);
exit(4);
}
rmd[i]=rmd[i]+cnt[k].f[mn[i]-1]-d;
cnt_mod[mn[i]]++;
tr[k].add(--mn[i],1);
}
else
rmd[i]-=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]+1]=0;
}
b[p]=v;
mn[p]=mnp;
rmd[p]=rmdp;
}
else
{
int p;
scanf("%d",&p);
int k=b[p];
for (int r=min(((p-1)/B+1)*B,n),i=p+1;i<=r;i++)
if (b[i]<=k)
k++;
for (int i=(p-1)/B+1;i*B<n;i++)
k+=tr[i].v1[k]+tr[i].v2[(k-1)/B];
printf("%d\n",k);
}
}
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
// #pragma GCC optimize("O3")
// #pragma GCC target("avx2")
/*
find my code templates at https://github.com/galencolin/cp-templates
also maybe subscribe please thanks
*/
#define send {ios_base::sync_with_stdio(false);}
#define help {cin.tie(NULL);}
#define f first
#define s second
#define getunique(v) {sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());}
typedef long long ll;
// typedef int ll;
// #pragma warning("int")
typedef long double lld;
typedef unsigned long long ull;
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v);
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 rng(61378913);
/* usage - just do rng() */
void usaco(string filename) {
// #pragma message("be careful, freopen may be wrong")
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
// #include <atcoder/all>
// using namespace atcoder;
const lld pi = 3.14159265358979323846;
const ll mod = 1000000007;
// const ll mod = 998244353;
// ll mod;
struct segtree {
int n, depth;
vector<pair<ll, ll>> tree;
vector<ll> lazy;
void init(int s, long long* arr) {
n = s;
tree = vector<pair<ll, ll>>(4 * s, {1e9, 0});
lazy = vector<ll>(4 * s, 0);
init(0, 0, n - 1, arr);
}
pair<ll, ll> init(int i, int l, int r, long long* arr) {
if (l == r) return tree[i] = {arr[l], l};
int mid = (l + r) / 2;
pair<ll, ll> a = init(2 * i + 1, l, mid, arr),
b = init(2 * i + 2, mid + 1, r, arr);
return tree[i] = min(a, b);
}
void update(int l, int r, ll v) {
update(0, 0, n - 1, l, r, v);
}
pair<ll, ll> update(int i, int tl, int tr, int ql, int qr, ll v) {
eval_lazy(i, tl, tr);
if (ql <= tl && tr <= qr) {
lazy[i] += v;
eval_lazy(i, tl, tr);
return tree[i];
}
if (tl > tr || tr < ql || qr < tl) return tree[i];
if (tl == tr) return tree[i];
int mid = (tl + tr) / 2;
pair<ll, ll> a = update(2 * i + 1, tl, mid, ql, qr, v),
b = update(2 * i + 2, mid + 1, tr, ql, qr, v);
return tree[i] = min(a, b);
}
pair<ll, ll> query(int l, int r) {
return query(0, 0, n-1, l, r);
}
pair<ll, ll> query(int i, int tl, int tr, int ql, int qr) {
eval_lazy(i, tl, tr);
if (ql <= tl && tr <= qr) return tree[i];
if (tl > tr || tr < ql || qr < tl) return {1e9, -1};
int mid = (tl + tr) / 2;
pair<ll, ll> a = query(2 * i + 1, tl, mid, ql, qr),
b = query(2 * i + 2, mid + 1, tr, ql, qr);
return min(a, b);
}
/* varies by implementation */
/* this one is for range additions */
void eval_lazy(int i, int l, int r) {
/* special part */
tree[i].f += lazy[i];
if (l != r) {
lazy[i * 2 + 1] += lazy[i];
lazy[i * 2 + 2] += lazy[i];
}
/* end special part */
lazy[i] = 0;
}
};
ll n, m, q, k, l, r, x, y, z;
const ll template_array_size = 1e5 + 16614;
ll a[template_array_size];
string s, t;
const ll B = 100;
ll res[1005][1005];
segtree st[1005];
void build(ll b) {
ll lb = B * b, rb = min(n - 1, B * (b + 1) - 1);
st[b].init(rb - lb + 1, a + lb);
ll t = 0;
for (ll p = 1; p <= B; p++) {
auto x = st[b].query(0, rb - lb);
ll c = max(0LL, x.f - t);
st[b].update(x.s, rb - lb, -1);
st[b].update(x.s, x.s, 1e6);
t += c;
res[b][p] = t;
}
}
ll get(ll b, ll v) {
ll lv = 0, rv = B + 1;
while (lv < rv) {
ll mv = (lv + rv) / 2;
if (res[b][mv] > v) {
rv = mv;
} else {
lv = mv + 1;
}
}
return lv - 1;
}
void solve(int tc = 0) {
cin >> n;
for (ll i = 0; i < n; i++) cin >> a[i], a[i] = (i + 1) - a[i];
for (ll i = 0; i < n; i += B) build(i / B);
cin >> q;
for (ll i = 0; i < q; i++) {
ll t;
cin >> t >> x;
--x;
if (t == 1) {
cin >> y;
a[x] = (x + 1) - y;
build(x / B);
} else {
ll ans = a[x];
ll p = x + 1;
while (p < n) {
if (p % B != 0) {
ans += (ans >= a[p]);
++p;
} else {
ans += get(p / B, ans);
p += B;
}
}
cout << ans << '\n';
}
}
}
int main() {
#ifdef galen_colin_local
auto begin = std::chrono::high_resolution_clock::now();
#endif
send help
#ifndef galen_colin_local
// usaco("code");
#endif
// usaco("cowland");
// freopen("tc.cpp", "r", stdin);
// freopen("tc2.cpp", "w", stdout);
cout << setprecision(15) << fixed;
int tc = 1;
// cin >> tc;
for (int t = 0; t < tc; t++) solve(t);
#ifdef galen_colin_local
auto end = std::chrono::high_resolution_clock::now();
cerr << setprecision(4) << fixed;
cerr << "Execution time: " << std::chrono::duration_cast<std::chrono::duration<double>>(end - begin).count() << " seconds" << endl;
#endif
} |
#include <bits/stdc++.h>
using namespace std;
const int MAXN=100005,B=550,BC=(MAXN/B)+1;
struct BlockCnt
{
int f[MAXN],g[BC];
void add(int p,int d)
{
f[p]+=d;
g[(p-1)/B]+=d;
}
void query(int k,int &p,int &s)
{
s=k;
for (int i=0;;i++)
{
if ((i+1)*B+g[i]>=s)
for (int j=i*B+1;;j++)
{
if (j+f[j]>=s)
{
p=j;
return;
}
s-=f[j];
}
s-=g[i];
}
}
}cnt[BC];
struct TransInfo
{
int v1[MAXN],v2[BC];
void add(int k,int d)
{
v1[k]+=d;
}
void add(int l,int r,int d)
{
int lc=(l-1)/B,rc=(r-1)/B;
if (lc==rc)
for (int i=l;i<=r;i++)
v1[i]+=d;
else
{
for (int i=l;;i++)
{
v1[i]+=d;
if (i%B==0)
break;
}
for (int i=r;;i--)
{
v1[i]+=d;
if (i%B==1)
break;
}
for (int i=lc+1;i<rc;i++)
v2[i]+=d;
}
}
}tr[BC];
int n,b[MAXN],mn[MAXN],rmd[MAXN],cnt_mod[MAXN];
void build(int k,int l,int r)
{
for (int i=l;i<=r;i++)
{
cnt[k].query(b[i],mn[i],rmd[i]);
tr[k].v1[mn[i]]++;
cnt[k].add(mn[i],1);
}
for (int i=2;i<=n;i++)
tr[k].v1[i]+=tr[k].v1[i-1];
}
int main()
{
#ifdef KeyID
freopen("read.txt","r",stdin);
#endif
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&b[i]);
b[i]=i-b[i];
}
for (int i=1;i<=n;i+=B)
build((i-1)/B,i,min(i+B-1,n));
int m;
scanf("%d",&m);
while (m--)
{
int op;
scanf("%d",&op);
if (op==1)
{
int p,v;
scanf("%d%d",&p,&v);
v=p-v;
if (b[p]==v)
continue;
int k=(p-1)/B,r=min(n,(k+1)*B);
for (int i=r;i>=p;i--)
cnt[k].add(mn[i],-1);
int mnp,rmdp;
cnt[k].query(v,mnp,rmdp);
if (mn[p]==mnp)
for (int i=p;i<=r;i++)
cnt[k].add(mn[i],1);
else if (mn[p]<mnp)
{
tr[k].add(mn[p],mnp-1,-1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]-1]+(mn[p]<mn[i]&&mnp>=mn[i]?1:0);
if (mn[i]+cnt[k].f[mn[i]]<rmd[i]+d)
{
rmd[i]=rmd[i]-cnt[k].f[mn[i]]+d;
cnt_mod[mn[i]]++;
tr[k].add(mn[i]++,-1);
}
else
rmd[i]+=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]-1]=0;
}
else
{
tr[k].add(mnp,mn[p]-1,1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]]+(mn[p]>=mn[i]&&mnp<mn[i]?1:0);
if (mn[i]-1+d>=rmd[i])
{
rmd[i]=rmd[i]+cnt[k].f[mn[i]-1]-d;
cnt_mod[mn[i]]++;
tr[k].add(--mn[i],1);
}
else
rmd[i]-=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]+1]=0;
}
b[p]=v;
mn[p]=mnp;
rmd[p]=rmdp;
}
else
{
int p;
scanf("%d",&p);
int k=b[p];
for (int r=min(((p-1)/B+1)*B,n),i=p+1;i<=r;i++)
if (b[i]<=k)
k++;
for (int i=(p-1)/B+1;i*B<n;i++)
k+=tr[i].v1[k]+tr[i].v2[(k-1)/B];
printf("%d\n",k);
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, SZ = 150;
int n, q, a[maxn], bel[maxn], bl[maxn], br[maxn];
int tim = 1, lst[maxn], mem[maxn];
vector<int> pos[maxn / SZ + 5];
namespace BIT {
int c[maxn];
void add(int p, int v) {
for (; p <= n; p += p & -p) c[p] += v;
}
// min p s.t. c_p >= s
int find(int s) {
int p = 1;
for (int i = 1 << 16; i; i >>= 1) {
if (p + i <= n && c[p + i - 1] < s) p += i, s -= c[p - 1];
}
return p;
}
} // namespace BIT
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), a[i] = i - a[i];
}
for (int i = 1; i <= n; i++) {
br[bel[i] = (i - 1) / SZ + 1] = i;
if (!bl[bel[i]]) bl[bel[i]] = i;
}
auto rebuild = [&](int k) {
for (int i = bl[k]; i <= br[k]; i++) {
BIT::add(pos[k][i - bl[k]] = BIT::find(a[i]), 1);
}
for (int x : pos[k]) BIT::add(x, -1);
sort(pos[k].begin(), pos[k].end());
};
for (int i = 1; i <= n; i++) {
BIT::add(i, 1);
}
for (int i = 1; i <= bel[n]; i++) {
pos[i].resize(br[i] - bl[i] + 1), rebuild(i);
}
scanf("%d", &q);
while (q--) {
int op, i, x;
scanf("%d %d", &op, &i);
if (op == 1) {
scanf("%d", &x), tim++;
a[i] = i - x, rebuild(bel[i]);
} else {
if (lst[i] == tim) { printf("%d\n", mem[i]); continue; }
int cur = a[i];
for (int j = i + 1; j <= br[bel[i]]; j++) {
cur += a[j] <= cur;
}
for (int j = bel[i] + 1; j <= bel[n]; j++) {
cur += upper_bound(pos[j].begin(), pos[j].end(), cur) - pos[j].begin();
}
printf("%d\n", mem[i] = cur), lst[i] = tim;
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int MAXN=100005,B=350,BC=(MAXN/B)+1;
struct BlockCnt
{
int f[MAXN],g[BC];
void add(int p,int d)
{
f[p]+=d;
g[(p-1)/B]+=d;
}
void query(int k,int &p,int &s)
{
s=k;
for (int i=0;;i++)
{
if ((i+1)*B+g[i]>=s)
for (int j=i*B+1;;j++)
{
if (j+f[j]>=s)
{
p=j;
return;
}
s-=f[j];
}
s-=g[i];
}
}
}cnt[BC];
struct TransInfo
{
int v1[MAXN],v2[BC];
void add(int k,int d)
{
v1[k]+=d;
}
void add(int l,int r,int d)
{
int lc=(l-1)/B,rc=(r-1)/B;
if (lc==rc)
for (int i=l;i<=r;i++)
v1[i]+=d;
else
{
for (int i=l;;i++)
{
v1[i]+=d;
if (i%B==0)
break;
}
for (int i=r;;i--)
{
v1[i]+=d;
if (i%B==1)
break;
}
for (int i=lc+1;i<rc;i++)
v2[i]+=d;
}
}
}tr[BC];
int n,b[MAXN],mn[MAXN],rmd[MAXN],cnt_mod[MAXN];
void build(int k,int l,int r)
{
for (int i=l;i<=r;i++)
{
cnt[k].query(b[i],mn[i],rmd[i]);
tr[k].v1[mn[i]]++;
cnt[k].add(mn[i],1);
}
for (int i=2;i<=n;i++)
tr[k].v1[i]+=tr[k].v1[i-1];
}
int main()
{
#ifdef KeyID
freopen("read.txt","r",stdin);
#endif
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&b[i]);
b[i]=i-b[i];
}
for (int i=1;i<=n;i+=B)
build((i-1)/B,i,min(i+B-1,n));
int m;
scanf("%d",&m);
while (m--)
{
int op;
scanf("%d",&op);
if (op==1)
{
int p,v;
scanf("%d%d",&p,&v);
v=p-v;
if (b[p]==v)
continue;
int k=(p-1)/B,r=min(n,(k+1)*B);
for (int i=r;i>=p;i--)
cnt[k].add(mn[i],-1);
int mnp,rmdp;
cnt[k].query(v,mnp,rmdp);
if (mn[p]==mnp)
for (int i=p;i<=r;i++)
cnt[k].add(mn[i],1);
else if (mn[p]<mnp)
{
tr[k].add(mn[p],mnp-1,-1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]-1]+(mn[p]<mn[i]&&mnp>=mn[i]?1:0);
if (mn[i]+cnt[k].f[mn[i]]<rmd[i]+d)
{
rmd[i]=rmd[i]-cnt[k].f[mn[i]]+d;
cnt_mod[mn[i]]++;
tr[k].add(mn[i]++,-1);
}
else
rmd[i]+=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]-1]=0;
}
else
{
tr[k].add(mnp,mn[p]-1,1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]]+(mn[p]>=mn[i]&&mnp<mn[i]?1:0);
if (mn[i]-1+d>=rmd[i])
{
rmd[i]=rmd[i]+cnt[k].f[mn[i]-1]-d;
cnt_mod[mn[i]]++;
tr[k].add(--mn[i],1);
}
else
rmd[i]-=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]+1]=0;
}
b[p]=v;
mn[p]=mnp;
rmd[p]=rmdp;
}
else
{
int p;
scanf("%d",&p);
int k=b[p];
for (int r=min(((p-1)/B+1)*B,n),i=p+1;i<=r;i++)
if (b[i]<=k)
k++;
for (int i=(p-1)/B+1;i*B<n;i++)
k+=tr[i].v1[k]+tr[i].v2[(k-1)/B];
printf("%d\n",k);
}
}
return 0;
} |
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int N=100005,B=55;
int n,m,Q;
int a[N],b[N];
struct BIT
{
int C[N];
int lowbit(int x)
{
return x&-x;
}
void add(int x,int y)
{
for(int i=x;i<=n;i+=lowbit(i))
C[i]+=y;
return;
}
int getsum(int x)
{
int res=0;
for(int i=x;i>0;i-=lowbit(i))
res+=C[i];
return res;
}
}T;
int bel[N];
struct Block
{
int l,r;
int p[B+5];
}block[N/B+5];
void update(int k)
{
vector<int>pos;
for(int i=block[k].l;i<=block[k].r;i++)
{
int l=1,r=n,p=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(mid+T.getsum(mid)>=a[i]) p=mid,r=mid-1;
else l=mid+1;
}
pos.emplace_back(p);
T.add(p,1);
}
for(int v=0;v<=block[k].r-block[k].l+1;v++)
{
int l=v>0?block[k].p[v-1]:0,r=n,ans=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(T.getsum(mid)<=v) ans=mid,l=mid+1;
else r=mid-1;
}
block[k].p[v]=ans;
}
for(int p:pos)
T.add(p,-1);
return;
}
int query(int x)
{
int ans=a[x];
for(int i=x+1;i<=block[bel[x]].r;i++)
if(ans>=a[i]) ans++;
for(int i=bel[x]+1;i<=m;i++)
{
int v=lower_bound(block[i].p,block[i].p+block[i].r-block[i].l+1+1,ans)-block[i].p;
ans+=v;
}
return ans;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&b[i]);
for(int i=1;i<=n;i++)
a[i]=i-b[i];
for(int i=1;i<=n;i++)
bel[i]=(i-1)/B+1;
m=(n-1)/B+1;
for(int i=1;i<=m;i++)
block[i].l=(i-1)*B+1,block[i].r=min(i*B,n);
for(int k=1;k<=m;k++)
{
vector<int>pos;
for(int i=block[k].l;i<=block[k].r;i++)
{
int l=1,r=n,p=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(mid+T.getsum(mid)>=a[i]) p=mid,r=mid-1;
else l=mid+1;
}
pos.emplace_back(p);
T.add(p,1);
}
for(int v=0;v<=block[k].r-block[k].l+1;v++)
{
int l=v>0?block[k].p[v-1]:0,r=n,ans=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(T.getsum(mid)<=v) ans=mid,l=mid+1;
else r=mid-1;
}
block[k].p[v]=ans;
}
for(int p:pos)
T.add(p,-1);
}
scanf("%d",&Q);
while(Q--)
{
int op,i;
scanf("%d",&op);
if(op==1)
{
int x;
scanf("%d%d",&i,&x);
b[i]=x,a[i]=i-b[i];
update(bel[i]);
}
else if(op==2)
{
scanf("%d",&i);
printf("%d\n",query(i));
}
}
return 0;
} |
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("inline")
#include<bits/stdc++.h>
using namespace std;
inline int my_getchar(){
static char buf[1048576];
static int s = 1048576;
static int e = 1048576;
if(s == e && e == 1048576){
e = fread(buf, 1, 1048576, stdin);
s = 0;
}
if(s == e){
return EOF;
}
return buf[s++];
}
inline void rd(int &x){
int k;
int m=0;
x=0;
for(;;){
k = my_getchar();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = my_getchar();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
struct MY_WRITER{
char buf[1048576];
int s;
int e;
MY_WRITER(){
s = 0;
e = 1048576;
}
~MY_WRITER(){
if(s){
fwrite(buf, 1, s, stdout);
}
}
}
;
MY_WRITER MY_WRITER_VAR;
void my_putchar(int a){
if(MY_WRITER_VAR.s == MY_WRITER_VAR.e){
fwrite(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
MY_WRITER_VAR.s = 0;
}
MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a){
my_putchar(a);
}
inline void wt_L(int x){
int s=0;
int m=0;
char f[10];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
my_putchar('-');
}
while(s--){
my_putchar(f[s]+'0');
}
}
template<class T, class S> inline T RoundUp(T a, S b){
T m;
if(b < 0){
b = -b;
}
if(b <= 1){
return a;
}
m = a % b;
if(m == 0){
return a;
}
if(m < 0){
m += b;
}
return ((a + b - m) / b) * b;
}
template<class S, class T> inline S chmin(S &a, T b){
if(a>b){
a=b;
}
return a;
}
int N;
int B[100000];
int Q;
int T;
int IND;
int X;
int memo[200][100000];
int ctm[200][100000];
int qtm[200];
int main(){
int i, q;
int res;
int tmp;
int t = 0;
int up;
rd(N);
{
int Lj4PdHRW;
for(Lj4PdHRW=(0);Lj4PdHRW<(N);Lj4PdHRW++){
rd(B[Lj4PdHRW]);
}
}
rd(Q);
for(i=(0);i<(N);i++){
B[i] = i - B[i];
}
for(i=(0);i<(200);i++){
qtm[i] = -1;
}
for(i=(0);i<(200);i++){
int j;
for(j=(0);j<(N);j++){
ctm[i][j] = -2;
}
}
for(q=(0);q<(Q);q++){
rd(T);
rd(IND);IND += (-1);
if(T==1){
rd(X);
B[IND] = IND - X;
qtm[IND/500] = q;
}
else{
up = RoundUp(IND+1, 500);
chmin(up, N);
res = B[IND];
for(i=(IND+1);i<(up);i++){
if(res >= B[i]){
res++;
}
}
IND = up;
while(IND < N){
up = IND + 500;
chmin(up, N);
if(ctm[IND/500][res] < qtm[IND/500]){
ctm[IND/500][res] = q;
tmp = res;
for(i=(IND);i<(up);i++){
if(res >= B[i]){
res++;
}
}
memo[IND/500][tmp] = res;
}
else{
res = memo[IND/500][res];
}
IND = up;
}
wt_L(res+1);
wt_L('\n');
}
}
return 0;
}
// cLay version 20210619-1 [beta]
// --- original code ---
// //no-unlocked
// int N, B[1d5], Q, T, IND, X;
// int memo[200][1d5], ctm[200][1d5], qtm[200];
// {
// int res, tmp, t = 0, up;
// rd(N,B(N),Q);
// // N = Q = 1d5;
// // rep(i,N) B[i] = rand()%(i+1);
// rep(i,N) B[i] = i - B[i];
//
// rep(i,200) qtm[i] = -1;
// rep(i,200) rep(j,N) ctm[i][j] = -2;
//
// rep(q,Q){
// rd(T,IND--);
// // T = 2;
// // IND = rand()%100;
// if(T==1){
// rd(X);
// B[IND] = IND - X;
// qtm[IND/500] = q;
// } else {
// up = RoundUp(IND+1, 500);
// up <?= N;
// res = B[IND];
// rep(i,IND+1,up) if(res >= B[i]) res++;
//
// IND = up;
// while(IND < N){
// up = IND + 500;
// up <?= N;
// if(ctm[IND/500][res] < qtm[IND/500]){
// ctm[IND/500][res] = q;
// tmp = res;
// rep(i,IND,up) if(res >= B[i]) res++;
// memo[IND/500][tmp] = res;
// } else {
// res = memo[IND/500][res];
// }
// IND = up;
// }
//
// // t += res;
// wt(res+1);
// }
// }
// // wt(t);
// }
|
#include<bits/stdc++.h>
using namespace std;
const int maxn=100005;
const int mlog=18;
const int B=200;
const int S=maxn/B+5;
int n,q,m;
int a[maxn],p[maxn],c[maxn],bl[S],br[S],bu[maxn];
namespace Fenwick{
int t[maxn];
void add(int v,int val){
for(;v<=n;v+=(v&-v))
t[v]+=val;
}
int qry(int k){
int res=0;
for(int i=mlog-1;i>=0;i--){
int cur=res+(1<<i);
if(cur<=n&&(1<<i)-t[cur]<k)
k-=(1<<i)-t[cur],res=cur;
}
res++;
return res;
}
}
void update(int id){
for(int i=br[id];i>=bl[id];i--){
p[i]=Fenwick::qry(a[i]);
Fenwick::add(p[i],1);
}
for(int i=bl[id];i<=br[id];i++)
Fenwick::add(p[i],-1),c[i]=p[i];
sort(c+bl[id],c+br[id]+1);
}
int query(int id,int k){
int l=bl[id]-1,r=br[id];
while(l<r){
int mid=l+r+1>>1;
if(c[mid]-(mid-bl[id]+1)<k)l=mid;
else r=mid-1;
}
return k+l-bl[id]+1;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]),a[i]=i-a[i];
for(int i=1;i<=n;i+=B){
m++;
bl[m]=i;
br[m]=min(n,i+B-1);
for(int j=bl[m];j<=br[m];j++)bu[j]=m;
update(m);
}
scanf("%d",&q);
while(q--){
int op,i;
scanf("%d%d",&op,&i);
if(op==1){
int x;
scanf("%d",&x);
a[i]=i-x;
update(bu[i]);
}
else{
int ans=p[i];
for(int j=bu[i]+1;j<=m;j++)
ans=query(j,ans);
printf("%d\n",ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int mod=1e9+7;
struct node
{
vector<int> s;
node(int n):s(n){}
void upd(int pos,int val)
{
for(;pos<s.size();pos|=pos+1)
s[pos]+=val;
}
int qry(int pos)
{
int res=0;
for(;pos>0;pos&=pos-1)
res+=s[pos-1];
return res;
}
int lb(int st)
{
if(st<=0)
return -1;
int pos=0;
for(int x=1<<19;x;x>>=1)
{
if(pos+x<=s.size() and s[pos+x-1]<st)
{
pos+=x;
st-=s[pos-1];
}
}
return pos;
}
};
void solve()
{
int n;
cin>>n;
vector<int> b(n);
for(auto& x:b)
cin>>x;
const int fx=max(1LL,(int)(sqrt(0.2*n)));
const int nax=(n+fx-1)/fx;
vector<int> l(nax),r(nax);
vector<vector<int>> a(nax);
node root(n+1);
for(int i=1;i<=n;i++)
root.upd(i,1);
auto qry=[&](int pos)
{
for(int j=l[pos];j<r[pos];j++)
{
int& vals=a[pos][j-l[pos]];
vals=max(0LL,root.lb(b[j]));
root.upd(vals,1);
}
for(int j=l[pos];j<r[pos];j++)
{
int& vals=a[pos][j-l[pos]];
root.upd(vals,-1);
}
sort(a[pos].begin(),a[pos].end());
};
for(int i=0;i<nax;i++)
{
l[i]=i*fx;
r[i]=min(n,(i+1)*fx);
a[i].resize(r[i]-l[i]);
qry(i);
}
int qq;
cin>>qq;
while(qq--)
{
int ty;
cin>>ty;
if(ty==1)
{
int i,x;
cin>>i>>x;
--i;
b[i]=x;
qry(i/fx);
}
else
{
int i;
cin>>i;
--i;
int id=i/fx;
int res=b[i];
for(int j=i+1;j<r[id];j++)
res+=(res>=b[j]);
for(int k=id+1;k<nax;k++)
res+=(int)(upper_bound(a[k].begin(),a[k].end(),res)-a[k].begin());
cout<<n-res<<'\n';
}
}
}
int32_t main()
{
int t=1;
//cin>>t;
while(t--)
solve();
return 0;
}
|
#include <bits/stdc++.h>
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int N; cin >> N;
const int LEVELS = 9;
std::array<std::vector<int>, LEVELS+1> B;
B[0].resize(N);
for (int i = 0; i < N; i++) {
cin >> B[0][i];
}
auto update = [&](int l, int lo) -> void {
assert(1 <= l && l <= LEVELS);
assert(0 <= lo && lo < N);
int md = min(N, lo + (1 << (l-1)));
int hi = min(N, lo + (1 << l));
// merge lo..md and md..hi
const auto& prv = B[l-1];
auto& cur = B[l];
int cur_diff = 0;
for (int i = lo, j = md, k = lo; k < hi; k++) {
if (i == md || (j < hi && prv[j] - cur_diff <= prv[i])) {
cur[k] = prv[j] - cur_diff;
j++;
} else {
cur[k] = prv[i];
i++;
cur_diff++;
}
}
};
for (int l = 1; l <= LEVELS; l++) {
B[l].resize(N);
for (int lo = 0; lo < N; lo += (1 << l)) {
update(l, lo);
}
}
int Q; cin >> Q;
while (Q--) {
int op; cin >> op;
if (op == 1) {
int i, x; cin >> i >> x; i--;
B[0][i] = x;
for (int l = 1; l <= LEVELS; l++) update(l, i >> l << l);
} else if (op == 2) {
int i; cin >> i; i--;
int v = B[0][i];
i++;
while (i < N) {
int l = min(LEVELS, __builtin_ctz(i));
const auto& dp = B[l];
auto lo = dp.begin() + i;
auto hi = dp.begin() + min(N, i + (1 << l));
v += int(upper_bound(lo, hi, v) - lo);
i = min(N, i + (1 << l));
}
cout << N-v << '\n';
} else assert(false);
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cctype>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <ctime>
#include <cassert>
#define _for(i,a,b) for(int i=(a);i<(b);++i)
#define _rep(i,a,b) for(int i=(a);i<=(b);++i)
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
inline int read_int(){
int t=0;bool sign=false;char c=getchar();
while(!isdigit(c)){sign|=c=='-';c=getchar();}
while(isdigit(c)){t=(t<<1)+(t<<3)+(c&15);c=getchar();}
return sign?-t:t;
}
inline LL read_LL(){
LL t=0;bool sign=false;char c=getchar();
while(!isdigit(c)){sign|=c=='-';c=getchar();}
while(isdigit(c)){t=(t<<1)+(t<<3)+(c&15);c=getchar();}
return sign?-t:t;
}
inline char get_char(){
char c=getchar();
while(c==' '||c=='\n'||c=='\r')c=getchar();
return c;
}
inline void write(LL x){
register char c[21],len=0;
if(!x)return putchar('0'),void();
if(x<0)x=-x,putchar('-');
while(x)c[++len]=x%10,x/=10;
while(len)putchar(c[len--]+48);
}
inline void space(LL x){write(x),putchar(' ');}
inline void enter(LL x){write(x),putchar('\n');}
const int MAXN=1e5+5,MAXB=600;
int b[MAXN];
struct Tree{
int lef[MAXB<<2],rig[MAXB<<2];
vector<int> p[MAXB<<2];
void push_up(int k){
int pos1=0,pos2=0,k1=k<<1,k2=k<<1|1;
p[k].clear();
_rep(i,lef[k],rig[k]){
if(pos1<p[k1].size()&&pos2<p[k2].size()){
if(p[k1][pos1]+pos2<p[k2][pos2])
p[k].push_back(p[k1][pos1++]+pos2);
else
p[k].push_back(p[k2][pos2++]);
}
else if(pos1<p[k1].size())
p[k].push_back(p[k1][pos1++]+pos2);
else
p[k].push_back(p[k2][pos2++]);
}
}
void build(int k,int L,int R){
lef[k]=L,rig[k]=R;
int M=L+R>>1;
if(L==R){
p[k].push_back(b[M]);
return;
}
build(k<<1,L,M);
build(k<<1|1,M+1,R);
push_up(k);
}
void update(int k,int pos){
if(lef[k]==rig[k]){
p[k][0]=b[pos];
return;
}
int mid=lef[k]+rig[k]>>1;
if(pos<=mid)
update(k<<1,pos);
else
update(k<<1|1,pos);
push_up(k);
}
int query(int v){
int lef=1,rig=p[1].size(),ans=0;
while(lef<=rig){
int mid=lef+rig>>1;
if(v+mid>p[1][mid-1]){
ans=mid;
lef=mid+1;
}
else
rig=mid-1;
}
return ans;
}
}tree[MAXB];
int blk_id[MAXN],lef[MAXB],rig[MAXB];
int main()
{
// freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
int n=read_int(),blk_sz=sqrt(n*log(n))/2+1,m=n/blk_sz;
if(n%blk_sz)m++;
_rep(i,1,n)b[i]=i-1-read_int();
_for(i,0,m){
lef[i]=i*blk_sz+1;
rig[i]=min((i+1)*blk_sz,n);
_rep(j,lef[i],rig[i])
blk_id[j]=i;
tree[i].build(1,lef[i],rig[i]);
}
int q=read_int();
while(q--){
int opt=read_int(),x=read_int();
if(opt==1){
b[x]=x-1-read_int();
tree[blk_id[x]].update(1,x);
}
else{
int ans=b[x];
_rep(i,x+1,rig[blk_id[x]]){
if(ans>=b[i])
ans++;
}
_for(i,blk_id[x]+1,m)
ans+=tree[i].query(ans);
enter(ans+1);
}
}
return 0;
}
|
// EZ problem
#include <bits/stdc++.h>
const int maxn = 1e5 + 222;
const int B = 165;
int n,q,l[maxn],r[maxn],in[maxn],f[maxn],b[maxn],rt;
std::vector<int>vec[maxn];
int ch[maxn][2],sum[maxn],tl;
int newnode() {
sum[++tl] = 0;
ch[tl][0] = ch[tl][1] = 0;
return tl;
}
void insert(int p,int l,int r,int rt) {
while (1) {
sum[rt] ++;
if (l == r) return ;
int mid = (l + r) >> 1;
if (p <= mid) {
if (!ch[rt][0]) ch[rt][0] = newnode();
r = mid;
rt = ch[rt][0];
} else {
if (!ch[rt][1]) ch[rt][1] = newnode();
l = mid + 1;
rt = ch[rt][1];
}
}
}
int query(int v,int l,int r,int rt) {
while (1) {
if (l == r) return l;
if (!rt) return v;
int mid = (l + r) >> 1;
if (sum[ch[rt][0]] + mid >= v) {
r = mid; rt = ch[rt][0];
} else {
v -= sum[ch[rt][0]];
l = mid + 1;
rt = ch[rt][1];
}
}
}
void rebuild(int p) {
tl = 0;
rt = newnode();
vec[p].clear();
// printf(">%d\n",r[p] - l[p]);
for (int i = l[p]; i <= r[p]; ++ i) {
// lim + pre >= b[p]
f[i] = query(b[i],0,n,rt);
insert(f[i],0,n,rt);
vec[p].push_back(f[i]);
} std::sort(vec[p].begin(),vec[p].end());
}
int Bquery(int p,int lim) {
return std::upper_bound(vec[p].begin(),vec[p].end(),lim) - vec[p].begin();
}
int read() {
int x = 0; char c = getchar();
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
return x;
}
int main() {
// freopen("in.txt","r",stdin);
scanf("%d",&n);
for (int i = 1; i <= n; ++ i)
b[i] = read();
for (int i = 1; i <= n; ++ i) {
in[i] = (i - 1) / B + 1;
if (!l[in[i]]) l[in[i]] = i;
r[in[i]] = i;
//printf("%d ",in[i]);
} //puts("");
for (int i = 1; i <= in[n]; ++ i)
rebuild(i);
scanf("%d",&q);
while (q --) {
int opt;
opt = read();
if (opt == 1) {
int i,x;
i = read(); x = read();
b[i] = x;
rebuild(in[i]);
//for (int i = 1; i <= n; ++ i) {
// printf("%d ",f[i]);
// } puts("");
} else {
int p;
p = read();
int cnt = b[p];
int x = cnt;
int lim = x;
// will be triggered if <= lim
for (int i = p + 1; i <= r[in[p]]; ++ i) {
if (b[i] <= lim) {
cnt ++;
lim ++;
}
}
for (int i = in[p] + 1; i <= in[n]; ++ i) {
int d = Bquery(i,lim);
cnt += d;
lim += d;
} printf("%d\n",n - cnt);
}
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
const int nn = 1e5 + 5;
const int inf = 1e9;
struct node {
int val, lazy, pos;
#define val(p) tree[p].val
#define lazy(p) tree[p].lazy
#define pos(p) tree[p].pos
#define ls (p << 1)
#define rs (p << 1 | 1)
} tree[nn << 3];
void update(int p) {
if (val(ls) < val(rs)) {
val(p) = val(ls);
pos(p) = pos(ls);
} else {
val(p) = val(rs);
pos(p) = pos(rs);
}
}
int c[nn];
void build(int p, int l, int r) {
if (l == r) {
val(p) = c[l];
pos(p) = l;
return;
}
int mid = l + r >> 1;
build(ls, l, mid);
build(rs, mid + 1, r);
update(p);
}
void pushdown(int p) {
if (!lazy(p)) return;
lazy(ls) += lazy(p);
val(ls) += lazy(p);
lazy(rs) += lazy(p);
val(rs) += lazy(p);
lazy(p) = 0;
}
void modify(int p, int l, int r, int pos, int val) {
if (l == r) {
val(p) = val;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (pos <= mid) modify(ls, l, mid, pos, val);
else modify(rs, mid + 1, r, pos, val);
update(p);
}
void add(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
val(p)--; lazy(p)--;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (ql <= mid) add(ls, l, mid, ql, qr);
if (mid < qr) add(rs, mid + 1, r, ql, qr);
update(p);
}
int a[nn], stack[3005][3005], lenth[nn];
void build_b(int p, int l, int r) {
for (int i = 1; i <= 2000; i++)
tree[i] = (node){0, 0, 0};
for (int i = l; i <= r; i++) c[i - l + 1] = a[i];
int len = r - l + 1;
build(1, 1, len);
for (int i = 1; i <= len; i++) {
stack[p][i] = std::max(val(1), stack[p][i - 1]);
int pos = pos(1);
if (pos != len) add(1, 1, len, pos + 1, len);
modify(1, 1, len, pos, inf);
}
stack[p][lenth[p] + 1] = inf;
}
int n, m, block, bl[nn], l[nn], r[nn];
int main() {
scanf("%d", &n);
block = 200;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
bl[i] = (i - 1) / block + 1;
}
for (int i = 1; i <= bl[n]; i++) {
l[i] = i * block - block + 1;
r[i] = std::min(n, i * block);
lenth[i] = r[i] - l[i] + 1;
build_b(i, l[i], r[i]);
}
scanf("%d", &m);
while (m--) {
int opt, x;
scanf("%d %d", &opt, &x);
if (opt == 1) {
scanf("%d", a + x);
build_b(bl[x], l[bl[x]], r[bl[x]]);
} else {
int ans = a[x];
for (int i = x + 1; i <= r[bl[x]]; i++) ans += (ans >= a[i]);
for (int i = bl[x] + 1; i <= bl[n]; i++) {
int pos = std::upper_bound(stack[i] + 1, stack[i] + lenth[i] + 2, ans) - stack[i];
ans += pos - 1;
}
printf("%d\n", n - ans);
}
}
} |
#include<bits/stdc++.h>
using namespace std;
#define forg(i,x) for(register int i=fir[x];i;i=nxt[i])
#define uu unsigned
#define scanf a14=scanf
#define rint register int
#define fre(x) freopen(#x".in","r",stdin),freopen(#x".out","w",stdout)
typedef long long ll;
typedef uu long long ull;
typedef pair<int,int>pii;
int a14;
inline int rd(int l,int r){return rand()%(r-l+1)+l;}
const int mxn=1e5+3,sq=300,qs=320;
int n,b[mxn],lp[mxn],rp[mxn],kn,be[mxn],po[mxn],qn,ls[mxn];
int ju[mxn/sq+2][mxn],ad[mxn/sq+2][mxn];
int TG;
struct shu{
int a[mxn],tg[mxn];
void add(int x){for(;x<=n;x+=x&-x){if(tg[x]!=TG)tg[x]=TG,a[x]=0;++a[x];}}
int ask(int x){
int su=0,p=0;
for(int i=1<<16;i;i>>=1){
if(p+i>=n)continue;
p+=i;if(tg[p]!=TG)tg[p]=TG,a[p]=0;
if(p+a[p]+su>=x)p-=i;else su+=a[p];
}
return p+1;
}
void gb(int t){for(int i=1;i<=n;++i){if(tg[i]!=TG)a[i]=0;ju[t][i]=ju[t][i-(i&-i)]+a[i];}for(int i=1;i<=n;++i)ju[t][i]+=i;}
}ar;
void add2(int t,int x,int y){
int k=(x-1)/qs;
for(int i=x;i<=(k+1)*qs;++i)ju[t][i]+=y;
for(++k;k*qs+1<=n;++k)ad[t][k]+=y;
}
int main(){
scanf("%d",&n);for(int i=1;i<=n;++i)scanf("%d",b+i),b[i]=i-b[i];scanf("%d",&qn);
for(int l=1,r;r!=n;l=r+1){r=min(l+sq-1,n);lp[++kn]=l,rp[kn]=r;for(int i=l;i<=r;++i)be[i]=kn;}
for(int t=1;t<=kn;++t){
++TG; for(int i=lp[t];i<=rp[t];++i)po[i]=ar.ask(b[i]),ar.add(po[i]);
ar.gb(t);
}
while(qn--){
int o,x,y;scanf("%d%d",&o,&x);if(o==1){
scanf("%d",&y);b[x]=x-y;int k=be[x],ls;
++TG;for(int i=lp[k];i<=rp[k];++i){
if(i<x)ar.add(po[i]);else{
ls=po[i],po[i]=ar.ask(b[i]),ar.add(po[i]);
if(ls==po[i])continue;
if(ls==po[i]-1){--ju[k][ls];continue;}
if(ls==po[i]+1){++ju[k][po[i]];continue;}
add2(k,ls,-1),add2(k,po[i],1);
}
}
}else{
int t=be[x],re=b[x];for(int i=x+1;i<=rp[t];++i)re+=b[i]<=re;
for(++t;t<=kn;++t)re=ju[t][re]+ad[t][(re-1)/qs];
printf("%d\n",re);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gi() {
int res = 0, w = 1;
char ch = getchar();
while (ch != '-' && !isdigit(ch)) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) res = res * 10 + ch - '0', ch = getchar();
return res * w;
}
const int MAX_N = 1e5 + 5;
const int BLOCK = 1005;
int N, Q, BLK;
int b[MAX_N], bL[BLOCK], bR[BLOCK], bel[MAX_N];
vector<int> pot[BLOCK];
int c[MAX_N];
inline int lb(int x) { return x & -x; }
void add(int x, int v) { for (; x <= N; x += lb(x)) c[x] += v; }
int sum(int x) { int res = 0; for (; x; x -= lb(x)) res += c[x]; return res; }
int kth(int k) {
int res = 0, now = 0;
for (int i = 16; ~i; i--)
if (res + (1 << i) <= N && now + c[res | (1 << i)] < k)
res += 1 << i, now += c[res];
return res + 1;
}
void rebuild(int o) {
static int pos[MAX_N];
for (int i = bR[o]; i >= bL[o]; i--) {
pos[i] = kth(b[i] + 1);
add(pos[i], -1);
}
pot[o].clear();
for (int i = bL[o]; i <= bR[o]; i++) pot[o].push_back(sum(pos[i]));
sort(pot[o].begin(), pot[o].end());
for (int i = bL[o]; i <= bR[o]; i++) add(pos[i], 1);
}
int main () {
#ifndef ONLINE_JUDGE
freopen("cpp.in", "r", stdin);
#endif
N = gi(), BLK = max(1, (int)sqrt(N / 2));
for (int i = 1; i <= N; i++) b[i] = gi();
for (int i = 1; i <= N; i++) bel[i] = (i - 1) / BLK + 1;
for (int i = 1; i <= N; i++) {
if (bel[i] != bel[i - 1]) bL[bel[i]] = i;
bR[bel[i]] = i;
}
for (int i = 1; i <= N; i++) add(i, 1);
for (int i = 1; i <= bel[N]; i++) rebuild(i);
Q = gi();
while (Q--) {
int op = gi(), x = gi();
if (op == 1) b[x] = gi(), rebuild(bel[x]);
else {
int ans = b[x] + 1;
for (int i = x + 1; i <= bR[bel[x]]; i++) if (ans > b[i]) ans++;
for (int i = bel[x] + 1; i <= bel[N]; i++)
ans += lower_bound(pot[i].begin(), pot[i].end(), ans) - pot[i].begin();
printf("%d\n", N - ans + 1);
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
#define F first
#define S second
const int MOD = 1e9 + 7;//XXX
const int C = 26;//XXX
void add(int &x, int y){
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x){
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b){
int ret = 1;
while (b){
if (b & 1)
ret = 1ll*ret*a%MOD;
b >>= 1;
a = 1ll*a*a%MOD;
}
return ret;
}
const int MAXN = 1e5 + 10;
const int SQ = 100;
int n, a[MAXN];
int weed[MAXN<<2];
vector<int> vec[(MAXN + SQ - 1) / SQ]; // +1 for each of these you're >= than
void plant(int v, int b, int e) {
if(e-b == 1) {
weed[v] = b != 0;
return;
}
int m = (b + e) >> 1;
plant(v<<1, b, m);
plant(v<<1^1, m, e);
weed[v] = weed[v<<1] + weed[v<<1^1];
}
void water(int v, int b, int e, int i, int x) {
if(e-b == 1) {
weed[v] += x;
return;
}
int m = (b + e) >> 1;
if(i < m)
water(v<<1, b, m, i, x);
else
water(v<<1^1, m, e, i, x);
weed[v] = weed[v<<1] + weed[v<<1^1];
}
int descend(int s) { // first >= s
int v = 1, b = 0, e = n;
while(b < e) {
if(e-b == 1) {
return weed[v] < s ? e : b;
}
int m = (b + e) >> 1;
if(weed[v<<1] < s) {
s -= weed[v<<1];
v = v<<1^1;
b = m;
} else {
v = v<<1;
e = m;
}
}
return -1;
}
void build(int id) {
vec[id].clear();
int l = id * SQ, r = min(n, l + SQ);
for(int i = l; i < r; i++) {
int j = descend(a[i]);
vec[id].push_back(j);
water(1, 0, n, j, 1);
}
for(int j : vec[id])
water(1, 0, n, j, -1);
sort(vec[id].begin(), vec[id].end());
}
void qry() {
int i; cin >> i; i--;
int ans = a[i];
for(i++; i < n && i % SQ != 0; i++)
if(a[i] <= ans)
++ans;
for(; i < n; i += SQ) {
ans += upper_bound(vec[i / SQ].begin(), vec[i / SQ].end(), ans) - vec[i / SQ].begin();
}
cout << ans+1 << "\n";
}
void solve() {
cin >> n;
for(int i = 0; i < n; i++) {
cin >> a[i];
a[i] = i - a[i];
}
plant(1, 0, n);
for(int l = 0; l < n; l += SQ) {
build(l / SQ);
}
int q; cin >> q;
while(q--) {
int qt; cin >> qt;
if(qt == 1) {
int i, x; cin >> i >> x; --i; x = i - x;
a[i] = x;
build(i / SQ);
} else {
qry();
}
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//cout << fixed << setprecision(6);
int te = 1;
//cin >> te;
for (int w = 1; w <= te; w++){
//cout << "Case #" << w << ": ";
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#define range(i, n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define ar array
using namespace std;
typedef long long ll;
typedef double ld;
typedef unsigned long long ull;
const ll INF = 2e18;
const int INFi = 2e9 + 5;
const int maxN = 1e5 + 1;
const int md = 1e9 + 7;
const int K = 150;
int n;
int b[maxN];
int bl[maxN];
struct fenwick {
int n{};
vector<int> fenw{};
void build(int k) {
n = k;
fenw.resize(n);
}
void upd(int i, int x) {
for (; i < n; i = i | (i + 1)) fenw[i] += x;
}
int get(int i) {
int res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) res += fenw[i];
return res;
}
int get(int l, int r) {
if (l > r) return 0;
return get(r) - get(l - 1);
}
void clear(vector<int> &was) {
for(auto &x : was) {
upd(x, -1);
}
}
} F;
// K log N
void rebuild(int block) {
int l = block * K;
int r = min(l + K, n);
vector<int> res;
for(int i = l; i < r; ++i) {
if (res.empty()) {
res.push_back(b[i]);
F.upd(b[i], 1);
continue;
}
int cur = -1;
int ad = 0;
for(int j = 18; j >= 0; --j) {
int t = 1 << j;
if (cur + t < n && cur + t + F.fenw[cur + t] + ad < b[i]) {
cur += t;
ad += F.fenw[cur];
}
}
cur++;
res.push_back(cur);
F.upd(cur, 1);
}
F.clear(res);
sort(all(res));
for(int i = l; i < r; ++i) {
bl[i] = res[i - l];
}
}
void upd(int i, int x) {
b[i] = x;
b[i] = i - b[i];
rebuild(i / K);
}
// N / K log N
int get(int i) {
int bq = i / K;
int r = min((bq + 1) * K, n);
int to = b[i];
for(int j = i + 1; j < r; ++j) {
if (b[j] <= to) to++;
}
int l = bq * K;
for(int j = bq + 1; j * K < n; ++j) {
r += K;
l += K;
if (r > n) r = n;
int c = (int)(upper_bound(bl + l, bl + r, to) - (bl + l));
to += c;
}
return to;
}
void solve() {
cin >> n;
F.build(n + 5);
range(i, n) {
cin >> b[i];
b[i] = i - b[i];
}
for(int j = 0; j * K < n; ++j) {
rebuild(j);
}
int q; cin >> q;
range(_, q) {
int t; cin >> t;
if (t == 1) {
int i, x; cin >> i >> x;
i--;
upd(i, x);
} else {
int i; cin >> i;
i--;
cout << get(i) + 1 << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
// cout << setprecision(15) << fixed;
int tests = 1;
// cin >> tests;
range(_, tests) {
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, SZ = 150;
int n, q, a[maxn], bel[maxn], bl[maxn], br[maxn];
vector<int> pos[maxn / SZ + 5];
namespace BIT {
int c[maxn];
void add(int p, int v) {
for (; p <= n; p += p & -p) c[p] += v;
}
// min p s.t. c_p >= s
int find(int s) {
int p = 1;
for (int i = 1 << 16; i; i >>= 1) {
if (p + i <= n && c[p + i - 1] < s) p += i, s -= c[p - 1];
}
return p;
}
} // namespace BIT
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), a[i] = i - a[i];
}
for (int i = 1; i <= n; i++) {
br[bel[i] = (i - 1) / SZ + 1] = i;
if (!bl[bel[i]]) bl[bel[i]] = i;
}
auto rebuild = [&](int k) {
for (int i = bl[k]; i <= br[k]; i++) {
BIT::add(pos[k][i - bl[k]] = BIT::find(a[i]), 1);
}
for (int x : pos[k]) BIT::add(x, -1);
sort(pos[k].begin(), pos[k].end());
};
for (int i = 1; i <= n; i++) {
BIT::add(i, 1);
}
for (int i = 1; i <= bel[n]; i++) {
pos[i].resize(br[i] - bl[i] + 1), rebuild(i);
}
scanf("%d", &q);
while (q--) {
int op, i, x;
scanf("%d %d", &op, &i);
if (op == 1) {
scanf("%d", &x);
a[i] = i - x, rebuild(bel[i]);
} else {
int cur = a[i];
for (int j = i + 1; j <= br[bel[i]]; j++) {
cur += a[j] <= cur;
}
for (int j = bel[i] + 1; j <= bel[n]; j++) {
cur += upper_bound(pos[j].begin(), pos[j].end(), cur) - pos[j].begin();
}
printf("%d\n", cur);
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, SZ = 120;
int n, q, a[maxn], bel[maxn], bl[maxn], br[maxn];
vector<int> pos[maxn / SZ + 5];
namespace BIT {
int c[maxn];
void add(int p, int v) {
for (; p <= n; p += p & -p) c[p] += v;
}
// min p s.t. c_p >= s
int find(int s) {
int p = 1;
for (int i = 1 << 16; i; i >>= 1) {
if (p + i <= n && c[p + i - 1] < s) p += i, s -= c[p - 1];
}
return p;
}
} // namespace BIT
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), a[i] = i - a[i];
}
for (int i = 1; i <= n; i++) {
br[bel[i] = (i - 1) / SZ + 1] = i;
if (!bl[bel[i]]) bl[bel[i]] = i;
}
auto rebuild = [&](int k) {
for (int i = bl[k]; i <= br[k]; i++) {
BIT::add(pos[k][i - bl[k]] = BIT::find(a[i]), 1);
}
for (int x : pos[k]) BIT::add(x, -1);
sort(pos[k].begin(), pos[k].end());
};
for (int i = 1; i <= n; i++) {
BIT::add(i, 1);
}
for (int i = 1; i <= bel[n]; i++) {
pos[i].resize(br[i] - bl[i] + 1), rebuild(i);
}
scanf("%d", &q);
while (q--) {
int op, i, x;
scanf("%d %d", &op, &i);
if (op == 1) {
scanf("%d", &x);
a[i] = i - x, rebuild(bel[i]);
} else {
int cur = a[i];
for (int j = i + 1; j <= br[bel[i]]; j++) {
cur += a[j] <= cur;
}
for (int j = bel[i] + 1; j <= bel[n]; j++) {
cur += upper_bound(pos[j].begin(), pos[j].end(), cur) - pos[j].begin();
}
printf("%d\n", cur);
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 100005;const int maxd = 205;const int maxk = 505;int n, q, b[maxn];int d, k, bel[maxn], st[maxn], ed[maxn];vector<int> val[maxk], T[maxd << 2];
void pushup(int id, int len) {int lc = id << 1, rc = id << 1 | 1;int lenl = (len + 1) / 2, lenr = len / 2;for(int i = 0, j = 0; i <= lenl && j <= len; i++) {
int nl = T[lc][i], nr = (i == lenl) ? n : T[lc][i + 1] - 1;for(; j - i <= lenr && nr + i >= T[rc][j - i]; j++)T[id][j] = max(nl, T[rc][j - i] - i);}}
void solve(int l, int r, int id) {T[id].resize(r - l + 2);if(l == r) {T[id][0] = 0;T[id][1] = b[l] + 1; return;}int mid = (l + r) >> 1;solve(l, mid, id << 1);solve(mid + 1, r, id << 1 | 1);pushup(id, r - l + 1);}
void build(int x) {solve(st[x], ed[x], 1);val[x] = T[1];}
int main() {scanf("%d", &n);for(int i = 1; i <= n; i++)scanf("%d", &b[i]), b[i] = i - 1 - b[i];d = 200;for(int i = 1; i <= n; i++)bel[i] = (i - 1) / d + 1;k = bel[n];
for(int i = 1; i <= k; i++) {st[i] = (i - 1) * d + 1;ed[i] = min(i * d, n);build(i);}scanf("%d", &q);for(int i = 1, opt, x, y; i <= q; i++) {scanf("%d%d", &opt, &x);
if(opt == 1) {scanf("%d", &y);b[x] = x - 1 - y;build(bel[x]);}else {int now = b[x] + 1;int p = bel[x];for(int j = x + 1; j <= ed[p]; j++)now += (now > b[j]);
for(int j = p + 1; j <= k; j++)now += upper_bound(val[j].begin(), val[j].end(), now) - val[j].begin() - 1;printf("%d\n", now);}}return 0;} |
#include <bits/stdc++.h>
using namespace std;
#define FOR(x,n) for(int x=0;x<n;x++)
#define mp make_pair
#define PI 3.14159265358979323846264338327950288
typedef long long ll;
typedef pair<int,int> ii;
const int MX = 1e5 + 1;
const int CHKSIZE = 150;
const int CHKS = MX/CHKSIZE + 1;
class fenwickTree {
public:
int* tree;
int size;
int get(int index) {
index++; // dummy node indexing
int ret = 0;
while(index > 0) {
ret += tree[index];
index -= (index & -index);
}
return ret;
}
void update(int index, int delta) {
if(index >= size) return;
index++; // dummy node indexing
while(index <= size) {
tree[index] += delta;
index += (index & -index);
}
}
int lbound(int x) {
int curr = 0, currsum = 0;
for(int i = 20; i >= 0; i--) {
int bit = (1 << i);
int up = curr + bit;
if(up > size || currsum + tree[up] >= x) continue;
curr = up;
currsum += tree[up];
}
return curr;
}
fenwickTree() {
size = MX;
tree = new int[size+1]; // +1 for dummy node at 0
memset(tree, 0, sizeof(int)*(size+1));
for(int i = 1; i < size; i++) {
update(i, 1);
}
}
};
int n;
int arr[MX], nxt[2*MX];
fenwickTree tree;
vector<int> updates[CHKS];
void upd1(int i, int val) {
int idx = i/CHKSIZE;
int start = idx*CHKSIZE;
int end = min(idx*CHKSIZE + CHKSIZE, n) - 1;
arr[i] = val;
for(int j = start; j <= end; j++) {
int x = tree.lbound(arr[j]);
tree.update(x, 1);
updates[idx][j - start] = x;
}
for(int j = end; j >= start; j--) {
tree.update(updates[idx][j - start], -1);
}
sort(updates[idx].begin(), updates[idx].end());
}
int query2(int i) {
int curr = arr[i];
i++;
while(i < n && nxt[i] == -1) {
if(arr[i] <= curr) curr++;
i++;
}
while(i < n) {
int idx = i/CHKSIZE;
curr += upper_bound(updates[idx].begin(), updates[idx].end(), curr) - updates[idx].begin();
i = nxt[i];
}
return n - curr;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
memset(nxt, -1, sizeof nxt);
for(int i = 0; i < 2*MX; i += CHKSIZE) {
nxt[i] = i + CHKSIZE;
}
scanf("%d", &n);
FOR(i,n) {
scanf("%d", &arr[i]);
}
int chks = (n + CHKSIZE - 1)/CHKSIZE;
FOR(i,chks) {
updates[i].resize(CHKSIZE, 2*MX);
upd1(CHKSIZE * i, arr[CHKSIZE * i]);
}
int q;
scanf("%d", &q);
while(q--) {
int t;
scanf("%d", &t);
if(t == 1) {
int i, x;
scanf("%d %d", &i, &x);
i--;
upd1(i, x);
}
else {
int i;
scanf("%d", &i);
i--;
printf("%d\n", query2(i));
}
}
}
// UPDATE N WHEN UR DONE AAAAAAAAAAAAAAAAAAAAAAAAAAA (if it applies lol)
|
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
#include <iostream>
#include <complex>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <random>
#define pb push_back
#define x first
#define y second
#define mp make_pair
#define len(a) int(a.size())
#define files(FILENAME) read(FILENAME); write(FILENAME)
#define read(FILENAME) freopen((string(FILENAME) + ".in").c_str(), "r", stdin)
#define write(FILENAME) freopen((string(FILENAME) + ".out").c_str(), "w", stdout)
using namespace std;
template<typename T1, typename T2>inline void chkmin(T1 &x, T2 y) { if (x > y) x = y; }
template<typename T1, typename T2>inline void chkmax(T1 &x, T2 y) { if (x < y) x = y; }
template<typename T, typename U> inline ostream &operator<< (ostream &_out, const pair<T, U> &_p) { _out << _p.first << ' ' << _p.second; return _out; }
template<typename T, typename U> inline istream &operator>> (istream &_in, pair<T, U> &_p) { _in >> _p.first >> _p.second; return _in; }
template<typename T> inline ostream &operator<< (ostream &_out, const vector<T> &_v) { if (_v.empty()) { return _out; } _out << _v.front(); for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T> inline istream &operator>> (istream &_in, vector<T> &_v) { for (auto &_i : _v) { _in >> _i; } return _in; }
template<typename T> inline ostream &operator<< (ostream &_out, const set<T> &_s) { if (_s.empty()) { return _out; } _out << *_s.begin(); for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T> inline ostream &operator<< (ostream &_out, const multiset<T> &_s) { if (_s.empty()) { return _out; } _out << *_s.begin(); for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T> inline ostream &operator<< (ostream &_out, const unordered_set<T> &_s) { if (_s.empty()) { return _out; } _out << *_s.begin(); for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T> inline ostream &operator<< (ostream &_out, const unordered_multiset<T> &_s) { if (_s.empty()) { return _out; } _out << *_s.begin(); for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T, typename U> inline ostream &operator<< (ostream &_out, const map<T, U> &_m) { if (_m.empty()) { return _out; } _out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')'; for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) { _out << ", (" << _it->first << ": " << _it->second << ')'; } return _out; }
template<typename T, typename U> inline ostream &operator<< (ostream &_out, const unordered_map<T, U> &_m) { if (_m.empty()) { return _out; } _out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')'; for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) { _out << ", (" << _it->first << ": " << _it->second << ')'; } return _out; }
typedef long long base;
typedef pair<int, int> point;
typedef complex<double> comp;
const int N = 1 << 17;
const int RN = N + 228;
const int BLOCK_SIZE = 700;
int n, m;
int c[RN], need[RN];
struct block {
int L, R;
vector<int> order;
void init() {
for (int M = L; M < R; ++M) {
need[M] = c[M];
int i = 0;
while (i < order.size()) {
if (need[order[i]] <= need[M]) {
++need[M];
++i;
} else {
break;
}
}
order.insert(order.begin() + i, M);
}
}
void chg(int id) {
for (int i = 0; i < order.size(); ++i) {
if (order[i] != id) continue;
order.erase(order.begin() + i);
for (int q = i; q < order.size(); ++q) {
if (order[q] > id) {
int pos = q;
need[order[pos]]--;
while (pos > 0 && need[order[pos - 1]] == need[order[pos]]) {
--need[order[pos]];
swap(order[pos], order[pos - 1]);
--pos;
}
}
}
need[id] = c[id];
int j = 0;
while (j < order.size()) {
if (order[j] > id) {
++j;
} else if (need[order[j]] <= need[id]) {
++need[id];
++j;
} else {
break;
}
}
j = 0;
while (j < order.size() && need[order[j]] < need[id]) {
++j;
}
order.insert(order.begin() + j, id);
for (int q = order.size() - 1; q >= j + 1; --q) {
if (order[q] > id) {
int pos = q;
need[order[pos]]++;
while (pos + 1 < order.size() && need[order[pos + 1]] == need[order[pos]]) {
++need[order[pos]];
swap(order[pos], order[pos + 1]);
++pos;
}
}
}
break;
}
}
int getk(int k) {
int Ln = -1, Rn = order.size();
// cout << "order: ";
// for (int i = 0; i < order.size(); ++i) {
// cout << need[order[i]] << ' ';
// }
// cout << '\n';
while (Rn - Ln > 1) {
int M = (Rn + Ln) >> 1;
if (need[order[M]] - M <= k) {
Ln = M;
} else {
Rn = M;
}
}
// cout << "needed: " << k << ' ' << Rn << '\n';
return k + Rn;
}
} box[N];
int get(int i) {
int block = i / BLOCK_SIZE;
int cur = need[i];
while (block > 0) {
--block;
cur = box[block].getk(cur);
}
return cur;
}
int main() {
ios::sync_with_stdio(0);
srand(time(0));
#ifdef ONPC
freopen("input", "r", stdin);
#endif
cin >> n;
for (int i = 0; i < n; ++i) {
int id = n - i - 1;
cin >> c[id];
// c[id] = rand() % (i + 1);
c[id] = i - c[id];
}
for (int L = 0; L < n; L += BLOCK_SIZE) {
box[L / BLOCK_SIZE].L = L;
box[L / BLOCK_SIZE].R = min(n, L + BLOCK_SIZE);
box[L / BLOCK_SIZE].init();
}
// return 0;
cin >> m;
for (int i = 0; i < m; ++i) {
int t, id;
cin >> t >> id;
id = n - id;
// t = 2;
// id = rand() % n;
if (t == 2) {
cout << get(id) + 1 << '\n';
} else {
int x;
cin >> x;
// x = rand() % (n - id);
c[id] = (n - id - 1) - x;
box[id / BLOCK_SIZE].chg(id);
}
}
}
|
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;
#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());
typedef long long ll;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
struct Trans {
int n;
int bsz, nb;
vector<int> val, bval;
void init(int _n) { n = _n, bsz = sqrt(n), nb = (n + bsz - 1) / bsz; val = vector<int>(n, 0), bval = vector<int>(nb, 0); }
void addpoint(int x, int by) { val[x] += by; }
void addrange(int l, int r, int by) {
int lb = (l + bsz - 1) / bsz;
while (l <= r && l < lb * bsz) val[l++] += by;
int rb = (r + 1) / bsz - 1;
while (l <= r && r >= (rb + 1) * bsz) val[r--] += by;
FORE(b, lb, rb) bval[b] += by;
}
int get(int x) { return val[x] + bval[x / bsz]; }
};
const int MAXN = 100000;
const int MAXQ = 100000;
int n;
int initinv[MAXN];
int nq;
int qkind[MAXQ], qidx[MAXQ], qval[MAXQ];
int qans[MAXQ];
int curinv[MAXN];
int bsz, blg, nb;
vector<int> bl, br;
Trans btrans;
vector<int> bsuff;
vector<vector<int>> tree;
vector<vector<int>> treepos;
vector<int> nsuff;
void mergetree(int k, int offset) {
int l = offset, m = offset + (1 << k), r = offset + (2 << k), have = 0;
FOR(i, l, r) {
if (m < r && (l >= offset + (1 << k) || tree[k][m] <= tree[k][l] + have)) {
tree[k + 1][i] = tree[k][m];
treepos[k + 1][i] = treepos[k][m];
++m, ++have;
} else {
tree[k + 1][i] = tree[k][l] + have;
treepos[k + 1][i] = treepos[k][l];
++l;
}
}
}
void buildtree(int b) {
tree = vector<vector<int>>(blg + 1, vector<int>(bsz, 0));
treepos = vector<vector<int>>(blg + 1, vector<int>(bsz, -1));
FOR(i, bl[b], br[b]) tree[0][i - bl[b]] = curinv[i], treepos[0][i - bl[b]] = i;
REP(k, blg) for (int offset = 0; offset < bsz; offset += (2 << k)) mergetree(k, offset);
nsuff = vector<int>(br[b] - bl[b]);
REP(i, bsz) if (treepos[blg][i] != -1) nsuff[treepos[blg][i] - bl[b]] = tree[blg][i] - i;
}
void updatetree(int b, int idx) {
tree[0][idx - bl[b]] = curinv[idx];
REP(k, blg) mergetree(k, ((idx - bl[b]) >> (k + 1)) << (k + 1));
nsuff = vector<int>(br[b] - bl[b]);
REP(i, bsz) if (treepos[blg][i] != -1) nsuff[treepos[blg][i] - bl[b]] = tree[blg][i] - i;
}
void init(int b) {
btrans.init(bl[b] + 1);
REP(at, bl[b]) btrans.addpoint(at, at);
buildtree(b);
FOR(i, bl[b], br[b]) bsuff[i] = nsuff[i - bl[b]], btrans.addrange(bsuff[i], bl[b], +1);
}
void rebuild(int b,int changedidx) {
updatetree(b, changedidx);
FOR(i, bl[b], br[b]) {
int at = nsuff[i - bl[b]];
if (i == changedidx) {
btrans.addrange(bsuff[i], bl[b], -1);
btrans.addrange(at, bl[b], +1);
} else {
assert(abs(at - bsuff[i]) <= 1);
if (at < bsuff[i]) btrans.addpoint(at, +1);
if (at > bsuff[i]) btrans.addpoint(bsuff[i], -1);
}
bsuff[i] = at;
}
}
int qpos[MAXQ];
void solve() {
blg = 0; while ((1 << (2 * (blg + 1))) <= n) ++blg;
bsz = 1 << blg;
nb = (n + bsz - 1) / bsz;
//printf("blg=%d bsz=%d\n", blg, bsz);
bl = br = vector<int>(nb);
bsuff = vector<int>(n, -1);
REP(b, nb) bl[b] = b * bsz, br[b] = min(n, (b + 1) * bsz);
REP(b, nb) {
REP(i, n) curinv[i] = initinv[i];
init(b);
REP(i, nq) {
int idx = qidx[i];
if (qkind[i] == 1 && idx / bsz == b) {
curinv[idx] = qval[i];
rebuild(b, idx);
}
if (qkind[i] == 2 && idx / bsz == b) {
qpos[i] = curinv[idx];
FOR(j, idx + 1, br[b]) if (curinv[j] <= qpos[i]) ++qpos[i];
}
if (qkind[i] == 2 && idx / bsz < b) {
qpos[i] = btrans.get(qpos[i]);
}
}
}
REP(i, nq) qans[i] = n - qpos[i] - 1;
}
void run() {
scanf("%d", &n);
REP(i, n) scanf("%d", &initinv[i]);
scanf("%d", &nq);
REP(i, nq) {
scanf("%d", &qkind[i]);
if (qkind[i] == 1) scanf("%d%d", &qidx[i], &qval[i]), --qidx[i];
if (qkind[i] == 2) scanf("%d", &qidx[i]), --qidx[i];
}
solve();
REP(i, nq) if (qkind[i] == 2) printf("%d\n", qans[i] + 1);
}
void stress() {
int mxlim = 100;
REP(rep, 10) {
int lim = rnd() % mxlim + 1;
n = MAXN;
REP(i, n) initinv[i] = rnd() % min(i + 1, lim);
nq = MAXQ;
REP(i, nq) {
qkind[i] = rnd() % 2 + 1;
qidx[i] = rnd() % n;
if (qkind[i] == 1) qval[i] = rnd() % min(qidx[i] + 1, lim);
}
solve();
printf(".");
}
}
int main() {
run();
//stress();
return 0;
}
|
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
//#define DEBUG
#ifdef DEBUG
template<typename ...Args>
int debug(const Args &...args){
return fprintf(stderr,args...);
}
#else
#define debug(...) void()
#endif
typedef unsigned long long ull;
typedef unsigned uint;
typedef long long ll;
#define G getchar()
int read()
{
int x=0; bool flg=false; char ch=G;
for (;!isdigit(ch);ch=G) if (ch=='-') flg=true;
for (;isdigit(ch);ch=G) x=(x<<3)+(x<<1)+(ch^48);
return flg?-x:x;
}
#undef G
#define fi first
#define se second
/*
const int mod=;
inline int upd(const int &x){return x+(x>>31&mod);}
inline void add(int &x,const int &y){x=upd(x+y-mod);}
inline void iadd(int &x,const int &y){x=upd(x-y);}
int qpow(int x,int y){
int res=1;
for (;y;y>>=1,x=1LL*x*x%mod)
if (y&1) res=1LL*res*x%mod;
return res;
}
*/
typedef pair<int,int> P;
#define rep(i,l,r) for (int i(l),_##i(r);i<=_##i;i++)
#define per(i,l,r) for (int i(r),_##i(l);i>=_##i;i--)
#define all(x) (x).begin(),(x).end()
#define forall(x,y) for (const int &y: e[x])
const int S=888,N=1e5;
int n,c[100010];
struct B{
P d[S+10]; int m;
void init(int l,int r){
m=0;
per(i,l,r) d[++m]={0,i};
}
void modify(int x,int w){
rep(_,1,m) if (d[_].se==x){
per(i,_+1,m) if (d[i].se>x){
if (i<m&&d[i].fi==d[i+1].fi) swap(d[i],d[i+1]);
else ++d[i].fi;
}
rep(i,_,m-1) swap(d[i],d[i+1]);
P o=d[m--];
c[x]=w;
int p=m+1,s=0;
rep(i,1,m){
s+=d[i].se<x;
if (d[i].fi+s>w){
p=i; break;
}
}
s=w;
rep(i,1,p-1) s-=d[i].se<x;
o.fi=s;
per(i,p,m) swap(d[i],d[i+1]);
++m; d[p]=o;
rep(i,p+1,m){
if (d[i].se>x){
if (d[i].fi==d[i-1].fi) swap(d[i],d[i-1]);
else --d[i].fi;
}
}
return;
}
assert(0);
}
int query(int x){
int l=0,r=m,mid;
while (l<r){
mid=l+r+1>>1;
if (d[mid].fi<x) l=mid;
else r=mid-1;
}
return l;
}
}b[N/S+10];
void solve(){
n=read();
for (int i=0;i*S+1<=n;++i) b[i].init(i*S+1,min((i+1)*S,n));
rep(i,1,n) b[(i-1)/S].modify(i,i-1-read());
int q=read();
while (q--){
if (read()&1){
int x=read(),w=x-1-read();
b[(x-1)/S].modify(x,w);
}
else{
int x=read(),z=c[x]+1;
rep(i,x+1,min(n,((x-1)/S+1)*S)) if (c[i]<z) ++z;
rep(i,(x-1)/S+1,(n-1)/S) z+=b[i].query(z);
printf("%d\n",z);
}
}
}
int main()
{
for (int T=1;T--;) solve();
return 0;
}
|
#include <bits/stdc++.h>
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
using namespace std;
using lint = long long;
using pi = pair<int, int>;
const int MAXN = 205;
const int mod = 1e9 + 7;
/*
template<typename T>
T gcd(const T &a, const T &b) {
return b == T(0) ? a : gcd(b, a % b);
}
struct mint {
int val;
mint() { val = 0; }
mint(const lint& v) {
val = (-mod <= v && v < mod) ? v : v % mod;
if (val < 0) val += mod;
}
friend ostream& operator<<(ostream& os, const mint& a) { return os << a.val; }
friend bool operator==(const mint& a, const mint& b) { return a.val == b.val; }
friend bool operator!=(const mint& a, const mint& b) { return !(a == b); }
friend bool operator<(const mint& a, const mint& b) { return a.val < b.val; }
mint operator-() const { return mint(-val); }
mint& operator+=(const mint& m) { if ((val += m.val) >= mod) val -= mod; return *this; }
mint& operator-=(const mint& m) { if ((val -= m.val) < 0) val += mod; return *this; }
mint& operator*=(const mint& m) { val = (lint)val*m.val%mod; return *this; }
friend mint ipow(mint a, lint p) {
mint ans = 1; for (; p; p /= 2, a *= a) if (p&1) ans *= a;
return ans;
}
friend mint inv(const mint& a) { assert(a.val); return ipow(a, mod - 2); }
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
operator int64_t() const {return val; }
};
int n, c[105], b[105];
int L[105];
mint dp[105][10005];
struct foo{
int x, i, j;
bool operator<(const foo &v)const{
return make_tuple(-x, i, j) < make_tuple(-v.x, v.i, v.j);
}
};
int main(){
cin >> n;
for(int i = 1; i <= n; i++) cin >> c[i];
for(int i = 1; i <= n - 1; i++){
cin >> b[i];
b[i] += b[i-1];
}
for(int i = 1; i <= n - 1; i++) b[i] += b[i-1];
int sum = 0;
vector<foo> vect;
for(int i = 1; i <= n; i++){
int x = -b[i-1] / i - 10;
sum += c[i];
for(int j = 0; j <= sum; j++){
while((x+1) * i + b[i-1] <= j) x++;
vect.push_back({x, i, j});
}
}
dp[0][0] = 1;
sort(all(vect));
mint ret = 0;
auto proc = [&](int i, int j){
dp[i][j] = 0;
if(i == n){
}
for(int k = 0; k <= j && k <= c[i+1]; k++){
if(i == n) ret -= dp[i][j];
else dp[i+1][j+k] -= dp[i][j];
}
}
{
int sum = 0;
for(int i = 1; i <= n; i++){
sum += c[i];
for(int j = L[i]; j <= sum; j++){
for(int k = 0; k <= j && k <= c[i]; k++){
dp[i][j] += dp[i-1][j-k];
}
if(i == n) ret += dp[i][j];
}
}
}
for(int i = 0; i < sz(vect); ){
int e = i;
while(e < sz(vect) && vect[i].x == vect[e].x) e++;
for(int j = i; j < e; j++){
proc(vect[j].i, vect[j].j);
}
i = e;
}
int q; cin >> q;
for(int i = 0; i < q; i++){
int x; cin >> x;
int cursum = 0;
for(int j = 1; j <= n; j++){
L[j] = x * j + cursum;
L[j] = max(L[j], 0);
cursum += b[j];
}
dp[0][0] = 1;
int sum = 0;
mint ret = 0;
for(int i = 1; i <= n; i++){
sum += c[i];
for(int j = L[i]; j <= sum; j++){
}
}
cout << ret << endl;
for(int j = 0; j < 105; j++){
for(int k = 0; k < 10005; k++){
dp[j][k] = 0;
}
}
}
}*/
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
// Fast IO ********************************************************************************************************
const int __BS = 4096;
static char __bur[__BS + 16], *__er = __bur + __BS, *__ir = __er;
template<class T = int> T _readInt() {
auto c = [&]() { if (__ir == __er) std::fill(__bur, __bur + __BS, 0), cin.read(__bur, __BS), __ir = __bur; };
c(); while (*__ir && (*__ir < '0' || *__ir > '9') && *__ir != '-') ++__ir; c();
bool m = false; if (*__ir == '-') ++__ir, c(), m = true;
T r = 0; while (*__ir >= '0' && *__ir <= '9') r = r * 10 + *__ir - '0', ++__ir, c();
++__ir; return m ? -r : r;
}
static char __buw[__BS + 20], *__iw = __buw, *__ew = __buw + __BS;
template<class T>
void writeInt(T x, char endc = '\n') {
if (x < 0) *__iw++ = '-', x = -x; if (x == 0) *__iw++ = '0';
char* s = __iw;
while (x) { T t = x / 10; char c = x - 10 * t + '0'; *__iw++ = c; x = t; }
char* f = __iw - 1; while (s < f) swap(*s, *f), ++s, --f;
if (__iw > __ew) cout.write(__buw, __iw - __buw), __iw = __buw;
*__iw++ = endc;
}
template<class T>
void writeStr(const T& str) {
int i = 0; while (str[i]) { *__iw++ = str[i++]; if (__iw > __ew) cout.write(__buw, __iw - __buw), __iw = __buw; }
}
struct __FL__ { ~__FL__() { if (__iw != __buw) cout.write(__buw, __iw - __buw); } };
static __FL__ __flushVar__;
int n, q;
int a[101000];
int ts[101005], cache[101005], foo;
int main(){
n = _readInt();
for(int i = 1; i <= n; i++) a[i] = i - _readInt();
q = _readInt();
foo = 1;
while(q--){
int t = _readInt();
int i = _readInt();
if(t == 1){
foo++;
a[i] = i - _readInt();
}
else{
if(ts[i] == foo){
writeInt(cache[i]);
continue;
}
int x = a[i];
for(int j = i + 1; j <= n; j++){
x += (a[j] > x ? 0 : 1);
}
ts[i] = foo;
cache[i] = x;
writeInt(x);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, SZ = 200;
int n, q, a[maxn], bel[maxn], bl[maxn], br[maxn];
vector<int> pos[maxn / SZ + 5];
namespace BIT {
int c[maxn];
void add(int p, int v) {
for (; p <= n; p += p & -p) c[p] += v;
}
// min p s.t. c_p >= s
int find(int s) {
int p = 1;
for (int i = 1 << 16; i; i >>= 1) {
if (p + i <= n && c[p + i - 1] < s) p += i, s -= c[p - 1];
}
return p;
}
} // namespace BIT
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), a[i] = i - a[i];
}
for (int i = 1; i <= n; i++) {
br[bel[i] = (i - 1) / SZ + 1] = i;
if (!bl[bel[i]]) bl[bel[i]] = i;
}
auto rebuild = [&](int k) {
for (int i = bl[k]; i <= br[k]; i++) {
BIT::add(pos[k][i - bl[k]] = BIT::find(a[i]), 1);
}
for (int x : pos[k]) BIT::add(x, -1);
sort(pos[k].begin(), pos[k].end());
};
for (int i = 1; i <= n; i++) {
BIT::add(i, 1);
}
for (int i = 1; i <= bel[n]; i++) {
pos[i].resize(br[i] - bl[i] + 1), rebuild(i);
}
scanf("%d", &q);
while (q--) {
int op, i, x;
scanf("%d %d", &op, &i);
if (op == 1) {
scanf("%d", &x);
a[i] = i - x, rebuild(bel[i]);
} else {
int cur = a[i];
for (int j = i + 1; j <= br[bel[i]]; j++) {
cur += a[j] <= cur;
}
for (int j = bel[i] + 1; j <= bel[n]; j++) {
cur += upper_bound(pos[j].begin(), pos[j].end(), cur) - pos[j].begin();
}
printf("%d\n", cur);
}
}
return 0;
} |
#include <iostream>
#include <cstdio>
#include <algorithm>
const int nn = 1e5 + 5;
const int inf = 1e9;
struct node {
int val, lazy, pos;
#define val(p) tree[p].val
#define lazy(p) tree[p].lazy
#define pos(p) tree[p].pos
#define ls (p << 1)
#define rs (p << 1 | 1)
} tree[nn << 3];
void update(int p) {
if (val(ls) < val(rs)) {
val(p) = val(ls);
pos(p) = pos(ls);
} else {
val(p) = val(rs);
pos(p) = pos(rs);
}
}
int c[nn];
void build(int p, int l, int r) {
if (l == r) {
val(p) = c[l];
pos(p) = l;
return;
}
int mid = l + r >> 1;
build(ls, l, mid);
build(rs, mid + 1, r);
update(p);
}
void pushdown(int p) {
if (!lazy(p)) return;
lazy(ls) += lazy(p);
val(ls) += lazy(p);
lazy(rs) += lazy(p);
val(rs) += lazy(p);
lazy(p) = 0;
}
void modify(int p, int l, int r, int pos, int val) {
if (l == r) {
val(p) = val;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (pos <= mid) modify(ls, l, mid, pos, val);
else modify(rs, mid + 1, r, pos, val);
update(p);
}
void add(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
val(p)--; lazy(p)--;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (ql <= mid) add(ls, l, mid, ql, qr);
if (mid < qr) add(rs, mid + 1, r, ql, qr);
update(p);
}
int a[nn], stack[3005][3005], lenth[nn];
void build_b(int p, int l, int r) {
for (int i = 1; i <= 2000; i++)
tree[i] = (node){0, 0, 0};
for (int i = l; i <= r; i++) c[i - l + 1] = a[i];
int len = r - l + 1;
build(1, 1, len);
for (int i = 1; i <= len; i++) {
stack[p][i] = std::max(val(1), stack[p][i - 1]);
int pos = pos(1);
if (pos != len) add(1, 1, len, pos + 1, len);
modify(1, 1, len, pos, inf);
}
stack[p][lenth[p] + 1] = inf;
}
int n, m, block, bl[nn], l[nn], r[nn];
int main() {
scanf("%d", &n);
block = 80;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
bl[i] = (i - 1) / block + 1;
}
for (int i = 1; i <= bl[n]; i++) {
l[i] = i * block - block + 1;
r[i] = std::min(n, i * block);
lenth[i] = r[i] - l[i] + 1;
build_b(i, l[i], r[i]);
}
scanf("%d", &m);
while (m--) {
int opt, x;
scanf("%d %d", &opt, &x);
if (opt == 1) {
scanf("%d", a + x);
build_b(bl[x], l[bl[x]], r[bl[x]]);
} else {
int ans = a[x];
for (int i = x + 1; i <= r[bl[x]]; i++) ans += (ans >= a[i]);
for (int i = bl[x] + 1; i <= bl[n]; i++) {
int pos = std::upper_bound(stack[i] + 1, stack[i] + lenth[i] + 2, ans) - stack[i];
ans += pos - 1;
}
printf("%d\n", n - ans);
}
}
} |
#include<bits/stdc++.h>
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define len(x) (int)(x).size()
typedef long long ll;
typedef long double ld;
using namespace std;
const bool debug = 0;
const int N = (int)1e5 + 10;
const int inf = 1e9;
const int buben = 500;
mt19937 rng(199999973);
vector < pair<int,int> > indablock[N/buben+1];
int perm[N], n;
pair<int,int> memory[4*buben][buben];
int PNT[4*buben];
void OG(int v, vector<int>&perm, int l , int r){
if(l == r){
PNT[v]=0;
memory[v][PNT[v]++] = {0,0};
memory[v][PNT[v]++] = {perm[l] , 1};
memory[v][PNT[v]++] = {N, 0};
return;
}
int mid = (l + r) >> 1;
OG(v*2+1, perm, l , mid);
OG(v*2, perm, mid+1 , r);
PNT[v]=0;
int lst = 0;
int LST = 0;
for(int x = 0; x < PNT[2*v+1] - 1; ++x){
/// cur is
int L = memory[2*v+1][x].fi + memory[2*v+1][x].se;
int R = min(N-5,memory[2*v+1][x+1].fi-1 + memory[2*v+1][x].se);
while(lst+1 < PNT[2*v] && memory[2*v][lst+1].fi <= L)
++lst;
if(lst == PNT[2*v]-1){
memory[v][PNT[v]++]= {memory[2*v+1][x].fi , memory[2*v+1][x].se};
}else{
while(lst < PNT[2*v]-1){
assert(memory[2*v][lst].fi <= L);
int r = min(R , memory[2*v][lst+1].fi-1);
/// so for them
memory[v][PNT[v]++] = {L-memory[2*v+1][x].se, memory[2*v+1][x].se+memory[2*v][lst].se};
L = r + 1;
if(r == R)
break;
lst++;
}
}
}
// assert(len(C) <= 2*buben);
memory[v][PNT[v]++] = {N, 0};
}
void additupbankroll(int id , vector<int>perm){
OG(1, perm, 0 , len(perm)-1);
indablock[id].clear();
for(int x = 0 ; x < PNT[1]; ++x)
indablock[id].pb(memory[1][x]);
}
int pass_through(int id, int x){
int ind = lower_bound(all(indablock[id]), make_pair(x+1,-1)) - indablock[id].begin();
ind--;
return indablock[id][ind].se;
}
void flexindablock(int id){
/// so
int L = id * buben, R = min(n-1, (id+1)*buben-1);
vector<int>cur;
for(int x = L;x <= R; ++x){
cur.pb(x+1-perm[x]);
}
additupbankroll(id , cur);
}
signed main(){
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
if(debug)
n = 1e5;
else
cin >> n;
for(int i = 0 ; i < n; ++i){
if(debug)
perm[i] = rng()%(i+1);
else
cin >> perm[i];
}
int q;
if(debug)
q = 1e5;
else
cin >> q;
/// so the id is
for(int i =0 ; i <= (n-1)/buben; ++i){
flexindablock(i);
}
int done = 0;
while(q--){
int t;
if(debug){
t = rng() % 2 + 1;
}else
cin >> t;
if(t == 1){
int i , x;
if(debug){
i = rng() % n;
i++;
x = rng() % i;
}else
cin >> i >> x;
--i;
perm[i] = x;
flexindablock(i / buben);
}else{
int i;
if(debug)
i = rng() % n + 1;
else
cin >> i;
--i;
/// so firstly our pos is
int x = i + 1 - perm[i];
i++;
while(i < n){
if(i % buben == 0 && i + buben - 1 < n){
x += pass_through(i / buben , x);
i += buben;
continue;
}
int cur = i + 1 - perm[i];
if(x >= cur)
x++;
i++;
}
cout << x << '\n';
}
}
return 0;
}
|
// Author: HolyK
// Created: Thu Jul 8 20:33:54 2021
#include <bits/stdc++.h>
#define dbg(a...) fprintf(stderr, a)
template <class T, class U>
inline bool smin(T &x, const U &y) {
return y < x ? x = y, 1 : 0;
}
template <class T, class U>
inline bool smax(T &x, const U &y) {
return x < y ? x = y, 1 : 0;
}
using LL = long long;
using PII = std::pair<int, int>;
struct FenwickTree {
std::vector<int> c;
FenwickTree(int n) : c(n) {}
void add(int p, int x) {
assert(p);
for (; p < c.size(); p += p & -p) c[p] += x;
}
int ask(int p) {
int r = 0;
for (; p; p -= p & -p) r += c[p];
return r;
}
int find(int k) {
if (!k) return 1;
int p = 0;
for (int i = 1 << 16; i; i >>= 1) {
if (p + i < c.size() && k > c[p + i] + i) {
p += i, k -= c[p] + i;
}
}
return p + 1;
}
};
constexpr int T(512);
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
std::cin >> b[i];
b[i] = i - b[i] + 1;
}
int tot = (n - 1) / T + 1;
std::vector<FenwickTree> t(tot, n + 1);
for (int i = 0, x = 0; i < tot; i++, x += T) {
int y = std::min(x + T, n);
for (int j = x; j < y; j++) {
a[j] = t[i].find(b[j]);
// std::cout << j << " " << a[j] << "\n";
t[i].add(a[j], 1);
}
}
// return 0;
int q;
std::cin >> q;
while (q--) {
int opt, i;
std::cin >> opt >> i;
i--;
int bi = i / T, y = std::min(n, bi * T + T);
if (opt == 1) {
for (int j = y - 1; j >= i; j--) t[bi].add(a[j], -1);
std::cin >> b[i];
b[i] = i - b[i] + 1;
for (int j = i; j < y; j++) {
a[j] = t[bi].find(b[j]);
t[bi].add(a[j], 1);
}
} else {
int ans = b[i];
for (int j = i + 1; j < y; j++) if (b[j] <= ans) ans++;
for (int j = bi + 1; j < tot; j++) {
assert(ans <= n);
ans += t[j].ask(ans);
}
std::cout << ans << "\n";
}
}
return 0;
}
/*
3
0 0 0
7
2 1
2 2
2 3
1 2 1
2 1
2 2
2 3
5
0 1 2 3 4
15
2 1
2 2
1 2 1
2 2
2 3
2 5
1 3 0
1 4 0
2 3
2 4
2 5
1 4 1
2 3
2 4
2 5
*/
|
#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <exception>
#include <map>
#include <memory>
#include <queue>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
#define mp(x, y) make_pair(x, y)
const int N = 1e5 + 5, bs = 320, mod = 1e9 + 7;
int n, q, b[N], c[N];
int t[N << 2], lz[N << 2], bit[N];
vector<int> v[550];
void add(int x, int v) {
while (x <= n) bit[x] += v, x += x & -x;
}
int query(int x) {
int ans = 0, sum = 0;
for (int i = 1 << 16; i; i >>= 1)
if ((ans | i) <= n && sum + bit[ans | i] < x) ans |= i, sum += bit[ans];
return ans + 1;
}
void load(int x) {
int l = max(1, x * bs), r = min(n, (x + 1) * bs - 1);
v[x].clear();
for (int i = l; i <= r; i++) {
v[x].push_back(query(b[i]));
add(v[x].back(), 1);
}
for (int i = v[x].size() - 1; i >= 0; i--) add(v[x][i], -1);
sort(v[x].begin(), v[x].end());
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), b[i] = i - b[i];
for (int i = 1; i <= n; i++) add(i, 1);
for (int i = 0; i <= n / bs; i++) load(i);
scanf("%d", &q);
while (q--) {
int op, x, y;
scanf("%d%d", &op, &x);
if (op == 1) {
scanf("%d", &y);
b[x] = x - y;
load(x / bs);
} else {
int rkx = b[x];
int las = min(n, (x / bs + 1) * bs - 1);
for (int i = x + 1; i <= las; i++)
if (b[i] <= rkx) rkx++;
if (las + 1 <= n) {
las = (las + 1) / bs;
for (int i = las; i <= n / bs; i++) {
int p = upper_bound(v[i].begin(), v[i].end(), rkx) - v[i].begin();
rkx += p;
}
}
printf("%d\n", rkx);
}
}
} |
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
const int maxN = 123456, MAGIC = 256;
int mn[MAGIC << 2], tag[MAGIC << 2];
int a[maxN], l[maxN], r[maxN], b[maxN], v[maxN / MAGIC][MAGIC + 1], len[maxN / MAGIC];
int n, q;
int seq[MAGIC];
void update(int u) {
mn[u] = min(mn[u << 1], mn[u << 1 | 1]);
}
void build(int u, int l, int r) {
tag[u] = 0;
if (l == r) {
mn[u] = seq[l];
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
update(u);
}
int val;
void query(int u, int l, int r, int sum) {
if (l == r) {
val = mn[u] + sum;
mn[u] = 1e9;
return;
}
int mid = (l + r) >> 1;
if (mn[u << 1] < mn[u << 1 | 1]) {
query(u << 1, l, mid, sum + tag[u]);
} else {
--tag[u << 1]; --mn[u << 1];
query(u << 1 | 1, mid + 1, r, sum + tag[u]);
}
mn[u] = min(mn[u << 1], mn[u << 1 | 1]) + tag[u];
}
void rebuild(int B) {
int len = 0;
for (int i = l[B]; i <= r[B]; i++) seq[len++] = a[i];
build(1, 0, len - 1);
for (int i = 1; i <= len; i++) {
query(1, 0, len - 1, 0);
v[B][i] = max(v[B][i - 1], val);
// fprintf(stderr, "v[%d][%d] = %d\n", B, i, v[B][i]);
}
::len[B] = len;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i] = i - a[i] + 1;
b[i] = i / MAGIC;
if (!l[b[i]]) l[b[i]] = i;
r[b[i]] = i;
}
l[0] = 0;
reverse(a, a + n);
// for (int i = 0; i < n; i++) fprintf(stderr, "a[%d] = %d\n", i, a[i]);
for (int i = 0; i <= b[n - 1]; i++) rebuild(i);
scanf("%d", &q);
while (q--) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int x, y;
scanf("%d %d", &x, &y);
y = x - 1 - y; x = n - x;
a[x] = y + 1;
rebuild(b[x]);
}
if (opt == 2) {
int x;
scanf("%d", &x);
x = n - x;
int r = a[x];
for (int i = x - 1; i >= l[b[x]]; i--) {
if (a[i] <= r) ++r;
}
for (int i = b[x] - 1; i >= 0; i--) {
int pos = upper_bound(v[i], v[i] + len[i] + 1, r) - v[i];
r += pos - 1;
}
printf("%d\n", r);
}
}
return 0;
} |
#include <cstdio>
#include <vector>
#include <algorithm>
const int BLK=500;
const int MAXN=100005;
int as[MAXN];
int N;
std::vector<int> st[MAXN*4];
std::vector<int> st2[MAXN*4];
void build(int w,int L,int R,int a,int b){
if(a>=R||b<=L) return;
st[w].clear();
if(R-L==1){
st[w].push_back(as[L]);
}else{
int M=(L+R)/2;
build(w*2+1,L,M,a,b);
build(w*2+2,M,R,a,b);
if(R-L<=BLK){
int shift=0;
int i=0,j=0;
const auto& lchd=st[w*2+1];
const auto& rchd=st[w*2+2];
while(i<lchd.size()||j<rchd.size()){
if(j==rchd.size()||(i<lchd.size()&&lchd[i]+shift<rchd[j])){
st[w].push_back(lchd[i++]+shift);
}else{
st[w].push_back(rchd[j++]);
shift++;
}
}
/*
fprintf(stderr,"[%d,%d]:",L,R);
for(int x:st[w]){
fprintf(stderr," %d",x);
}
fprintf(stderr,"\n");
*/
}
}
st2[w].clear();
for(int i=0;i<st[w].size();i++){
st2[w].push_back(st[w][i]-i);
}
}
int query(int w,int L,int R,int a,int b,int v){
int v0=v;
if(a>=R||b<=L){
//do nothing
}else if(a<=L&&b>=R&&R-L<=BLK){
v+=(std::upper_bound(st2[w].begin(),st2[w].end(),v)-st2[w].begin());
}else{
int M=(L+R)/2;
v=query(w*2+1,L,M,a,b,v);
v=query(w*2+2,M,R,a,b,v);
}
//printf("query[%d,%d](%d,%d,%d)=%d\n",L,R,a,b,v0,v);
return v;
}
int main(){
scanf("%d",&N);
for(int i=0;i<N;i++){
int B;
scanf("%d",&B);
as[i]=i-B;
}
build(0,0,N,0,N);
int Q;
scanf("%d",&Q);
while(Q--){
/*
printf("A: ");
for(int i=0;i<N;i++){
printf(" %d",as[i]);
}printf("\n");
*//*printf("Recover:");
for(int i=0;i<N;i++){
printf(" %d",query(0,0,N,i+1,N,as[i])+1);
}
printf("\n");*/
int T;
scanf("%d",&T);
if(T==1){
int I,X;
scanf("%d %d",&I,&X);
I--;
as[I]=I-X;
build(0,0,N,I,I+1);
}else{
int I;
scanf("%d",&I);
I--;
printf("%d\n",query(0,0,N,I+1,N,as[I])+1);
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.