min-max容斥小结

公式及其证明

公式:
$S,T$为两个非空数集.
$$\max (S)=\sum _{T\subseteq S}(-1{)}^{|T|-1}\min (T)$$
$$\min (S)=\sum _{T\subseteq S}(-1{)}^{|T|-1}\max (T)$$

证明:

方法1:
我们都知道容斥原理:
$$|{\cup }_{i=1}^n{A}_i|=\sum _{j=0}^n(-1{)}^{j+1}\left(\sum _{1\le a_1<a_2...<a_j\le n}|A_{a_1}\cap A_{a_2}...\cap A_{a_j}|\right)\text{\hspace{1em}(1)}$$
$$|{\cap }_{i=1}^n{A}_i|=\sum _{j=0}^n(-1{)}^j\left(\sum _{1\le a_1<a_2...<a_j\le n}|\overline{A_{a_1}}\cap \overline{A_{a_2}}...\cap \overline{A_{a_j}}|\right)\text{\hspace{1em}(2)}$$

我们设 A i = { 1 , 2 , . . . , i } A_i=\{1,2,...,i\} Ai​={1,2,...,i}.
定义集族$S^{\prime }$,若$x\in S$,则有$A_x\in S^{\prime }$.
因为$|A_x\cup A_y|=\max (x,y),|A_x\cap A_y|=\min (x,y)$.
所以$\max (S)=|{\cup }_{x\in S}{A}_x|={\sum }_{j=1}^n(-1{)}^{j+1}\left(\sum |{\cap }_{k=1}^j{A}_{a_k}|\right)={\sum }_{T\in S}(-1{)}^{|T|+1}\min (T)$.

同理,我们把每个数的大小翻转$x=-x$,那么最大值和最小值就互换了,也就可以得到第二个式子.

方法2:
参考资料
上面的证明有一定的局限性,因为是只能作用于整数域.
$\max (S)={\sum }_{T\in S}(-1{)}^{|T|-1}\min (T)$

那么第$k$小的数的贡献为 ${\sum }_{j=0}^{n-k}(-1{)}^j(\genfrac{}{}{0ex}{}{n-k}{j})=0^{n-k}=[n=k]$.
所以公式显然成立.

大小翻转$x=-x$可得公式二.

例题

HDU4336

$\min -\max$容斥的套路是化$\max$为$\min$,因为$\min$一般更好求.

我们定义$max(S),min(S)$分别表示取到$S$的最大,最小时间,也就是一个$S$对应一个时间集合.
$\min (T)=\frac{1}{{\sum }_{i\in T}{p}_i}$,求一个的概率还是很简单的~~

#include<bits/stdc++.h>
using namespace std;
const int N=22;

int n,g[1<<N];
double ans,f[1<<N];

int main() {
    while(~scanf("%d",&n)) {
        for(int i=0;i<n;i++) scanf("%lf",&f[1<<i]);
        g[0]=-1; ans=0;
        for(int i=1;i<(1<<n);i++) {
            f[i]=f[i&(i-1)]+f[i&-i];
            g[i]=-g[i&(i-1)];
            ans += g[i]/f[i];
        }
        printf("%.8lf\n",ans);
    }
    return 0;
}

P3175 [HAOI2015]按位或

定义$min(T)$为取到$T$集合中任意一位的最小时间,$max(S)$为最大时间.
$min(T)=\frac{1}{{\sum }_{S\cap T\ne \varnothing }{p}_S}=\frac{1}{1-fwt[\overline{T}]}$

#include<bits/stdc++.h>
using namespace std;
const int N=(1<<20)|10;
const double eps=1e-9;

int n,g[N];
double f[N],ans;

void fwt(double *f) {
    for(int k=1;k<n;k*=2)
        for(int i=0;i<n;i+=2*k)
            for(int j=0;j<k;j++) 
                f[i+j+k] += f[i+j];
}

