hdu 状态压缩dp小集（中低难度）

源自----------------------------------------------------Ice_Crazy

hdu1074

状态压缩dp入门题，关键是输出顺序。

#include"stdio.h"
#include"string.h"
#include"stdlib.h"

int n,base[20];
struct node
{
    char name[111];
    int dead,cost;
}MEM[20];
struct node1
{
    int days,score;
    int pre,now;
}DP[1<<15];

int main()
{
    int T;
    int i,l;
    int tot,t,reduce;
    for(i=0;i<15;i++)    base[i]=1<<i;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(i=0;i<n;i++)    scanf("%s%d%d",MEM[i].name,&MEM[i].dead,&MEM[i].cost);

        memset(DP,127,sizeof(DP));
        DP[0].days=0;
        DP[0].score=0;
        DP[0].pre=-1;
        tot=1<<n;
        for(i=0;i<tot;i++)
        {
            for(l=n-1;l>=0;l--)        //从大到小，并且在后面的第七行用了“<”：保证顺序
            {
                if(i & base[l])
                {
                    t=i-base[l];
                    reduce=DP[t].days+MEM[l].cost-MEM[l].dead;
                    if(reduce<0)    reduce=0;
                    if(DP[t].score+reduce<DP[i].score)
                    {
                        DP[i].pre=t;
                        DP[i].now=l;
                        DP[i].days=DP[t].days+MEM[l].cost;
                        DP[i].score=DP[t].score+reduce;
                    }
                }
            }
        }

        int K=0,temp=(1<<n)-1;
        char ans[20][111];
        while(DP[temp].pre!=-1)
        {
            strcpy(ans[K++],MEM[DP[temp].now].name);
            temp=DP[temp].pre;
        }
        printf("%d\n",DP[(1<<n)-1].score);
        for(i=K-1;i>=0;i--)    printf("%s\n",ans[i]);
    }
    return 0;
}

hdu3182

状态压缩dp水题。

hdu4568

最短路+状态压缩dp、不难，两部分都较果。

hdu4336

概率dp+状态压缩 求期望。

没啥难的、主要是关于期望的运算。。期望。。高中的数学知识

啊、我推了半张演草纸才想起来啊。。。

#include"iostream"  
#include"cstdio"  
#include"cstring"  
using namespace std;  
const int N=1<<20;  
  
int n,base[20];  
double p[20],dp
;  
int main()  
{  
    int i,l;  
    int limit;  
    double t,sum;  
    for(i=0;i<20;i++)    base[i]=1<<i;  
    while(scanf("%d",&n)!=-1)  
    {  
        for(i=0;i<n;i++) scanf("%lf",&p[i]);  
        limit=1<<n;  
        dp[0]=0;  
        for(i=1;i<limit;i++)  
        {  
            t=sum=0;  
            for(l=0;l<n;l++)  
            {  
                if(!(i & base[l]))  continue;  
                t+=p[l]*dp[i-base[l]];  
                sum+=p[l];  
            }  
            dp[i]=(t+1)/sum;  
        }  
        printf("%.5lf\n",dp[(1<<n)-1]);  
    }  
    return 0;  
}

hdu1565

很果的二进制dp。

不过这题的数据小，所以可以这样暴力，好的方法是网络流，

可以做下hdu1569。

hdu2167

果果的状态压缩dp。

可以先做一下hdu1565，那个比这个更果。。

这个题的话可以先算一下，15位的格子只有1597个可用来

递推的状态，所以，尽情的暴力吧~！= =II。

hdu4539

很水的状态压缩dp，数据也不强，4层for循环写的pl的可以迅速过之，当然不pl也能过= =。

hdu3001

三进制dp，思路同二进制。

#include"iostream"
#include"cstdio"
#include"cstring"
using namespace std;
const int N=60000;
const int M=1000;
const int inf=123456789;

int n,m,map[20][20],dp
[10],sp
[10],base[10];
struct Edge{
    int v,len,next;
}edge[M];
int tot,head[10];
void add(int a,int b,int c){
    edge[tot].v=b;edge[tot].len=c;edge[tot].next=head[a];head[a]=tot++;
}

void init()
{
    int i,k,temp,limit;
    base[0]=1;
    for(i=1;i<10;i++)    base[i]=base[i-1]*3;
    limit=base[9]*3;
    memset(sp,0,sizeof(sp));
    for(i=0;i<limit;i++)
    {
        k=0;temp=i;
        while(temp)    {sp[i][k++]=temp%3;temp/=3;}
    }
}
void build_map()
{
    int i,l;
    int a,b,c;
    for(i=1;i<=n;i++)
    {
        for(l=1;l<=n;l++)    map[i][l]=inf;
        map[i][i]=0;
    }
    while(m--)
    {
        scanf("%d%d%d",&a,&b,&c);
        map[a][b]=map[b][a]=map[a][b]>c?c:map[a][b];
    }
    tot=0;
    memset(head,-1,sizeof(head));
    for(i=1;i<=n;i++)
    for(l=1;l<=n;l++)
    {
        if(i==l || map[i][l]==inf)    continue;
        add(i-1,l-1,map[i][l]);
    }
}
int DP()
{
    int i,l,j,v;
    int t,next,flag,limit,ans;
    limit=1;
    for(i=0;i<n;i++)    limit*=3;
    for(i=0;i<limit;i++)
    for(l=0;l<n;l++)
        dp[i][l]=inf;
    t=1;
    for(i=0;i<n;i++)    {dp[t][i]=0;t*=3;}

    ans=inf;
    for(i=0;i<limit;i++)
    {
        flag=1;
        for(l=0;l<n;l++)
        {
            if(!sp[i][l])    {flag=0;continue;}
            if(dp[i][l]==inf)    continue;
            for(j=head[l];j!=-1;j=edge[j].next)
            {
                v=edge[j].v;
                if(sp[i][v]>=2)    continue;
                next=i+base[v];
                if(dp[i][l]+edge[j].len<dp[next][v])
                    dp[next][v]=dp[i][l]+edge[j].len;
            }
        }
        if(!flag)    continue;
        for(l=0;l<n;l++)if(dp[i][l]<ans)ans=dp[i][l];
    }
    if(ans==inf)    ans=-1;
    return ans;
}
int main()
{
    init();
    while(scanf("%d%d",&n,&m)!=-1)
    {
        build_map();
        printf("%d\n",DP());
    }
    return 0;
}