C++博客-Ayue-随笔分类-DP

zoj2563

Ayue — Sun, 04 Dec 2011 14:13:00 GMT

题意：m*n的格子里放1*3的矩形，问有多少种放法。
分析：状态压缩dp,每个格子有三种状态，dp[i][j]表示到第i层状态为j的方法数。

#include
#include
#include
using namespace std;
#define LL long long

LL dp[31][20000],n,m,row,zt;
LL num[10],pp[10];

// 状态  0----横放或者竖放的第三个格子对下层没有影响
//       1----竖放的中间那个格子  对下一层有影响
//       2----竖放的第一个格子    对下两层有影响

void dfs(LL pos,LL status)
{
    if(pos==n)
    {
        dp[row+1][status]+=dp[row][zt];
        return;
    }
    if(num[pos]==0)  // 上层为0  这层可以横放或者成2
    {
        if(pos+2// 横放
        dfs(pos+1,status+2*pp[pos]);
    }
    else if(num[pos]==1)     // 上层为1  这层为0
    {
        dfs(pos+1,status);
    }
    else      // 上层为2 这层为1
    {
        dfs(pos+1,status+pp[pos]);
    }
}

void change()
{
    LL now=zt,k=-1;
    memset(num,0,sizeof(num));
    if(now==0) return;
    while(now)
    {
        num[++k]=now%3;
        now/=3;
    }
}

int main()
{
    LL i,nmax;
    pp[0]=1;
    for(i=1;i<=9;i++) pp[i]=pp[i-1]*3;
    while(scanf("%lld%lld",&n,&m)&&(m||n))
    {
        if((m*n)%3!=0) {printf("0\n"); continue;}
        nmax=pp[n];      // 状态总数
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        for(row=0;row<=m-1;row++)
        {
            for(zt=0;zt            {
                if(dp[row][zt])
                {
                    change();
                    dfs(0,0);
                }
            }
        }
        printf("%lld\n",dp[m][0]);
    }
    return 0;
}

Ayue 2011-12-04 22:13 发表评论

zoj2498

Ayue — Sat, 03 Dec 2011 02:53:00 GMT

题意: ......
分析: 二分答案，对于当前二分到的答案，验证在这个时间内是否可以完成，dp[i][j]表示到第i个人时，完成了j个A任务时最多能完成B任务的个数。然后枚举第i个人完成A任务的个数k来转移，dp[i][j]=max{dp[i-1][j-k]+第i个人完成k个A任务后还能完成B任务的个数}。

#include
#include
#include
using namespace std;

int dp[110],a[110],b[110],maxx,n,m;

int judge(int now)
{
    int i,j,k,tem;
    memset(dp,-1,sizeof(dp));
    for(j=0;j<=m;j++)
    {
        if(j*a[1]>now) break;
        tem=now-j*a[1];   // 第一个人完成j个任务1后还剩的时间
        tem=tem/b[1];     // 第一个人还能完成任务2的个数
        dp[j]=tem;
    }
    for(i=2;i<=n;i++)
    {
        for(j=m;j>=0;j--)    // 因为dp[]只用一维，所以类似完全背包这里应该倒过来循环
        {
            for(k=0;k<=j;k++)
            {
                if(k*a[i]>now) break;
                tem=now-k*a[i];   // 第i个人完成k个任务1后还剩的时间
                tem=tem/b[i];     //  还能完成任务2的个数
                if(dp[j-k]!=-1&&dp[j-k]+tem>dp[j])
                    dp[j]=dp[j-k]+tem;
            }
        }
        if(dp[m]>=m) return 1;
    }
    return 0;
}

void solve()
{
    int l=0,r=maxx*2*m,ans=r,mid;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(judge(mid))
        {
            ans=mid;
            r=mid-1;
        }
        else l=mid+1;
    }
    printf("%d\n",ans);
}

int main()
{
    int t,i;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        maxx=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",a+i,b+i);
            if(a[i]>maxx) maxx=a[i];
            if(b[i]>maxx) maxx=b[i];
        }
        solve();
    }
    return 0;
}

Ayue 2011-12-03 10:53 发表评论

zoj2283

Ayue — Wed, 30 Nov 2011 06:56:00 GMT