int main() {
    scanf("%d",&n); n=1<<n;
    for(int i=0;i<n;i++) scanf("%lf",&f[i]);
    fwt(f); g[0]=-1;
    for(int i=1;i<n;i++) {
        g[i]=-g[i&(i-1)];
        if(fabs(f[i^(n-1)]-1)<eps) 
            {puts("INF"); return 0;}
        ans += g[i]/(1-f[i^(n-1)]);
    }
    printf("%.10lf\n",ans); 
    return 0;
}

2542. 「PKUWC2018」随机游走

给定一棵 $n$ 个结点的树，你从点 $x$ 出发，每次等概率随机选择一条与所在点相邻的边走过去。
有$q$次询问，每次询问给定一个集合 ，求如果从$x$出发一直随机游走，直到点集$S$中所有点都至少经过一次的话，期望游走几步。
特别地，点$x$（即起点）视为一开始就被经过了一次。
答案对 998244353 取模。

我们对于给定的$S$,定义$f_x$表示$x$到$S$一点的期望时间,则$\min (S)=f_{root}$.
转移方程:$f_x=\frac{f_{fa}+{\sum }_{y\in so{n}_x}{f}_y}{deg[x]}+1$.
为了避免后效性,我们定义$f_x=A_x\cdot f_{fa}+B_x$.
则有:$f_x=\frac{f_{fa}+{\sum }_{y\in so{n}_x}{A}_y\cdot f_x+B_y}{deg[x]}+1$.
把和$f(x)$有关的系数移动到左边,然后消去系数,得到:
$f_x=\frac{f_{fa}}{de{g}_x-\sum A_y}+\frac{de{g}_x+\sum B_y}{de{g}_x-\sum A_y}\to A_x=\frac{1}{de{g}_x-\sum A_y},B_x=\frac{de{g}_x+\sum B_y}{de{g}_x-\sum A_y}$.
特别的,对于$S$内的点$x$,$f_x=A_x=B_x=0$.

然后就是一个子集和的问题了,显然$O(q\ast 3^n)$会T,优化一下可以做到$O(q\cdot 2^n\cdot n)$.
如果我们全部预处理一般的话,复杂度即为$O(n{2}^n+\sum k)$.

int n,q,rt,cnt[M],f[M],fa[N];
struct edge{int y,next;} a[N*2]; int len,last[N],deg[N];
void ins(int x,int y) {a[++len]=(edge){y,last[x]}; last[x]=len; deg[x]++;}

struct rec {
    ll x,y;
    void operator *=(ll t) {x=x*t%mod; y=y*t%mod;}
    void operator +=(rec t) {x=(x+t.x)%mod; y=(y+t.y)%mod; }
} ;

ll power(ll a,ll b=mod-2) {
    ll c=1;
    while(b) {
        if(b&1) c=c*a%mod; 
        b /= 2; a=a*a%mod;
    }
    return c;
}

rec dfs(int x,int S) {
    rec now=(rec){0,0};
    if(S>>x&1) return now;
    for(int k=last[x],y;k;k=a[k].next)
        if((y=a[k].y)^fa[x]) {
            fa[y]=x;
            now += dfs(y,S);
        }
    ll t=power(deg[x]-now.x+mod);
    now.x=t; now.y=(now.y+deg[x])*t%mod;
    return now;
}

int main() {
    qr(n); qr(q); qr(rt); rt--;
    for(int i=1,x,y;i<n;i++)
        qr(x),qr(y),--x,--y,ins(x,y),ins(y,x);
    fa[rt]=cnt[0]=-1;
    for(int i=1;i<(1<<n);i++)
        cnt[i]=-cnt[i&(i-1)],f[i]=(cnt[i]+mod)*dfs(rt,i).y%mod;
    for(int i=1;i<(1<<n);i*=2)
        for(int j=i;j<(1<<n);j++) if(j&i) f[j]=(f[j]+f[i^j])%mod;
    while(q--) {
        int k,x=0,y; qr(k); 
        while(k--) qr(y),x|=1<<(--y);
        pr2(f[x]);
    }
    return 0;
}

