每日总结之动态规划dp 5.2 【一维dp+二维dp】

算法

 一维dp【】

---

问题描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

 1.含义：dp【i】：跳到一个 i 级的台阶的方法数

2.底层条件：初始化边界；dp[0] = 0 ，dp[1] = 1;

dp[1] = dp[0] + dp[-1]，当n=1时，dp[-1]下标不能为-1，故dp[1]应为1，dp[0]应为0；

3.递推关系式： dp[n] = dp[n-1] + dp[n-2]

    dp[0] = 0;
    dp[1] = 1;
   
    for(int i = 2; i <= n; i++)
    {
        dp[i] = dp[i-1] + dp[i-2];
    }
    
    return dp[n];     //最终结果

 二维dp【】【】

---

问题描述：机器人从起点走到终点，求可能路径数

1.含义：dp【i】【j】：从 i -> j 共有路径数

2.底层条件：dp【i】【0】= 1;    dp【0】【j】= 1;
一直向下走，一直向右走

如果 i 或者 j 有一个为 0， i - 1 或者 j - 1作为数组下标就变为负数

3.递推关系式：  dp[i] [j] = dp[i-1] [j] + dp[i] [j-1] 

 for(int i = 0; i < m; i++)
    {
      dp[i][0] = 1;
    }

      for(int i = 0; i < n; i++)
    {
      dp[0][i] = 1;
    }
      
    for (int i = 1; i < m; i++)
    {
        for (int j = 1; j < n; j++) 
        {
            dp[i][j] = dp[i-1][j] + dp[i][j-1];
        }
    }
    return dp[m-1][n-1];   //二维数组起点从（0，0）开始

刷题 

1. 五倍经验日

P1802 5 倍经验日 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)https://www.luogu.com.cn/problem/P1802

1.含义：

dp【i】【j】：表示对前i个人，药数为j时能获得最大经验值dp

c【i】.use：打败第i人所需药数

2.更新dp【】【】：max（win，lose）

 //赢win可获经验值：c[i].win+dp[i-1][j-c[i].use];
 //输lose可获经验值：c[i].lose+dp[i-1][j];

3.注意：long long（五倍经验）

j 从0开始！！！（use药可以不使用）

#include<stdio.h>
int n,x ;
long long dp[1002][1002];        //表示对前i个人，药数为j时能获得最大经验值为dp[i][j]

struct node
{
    int  lose;         //输可获经验值
    int  win;          //赢可获经验值
    int use;          //需药量
}c[1001];

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

int main()
{
	scanf("%d%d",&n,&x);    // n为人数，x为药数
	for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d",&c[i].lose,&c[i].win,&c[i].use);
    }

    //赢win可获经验值：c[i].win+dp[i-1][j-c[i].use];
    //输lose可获经验值：c[i].lose+dp[i-1][j];

    for(int i=1;i<=n;i++)       //人数
        for(int j=0;j<=x;j++)   //药数
    {
        if(j>=c[i].use)   //能赢
        {
            dp[i][j]=max(c[i].lose+dp[i-1][j],c[i].win+dp[i-1][j-c[i].use]);
        }

        else            //只能输，药不够用
        {
           dp[i][j]=dp[i-1][j]+c[i].lose;
        }
    }
    printf("%lld",dp[n][x]*5);
		return 0;

}

2.合唱队形

P1091 [NOIP2004 提高组] 合唱队形 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)https://www.luogu.com.cn/problem/P1091

1.题意：求对称上升下降序列

2. 含义：

a【】：存当前队列

b【i】：以第 i 位同学为最高点的  最大上升序列的长度

c【i】：以第 i 位同学为最高点的  最大下降序列的长度

3.初始化：

 b[1]=1;  若最高点为第1位同学，上升序列长度则为1

 c[n]=1;  若最高点为第n位同学，下降序列长度则为1

4.双重比较：比较最高点的邻近数，比较上升序列长度

5.注意：顶点重复计算，ans-1为最大序列数，n-(ans-1)则为需去掉的点数

ans=b[ i ] + c[ i ]          顶点两边的数的个数一样（对称）

#include<stdio.h>
int n;
int a[101];           //存队列
int b[101];          //以第i位同学为终点的  最大上升序列的长度
int c[101];          //以第i位同学为终点的  最大下降序列的长度

int main()
{
    int maxn=0;
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&a[i]);
    }

    b[1]=1;            //若最高点为第一位同学，上升序列长度则为1
    for(int i=2; i<=n; i++)    //后一位同学
    {
        maxn=0;                 //初始化maxn为零
        for(int j=1; j<i; j++)   //前几位同学
        {
            if(a[i]>a[j])
            {
                if(b[j]>maxn)
                {
                    maxn=b[j];
                }
            }
        }
        b[i]=maxn+1;
    }

    c[n]=1;            //若最高点为最后一位同学，下降序列长度则为1
    for(int i=n-1; i>=1; i--)   //最后一位同学
    {
        maxn=0;              //初始化maxn为零
        for(int j=i+1; j<=n; j++)   //
        {
            if(a[i]>a[j])
            {
                if(c[j]>maxn)
                {
                    maxn=c[j];
                }
            }
        }
        c[i]=maxn+1;
    }

    int ans=0;
    for(int i=1; i<=n; i++)
    {
        if(b[i]+c[i]>ans)         //顶点两边的数的个数一样（对称）
        {
            ans=b[i]+c[i];       //找最值ans
        }
    }

    printf("%d",n-(ans-1));      //顶点重复计算，ans-1为最大序列数
}                               //n-(ans-1)则为需去掉的数