状态压缩dp

所谓的状态压缩dp其实就是使用一个整数表示一个状态然后其余的就跟普通的动态规划是一样的了。

通常的状态有集合的表示（使用2进制表示有或没有）

2441

题目大意：

有n个人可以去pi个球场，问要求一个球场只能有一个人去且满足所以人都去一个的方案数有多少种

分析：

dp[i][j]表示当前第i个人选择状态为j的方案数，那么转移就是

dp[i][j]=sum{dp[i-1][s']}s'为之前的状态

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include<cmath>
#include<vector>
#define maxn 20
#define maxm 20
#define mod 1000000000000000000
#define INF 0x3f3f3f3f
using namespace std;
int a[maxn][maxn];
int n,m;
int dp[1<<maxm+1];
int state[1<<maxm+1];
int main (){
    while(scanf("%d%d",&n,&m)!=EOF){
        for(int i=1;i<=n;++i){
            scanf("%d",&a[i][0]);
            for(int j=1;j<=a[i][0];++j){
                scanf("%d",&a[i][j]);
                a[i][j]--;
            }
        }
        for(int i=0;i<(1<<m);++i){
            state[i] =0;
            for(int j=0;j<m;++j){
                if(i&(1<<j))state[i]++;
            }
        }
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=a[1][0];++i){
            dp[(1<<a[1][i])]=1;
        }
        for(int i=2;i<=n;++i){
            for(int j=(1<<m)-1;j>=0;--j){
                if(state[j]!=i)continue;
                for(int k=1;k<=a[i][0];++k){
                    if(!(j&(1<<a[i][k])))continue;
                    dp[j]+=dp[j-(1<<a[i][k])];
                }
            }
        }
        int ans=0;
        for(int i=0;i<(1<<m);++i){
            if(state[i]==n)ans+=dp[i];
        }
        printf("%d\n",ans);
    }
}

2836

题意：

给你n个二维的点，要求画两边平行于x,y轴的长方形去覆盖所有的点，要求一个长方形最少覆盖两个点，问长方形面积总和最小值。

分析：

首先枚举长方形的两个顶点，构造n*n/2个长方形，注意如果两个点的x,y有一个相同要特殊处理。

然后对于每一个长方形计算面积以及状态(覆盖了哪些点，用2进制表示) 

接下来就是dp的计算了。

dp[i][j]表示选到第i个长方形是状态为j的最小面积。转移就是分第i个选还是不选，跟01背包是一样的。

dp[i][j]=min(dp[i-1][j],dp[i-1][j&(~r[i].state)]+r[i].s);

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include<cmath>
#include<vector>
#define maxn 15
#define maxm (15*15)/2
#define mod 1000000000000000000
#define INF 0x3f3f3f3f
using namespace std;
struct point{
    int x,y;
}a[maxn];
int n;
int dp[maxm][1<<maxn+1];
struct rect{
    int x1,y1,x2,y2;
    int s,state;
}r[maxm];
int cnt;
bool in(rect a,point b){
    int minx = min(a.x1,a.x2);
    int maxx = max(a.x1,a.x2);
    int miny = min(a.y1,a.y2);
    int maxy = max(a.y1,a.y2);
    if(b.x>=minx&&b.x<=maxx&&b.y>=miny&&b.y<=maxy)return true;
    else return false;
}
void init(){
    cnt=1;
    for(int i=0;i<n;++i){
        for(int j=i+1;j<n;++j){
            if(i==j)continue;
            //if(a[i].x==a[j].x||a[i].y==a[j].y)continue;
            r[cnt].x1=a[i].x;r[cnt].y1=a[i].y;
            r[cnt].x2=a[j].x;r[cnt].y2=a[j].y;
            if(a[i].x==a[j].x)r[cnt].s=abs(a[i].y-a[j].y);
            else if(a[i].y==a[j].y)r[cnt].s = abs(a[i].x-a[j].x);
            else r[cnt].s = abs(a[i].x-a[j].x)*abs(a[i].y-a[j].y);
            cnt++;
        }
    }
    for(int i=1;i<cnt;++i){
        r[i].state=0;
        for(int j=0;j<n;++j){
            if(in(r[i],a[j]))r[i].state|=(1<<j);
        }
    }
}
int main (){
    while(scanf("%d",&n)!=EOF){
        if(n==0)break;
        for(int i=0;i<n;++i)scanf("%d%d",&a[i].x,&a[i].y);
        init();
        for(int i=0;i<cnt;++i){
            for(int j=0;j<(1<<n);++j)dp[i][j]=INF;
            dp[i][0]=0;
        }
        for(int i=1;i<cnt;++i){
            for(int j=0;j<(1<<n);++j){
                dp[i][j]=min(dp[i-1][j],dp[i-1][j&(~r[i].state)]+r[i].s);
            }
        }
        int ans=dp[cnt-1][(1<<n)-1];
        printf("%d\n",ans);
    }
}

3411

题目大意：

有n个点，m个边的有向图，有重边。对于每一条边ai到bi点有两种收费方式，一种是如果到过ci点就收费pi否则收费ri,问从1到N的最短花费

其实是个图论+dp，dp[i][j]表示当前在i点，之前走过的点的集合状态为j的最小花费。

那么对于每个dp[i][j]去更新其他的状态，两种收费方式，类似于最短路里面的松弛过程。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include<cmath>
#include<vector>
#define maxn 15
#define maxm 15
#define mod 1000000000000000000
#define INF 0x3f3f3f3f
using namespace std;
int dp[maxn][(1<<maxn)+1];
bool inq[maxn][(1<<maxn)+1];
struct node{
    int b,c,p,r;
    node(){}
    node(int _b,int _c,int _p,int _r){
        b=_b;c=_c;p=_p;r=_r;
    }
};
vector<node>G[maxn];
int n,m;
void init(){
    memset(inq,false,sizeof(inq));
    for(int i=0;i<maxn;++i){
        for(int j=0;j<(1<<maxn);++j){
            dp[i][j]=INF;
        }
    }
}
void solve(){
    init();
    queue<int>q1,q2;
    dp[0][1]=0;
    inq[0][1]=true;
    q1.push(0),q2.push(1);
    while(!q1.empty()){
        int u = q1.front();q1.pop();
        int s = q2.front();q2.pop();
        inq[u][s]=false;
        for(int i=0;i<G[u].size();++i){
            int v = G[u][i].b,c = G[u][i].c,p = G[u][i].p,r=G[u][i].r;
            if(s&(1<<c)){
                if(dp[u][s]+p<dp[v][s|(1<<v)]){
                    dp[v][s|(1<<v)]=dp[u][s]+p;
                    if(!inq[v][s|(1<<v)]){
                        q1.push(v);
                        q2.push(s|(1<<v));
                        inq[v][s|(1<<v)]=true;
                    }
                }
            }
            else {
                if(dp[u][s]+r<dp[v][s|(1<<v)]){
                    dp[v][s|(1<<v)]=dp[u][s]+r;
                    if(!inq[v][s|(1<<v)]){
                        q1.push(v);
                        q2.push(s|(1<<v));
                        inq[v][s|(1<<v)]=true;
                    }
                }
            }
        }
    }
    int ans = INF;
    for(int i=0;i<(1<<n);++i){
        if((i&1)&&(i&(1<<(n-1))))ans = min(ans,dp[n-1][i]);
    }
    if(ans==INF)printf("impossible\n");
    else printf("%d\n",ans);
}
int main (){
    while(scanf("%d%d",&n,&m)!=EOF){
        for(int i=0;i<maxn;++i)G[i].clear();
        for(int i=0;i<m;++i){
            int a,b,c,p,r;
            scanf("%d%d%d%d%d",&a,&b,&c,&p,&r);
            a--;b--;c--;
            G[a].push_back(node(b,c,p,r));
        }
        solve();
    }
}