1355 斐波那契的最小公倍数

给定一个长度为$n$的序列$a$,求$lcm(f_{a_1},f_{a_2},...,f_{a_n})\mathrm{m}\mathrm{o}\mathrm{d}(10^9+7)$,其中$f$为斐波那契数列.$n\le 5e4,a_i\le 1e6$.

神仙题,膜题解才会.

通过这题 get 一个斐波那契数列的性质: $\gcd (f_n,f_m)=f_{\gcd (n,m)}$.

由于$lcm,gcd$分别是指数的$\max ,\min$运算,不妨把他们用$\min -\max$容斥的方法连起来.
$\max (S)={\sum }_{T\subseteq S}(-1{)}^{|T|+1}\min (T)$
对于同一个质因子的话,则有$lcm(S)={\prod }_{T\subseteq S}\gcd (T{)}^{(-1{)}^{|T|+1}}(x\in S\to p|x)$.
我们把所有质因子的情况乘起来就是总的情况了:$ lcm(S)=\prod_{T\subseteq S} \gcd(T)^{(-1){|T|+1}}$.

定义$f_S$表示 { f x ∣ x ∈ S } \{f_x|x\in S \} {fx​∣x∈S},这里的$S$为$a$.
$soans=lcm(f_S)={\prod }_{T\subseteq S}gcd(f_T{)}^{(-1{)}^{|T|+1}}={\prod }_{T\subseteq S}{f}_{gcd(T)}^{(-1{)}^{|T|+1}}$.
我们不可能枚举$T,求\gcd (T)$,因为这是$2^{n}n$级别的暴力.

考虑每个位置 $d$ 的影响, 那么显然我们有一个 $\sum [gcd(T)=d](-1{)}^{|T|+1}$ 的指数.
有 $\gcd$ 我们想到什么,没错就是我们的莫比乌斯反演,不过是在 $\prod$ 意义下哦.
$f=g\ast 1\iff g=f\ast \mu ,f_n={\prod }_{d|n}{g}_d\iff g_n={\prod }_{d|n}{f}_d^{\mu (n/d)}$.
加法转乘法可以类比 指数加法 和 乘法 来理解.(不过我们下面并没有用到反演公式)

我们把其他约数的影响去掉即可得到$g_n$.

式子变成这个丫子:
${\prod }_{T\subseteq S}{f}_{gcd(T)}^{(-1{)}^{|T|+1}}={\prod }_{T\subseteq S}{\left({\prod }_{d|gcd(T)}{g}_d\right)}^{(-1{)}^{|T|+1}}={\prod }_{d}g(d{)}^{{\sum }_{d|gcd(T)}(-1{)}^{|T|+1}}$.

考虑每个$d$的贡献,设$d$的倍数有$n$个,则有:
${\sum }_{i=1}^n\left(\genfrac{}{}{0ex}{}{n}{i}\right)(-1{)}^{i+1}=\left({\sum }_{i=0}^n\left(\genfrac{}{}{0ex}{}{n}{i}\right)(-1{)}^{i+1}\right)+1=1-0^n=[n>0]$.
也就是说,只要有一个$d$的倍数,那么$g_d$就会被计算一次.

综上,用个埃氏筛求$g$并判断倍数有没有即可.总复杂度为$O(n+m\log m)(m=\max a_i)$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e6+10,mod=1000000007;

int n,g[N],m;
bool v[N];

ll power(ll a,ll b=mod-2) {
    ll c=1;
    while(b) {
        if(b&1) c=c*a%mod;
        b /= 2; a=a*a%mod;
    }
    return c;
}

void qr(int &x){scanf("%d",&x);}

