C++博客-寒月-随笔分类-动态规划

pku1609【二维最长上升子序列】

wuxu — Tue, 07 Sep 2010 13:08:00 GMT

题目链接：http://acm.pku.edu.cn/JudgeOnline/problem?id=1609
方法一：转化为求一维最长上升子序列。O(nlogn)

#include<iostream>
#include<algorithm>
using namespace std;
int b[10005];
int n;
typedef struct node
{
    int l,m;
    bool operator<(node t)
    {
         if(l<t.l) return 1;
         else if(l==t.l&&m<t.m) return 1;
         else return 0;
    }
}block;
block a[10005];
int LIS()
{
    int L=0;
    for(int i=1;i<=n;i++)
    {
         int ll=1,rr=L;
         while(ll<=rr)
         {
            int mid=(ll+rr)/2;
            if(b[mid]<=a[i].m) ll=mid+1;
            else rr=mid-1;
         }
         b[ll]=a[i].m;
         if(ll>L) L++;
    }
    return L;
}
int main()
{
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(int i=1;i<=n;i++)
        scanf("%d%d",&a[i].l,&a[i].m);
        sort(a+1,a+n+1);
        printf("%d\n",LIS());
    }
    printf("*\n");
    return 0;
}

方法二：状态转移方程为：f[i][j]=max{f[i-1][j],f[i][j-1]}+a[i][j].

#include<iostream>
using namespace std;
#define max(x,y) (x>y?x:y)
int a[105][105],f[105][105];

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF&&n)
    {
        int i,j,k,s;
        memset(a,0,sizeof(a));
        memset(f,-1,sizeof(f));
        f[0][0]=0;
        f[0][1]=0;
        f[1][0]=0;
        int xx=0,yy=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&k,&s);
            if(xx<k) xx=k;
            if(yy<s) yy=s;
            a[k][s]++;
        }
        for(i=1;i<=xx;i++)
            for(j=1;j<=yy;j++)
            {
                if(f[i-1][j]!=-1)
                    f[i][j]=max(f[i][j],f[i-1][j]+a[i][j]);
                if(f[i][j-1]!=-1)
                    f[i][j]=max(f[i][j],f[i][j-1]+a[i][j]);
            }
       int ans=0;
       for(i=1;i<=xx;i++)
           for(j=1;j<=yy;j++)
               if(ans<f[i][j]) ans=f[i][j];
       printf("%d\n",ans);
    }
    printf("*\n");
    return 0;
}

wuxu 2010-09-07 21:08 发表评论

pku1887【最长下降子序列】

wuxu — Mon, 06 Sep 2010 12:05:00 GMT

O(n^2)代码：

#include<iostream>
using namespace std;
int h[40000],d[40000];
int main()
{
    int test=0;
    while(1)
    {
        int i,j,k;
        test++;
        scanf("%d",&h[1]);
        if(h[1]==-1) break;
        k=1;
        while(scanf("%d",&j)!=EOF&&j!=-1)
        {
             h[++k]=j;
        }
        h[0]=40000;
        memset(d,0,sizeof(d));
        for(i=1;i<=k;i++)
        for(j=0;j<i;j++)
        if(h[j]>h[i]&&d[j]+1>d[i])
        d[i]=d[j]+1;

        int ans=0;
        for(i=1;i<=k;i++)
        if(d[i]>ans) ans=d[i];
        if(test!=1) printf("\n");
        printf("Test #%d:\n",test);
        printf("  maximum possible interceptions: %d\n",ans);
    }
    //system("pause");
    return 0;
}

O(nlogn)代码：

/*============================*\
  最长下降子序列 O(nlogn)
\*============================*/
#include<iostream>
using namespace std;
const int inf=1000000;
int a[30000],b[30000];//b[i]表示长度为i的下降序列中，末尾数最大的那个序列的代表。
int n;

int lds()
{
    int ans=0;
    b[0]=inf;
    for(int i=1;i<=n;i++)
    {
        int l=1,r=ans;
        while(l<=r)       //找l最小的b[l],使b[l]<=a[i].
        {
            int t=(l+r)/2;
            if(b[t]>a[i]) l=t+1;
            else r=t-1;
        }
        b[l]=a[i];
        if(l>ans) ans++;
    }
    return ans;
}

int main()
{
    int test=0;
    while(scanf("%d",&a[1])!=EOF&&a[1]!=-1)
    {
        int i,t;
        n=1;
        test++;
        while(scanf("%d",&t)!=EOF&&t!=-1)
        a[++n]=t;
        if(test!=1) printf("\n");
        printf("Test #%d:\n",test);
        printf("  maximum possible interceptions: %d\n",lds());
    }
    //system("pause");
    return 0;
}

wuxu 2010-09-06 20:05 发表评论

zoj3399(DP+单调队列优化)

wuxu — Sat, 04 Sep 2010 14:40:00 GMT

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4007
很好的一道题目，用f[i,j]表示前i个学生分为j个班时的最小unhappy值，状态转移方程为：f[i,j]=min{f[k,j-1],+(sum[i]-sum[k])*g[j]}.其中a<=i-k<=b,sum[i] = sigma {(x[s] -L)^2 | s≤ i}.
但现在的时间复杂度为O(k*n^2)，显然会TLE。将转移方程整理一下：f[i,j]=sum[i]*g[j]+min{f[k,j-1]-sum[k]*g[j]}. 显然可维护一个单调递增队列，每次转移之前将新的可选状态从队列尾插入，同时保证队列头的元素在可选范围之内。这样每次转移就可以只取队列头的元素，总的时间复杂度为O(n*k).

#include<iostream>
using namespace std;
const long long inf=100000000000000ll;
long long sum[10005],aver;
long long f[10005][205];
int x[10005],g[205];
int n,m,a,b;
typedef struct
{
   long long unhap;
   int loc;
}node;
node q[10005];

int main()
{
    int test=0;
    while(scanf("%d%d%d%d",&n,&m,&a,&b)!=EOF)
    {
         test++;
         aver=0;
         int i,j;
         for(i=1;i<=n;i++)
         {
              scanf("%d",&x[i]);
              aver+=x[i];
         }
         aver/=n;
         for(i=1;i<=m;i++)
         scanf("%d",&g[i]);
         sum[0]=0;
         for(i=1;i<=n;i++)
         sum[i]=sum[i-1]+(x[i]-aver)*(x[i]-aver);
         for(i=0;i<=n;i++)
         for(j=0;j<=m;j++)
         f[i][j]=inf;
         f[0][0]=0;
         long long ans_unhap=inf;
         int ans_k=m+1,ans_t=n+1;
         for(j=1;j<=m;j++)
         {
              int head=0,tail=0;
              for(i=a;i<=n;i++)
              {
                   node temp;
                   if(f[i-a][j-1]!=inf)
                   {
                        temp.unhap=f[i-a][j-1]-sum[i-a]*g[j];
                        temp.loc=i-a;
                        while(head<tail&&q[tail-1].unhap>=temp.unhap) tail--;  //用>=是为了保证最后一个班的学生在多解的情况下人数最少。
                        q[tail].unhap=temp.unhap;
                        q[tail++].loc=temp.loc;
                   }
                   while(head<tail&&q[head].loc<i-b) head++;
                   if(head<tail) f[i][j]=q[head].unhap+sum[i]*g[j];
              }
              if(f[n][j]!=inf)  //求多解情况下的最小分班数。
              {
                   if(ans_unhap>f[n][j])
                   {
                        ans_unhap=f[n][j];
                        ans_k=j;
                        ans_t=n-q[head].loc;
                   }
              }
         }
         if(test!=1) printf("\n");
         if(ans_unhap==inf) printf("No solution.\n");
         else printf("%lld %d %d",ans_unhap,ans_k,ans_t);
    }
    return 0;
}

