算法必备—动态规划详解,从递归到动态规划

动态规划

文章目录

      • 动态规划
        • 1.机器人走路问题
          • 解法1:递归法
          • 解法2:动态规划
        • 2.背包问题
          • 解法1:暴力递归法
          • 2.动态规划

动态规划作为经典的算法,在使用上现在十分广泛,机器人走路问题、背包问题、八皇后问题,可以说是用的地方十分广泛。

动态规划从简单的地方说起,最初的时候可以理解为循环问题,就是常说的递归,我们仔细的想一想,如果一个问题能够使用递归得到解,那么只要在递归过程中有重复的计算,都可以换做动态规划来解决。

首先了解动态规划是什么?

就是将大问题,分解为小问题,然后一步步的解决它,很类似于分治算法,但是用很不相同。

再次了解递归的要点?

递归必须右函数出口,否则会死递归下去

递归过程必须是要向着出口的条件逼近,否则也会是死递归过程

可以将递归理解为栈结构,当主递归进去后,就是方法入栈,一直递归调用,知道最后一个递归方法全部进栈,开始出栈回溯。

例子:

1.机器人走路问题

假设有一个直线,可以使用一个数组表示,机器人每次可以向左或者向右移动一个位置,在规定的移动次数下,有多少种方法可以到达指定位置?

输入:N S A K
N: 这条路一共有多少位置可以移动
S: 机器人初始位置
A: 需要到达的目的地
K: 可以移动多少步
输出:ANS
ANS: 共有多少种移动方法
解法1:递归法

我们假设机器人当前所在的位置为 C,还可以移动M次,那么接下来的一步,机器人要么去到左边,要么去到右边

1 2 3 4 5 6
     
  C     A
剩余步数 K: 4

那么机器人接下来,要么向左移动到1位置,剩余步数为3,目的地不变;要么向右移动到3位置,剩余步数为3,目的地不变。那么就出现了递归调用。

因为每次机器人移动时候所要考虑的就是两件事情,

1.还有没有可以动的步数

2.往左还是往右

所以递归的方法体就可以出来了

/**
     * 机器人可以到达的方式
     * @param N 有多少可以走的位置
     * @param start 开始的位置
     * @param aim 到达的目的
     * @param K 剩余步数
     * @return 所有的组合
     */
    public static int ways(int N, int start, int aim, int K){
        
    }

参数选定了,就考虑方法体的具体细节

注意1: 如果机器人走到了边界,也就是1,或者6的位置,他就只能往反方向走

注意2: 方法的出口就是,当机器人可移动的步数为0之后,所在的位置,是否是目的地

那么递归方法体就是:

/**
     * 机器人可以到达的方式
     * @param N 有多少可以走的位置
     * @param start 开始的位置
     * @param aim 到达的目的
     * @param K 剩余步数
     * @return 所有的组合
*/
public static int process(int N, int start, int aim, int K){
  // 递归终止条件
  if (K == 0){
    return start == aim ? 1: 0;
  }
  // 如果在起点,只能往右走
  if (start == 0){
    return process(N, start+1, aim, K-1);
  }
  // 如果在终点,只能往左走
  if (start == N){
    return process(N, start-1, aim, K-1);
  }
  // 否则,往右往左都试一试
  return process(N, start-1, aim, K-1) + process(N, start+1, aim, K-1);
}

调用测试:

@Test
public void test1(){
  // 假如路径为下
  // 1 2 3 4 5 6
  // 初始在位置2,目的地达到6, 共可移动6步
  System.out.println(ways(4, 2, 4, 4));
}

结果:

3
解法2:动态规划

所谓的动态规划,可以理解为 把每次计算的过程都记录下来,再次使用到这次计算时候,可以直接在记录数据中拿到,而不需要再次计算了。

上述的递归解法中,因为在递归调用的过程中,会存在重复计算的过程,所以使用一个缓存表,记录每次的结果。

上述例子中,一直在变动的参数有两个

  1. 当前的位置
  2. 剩余可移动的步数

所以可以实例一个二维数组,记录 在 cur位置时候,剩余 step步数时候,返回的结果是什么样的?

因为机器人是从1开始的,为了迎合,所以二维数组多实例一行一列,初始值设为-1,如果是-1,就认为该递归方法体未被调用过

int[][] dp = new int[N+1][K+1];
for (int i = 0; i < N+1; i++) {
  for (int j = 0; j < K+1; j++) {
    dp[i][j] = -1;
  }
}

那么在每次调用的时候,方法中都夹带着这个缓存表,如果调用的方法已经被计算过了,就从缓存表里拿结果,如果没有,就计算。

那么就需要在开始加一个判断,是否该次计算已经执行过,也就是缓存表相对位置为-1时候,就是未被执行

/**
     *
     * 机器人可以到达的方式
     * @param N 有多少可以走的位置
     * @param start 开始的位置
     * @param aim 到达的目的
     * @param K 剩余步数
     * @return 所有的组合
*/
public static int process2(int N, int start, int aim, int K, int[][] dp){

  // 作为缓存,把每次[start][K]都放进去
  if (dp[start][K] != -1){
    return dp[start][K];
  }
  // 记录本次结果,因为要放进去缓冲表
  int ans = 0;
  // 就是正经的递归调用了
  // 递归终止条件
  if (K == 0){
    ans =  (start == aim ? 1: 0);
  }else if (start == 1){
    ans = process2(N, start+1, aim, K-1, dp);
  }else if (start == N){
    ans = process2(N, start-1, aim, K-1, dp);
  }else{
    ans = process2(N, start-1, aim, K-1, dp) + process2(N, start+1, aim, K-1, dp);
  }
  dp[start][K] = ans;
  return ans;
}

