状压 DP 详解

简介

状压 DP 其实约等于一个 DP 的小技巧,一般应用在处理一个或多个集合的问题中(因为状压 DP 的下标就是一个集合),而且在 n n n 太大的时候建议不要使用这种方法。(如果你不懂,那么就继续往下看。好吧你本来就不懂。)

做法

状压 DP 的本质就是用一连串的 0 / 1 0/1 0/1 表示一个集合中的每一个元素的状态,一个 0 / 1 0/1 0/1 就对应一个元素的状态,它所组成的编码就很像二进制,所以状压 DP 的下标大小一般都是 2 n 2^n 2n(如果 n n n 很大,那么你就会收到一份 M L E \color{darkblue}{MLE} MLE 大礼包,好吧有时候是 C E \color{yellow}{CE} CE),用来保存当前这个集合的状态。

然后我们就可以用位运算来操作与处理,为了方便讲解,我们选择一道例题

洛谷 P1171

某乡有 n   ( 2 ≤ n ≤ 20 ) n\ (2\le n\le 20) n (2n20) 个村庄,有一个售货员,他要到各个村庄去售货,各村庄之间的路程 s   ( 0 < s < 1000 ) s\ (0<s<1000) s (0<s<1000) 是已知的,且 A A A 村到 B B B 村与 B B B 村到 A A A 村的路大多不同。为了提高效率,他从商店出发到每个村庄一次,然后返回商店所在的村,假设商店所在的村庄为 1 1 1,他不知道选择什么样的路线才能使所走的路程最短。请你帮他选择一条最短的路。

这道题一看就知道肯定能写最短路,但是我们讲的是状压 DP,那就拿状压 DP 写吧。

首先确定下标是什么。状压 DP 下标的第一维肯定是当前状态,那是啥的状态呢?一看: n ≤ 20 n\le20 n20。这不妥妥的天生状压 DP 之体吗?所以状态就很简单了:当前这个点走没走过(也只能这么定义了,又不可能定义这个点存不存在,如果是这样的话那这个村子都没了还走个什么)。然后第二位就是图上 DP 的经典操作——当前在哪个点——了啊。一算总大小,刚好 1 0 7 = 10000000 10^7=10000000 107=10000000 左右( 2 20 = 1048576 2^{20}=1048576 220=1048576),不多不少。

那么 dp[i][j] 的定义自然就是在 i i i 这个状态下从第 1 1 1 个点到第 j j j 个点的最短距离。

其次就是状态转移方程了。首先状压 DP 的标配就是枚举当前状态,即从 00 … 0 ⏟ n  个  0 \underbrace{00\dots0}_{n\ \text{个}\ 0} n  0 000 11 … 1 ⏟ n  个  1 \underbrace{11\dots1}_{n\ \text{个}\ 1} n  1 111(在十进制下就是从 0 0 0 2 n − 1 2^n-1 2n1,这个减 1 1 1 的原因是因为二进制是从第 0 0 0 位开始算的,不是第 1 1 1 位,所以说最高位实际上是第 n − 1 n-1 n1 位,正好 2 n − 1 2^n-1 2n1 就有 n − 1 n-1 n1 位,且能极好的表达 11 … 1 ⏟ n  个  1 \underbrace{11\dots1}_{n\ \text{个}\ 1} n  1 111 这个数),这就是第一层循环。

其次肯定要枚举当前在哪个点。那对于当前所在的点我们就要进行分类讨论了:这个点在当前状态下走过还是没走过。现在我们不要管实际上是不是真的走过某个点,我们就认为当前这个状态就是对的。那走过的肯定不用说,走都走过了还有什么好更新的,关键在于没走过的。

没走过的我们就按照类似 Floyd 的方法,即给它找一个中转点(毕竟 Floyd 的本质不就是一个类似于 DP 的东西吗),所以我们只需要再浅浅的加一层循环找一个中转点,当然,这个中转点必须是当前状态下已经走过的点。(你自己都没走过还想帮别人。)

于是我们就可以写出一份伪代码:

memset(dp,0x3f3f3f3f,sizeof(dp));
dp[1][1]=0;//初始化:走过 1 且从 1 到 1 的距离等于没有距离(没走过一个点怎么走?)
for(int i=0;i<(1<<n);i++)
{
    for(int j=1;j<=n;j++)
    {
        if(!((1<<j-1)&i))
        {
            for(int k=1;k<=n;k++)
            {
                if((1<<k-1)&i)
                {
                    dp[i|(1<<j-1)][j]=min(dp[i|(1<<j-1)][j],dp[i][k]+a[k][j]);
                }
            }
        }
    }
}

有人会说:你这个时间复杂度一看就是 O ( 2 n × n 2 ) O(2^n\times n^2) O(2n×n2) 啊,这不包超时的吗?啊,其实是不会的,因为你看到第 5 5 5 行没有?这一句话会帮我省掉大部分循环,所以总体时间复杂度是肯定没有那么高的,是肯定不会超时的。

于是我们就可以写出完整代码:

#include<bits/stdc++.h>
using namespace std;
int n,ans=0x3f3f3f3f,a[26][26],dp[1050006][26];
signed main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cin>>a[i][j];
        }
    }
    memset(dp,0x3f3f3f3f,sizeof(dp));
    dp[1][1]=0;
    for(int i=0;i<(1<<n);i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(!((1<<j-1)&i))
            {
                for(int k=1;k<=n;k++)
                {
                    if((1<<k-1)&i)
                    {
                        dp[i|(1<<j-1)][j]=min(dp[i|(1<<j-1)][j],dp[i][k]+a[k][j]);//中转一下
                    }
                }
            }
        }
    }
    for(int i=2;i<=n;i++)
    {
        ans=min(ans,dp[(1<<n)-1][i]+a[i][1]);//在经过了所有点的情况下最后走那个点路程最短呢?
    }
    cout<<ans;
    return 0;
}

以上就是状压 DP 的全部内容了。喜欢的同学们麻烦点个赞、收藏一下,我们下期再见。