int main() {
    qr(n);
    for(int i=1,x;i<=n;i++) qr(x),v[x]=1,m=max(m,x);
    g[1]=1; for(int i=2;i<=m;i++) g[i]=(g[i-1]+g[i-2])%mod;
    for(int i=1;i*2<=m;i++) {
        ll k=power(g[i]);
        for(int j=2*i;j<=m;j+=i)
            g[j]=g[j]*k%mod;
    }
    ll ans=1;
    for(int i=1;i<=m;i++)
        for(int j=i;j<=m;j+=i)
            if(v[j]) {ans=ans*g[i]%mod; break;}
    printf("%lld\n",ans);return 0;
}

BZOJ #4833. Lydsy1704月赛 最小公倍佩尔数

设$(1+\sqrt{2}{)}^n=a_n+\sqrt{2}{b}_n,g_n=lcm(b_1,b_2,...,b_n)$,求${\sum }_{i=1}^{n}ig(i)\mathrm{m}\mathrm{o}\mathrm{d}p$.$(n\le 1e6,p\le 1e9+7)$

我们可以推一下公式:
$a_n=a_{n-1}+2\ast b_{n-1}$,
$b_n=a_{n-1}+b_{n-1}=a_{n-2}+2\ast b_{n-2}+b_{n-1}=1+b_{n-1}+{\sum }_{i=1}^{n-2}2b_i$.
差分得到:$b_n-b_{n-1}=b_{n-1}+2b_{n-2}-b_{n-2}=b_{n-1}+b_{n-2}\to b_n=2b_{n-1}+b_{n-2}$.(其实不推也罢)

然后,我们猜个结论$gcd(b_x,b_y)=b_{\gcd (x,y)}$,结果用$\_\_int128$跑了$n=100$范围内,发现结论正确.

那么这道题好像就和上一题没啥区别了:
$lcm(f_S)={\prod }_{T\subseteq S}gcd(f_T{)}^{(-1{)}^{|T|+1}}={\prod }_{T\subseteq S}{f}_{\gcd (T)}^{(-1{)}^{|T|+1}}...={\prod }_{d=1}^n{g}_i$.

我们解出$g$后就差不多做完了…



最后证明一下瞎猜结论的正确性吧:
有个结论,$f_0=0,f_1=1,a\perp b,f_i=a\ast f_{i-1}+b\ast f_{i-2}\to \gcd (f_x,f_y)=f_{\gcd (x,y)}$

引理1:$\forall i\in \mathbb{N},b\perp f_i$.证明:前两项显然成立,然后$f_i\equiv a\ast f_{i-1}(\mathrm{m}\mathrm{o}\mathrm{d}b)$,因为$a\perp b,f_{i-1}\perp b$,所以可以归纳,结论正确.
引理2:$f_n\perp f_{n+1}$,证明:$\gcd (f_n,f_{n+1})=\gcd (f_n,b\ast f_{n-1})=\gcd (f_n,f_{n-1})...=\gcd (f_1,f_2)=1$

容易推出 $f_m=f_n\ast f_{m-(n+1)}+f_{n+1}\ast f_{m-n}\to \gcd (f_m,f_n)=\gcd (f_n,f_{n+1}\ast f_{m-n})=\gcd (f_n,f_{m-n})$.这个可以更相减损,所以可以归纳出$\gcd (n,m)$,证毕!

int T,n,mod;
ll power(ll a,ll b=mod-2) {
    ll c=1;
    while(b) {
        if(b&1) c=c*a%mod;
        b /= 2; a=a*a%mod;
    }
    return c;
}

ll f[N];

int main() {
    qr(T); while(T--) {
        qr(n); qr(mod);
        f[1]=1;
        for(int i=2;i<=n;i++) f[i]=(2*f[i-1]+f[i-2])%mod;
        for(int i=1;i*2<=n;i++) {
            ll t=power(f[i]);
            for(int j=i*2;j<=n;j+=i) f[j]=f[j]*t%mod;
        }
        ll ans=0,s=1;
        for(int i=1;i<=n;i++) {
            s=s*f[i]%mod;
            ans += s*i%mod;
        }
        pr2(ans%mod);
    }
    return 0;
}

推广-$kthmax$

