状态压缩动态规划1：基本状态压缩

前言——

  很抱歉以这样的方式讲DP。但是现在的时间必须开始高级的算法了。
  实际上到现在，我还没有完全弄明白基础DP怎么做好，但是没办法，等等吧。
  今天的状态压缩动态规划就是我们常说的“状压DP”，它的思想很简单，但是操作很难。所以今天恐怕最难的部分反而是“前置知识”

正文——

1、前置知识：集合和二进制

  集合是由一定元素构成的一个整体，我们这里说几种集合状态。

  1.1 交集

  交集简单来说就是两个集合重复的部分。严谨一点的数学表达是

交集是由属于A且属于B的相同元素组成的集合,数学符号是"∩"。

  如果画成文氏图，那么就是这样

  交集所对应的位运算就是与运算，数学上是AND，程序上的符号是’&'，在二进制里就是同为1的时候取1，否则取0的操作。
  比如，两个二进制串：
  111010
  100100
  那么进行与运算后的结果就是
  100000

  补充1 集合运算和二进制运算的理解

  实际上仔细想一想，会发现二进制和集合的理解上是有一定冲突的。一个集合需要元素的存在，但是如果二进制串的0/1只是表示为“元素是否存在”，那么这种方式并不具体。
  简单点说，你可以说这是一个元素，这个元素是有确切指明的。但是如果你说这个元素存在，那么这个元素到底是什么呢？这样的理解就模糊了。
  举个例子，二进制的与运算是相同位置为1取1，但是如果一个位置仅仅是表达存在不存在，那么两个二进制串标1的位置完全可以对应同一个元素啊，那样不就全乱了套了吗？
  所以对于二进制串表示的集合，更确切的理解方式是：

对于一个二进制串，它的第i位表示对应特定集合中的第i个元素存在

  你可能不明白这种表示方式和感性理解的区别，但是别急，当你看到状压的方式时你会明白一切。这是似乎是一种唯一且最有效的表达方式。
  现在来看，这就能解释为什么二进制的与运算是“同位为1取1”，因为两个串第同一位置才对应相同的元素。

  1.2 并集

  听上去这个名字不好理解，但是实际上就是只要存在于两个集合的元素组成的集合。
  准确的数学表达是：

并集由所有属于A或属于B的元素所组成的集合，数学符号是“∪”。

  如果画成文氏图，就是这样：

  不难看出并集对应的集合运算就是二进制中的或运算，数学上称作OR，注意这里的对应的程序中的运算符是’|‘，而不是’||'。前者是位运算符，后者是逻辑运算符。
  在二进制里的运算就是对应位只要有1就得1，全是0才得0，换句话说就是对应位置的相同元素只要存在于一个集合就可以了。
  一个简单的例子：
  111010
  100100
  结果为：
  111110

  1.3 补集和差集

  已经讲了或运算，与运算，还剩下什么二进制运算？
  是的，补集对应的集合操作是异或运算，程序里的运算符是’^'。
  我们还是先看补集的定义，这个定义实际上是有点麻烦的。

由属于A而不属于B的元素组成的集合，称为B关于A的差集，当A是全集时，称为B关于A的补集。数学上记作A-B或A\B，即A-B={x|x∈A，且x∉B}。

  我们还是看张文氏图：

  这里注意，一般来说补集对应的是全集和子集的关系（子集在后面讲），而差集和补集的定义基本类似，但是差集是两个集合的相对关系。
  对应到二进制里，同一位对应元素中只能存在于1个集合，所以就是不同取1，相同取0的异或运算，但是注意，异或只针对补集，就是确定两者有子集关系的情况下，否则更稳妥的方式是A&(~B)。（不同时存在于两个集合的元素）。
  我们还是给个例子
  111010
  100100
  异或后：
  011110

  附表1 集合和二进制运算

集合类型	集合符号	二进制运算	二进制符号
交集	∩	与运算	&
并集	∪	或运算	|
补集	- \	异或运算	^

  1.4 子集

  我们先看定义：