题意：n*m的网格，有些格子里可能有宝藏，若站在(x,y),每次只能向(x+1,y)或者(x,y+1)方向走，问最少要走几趟能将网格中的宝物收集完。
分析: 按题目的意思就是只能向右和向下走。如果将宝物的坐标按x轴来从小到大排(x轴相同的按y轴从小到大)，那么就可以只考虑y坐标了
，假设有两个位置i,j，i.x<=j.x,当i.y<=j.y时，才有可能收集完i后收集j,所以按x轴排序完后，问题就转化为用最少几个不降子序列可将y轴坐标序列全部涵盖。那就是最长(严格)递减子序列的长度了。

#include <iostream>
#include <stdio.h>
#include <memory.h>
#include <algorithm>
using namespace std;

struct node
{
    int x,y;
}a[100010];

int dp[100010],num[100010],b[100010],n,m,p;

int cmp(node p,node q)
{
    if(p.x==q.x) return p.y<q.y;
    return p.x<q.x;
}

void solve()    // 求最长递减子序列
{
    int i,tem,l,r,mid,ans,top;
    b[1]=num[1]; top=1; dp[1]=1;
    ans=0;
    for(i=2;i<=p;i++)
    {
        if(num[i]<b[top])
        {
            b[++top]=num[i];
            dp[i]=top;
        }
        else
        {
            l=1; r=top;
            while(l<=r)
            {
                mid=(l+r)>>1;
                if(b[mid]<=num[i])
                {
                    tem=mid;
                    r=mid-1;
                }
                else l=mid+1;
            }
            b[tem]=num[i];
            dp[i]=tem;
        }
        if(dp[i]>ans) ans=dp[i];
    }
    printf("%d\n",ans);
}

int main()
{
    int i;
    while(scanf("%d%d%d",&m,&n,&p)!=EOF)
    {
        for(i=1;i<=p;i++)
            scanf("%d%d",&a[i].x,&a[i].y);
        sort(a+1,a+1+p,cmp);
        for(i=1;i<=p;i++)
            num[i]=a[i].y;
        solve();
    }
    return 0;
}

Ayue 2011-11-30 14:56 发表评论

zoj2144

Ayue — Sat, 26 Nov 2011 03:22:00 GMT

