DP - 状压DP - 蒙德里安的梦想 + 最短Hamilton路径

DP - 状压DP - 蒙德里安的梦想 + 最短Hamilton路径

1、蒙德里安的梦想

求把N*M的棋盘分割成若干个1×2的的长方形，有多少种方案。

例如当N=2，M=4时，共有5种方案。当N=2，M=3时，共有3种方案。

如下图所示：

输入格式
输入包含多组测试用例。

每组测试用例占一行，包含两个整数N和M。

当输入用例N=0，M=0时，表示输入终止，且该用例无需处理。

输出格式
每个测试用例输出一个结果，每个结果占一行。

数据范围
1≤N,M≤11

输入样例：
1 2
1 3
1 4
2 2
2 3
2 4
2 11
4 11
0 0
输出样例：
1
0
1
2
3
5
144
51205

---

分析：

$$\begin{gathered} 由于分割的长方形都是1\times 2的，且在矩形方格中仅有横放与竖放两种情况，因此横放的情况确定后， \\ 竖放的情况也就确定了(将剩下的空格放满)。 \\ 因此，只需要计算合法的横着摆放的方案总数即可。 \end{gathered}$$

$我们用一个二进制数来表示每一列的状态。$

$$\begin{gathered} 先考虑横放的情况： \\ 若第i列的某一行被i-1列的横着放的长方形占据(就是说该长方形占了i-1列到i列)，那么这一行对应的二进制数为1。 \end{gathered}$$

$如下图，第i列对应的状态j表示成的二进制数就是0100。$

$那么在转移的过程中有两点限制：$

$$\begin{gathered} ①、横放时：第i列与第i-1列不能存在某一行横放时出现重叠(前一块砖的后一半与后一块转的前一半重叠)， \\ 对应到二进制状态上，就是第i列的状态j和第i-1列的状态k相与应当为0，即j\&k=0。 \end{gathered}$$

$$\begin{gathered} ②、竖放时：为了填满剩余的空格，那么横放时就要避免剩余的空格中出现连续的奇数个空格， \\ 对应到二进制状态上，就是第i列的状态j和第i-1列的状态k相或，即j|k，看二进制数j|k是否存在奇数个0。 \end{gathered}$$

$$\begin{gathered} 这里来解释一下j|k，因为j表示的是占据i-1列和i列的长方形，若状态j在某一行对应的二进制数1， \\ 则i-1列对应的行就不是空格， \\ 同样的，因为k表示的是占据i-2列和i-1列的长方形，若状态k在该行对应的二进制数为1， \\ 第i-1列对应的行也不是空格。 \end{gathered}$$
$因此，只要状态j与k在某一行有一个状态对应的二进制数为1，则i-1列对应的这一行就不是空格。$

$只有满足以上两个条件时，才能从第i-1列的状态转移到第i列的状态上来。$

$状态表示，f[i][j]:第i列且二进制状态是j的方案总数。$

$状态计算：若第i列的状态j与第i-1列的状态k满足以上两个条件，则f[i][j]+=f[i-1][k]。$

具体落实：

$①、预处理标记一下所有存在连续奇数个0的状态，提高效率。$

$$\begin{gathered} ②、边界上：第一列没有前一列，默认只有一种方案(全空，二进制状态即全0)。 \\ 同样的，最后一列没有后一列，默认只有一种方案(全空，二进制状态全0)。 \\ 那么最终答案就是f[m][0]。 \end{gathered}$$

$③、一共有n行，每一种状态就是n位二进制数，状态表示的范围就是[0,2^n-1]，即[0,(1<<n)-1]。$

$$\begin{gathered} ④、预处理计算状态数组st时，计算的是连续0的个数，一但某一位是1，那么cnt要重新置0。 \\ 对每一个装态统计完最后一位后都要最后再判断一下cnt的数量是否为奇数。 \end{gathered}$$

$⑤、多组测试数据，f数组需要重置，但st数组不需要。因为st数组计算的是二进制状态，与具体的数据无关。$

代码：

#include<iostream>
#include<algorithm>
#include<cstring>

#define ll long long

using namespace std;

const int N=12,M=1<<N;

int n,m;
ll f[N][M];
bool st[M];

int main()
{
    while(cin>>n>>m,n||m)
    {
        for(int i=0;i<1<<n;i++)
        {
            int cnt=0;
            st[i]=true;
            for(int j=0;j<n;j++)
                if(i>>j&1)
                {
                    if(cnt&1) st[i]=false;
                    cnt=0;
                }
                else cnt++;
    
            if(cnt&1) st[i]=false;
        }
        
        memset(f,0,sizeof f);
        f[0][0]=1;
        for(int i=1;i<=m;i++)
            for(int j=0;j<1<<n;j++)
                for(int k=0;k<1<<n;k++)
                    if((j&k)==0&&(st[j|k]))
                        f[i][j]+=f[i-1][k];
                        
        cout<<f[m][0]<<endl;
    }
    
    return 0;
}

---

2、最短Hamilton路径

给定一张 n 个点的带权无向图，点从 0~n-1 标号，求起点 0 到终点 n-1 的最短Hamilton路径。 Hamilton路径的定义是从 0 到 n-1 不重不漏地经过每个点恰好一次。

输入格式
第一行输入整数n。

接下来n行每行n个整数，其中第i行第j个整数表示点i到j的距离（记为a[i,j]）。

对于任意的x,y,z，数据保证 a[x,x]=0，a[x,y]=a[y,x] 并且 a[x,y]+a[y,z]>=a[x,z]。

输出格式
输出一个整数，表示最短Hamilton路径的长度。

数据范围
1≤n≤20
0≤a[i,j]≤10⁷

输入样例：
5
0 2 4 5 1
2 0 6 5 3
4 6 0 8 3
5 5 8 0 5
1 3 3 5 0
输出样例：
18

---

分析：

$目标即求一条经过每个点一次的最短路的长度。$

$总的方案数是n!，求路径长度是O(n)的，因此暴力DP是不行的。$

$由于我们只需要保证经过了n个点，而无需考虑经过的顺序。$

$因此用一个二进制数来表示当前经过了哪些点的状态。$

$共有n个点，就用一个n位二进制数来表示已经经过的点，经过第i个点，就将第i位标记位1。$

$状态表示，f[i][j]:表示状态为i，走到第j个点的最短路长度。$

$$\begin{gathered} 状态计算：考虑以倒数第二个点为划分依据，假设第j个点是由第k个点直接转移而来的。 \\ 则有状态i的第j位为1，且状态i-(1<<k)的第k位为1，这样第j个点才能由第k个点直接转移而来。 \\ 方程：f[i][j]=min(f[i-(1<<k)][k]+w[k][j])，i\in [0,2^n-1]，j,k\in [0,n-1]。 \end{gathered}$$

$最终答案为f[(1<<n)-1][n-1](经过n-1个点，到达第n-1个点)。$

代码：

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N=20,M=1<<N;

int n,w[N][N],f[M][N];

int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            cin>>w[i][j];
            
    memset(f,0x3f,sizeof f);
    f[1][0]=0;
    for(int i=0;i<1<<n;i++)
    for(int j=0;j<n;j++)
        if((i>>j)&1)
        for(int k=0;k<n;k++)
            if((i-(1<<j))>>k&1)
                f[i][j]=min(f[i][j],f[i-(1<<j)][k]+w[k][j]);
                
    cout<<f[(1<<n)-1][n-1]<<endl;
    
    return 0;
                        
}

---