设S，T是两个集合，如果S的所有元素都属于T ，即x∈S ⇒x∈T，则称S是T的子集，记为 S⊆T

  这个数学符号’∈’ 记得记一下，它表示“子集”。定义如上所示，一个集合中的元素都存在另一个集合。而’⫋’表示真子集，就是说这个子集S并不包含T的所有元素（人话说就是S!=T）。
  子集上的有关操作我们放到后面说，牵扯到集合运算

  1.5 二进制操作

  这个部分按道理说应该和前面的集合部分分开讲，但是都是前置知识。所以就放一起了。
  我们刚刚说的是二进制的运算，这里是二进制的特有操作：左移，右移，非。

  左移(<<)

  左移就是将整个二进制串向左移动，出现空位补0，溢出丢弃。
  二进制串10101011，向左移动2位，那么表示方法是10101011<<2。结果易得是1010101100，如果这个二进制只存储8位，那么这个结果就变成10101100。左移可以直接理解为*2

  右移(>>)

  这个和左移思路是完全一样的，向右移动，高位补0，溢出的时候舍弃的是低位。比如一个二进制串10101011，右移4位，就是000010101011，如果只存8位，那么就是00001010。
  和左移类似，右移理解为/2。

  非(~)

  这里还是请各位注意，这个非不是逻辑运算符，而是位运算符。
  非的理解还是1变0,0变1，不过这里是对一个二进制数按位进行取反。最终得到一个新数。
  二进制串10101011，按位取反之后就是01010100，不存在溢出情况。

  附表2 二进制的特有操作

操作符	运算含义	溢出处理
<<	左移，将整个二进制数向左移动	丢弃高位
>>	右移，将整个二进制数向右移动	丢弃低位
~	非，按位取反	无

  1.6 二进制和集合运算结合操作

  这里的操作都很常见，我决定直接整理一张表。