摘要: 题意：有个人去一幢楼送礼物，他用两根柱状的容器装礼物，每次只能从容器的两端取出礼物送出去，上一层楼花费5的体力，下一层楼花费3的体力。求送完所有礼物耗费的最少体力。分析：不难的题目，只是目前写的人比较少而已。状态表示还是很好想出来的。dp[i1][j1][i2][j2][0]--第一根柱子到两端为i1,j1都送完,第二根到两端为i2,j2都送完，最后送的是a[i1]这个礼物所花费的最小体力。dp[... 阅读全文

Ayue 2011-11-26 11:22 发表评论

zoj1554/poj2176

Ayue — Sun, 20 Nov 2011 10:18:00 GMT

题意: 将字符串压缩到最短。压缩规则见题目。
分析: 这题我就是用了最原始的方法了。一段一段来压缩。即现在要压缩[i,j]这一段时，要保证任意一段长度比j-i+1小的压缩结果都已经得出来了，也就是按长度从小到大来dp。压缩[i,j]的方法有两种，一种压缩成"数字(字符串)"的形式，另一种是压缩成[i,k][k+1,j]的形式。比较一下，哪种短就选哪种了。

#include <iostream>
#include <stdio.h>
#include <memory.h>
using namespace std;
#define inf 200000000

struct node
{
    int len;
    char ss[110];
}f[110][110];

char ts[110];
int pos;

void tostring(int num)
{
    char cc;
    int i;
    pos=-1;
    while(num)
    {
        ts[++pos]=(num%10)+'0';
        num/=10;
    }
    for(i=0;i<=pos/2;i++)
    {
        cc=ts[i]; ts[i]=ts[pos-i]; ts[pos-i]=cc;
    }
}

int main()
{
    int i,j,k,nlen,now,p,q,n,num;
    char s[110];
    while(scanf("%s",s+1)!=EOF)
    {
        n=strlen(s+1);
        for(i=1;i<=n;i++)   // 初始化
        {
            f[i][i].ss[0]=s[i];
            f[i][i].ss[1]='\0';
            f[i][i].len=1;
        }
        for(nlen=2;nlen<=n;nlen++)   // 现在的长度
        {
            for(i=1;i+nlen-1<=n;i++)
            {
                j=i+nlen-1;
                f[i][j].len=inf;
                //  先看能不能压缩成"数字(字符串)"的形式
                for(now=1;now<nlen;now++)   // now---想折叠成的长度
                {
                    if(nlen%now) continue;
                    q=i+now; p=i;
                    while(q<=j)
                    {
                        if(s[q]!=s[p]) break;
                        p++; q++;
                        if(p==i+now) p=i;
                    }
                    if(q>j)     // 可以压缩成"数字(字符串)"的形式
                    {
                        num=nlen/now;
                        tostring(num);
                        strcpy(f[i][j].ss,ts);
                        f[i][j].ss[++pos]='(';
                        for(p=0;f[i][i+now-1].ss[p];p++) f[i][j].ss[++pos]=f[i][i+now-1].ss[p];
                        f[i][j].ss[++pos]=')';
                        f[i][j].len=pos+1;
                        f[i][j].ss[++pos]='\0';
                        break;
                    }
                }
                for(k=i;k<j;k++)  // [i,k][k+1,j]这种形式
                {
                    if(f[i][k].len+f[k+1][j].len<f[i][j].len)
                    {
                        f[i][j].len=f[i][k].len+f[k+1][j].len;
                        strcpy(f[i][j].ss,f[i][k].ss);
                        strcat(f[i][j].ss,f[k+1][j].ss);
                    }
                }
            }
        }
        printf("%s\n",f[1][n].ss);
    }
    return 0;
}

Ayue 2011-11-20 18:18 发表评论

zoj1475

Ayue — Thu, 17 Nov 2011 15:00:00 GMT

题意：问n个人的不同的排名方式有多少种，多个人可能处在同一个名次。
分析: 递推了。公式也很容易写出来。 f[i][j]表示有i个人，j个不同的名次(可能多个人在同一个名次)的方案数.
f[i][j]=f[i-1][j]*j+f[i-1][j-1]*j; 因为i个人排成j个档次可以在i-1个人j个档次的基础上随便找个档次(共有j个档次)加上第i个人，也可以在i-1个人j-1个档次的基础上让第i个人独立作为一个档次随意排，有j个位置。答案就是sigma{f[n][i] | i从1到n}。这题要用大数。于是我的第一个java程序诞生了，乱搞查资料，debug了半天，终于写出来了，很丑的。自我鄙视一下。

import java.io.*;
import java.util.*;
import java.math.*;
import java.text.*;

public class Main
{
    static int n;
    static BigInteger ans=new BigInteger("0");
    static BigInteger tem=new BigInteger("0");
    static BigInteger tt=new BigInteger("0");
    static BigInteger[][] f = new BigInteger[210][210];
    static int zero=0;
    public static void main(String[] args)
    {
        ini();
        Scanner cin=new Scanner(new BufferedInputStream(System.in));
        while((n=cin.nextInt())>=0)
        {
            ans=ans.valueOf(0);
            for(int i=1;i<=n;i++) ans=ans.add(f[n][i]);
            System.out.println(ans);
        }
    }
    public static void ini()
    {
        for(int i=1;i<=200;i++)
        {
            for(int j=1;j<=200;j++) f[i][j]=f[i][j].valueOf(0);
        }
        for(int i=1;i<=200;i++)
        {
            f[i][1]=f[i][1].valueOf(1);
        }
        for(int i=2;i<=200;i++)
        {
            for(int j=2;j<=i;j++)
            {
                f[i][j]=f[i][j].valueOf(0);
                tem=tem.valueOf(j);
                tt=f[i-1][j].multiply(tem);
                f[i][j]=f[i][j].add(tt);
                tt=f[i-1][j-1].multiply(tem);
                f[i][j]=f[i][j].add(tt);
            }
        }
    }
}

Ayue 2011-11-17 23:00 发表评论

zoj1490

Ayue — Wed, 16 Nov 2011 03:05:00 GMT

题意：当任意两个卫星的距离小于等于25时，放置一个天线就可以同时接受到这两个卫星的信号。现在告诉n个卫星的位置，求最少需购买天线数量，同时需要保证，得到的信号值总和最大。信号值计算公式是Qx=100-|卫星的位置-天线的位置|。
分析：只要弄清楚了题意，就很容易发现这个题其实就是经典的村庄里建邮局的问题了，只不过这里要求每一段的范围在25以内。因为数据范围只有100，就没写什么优化了，直接上n^3的。
f[i][j]表示前i个卫星放j个天线所能得到的最大信号。 f[i][j]=max{f[k][j-1]+w[k+1][i]; | d[i]-d[k+1]<=25}

#include <iostream>
#include <stdio.h>
#include <memory.h>
#include <algorithm>
using namespace std;
#define eps 1e-8

int n;
double f[110][110],w[110][110],d[110];

int main()
{
    int i,j,k,tem;
    while(scanf("%d",&n)!=EOF)
    {
        d[0]=0.0;
        for(i=1;i<=n;i++)
        {
            scanf("%lf",&d[i]);
        }
        sort(d+1,d+n+1);
        for(i=1;i<=n;i++)   // 预处理出任意一段放一个卫星的所获得的最大信号值。
        {
            w[i][i]=100.0;
            for(j=i+1;j<=n;j++)
            {
                tem=i+(j-i+1)/2;
                w[i][j]=0.0;
                for(k=i;k<=tem;k++)
                    w[i][j]+=d[tem]-d[k];
                for(;k<=j;k++)
                    w[i][j]+=d[k]-d[tem];
                w[i][j]=(j-i+1)*100.0-w[i][j];
            }
        }
        for(i=0;i<=n;i++)
        {
            for(j=0;j<=n;j++) f[i][j]=-1.0;
        }
        f[0][0]=0.0;
        f[1][1]=100.0;
        for(i=2;i<=n;i++)
        {
            for(j=1;j<=i;j++)
            {
                for(k=i-1;k>=j-1&&d[i]+eps<=25.0+d[k+1];k--)
                {
                    if(f[k][j-1]+eps<0.0) continue;
                    tem=i-k;
                    if(f[k][j-1]+w[k+1][i]>f[i][j]+eps)
                        f[i][j]=f[k][j-1]+w[k+1][i];
                }
            }
        }
        for(j=1;j<=n;j++)
        {
            if(f[n][j]>=0) break;
        }
        printf("%d %.2lf\n",j,f[n][j]);
    }
    return 0;
}

Ayue 2011-11-16 11:05 发表评论

zoj1446

Ayue — Mon, 14 Nov 2011 08:55:00 GMT

题意：好难表达...
分析：dp了，没什么好说的，dp[now]=min{dp[i]+dp[now-i],dp[i]+dp[now/i]且now%i==0,dp[i]+dp[j]且i^j==now;} 。不过转移的时候我的方法很暴力，不知道其他优秀的方法是怎么做的。一些很明显的值的表达式可以预处理出来。

#include <iostream>
#include <stdio.h>
#include <memory.h>
#include <cmath>
using namespace std;
#define inf 2000000000

struct node
{
    int  num;
    char s[100];
}a[20010];

void ini()
{
    int i,now,j,tem,cnt;
    for(i=1;i<=20000;i++) a[i].num=inf;
    a[1].num=1; strcpy(a[1].s,"1");      // 1,2,3,5,7预处理出来
    a[2].num=1; strcpy(a[2].s,"2");
    a[3].num=1; strcpy(a[3].s,"3");
    a[5].num=1; strcpy(a[5].s,"5");
    a[7].num=1; strcpy(a[7].s,"7");

    a[4].num=2; strcpy(a[4].s,"(2^2)");   // 4也预处理

    a[6].num=1; strcpy(a[6].s,"3!");      //  预处理3到7的阶乘，因为8的阶乘已经超过20000了
    a[24].num=2; strcpy(a[24].s,"(2^2)!");  // 注意阶乘的表达式外面就不用括号了，我一开始加了就wa
    a[120].num=1; strcpy(a[120].s,"5!");
    a[720].num=1; strcpy(a[720].s,"3!!");
    a[5040].num=1; strcpy(a[5040].s,"7!");

    for(now=4;now<=20000;now++)     // 下面就是dp了转移的时候很暴力
    {
        if(a[now].num!=inf) continue;
        tem=(int)sqrt(now+0.0);
        for(i=2;i<=tem;i++)
        {
            if(now%i==0)
            {
                j=now/i;
                if(a[i].num+a[j].num<a[now].num)      // *运算
                {
                    a[now].num=a[i].num+a[j].num;
                    strcpy(a[now].s,"(");
                    strcat(a[now].s,a[i].s);
                    strcat(a[now].s,"*");
                    strcat(a[now].s,a[j].s);
                    strcat(a[now].s,")");
                }
                cnt=now; j=0;
                while(cnt%i==0&&cnt>0)
                {
                    ++j;
                    cnt/=i;
                }
                if(cnt==1)
                {
                    if(a[i].num+a[j].num<a[now].num)   // ^运算
                    {
                        a[now].num=a[i].num+a[j].num;
                        strcpy(a[now].s,"(");
                        strcat(a[now].s,a[i].s);
                        strcat(a[now].s,"^");
                        strcat(a[now].s,a[j].s);
                        strcat(a[now].s,")");
                    }
                }
            }
        }
        for(i=1;i<=now/2;i++)
        {
            j=now-i;
            if(a[i].num+a[j].num<a[now].num)   // +运算
            {
                a[now].num=a[i].num+a[j].num;
                strcpy(a[now].s,"(");
                strcat(a[now].s,a[i].s);
                strcat(a[now].s,"+");
                strcat(a[now].s,a[j].s);
                strcat(a[now].s,")");
            }
        }
    }
}

int main()
{
    ini();
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        printf("%s\n",a[n].s);
    }
    return 0;
}