wuxu 2010-09-04 22:40 发表评论

hdu3127

wuxu — Sun, 29 Aug 2010 02:38:00 GMT

简单DP 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3127

状态转移方程：f[i,j]=max{f[i,j],f[i-a,j]+f[a,j-b]+p,f[i,j-b]+f[i-a,b]+p}
f[i,j]=max{f[i,j],f[i-b,j]+f[b,j-a]+p,f[i,j-a]+f[i-b,a]+p}

#include<iostream>
#include<algorithm>
#define max(a,b) (a>b?a:b)
using namespace std;
int test,n,x,y;
int f[1005][1005];
typedef struct
{
   int len,wth,val;
}CLOTH;
CLOTH c[15];
int main()
{
    scanf("%d",&test);
    while(test--)
    {
         scanf("%d%d%d",&n,&x,&y);
         for(int i=0;i<n;i++)
         scanf("%d%d%d",&c[i].len,&c[i].wth,&c[i].val);
         memset(f,0,sizeof(f));
         for(int i=1;i<=x;i++)
         for(int j=1;j<=y;j++)
         {
              for(int k=0;k<n;k++)
              {
                  int a=c[k].len;
                  int b=c[k].wth;
                  if(i>=a&&j>=b)
                  {
                       f[i][j]=max(f[i][j],f[i-a][j]+f[a][j-b]+c[k].val);
                       f[i][j]=max(f[i][j],f[i][j-b]+f[i-a][b]+c[k].val);
                  }
                  swap(a,b);
                  if(i>=a&&j>=b)
                  {
                       f[i][j]=max(f[i][j],f[i-a][j]+f[a][j-b]+c[k].val);
                       f[i][j]=max(f[i][j],f[i][j-b]+f[i-a][b]+c[k].val);
                  }
              }
         }
         printf("%d\n",f[x][y]);
    }
    //system("pause");
    return 0;
}

wuxu 2010-08-29 10:38 发表评论

pku3264(ST算法求解RMQ问题)

wuxu — Sat, 28 Aug 2010 05:29:00 GMT

RMQ(Range Minimum/Maximum Query)问题是求区间最值问题，用ST算法，可以做到O(nlogn)的预处理，O(1)地回答每个询问。
以求最大值为例，设f[i,j]表示以i为起点，长度为2^j这个区间中的最大值，即[i,i+2^j-1]这个区间内的最大值，那么在询问[a,b]区间的最大值时答案就是max(f[a,k], f[b-2^k+1,k]),其中k是满足2^k<=b-a的最大的k，即k=ln(b-a+1)/ln(2);另外,这两个区间必须覆盖[a,b].
f的求法可以用动态规划，f[i,j]=max(f[i,j-1],f[i+2^(j-1),j-1]).

题目链接：http://acm.pku.edu.cn/JudgeOnline/problem?id=3264

#include<iostream>
#include<cmath>
#define max(a,b) (a>b?a:b)
#define min(a,b) (a
using namespace std;
int n,q,a,b;
int h[50005];
int maxn[50005][16];
int minn[50005][16];
void st_init()
{
     for(int i=1;i<=n;i++)
     maxn[i][0]=minn[i][0]=h[i];
     int m=int(log(double(n))/log(2.0));
     for(int i=1;i<=m;i++)
     for(int j=1;j<=n;j++)
     {
          maxn[j][i]=maxn[j][i-1];
          if(j+(1<<(i-1))<=n)
          maxn[j][i]=max(maxn[j][i],maxn[j+(1<<(i-1))][i-1]);
     }

     for(int i=1;i<=m;i++)
     for(int j=1;j<=n;j++)
     {
          minn[j][i]=minn[j][i-1];
          if(j+(1<<(i-1))<=n)
          minn[j][i]=min(minn[j][i],minn[j+(1<<(i-1))][i-1]);
     }
}
int st_search(int l,int r)
{
    int m=int(log(double(r-l+1))/log(2.0));
    int mx=max(maxn[l][m],maxn[r-(1<<m)+1][m]);
    int mn=min(minn[l][m],minn[r-(1<<m)+1][m]);
    return mx-mn;
}
int main()
{
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++)
    scanf("%d",&h[i]);
    st_init();
    for(int i=1;i<=q;i++)
    {
        scanf("%d%d",&a,&b);
        printf("%d\n",st_search(a,b));
    }
    //system("pause");
    return 0;
}

wuxu 2010-08-28 13:29 发表评论

hdu3401(DP+单调队列优化)

wuxu — Fri, 27 Aug 2010 10:38:00 GMT

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3401
用f[i][j]表示第i天股票数为j的最大收益，f[i][j]可以从以下三个地方得到：
1、在上次交易的基础上再买一些: f[i][j]=max{f[i][j],f[r][k]-(j-k)*b_price[i]} 02、在上次交易的基础上卖出一些: f[i][j]=max{f[i][j],f[r][k]+(k-j)*s_price[i]} 03、当天股票不动: f[i][j]=max{f[i][j],f[i-1][j]}
这样的时间复杂度为O(T^2*MaxP^2)，需要做一些优化.
对于买股票的时候，f[r][k]-(j-k)*b_price[i]=f[r][k]+k*b_price[i]-j*b_price[i] ,(j>= k>=j-b_num[i]),f[i][j]的最优值由f[r][k]+k*b_price[i]确定，由递推方程可知，f[r][k]始终是股票数为k的最大值. 对于某个j，f[r][k]+k*b_price[i]已经重复求过了，这次只需要求f[r][j]+j*b_price[i]即可,因此可以用单调队列来保存这些信息,并且可以方便的取出最大值。卖股票的情况也同上面类似。此时的时间复杂度为O(T*MaxT).