操作	意义
1<<(i-1)	将第i个元素映射到状态里（从1开始计数）
(A&B）==A /(A|B)==B	判断A是否是B的子集
B&(1<<(i-1))>0	判断第i个元素是否属于集合B
(s&(1<<(i-1)))	判断s的第i位是否为1
(s|(1<<(i-1)))	将s的第i位改为1
s&(s-1)	将s的最后一个1去除
s&(~(1<<i)	将s的第i位改为0

  还有一些求补集，全集这些的操作，我都不列举了。这些只要有集合运算的知识自己很轻松可以推出来。
  这里主要说两个操作，一个是操作2，一个是操作4
  如果A和B求相同的部分最终得到的全是A，证明A肯定包含在B内，或者A和B求全集为B，不含A的任何元素，也可以证明。这是判断子集的有效方式，当然，加上A!=B的条件之后可以判断是否为真子集。
  操作4，还记得我们说的二进制数位的含义吗？这里就用到了。因为从1开始计数，所以只能左移i-1位，然后就对应到了一个二进制状态中的第几个元素，如果这个元素和状态与运算为1，证明这个元素存在，也就是第i位为1。
  到了这里，我们终于解决了前置知识，可以开始进入动态规划了。

2、简单状压的思路

  状态压缩，就是将原本看似不可能的枚举所有特定方案的做法，以二进制压缩的方式快速实现，状态压缩的题目一般来说都没有多项式级的解法，暴力算法的复杂度又会较高。状压的一般复杂度是$\mathcal{O}(N^2\ast 2^n)$。虽然是特定问题的最优解，但是一般的数据范围不超过20。
  我知道刚刚的那段话你们可能没太看懂，我们还是以一道例题来讲。

  例题 原子弹

  最近，火星研究人员发现了N个强大的原子。他们互相都不一样。
  这些原子具有一些性质。当这两个原子碰撞时，其中一个原子会消失，产生大量的能量。
  研究人员知道每两个原子在碰撞时的能释放的能量。
  你要写一个程序，让它们碰撞之后产生最多的总能量。
  输入格式
  有多组数据。
  每组数据下的第一行是整数N（2 <= N <= 10），这意味着有N个原子：A1到AN。
  然后下面有N行，每行有N个整数。
  在第i行中的第j个整数表示当i和j碰撞之后产生的能量，并且碰撞之后j会消失。
  所有整数都是正数，且不大于10000。
  输入以n=0结尾。
  输入数据不超过500个。
  输出格式
  输出N个原子碰撞之后产生的最大总能量。
  输入/输出例子1
  输入：

2 
0 4
1 0
3 
0 20 1 
12 0 1 
1 10 0 
0

  输出：

4 
22

  2.1 例题分析

  这道题的暴力算法相当的恐怖：我们需要枚举每两个原子弹的碰撞情况，而且还要枚举怎么碰撞的这个顺序，也就是N个原子弹的全排列，时间就是$\mathcal{O}(N!\ast N^2)$。这个复杂度显然是不能接受的。
  这个题在枚举所有状态的时候时间太高了。那么我们有没有什么方法能快速枚举所有状态呢？
  根据我们之前的集合知识，不难想出，一个集合有N个元素，完全可以映射为一个长度为N的二进制状态，而枚举这样的二进制状态只要$\mathcal{O}(2^n)$，远远小于阶乘的大小。
  现在的第一个问题：如何设计状态？
  对于一种可能的情况，一个二进制的1/0表示这个原子弹存在不存在，我们只需要用一重循环就可以得到一个状态下包含的所有与原子弹，显然，在$\mathcal{N}<=10$的情况下，我们两重循环挨个去炸是完全可行的。所以我们的状态直接设计为F[S]就行了，每个状态对应一个最大的保障能量，最后输出F[S] (S是总方案数)。
  解决了状态设计，实际上方程还是很好推的。我们只需要在得到包含的原子弹后枚举所有可能的炸的情况就行了。因为这里分为谁炸完之后消失，所以对于“消失的原子弹”，我们就直接在状态中用异或运算剔除就可以了。
  接下来让我们看一下DP的伪代码。

void DP(){
	循环枚举所有状态S{
		先收集状态中包含的原子弹 {
			if(......)
				boom[++d]= ...
		}
		两重循环遍历两两原子弹{
			X号原子弹,Y号原子弹 
			
			1. 炸的时候使X消失
				dp[s]=dp[s^X]+Energy[X][Y];
			2. 炸的时候使Y消失
				dp[s]=dp[s^Y]+Energy[Y][X]; 
		} 
 	}
	输出最终方案DP[S] 
}

  这里注意一下我们的能量是有顺序的，对于相同的一组A，B，能量值Energy[A][B]和Energy[B][A]不一定是相等的。
  接下来我们直接放代码，具体的注释代码里都都有。

  2.2 完整代码

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

const int N=12;

int n,Energy[N][N],dp[(1<<N)],boom[N];
/*
dp数组记录一个方案对应的最大能量
所以最多有2^n-1个方案 (从0~2^n-1)
那么2^n可以用连续左移n位完成（即*2*2*2*2...） 
*/ 
void DP(){
	int S=(1<<n)-1;//总方案数，2^n-1
	for(int s=0;s<=S;++s){
		int d=0;
		for(int i=1;i<=n;++i)
			if(s&(1<<(i-1)))//如果s第i位为1，那么第i个原子弹存在
				boom[++d]=i;//收集原子弹
		//这里注意，因为我们每次是直接炸一组，所以不需要重复枚举。
		//如果每次只炸一个，那j也要从1开始，并且i需要枚举到n。
		for(int i=1;i<d;++i)  
			for(int j=i+1;j<=d;++j){
				if(i==j)//不能自己和自己炸 
					continue;
				int a=boom[i],b=boom[j];//两颗原子弹
				//b消失 
				dp[s]=max(dp[s],dp[s^(1<<(boom[j]-1))]+Energy[a][b]);
				//a消失 
				dp[s]=max(dp[s],dp[s^(1<<(boom[i]-1))]+Energy[b][a]);
			}
	} 
	printf("%d\n",dp[S]); 
}
int main(){
	while(scanf("%d",&n)&&n!=0){
		memset(dp,0,sizeof dp);
		memset(Energy,0,sizeof Energy);
		
		for(int i=1;i<=n;++i)
			for(int j=1;j<=n;++j)
				scanf("%d",&Energy[i][j]);
		DP();
	}
    return 0;
}

  2.3 例题总结

  以这道为基础，我们不难总结出状压DP的一些特点。
  状压DP，我们首先要找到状态压缩的对象，根据这个对象去确定具体的DP状态设置。然后推出方程，以此解题。
  一般来说，一道状压DP的题能状压的对象是固定的。因为状压对数据范围的要求及其严格。

3、基本状压DP的习题

  这个部分讲述的6道题目都是基本的状压DP，我们一道一道分析。

3.1 O - Matching

  有n本不同的书，编号1至n。
  有n个不同的书包，编号1至n。
  冬令营开始了，有n个学生，每个学生将会获得1个书包和1本书。
  给出二维数组a[1…n][1…n]，如果a[i][j]=1表示第i本书和第j个书包是兼容的，
  若a[i][j]=0表示第i本书和第j个书包是不兼容的。
  每个学生收到的1个书包和1本书必须是兼容的。
  n本书和n个书包之间，有多少种不同的匹配方案。
  输入格式
  第一行，一个整数n. 1<=n<=21。
  接下来是n行n列的二维数组a。
  输出格式
  一个整数，答案模1000000007。
  输入/输出例子1
  输入：

3
0 1 1
1 0 1
1 1 1

  输出：

3

  输入/输出例子2
  输入：

4
0 1 0 0
0 0 0 1
1 0 0 0
0 0 1 0

  输出：

1

  输入/输出例子3
  输入：

1
0

  输出：

0

  3.1.1 题目分析

  这道题基本上和例题是一样的。
  鉴于这道题数据很小，我们完全可以进行两重循环的枚举，每次判断书包和书是否兼容，兼容的话，就去判断书包是否存在于这个状态中。如果本来不存在，那么就加入这个新兼容的书包，然后计算结果。
  这里值得注意的是，在这种顺序思考的思路之下（就是增加新的匹配），我们需要两个维度，一个维度枚举前i个书包，另一个维度枚举状态。
  我们看看具体的操作。

void DP(){
	两重循环枚举书包/书{
		得到书的对应二进制 
		匹配？{
			枚举所有可能状态{
				if(这本书本来不在状态里&&上一个匹配状态成立){
					dp[i][算上书本状态]+=dp[i-1][s];
				}
			} 
		} 
	} 
}

  我们先看看具体代码，这个实现比较简单。

	//前i个书包，匹配状态为s，方案数 
	int S=(1<<n)-1;
	dp[0]=1;
	for(int i=1;i<=n;++i)//书包 
		for(int j=1;j<=n;++j){//书 
			int now=1<<(j-1);//得到书的对应二进制 
			if(a[i][j]){//新的兼容可能出现 
				for(int s=0;s<=S;++s)//枚举所有状态 
					if(dp[i-1][s]&&(s&now)==0)//新的书不在原状态里，并且前i-1个书包可以完成状态s的匹配 
						dp[i][(s|now)]=(dp[i][(s|now)]+dp[i-1][s])%MOD;//加上方案数 
			}
		}

  当然了，这个思路的大小是$\mathcal{O}(N^2\ast 2^n)$，虽然一般情况下已经很优秀，但是并不是最好的方法。
  如果想要优化，我们只能在两重循环那里做文章，我们的$dp[i][s]$是枚举到第i个书包状态为s的方案，我们原来的转移方程写成完整形式是：
  $dp[i][s|(1<<(j-1))]+=dp[i-1][s]$
  然后我们会发现，$s$一定是$s|(1<<(j-1))$的子集。
  也就是说，我们顺着考虑可行的情况下，现在我们可以进行逆向方程推导。也就是说：
  $dp[i][s]+=dp[i-1][s-1<<(j-1)]$ 这个方程是可行的。
  那么我们还可以按照之前方法枚举着做，但是因为$s-1<<(j-1)$一定是$s$的子集，所以，我们完全就可以省略$i$的枚举而先对状态进行枚举，所以这样，整个代码结构又回到了我们熟悉的样子：

void DP(){
	循环枚举所有状态s{
		算出状态中存在有多少个书包
		循环枚举书{
			得到书的对应二进制
			if(书如果匹配的状态存在&&当前的书包和书兼容)
				dp[s]+=dp[s^书的匹配状态] 
		} 
	} 
}

  我知道你们肯定和我一样，非常的疑惑。我先给个对应代码，然后再讲。

	for(int s=0;s<=S;++s){
		int cnt=Count(s);
		for(int i=1;i<=n;++i){
			int st=(1<<(i-1));
			if(s&st&&a[cnt][i])
				dp[s]=(dp[s]+dp[s^st])%MOD; 
		}
	} 

  首先就是这个“算出状态中存在的书包”，实际上对应的操作就是这个$Count(s)$，统计状态s中有多少个1。然后最大的问题就出来了，如果$Count(s)$是统计多少个1的话，那么这个$if$就怎么看怎么不合理啊？
  为什么会拿这个$cnt$的个数和书作匹配啊？
  这里是个非常隐蔽的条件。如果我的书包和书在一种状态下是匹配的，那么还可能打乱顺序进行匹配。好比原来书包按照1 2 3 4 5匹配了，那么打乱顺序按照2 3 1 4 5对于相同的学生就又是一种方案。而如果你去看我们优化思路时的状态设置，会发现这个状态枚举时已经暗含了顺序的打乱。110和101对应两种不同的二进制。
  所以枚举到状态$s$的时候，以1的个数确定找的是第几个书包匹配，我们始终去找一本书和这第$Count(s)$个书包作匹配，这样随着状态的枚举，1的个数只要没有增加，对应的就是这第$Count(s)$个书包位置被打乱的所有可能。
  然后就是需要判断这个书包本身的位置，如果虽然它和这本书匹配，但是这个匹配不在状态里，那也不能要。
  所以，这道题解决了。后面的转移过程和例题类似，我不讲了。
  下面给不优化和优化的两版代码。

  3.1.2 完整代码

  不优化版

#include<bits/stdc++.h>
using namespace std;
const int N=50;
const int MOD=1000000007;
int n;
int a[N][N],dp[(1<<23)];
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i)
		for(int j=1;j<=n;++j)
			scanf("%d",&a[i][j]);
	//前i个书包，匹配状态为s，方案数 
	int S=(1<<n)-1;
	dp[0]=1;
	for(int i=1;i<=n;++i)//书包 
		for(int j=1;j<=n;++j){//书 
			int now=1<<(j-1);//得到书的对应二进制 
			if(a[i][j]){//新的兼容可能出现 
				for(int s=0;s<=S;++s)//枚举所有状态 
					if(dp[i-1][s]&&(s&now)==0)//新的书不在原状态里，并且前i-1个书包可以完成状态s的匹配 
						dp[i][(s|now)]=(dp[i][(s|now)]+dp[i-1][s])%MOD;//加上方案数 
			}
		}
	printf("%d\n",dp[S]);
    return 0;
}

  优化版