测试:

@Test
public void test1(){
  // 1 2 3 4 5 6
  // 在位置2,达到6, 共6步
  System.out.println(ways(4, 2, 4, 4));
}

public static int ways(int N, int start, int aim, int K){
  int[][] dp = new int[N+1][K+1];
  for (int i = 0; i < N+1; i++) {
    for (int j = 0; j < K+1; j++) {
      dp[i][j] = -1;
    }
  }
  return process2(N, start, aim, K, dp);
}
2.背包问题

假设有一个背包,容量为k,有n个物品,其重量和价值为w[i],v[i],把东西放进背包,如何拿到最有价值的组合

解法1:暴力递归法

同样,先考虑暴力递归的问题

假如我们需要把所有的组合都算一遍,那么先定义一下参数都有哪些?

可选的物品重量,可选的物品价值,背包容量

只有三个,那么主函数的参数列表就有了:

/**
     *
     * @param weight 物品重量
     * @param value 物品价值
     * @param capacity 背包容量
     * @return
*/
public static int bag(int[] weight, int[] value, int capacity){

}

那递归时候怎么做呢?

首先思考函数出口在哪里?

  1. 因为我们是递归选择物品,那么,如果选择到了最后一个商品,就没有东西选择了,直接返回0
  2. 如果背包容量没了,也可以作为函数出口

出口选择好了,那么我们需要构思递归方法体,按照特点,递归调用要朝着出口去

那么我们在方法体中增加一个index,认为是递归选择到了当前的物品,那么参数也有了

/**
     * 背包问题,当前考虑index号货物,index后所有货物都可以选择
     * @param weight 可以拿的物品重量
     * @param value 可以拿的物品价值
     * @param cap 背包剩余容量
     * @return
*/
public static int maxValue(int[] weight, int[] value, int index, int cap){
  // 函数出口
  if (cap < 0){
    return -1;
  }
  if (index == weight.length){
    return 0;
  }
  
  // 函数体
}

那么考虑方法体,在到了一个物品时候,有两种选择

  1. 选择该商品,减背包,加价值
  2. 不选择该商品,背包和价值不变,之间index+1

那么方法体就有了

/**
     * 背包问题,当前考虑index号货物,index后所有货物都可以选择
     * @param weight 可以拿的物品重量
     * @param value 可以拿的物品价值
     * @param cap 背包剩余容量
     * @return
*/
public static int maxValue(int[] weight, int[] value, int index, int cap){
  if (cap < 0){
    return -1;
  }
  if (index == weight.length){
    return 0;
  }
  // 有货,index位置有货
  // 两种选择,要 / 不要
  // 不选择当前商品
  int p1 = maxValue(weight, value, index+1, cap);
  // 选择当前商品
  int m = maxValue(weight, value, index+1, cap-weight[index]);
  int p2 = 0;
  // 如果选择后背包变成了负数,也就是背包不能选择这个商品了,那么不做处理
  if (m != -1) {
    p2 = value[index] + m;
  }
  return Math.max(p1, p2);
}

测试:

@Test
public void test2(){
  int[] w = {5, 2, 3, 6, 7};
  int[] v = {10, 5, 8, 2, 6};
  System.out.println(bag(w, v, 15));
}
2.动态规划

同样因为在上述递归过程中,有重复的计算问题,所以我们用一个缓存表,来存放每次的递归结果,那么这张缓存表该怎么设置?

因为在方法递归时候,只有两个参数是变换的

  1. 背包的剩余容量
  2. 当前的选择物品

确定了之后,那么改为动态规划,就是变成缓存表

int[][] dp = new int[weight.length+1][capacity+1];
for (int i = 0; i < weight.length + 1; i ++){
  for (int j = 0; j < capacity + 1; j ++){
    dp[i][j] = -2;
  }
}

写入缓存表时候:

/**
     * 背包问题,当前考虑index号货物,index后所有货物都可以选择
     * @param weight 可以拿的物品重量
     * @param value 可以拿的物品价值
     * @param cap 背包剩余容量
     * @return
*/
public static int maxValue2(int[] weight, int[] value, int index, int cap, int[][] dp){
  if (cap < 0){
    return -1;
  }
  if (index == weight.length){
    return 0;
  }
  if (dp[index][cap] != -2){
    return dp[index][cap];
  }
  int ans = 0;
  // 有货,index位置有货
  // 两种选择,要 / 不要
  int p1 = maxValue2(weight, value, index+1, cap, dp);
  int m = maxValue2(weight, value, index+1, cap-weight[index], dp);
  int p2 = 0;
  if (m != -1) {
    p2 = value[index] + m;
  }
  ans = Math.max(p1, p2);
  dp[index][cap] = ans;
  return ans;
}

测试:

@Test
public void test2(){
  int[] w = {5, 2, 3, 6, 7};
  int[] v = {10, 5, 8, 2, 6};
  System.out.println(bag(w, v, 15));
}


/**
     *
     * @param weight 物品重量
     * @param value 物品价值
     * @param capacity 背包容量
     * @return
*/
public static int bag(int[] weight, int[] value, int capacity){

  if (weight == null || weight == null || weight.length != value.length || weight.length == 0){
    return 0;
  }
  int[][] dp = new int[weight.length+1][capacity+1];
  for (int i = 0; i < weight.length + 1; i ++){
    for (int j = 0; j < capacity + 1; j ++){
      dp[i][j] = -2;
    }
  }

  // 尝试函数
  return maxValue2(weight, value, 0, capacity, dp);
}

你可能感兴趣的:(数据结构,算法,动态规划,java)