leetcode 二

问题

1. 无重复字符的最长子串

2. 三角形最小路径和(动态规划 *)

3. 查找指定值返回下标

4. 集合相邻重复的元素去重

5. 最长递增子序列

6. 最大子数组和

7. 最长公共子序列

8. 动态规划是什么?
   利用历史记录，来避免我们的重复计算。而这些历史记录，我们得需要一些变量来保存，一般是用一维数组或者二维数组来保存
   1. 设计状态
   2. 写出状态转移方程
   3. 设定初始状态
   4. 执行状态转移
   5. 返回最终的解

1 无重复字符的最长子串（3）

题目链接

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:
输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

示例 2:
输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。

示例 3:
输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

public class LengthOfLongestSubstring {

    public static int lengthOfLongestSubstring(String s) {
        HashMap<Character, Integer> map = new HashMap<>();
        int max = 0, start = 0;
        for (int end = 0; end < s.length(); end++) {
            char ch = s.charAt(end);
            if (map.containsKey(ch)) {//若含有重复的，start右移
                start = Math.max(map.get(ch) + 1, start);
            }
            //end - start + 1
            max = Math.max(max, end - start + 1);
            //重复的字符会覆盖之前的
            map.put(ch, end);
        }
        return max;
    }

    public static void main(String[] args) {
        String a = "aabbcdef";

        int i = lengthOfLongestSubstring(a);
        System.out.println(i);
    }
}

2 三角形最小路径和（120）

题目链接
解题视频链接
给定一个三角形 triangle ，找出自顶向下的最小路径和。

输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
输出：11
解释：如下面简图所示：
—2
–3 4
-6 5 7
4 1 8 3
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

动态规划

    /*三角形最短路径
    [2]
    [3,4]
    [6,5,7]
    [4,1,8,3]
	*/
    /*
    从上往下
     */
    public static int minimumTotal(List<List<Integer>> triangle) {
        int len = triangle.size();
        // 新建二维数组
        int[][] dp = new int[len][len];
        //边界
        dp[0][0] = triangle.get(0).get(0);
        for (int i = 1; i < len; i++) {
            dp[i][0] = dp[i - 1][0] + triangle.get(i).get(0);
            for (int j = 1; j < i; j++) {
                dp[i][j] = Math.min(dp[i - 1][j - 1], dp[i - 1][j]) + triangle.get(i).get(j);
            }
            dp[i][i] = dp[i - 1][i - 1] + triangle.get(i).get(i);
        }
        //三角形最后一行的起始位置
        int ans = dp[len - 1][0];
        //遍历最后一行所有位置比较
        for (int i = 0; i < len; i++) {
            ans = Math.min(ans, dp[len - 1][i]);
        }
        return ans;
    }

优化 从下往上

    /*
    从下往上
     */
    public static int minimumTotal2(List<List<Integer>> triangle) {
        int n = triangle.size();
        int[][] dp = new int[n + 1][n + 1];
        for (int i = n - 1; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                dp[i][j] = Math.min(dp[i + 1][j], dp[i + 1][j + 1]) + triangle.get(i).get(j);
            }
        }
        return dp[0][0];
    }

优化 一维数组

    /*
    减小空间复杂度
    一维数组
    */
    public static int minimumTotal3(List<List<Integer>> triangle) {
        int n = triangle.size();
        int[] dp = new int[n + 1];
        for (int i = n - 1; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
            }
        }
        return dp[0];
    }

测试结果

    //triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
    public static void main(String[] args) {
        ArrayList<List<Integer>> lists = new ArrayList<>();
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<Integer> list4 = new ArrayList<>();

        list1.add(2);
        Collections.addAll(list2, 3, 4);
        Collections.addAll(list3, 6, 5, 7);
        Collections.addAll(list4, 4, 1, 8, 3);

        Collections.addAll(lists, list1, list2, list3, list4);
        System.out.println(lists);

        int i = minimumTotal3(lists);
        System.out.println(i);
    }

3 查找指定值返回下标（34，35）

35 搜索插入位置

题目链接
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。