#include<bits/stdc++.h>
using namespace std;
const int N=50;
const int MOD=1000000007;
int n;
int a[N][N],dp[(1<<23)];
int Count(int x){
	int res=0;
	while(x){
		x=x&(x-1);
		++res;
	}
	return res;
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i)
		for(int j=1;j<=n;++j)
			scanf("%d",&a[i][j]);
	//匹配状态为s，方案数 
	int S=(1<<n)-1;
	dp[0]=1;
	//双重枚举时间很大，逆推方程进行优化 
	for(int i=0;i<=S;++i){//枚举所有状态 
		int cnt=Count(i);//当前是第几个书包 
		for(int j=1;j<=n;++j){//枚举数 
			int st=(1<<(j-1));
			if(i&st&&a[cnt][j])//如果书和书包匹配，同时这本书和书包匹配之后在状态里 
				dp[i]=(dp[i]+dp[i^st])%MOD; //转移 
		}
	} 
	printf("%d\n",dp[S]);
    return 0;
}

3.2 U - Grouping

  有n只兔子，编号1至n。
  给出二维数组a[1…n][1…n]其中a[i][j]表示第i只兔子和第j只兔子的兼容度，
  数据保证a[i][i]=0, a[i][j] = a[j][i]。
  现在你需要把这n只兔子分成若干组，使得每只兔子仅属于一个组。
  当分组结束后，对于1<=i<j<=n，你将会获得a[i][j]元钱，前提是第i只兔子和第j只兔子分在了同一组。
  应该如何分组，才能使得最终赚的钱最多。
  输入格式
  第一行，一个整数n。 1<=n<=16。
  接下来是二维数组a, 其中 -1e9 <= a[i][j] <= 1e9。
  输出格式
  一个整数，最多能赚的钱。
  输入/输出例子1
  输入：

