LOJ2540 PKUWC2018 随机算法 状压DP

传送门

---

两种$DP$：

①$f_{i,j}$表示前$i$次选择，最大独立集为$j$时达到最大独立集的方案总数，转移：$a.f_{i,j}+=f_{i+1,j+2^k}$（保证$k$加入后符合条件）；$b.f_{i,j}+=f_{i+1,j} imes ext{现在可以放的不影响最大独立集的点的数量}$，这个现在可以放的不影响最大独立集的点的数量就是不可选择的点（即已经选择和与已经选择的点相邻的点）的数量$-i$

复杂度$O(2^nn^2)$而且似乎无法优化

#include<bits/stdc++.h>
//This code is written by Itst
using namespace std;

inline int read(){
    int a = 0;
    bool f = 0;
    char c = getchar();
    while(c != EOF && !isdigit(c)){
        if(c == '-')
            f = 1;
        c = getchar();
    }
    while(c != EOF && isdigit(c)){
        a = (a << 3) + (a << 1) + (c ^ '0');
        c = getchar();
    }
    return f ? -a : a;
}

const int MOD = 998244353;
bool can[21][1 << 20] , edge[21][21] , choose[21];
int dp[21][1 << 20] , cnt1[1 << 20] , N , M , maxN , logg2[1 << 21];

inline int poww(long long a , int b){
    int times = 1;
    while(b){
        if(b & 1)
            times = times * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return times;
}

void dfs(int now , int size){
    if(N - now + size <= maxN)
        return;
    if(now == N){
        maxN = size;
        return;
    }
    dfs(now + 1 , size);
    for(int i = 0 ; i < now ; ++i)
        if(choose[i] && edge[i][now])
            return;
    choose[now] = 1;
    dfs(now + 1 , size + 1);
    choose[now] = 0;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("2540.in" , "r" , stdin);
    //freopen("2540.out" , "w" , stdout);
#endif
    N = read();
    logg2[0] = -1;
    for(int i = 1 ; i < (1 << N) ; ++i){
        cnt1[i] = cnt1[i - (i & -i)] + 1;
        logg2[i] = logg2[i >> 1] + 1;
    }
    for(M = read() ; M ; --M){
        int a = read() - 1 , b = read() - 1;
        edge[a][b] = edge[b][a] = 1;
    }
    dfs(0 , 0);
    for(int i = 0 ; i < N ; ++i){
        can[i][0] = 1;
        for(int j = 1 ; j < (1 << N) ; ++j)
            if(!(j & (1 << i)))
                if(can[i][j - (j & -j)]){
                    int minN = logg2[j & -j];
                    if(!edge[i][minN])
                        can[i][j] = 1;
                }
    }
    for(int i = 1 ; i < (1 << N) ; ++i)
        if(cnt1[i] == maxN)
            dp[N][i] = 1;
    for(int i = N - 1 ; i ; --i)
        for(int j = 1 ; j < (1 << N) ; ++j)
            if(cnt1[j] <= i && cnt1[j] <= maxN){
                int cnt = 0;
                for(int p = ((1 << N) - 1) ^ j ; p ; p ^= p & -p){
                    int k = logg2[p & -p];
                    if(can[k][j])
                        dp[i][j] = (dp[i][j] + dp[i + 1][j | (1 << k)]) % MOD;
                    else
                        ++cnt;
                }
                dp[i][j] = (dp[i][j] + 1ll * dp[i + 1][j] * (cnt + cnt1[j] - i)) % MOD;
            }
    long long sum = 0 , ans = 1;
    for(int i = 0 ; i < N ; ++i)
        sum = (sum + dp[1][1 << i]) % MOD;
    for(int i = 2 ; i <= N ; ++i)
        ans = ans * i % MOD;
    cout << sum * poww(ans , MOD - 2) % MOD;
    return 0;
}

②$f_{j}$表示当前已经无法选择（即已经选择和与已经选择的点相邻的点）的集合为$j$时、独立集取到最大的方案数，设$w_i$表示与$i$相邻（包括$i$）的点集，则有转移：$f_{S cup w_i}+=f_{S} imes P_{N - |S| - 1}^{|S| - |S cap w_i| - 1}$，记得要满足最大独立集大小要是最大的。

复杂度$O(2^nn)$

#include<bits/stdc++.h>
//This code is written by Itst
using namespace std;

inline int read(){
    int a = 0;
    bool f = 0;
    char c = getchar();
    while(c != EOF && !isdigit(c)){
        if(c == '-')
            f = 1;
        c = getchar();
    }
    while(c != EOF && isdigit(c)){
        a = (a << 3) + (a << 1) + (c ^ '0');
        c = getchar();
    }
    return f ? -a : a;
}

const int MOD = 998244353;
long long dp[1 << 21] , maxN[1 << 21] , cnt1[1 << 21] , need[21] , jc[21] = {1} , ny[21] = {1} , N , M;

inline int poww(long long a , int b){
    int times = 1;
    while(b){
        if(b & 1)
            times = times * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return times;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("2540.in" , "r" , stdin);
    //freopen("2540.out" , "w" , stdout);
#endif
    N = read();
    for(int i = 1 ; i < 1 << N ; ++i)
        cnt1[i] = cnt1[i - (i & -i)] + 1;
    jc[1] = ny[1] = 1;
    for(int i = 2 ; i <= N ; ++i)
        jc[i] = jc[i - 1] * i % MOD;
    ny[N] = poww(jc[N] , MOD - 2);
    for(int i = N - 1 ; i > 1 ; --i)
        ny[i] = ny[i + 1] * (i + 1) % MOD;
    for(int i = 0 ; i < N ; ++i)
        need[i] = 1 << i;
    for(M = read() ; M ; --M){
        int a = read() - 1 , b = read() - 1;
        need[a] |= 1 << b;
        need[b] |= 1 << a;
    }
    dp[0] = 1;
    for(int i = 0 ; i + 1 < (1 << N) ; ++i)
        for(int j = 0 ; j < N ; ++j)
            if(!(i & (1 << j)) && maxN[i] + 1 >= maxN[i | need[j]]){
                if(maxN[i] + 1 > maxN[i | need[j]]){
                    maxN[i | need[j]] = maxN[i] + 1;
                    dp[i | need[j]] = 0;
                }
                dp[i | need[j]] = (dp[i | need[j]] + dp[i] * jc[N - cnt1[i] - 1] % MOD * ny[N - cnt1[i] - 1 - (cnt1[need[j]] - cnt1[i & need[j]] - 1)]) % MOD;
            }
    cout << dp[(1 << N) - 1] * ny[N] % MOD;
    return 0;
}