Ayue 2011-11-14 16:55 发表评论

zoj1346

Ayue — Sat, 12 Nov 2011 08:01:00 GMT

题意：给一些人的排列限制关系（比如x要排在y前面），求符合这些条件的排列总数。
分析: 这题自己没想出来，看了别人的题解。这句“我们想求一堆人的排列总数，它等于在这一堆人中减去每一个入度为 0 的人，剩下的人的排列总数的和。”就是这题的方法了。记忆化搜索写法。

#include <iostream>
#include <memory.h>
#include <stdio.h>
#include <cstring>
using namespace std;
#define LL long long

LL dp[(1<<16)+10],g[16][16],din[16],n,m;
char name[16][20];

LL find(char s[])
{
    for(LL i=0;i<=n;i++)
    {
        if(strcmp(s,name[i])==0) return i;
    }
    return -1;
}

LL dfs(LL now)
{
    LL i,j;
    if(dp[now]>=0) return dp[now];
    dp[now]=0;
    for(i=0;i<n;i++)
    {
        if(!din[i]&&(now&(1<<i))) // 如果i的入度为0且now这个状态含有i
        {
            for(j=0;j<n;j++)
            {
                if(g[i][j]) din[j]--;
            }
            dp[now]+=dfs(now-(1<<i));   // 递推关系
            for(j=0;j<n;j++)   // 恢复
            {
                if(g[i][j]) din[j]++;
            }
        }
    }
    return dp[now];
}