<think>嗯,用户想了解用Python中的动态规划DP)解决旅行商问题(TSP)的详细方法。首先,我需要回忆一下TSP的基本概念。TSP是要找到一条最短的路径,让旅行商访问所有城市并回到起点,每个城市只访问一次。这属于NP难问题,所以需要高效的算法来处理,尤其是当城市数量较多时。 DP通常用于处理态中包含集合的情况,比如访问过的城市集合。因为用二进制位来表示集合可以节省空间,例如,n个城市可以用n位的二进制数表示,每一位代表是否访问过该城市。这样的话,态可以表示为当前所在城市和已经访问过的城市集合。 接下来,我得考虑动态规划态定义。通常,dp[mask][i]表示当前已经访问过的城市集合为mask,并且最后停留在城市i时的最短路径长度。初始态应该是只访问了一个城市的情况,比如dp[1 << i][i] = 0,因为从城市i出发,还没有移动,所以距离为0。不过根据用户提供的引用[1],初始化每个景点j在只访问自己的态下的公交次数为0,即dp[j][1 << j] = 0。这里的公交次数可能对应路径长度,所以类似。 然后态转移方程应该是:对于每一个态mask和当前城市i,遍历所有未访问过的城市j,更新dp[mask | (1 << j)][j] = min(dp[mask | (1 << j)][j], dp[mask][i] + dist[i][j])。也就是说,从i到j,将j加入已访问集合,并更新最短路径。 接下来要考虑Python的实现。由于Python对于位运算的支持还不错,可以用字典或者二维数组来存储dp。不过考虑到空间问题,如果城市数量n较大,二维数组可能会占用太多内存。但TSP通常处理的是n较小的情况(比如n=15左右),所以可能还是可行的。 需要处理的问题包括如何遍历所有可能的mask,以及如何高效地进行态转移。另外,要注意mask的位数,比如n个城市,mask的范围是0到2^n -1。对于每个mask,需要检查哪些城市已经被访问过,然后找到下一个未访问的城市。 还需要给出具体的代码示例。比如,初始化一个二维数组dp,大小为(2^n, n),初始化为无穷大,然后设置初始态,接着遍历所有mask,对于每个mask中的当前城市i,找到未访问的城市j,进行态转移。 另外,用户提供的引用[2]提到了分支限界法使用优先队列来减少搜索空间,可能和这里的DP不同,但可以提一下其他方法作为对比。引用[3]中的回溯法框架可能也相关,但DP更高效。 最后,需要考虑路径的起点和终点是否需要回到起点。在TSP中,通常要求回到起点,所以在计算完所有城市被访问的态后,还需要加上从最后一个城市回到起点的距离。或者,在代码实现中,最后一步需要处理这一步。 举个例子,假设有4个城市,距离矩阵给出各个城市之间的距离。初始化时,dp[0001][0] = 0,dp[0010][1] = 0,依此类推。然后对于每个mask,比如0001,当前城市0,那么遍历其他城市1、2、3,将mask更新为0011、0101、1001,对应的dp值加上距离。 在Python中,可以用一个二维列表来存储dp,例如dp = [[inf] * n for _ in range(1 << n)]。然后循环mask从1到(1 << n) -1,对于每个mask,检查每一位是否为1,找到当前城市i,然后遍历所有可能的j不在mask中的情况。 最后,得到所有城市都被访问过的mask(全1),然后找出最小的dp值,再加上从最后城市回到起点的距离,或者如果在态转移中已经考虑了回到起点的情况,那就可以直接取最小值。 可能的错误点:初始化是否正确,mask的遍历顺序是否正确(应该从小到大),以及如何处理最后回到起点的问题。需要仔细检查这些步骤。 然后,编写代码示例,包括距离矩阵的定义,dp数组的初始化,态转移的循环,以及最后结果的提取。同时,可能需要测试一个简单案例,比如3个城市,手动计算验证是否正确。 此外,用户可能需要了解时间复杂度和空间复杂度,以及优化方法,比如使用位运算加速,或者空间优化(例如使用滚动数组),但可能对于Python来说,空间优化不太容易,因为n超过20的话,2^20已经是百万级别,可能会占用较大内存。 总结来说,步骤是:问题分析,态定义,转移方程,初始化,遍历顺序,代码实现,结果处理,复杂度分析,以及可能的优化。</think>### PythonDP解决旅行商问题(TSP)详解 #### 1. 问题分析 旅行商问题(TSP)要求在$n$个城市中找到一条最短环路,访问每个城市恰好一次并返回起点。动态规划通过二进制表示已访问城市集合,将时间复杂度优化到$O(n^2 \cdot 2^n)$[^2]。 #### 2. 态定义 定义二维数组$dp[mask][i]$: - $mask$:二进制数,第$j$位为1表示已访问城市$j$ - $i$:当前所在城市 - 值:从起点出发,经过$mask$对应城市后到达$i$的最小路径长度 #### 3. 态转移方程 $$dp[mask | (1 << j)][j] = \min\left(dp[mask | (1 << j)][j],\ dp[mask][i] + dist[i][j]\right)$$ 其中$j$是未访问城市(即$mask$的第$j$位为0) #### 4. 实现步骤 ```python import sys def tsp(dist): n = len(dist) total_mask = 1 << n INF = sys.maxsize # 初始化dp表:dp[mask][i] dp = [[INF] * n for _ in range(total_mask)] for i in range(n): dp[1 << i][i] = 0 # 初始态:只访问过城市i # 遍历所有态 for mask in range(total_mask): for i in range(n): if not (mask & (1 << i)): # 当前城市必须已访问 continue for j in range(n): if mask & (1 << j): # 目标城市必须未访问 continue new_mask = mask | (1 << j) dp[new_mask][j] = min(dp[new_mask][j], dp[mask][i] + dist[i][j]) # 最终结果需返回起点(假设起点是0) final_mask = (1 << n) - 1 return min(dp[final_mask][i] + dist[i][0] for i in range(n)) # 示例距离矩阵(4个城市) dist = [ [0, 10, 15, 20], [10, 0, 35, 25], [15, 35, 0, 30], [20, 25, 30, 0] ] print(tsp(dist)) # 输出:80 (0->1->3->2->0) ``` #### 5. 关键点说明 1. **态初始化**:每个城市作为起点时路径长度为0[^1] 2. **掩码遍历顺序**:从小到大确保态依赖已计算 3. **路径闭合处理**:最终结果需加上返回起点的距离 4. **空间优化**:可使用滚动数组减少内存占用 #### 6. 复杂度分析 - 时间复杂度:$O(n^2 \cdot 2^n)$ - 空间复杂度:$O(n \cdot 2^n)$
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值