状态压缩

最新推荐文章于 2024-09-13 13:47:23 发布

原创最新推荐文章于 2024-09-13 13:47:23 发布 · 503 阅读

3 ·

CC 4.0 BY-SA版权

计蒜客专栏收录该内容

56 篇文章

订阅专栏

1. 二进制

给定一个集合，枚举所有可能的子集。枚举子集的方法有很多，二进制是一种代码编写非常方便的枚举子集方法。我们可以用二进制的一位表示集合对应某一元素的选取状态，1表示选取，0表示未选取。比如集合{ 1,2,3,4,5,6 },我们可以用010111表示集合{1,2,3,5}.

二进制数位	6	5	4	3	2	1
是否选取（0,1）	1	1	1	0	1	0

通过用二进制，可以很方便的枚举子集。

2.位运算

与运算：两者都为1时，结果即为1，否则为0. (可以看成和&&计算结果一样)。

或运算：两者都为0时，结果即为0，否则为1。（看以看成和 || 结果一样）
异或运算：是两者同为0或1时，结果即为0，否则为1。（类似数学中的 - 减去）

对于A<<B，表示把A转化为二进制后向左移动B位（在末尾添加B个0）。

对于A>>B，表示把A转化为二进制后向右移动B位（删除未尾的B位）。

题目：
话说大诗人李白，一生好饮。幸好他从不开车。
一天，他提着酒壶，从家里出来，酒壶中有酒两斗。他边走边唱：无事街上走，提壶去打酒。逢店加一倍，遇花喝一斗。
这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。请你计算李白遇到店和花的次序，有多少种可能的方案。

我们可以将1表示为遇店，0表示遇花，枚举15位的01序列来判断是否满足要求。

int ans = 0;
for (int i = 0; i < (1<<15); ++i) {
    int tot_1 = 0;
    int tot_0 = 0;
    int num = 2;
    for (int j = 0; j < 14; ++j) {
        if (i&(1 << j)) { // 这里判断二进制 i 从右数第 j + 1 位是否为 1
            tot_1++;
            num = num * 2;
        } else {
            tot_0++;
            num = num - 1;
        }  
    }
    //如果最后一次遇到的是店，那么不符合要求
    if(i&(1<<14))continue;
    if (tot_1 == 5 && tot_0 == 9 && num == 1) {
        ++ans; // 记录合法方案数
    }
}

3.状态压缩动态规划(状压DP)

需要借助状态压缩过程的动态规划就是状态压缩DP（很多地方会简称为状压DP）。就是将状态压缩到二进制位中，然后通过DP的手段求解。DP的每一步即是一个状态。

状态压缩的几种类型题目

例题下面我们通过一个具体的题目来了解状态压缩动态规划。
n个人在做传递物品的游戏，编号为1-n。游戏规则是这样的：开始时物品可以在任意一人手上，他可把物品传递给其他人中的任意一位；下一个人可以传递给未接过物品的任意一人。即物品只能经过同一个人一次，而且每次传递过程都有一个代价；不同的人传给不同的人的代价值之间没有联系。求当物品经过所有n个人后，整个过程的总代价是多少。

解析：

我们就可以将“当前传递过物品的人的集合、最后一个传递到的人”作为状态进行动态规划，用dp[i][j]表示这个状态的最小代价。
这里，我们就要用到状态压缩：把“传递过物品的人的集合”压缩为一个整数。我们用二进制表示这个集合，比如一共5个人，第0、3、4个人被传递过（为了方便起见，序号从0开始），就用11001表示，该集合的十进制表示为25。
注意到j是最后一个被传递到的人，也就是说必须在传递集合i中标记为1，即合法状态必须满足（i&（1<<j））!=0。如果从j传递到k，那k必须不在集合i里，即必须满足（i&（1<<k））==0。
转移方程为dp[i|1<<k][k]=min（dp[il1<<k][k]，dp[i][]+a[j][k]），其中a[j][k]为从j传递到k的代价。
因为开始时物品可以在任意一人手上，所以把dp[1<<i][i]置为0，其它状态置为无穷大。

代码：

memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i < n; i++) {
    dp[1 << i][i] = 0;
}
for (int i = 0; i < (1 << n); i++) {
    for (int j = 0; j < n; j++) {
        if (i & (1 << j)) {
            for (int k = 0; k < n; k++) {
                if (!(i & (1 << k))) {
                    dp[i | 1 << k][k] =
                        min(dp[i | 1 << k][k], dp[i][j] + a[j][k]);
                }
            }
        }
    }
}
int ans = INF;
for (int i = 0; i < n; i++) {
    ans = min(ans, dp[(1 << n) - 1][i]);
}

4.旅行商问题

旅行商问题，即TSP问题（Traveling Salesman Problem）又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。

代码：

package _状态压缩;

import java.util.Arrays;
import java.util.Scanner;

public class _旅行商问题 {

	static int n, INF = (int) 1e9;
	static int[][] dist;
	static int[][] dp = new int[1 << 16][20];

	static void init() {
		dist = new int[n][n];
		for (int i = 0; i < (1 << 16); i++)
			Arrays.fill(dp, INF);
	}

	static void Floyd() {
		for (int k = 0; k < n; k++) {
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
				}
			}
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		init();
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				dist[i][j] = sc.nextInt();
				if (dist[i][j] == -1)
					dist[i][j] = INF;
			}
		}
		dp[1][0] = 0;
		// 枚举状态
		for (int s = 0; s < (1 << n); s++) {
			// 枚举当前在哪个点上
			for (int i = 0; i < n; i++) {
				// 如果城市i在状态S中
				if ((s & (1 << i)) != 0) {
					// 枚举前一个城市
					for (int j = 0; j < n; j++) {
						// 如果城市j在状态S中
						if (j != i && (s & (1 << j)) != 0) {

							// ^ 帮助完成减法操作 s^1<<i == s-(1<<i)
							dp[s][i] = Math.min(dp[s][i], dp[s ^ 1 << i][j] + dist[j][i]);
						}
					}
				}
			}
		}
		int ans = INF;
		for (int i = 0; i < n; i++) {
			ans = Math.min(ans, dp[(1 << n) - 1][i] + dist[i][0]);
		}
		if (ans == INF)
			ans = -1;
		System.out.println(ans);
	}

}