int main()
{
    LL i,x,y,ans,nmax,j;
    char s1[20],s2[20];
    while(scanf("%lld",&m)!=EOF)
    {
        memset(g,0,sizeof(g));
        n=-1;
        for(i=1;i<=m;i++)
        {
            scanf("%s %s",s1,s2);
            x=find(s1);
            if(x==-1) {strcpy(name[++n],s1); x=n;}
            y=find(s2);
            if(y==-1) {strcpy(name[++n],s2); y=n;}
            g[x][y]=1;
        }
        n++;
        memset(din,0,sizeof(din));
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                if(g[i][j]) din[j]++;
            }
        }
        memset(dp,-1,sizeof(dp));
        for(i=0;i<n;i++) dp[(1<<i)]=1;   // 只剩一个人的时，必然是1 所以先设好边界
        nmax=(1<<n)-1;
        ans=dfs(nmax);
        printf("%lld\n",ans);
    }
    return 0;
}

Ayue 2011-11-12 16:01 发表评论

zoj1245

Ayue — Fri, 11 Nov 2011 12:54:00 GMT

摘要: 题意：给一个三角形，被分成了很多个三角形(具体看题目里的图)，求一个最大的只包含白色三角形三角形。分析：不难但有点小恶心的题目。方法应该很多，怎么数都行了。我是用类似dp的方法的，如果上一层的[j+1,k-1]这个范围能构成一个纯白色三角形，并且这一层的[j,k]这个范围也都是白的，那么f[i][j][k]就代表了一个纯白色的大三角形。代码写得有些啰嗦，懒得简化了。 Code hig... 阅读全文