3
0 10 20
10 0 -100
20 -100 0

  输出：

20

  输入/输出例子2
  输入：

2
0 -10
-10 0

  输出：

0

  输入/输出例子3
  输入：

4
0 1000000000 1000000000 1000000000
1000000000 0 1000000000 1000000000
1000000000 1000000000 0 -1
1000000000 1000000000 -1 0

  输出：

4999999999

  3.2.1 题目分析

  这个题目我感觉不用多说了，和之前的题目稍微有区别。
  我们尝试枚举出每种状态只分1组的情况，然后类似于偏序的题目，枚举分割的端点进行转移就行了。注意这里的分割断点是每种状态里1的位置，所以每次去掉最后一个1就行了。
  我直接给代码，看注释吧。

  3.2.2 完整代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=17;
int n,a[N][N];
ll f[(1<<20)],v[(1<<20)];
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i)
		for(int j=1;j<=n;++j)
			scanf("%d",&a[i][j]);
	ll S=(1<<n)-1;
	
	//求出每种状态不分组（只有1组）的兼容度 
	for(int s=1;s<=S;++s){//枚举所有状态
		//直接暴力枚举任意两只兔子 
		for(int i=1;i<=n;++i)
			for(int j=i+1;j<=n;++j){
				ll m1=1<<(i-1),m2=1<<(j-1);
				if((s&m1)==m1&&(s&m2)==m2)//两只兔子都在状态s里 
					v[s]+=a[i][j];//加上兼容度 
			}		
	}
	for(int s=1;s<=S;++s){//枚举所有状态 
		f[s]=v[s];
		for(int i=s&(s-1);i;i=(i-1)&s)//根据状态枚举断点 
			f[s]=max(f[s],f[i]+f[s^i]);//打擂台转移 
	}
	printf("%lld\n",f[S]);//输出 
    return 0;
}

