[ZOJ 3662] Math Magic (动态规划+状态压缩)

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3662

之前写过这道题，结果被康神吐槽说代码写的挫。

的确，那时候想法太挫了。

题意：

给你三个数n，m，k。

问你存在多少个数列 a1,a2,...,ak，使得他们的和为n，他们的最小公倍数为m。

 

想法一：

因为 lcm(a1,a2,...,ak)=m，所以a1,a2,a3,...,ak都是m的约数。

因此预处理出来m的约数，记在w[i]里。

设计状态dp[i][j][k]代表有i个数的数列，和为j，最小公倍数为k的个数。

转移：dp[i][j][k] = sigma( dp[i-1][s][t] ) 其中 s+w[i] = j，lcm( t,w[i] ) = k

于是写成 dp[i][s+w[i]][lcm(t,w[i])] = sigma( dp[i-1][s][t] )

需要优化的部分较多，需要滚动数组，很容易TLE掉。

时间复杂度O( n*m*k*sqrt(n) )

于是被康神吐槽了。。

#include <bits/stdc++.h>
using namespace std;

const int MOD = 1000000007;
int n,m,kk;
int a[1100],ptr;
int lcmn[1100][1100];
int dp[2][1100][1100];
int ss[2][1100][1100];

void getlcmn(){
    for(int i=1;i<1100;i++){
        for(int j=1;j<1100;j++){
            lcmn[i][j] = i / __gcd(i,j) * j;
        }
    }
}


int main(){
    getlcmn();
    while(scanf("%d%d%d",&n,&m,&kk)!=EOF){
        ptr = 0;
        for(int i=1;i*i<=m;i++){
            if( m%i==0 ){
                a[ptr++] = i;
                if( i*i!=m ) a[ptr++] = m/i;
            }
        }
        //for(int i=0;i<ptr;i++) printf("%d ",a[i]); puts("");
        memset(dp,0,sizeof(dp));
        for(int i=0;i<=min(m,n);i++) dp[1][i][i] = 1;
        for(int i=2;i<=kk;i++){
            for(int j=0;j<=n;j++){
                for(int k=0;k<=m;k++) dp[i&1][j][k] = 0;
                for(int s=0;s<ptr;s++){
                    if( j-a[s]>=0 ){
                        for(int t=0;t<ptr;t++) {
                            if(lcmn[a[s]][a[t]]<=m) {
                                dp[i&1][j][lcmn[a[s]][a[t]]] += dp[(i-1)&1][j-a[s]][a[t]];
                                dp[i&1][j][lcmn[a[s]][a[t]]] %= MOD;
                            }
                        }
                    }
                }
            }
        }
        printf("%d\n",dp[kk&1][n][m]);
    }
    return 0;
}

 

当时听康神说所谓的正解，还真是没听懂，正巧昨天做了这道题：http://www.cnblogs.com/llkpersonal/p/4037686.html

于是今天早上就想起这个题目，也想了想“正解”。

由题意我们知道，m是a1,a2,...,ak的最小公倍数，因此，将a1,a2,a3,...,an质因数分解，取每一个质因数的最高次幂，然后乘起来就是m。

那么我们先对m进行质因数分解，然后划分状态，假设有sn个质因数，那么总状态数就是(1<<sn)-1个。

然后去分解m的因数，给每个因数定状态，如果说因数k的质因数的指数等于m的指数，那么就给该状态标1。记作v[i]

然后去跑完全背包。

定义状态dp[i][j][k][mask]代表数列有i个数，从前j个数里选，和为k，状态为mask。

状态转移：dp[i][j][k][mask] = sigma( dp[i-1][j-1][s][t] ) 其中s+w[i] = k , t|v[i]=mask

于是有dp[i][j][s+w[i]][t|v[i]] = sigma( dp[i-1][j-1][s][t] ) 对于每一个i，都相当于是一次独立的完全背包。

由于是完全背包，因此j维可以省掉。

于是化为

dp[j][s+w[i]][t|v[i]] = sigma( dp[j-1][s][t|v[i]] )

正向递推

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <iterator>
#include <vector>
using namespace std;
typedef long long LL;

int n,m,k;
int p[1000],h[1000],w[1000],v[1000],ptr;
int dp[111][1100][1<<5];
const int MOD = 1000000007;

void prime_factor(int x){
    for(int i=2;i*i<=x;i++){
        while( x%i==0 ){
            p[i]++;
            x /= i;
        }
    }
    if( x!=1 ) p[x] = 1;
}

void handle(int x){
    w[++ptr] = x;
    for(int i=2;i*i<=x;i++){
        int t = 0;
        while( x%i==0 ){
            t ++;
            x /= i;
        }
        if( t&&t==p[i] ) v[ptr] |= (1<<(h[i]-1));
    }
    if( x!=1&&p[x]==1 ) v[ptr] |= (1<<(h[x]-1));
}

int main(){
    while(scanf("%d%d%d",&n,&m,&k)!=EOF){
        ptr = 0;
        memset(p,0,sizeof(p));
        memset(w,0,sizeof(w));
        memset(v,0,sizeof(v));
        memset(h,0,sizeof(h));
        prime_factor(m);
        int sn = 0;
        for(int i=0;i<1000;i++){
            if( p[i] ) {
                h[i] = ++sn;
            }
        }
        for(int i=1;i*i<=m;i++){
            if( m%i==0 ) {
                handle(i);
                if( i*i!=m ) handle(m/i);
            }
        }
        memset(dp,0,sizeof(dp));
        dp[0][0][0] = 1;
        for(int j=1;j<=k;j++){
            for(int i=1;i<=ptr;i++){
                for(int k=0;k<=n;k++){
                    for(int mask=0;mask<(1<<sn);mask++){
                        if( k+w[i]<=n&&(mask|v[i])<(1<<sn) ){
                            dp[j][k+w[i]][mask|v[i]] = (dp[j][k+w[i]][mask|v[i]]+dp[j-1][k][mask])%MOD;
                        }
                    }
                }
            }
        }
        printf("%d\n",dp[k][n][(1<<sn)-1]);
    }
    return 0;
}