递归类型与一维数组的动态规划的题笔记

来源：https://www.bilibili.com/video/BV12W411v7rd?from=search&seid=17601861999891282066

问题的演变：

第一个问题：以斐波那契数列为例，当使用递归的方式计算时，递归公式如下：时间复杂度是O(2^n)。

许多数据会重复的计算，比如计算fib(7)会计算fib(6)和 fib(5),fib(5)会计算fib(4),fib(3)，，，

动态规划的改进：

从fib(1),fib(2),fib(3)...一直计算到要求的fib(n)并把它们存到数组中,在使用公式计算时，直接从数组中取要用的数据，时间复杂度是O(n).

引用：https://www.bilibili.com/video/BV18x411V7fm?from=search&seid=17601861999891282066

第二个问题：找出数组中任意不相邻数组的最大值。数据只要是不相邻的就可以，选几个都行。

以选不选当前这个数来分类讨论

递归出口：

Python代码：递归方式

动态规划非递归写法：

第三种题：找出数组（数组中都是正整数）中有没有数加起来和为给出的数值值的，有就打印true，反打印false

还是讨论选不选

Python递归实现：

动态规划非递归实现：

1、“括号生成””

给出n对括号，请编写一个函数来生成所有的由n对括号组成的合法组合。

例如，给出n=3，解集为：

"((()))", "(()())", "(())()", "()(())", "()()()"

出错的地方，递归时候使用栈，字符串这种，从内层的递归出来之后，还需要把数据恢复。尽量用字符串吧，有的时候不知道如何恢复到递归前的数据，递归时最好不要用下面这种：

 left--;
 s+="(";
dfs(left,right,s);

这种也别用：因为left还是被修改了

dfs(--left,right,s+"(");

最好用这种：

dfs(left-1,right,s+"(");

完整代码：

package dp;

import java.util.ArrayList;


public class Dp2 {
    static ArrayList<String> list = new ArrayList<>();
    public static void main(String[] args) {
        int n = 3;
        list = generateParenthesis(n);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static ArrayList<String> generateParenthesis(int n) {
        // write code here

        String s = "";
        dfs(n, n, s);

        return list;
    }

    public static void dfs(int left, int right, String s ) {
      if(left==0 &&right==0){
          list.add(s);
      }
      if(left>0){
//          left--;
//          s+="(";
          dfs(left-1,right,s+"(");
      }
      if(left<right){
//          right--;
//          s+=")";
          dfs(left,right-1,s+")");
      }
    }
}

题目描述

给定一个数组arr，返回子数组的最大累加和

例如，arr = [1, -2, 3, 5, -2, 6, -1]，所有子数组中，[3, 5, -2, 6]可以累加出最大的和12，所以返回12.

[要求]

时间复杂度为O(n），空间复杂度为O(1)

思路：主要就是选不选的问题，只不过，这个是，前面的数组内容选不选的问题，resArr表示点评数组，注意arr数组中的i-1跟resArr数组中的i对应，选就是resArr[i-1]+arr[i-1]，不选就是arr[i-1]。

 /**
     * max sum of the subarray
     * @param arr int整型一维数组 the array
     * @return int整型
     */
    public int maxsumofSubarray (int[] arr) {
        // write code here
        int[] resArr = new int[arr.length+1];
        for(int i=1;i<resArr.length;i++){
            resArr[i] = Math.max(arr[i-1],resArr[i-1]+arr[i-1]);
        }
        return resArr[resArr.length-1];
    }

2、“分糖果”

有N个小朋友站在一排，每个小朋友都有一个评分

你现在要按以下的规则给孩子们分糖果：

• 每个小朋友至少要分得一颗糖果
• 分数高的小朋友要他比旁边得分低的小朋友分得的糖果多

你最少要分发多少颗糖果？

思路：首先给数组arr赋初值1，每个人都是1，然后依次从左往右，把左边比当前节点小的值的arr[i]修改了，然后从右往左，把左边比当前大，但是arr中数据不合规定的值改了。

package dp;

import java.util.Arrays;

public class Fentangguo {
    public static void main(String[] args) {
        int[] scores = {2,1};
        System.out.println(candy(scores));
    }
    public static int candy (int[] ratings) {
        // write code here
        int res = 0;
        int[] arr = new int[ratings.length];
        Arrays.fill(arr,1);
        for (int i = 1; i < arr.length; i++) {
            if(ratings[i-1]<ratings[i]){
                arr[i] = arr[i-1]+1;
            }
        }
        for (int i = arr.length-1; i >= 1; i--) {
            if(ratings[i]<ratings[i-1] && arr[i]>=arr[i-1]){
                arr[i-1] = arr[i]+1;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            res  += arr[i];
        }
        return res;
    }
}