我们设$kthmax(S)={\sum }_{S\subseteq T}f(|T|)\min (T)$.

那么第 $x$ 大数的贡献为 $[x=k]=g(x)={\sum }_{i=0}^{x-1}f(i+1)\left(\genfrac{}{}{0ex}{}{x-1}{i}\right)$.

由二项式反演得: $f(x+1)={\sum }_{i=0}^x(-1{)}^{x-i}(\genfrac{}{}{0ex}{}{x}{i})g(i+1)=(-1{)}^{x-(k-1)}\left(\genfrac{}{}{0ex}{}{x}{k-1}\right)$ ,即$f(x)={\sum }_{i=0}^x(-1{)}^{x-k}(\genfrac{}{}{0ex}{}{x-1}{k-1})$.

例题
列出公式$kth\max (S)={\sum }_{T\subseteq S}(-1{)}^{|T|-k}(\genfrac{}{}{0ex}{}{|T|-1}{k-1})\min (T),\min (T)=\frac{1}{\sum p}$.
最暴力的做法为$O(2^n)$.
如果我们像背包一样记录$|T|,\sum p$总复杂度为$O(n^{2}m)$.这样还是会T.

我们发现$k\le 11$,那么我们可以考虑试着把$k$放进dp的状态内.

定义$f_{i,j,k} $表示钦定$k$,$j=\sum p$时,$\sum (-1)^{|T|-1} \dbinom {|T|-k}{k-1}$ 的大小.

若第 $i$ 个位置不选有$f_{i,j,k}=f_{i-1,j,k}$.
选择的话,有$f_{i,j,k}=\sum (-1{)}^{|T|-k}(\genfrac{}{}{0ex}{}{|T|-1}{k-1})=\sum (-1{)}^{|T|-k+1}\left(\genfrac{}{}{0ex}{}{|T|}{k-1}\right)(|T|表示前一个状态的大小)=\sum (-1{)}^{|T|-k+1}\left[\left(\genfrac{}{}{0ex}{}{|T|-1}{k-1}\right)+\left(\genfrac{}{}{0ex}{}{|T|-1}{k-2}\right)\right]=\sum (-1{)}^{|T|-k+1}\left(\genfrac{}{}{0ex}{}{|T|-1}{k-1}\right)+(-1{)}^{|T|-k+1}(\genfrac{}{}{0ex}{}{|T|-1}{k-2})=f_{i-1,j-p[i],k-1}-f_{i-1,j-p[i],k}$.

特别的,边界设定$f_{x,0,0}=1$,这个是为了保证$k=1$时候的正确性~~(其余情况$j>0,k=0$显然为0)
需要注意的是,直接三维会爆空间,需要滚掉$i$维.

#include<bits/stdc++.h>
using namespace std;
const int N=1010,K=12,M=10010,mod=998244353;
typedef long long ll;

int n,k,m,p[N];
ll f[2][M][K],inv[M];

int main(){
    scanf("%d%d%d",&n,&k,&m); k=n-k+1;
    for(int i=1;i<=n;i++) scanf("%d",&p[i]);
    int x=0,y=1; f[x][0][0]=1;
    for(int i=1;i<=n;i++) {
        swap(x,y); memset(f[x],0,sizeof f[x]),f[x][0][0]=1;
        for(int j=1;j<p[i];j++)
            for(int v=1;v<=k;v++)
                f[x][j][v]=f[y][j][v];
        for(int j=p[i];j<=m;j++)
            for(int v=1;v<=k;v++)
                f[x][j][v]=(f[y][j][v]+f[y][j-p[i]][v-1]-f[y][j-p[i]][v]+mod)%mod;
    }
    ll ans=0;
    inv[1]=1; for(int i=2;i<=m;i++) inv[i]=inv[mod%i]*(mod-mod/i)%mod;
    for(int i=1;i<=m;i++) ans += f[x][i][k]*inv[i]%mod;
    printf("%lld\n",ans%mod*m%mod); return 0;
}