#include<iostream>
#define max(a,b) (a>b?a:b)
using namespace std;
const int inf=0x7fffffff;
int test,t,maxp,w;
int b_price[2005],s_price[2005];
int b_num[2005],s_num[2005];
int f[2005][2005];
typedef struct node
{
    int mon,num;
}NODE;
NODE q[2005];
int main()
{
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d%d%d",&t,&maxp,&w);
        for(int i=1;i<=t;i++)
        scanf("%d%d%d%d",&b_price[i],&s_price[i],&b_num[i],&s_num[i]);
        for(int i=0;i<=t;i++)
        for(int j=0;j<=maxp;j++)
        f[i][j]=-inf;
        for(int i=1;i<=w+1;i++)
        for(int j=0;j<=maxp&&j<=b_num[i];j++)
        f[i][j]=-j*b_price[i];
        for(int i=2;i<=w+1;i++)
        for(int j=0;j<=maxp;j++)
        f[i][j]=max(f[i-1][j],f[i][j]);

        for(int i=w+2;i<=t;i++)
        {
            int head=0,tail=0;
            for(int j=0;j<=maxp;j++)
            {
                 f[i][j]=max(f[i][j],f[i-1][j]);
                 int pre=i-w-1;
                 int money=f[pre][j]+j*b_price[i];
                 while(head<tail&&q[tail-1].mon<money) tail--;
                 q[tail].mon=money;
                 q[tail++].num=j;
                 while(head<tail&&j-q[head].num>b_num[i]) head++;
                 f[i][j]=max(f[i][j],q[head].mon-j*b_price[i]);
            }
            head=tail=0;
            for(int j=maxp;j>=0;j--)
            {
                 int pre=i-w-1;
                 int money=f[pre][j]+j*s_price[i];
                 while(head<tail&&q[tail-1].mon<money) tail--;
                 q[tail].mon=money;
                 q[tail++].num=j;
                 while(head<tail&&q[head].num-j>s_num[i]) head++;
                 f[i][j]=max(f[i][j],q[head].mon-j*s_price[i]);
            }
        }
        int ans=-inf;
        for(int i=0;i<=maxp;i++)
        if(f[t][i]>ans) ans=f[t][i];
        printf("%d\n",ans);
    }
    //system("pause");
    return 0;
}

wuxu 2010-08-27 18:38 发表评论

pku1179

wuxu — Mon, 23 Aug 2010 10:36:00 GMT

经典DP. 题目来源：http://acm.pku.edu.cn/JudgeOnline/problem?id=1179
枚举第一次拿走的边，f[i][j][0]记录i到j的最小值，f[i][j][1]记录最大值，然后递推计算。记录最小值是因为两个负数相乘可能得到一个大的正数。见代码：

#include<iostream>
#include<algorithm>
using namespace std;
const int inf=100000000;
int n,max_score,tot,fir_mov[55];
int f[55][55][2],val[55];
char sign[55][55];
void fun(int a[4],int &tmax,int &tmin)
{
    sort(a,a+4);
    if(a[0]<tmin) tmin=a[0];
    if(a[3]>tmax) tmax=a[3];
}
int main()
{
    scanf("%d",&n);
    int i,j,k,s;
    for(i=0;i<n;i++)
    {
        getchar();
        scanf("%c%d",&sign[(i-1+n)%n][i],&val[i]);
    }
    int max_score=-inf;
    tot=0;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        for(k=0;k<n;k++)
        {
            f[j][k][0]=inf;  //min
            f[j][k][1]=-inf;  //max
        }
        for(j=0;j<n;j++)
        {
            f[j][j][0]=val[j];
            f[j][j][1]=val[j];
        }
        int start=i,end=(i-1+n)%n;
        for(j=1;j<=n-1;j++)
        for(k=start;(k+j)%n!=(end+1)%n;k=(k+1)%n)
        {
            int v=(k+j)%n;
            int tmax=-inf,tmin=inf;
            for(s=k;s!=v;s=(s+1)%n)
            {
                if(sign[s][(s+1)%n]=='t')
                {
                    if(tmax<f[k][s][1]+f[(s+1)%n][v][1])
                        tmax=f[k][s][1]+f[(s+1)%n][v][1];
                    if(tmin>f[k][s][0]+f[(s+1)%n][v][0])
                        tmin=f[k][s][0]+f[(s+1)%n][v][0];
                }
                else
                {
                    int a[4];
                    a[0]=f[k][s][1]*f[(s+1)%n][v][1];
                    a[1]=f[k][s][0]*f[(s+1)%n][v][0];
                    a[2]=f[k][s][0]*f[(s+1)%n][v][1];
                    a[3]=f[k][s][1]*f[(s+1)%n][v][0];
                    fun(a,tmax,tmin);
                }
            }
            if(f[k][v][0]>tmin) f[k][v][0]=tmin;
            if(f[k][v][1]<tmax) f[k][v][1]=tmax;
        }
        if(max_score==f[start][end][1])
        {
             fir_mov[tot++]=i+1;
        }
        else if(max_score<f[start][end][1])
        {
             tot=0;
             max_score=f[start][end][1];
             fir_mov[tot++]=i+1;
        }
    }
    printf("%d\n",max_score);
    for(i=0;i<tot;i++)
    if(i!=tot-1) printf("%d ",fir_mov[i]);
    else printf("%d\n",fir_mov[i]);
    //system("pause");
    return 0;
}

wuxu 2010-08-23 18:36 发表评论

hdu3237(压缩DP)

wuxu — Mon, 23 Aug 2010 02:56:00 GMT