Ayue 2011-11-11 20:54 发表评论

zoj1234

Ayue — Fri, 11 Nov 2011 07:45:00 GMT

题意：从n根筷子中选出3*（k+8）根筷子，组成k+8组，每组3根，每组的badness值为最短两根长度之差的平方。求最小的badness值。
分析：这本是个很简单的题，但我一直脑残总想着顺推，想了各种方法处理第三根筷子，发现都不行。其实逆着推就可以保证每组都能找到最长的那根筷子了。 dp[i][j]表示从第i根到第n根组成了j组的最小值，则有dp[i][j]=min(dp[i+1][j],dp[i+2][j-1]+(a[i+1]-a[i])*(a[i+1]-a[i]))。注意当n-i+1==3*j时，dp[i][j]是直接等于dp[i+2][j-1]+(a[i+1]-a[i])*(a[i+1]-a[i])的，因为这时不能再舍弃第i根筷子不用了。

#include <iostream>
#include <stdio.h>
#include <memory.h>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
#define inf 2000000000

int dp[5010][1010],n,k,a[5010];

int main()
{
    int t,i,j;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&k,&n);
        k+=8;
        for(i=1;i<=n;i++) scanf("%d",a+i);
        for(i=n;i>=1;i--) dp[i][0]=0;
        for(i=n;i>=n-1;i--)  // 初始化
        {
            for(j=1;j<=k;j++) dp[i][j]=inf;
        }
        for(i=n-2;i>=1;i--)
        {
            for(j=1;j<=k&&n-i+1>=3*j;j++)
            {
                if(n-i+1>3*j) dp[i][j]=min(dp[i+1][j],dp[i+2][j-1]+(a[i+1]-a[i])*(a[i+1]-a[i]));
                else dp[i][j]=dp[i+2][j-1]+(a[i+1]-a[i])*(a[i+1]-a[i]);
            }
        }
        printf("%d\n",dp[1][k]);
    }
    return 0;
}

Ayue 2011-11-11 15:45 发表评论

zoj1206

Ayue — Thu, 10 Nov 2011 14:11:00 GMT

题意：给出m个长度为3的由0~9组成的字符串，每个字符串有一个权值，可正可负。要求构造出一个长度为n的字符串，若字符串中包含题目给出的某个字符串，则获得该字符串的权值。求一个权值最大的字符串。
分析：其实很早就想到了记录当前位和上一位的数字的dp方程，但是由于没理解题目意思(貌似题目说的也不太清楚)，所以不确定如果包含同一个字符串多次，该字符串的权值是只算一次还是算多次。在网上看了看他人的解答，原来是按算多次来理解的。于是下手写，细想的时候发现顺推不能保证字典序最小，于是加了个string记录，还是顺推，果断超时了。才想到从右往左倒着dp，就能保证最后得出的字符串是字典序最小的了，这一点想一想dp时循环的顺序就很容易理解了。
用f[now][i][j]表示从右往左到第now位，且第now位上数字为i,第now-1位上的数字为j的最大值，则f[now][i][j]=max{
f[now-1][j][k]+w[100*i+10*j+k] }

#include <iostream>
#include <stdio.h>
#include <memory.h>
#include <stdlib.h>
#include <limits.h>
using namespace std;
#define inf INT_MAX

int f[10010][10][10],pre[10010][10][10],n,m,w[1010],out[10010];