二分

    //二分搜索出现的数
    public static int searchInsert(int[] nums, int target) {
        int l=0;
        int r=nums.length-1;
        while (l<=r){
            int mid=(l+r)/2;
            if (nums[mid]==target){
                return mid;
            }else if (nums[mid]>target){
                r=mid-1;
            }else {
                l=mid+1;
            }
        }
//        return target<=nums[l]?l:l+1;
        return l;
    }

34. 在排序数组中查找元素的第一个和最后一个位置

题目链接

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。

4 集合相邻重复的元素去重

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        Collections.addAll(list, 1,1,2,2,2,3,3,1,1,2,2);
        System.out.println(list);

        int l=0;
        for (int i = 1; i < list.size(); i++) {
            if (list.get(l)==list.get(i)){
                list.remove(i);
                i--;
            }else {
                l++;
            }
        }
        System.out.println(list);
    }

5 最长递增子序列（300）

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

		//测试数组
        int[] a = {10, 9, 2, 5, 3, 7, 101, 18};	//4
        int[] b = {0, 3, 1, 6, 2, 2, 7};       	//4
        int[] c = {0, 1, 0, 3, 2, 3};           //4
        int[] d = {1, 3, 6, 7, 9, 4, 10, 5, 6}; //6

1 动态规划

    public static int method01(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int len = nums.length;
        //记录升序的个数
        int[] tmp = new int[len];
        int res = 0;

        for (int i = 0; i < len; i++) {
            //内层循环，确保升序 满足nums[j] < nums[i] 的向tmp中记录
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    tmp[i] = Math.max(tmp[i], tmp[j] + 1);
                }
            }
            res = Math.max(res, tmp[i]);
        }
        return res + 1;//初始是从0开始记录的，所以结果+1

    }

6 最大子数组和（53）

最大子数组和 — 题目链接
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

6.1 贪心

若当前指针所指元素之前的和小于0，则丢弃当前元素之前的数列

    public int maxSubArray2(int[] nums) {
        int curSum=nums[0];
        int maxSum=curSum;
        for (int i = 1; i < nums.length; i++) {
            //若当前指针所指向 元素之前 的和 小于0，则丢弃当前元素之前的数列
            curSum=Math.max(nums[i],curSum+nums[i]);
            //将当前值与最大值比较，取最大值
            maxSum=Math.max(curSum,maxSum);
        }
        return maxSum;
    }

6.2 动态规划

若前一个元素大于0，则将其加到当前元素上

    public int maxSubArray(int[] nums) {
        int len=nums.length;
        int[] dp=new int[len];
        dp[0]=nums[0];

        for (int i = 1; i < len; i++) {
            if (dp[i-1]>0){
                dp[i]=dp[i-1]+nums[i];
            }else {
                dp[i]=nums[i];
            }
        }
        int res=dp[0];
        for (int i = 0; i < len; i++) {
            res=Math.max(res,dp[i]);
        }
        return res;
    }   

优化，滑动窗口更新区间

    public int maxSubArray2(int[] nums) {
        int pre = 0, maxAns = nums[0];
        for (int x : nums) {
            pre = Math.max(pre + x, x);
            maxAns = Math.max(maxAns, pre);
        }
        return maxAns;
    }

6.3 分治(分段树)

7 最长公共子序列（1143）

最长公共子序列 — 题目链接

题解链接

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

示例 1：
输入：text1 = “abcde”, text2 = “ace”
输出：3
解释：最长公共子序列是 “ace” ，它的长度为 3 。

示例 2：
输入：text1 = “abc”, text2 = “abc”
输出：3
解释：最长公共子序列是 “abc” ，它的长度为 3 。

示例 3：
输入：text1 = “abc”, text2 = “def”
输出：0
解释：两个字符串没有公共子序列，返回 0 。

动态规划

状态转移方程为：

    public int longestCommonSubsequence(String text1, String text2) {
        int m=text1.length(),n=text2.length();
        int[][] f=new int[m+1][n+1];
        for (int i = 1; i <=n; i++) {
            for (int j = 1; j <=m ; j++) {
                if (text1.charAt(i-1)==text2.charAt(j-1)){
                    f[i][j]=f[i-1][j-1]+1;
                }else {
                    f[i][j]=Math.max(f[i-1][j],f[i][j-1]);
                }
            }
        }
        return f[m][n];
    }