题目来源：http://acm.hdu.edu.cn/showproblem.php?pid=3237
用f[i,j,k,s]表示从前i本书中取出j本，没被取出书的状态为k(k不仅要表示书存在的种类，还要具体表示哪类书存在)，没被取出书的最后一本高度为s时，剩下书的最小mess值。由于书按高度分类共有8类，可以用八位二进制来表示剩余书的状态，如果对应位为1则表明该类书存在。各类书存在与否，状态众多，这里可以进行状态压缩。不考虑被拿出来的书的原因是，我们可以把这些书放到最恰当的位置，对前面求最优值不会产生影响。现在由前i-1本书推后面：对于第i本书，若要取f[i,j+1,k,s]=min{f[i,j+1,k,s],f[i-1,j,k,s]}；若不取分两种情况：第i本书的高度与前面相同时，f[i,j,k,s]=min{f[i,j,k,s],f[i-1,j,k,s]};第i本书的高度与前面不同时，f[i,j,k|(1<

#include<iostream>
#define min(a,b) (a
using namespace std;
const int inf=10000000;
int n,m,begin;
int h[105],num[1<<8];
int f[2][105][1<<8][9];
void Init()
{
     int i,j;
     memset(num,0,sizeof(num));
     for(i=0;i<(1<<8);i++)
     {
         for(j=0;j<8;j++)
         if(i&(1<<j)) num[i]++;
     }
}
int main()
{
    int test=1;
    Init();
    while(scanf("%d%d",&n,&m)!=EOF&&(n||m))
    {
         int i,j,k,s;
         begin=0;
         for(i=1;i<=n;i++)
         {
             scanf("%d",&h[i]);
             h[i]-=25;
             begin=begin|(1<<h[i]);
         }
         for(i=0;i<=m;i++)
         for(j=0;j<(1<<8);j++)
         for(k=0;k<=8;k++)
         f[0][i][j][k]=inf;

         f[0][0][0][8]=0;

         for(i=1;i<=n;i++)
         {
              for(j=0;j<=m;j++)
              for(k=0;k<(1<<8);k++)
              for(s=0;s<=8;s++)
              f[i&1][j][k][s]=inf;

              for(j=0;j<=i-1&&j<=m;j++)
              for(k=0;k<(1<<8);k++)
              for(s=0;s<=8;s++)
              if(f[(i-1)&1][j][k][s]!=inf)
              {
                   if(j<m)f[i&1][j+1][k][s]=min(f[i&1][j+1][k][s],f[(i-1)&1][j][k][s]);

                   if(h[i]==s) f[i&1][j][k][s]=min(f[i&1][j][k][s],f[(i-1)&1][j][k][s]);
                   else f[i&1][j][k|(1<<h[i])][h[i]]=min(f[i&1][j][k|(1<<h[i])][h[i]],f[(i-1)&1][j][k][s]+1);
              }
         }
         int ans=inf;
         for(i=0;i<=m;i++)
         for(j=0;j<(1<<8);j++)
         for(k=0;k<8;k++)
         if(f[n&1][i][j][k]!=inf)
         {
              int temp=j^begin;
              if(ans>f[n&1][i][j][k]+num[temp])
              ans=f[n&1][i][j][k]+num[temp];
         }
         printf("Case %d: %d\n\n",test++,ans);
    }
    //system("pause");
    return 0;
}

wuxu 2010-08-23 10:56 发表评论

hdu3236

wuxu — Sun, 22 Aug 2010 03:08:00 GMT

背包.        题目来源：http://acm.hdu.edu.cn/showproblem.php?pid=3236
初看题目可以知道这是个背包问题，但物品分为普通和特殊两种，并且要求特殊的全部得到。如果只有这两个限制，可以做两次二维背包，先做特殊物品背包，然后把不满足题目要求的状态删掉(同时可以判断能否满足女友的要求)，再做普通物品背包。但是，题目又多了个特殊情况，就是可以免费赠送一个物品，那么可以通过加维来处理。用f[i][j][s]表示得到的最大happy值，其中i表示第一张购物卷，j表示第二张购物卷，s==0表示未赠送，s==1表示已赠送。
普通物品：f[i][j][s]=max{f[i][j][s],f[i-price[k]][j][s]+hap[k],f[i][j-price[k]][s]+hap[k]} (s=0,1)
           另外当s==1时还有一种情况，f[i][j][1]=max{f[i][j][1],f[i][j][0]+hap[k]}
特殊物品：f[i][j][0]=max{f[i-price[k]][j][0]+hap[k],f[i][j-price[k]][0]+hap[k]}
             f[i][j][1]=max{f[i-price[k]][j][1]+hap[k],f[i][j-price[k]][1]+hap[k],f[i][j][0]+hap[k]}
详细见代码：

#include<iostream>
using namespace std;
int v1,v2,n;
int price[305],hap[305],spec[305];
int f[505][55][2];
int main()
{
    int test=1;
    while(scanf("%d%d%d",&v1,&v2,&n)!=EOF&&(v1||v2||n))
    {
        int i,j,k,s,total_spec=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d%d%d",&price[i],&hap[i],&spec[i]);
            if(spec[i])  total_spec+=hap[i];
        }

        memset(f,-1,sizeof(f));
        f[0][0][0]=0;

        for(k=1;k<=n;k++)
        {
            if(!spec[k]) continue;
            for(i=v1;i>=0;i--)
            for(j=v2;j>=0;j--)
            {
                f[i][j][1]=-1;
                if(f[i][j][0]!=-1&&f[i][j][1]<f[i][j][0]+hap[k])
                f[i][j][1]=f[i][j][0]+hap[k];
                if(i-price[k]>=0&&f[i-price[k]][j][1]!=-1&&f[i][j][1]<f[i-price[k]][j][1]+hap[k])
                f[i][j][1]=f[i-price[k]][j][1]+hap[k];
                if(j-price[k]>=0&&f[i][j-price[k]][1]!=-1&&f[i][j][1]<f[i][j-price[k]][1]+hap[k])
                f[i][j][1]=f[i][j-price[k]][1]+hap[k];

                f[i][j][0]=-1;
                if(i-price[k]>=0&&f[i-price[k]][j][0]!=-1&&f[i][j][0]<f[i-price[k]][j][0]+hap[k])
                f[i][j][0]=f[i-price[k]][j][0]+hap[k];
                if(j-price[k]>=0&&f[i][j-price[k]][0]!=-1&&f[i][j][0]<f[i][j-price[k]][0]+hap[k])
                f[i][j][0]=f[i][j-price[k]][0]+hap[k];
            }
        }
        bool flag=false;
        for(i=0;i<=v1;i++)
        for(j=0;j<=v2;j++)
        for(s=0;s<2;s++)
        {
             if(f[i][j][s]==total_spec)
             flag=true;
             else f[i][j][s]=-1;
        }
        if(!flag)
        {
             printf("Case %d: -1\n\n",test++);
             continue;
        }

        for(k=1;k<=n;k++)
        {
            if(spec[k]) continue;
            for(i=v1;i>=0;i--)
            for(j=v2;j>=0;j--)
            {
                if(f[i][j][0]!=-1&&f[i][j][1]<f[i][j][0]+hap[k])
                f[i][j][1]=f[i][j][0]+hap[k];
                for(s=0;s<2;s++)
                {
                     if(i-price[k]>=0&&f[i-price[k]][j][s]!=-1&&f[i][j][s]<f[i-price[k]][j][s]+hap[k])
                     f[i][j][s]=f[i-price[k]][j][s]+hap[k];
                     if(j-price[k]>=0&&f[i][j-price[k]][s]!=-1&&f[i][j][s]<f[i][j-price[k]][s]+hap[k])
                     f[i][j][s]=f[i][j-price[k]][s]+hap[k];
                }
            }
        }

        int ans=-1;
        for(i=0;i<=v1;i++)
        for(j=0;j<=v2;j++)
        for(s=0;s<2;s++)
        if(ans<f[i][j][s])
        ans=f[i][j][s];
        printf("Case %d: %d\n\n",test++,ans);
    }
    //system("pause");
    return 0;
}

wuxu 2010-08-22 11:08 发表评论

pku1170

wuxu — Fri, 20 Aug 2010 02:05:00 GMT

DP(递归形式). 用f[a0,a1,a2,a3,a4]表示每种商品数量分别为a0,a1,a2,a3,a4时的最小价格.则f[a0,a1,a2,a3,a4]=min{f[a0-b0,a1-b1,a2-b2,a3-b3,a4-b4]+priceb,f[a0-c0,a1-c1,a2-c2,a3-c3,a4-c4]+pricec,......}.bi表示第一种优惠组合中各商品的数量,priceb为对应的优惠价. 以此类推. 此题用记忆化DP较好, 详细见代码:

#include<iostream>
#include<map>
using namespace std;
int B,S,N;
int num[6];
int offer[105][6];
int price[105];
int f[6][6][6][6][6];

int dp(int a0,int a1,int a2,int a3,int a4)
{
    if(f[a0][a1][a2][a3][a4]!=-1)
    return f[a0][a1][a2][a3][a4];
    int i,j,temp=100000000;
    for(i=0;i<B+S;i++)
    {
        if(a0>=offer[i][0]&&a1>=offer[i][1]&&a2>=offer[i][2]&&a3>=offer[i][3]&&a4>=offer[i][4])
        {
             if(temp>dp(a0-offer[i][0],a1-offer[i][1],a2-offer[i][2],a3-offer[i][3],a4-offer[i][4])+price[i])
             temp=dp(a0-offer[i][0],a1-offer[i][1],a2-offer[i][2],a3-offer[i][3],a4-offer[i][4])+price[i];
        }
    }
    f[a0][a1][a2][a3][a4]=temp;
    return temp;
}

int main()
{
    int i,j,c,k,p,s;
    map<int,int> ref;
    memset(num,0,sizeof(num));
    memset(offer,0,sizeof(offer));
    scanf("%d",&B);
    for(i=0;i<B;i++)
    {
        scanf("%d%d%d",&c,&k,&p);
        ref[c]=i;
        num[i]=k;

        price[i]=p;
        offer[i][i]=1;
    }

    scanf("%d",&S);
    for(i=B;i<B+S;i++)
    {
        scanf("%d",&N);
        for(j=0;j<N;j++)
        {
            scanf("%d%d",&c,&k);
            offer[i][ref[c]]=+k;
        }
        scanf("%d",&price[i]);
    }

    memset(f,-1,sizeof(f));
    f[0][0][0][0][0]=0;
    int ans=dp(num[0],num[1],num[2],num[3],num[4]);
    printf("%d\n",ans);
    //system("pause");
    return 0;
}

wuxu 2010-08-20 10:05 发表评论

pku1160

wuxu — Thu, 19 Aug 2010 04:45:00 GMT

DP .首先求出任意两个村庄间(包括端点)建一个邮局后,到邮局的最短距离和,记为min_dis[i][j],当邮局建到中点时min_dis[i][j]最小. 用f[i][j]表示前i个邮局建在前j个村庄.则f[i][j]=min{f[i-1][k]+min_dis[k+1][j]，i-1<=k

#include<iostream>
using namespace std;
int v,p;
int vill[305];
int f[35][305];
int min_dis[305][305];

int main()
{
    int i,j,k;
    scanf("%d%d",&v,&p);
    for(i=1;i<=v;i++)
    scanf("%d",&vill[i]);
    memset(min_dis,0,sizeof(min_dis));
    for(i=1;i<=v;i++)
    for(j=i+1;j<=v;j++)
    {
        int mid=(i+j)/2;
        for(k=i;k<mid;k++)
        {
            min_dis[i][j]+=vill[mid]-vill[k];
        }
        for(k=mid+1;k<=j;k++)
        {
            min_dis[i][j]+=vill[k]-vill[mid];
        }
    }
    for(i=1;i<=v;i++) f[1][i]=min_dis[1][i];
    for(i=2;i<=p;i++)
    for(j=i;j<=v;j++)
    {
        int minn=100000000;
        for(k=i-1;k<=j-1;k++)
        {
            if(f[i-1][k]+min_dis[k+1][j]<minn)
            minn=f[i-1][k]+min_dis[k+1][j];
        }
        f[i][j]=minn;
    }

    printf("%d\n",f[p][v]);
    //system("pause");
    return 0;
}

wuxu 2010-08-19 12:45 发表评论

hdu1158

wuxu — Wed, 18 Aug 2010 13:35:00 GMT

DP. 用f[i][j]表示前i个月末人数为j时的最小开支.则f[i][j]=min{f[i-1][k]+cost(i,j)},其中k表示第i-1个月的人数,cost(i,j)为第i个月的开支.当k<=j时,cost(i,j)=hire*(j-k)+j*salary;当k>j时,cost(i,j)=fire*(k-j)+j*salary.详细见代码:

#include<iostream>
using namespace std;
const int inf=100000000;
int hire,fire,sal;
int mon,men[13];
int f[13][10000];
int main()
{
    while(scanf("%d",&mon)!=EOF&&mon)
    {
        scanf("%d%d%d",&hire,&sal,&fire);
        int i,j,k,MAX_NUM=0;
        for(i=1;i<=mon;i++)
        {
             scanf("%d",&men[i]);
             if(MAX_NUM<men[i]) MAX_NUM=men[i];
        }
        for(i=men[1];i<=MAX_NUM;i++)
            f[1][i]=hire*i+sal*i;
        for(i=2;i<=mon;i++)
            for(j=men[i];j<=MAX_NUM;j++)
            {
                int minn=inf;
                for(k=men[i-1];k<=MAX_NUM;k++)
                {
                    if(k<=j&&minn>f[i-1][k]+hire*(j-k)+j*sal)
                        minn=f[i-1][k]+hire*(j-k)+j*sal;
                    else if(k>j&&minn>f[i-1][k]+fire*(k-j)+j*sal)
                        minn=f[i-1][k]+fire*(k-j)+j*sal;
                }
                f[i][j]=minn;
            }
        int ans=inf;
        for(i=men[mon];i<=MAX_NUM;i++)
            if(f[mon][i]!=0&&f[mon][i]<ans)
                ans=f[mon][i];
        printf("%d\n",ans);
    }
    return 0;
}

wuxu 2010-08-18 21:35 发表评论

hdu3535

wuxu — Wed, 18 Aug 2010 01:58:00 GMT

01背包+互斥背包+条件背包。详细见代码：

#include<iostream>
using namespace std;
int n,t,m,s;
int cost[105],hap[105];
int f[105];

int main()
{
    while(scanf("%d%d",&n,&t)!=EOF)
    {
        int i,j,k;
        memset(f,-1,sizeof(f));
        f[0]=0;
        for(k=1;k<=n;k++)
        {
            scanf("%d%d",&m,&s);
            for(i=0;i<m;i++)
                scanf("%d%d",&cost[i],&hap[i]);
            if(s==0)
            {
                int d[105];
                memset(d,-1,sizeof(d));
                for(i=0;i<m;i++)
                    for(j=t;j>=cost[i];j--)
                    {
                        if(d[j-cost[i]]!=-1&&d[j]<d[j-cost[i]]+hap[i])
                            d[j]=d[j-cost[i]]+hap[i];
                        if(f[j-cost[i]]!=-1&&d[j]<f[j-cost[i]]+hap[i])
                            d[j]=f[j-cost[i]]+hap[i];
                    }
               memcpy(f,d,sizeof(d));
            }
            else if(s==1)
            {
                for(j=t;j>=0;j--)
                {
                    int temp=-1;    //注意:找这m个中的最大值时,应先找到最大值,再更新f[j].不要边比较边更新,如果出现f[j]
                    for(i=0;i<m;i++)
                    {
                        if(j-cost[i]>=0&&f[j-cost[i]]!=-1&&temp<f[j-cost[i]]+hap[i])
                            temp=f[j-cost[i]]+hap[i];
                    }
                    f[j]=f[j]>temp?f[j]:temp;
                }
            }
            else if(s==2)
            {
                for(i=0;i<m;i++)
                    for(j=t;j>=cost[i];j--)
                        if(f[j-cost[i]]!=-1&&f[j]<f[j-cost[i]]+hap[i])
                            f[j]=f[j-cost[i]]+hap[i];
            }
        }
        int ans=-1;
        for(i=0;i<=t;i++)
            if(ans<f[i]) ans=f[i];
            printf("%d\n",ans);
    }
    return 0;
}

wuxu 2010-08-18 09:58 发表评论

pku1185(压缩DP)

wuxu — Sun, 15 Aug 2010 14:08:00 GMT

状态压缩DP（三进制压缩）。
由于第i行的放置受到第i-1和i-2行放置情况的影响。我们用0表示方格(i-1,j)和(i-2,j)未放置炮兵；1表示方格(i-1,j)未放炮兵，方格(i-2,j)已被放上炮兵；2表示方格(i-1,j)被放上了炮兵。那么第i-1行和i-2行的放置情况可以用m位的三进制表示。如果放置情况为0,对应的第i行才可以放炮兵，为1和2都不能放。
f[i][j]表示前i行放置好后,并且放置情况为j时炮兵的最大数量。详细见代码：

#include<iostream>
using namespace std;
int n,m;
int map[105][15];
int f[2][60000];
int b[15],s[15];

void dfs(int i,int j,int cur,int sta,int num)
{
    if(cur>m)
    {
        if(f[i&1][sta]<f[(i-1)&1][j]+num)
            f[i&1][sta]=f[(i-1)&1][j]+num;
        return;
    }

    int t,d;

    if(s[cur]>0) t=s[cur]-1;
    else t=0;
    d=sta+t*b[cur-1];
    dfs(i,j,cur+1,d,num);

    if(map[i][cur]=='P'&&s[cur]==0)
    {
        d=sta+2*b[cur-1];
        if(cur+1<=m)
        {
            if(s[cur+1]>0) t=s[cur+1]-1;
            else t=0;
            d+=t*b[cur];
        }
        if(cur+2<=m)
        {
            if(s[cur+2]>0) t=s[cur+2]-1;
            else t=0;
            d+=t*b[cur+1];
        }
        dfs(i,j,cur+3,d,num+1);
    }
}

int main()
{
    int i,j,k;
    b[0]=1;
    for(i=1;i<=10;i++) b[i]=b[i-1]*3;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
         for(i=1;i<=n;i++)
         {
             getchar();
             for(j=1;j<=m;j++)
                 scanf("%c",&map[i][j]);
         }
         memset(f,-1,sizeof(f));
         f[0][0]=0;
         for(i=1;i<=n;i++)
         {
             for(j=0;j<b[m];j++)  f[i&1][j]=-1;
             for(j=0;j<b[m];j++)
             {
                 if(f[(i-1)&1][j]!=-1)
                 {
                     s[0]=1;
                     int v=j;
                     for(k=1;k<=m;k++)
                     {
                         s[k]=v%3;
                         v/=3;
                     }
                     dfs(i,j,1,0,0);
                 }
             }
         }
         int ans=-1;
         for(i=0;i<b[m];i++)
             if(ans<f[n&1][i])  ans=f[n&1][i];
         printf("%d\n",ans);
    }
    return 0;
}

wuxu 2010-08-15 22:08 发表评论

pku1038(压缩DP)

wuxu — Sun, 15 Aug 2010 05:09:00 GMT

经典的压缩DP.

题目描述:
      Bugs公司生产一种2x3单位尺寸的高科技芯片，芯片被嵌入NxM的模板内。模板接受过严格的检查，损坏的单位小方格已被标上黑色记号。
      嵌入芯片的要求是，放置芯片的区域内不能有黑色记号，芯片间不能重叠。求出可能的最大芯片数量。

分析：
       我们从左至右考虑每列的放置。由于芯片长度只有3，所以第j列芯片的放置只受第j-1和j-2列放置情况的影响。同时，如果方格(i,j-1)被黑色标记或其他芯片占据，方格(i,j-2)即使空闲对第j列也没影响。
      这里以0表示方格(i,j-2),(i,j-1)空闲；以1表示方格(i,j-2)被占据,方格(i,j-1)空闲；以2表示方格(i,j-1)被占据。对于每一行有三种可能的状态。所以第j-2和j-1列的放置情况可以用m位的3进制表示。

状态转移方程推导：
      假如我们现在要放置第j列，那么它将受到前两列放置情况的影响。那么我们怎么来表示状态转移呢？
      令f[i][j]前j列放置好后，并且放置情况为i时芯片的最大数量。f[i][j]=max{f[k][j-1]+num}. 由此,第j列的放置可由前j-1列的放置情况来推导。

详细见代码：

#include<iostream>
using namespace std;
int n,m,t;
bool bug[12][155];
int f[60000][2];
int b[12],s[12];

void dfs(int j,int i,int cur,int sta,int num)
{
    int tt,d;
    if(cur>m)
    {
        if(f[sta][j&1]<f[i][(j-1)&1]+num)
            f[sta][j&1]=f[i][(j-1)&1]+num;
        return;
    }
    //当前位置不放芯片.
    if(bug[cur][j])  tt=2;
    else if(s[cur]>0) tt=s[cur]-1;
    else tt=0;
    d=sta+tt*b[cur-1];
    dfs(j,i,cur+1,d,num);
    //横着放芯片.
    if(cur+1<=m&&s[cur]==0&&s[cur+1]==0&&!bug[cur][j]&&!bug[cur+1][j])
    {
        d=sta+2*b[cur-1]+2*b[cur];
        dfs(j,i,cur+2,d,num+1);
    }
    //竖着放芯片.
    if(cur+2<=m&&s[cur]<=1&&s[cur+1]<=1&&s[cur+2]<=1&&!bug[cur][j]&&!bug[cur+1][j]&&!bug[cur+2][j])
    {
        d=sta+2*b[cur-1]+2*b[cur]+2*b[cur+1];
        dfs(j,i,cur+3,d,num+1);
    }
}

int main()
{
    int i,j,k,v;
    b[0]=1;
    for(i=1;i<=10;i++)
        b[i]=b[i-1]*3;
    scanf("%d",&t);
    while(t--)
    {
        int x,y;
        scanf("%d%d%d",&n,&m,&k);
        memset(bug,false,sizeof(bug));
        for(i=0;i<k;i++)
        {
            scanf("%d%d",&x,&y);
            bug[y][x]=true;
        }
        memset(f,-1,sizeof(f));
        f[b[m]-1][0]=0;
        for(j=1;j<=n;j++)
        {
            for(i=0;i<b[m];i++) f[i][j&1]=-1;
            for(i=0;i<b[m];i++)
                if(f[i][(j-1)&1]!=-1)
                {
                    v=i;
                    s[0]=1;
                    for(k=1;k<=m;k++)
                    {
                        s[k]=v%3;
                        v/=3;
                    }
                    dfs(j,i,1,0,0);
                }
        }
        int ans=-1;
        for(i=0;i<b[m];i++)
            if(ans<f[i][n&1]) ans=f[i][n&1];
        printf("%d\n",ans);
    }
    return 0;
}

wuxu 2010-08-15 13:09 发表评论

hdu1565(压缩DP)

wuxu — Thu, 12 Aug 2010 13:08:00 GMT

这到题我是用压缩DP做的，但是要是n再大一些就不能这么做了。每一行取或不取分别用1、0来表示。那么我们可以用二进制来表示每行的状态。状态转移方程为：f[i][j]=max{f[i-1][k]+sum(i,j),k为第i-1行的一个状态，且j&k==0}，sum(i,j)表示第i行满足状态j的数之和。对于每行的状态不能连续出现两个或多个1，因此可以把这种状态舍去。最后用滚动数组。详细见代码：

#include<iostream>
using namespace std;
int n;
int map[21][21];
int dp[2][1<<20+1];
int s[1<<20+1];
int bit[21];

int main()
{
    int i,j,k;
    bit[1]=1;
    for(i=1;i<n;i++) bit[i+1]=1<<i;

    int top=0;
    for(i=0;i<(1<<20);i++)
    {
        for(j=1;j<20;j++)
        {
            if((i&(1<<(j-1)))&&(i&(1<<j)))
                break;
        }
        if(j==20) s[top++]=i;
    }

    while(scanf("%d",&n)!=EOF)
    {
        int ans=0;
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                scanf("%d",&map[i][j]);

        memset(dp,0,sizeof(dp));

        for(i=1;i<=n;i++)
        {
            for(j=0;j<top;j++)
            {
                 int temp=0;
                 if(s[j]>=(1<<n)) break;
                 for(k=1;k<=n;k++)
                 {
                     if(s[j]&(1<<(k-1)))
                         temp+=map[i][k];
                 }
                 int minn=0;
                 for(k=0;k<top;k++)
                 {
                     if(s[k]>=(1<<n)) break;
                     if((s[k]&s[j])==0)
                     {
                         if(minn<dp[(i-1)&1][k])
                             minn=dp[(i-1)&1][k];
                     }
                 }
                 dp[i&1][j]=minn+temp;
                 if(ans<dp[i&1][j]) ans=dp[i&1][j];
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

wuxu 2010-08-12 21:08 发表评论

pku1112

wuxu — Wed, 11 Aug 2010 15:23:00 GMT

摘要: 图论+DP.题目要求：1、把所有的人分成2组，每组至少有1人；2、每组里的人两两认识。3、两个组的成员应尽量接近。我们先构图，如果存在两个人A和B，A不认识B，或B不认识A，那么A和B一定不能分在同一组。因此，我们以人为结点重新构造一个图G。假如A和B不能分在同一组，那么就在G中增加一条无向边(A,B)。然后求极大连通分量... 阅读全文

wuxu 2010-08-11 23:23 发表评论

pku1088

wuxu — Wed, 11 Aug 2010 09:31:00 GMT

DP(递归实现,并保存子问题的解).

#include<iostream>
using namespace std;
int height[105][105];
int dis[105][105];
int dir[4][2]={0,1,0,-1,-1,0,1,0};
int c,r;
int dp(int u,int v)
{
    if(dis[u][v]) return dis[u][v];
    dis[u][v]=1;
    for(int i=0;i<4;i++)
    {
        int x=u+dir[i][0];
        int y=v+dir[i][1];
        if(x>=0&&x<r&&y>=0&&y<c&&height[u][v]>height[x][y])
        {
            if(!dis[x][y]) dp(x,y);
            if(dis[u][v]<dis[x][y]+1)
                dis[u][v]=dis[x][y]+1;
        }
    }
    return dis[u][v];
}
int main()
{
    while(scanf("%d%d",&r,&c)!=EOF)
    {
        int i,j;
        for(i=0;i<r;i++)
            for(j=0;j<c;j++)
                scanf("%d",&height[i][j]);
        memset(dis,0,sizeof(dis));
        for(i=0;i<r;i++)
            for(j=0;j<c;j++)
                dp(i,j);
        int ans=0;
        for(i=0;i<r;i++)
            for(j=0;j<c;j++)
                if(ans<dis[i][j])
                    ans=dis[i][j];
        printf("%d\n",ans);
    }
    return 0;
}

wuxu 2010-08-11 17:31 发表评论

pku1050

wuxu — Wed, 11 Aug 2010 02:19:00 GMT

分别枚举矩形的上下边,把问题转化为求一维的最大子段。

#include<iostream>
using namespace std;
int arr[105][105];
int n,t[105];
const int inf=100000000;

int maxsubr()
{
    int maxn=-inf,sum=0;
    for(int i=1;i<=n;i++)
    {
        if(sum>0)
            sum+=t[i];
        else
            sum=t[i];
        if(maxn<sum)
            maxn=sum;
    }
    return maxn;
}

int main()
{
    int i,j;
    int ans=-inf;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            scanf("%d",&arr[i][j]);
    for(i=1;i<=n;i++)
    {
        memset(t,0,sizeof(t));
        for(j=i;j<=n;j++)
        {
            for(int k=1;k<=n;k++)
            {
                  t[k]+=arr[j][k];
            }
            int temp=maxsubr();
            if(ans<temp) ans=temp;
        }
    }
    printf("%d\n",ans);
    return 0;
}

wuxu 2010-08-11 10:19 发表评论

pku1036

wuxu — Mon, 09 Aug 2010 09:43:00 GMT

做该题的时候,看了网上另外一个版本的递推关系,不过还是朴素一点的比较好理解.状态转移方程为:
f[i,j]=max{f[i-1,j-1],f[i-1,j],f[i-1,j+1]}+w(i,j), 其中f[i,j]表示第i 秒 ,门开放度为j 时的最大加分.w(i,j)表示在该状态下的所有加分.为防止超内存用滚动数组.(由于不仔细把1写成了i,调试了半天,杯具了~~) 详细见代码:

#include<iostream>
#include<algorithm>
using namespace std;

int f[2][102];
int hash[30002];
int N,K,T,ans;

typedef struct
{
    int t,p,s;
}Gant;
Gant s[102];

int cmp(Gant a,Gant b)
{
   if(a.t<b.t) return 1;
   else if(a.t==b.t)
   {
       if(a.s<b.s) return 1;
   }
   return 0;
}

int main()
{
    int i,j,k;
    scanf("%d%d%d",&N,&K,&T);
    for(i=1;i<=N;i++) scanf("%d",&s[i].t);
    for(i=1;i<=N;i++) scanf("%d",&s[i].p);
    for(i=1;i<=N;i++) scanf("%d",&s[i].s);

    memset(hash,0,sizeof(hash));
    memset(f,-1,sizeof(f));

    for(i=1;i<=N;i++) hash[s[i].t]=1;
    sort(s+1,s+N+1,cmp);
    f[0][0]=0;
    ans=0;

    for(i=1;i<=T;i++)
        for(j=0;j<=K;j++)
        {
            int w=0;
            if(hash[i])
            {
                for(k=1;k<=N;k++)
                    if(s[k].t==i&&s[k].s==j)
                        w+=s[k].p;
            }
            if(j>=1&&f[(i-1)&1][j-1]!=-1&&f[i&1][j]<f[(i-1)&1][j-1]+w)
                f[i&1][j]=f[(i-1)&1][j-1]+w;

            if(j+1<=K&&f[(i-1)&1][j+1]!=-1&&f[i&1][j]<f[(i-1)&1][j+1]+w)
                f[i&1][j]=f[(i-1)&1][j+1]+w;

            if(f[(i-1)&1][j]!=-1&&f[i&1][j]<f[(i-1)&1][j]+w)
                f[i&1][j]=f[(i-1)&1][j]+w;

            if(ans<f[i&1][j]) ans=f[i&1][j];
        }
    printf("%d\n",ans);
    return 0;
}

wuxu 2010-08-09 17:43 发表评论

pku1015

wuxu — Sun, 08 Aug 2010 17:16:00 GMT

一道很经典的DP，状态转移方程为：f[i,j,k]=max{f[i-1,j,k],f[i-1,j-1,k-(p[i]-d[i])]+p[i]+d[i]}。其中f[i,j,k]表示在前i个候选人中选择j个人,并且辩控差为k时的最大辩控和。另外用path[i,j,k]来记录路径，表示当前方案下选择的最后一个人。详细见代码：

#include<iostream>
#include<stack>
using namespace std;
int n,m,test;
int p[205],d[205];
int f[205][25][805];
int path[205][25][805];
int main()
{
    test=0;
    while(scanf("%d%d",&n,&m)!=EOF&&(m||n))
    {
        int i,j,k;
        for(i=1;i<=n;i++)
            scanf("%d%d",&p[i],&d[i]);
        int mid=m*20;
        memset(f,-1,sizeof(f));
        memset(path,-1,sizeof(path));
        for(i=0;i<=n;i++) f[i][0][mid]=0;
        for(i=1;i<=n;i++)
            for(j=1;j<=m&&j<=i;j++)
                for(k=0;k<=2*mid;k++)
                {
                    f[i][j][k]=f[i-1][j][k];
                    path[i][j][k]=path[i-1][j][k];
                    if(k>=p[i]-d[i]&&k-(p[i]-d[i])<=2*mid
                        &&f[i-1][j-1][k-(p[i]-d[i])]!=-1
                        &&f[i][j][k]<=f[i-1][j-1][k-(p[i]-d[i])]+p[i]+d[i])
                    {
                        f[i][j][k]=f[i-1][j-1][k-(p[i]-d[i])]+p[i]+d[i];
                        path[i][j][k]=i;
                    }
                }
        i=0;
        int conc;
        while(i<=mid)
        {
            if(f[n][m][mid+i]!=-1||f[n][m][mid-i]!=-1)
                break;
            i++;
        }
        if(f[n][m][mid+i]>f[n][m][mid-i])
            conc=mid+i;
        else conc=mid-i;
        int prose=0,def=0;
        stack<int> ss;
        i=path[n][m][conc];
        j=m;
        while(i!=-1)
        {
            prose+=p[i];
            def+=d[i];
            ss.push(i);
            j=j-1;
            conc-=(p[i]-d[i]);
            i=path[i-1][j][conc];
        }
        printf("Jury #%d\n",++test);
        printf("Best jury has value %d for prosecution and value %d for defence:\n",prose,def);
        while(!ss.empty())
        {
            printf(" %d",ss.top());
            ss.pop();
        }
        printf("\n\n");
    }
    return 0;
}

wuxu 2010-08-09 01:16 发表评论

pku3345(树形DP)

wuxu — Sat, 07 Aug 2010 07:03:00 GMT

首先建一个虚结点,权值为无穷大. 将入度为0的点与之相连, 然后做树形DP,为了防止重复,父亲单独考虑.详细见代码:

#include<iostream>
#include<vector>
#include<map>
#include<string>
#include<sstream>
using namespace std;

const int inf=1000000000;

vector<int> G[210];
int dp[210][210];
int cost[210],in_degree[210];
bool vis[210];
int n,m;

int min(int a,int b)
{
     return a<b?a:b;
}

int dfs(int u)
{
     int i,j,k,v;
     int num=1;
     vis[u]=1;
     dp[u][0]=0;
     for(i=0;i<G[u].size();i++)
     {
         v=G[u][i];
         if(vis[v]) continue;
         num+=dfs(v);
     }
     for(i=0;i<G[u].size();i++)
     {
         v=G[u][i];
         for(j=n;j>=0;j--)
         for(k=1;k<=n;k++)
         {
              if(j>=k&&dp[u][j]!=-1&&dp[u][j-k]!=-1&&dp[v][k]!=-1)
                 dp[u][j]=min(dp[u][j],dp[u][j-k]+dp[v][k]);
              else if(j>=k&&dp[u][j]==-1&&dp[u][j-k]!=-1&&dp[v][k]!=-1)
                  dp[u][j]=dp[u][j-k]+dp[v][k];
         }
     }
     if(dp[u][num]!=-1&&dp[u][num]>cost[u])
        dp[u][num]=cost[u];
     else if(dp[u][num]==-1) dp[u][num]=cost[u];
     return num;
}

int main()
{
    int i,j;
    char str[1000];
    while(gets(str))
    {
        if(str[0]=='#') break;
        sscanf(str,"%d%d",&n,&m);
        for(i=0;i<=n;i++) G[i].clear();
        map<string,int>graph;
        memset(in_degree,0,sizeof(in_degree));
        int id=0;
        for(i=1;i<=n;i++)
        {
            scanf("%s",str);
            if(graph.find(str)==graph.end()) graph[str]=++id;
            int u=graph[str];
            scanf("%d",&cost[u]);
            gets(str);
            stringstream ss(str);
            string name;
            while(ss>>name)
            {
                if(graph.find(name)==graph.end()) graph[name]=++id;
                G[u].push_back(graph[name]);
                in_degree[graph[name]]++;
            }
        }
       cost[0]=inf;
       for(i=1;i<=n;i++)
       {
            if(in_degree[i]) continue;
            G[0].push_back(i);
       }
       memset(vis,0,sizeof(vis));
       memset(dp,-1,sizeof(dp));
       dfs(0);
       int ans=inf;
       for(j=m;j<=n;j++)
       if(dp[0][j]!=-1&&dp[0][j]<ans)
       ans=dp[0][j];
       printf("%d\n",ans);
    }
    //system("pause");
    return 0;
}

wuxu 2010-08-07 15:03 发表评论

hdu1011(树形DP)

wuxu — Fri, 06 Aug 2010 17:25:00 GMT

摘要: 树形背包。代码如下： #include#includeusing namespace std;int n,m;int num[105],brain[105];int dp[105][105];int vis[105];vector map[105... 阅读全文

wuxu 2010-08-07 01:25 发表评论

hdu1561(树形DP)

wuxu — Thu, 05 Aug 2010 10:00:00 GMT

依赖背包(树形背包)。见代码：

#include<iostream>
#include<vector>
using namespace std;
int N,M;
int val[205];
int vis[205];
int f[205][205];
int dp[205][205];
vector<int> tree[205];

int max(int a,int b)
{
    return a>b?a:b;
}

void dfs(int x)
{
    int i,j,k;
    vis[x]=1;
    dp[x][0]=0;
    f[x][0]=0;

    for(i=0;i<tree[x].size();i++)
        for(j=M;j>=0;j--)
        {
            int temp=tree[x][i];
            if(!vis[temp]) dfs(temp);
            for(k=0;k<=M;k++)
            {
                if(dp[temp][k]!=-1&&j>=k&&f[x][j-k]!=-1)
                    f[x][j]=max(f[x][j],f[x][j-k]+dp[temp][k]);
            }
        }
    for(i=1;i<=M+1;i++)
        if(f[x][i-1]!=-1) dp[x][i]=f[x][i-1]+val[x];
}

int main()
{
    while(scanf("%d%d",&N,&M)!=EOF&&(N||M))
    {
        int i,a,b;
        for(i=0;i<=N;i++)
            tree[i].clear();
        for(i=1;i<=N;i++)
        {
            scanf("%d%d",&a,&b);
            tree[a].push_back(i);
            val[i]=b;
        }

        val[0]=0;
        memset(vis,0,sizeof(vis));
        memset(dp,-1,sizeof(dp));
        memset(f,-1,sizeof(f));
        dfs(0);
        printf("%d\n",dp[0][M+1]);
    }
    return 0;
}

wuxu 2010-08-05 18:00 发表评论