动态规划（2） 神奇口袋 0-1背包 滑雪 最佳加法表达式

神奇的口袋(百练2755)
 有一个神奇的口袋，总的容积是40，用这个口袋可以变出一
些物品，这些物品的总体积必须是40。
 John现在有n（1≤n ≤ 20）个想要得到的物品，每个物品
的体积分别是a 1 ，a 2 ……a n 。John可以从这些物品中选择一
些，如果选出的物体的总体积是40，那么利用这个神奇的口
袋，John就可以得到这些物品。现在的问题是，John有多少
种不同的选择物品的方式。
61
 输入
输入的第一行是正整数n (1 <= n <= 20)，表示不同的物品的
数目。接下来的n行，每行有一个1到40之间的正整数，分别
给出a 1 ，a 2 ……a n 的值。
 输出
输出不同的选择物品的方式的数目。
 输入样例
3
20
20
20
 输出样例
3

类似于01背包，但边界条件有所不同。即必须装满。状态转移方程为：

if(w-a[k]>=0)
dp[w][k]+=dp[w-a[k]][k-1]
else
dp[w][k]=dp[w][k-1]

#include <iostream>
#include <stdlib.h>
using namespace std;
int n;
int a[30];
int num[45][30];//num[i][j]从前j种物品里凑出体积为i的方法数
int main()
{
    cin>>n;
    int i;
    memset(num,0,sizeof(num));//多少种选择，初始化为0
    for (i=1;i<=n;i++)
    {
        cin>>a[i];
        num[0][i]=1;//都置为1，后期只需相加
    }
    num[0][0]=1;
    int v,j;
    for (v=1;v<=40;v++)
    {
        for (j=1;j<=n;j++)
        {
            num[v][j]=num[v][j-1];//当前的与其前一个有关
            if (v-a[j]>=0)//40减去此点的所存体积
                num[v][j]+=num[v-a[j]][j-1];//所剩体积所在行的前一列的方法数
        }
    }
    cout<<num[40][n]<<endl;//将最后一个输出
    system("pause");
    return 0;
}

0-1背包问题(POJ3624)
有N件物品和一个容积为M的背包。第i件物品的体积w[i]
，价值是d[i]。求解将哪些物品装入背包可使价值总和
最大。每种物品只有一件，可以选择放或者不放
(N<=3500,M <= 13000)。
Input

• Line 1: Two space-separated integers: N and M
• Lines 2..N+1: Line i+1 describes charm i with two space-separated integers: Wi and Di
  Sample Input
  4 6
  1 4
  2 6
  3 12
  2 7
  Sample Output
  23
  用 F[i][j] 表示取前i种物品，使它们总体积不超过j的
  最优取法取得的价值总和
  递推： F[i][j] = max(F[i-1][j],F[i-1][j-w[i]]+d[i])
  取或不取第 i种物品，两者选优
  (j-w[i] >= 0才有第二项)

#include <iostream>
#include <cstdio>
#include <cstring>//用于memset
using namespace std;
int n,m;
int main()
{
    int i;
    int w[3406],d[3406];
    int a[12884];//体积不超过lw的去扽最优价值总和
    while(scanf("%d%d",&n,&m)!=EOF)//个数和最重体积
    {
        for(i=0;i<n;i++)
        {
            scanf("%d%d",&w[i],&d[i]);
        }
        memset(a,0,sizeof(a));
        int lw;//当前价值
        for(i=0;i<n;i++)
        {//个数
            for(lw=m;lw>=w[i];lw--)体积控制
                a[lw]=max(a[lw-w[i]]+d[i],a[lw]);//所剩体积加该处的价值与当前点的价值，取最大
        }
        cout<<a[m]<<endl;
    }
    return 0;
}

滑雪(百练1088)
查看 提交 统计 提示 提问
总时间限制: 1000ms 内存限制: 65536kB
描述
Michael喜欢滑雪百这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-…-3-2-1更长。事实上，这是最长的一条。
输入
输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。
输出
输出最长区域的长度。
样例输入
5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
样例输出
25
L(i,j)表示从点(i,j)出发的最长滑行长度。
一个点(i,j), 如果周围没有比它低的点，L(i,j) = 1
否则
递推公式： L(i,j) 等于(i,j)周围四个点中,比(i,j)低，且L值最大的那个点
的L值，再加1

#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <cstdio>
using namespace std;
struct num
{
    int h;
    int x,y;
    bool operator <(const num &n)const
    { return h<n.h;}//按高度从小到大排顺序
}nums[12100];
int main()
{
    int i,j,r,c,cnt=0;
    int a[110][110],b[110][110];
    scanf("%d%d",&r,&c);//行 列
    for(i=1;i<=r;i++)
    {
        for (j=1;j<=c;j++)
        {
            scanf("%d",&a[i][j]);//用来暂存输入的数据
            b[i][j]=1;
            nums[cnt].h=a[i][j];
            nums[cnt].x=i;//记录下横纵坐标
            nums[cnt].y=j;
            cnt++;//num数组是存储数据
        }
    }
    sort(nums,nums+cnt);
    int ans=1;//从第一个开始则长度一开始就为1
    for (i=cnt-1;i>0;i--)
    {//ans等于比该点处低，
        int x=nums[i].x ;int y=nums[i].y;
        if (x+1<=r&&(a[x+1][y]<a[x][y]))//高度低 向下
        {  
            b[x+1][y]=max(b[x+1][y],b[x][y]+1);//取向下的长度和此点长度=（向下的+1）最大的
        ans=max(ans,b[x+1][y]);}//记录更新下最大的长度
        if (y+1<=c&&a[x][y+1]<a[x][y])//向右
        { 
            b[x][y+1]=max(b[x][y+1],b[x][y]+1);
        ans=max(ans,b[x][y+1]);}
        if(x-1>=1&&a[x-1][y]<a[x][y])//向上
        {
            b[x-1][y]=max(b[x-1][y],b[x][y]+1);
        ans=max(ans,b[x-1][y]);}
        if (y-1>=1&&a[x][y-1]<a[x][y])//向左
        {
            b[x][y-1]=max(b[x][y-1],b[x][y]+1);
        ans=max(ans,b[x][y-1]);}
    }
    cout<<ans<<endl;
    system("pause");
    return 0;
}