3.3 开锁

  有n把锁，编号1至n。有m把钥匙，第i把钥匙的价格是p[i]，第i把钥匙可以开k[i]把锁，
  分别可以开第c[i][1],c[i][2],…第c[k[i]]把锁。
  问你如果购买钥匙，用最少的费用把n把锁全部打开。
  如果无论无何也不能把n把锁全部打开，输出-1。
  输入格式
  第一行，两个整数n和m。1<=n<=12, 1<=m<=1000。
  接下来是描述m把钥匙的信息，第i把钥匙有两行：
  第1行，两个整数: p[i]和k[i]。1<=p[i]<=100000, 1<=k[i]<=n。
  第2行，k[i]个整数，依次表似乎第i把钥匙所能打开的锁的编号，从小到大给出编号。
  输出格式
  一个整数。
  输入/输出例子1
  输入：

2 3
10 1
1
15 1
2
30 2
1 2

  输出：

25

  输入/输出例子2
  输入：

12 1
100000 1
2

  输出：

-1

  输入/输出例子3
  输入：

4 6
67786 3
1 3 4
3497 1
2
44908 3
2 3 4
2156 3
2 3 4
26230 1
2
86918 1
3

  输出：

69942

3.3.1 题目分析

  这道题目还是挺有意思的。
  首先我们很明显能知道状压的只能是$n$把锁的状态，但是现在的问题是怎么安排拿什么钥匙开锁的最小花费呢？
  这个最小花费，当时给我的感觉是类似背包一样的操作，事实证明我是对的。但是这个思路确实有点烧脑。
  我们要想让$n$把锁全部最小花费打开，那就暴力试就行了。鉴于一把钥匙可能开很多锁，我枚举所有可能的锁的状态，然后只要是这把钥匙能开的全部置为1。结合之前的状态的花费+这把钥匙的花费，就是从之前的状态转移到用这把钥匙开锁之后的状态。
  写成方程就是
  $dp[s|key]=min(dp[s|key]+{\sum }_{s=1}^{(1<<n)-1}min(dp[s]+p[i]))$
  那么我们现在就只需要得到这把钥匙能开的所有的锁的状态$key$就行了。
  这个实际上也很好求，把整个$key$映射为一个二进制状态，能开的锁为1，不然为0。这样就满足了我们的上述条件。

3.3.2 完整代码

  这个题目我也直接给代码。各位自己看注释。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int n,m;
int p[N],k[N];
int c[N][20],dp[N];
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;++i){
		scanf("%d%d",&p[i],&k[i]);
		for(int j=1;j<=k[i];++j)
			scanf("%d",&c[i][j]);
	}
	for(int i=0;i<=(1<<n);++i)//这里要求最小花费，所以初始化无穷大 
		dp[i]=1e9;
	dp[0]=0;
	for(int i=1;i<=m;++i){//枚举所有钥匙 
		int now=0;
		for(int j=1;j<=k[i];++j)//映射能开的锁 
			now |= (1<<(c[i][j]-1));
		/*
		这里按照背包的写法，倒着枚举，但是正着枚举也可以。
		显然，如果一个数和一个数重复或两次，那么第二次的结果肯定和第一次的结果相同，所以可行。
		*/
		for(int s=(1<<n-1);s>=0;--s){//枚举所有锁的状态 
			int nxt=s|now;
			dp[nxt]=min(dp[nxt],dp[s]+p[i]);//向新的状态转移 
		}
	}
	if(dp[(1<<n)-1]!=1e9)//更新到全开的状态，有结果 
		printf("%d\n",dp[(1<<n)-1]);
	else
		printf("-1\n");
    return 0;
}

3.4 旅行商

  有三维立体空间里，有n个城市，第i个城市的坐标是(x[i],y[i],z[i])。
  从第i个城市到第j个城市的距离dis[i][j] = abs(x[j]-x[i]) + abs(y[j]-y[i]) + max(0,z[j]-z[i])，其中abs是求绝对值。
  你需要从1号城市出发，遍历每一个城市至少一次，最后回到1号城市，问最少的旅行距离。
  输入格式
  第一行，一个整数n。2<=n<=17。
  接下来有n行，第i行有三个整数：x[i],y[i],z[i]。-1e6<=x[i],y[i],z[i]<=1e6。
所有的城市坐标不会重叠。
  输出格式
  一个整数。
  输入/输出例子1
  输入：

2
0 0 0
1 2 3

  输出：

