半月算法小结/2021-04-16

1.动态规划与贪心算法的区别与联系

• 1.联系
  • 都是一种推导算法
  • 都是分解成子问题来求解，都需要具有最优子结构
• 2.区别
  *1. 贪心：每一步的最优解一定包含上一步的最优解，上一步之前的最优解则不作保留。动态规划：全局最优解中一定包含某个局部最优解，但不一定包含前一个局部最优解，因此需要记录之前的所有的局部最优解

  • 贪心：1779. 找到最近的有相同 X 或 Y 坐标的点

  • 动态规划：213. 打家劫舍 II

• 2.贪心：如果把所有的子问题看成一棵树的话，贪心从根出发，每次向下遍历最优子树即可（通常这个“最优”都是基于当前情况下显而易见的“最优”）；这样的话，就不需要知道一个节点的所有子树情况，于是构不成一棵完整的树。动态规划：动态规划则自底向上，从叶子向根，构造子问题的解，对每一个子树的根，求出下面每一个叶子的值，最后得到一棵完整的树，并且最终选择其中的最优值作为自身的值，得到答案
• 3.根据以上两条可以知道，贪心不能保证求得的最后解是最佳的，一般复杂度低；而动态规划本质是穷举法，可以保证结果是最佳的，复杂度高。
• 4.代码对比

class Solution {

    public int nearestValidPoint(int x, int y, int[][] points) {
    int lab=-1;//记录哈曼顿距离距离最小的下标
    int MinDistance=2147483647;
    for(int i=0;i<points.length;i++){
        if(points[i][0]==x||points[i][1]==y){
            if(MinDistance>(Math.abs(x-points[i][0])+Math.abs(y-points[i][1])))
            {
                MinDistance=(Math.abs(x-points[i][0])+Math.abs(y-points[i][1]));
                lab=i;
            }
        }
    }
    return lab;
    }
}

class Solution {
    public int rob(int[] nums) {//动态规划
    //分成俩个队列进行比较
    int n=nums.length-1;
    if(n==0)
        return nums[0];
    if(n==1)
        return Math.max(nums[0],nums[1]);
    int MaxMonwy[][] = new int[n+1][2];
    int MAX=0;
    //一队为0到n-1
    MaxMonwy[0][0]=0;//不偷为0
    MaxMonwy[0][1]=nums[0];//只有一家偷则为该家金额数
    MaxMonwy[1][0]=nums[0];
    MaxMonwy[1][1]=nums[1];
    for(int i=2;i<=n-1;i++){
    //偷与不偷的最优解
        MaxMonwy[i][0]=Math.max(MaxMonwy[i-1][0],MaxMonwy[i-1][1]);//不偷第i家的最优解
        MaxMonwy[i][1]=Math.max(MaxMonwy[i-2][0],MaxMonwy[i-2][1])+nums[i];//偷第i家的最优解
    }
    int t; 
    t=(MaxMonwy[n-1][0]>MaxMonwy[n-1][1]?MaxMonwy[n-1][0]:MaxMonwy[n-1][1]);
    MAX=MAX>t?MAX:t;
    //另一队为1到n
    MaxMonwy[1][0]=0;//不偷为0
    MaxMonwy[1][1]=nums[1];//只有一家偷则为该家金额数
    MaxMonwy[2][0]=nums[1];
    MaxMonwy[2][1]=nums[2];
    for(int i=3;i<=n;i++){
        MaxMonwy[i][0]=Math.max(MaxMonwy[i-1][0],MaxMonwy[i-1][1]);//不偷第i家的最优解
        MaxMonwy[i][1]=Math.max(MaxMonwy[i-2][0],MaxMonwy[i-2][1])+nums[i];//偷第i家的最优解
    }
    t=MaxMonwy[n][0]>MaxMonwy[n][1]?MaxMonwy[n][0]:MaxMonwy[n][1];
    MAX=MAX>t?MAX:t;
    return MAX;  
    }
}

2.递归

1. 分治
2. 回溯
   可参考文章