状态压缩DP总结【POJ3311】【HDU3001】【POJ2288】【ZOJ4257】【POJ2411】【HDU3681】

来源：互联网发布：中小学生网络知识竞赛编辑：程序博客网时间：2024/05/18 09:12

【POJ3311】Hie With The Pie

【题目大意】类似于TSP问题，只是每个点可以走多次，比经典TSP问题不同的是要先用弗洛伊的预处理一下两两之间的距离。求最短距离。

【解析】可以用全排列做，求出一个最短的距离即可。或者用状态压缩DP.用一个二进制数表示城市是否走过

【状态表示】dp[state][i]表示到达i点状态为state的最短距离

【状态转移方程】dp[state][i] =min{dp[state][i],dp[state'][j]+dis[j][i]} dis[j][i]为j到i的最短距离

【DP边界条件】dp[state][i] =dis[0][i] state是只经过i的状态

【代码】

[cpp] view plaincopyprint?

#include<iostream>
#define INF 100000000
using namespace std;
int dis[12][12];
int dp[1<<11][12];
int n,ans,_min;
int main()
{
//freopen("in.txt","r",stdin);
while(scanf("%d",&n) && n)
{
for(int i = 0;i <= n;++i)
for(int j = 0;j <= n;++j)
scanf("%d",&dis[i][j]);
for(int k = 0;k <= n;++k)
for(int i = 0;i <= n;++i)
for(int j = 0;j <=n;++j)
if(dis[i][k] + dis[k][j]< dis[i][j])
dis[i][j] = dis[i][k] +dis[k][j];
for(int S = 0;S <= (1<<n)-1;++S)//枚举所有状态，用位运算表示
for(int i = 1;i <= n;++i)
{
if(S & (1<<(i-1)))//状态S中已经过城市i
{
if(S ==(1<<(i-1))) dp[S][i] =dis[0][i];//状态S只经过城市I，最优解自然是从0出发到i的dis,这也是DP的边界
else//如果S有经过多个城市
{
dp[S][i] = INF;
for(int j = 1;j <=n;++j)
{
if(S &(1<<(j-1)) && j != i)//枚举不是城市I的其他城市
dp[S][i] =min(dp[S^(1<<(i-1))][j] + dis[j][i],dp[S][i]);
//在没经过城市I的状态中，寻找合适的中间点J使得距离更短
}
}
}
}
ans = dp[(1<<n)-1][1] + dis[1][0];
for(int i = 2;i <= n;++i)
if(dp[(1<<n)-1][i] + dis[i][0] < ans)
ans = dp[(1<<n)-1][i] +dis[i][0];
printf("%d\n",ans);
}
return 0;
}

【HDU3001】Traveling

【题目大意】10个点的TSP问题，但是要求每个点最多走两边，不是只可以走一次，所以要用三进制的状态压缩解决这个问题。可以预处理每个状态的第k位是什么。

【解析】和tsp问题相同,类似于上面那个题

【状态表示】【状态转移方程】同上题，具体见代码

【代码】

[cpp] view plaincopyprint?

#include <cstdio>
#include <cstring>
#define INF 0x1f1f1f1f //刚发现这里写0x1f1f1f跑的比0x1f1f1f1f差不多慢了一倍！Orz~
#define min(a,b) (a) < (b) ? (a) : (b)
using namespace std;
int N,M;
int tri[12] ={0,1,3,9,27,81,243,729,2187,6561,19683,59049};
int dig[59050][11]; //dig[state][k_dig] 状态state的第k位是多少
int edge[11][11],dp[59050][11];
int main(){
for(int i = 0; i < 59050; ++i){
int t = i;
for(int j = 1; j <= 10; ++j){
dig[i][j] = t%3;
t /= 3;
if(t == 0)break;
}
}
while(scanf("%d%d",&N,&M) != EOF){
memset(edge,INF,sizeof(edge));
int a,b,c;
while(M --){
scanf("%d%d%d",&a,&b,&c);
if(c < edge[a][b])edge[a][b] = edge[b][a] = c;
}
memset(dp,INF,sizeof(dp));
for(int i = 1; i <= N; ++i)dp[tri[i]][i] = 0;
int ans = INF;
for(int S = 0; S < tri[N+1]; ++S){
int visit_all = 1;
for(int i = 1; i <= N; ++i){
if(dig[S][i] == 0)visit_all = 0;
if(dp[S][i] == INF)continue;
for(int j = 1; j <= N; ++j){
if(i == j)continue;
if(edge[i][j] == INF ||dig[S][j] >= 2)continue;
int newS = S + tri[j];
dp[newS][j] =min(dp[newS][j],dp[S][i] + edge[i][j]);
}
}
if(visit_all){
for(int j = 1; j <= N; ++j)
ans = min(ans,dp[S][j]);
}
}
if(ans == INF){
puts("-1");
continue;
}
printf("%d\n",ans);
}
return 0;
}

【POJ2288】Islands and Bridge

【题目大意】求汉密尔顿的一道变形问题，中间每个点有权值，关于最后得分的描述如下

Suppose there are n islands. The value of aHamilton path C1C2...Cn is calculated as the sum of three parts. Let Vi be thevalue for the island Ci. As the first part, we sum over all the Vi values foreach island in the path. For the second part, for each edge CiCi+1 in the path,we add the product Vi*Vi+1. And for the third part, whenever three consecutiveislands CiCi+1Ci+2 in the path forms a triangle in the map, i.e. there is abridge between Ci and Ci+2, we add the product Vi*Vi+1*Vi+2.

这题要求让得分最高

【解析】发现每个点的状态由前面两个点确定，用DP（S,A,B）表示状态为S时，当前到达A，而上一个点是B时的最大得分，这个状态由DP（S',B,C）通过从B走到A得到，S'=S-(1<<A),即S'状态就是经过B和C但不经过A的一个状态，C是不同于A和B的一个点。

【状态转移】dp[S][A][B] =max(dp[S][A][B],dp[S'][B][C]+temp) 这里的temp指的是加上的得分即Vb*Va+Va,如果构成三角关系（即A和C间有边），temp就要再加上Vb*Va*Vc.

【边界条件】DP((1<<A)+(1<<B),A,B)=Va+Vb+Va*Vb(A和B间有边)表示

【代码】

[cpp] view plaincopyprint?

#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN = 13;
const int MAX_S = 1<<(MAXN+1);
long long dp[MAX_S][MAXN+1][MAXN+1];
long long way[MAX_S][MAXN+1][MAXN+1];
int edge[MAXN+1][MAXN+1];
long long V[MAXN+1];
int N,M;
int main(){
int cas;
scanf("%d",&cas);
while(cas --){
memset(edge,0,sizeof(edge));
scanf("%d%d",&N,&M);
for(int i = 1; i <= N; ++i)
scanf("%d",&V[i]);
if(N == 1){
printf("%d 1\n",V[1]);
continue;
}
int a,b;
while(M --){
scanf("%d%d",&a,&b);
edge[a][b] = edge[b][a] = 1;
}
memset(dp,-1,sizeof(dp));
memset(way,0,sizeof(way));
int ii,jj;
long long temp;
for(int i = 1; i <= N; ++i)
for(int j = 1; j <= N; ++j){
if(i == j || !edge[i][j])continue;
ii = 1<<(i-1);
jj = 1<<(j-1);
temp = V[i]+V[j]+V[i]*V[j];
dp[ii+jj][i][j] = temp;
way[ii+jj][i][j] = 1;
}
for(int S = 0; S < (1<<N); ++S)
for(int i = 1; i <= N; ++i){
if((S&(1<<(i-1))) == 0)continue;
for(int j = 1; j <= N; ++j){
if((S&(1<<(j-1))) ==0 || i == j || !edge[i][j])continue;
for(int k = 1; k <= N; ++k){
if(i == k || j == k ||(S&(1<<(k-1))) == 0)continue;
int newS = S -(1<<(i-1));
if(dp[newS][j][k] ==-1)continue;
if(!edge[j][k])continue;
temp =V[i]+V[i]*V[j]+dp[newS][j][k];
if(edge[i][k])temp +=V[i]*V[j]*V[k];
if(dp[S][i][j] < temp){
dp[S][i][j] = temp;
way[S][i][j] =way[newS][j][k]; //如果dp更新，way直接更新
}
//如果dp不更新，但dp=temp，way加上原来的值
else if(temp ==dp[S][i][j])way[S][i][j] += way[newS][j][k];
}
}
}
long long ans = -1,num = 0;
int p = (1<<(N)) - 1;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j){
if(i == j)continue;
if (ans < dp[p][i][j]){
ans = dp[p][i][j];
num = way[p][i][j];
}
else if (ans == dp[p][i][j])
num += way[p][i][j];
}
if(ans == -1){
puts("0 0");
continue;
}
printf("%lld %lld\n",ans,num/2);
}
return 0;
}

【ZOJ4257】MostPowerful

【题目大意】不超过10种气体，两两之间相互碰撞可以产生一定的能量，如a碰b，那么b气体就消失，自身不能碰自身，问最后所能得到的最大能量。

【题目解析】用10位二进制表示气体是否存在，0表示存在，1表示不存在，S（上一个状态）中的两种气体碰撞并且有一种消失，可以得到newS的状态（状态转移）

【状态表示】dp[state] 状态为state时的最大能量

【转移方程】dp[state] = max(dp[state],dp[state']+a[i][j])

【边界条件】dp[i] = 0;

【代码】

[cpp] view plaincopyprint?

#include <cstdio>
#include <cstring>
using namespace std;
#define max(a,b) (a) > (b) ? (a) : (b)
const int MAXN = 10;
const int MAX_S = 1 << 10;
int a[MAXN+1][MAXN+1];
int dp[MAX_S];
int N;
int main(){
while(scanf("%d",&N) != EOF){
if(N == 0)break;
for(int i = 0; i < N; ++i)
for(int j = 0; j < N; ++j){
scanf("%d",&a[i][j]);
}
memset(dp,0,sizeof(dp));
int full = 1 << N;
for(int s = 0; s < full; ++s){
for(int i = 0; i < N; ++i){
if((s&(1<<i)))continue;
for(int j = 0; j < N; ++j){
if(i == j)continue;
if( (s&(1<<j)) )continue;
int newS = s + (1<<j);
dp[newS] = max(dp[newS],dp[s] + a[i][j]);
}
}
}
int ans = 0;
for(int s = 0; s < full ; ++s)
ans = max(ans,dp[s]);
printf("%d\n",ans);
}
return 0;
}

【POJ2411】Mondriaan'sDream

【题目大意】一个矩阵，只能放1*2的木块，问将这个矩阵完全覆盖的不同放法有多少种。

【解析】如果是横着的就定义11，如果竖着的定义为竖着的01，这样按行dp只需要考虑两件事儿，当前行&上一行，是不是全为1，不是说明竖着有空（不可能出现竖着的00），另一个要检查当前行里有没有横放的，但为奇数的1。

【状态表示】dp[state][i]第i行状态为state时候的方案数

【转移方程】dp[state][i] += dp[state'][i-1] state'为i-1行的，不与i行状态state冲突的状态

【边界条件】第一行符合条件的状态记为1 即dp[state][0] = 1;

【代码】

[cpp] view plaincopyprint?

#include <cstdio>
#include <cstring>
using namespace std;
int M,N;
long long dp[1<<11][11];
bool kexing[1<<11];
int full;
inline bool check(int in)
{
int bit=0;
while(in>0){
if( (in&1)==1)
bit++;
else{
if( (bit&1)==1)
return false;
bit=0;
}
in>>=1;
}
if( (bit&1)==1)
return false;
return true;
}
inline bool check2(int x1,int x2){
if( (x1|x2)!= full-1 ) //如果这里不用位运算，时间很长，要用约3000MS
return false;
return kexing[x1&x2];
}
int main(){
full = 1<<11;
for(int s = 0; s < full; ++s)if(check(s))kexing[s] = 1;
while(scanf("%d%d",&M,&N) != EOF){
if(N == 0 && M == 0)break;
memset(dp,0,sizeof(dp));
full = 1<<N;
for(int s = 0; s < full; ++s){
if(kexing[s])
dp[s][0] = 1;
}
for(int i = 1; i < M; ++i){
for(int s = 0; s < full; ++s){
for(int s1 = 0; s1 < full; ++s1){
if(!check2(s1,s))continue;
//if(dp[s1][i-1] == 0)continue;
/*这一步判断的时间要大于位运算和+=的时间，如果先把这一步放在
check2前面，1300多MS，如果放在check2后面，610多MS，如果不加这
一步，560MS，但如果check2用的不是位运算，将这一步加在check2前
面3000MS左右（水过），如果不加这一步，TLE
*/
dp[s][i] += dp[s1][i-1];
}
}
}
int S = (1<<N) - 1;
printf("%lld\n",dp[S][M-1]);
}
return 0;
}

【HDU3681】PrisonBreak 状态压缩DP+BFS+二分答案

2010杭州赛区的题目，以现在的水平遇到这种题也就能想一下，赛场上动手写这个题是不会的。前天做状压DP的时候又看到这个题，没想起来怎么做，昨天看了一下解题报告开始下手，遇到了各种问题。调试了N久，终于过了。

【题目大意】机器人从F出发，走到G可以充电，走到Y关掉开关，D不能走进，要求把所有开关关掉，且电量最少，并求出该最小电量。

【题目解析】机器人从出发点出发要求走过所有的Y，因为点很少，所以就能想到经典的TSP问题（起初我也想到了），但关于G点（不要YY）能充电的问题不知道怎么办，看了下解题报告才知道。G点可以充电，到达G点就把当前能量更新为电池容量然后继续走。因为每个G点只能充一次电，这就好像TSP中的每个点只能走一次一样（G和Y都可以走多次，但走到G充电后，该点就变为了S，而走到Y关上开关以后，Y也变成了S。这是一个很巧妙地想法，所以要求Y点只能关一次开关，G点只能充一次电，这就是TSP了。Orz赛场上可以秒杀这题的大神们），然后就是二分答案了，用状压DP判定当前电池容量的情况下是否能符合条件。

【状态表示】dp[s][i]表示到达当前i点状态为s时最大的剩余的能量

【转移方程】同TSP问题了

【边界条件】dp[1<<sid][sid] = rongliang.即出发点的能量就是电池容量

【代码】：

[cpp] view plaincopyprint?

#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
using namespace std;
#define INF 0x1f1f1f1f
int dp[32769][16];
int dist[16][16][16][16];
int di[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
int M,N,sid,nCnt,FinalState;
char map[16][16];
struct node{
int x,y;
node(){}
node(int _x,int _y):x(_x),y(_y){}
}nodes[16];
inline void BFS(node start)
{
queue<node> que;
int sx = start.x,sy = start.y;
dist[sx][sy][sx][sy] = 0;
que.push(start);
node cur;
while(!que.empty()){
cur = que.front();
que.pop();
int x = cur.x,y = cur.y,tx,ty;
for(int i = 0; i < 4; ++i){
tx = x + di[i][0];
ty = y + di[i][1];
if(tx < 0 || tx >= M || ty < 0 || ty >= N || map[tx][ty] == 'D')continue;
if(dist[sx][sy][tx][ty] == -1){
dist[sx][sy][tx][ty] = dist[sx][sy][x][y] + 1;
que.push(node(tx,ty));
}
}
}
}
inline bool ok(int s,int t){ //s状态中走过所有t状态中的城市
if(((s&t)&t) == t)return 1;
return 0;
}
inline bool check(int step){
int res = -1;
memset(dp,-1,sizeof(dp));
dp[1<<sid][sid] = step;
int full = 1<<nCnt;
for(int s = 0; s < full; ++s){
for(int i = 0; i < nCnt; ++i){
if((s&(1<<i)) == 0 || dp[s][i] == -1)continue;
if(ok(s,FinalState))res = max(res,dp[s][i]);
for(int j = 0; j < nCnt; ++j){
int temp = dist[nodes[i].x][nodes[i].y][nodes[j].x][nodes[j].y];
if(i == j || temp == -1 || (s&(1<<j)))continue;
temp = dp[s][i] - temp;
if(temp < 0)continue;
int newS = s + (1<<j);
dp[newS][j] = max(dp[newS][j],temp);
if(map[nodes[j].x][nodes[j].y] == 'G')dp[newS][j] = step;
}
}
}
if(res < 0)return 0;
return 1;
}
inline int solve(){
int low = 0,high = 300;
int mid;
while(low <= high){
mid = (low+high)/2;
if(check(mid))high = mid-1;
else low = mid+1;
}
if(low == 301)return -1;
return low;
}
int main(){
while(scanf("%d%d",&M,&N) != EOF){
if(M == 0 && N == 0)break;
nCnt = 0;
FinalState = 0;
for(int i = 0; i < M; ++i){
scanf(" %s",map[i]);
for(int j = 0; j < N; ++j){
if(map[i][j] == 'F'){
sid = nCnt;
nodes[nCnt++] = node(i,j);
FinalState += (1<<sid);
}
else if(map[i][j] == 'G')
nodes[nCnt++] = node(i,j);
else if(map[i][j] == 'Y'){
int tid = nCnt;
nodes[nCnt++] = node(i,j);
FinalState += (1<<tid);
}
}
}
memset(dist,-1,sizeof(dist));
for(int i = 0; i < nCnt; ++i)BFS(nodes[i]);
int ans = solve();
printf("%d\n",ans);
}
return 0;
}

0 0