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} \times \text{现在可以放的不影响最大独立集的点的数量}$，这个现在可以放的不影响最大独立集的点的数量就是不可选择的点（即已经选择和与已经选择的点相邻的点）的数量$-i$

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

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

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

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

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

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

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

②$f_{j}$表示当前已经无法选择（即已经选择和与已经选择的点相邻的点）的集合为$j$时、独立集取到最大的方案数，设$w_i$表示与$i$相邻（包括$i$）的点集，则有转移：$f_{S \cup w_i}+=f_{S} \times 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 = ;
     bool f = ;
     char c = getchar();
     while(c != EOF && !isdigit(c)){
         if(c == '-')
             f = ;
         c = getchar();
     }
     while(c != EOF && isdigit(c)){
         a = (a << ) + (a << ) + (c ^ '');
         c = getchar();
     }
     return f ? -a : a;
 }

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

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

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