1.最佳加法表达式：
有一个由1..9组成的数字串.问如果将m个加
号插入到这个数字串中,在各种可能形成的
表达式中，值最小的那个表达式的值是多少
输入
有不超过15组数据
每组数据两行。第一行是整数m，表示有m个加号要放( 0<=m<=50)
第二行是若干个数字。数字总数n不超过50,且 m <= n-1
输出
对每组数据，输出最小加法表达式的值
样例输入
2
123456
1
123456
4
12345
样例输出
102
579
15
提示
要用到高精度计算，即用数组来存放long long 都装不下的大整数，并用模拟列竖式的办法进行大整数的加法。

设V(m,n)表示在n个数字中插入m个加号所能形成
的表达式最小值，那么：
if m = 0
V(m,n) = n个数字构成的整数
else if n < m + 1
V(m,n) = ∞
else
V(m,n) = Min{ V(m-1,i) + Num(i+1,n) } ( i = m … n-1)
Num(i,j)表示从第i个数字到第j个数字所组成的数。数字编号从1开始算。此操
作复杂度是O(j-i+1)，可以预处理后存起来。
该题处理思路先放一个加号：可以先放最右边的加号，右边固定，左边放加号最小。
要避免重复计算：将数存起来，Num(i,j)表示从第i个数字到第j个数字所组成的数。

#include<iostream>
#include<string>
#include<cstring>
using namespace std;
struct BigInt{
    int num[110];
    int len;
    BigInt operator+(const BigInt &n){
        //重载+，使得a+b在a,b都是BigInt变量的时候能成立
        int ml=max(len,n.len);
        int carry=0;//进位
        BigInt result;
        for(int i=0;i<ml;++i){
            result.num[i]=num[i]+n.num[i]+carry;
            if(result.num[i]>=10){
                carry=1;//倒着存储的
                result.num[i]-=10;
            }
            else
                carry=0;
        }
        if(carry==1){
            result.len=ml+1;
            result.num[ml]=1;
        }
        else
            result.len=ml;
        return result;
    }
    bool operator<(const BigInt &n){//重载运算符小于号
        if(len>n.len)
            return false;
        else if(len<n.len)
            return true;//更换长度
        else{
            for(int i=len-1;i>=0;--i){
                if(num[i]<n.num[i])
                    return true;//从小到大排序
                else if(num[i]>n.num[i])
                    return false;
            }
            return false;
        }
    }
    BigInt(){//大数的无参数构造
        len=1;
        memset(num,0,sizeof(num));
    }
    BigInt(const char *n,int L){
        //由长度为L的char数组构造大整数，n里面的元素取值范围从1到9。
        memset(num,0,sizeof(num));
        len=L;
        for(int i=0;n[i];++i)
            num[len-i-1]=n[i]-'0';//改为数字类型
    }
};

ostream &operator<<(ostream &o,const BigInt &n)
{//重载输出流
    for(int i=n.len-1;i>=0;--i)
        o<<n.num[i];
    return o;
}

const int MAXN=60;
char a[MAXN];
BigInt Num[MAXN][MAXN];//Num[i][j]表示从第i个数字到第j个数字所构成的整数
BigInt V[MAXN][MAXN];//V[i][j]表示i个加号放到前j个数字中间，所能得到的最佳表达式的值

int main()
{
    int m,n;
    BigInt inf;//无穷大 ，定义时，直接调用无参数构造
    inf.num[MAXN-2]=1;
    inf.len=MAXN-1;//无穷大

    while(cin>>m){//m个加号
        cin>>a+1;//从下标1开始
        n=strlen(a+1);
        for(int i=1;i<=n;++i)
            for(int j=i;j<=n;++j)
                Num[i][j]=BigInt(a+i,j-i+1);//预处理，改成数字类型，将从第i个数字到第j个数字所构成的整数存储
        for(int j=1;j<=n;++j)
            V[0][j]=BigInt(a+1,j);//在前j个数之前加0个加号，所形成的最小表达式的值就是这前j个数字串连成的数值

        for(int i=1;i<=m;++i){
            for(int j=1;j<=n;++j){
                if(j-1<i)//加号数
                    V[i][j]=inf;//j个数最多加j-1个加号，加好数目i>j-1,表达式不形成，而这个肯定不是最佳表达式的最小值，所以初始化，inf
                else{
                    BigInt tmpMin=inf;//先设为无穷大
                    for(int k=i;k<j;++k){//加号可以放最右边的距离
                        BigInt tmp=V[i-1][k]+Num[k+1][j];//i-1个加号放到k个之前的最佳表达式的值 + k+1到j构成数
                        if(tmp<tmpMin)
                            tmpMin=tmp;//再更换
                    }
                    V[i][j]=tmpMin;//i个加号加在j之前的最佳表达式值
                }
            }
        }
        cout<<V[m][n]<<endl;
    }
    return 0;
}

代码来自各路大神