9

  输入/输出例子2
  输入：

3
0 0 0
1 1 1
-1 -1 -1

  输出：

10

  输入/输出例子3
  输入：

17
14142 13562 373095
-17320 508075 68877
223606 -79774 9979
-24494 -89742 783178
26457 513110 -64591
-282842 7124 -74619
31622 -77660 -168379
-33166 -24790 -3554
346410 16151 37755
-36055 51275 463989
37416 -573867 73941
-3872 -983346 207417
412310 56256 -17661
-42426 40687 -119285
43588 -989435 -40674
-447213 -59549 -99579
45825 7569 45584

  输出：

6519344

3.4.1 题目分析

  这道题目是状态压缩经典题的一个升级版，原题是直接给了两两城市之间的距离。
  显然，状压的对象很明显：只能是城市的情况，那么枚举排列情况是不现实的。我们枚举到达了那些城市就行了。
  然后这道题就类似于$Floyd$，或者说是偏序DP，我们不妨设状态为$dp[s][i]$，表示状态为s，最终到达城市i的最小距离。那么接下来只需要挨个枚举每个结尾和对应的状态，并从中枚举途径城市进行转移就行了。
  那么易得伪代码如下：

	void DP(){
		枚举所有的途径城市状态s{
			枚举所有的结尾i{
				if(i存在于状态s中){
					枚举所有的途径城市j
					dp[s][i]=min(dp[s][i],dp[s][j]+dis[j][i]); 
				}
			} 
		} 
	}

  这道题实际上思路不难，但是坑点是最后的求答案过程，根据我们的方程设定，不难想出最终答案是${\sum }_{i=1}^{n}min(dp[S][i])$，但是由于我们以第$i$个城市结尾，所以最终还要加上这个城市到1的距离！！！
  接下来还是直接给完整代码。

3.4.2 完整代码

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

typedef long long ll;
const int N=20;

ll n;
struct node{
	ll x,y,z;
}a[N];
ll dp[(1<<N)][N],dis[N][N];

void dist(){//计算任意两个城市之间的距离 
	for(int i=1;i<=n;++i)
		for(int j=1;j<=n;++j)
			//！ 
			dis[j][i]=abs(a[j].x-a[i].x)+abs(a[j].y-a[i].y)+max(ll(0),a[j].z-a[i].z);
}
void DP(){
	memset(dp,0x3f3f3f3f,sizeof dp);
	dp[1][1]=0;
	ll S=(1<<n)-1;
	for(ll s=1;s<=S;++s){//枚举状态s 
		ll si=0,sj=0;
		for(ll i=1;i<=n;++i){//枚举终点 
			si=1<<(i-1),sj=0;
			if((s&si))//终点存在才操作 
				for(ll j=1;j<=n;++j){//枚举中间点 
					sj=1<<(j-1);
					if(j!=i&&(s&sj))//中间点也存在，同时不能使终点 
						dp[s][i]=min(dp[s][i],dp[s^si][j]+dis[j][i]);//正常计算 
				}
		}
	}
	ll ans=0x7fffffff;
	for(int i=2;i<=n;++i)
		ans=min(ans,dp[S][i]+dis[i][1]);//!!!一定要加上返回1的距离 
	printf("%lld\n",ans);
}
int main(){
	scanf("%lld",&n);
	for(int i=1;i<=n;++i)
		scanf("%lld%lld%lld",&a[i].x,&a[i].y,&a[i].z);
	dist();
	DP();	
    return 0;
}

3.5 不同排列

  有n个学生，学号1至n。你现在需要把这n个学生从左往右排成一行形成队伍，要满足如下所有m个条件：
  第i个条件的格式是x[i],y[i],z[i]，表示队伍的前x[i]学生当中，学号小于y[i]的学生不能超过z[i]人。
  求满足上面所有m个条件的队伍有多少种不同的方案。
  输入格式
  第一行，n和m。 2<=n<=18, 0<=m<=100。、
  接下来m行，第i行是x[i],y[i],z[i]。1<=x[i],y[i]<n，0<=z[i]<n。
  输出格式
  一个整数。
  输入/输出例子1
  输入：

3 1
2 2 1

  输出：

4

  输入/输出例子2
  输入：

5 2
3 3 2
4 4 3

  输出：

90

  输入/输出例子3
  输入：

18 0

  输出：

6402373705728000

3.5.1 题目分析

  乍一看，这个题目除了个数据范围，完全没有一点状压的影子。
  怎么设置状态？？？$dp[s]$怎么能表示排列呢？
  哎，别急。仔细去想一想，这道题的表示方式完全可以借鉴第一题啊。