int main()
{
    int i,j,k,ans,p,q,tem,x,y,now;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(w,0,sizeof(w));
        for(i=1;i<=m;i++)
        {
            scanf("%d%d",&x,&y);
            w[x]=y;
        }
        for(j=0;j<=9;j++)
        {
            for(k=0;k<=9;k++)
            {
                f[2][j][k]=0;
            }
        }
        for(now=3;now<=n;now++)  // dp
        {
            for(i=0;i<=9;i++)
            {
                for(j=0;j<=9;j++)
                {
                    f[now][i][j]=-inf;
                    for(k=0;k<=9;k++)
                    {
                        if(f[now-1][j][k]+w[100*i+10*j+k]>f[now][i][j])
                        {
                            f[now][i][j]=f[now-1][j][k]+w[100*i+10*j+k];
                            pre[now][i][j]=k;
                        }
                    }
                }
            }
        }
        ans=-inf;
        for(i=0;i<=9;i++)
        {
            for(j=0;j<=9;j++)
            {
                if(f[n][i][j]>ans)
                {
                    ans=f[n][i][j];
                    p=i; q=j;
                }
            }
        }
        i=n;
        while(i>2)
        {
            printf("%d",p);
            tem=pre[i][p][q];
            p=q; q=tem;
            i--;
        }
        printf("%d%d\n",p,q);
    }
    return 0;
}

Ayue 2011-11-10 22:11 发表评论

zoj1013

Ayue — Mon, 07 Nov 2011 07:45:00 GMT

题意：表达能力不好，就不说了。
分析：算是比较简单的背包了，f[i][j][k]表示前i辆车装了j个武器1和k个武器2后还能装武器3的最多个数，再转移即可。

#include <iostream>
#include <stdio.h>
#include <memory.h>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))

int f[2][510][510],w[4],s[4],d[4],x[110],y[110],n;

int main()
{
    int i,j,k,now,pre,tem,c1,c2,c3,d4,ca=0,p,q,rew,res;
    int last1,last2,up1,up2;
    while(scanf("%d",&n)&&n)
    {
        if(ca>0) printf("\n");
        for(i=1;i<=3;i++) scanf("%d%d%d",&w[i],&s[i],&d[i]);
        scanf("%d%d%d%d",&c1,&c2,&c3,&d4);
        for(i=1;i<=n;i++) scanf("%d%d",&x[i],&y[i]);
        memset(f,-1,sizeof(f));
        f[0][0][0]=0;
        now=1; pre=0;
        last1=0; last2=0;
        for(i=1;i<=n;i++)
        {
            up1=last1+min(x[i]/w[1],y[i]/s[1]);  // 加点小优化减少决策范围从5000ms减到500ms
            if(up1>500) up1=500;
            up2=last2+min(x[i]/w[2],y[i]/s[2]);
            if(up2>500) up2=500;
            for(j=0;j<=up1;j++)
            {
                for(k=0;k<=up2;k++)
                {
                    f[now][j][k]=-1;
                    for(p=0;p<=j;p++)
                    {
                        if(p*w[1]>x[i]||p*s[1]>y[i]) break;
                        for(q=0;q<=k;q++)
                        {
                            if(p*w[1]+q*w[2]>x[i]||p*s[1]+q*s[2]>y[i]) break;
                            if(f[pre][j-p][k-q]==-1) continue;
                            rew=x[i]-p*w[1]-q*w[2];
                            res=y[i]-p*s[1]-q*s[2];
                            tem=min(rew/w[3],res/s[3]); // 当前这辆车装完p个武器1和q个武器2后还能装武器3的个数
                            if(f[pre][j-p][k-q]+tem>f[now][j][k])
                                f[now][j][k]=f[pre][j-p][k-q]+tem;
                        }
                    }
                    if(f[now][j][k]!=-1)
                    {
                        last1=max(last1,j);
                        last2=max(last2,k);
                    }
                }
            }
            tem=now; now=pre; pre=tem;
        }
        int flag,ans=0,num;
        if(c1*d[1]+c2*d[2]+c3*d[3]>d4) flag=1;  // 选择比较好的组合武器的方式
        else flag=2;
        for(i=0;i<=500;i++)
        {
            for(j=0;j<=500;j++)
            {
                if(f[pre][i][j]==-1) continue;
                k=f[pre][i][j];
                if(flag==1)
                    ans=max(ans,i*d[1]+j*d[2]+k*d[3]);
                else
                {
                    num=min(i/c1,min(j/c2,k/c3));
                    tem=num*d4+(i-num*c1)*d[1]+(j-num*c2)*d[2]+(k-num*c3)*d[3];
                    ans=max(ans,tem);
                }
            }
        }
        printf("Case %d: %d\n",++ca,ans);
    }
    return 0;
}

Ayue 2011-11-07 15:45 发表评论