力扣题2022.10.1

今天刷了三道题，用了两个多小时，时间成本还是有点大。之后还是一天刷两道题比较合适，留下更多的时间做一些更多价值的事情。

1 力扣题5:最长回文字串

1.1 题目描述

给你一个字符串 s，找到 s 中最长的回文子串

1.2 解题思路

1.2.1 暴力模拟

直接二重循环模拟

1.2.2 动态规划

动态规划的关键在于记忆和状态转移方程，而最长回文字串很明显存在记忆的规律在里面，具体而言，si…sj为回文子串，则只需判断si-1是否等于sj+1，即可判断出si-1…sj+1是否为回文子串

1.3 代码实现

1.3.1 暴力模拟

  public static boolean isHuiwen(String str) {
        int n = str.length();
        boolean result = true;
        for (int i=0; i<=n/2; i++) {
            if (str.charAt(i)!=str.charAt(n-i-1)) {
                result = false;
                break;
            }
        }
        return result;
    }

    public String longestPalindrome(String s) {
        int n = s.length();
        String result = "";
        for (int i=0; i<n; i++) {
            for (int j=i; j<n; j++) {
                String pivot = s.substring(i,j+1);
                if (isHuiwen(pivot))
                    result = pivot.length()>result.length()?pivot:result;
            }
        }
        return result; 
    }

1.3.2 动态规划

public String longestPalindrome(String s) {
int len = s.length();
if (len < 2) {
return s;
}

int maxLen = 1;
int begin = 0;
// dp[i][j] 表示 s[i..j] 是否是回文串
boolean[][] dp = new boolean[len][len];
// 初始化：所有长度为 1 的子串都是回文串
for (int i = 0; i < len; i++) {
    dp[i][i] = true;
}

char[] charArray = s.toCharArray();
// 递推开始
// 先枚举子串长度
for (int L = 2; L <= len; L++) {
    // 枚举左边界，左边界的上限设置可以宽松一些
    for (int i = 0; i < len; i++) {
        // 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
        int j = L + i - 1;
        // 如果右边界越界，就可以退出当前循环
        if (j >= len) {
            break;
        }

        if (charArray[i] != charArray[j]) {
            dp[i][j] = false;
        } else {
            if (j - i < 3) {
                dp[i][j] = true;
            } else {
                dp[i][j] = dp[i + 1][j - 1];
            }
        }

        // 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
        if (dp[i][j] && j - i + 1 > maxLen) {
            maxLen = j - i + 1;
            begin = i;
        }
    }
}
return s.substring(begin, begin + maxLen);
}

2 力扣题11:盛最多的水

2.1 题目描述

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 返回容器可以储存的最大水量。 说明：你不能倾斜容器。

2.2 解题思路

2.2.1 暴力模拟

直接二重循环模拟

2.2.2 最优贪心

这个场景里隐藏着一个最优贪心规律，用双指针化二重循环为一重循环。先开始设两个指针，分别初始为最左位置和最右位置。之后找值较小的那个指针移动一个位置，比较，不断重复直至指针重合。可以自己证明这种方法是最优贪心。

2.3 代码实现

2.3.1 暴力模拟

  public int maxArea(int[] height) {
        int result = 0;
        for (int i=0; i<height.length-1; i++) {
            for (int j=i+1; j<height.length; j++) {
                int pivot = (j-i)*(height[i]>height[j]?height[j]:height[i]);
                result = pivot>result?pivot:result;
            }
        }
        return result;
    }

2.3.2 最优贪心

// 最优贪心,双指针
        public int maxArea(int[] height) {
        int result = 0;
        int left = 0;
        int right = height.length-1;
        while (left!=right) {
            int pivot = (right-left)*(height[left]>height[right]?height[right]:height[left]);
            result = pivot>result?pivot:result;
            if (height[left]>height[right])
                right -= 1;
            else
                left += 1;
        }
        return result;
    }

3 力扣题15:三数之和

3.1 题目描述

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k
且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请 你返回所有和为 0
且不重复的三元组。 注意：答案中不可以包含重复的三元组。

3.2 解题思路

3.2.1 模拟+逆向

可以先用哈希表存数组中每个值出现的次数，并将k的值作为一个已知条件，从而用两重循环解决问题。但这样有一个弊端，边界信息考虑的因素很多并且难以处理不重复三元组问题。在代码实现时采用的是对已有解集合进行遍历从而防止重复，然而最后还是超时了。

3.2.1 排序+双指针

先对数组进行排序，从而天然地消除了不重复的问题。之后依然利用排序的规律，j从左边开始，k只需从右边开始即可，大大缩小搜索空间，化三重循环为二重循环。

3.3 代码实现

3.3.1 模拟+逆向

  public List<List<Integer>> threeSum(int[] nums) {
        HashMap<Integer,Integer> hashMap = new HashMap<>();
        List<List<Integer>> result = new ArrayList<>();
        for (int i=0; i<nums.length; i++) {
            if (hashMap.containsKey(nums[i]))
                hashMap.put(nums[i],hashMap.get(nums[i])+1);
            else
                hashMap.put(nums[i],1);
        }
        for (int i=0; i<nums.length-1; i++) {
            for (int j=i+1; j<nums.length; j++) {
                int res = -(nums[i]+nums[j]);
                boolean repetition = false;
                boolean get = false;
                if (nums[i]==0&&nums[j]==0) {
                    if(hashMap.get(res)>2)
                        get = true;
                }
                else if (res==nums[i]||res==nums[j]) {
                    if (hashMap.containsKey(res) && hashMap.get(res)>1) 
                        get = true;
                }
                else if(hashMap.containsKey(res))
                    get = true;
                if (get) {
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[i]);list.add(nums[j]);list.add(res);
                    boolean isValue = true;
                    for (int k=0; k<result.size(); k++) {
                        List<Integer> temp = result.get(k);
                        if (list.contains(temp.get(0)) && list.contains(temp.get(1)) && 
                            list.contains(temp.get(2))) {
                                if (temp.get(0)==0&&temp.get(1)==0&&temp.get(2)==0) {
                                    if (list.get(0)==0&&list.get(1)==0&&list.get(2)==0) {
                                        isValue = false;
                                        break;
                                    }
                                } else {
                                    isValue = false;
                                    break;
                                }
                        }
                    }
                    if (isValue)
                        result.add(list);
                }
            }
        }
        return result;
    }

3.3.2 排序+双指针

public List<List<Integer>> threeSum(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        // 枚举 a
        for (int first = 0; first < n; ++first) {
            // 需要和上一次枚举的数不相同
            if (first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            // c 对应的指针初始指向数组的最右端
            int third = n - 1;
            int target = -nums[first];
            // 枚举 b
            for (int second = first + 1; second < n; ++second) {
                // 需要和上一次枚举的数不相同
                if (second > first + 1 && nums[second] == nums[second - 1]) {
                    continue;
                }
                // 需要保证 b 的指针在 c 的指针的左侧
                while (second < third && nums[second] + nums[third] > target) {
                    --third;
                }
                // 如果指针重合，随着 b 后续的增加
                // 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                    List<Integer> list = new ArrayList<Integer>();
                    list.add(nums[first]);
                    list.add(nums[second]);
                    list.add(nums[third]);
                    ans.add(list);
                }
            }
        }
        return ans;
    }