状压DP 从TSP问题开始入门哦

　　　　  一开始学状压DP难以理解,后来从TSP开始,终于入门了nice!!!!

旅行商问题 :    给定n个城市和两两相互的距离 ,求一条路径经过所有城市,并且路径达到最下仅限于;

朴树想法: 做n个城市的排列 复杂度为n!,  但显然不可以;

首先介绍什么是状态压缩 , 本题的状态压缩就是把每一个城市分成两种状态:0代表还没有经过这座城市,1代表已经经过了这座城市，(这里就是状态)

现在，按照一定的顺序给每个城市一个编号(dp一定要有顺序性)，那么已经走过的城市的状态就可以压缩成一个数(十进制的数)(这里就是压缩)。

如果有5座城市:

　　　　初始状态:0 0 0 0 0   :表示的是都没有经历过
　　　　如果进入了下一个状态,比如第一座城市已经走过(这里是从右向左的顺序) 就为00001;
我们现在就定义一个  dp [i] [j] 表示的是这种状态下最后一个走到的城市是第j做城市    (这里的序号都是从1开始)  的最短路径,注意这里 i 和 j 有一定是联系
具体用式子说 :    (i&1<<j)==1, 就是说 i里面在 j 这个城市一定是访问过的.否者是没有意义的

状态转移: 这个状态由多个状态转移而来,dp[ i ][ j]=min( dp[ i ^ (1<<j) ][ k ] + dis[ k ][ j ]  );   k为所有非j且在i状态中存在;(这样的转移是没有后效性的)保证最优子结构

for (int i = ; i <= n; i++)
    dp[<<(i - )][i] = ;
int ans = inf;
for (int i = ; i < (<<n); i++) //状态的个数，从n个0到n个1
    for (int j = ; j <= n; j++)
    {
        if (i&(<<(j - ))) //必须是访问过的点j才可以，访问过的才知道最优子结构
        {
            for (int k = ; k <= n; k++)
                if (i&(<<(k - )) !=  && g[k][j] != -) //必须是访问过的k点且边存在
                    dp[i][j] = min(dp[i^(<<(j - ))][k] + g[k][j], dp[i][j]);
        }
        if (i == (<<n) - )
            ans = min(ans, dp[i][j]);
    }
if (ans == inf)
    return -;
return ans; 

接下来介绍一道例题

题目：
2230: Cheap deliveries

Time Limit: 2 Sec  Memory Limit: 64 MB   64bit IO Format: %lld
Submitted: 40  Accepted: 16
[Submit][Status][Web Board]

Description

Abu runs a delivery service where he deliver items from one city to another. As with any business, Abu wants to decrease his cost as much as possible. The further he travel, the more fuel he will use.

In any particular day, Abu have k items to deliver. Each item needs to be delivered from a start city to a destination city. Each city is represented by an integer. Because of his business policies, he can only deliver one item at a time. However, he can deliver the items in any order that he wants, as long as he deliver all of them. So, everyday he starts at an item's start city and deliver the item to its destination city. Then, he goes to the next items's start city and deliver the item to the its destination city. And, he does this until he does not have any item left to deliver.