$dp[s]$表示状态为s，选择Count(s)个人时的排列方案。

  这个Count(s)我们还是用第一题的理解：状态s中有多少个人。
  然后如果我们知道到达每个位置所需要满足的限制条件，我们就可以直接判定这个状态本身的合法性，如果这个状态合法，那么又一次采取断点枚举操作，我们枚举集合中的剔除每一个元素后的方案数，就是这个状态下所有可能的方案数。
  举个例子，当前状态是10011，我们假设状态合法，那么对于这个状态的所有方案就是：
  $dp[10011]=dp[00011]+dp[10001]+dp[10010]$
  对于固定的一个元素以及固定的方案，去除这个元素的结果和加上这个元素的结果是一样的。
  我还是先给伪代码。

void DP(){	
	枚举所有状态s{
		统计s当中1的个数，算出当前到第几个人
		if(状态合法){
			循环找出每一个s中的元素
			dp[s]+=dp[s^s中的一个元素] 
		} 
	} 
}

  但是现在还有个BUG，怎么知道状态是否合法呢？
  首先，我们肯定要知道到达第$i$位的条件限制。
  因为输入给了前$x$个人学号$<y$的限制人数$z$，我们不妨就记为$lim[x][y-1]=z$。这样的话，在状态s中人数固定的情况下，我们只需要判断每一个位i前面所含有的$<=y-1$的人数是否超过限制就行了。
  这种判断方法可行，是因为我们枚举每一位的时候实际上就在枚举学号，直接就能判断。
  直接给代码了啊

bool check(ll nn,ll sta){//nn是固定人数，sta是我们要检查的状态 
	ll t=0;//记录人数 
	for(ll i=1;i<=n;++i){//循环遍历每一个人 
		ll si=1<<(i-1);
		if(sta&si) ++t;//存在，人数++ 
		if(t>lim[nn][i-1])//如果超过了学号限制 
			return false;//不合法 
	}
	return true;//合法 
}

  前期的读入处理也很简单，直接贴代码：

for(ll i=1;i<=m;++i){
	scanf("%lld%lld%lld",&x,&y,&z);
	lim[x][y-1]=min(lim[x][y-1],z);//注意这里打一个最小值，可能会重复读入，取要求最严的那个 
}

  3.5.2 完整代码

  我知道你在期待什么

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

typedef long long ll;
const ll N=20;

ll n,m;
ll x,y,z;
ll lim[N][N],dp[(1<<N)];

bool check(ll nn,ll sta){//nn是固定人数，sta是我们要检查的状态 
	ll t=0;//记录人数 
	for(ll i=1;i<=n;++i){//循环遍历每一个人 
		ll si=1<<(i-1);
		if(sta&si) ++t;//存在，人数++ 
		if(t>lim[nn][i-1])//如果超过了学号限制 
			return false;//不合法 
	}
	return true;//合法 
}
void DP(){
	dp[0]=1;
	ll S=(1<<n)-1;
	for(ll s=1;s<=S;++s){//枚举所有状态 
		ll si=0,cnt=0;
		for(ll i=1;i<=n;++i){//求出当前的队伍长度 
			si=1<<(i-1);
			if(s&si)
				++cnt; 
		}
		if(check(cnt,s)){//判断合法性 
			for(ll i=1;i<=n;++i){
				si=1<<(i-1);//存在就转移 
				if((si&s))
					dp[s]+=dp[s^si];
			}
		}
	}
	printf("%lld\n",dp[S]);
}

int main(){
	memset(lim,0x3f3f3f3f,sizeof lim);
	scanf("%lld%lld",&n,&m);
	for(ll i=1;i<=m;++i){
		scanf("%lld%lld%lld",&x,&y,&z);
		lim[x][y-1]=min(lim[x][y-1],z);//注意这里打一个最小值，可能会重复读入，取要求最严的那个 
	}
	DP();
    return 0;
}

结语——

  这只是最基础的状压DP，但是我居然还有两道题没讲（大悲）。
  预告一下啊，后面大概率会有3篇题解：一篇解决遗留的两道题，一篇是轮廓线状压DP，一篇是树形DP（这个玩意简单一点）。
  状压DP，就是要无惧时间复杂度，先从最暴力的开始想起，然后看见全排列的出现基本上就AC预定了。只要再将全排列部分用状压优化即可。它属于一种优化型的DP，我个人认为可以放到线段树和单调队列那部分去。

$Update\mathrm{2022.8.22}$:修改了部分笔误，增添了差集的描述，并对程序进行调整和说明