From experimentation, Abu notices that the distance he travels change if he change the order of his delivery. He thought, he can save a lot of money if he knows the best delivery order. He knows that you are very good at solving this kind of problem. So he wants you to solve it for him. Given a list of cities, a list of roads between the cities (and the road's length), and a description of deliveries he must do, determine what is the minimum total travel distance, given that he execute his delivery in the most efficient order.

Every road is bidirectional and there can be more than one road between two cities. Abu can use any road as many time as he wants.

Input

The first line consists of two integer n, m, k (2 ≤ n, m ≤ 104), (1 ≤ k ≤ 18) which is the number of cities, the number of roads and the number of items respectively.

The next m line each consist of 3 integers, ui, vi, li (1 ≤ ui, vi ≤ 10^4), (1 ≤ li ≤ 10^6), which denotes that a road exists from city ui to vi with length li.

The next k line each consist of 2 integers, fi, di (1 ≤ fi, di ≤ 10^4) which denotes that the ith item is from city fi and its destination is city di.

Output

A single integer, which is the minimum total travel distance given that Abu deliver all items optimally, or -1 if its is impossible for him to deliver all items.

Sample Output 1:

题目简要: 给定一张n个点 m条路的图 和k对结点,要求选择一条路径(可以重复)且路径最短,完全就是TSP问题的变形,只不过是把一个城市转化为了一段路径(感觉像是网络流里面的拆点);先把每个点之间的距离算出来直接做就完事了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include<string.h>
#include<queue>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn = 500000+10;
inline int gi() {
	int date = 0,m = 1;
	char ch = 0;
	while(ch!='-'&&(ch<'0'||ch>'9'))ch = getchar();
	if(ch=='-') {
		m = -1;
		ch = getchar();
	}
	while(ch>='0' && ch<='9') {
		date = date*10+ch-'0';
		ch = getchar();
	}
	return date*m;
}
struct Edge {
	int to, w,nxt;
} e[maxn];
struct node2 {
	bool friend operator < (node2 n1, node2 n2) {
		return n1.d > n2.d;
	}
	int id, d;
};
int head[maxn], cnt=0;
int dis[maxn];
int finish[maxn];
int n, m,k;
inline void add(const int& from, const int& to,const int&w) {
	++cnt;
	e[cnt].to = to;
	e[cnt].nxt = head[from];
	e[cnt].w=w;
	head[from] = cnt;
}
void dij(int s) {
	memset(dis,0x3f,sizeof(dis));
	memset(finish,0,sizeof(finish));
	priority_queue<node2> q;
	dis[s] = 0;
	node2 nn1;
	nn1.id = s;
	nn1.d = dis[s];
	q.push(nn1);
	while(!q.empty()) {
		node2 nn2 = q.top();
		q.pop();
		int now = nn2.id;
		if(finish[now])continue;
		else finish[now] = 1;
		for(int i = head[now]; i ; i=e[i].nxt) {
			int nv=e[i].to;
			if(!finish[nv] && e[i].w+dis[now] < dis[nv]) {
				dis[nv] = e[i].w + dis[now];
				node2 nn3;
				nn3.id = nv;
				nn3.d = dis[nv];
				q.push(nn3);
			}

		}
	}
}
int klist[20][2];
int d[20][20];
int dp[1<<18][20];
int main() {
	int ans=inf;
	int i,j,v;
	memset(head,0,sizeof(head));
	memset(d,inf,sizeof(d));
	n=gi(),m=gi(),k=gi();
	for( i=0; i<m; i++) {
		int u=gi(),v=gi(),w=gi();
		add(u,v,w);
		add(v,u,w);
	}
	for( i=1; i<=k; i++) {
		int u=gi(),v=gi();
		klist[i][0]=u;
		klist[i][1]=v;
	}
	for( i=1; i<=k; i++) {
		dij(klist[i][0]);
		for(j=1; j<=k; j++) {
			d[i][j]=dis[klist[j][1]];
		}
	}
	memset(dp,inf,sizeof(dp));
	for(int i=0; i<k; i++) {
		dp[1<<i][i+1]=d[i+1][i+1];
	}
	for( i=0; i<(1<<k); i++) {
		for( j=0; j<k; j++) {
			if( i&(1<<j)) {
				for(v = 0; v < k; v++) {
					if((i&(1<<v))!=0&&d[j+1][v+1]!=inf) {
						dp[i][j+1]=min(dp[i][j+1],dp[i^(1<<j)][v+1]+d[j+1][v+1]+d[j+1][j+1]);
					}
				}
				if(i== (1<<k)-1) {
					ans = min(ans,dp[i][j+1]);
				}
			}
		}
	}
    if(ans==inf)ans=-1;
	cout<<ans<<endl;
	return 0;
}