二分查找与动态规划算法精解-代码聚汇网

二分查找与动态规划算法精解

陈小严·2026-06-02·阅读 40 GEO检测（免费）

二分查找动态规划算法

|难度：普通|阅读约 30 分钟

1. 二分查找算法精解

二分查找是算法面试中的常客，也是程序员必须掌握的基础算法之一。它的核心思想是通过不断缩小搜索范围来快速定位目标元素。让我们深入分析几个典型的二分查找变种问题。

1.1 基础二分查找实现

搜索插入位置（LeetCode 35）是二分查找最基础的应用场景。给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

java复制class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;  // 防止整数溢出
            
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;  // 目标在右半部分
            } else {
                right = mid - 1; // 目标在左半部分
            }
        }
        
        // 循环结束时，left 的位置就是 target 应该插入的位置
        return left;
    }
}

关键点解析：

循环条件是 left <= right，确保所有元素都被检查

mid = left + (right - left)/2 的写法可以避免整数溢出

当 nums[mid] < target 时，说明目标在右半部分，因此 left = mid + 1

当循环结束时，left 的位置就是目标值应该插入的位置

1.2 二分查找变种：旋转数组搜索

搜索旋转排序数组（LeetCode 33）是二分查找的一个经典变种。虽然数组被旋转过，但我们可以利用二分查找的特性来解决这个问题。

java复制class Solution {
    public int search(int[] nums, int target) {
        int left=0, right=nums.length-1;
        if(nums[left]==target) return left;
        if(nums[right]==target) return right;
        while(left<right){
            if(nums[left]==target) return left;
            if(nums[right]==target) return right;
            int mid=(left+right)/2;
            if(nums[mid]==target) return mid;
            //如果左边有序
            if(nums[left]<=nums[mid]){
                //查看target是否在有序的之中
                if(target>=nums[left]&&target<nums[mid]){
                    //如果在，那么更新right
                    right=mid-1;
                }else{
                    //target不在有序的之中，那么更新待测数组
                    left=mid+1;
                }
            }else{
                //右边有序
                if(target>nums[mid]&&target<=nums[right]){
                    left=mid+1;
                }else{
                    right=mid-1;
                }
            }
        }
        return -1;
    }
}

解题思路：

虽然数组被旋转过，但mid左右两侧的其中一侧一定是有序的

如果左侧有序：查看target是否在左侧，如果在，更新到左侧，否则，更新到右侧

如果右侧有序：查看target是否在右侧，如果在，更新到右侧，否则，更新到左侧

1.3 二分查找变种：寻找旋转点

寻找旋转排序数组中的最小值（LeetCode 153）是另一个常见的二分查找变种问题。

java复制class Solution {
    public int findMin(int[] nums) {
        int left=0, right=nums.length-1;
        while(left<right){
            int mid=(left+right)/2;
            //mid>right，表明右侧为乱序，最小值在右侧
            if(nums[mid]>nums[right]){
                //这里可以+1，因为mid已经比right大了，所以直接跳过mid
                left=mid+1;
            }
            //mid<right，表明左侧为乱序，最小值在左侧
            if(nums[mid]<nums[right]){
                //这里不可+1，因为mid可能为最小值
                right=mid;
            }
        }
        //最后left一定会等于right，此时所处的位置就是min的位置
        return nums[left];
    }
}

关键点：

虽然数组旋转过，但是一定有一侧有序，而最小值一定在另一侧无序的当中

如果左侧有序：更新到右侧

如果右侧有序：更新到左侧

最后left一定会等于right，此时所处的位置就是最小值的位置

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 栈与队列的高级应用

栈和队列是算法中常用的数据结构，掌握它们的应用场景和变种用法对解决实际问题至关重要。

2.1 栈的基本应用：括号匹配

有效的括号（LeetCode 20）是栈的经典应用场景。我们需要检查字符串中的括号是否有效配对。

java复制class Solution {
    public boolean isValid(String s) {
        Deque<Character> stack=new ArrayDeque<>();;
        for(int i=0;i<s.length();i++){
            //如果栈为空，那么压入一个元素
            if(stack.isEmpty()){
                //优化条件，不加也行
                if(s.charAt(i)==')'||s.charAt(i)==']'||s.charAt(i)=='}') return false;
                stack.push(s.charAt(i));
                continue;
            }
            //取出栈顶元素，与下一个元素匹配
            char top=stack.pop();
            //如果匹配为一对，则出栈
            if((top=='('&&s.charAt(i)==')')||(top=='['&&s.charAt(i)==']')||(top=='{'&&s.charAt(i)=='}')){
                continue;
            }else{
                //如果不为一对，则新元素入栈
                stack.push(top);
                stack.push(s.charAt(i));
            }
        }
        //如果最终栈中有残留元素，表明无法完美匹配，则不有效括号
        return stack.isEmpty();
    }
}

实现要点：

使用栈来存储遇到的左括号

遇到右括号时，检查是否与栈顶的左括号匹配

如果匹配则弹出栈顶元素，否则返回false

最后检查栈是否为空，空则表示所有括号都匹配成功

2.2 栈的高级应用：字符串解码

字符串解码（LeetCode 394）是一个更复杂的栈应用问题，需要处理嵌套的编码字符串。

java复制class Solution {
    public String decodeString(String s) {
        Deque<Character> stack=new ArrayDeque<>();
        for(int i=0;i<s.length();i++){
            int sum=0;
            StringBuilder res=new StringBuilder();
            //一直压栈，压到]出现
            if(s.charAt(i)!=']'){
                stack.push(s.charAt(i));
                continue;
            }
            //base：作为后面sum的进位辅助
            int base=1;
            //如果为字母，那么构造字符串res
            while(!stack.isEmpty()&&stack.peek()>='a'&&stack.peek()<='z'){
                res.insert(0, stack.pop());
            }
            //如果为[，那么直接弹出
            if(!stack.isEmpty()&&stack.peek()=='['){
                stack.pop();
            }
            //如果为数字，那么构造复制次数sum
            while(!stack.isEmpty()&&stack.peek()>='0'&&stack.peek()<='9'){
                int num=stack.pop()-'0';
                sum=sum+num*base;
                base*=10;
            }
            //拼接字符串，并重新压入栈，比如此时拼接好abcabc，还需要继续压入栈
            for(int cnt=0;cnt<sum;cnt++){
                for(int j=0;j<res.length();j++){
                    stack.push(res.charAt(j));
                }
            }
        }
        //拼接栈中的最终结果，返回
        StringBuilder result = new StringBuilder();
        while (!stack.isEmpty()) {
            result.insert(0, stack.pop());
        }
        return result.toString();
    }
}

解题思路：

使用栈作为主要数据结构

遇到 ] 时触发解码操作

将栈顶的字符组合成字符串，并根据前面的数字进行重复

然后再压回栈中

最后将栈中所有字符拼接成最终结果

2.3 单调栈应用：每日温度

每日温度（LeetCode 739）是单调栈的典型应用，需要找到每一天之后更高温度出现的天数。

java复制class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        //构建等长的结果数组
        int[] res=new int[temperatures.length];
        //栈中存放一个用数组实现的键值对，键是气温的索引，值是具体气温
        Deque<int[]> stack=new ArrayDeque<>();
        //遍历气温数组
        for(int i=0;i<temperatures.length;i++){
            //第一次开头，栈为空，压入一个元素
            if(stack.isEmpty()){
                stack.push(new int[]{i, temperatures[i]});
                continue;
            }
            //不断弹出栈顶的元素，与待压入的元素比较，只要栈顶元素气温更低，就表明找到了未来某天的高气温
            //注意while循环中必须只能由一个pop，多了就会导致多弹出。其余的用peek
            while(!stack.isEmpty()&&stack.peek()[1]<temperatures[i]){
                //在结果数组的相同位置写入两个气温相隔的天数
                res[stack.peek()[0]]=i-stack.pop()[0];
            }
            //压入新的气温
            stack.push(new int[]{i, temperatures[i]});
        }
        return res;
    }
}

实现要点：

维护一个单调递减的栈

当遇到更高的温度时，就弹出并"结算"栈中所有比它低的温度

计算当前温度与栈中温度的天数差，存入结果数组

将当前温度压入栈中

3. 堆（优先队列）的应用

堆（优先队列）是一种特殊的树形数据结构，常用于解决Top K问题等场景。

3.1 堆的基本应用：数组中的第K个最大元素

数组中的第K个最大元素（LeetCode 215）是堆的经典应用场景。

java复制class Solution {
    public int findKthLargest(int[] nums, int k) {
        //初始化最小堆，长度为k
        PriorityQueue<Integer> heap=new PriorityQueue<>(k);
        for(int i=0;i<nums.length;i++){
            //压入前k个元素
            if(i<k) {
                heap.offer(nums[i]);
                continue;
            }
            //如果当前元素大于堆顶元素，换入
            if(nums[i]>heap.peek()){
                heap.poll();
                heap.offer(nums[i]);
            }
        }
        //返回堆顶元素即为第k大元素
        return heap.peek();
    }
}

实现思路：

维护一个容量为k的最小堆

堆顶元素是堆中最小的元素，也是当前的第k大元素

遍历数组，如果元素大于堆顶元素，则替换堆顶元素

最后堆顶元素就是第k大元素

3.2 堆的高级应用：前K个高频元素

前K个高频元素（LeetCode 347）需要结合哈希表和堆来解决。

java复制class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //建立哈希表
        Map<Integer, Integer> map=new HashMap<>();
        //小堆，排序方式为比较数组的第二个元素，即频率
        PriorityQueue<int[]> heap=new PriorityQueue<>(k, (a, b)->a[1]-b[1]);
        //把频率放入哈希表，如果数字存在，则频率加1，如果不存在则放入新数字，频率设为1
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        //把哈希表中的前k个元素放入堆，然后遍历剩下的元素，如果比堆顶（最小的元素）大，则替换进入，如果小，则跳过
        int cnt=0;
        for(Map.Entry<Integer, Integer> entry : map.entrySet()){
            if(cnt<k){
                heap.offer(new int[]{entry.getKey(), entry.getValue()});
                cnt++;
                continue;
            }
            int num=heap.peek()[1];
            if(num<entry.getValue()){
                heap.poll();
                heap.offer(new int[]{entry.getKey(), entry.getValue()});
            }
        }
        //最终留存在堆中的元素就是频率最高的前k个元素
        int[] res=new int[k];
        int i=0;
        while(!heap.isEmpty()){
            res[i]=heap.poll()[0];
            i++;
        }
        return res;
    }
}

解题步骤：

使用哈希表统计每个数字的出现频率

创建容量为k的最小堆，按频率排序

遍历哈希表，维护堆的大小为k，保留频率最高的k个元素

最后将堆中的元素输出为结果数组

4. 动态规划专题

动态规划是算法设计中的重要方法，适用于有重叠子问题和最优子结构性质的问题。

4.1 基础DP问题：爬楼梯

爬楼梯（LeetCode 70）是最经典的动态规划入门问题。

java复制class Solution {
    public int climbStairs(int n) {
        //构建状态表
        int[] dp=new int[n+1];
        //特殊情况
        if(n<=2){
            return n;
        }
        //初始化状态表
        dp[0]=0;
        dp[1]=1;
        dp[2]=2;
        //填表
        for(int i=3;i<=n;i++){
            //状态转移方程
            dp[i]=dp[i-2]+dp[i-1];
        }
        return dp[n];
    }
}

动态规划思路：

定义dp[i]为爬到第i阶楼梯的方法数

初始化：dp[1]=1, dp[2]=2

状态转移方程：dp[i] = dp[i-1] + dp[i-2]

因为每次可以爬1或2阶，所以当前阶的方法数等于前一阶和前两阶方法数之和

4.2 二维DP问题：最小路径和

最小路径和（LeetCode 64）是二维动态规划的典型问题。

java复制class Solution {
    public int minPathSum(int[][] grid) {
        //构建dp数组
        int[][] dp=new int[grid.length][grid[0].length];
        //初始化，0，0位置只能是grid本身
        dp[0][0]=grid[0][0];
        //填表，状态转换方程为 dp[i][j]=Math.min(dp[i-1][j], dp[i][j-1])+grid[i][j];
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(i==0&&j==0) continue;
                if(i==0){
                    dp[i][j]= dp[i][j-1]+grid[i][j];
                    continue;
                }
                if(j==0){
                    dp[i][j]=dp[i-1][j]+grid[i][j];
                    continue;
                }
                dp[i][j]=Math.min(dp[i-1][j], dp[i][j-1])+grid[i][j];
            }
        }
        //返回
        return dp[dp.length-1][dp[0].length-1];
    }
}

解题要点：

dp(i,j)的值为grid(i,j) + min(上面的，左面的)

状态转移方程为 dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j]

需要特殊处理第一行和第一列的边界情况

4.3 字符串DP问题：编辑距离

编辑距离（LeetCode 72）是字符串处理中经典的动态规划问题。

java复制class Solution {
    public int minDistance(String word1, String word2) {
        //构建dp数组
        int [][] dp=new int[word1.length()+1][word2.length()+1];
        //初始化第一行和第一列
        for(int i=0;i<dp.length;i++){
            dp[i][0]=i;
        }
        for(int i=0;i<dp[0].length;i++){
            dp[0][i]=i;
        }
        //填表
        for(int i=1;i<dp.length;i++){
            for(int j=1;j<dp[0].length;j++){
                //两字符相等
                if(word1.charAt(i-1)==word2.charAt(j-1)){
                    //状态转移方程1
                    dp[i][j]=dp[i-1][j-1];
                    //不相等
                }else{
                    //状态转移方程2
                    dp[i][j]=Math.min(dp[i-1][j-1]+1, Math.min(dp[i-1][j]+1, 1+dp[i][j-1]));
                }
            }
        }
        //返回
        return dp[dp.length-1][dp[0].length-1];
    }
}

算法解析：

dp[i][j]表示word1的前i个字符转换成word2的前j个字符所需的最小操作数

初始化：空字符串转换为任意长度字符串需要相应次数的插入操作

状态转移：

如果字符相等，则dp[i][j] = dp[i-1][j-1]

如果字符不等，则取替换、删除、插入三种操作的最小值加1

5. 数组与字符串处理技巧

数组和字符串是算法题中最常见的数据结构，掌握它们的处理技巧至关重要。

5.1 双指针技巧：颜色分类

颜色分类（LeetCode 75）是经典的荷兰国旗问题，可以使用三指针法高效解决。

java复制class Solution {
    public void sortColors(int[] nums) {
        //初始化三指针
        int left=0, right=nums.length-1, ptr=0;
        //循环条件ptr<=right
        while(ptr<=right){
            //ptr=1：ptr++，continue
            if(nums[ptr]==1){
                ptr++;
                continue;
            } 
            //ptr=2：交换，right--，不continue继续检查ptr当前值
            if(nums[ptr]==2){
                swap(ptr, right, nums);
                right--;
            }
            //ptr=0：交换，ptr++，left++，continue
            if(nums[ptr]==0){
                swap(ptr, left, nums);
                ptr++;
                left++;
                continue;
            } 
        }
    }

    //交换方法
    public void swap(int a, int b, int[] nums){
        int x=nums[a];
        nums[a]=nums[b];
        nums[b]=x;
    }
}

三指针法解析：

left指针：指向最后一个0的下一个位置

right指针：指向第一个2的前一个位置

ptr指针：当前遍历的指针

当nums[ptr]==0时，与left交换，left和ptr都右移

当nums[ptr]==2时，与right交换，right左移

当nums[ptr]==1时，ptr右移

5.2 数组技巧：下一个排列

下一个排列（LeetCode 31）需要理解排列的生成规律。

java复制class Solution {
    public void nextPermutation(int[] nums) {
        //遍历指针
        int ptr=nums.length-2;
        //找拐点
        while(ptr>=0){
            if(nums[ptr+1]<=nums[ptr]){
                ptr--;
                continue;
            }else{
                break;
            }
        }
        //如果没找到拐点，表明这个数组是一个类似"4，3，2，1"这个样的单调形式，那么直接sort
        if(ptr==-1){
            Arrays.sort(nums);
            return;
        }
        //找到右侧比这个数字大的最小数字，交换
        for(int i=nums.length-1;i>=0;i--){
            if(nums[i]>nums[ptr]){
                swap(ptr, i, nums);
                break;
            }
        }
        //反转右侧，因为右侧一定是一个单调递减，现在将其变成单调递增
        int left=ptr+1;
        int right=nums.length-1;
        while(left<right){
            swap(left, right, nums);
            left++;
            right--;
        }
    }

    //抽取的交换方法
    public void swap(int a, int b, int[] nums){
        int temp=nums[a];
        nums[a]=nums[b];
        nums[b]=temp;
    }
}

算法步骤：

从后向前查找第一个相邻升序的元素对 (i,j)

如果找不到这样的元素对，说明整个数组是降序排列的，直接反转整个数组

在j及之后的元素中，从后向前查找第一个大于nums[i]的元素nums[k]

交换nums[i]和nums[k]

反转j及之后的元素

5.3 快慢指针技巧：寻找重复数

寻找重复数（LeetCode 287）可以转化为链表环检测问题。

java复制class Solution {
    public int findDuplicate(int[] nums) {
        int slow=0, fast=0;
        //数组版"判断有无环"
        while(true){
            slow=nums[slow];
            fast=nums[nums[fast]];
            if(slow==fast) break;
        }
        //找到环的入口点
        slow = 0;
        while(slow != fast){
            slow = nums[slow];
            fast = nums[fast];
        }
        return slow;
    }
}

解题思路：

将数组视为链表，数组值表示下一个节点的索引

使用快慢指针法检测环

找到环的入口点，即为重复数字

这种方法时间复杂度O(n)，空间复杂度O(1)

6. 贪心算法应用

贪心算法在解决某些最优化问题时非常有效，它通过局部最优选择来达到全局最优。

6.1 跳跃游戏系列

跳跃游戏（LeetCode 55）和跳跃游戏II（LeetCode 45）是贪心算法的典型应用。

跳跃游戏实现：

java复制class Solution {
    public boolean canJump(int[] nums) {
        //最远可达位置
        int maxReach=nums[0];
        for(int i=0;i<nums.length;i++){
            //如果该位置无法到达，表明剩下所有位置也都无法到达，直接返回false
            if(i>maxReach) return false;
            //不断更新最大位置
            maxReach=Math.max(maxReach, nums[i]+i);
        }
        return true;
    }
}

跳跃游戏II实现：

java复制class Solution {
    public int jump(int[] nums) {
        int jump=0;
        //当前跳的最远距离
        int currentJump=0;
        //下一跳的最远距离（最有潜力的距离）
        int maxCover=nums[0];
        //遍历所有元素
        for(int i=0;i<nums.length-1;i++){
            //更新下一跳最远距离
            maxCover=Math.max(maxCover, i+nums[i]);
            //到达当前跳的最远距离，必须进行下一跳了
            if(i==currentJump){
                //进行下一跳
                jump++;
                //更新当前最远距离
                currentJump=maxCover;
                //如果当前最远距离已经包含了终点，意味着这一跳已经能跳到终点，直接结束
                if(currentJump>=nums.length-1){
                    break;
                }
            }
        }
        return jump;
    }
}

贪心策略分析：

跳跃游戏：维护一个最远可达位置，遍历数组时更新这个值

如果当前位置超过了最远可达位置，说明无法到达终点

跳跃游戏II：维护当前跳跃范围和下一跳的最远距离

当到达当前跳跃边界时，增加跳跃次数并更新跳跃范围

6.2 划分字母区间

划分字母区间（LeetCode 763）需要贪心地尽可能划分更多的片段。

java复制class Solution {
    public List<Integer> partitionLabels(String s) {
        //哈希表存入所有元素的最后一个出现的位置
        Map<Character, Integer> map=new HashMap<>();
        for(int i=0;i<s.length();i++){
            map.put(s.charAt(i), i);
        }

        //设置right为当前片段的尾，left为当前元素的头
        List<Integer> res=new ArrayList<>();
        int right=0;
        int left=0;
        //遍历数组
        for(int i=0;i<s.length();i++){
            //不断更新尾
            right=Math.max(right, map.get(s.charAt(i)));
            //如果走到尾，表明后续片段中不再存在当前片段的任何一个元素
            if(i==right){
                //计算长度，加入结果
                res.add(right+1-left);
                //设置left为新片段头
                left=i+1;
            }
        }
        return res;
    }
}

算法步骤：

统计每个字符最后出现的位置

遍历字符串，维护当前片段的结束位置

当当前位置等于当前片段的结束位置时，表示可以划分一个片段

记录片段长度，并开始新的片段

7. 位运算技巧

位运算在某些问题中可以提供非常高效的解决方案，掌握常见的位运算技巧很有必要。

7.1 只出现一次的数字

只出现一次的数字（LeetCode 136）可以利用异或运算的特性高效解决。

java复制class Solution {
    public int singleNumber(int[] nums) {
        //创建哈希表
        Map<Integer, Integer> map=new HashMap<>();
        //遍历，出现一次放入哈希，出现两次移除出哈希
        for(int i=0;i<nums.length;i++){
            if(!map.containsKey(nums[i])){
                map.put(nums[i], 1);
            }else{
                map.remove(nums[i]);
            }
        }
        //拿出唯一的哈希键
        Map.Entry<Integer, Integer> entry = map.entrySet().iterator().next();
        Integer key = entry.getKey();
        return key;
    }
}

位运算优化版：
java复制public int singleNumber(int[] nums) {
    int result = 0;
    for (int num : nums) {
        result ^= num;
    }
    return result;
}
异或运算特性：

任何数和0异或都是它本身

任何数和自身异或都是0

异或运算满足交换律和结合律

7.2 多数元素

多数元素（LeetCode 169）可以使用摩尔投票法高效解决。

java复制class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[(nums.length)/2];
    }
}

摩尔投票法实现：
java复制public int majorityElement(int[] nums) {
    int count = 0;
    Integer candidate = null;
    
    for (int num : nums) {
        if (count == 0) {
            candidate = num;
        }
        count += (num == candidate) ? 1 : -1;
    }
    
    return candidate;
}
摩尔投票法要点：

维护一个候选人和计数器

遇到相同元素计数器加1，不同则减1

计数器为0时更换候选人

最后剩下的候选人就是多数元素

8. 动态规划进阶问题

8.1 完全平方数

完全平方数（LeetCode 279）是典型的动态规划问题。

java复制class Solution {
    public int numSquares(int n) {
        //初始化dp数组，每个元素存储的是构成当前索引值的最小平方数个数
        int dp[]=new int[n+1];
        //填表
        for(int i=1;i<n+1;i++){
            //先按照最坏情况，即构成当前索引的平方数全为1，i/1=i
            dp[i]=i;
            //尝试减去比i小的平方数j*j，然后跳转到i-j*j的索引位置，查看平方数最小个数+1，与当前的个数相比，取其小，更新
            for(int j=0;j*j<=i;j++){
                dp[i]=Math.min(dp[i], dp[i-j*j]+1);
            }
        }
        //最后返回构成n的最少平方数个数
        return dp[n];
    }
}

动态规划思路：

dp[i]表示组成数字i所需的最少完全平方数个数

初始化：最坏情况是全部由1组成，即dp[i]=i

状态转移：对于每个i，尝试所有可能的j*j，取最小值

dp[i] = min(dp[i], dp[i-jj]+1) 对所有jj <= i

8.2 零钱兑换

零钱兑换（LeetCode 322）是另一个经典的动态规划问题。

java复制class Solution {
    public int coinChange(int[] coins, int amount) {
        //构建dp数组
        int[] dp=new int[amount+1];
        //初始化，dp0=0，其他都设为amount+1，即不可达
        dp[0]=0;
        for(int i=1;i<amount+1;i++){
            dp[i]=amount+1;
        }
        //循环填表
        for(int i=0;i<=amount;i++){
            //逐个尝试硬币金额
            for(int j=0;j<coins.length;j++){
                //判断哪种更小，状态转换方程：dp[i]=Math.min(dp[i], dp[i-coins[j]]+1)
                if(coins[j]<=i) dp[i]=Math.min(dp[i], dp[i-coins[j]]+1);
            }
        }
        //返回最终结果，如果最终仍是不可达，返回-1
        if(dp[amount]==amount+1) return -1;
        return dp[amount];
    }
}

算法解析：

dp[i]表示组成金额i所需的最少硬币数

初始化：dp[0]=0，其他为amount+1（表示不可达）

状态转移：对于每个金额i，尝试所有可能的硬币面额

dp[i] = min(dp[i], dp[i-coin]+1) 对所有coin <= i

最后检查dp[amount]是否被更新，否则返回-1

8.3 单词拆分

单词拆分（LeetCode 139）是字符串处理与动态规划的结合。

java复制class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        //将列表转换为哈希set，所有的collection类型都能转换，转换方法就是Set<type> set=new HashSet<>(target object)
        Set<String> wordSet = new HashSet<>(wordDict);
        //构建dp数组，元素代表0到当前索引的字符串能否被拆分
        boolean[] dp=new boolean[s.length()+1];
        //初始化，dp[0]为空，能被拆分，直接为true
        dp[0]=true;
        for(int i=1;i<s.length()+1;i++){
            dp[i]=false;
        }
        //填表
        for(int i=0;i<s.length()+1;i++){
            for(int j=0;j<i;j++){
                //将单词分为三段区间，0-j；j-i，i-结尾。如果0-j可拆，并且j-i也可拆，那么表明0-i可拆，即dpi=true
                if (dp[j] && wordSet.contains(s.substring(j, i))) {
                    dp[i] = true;
                    break;  // 找到一种拆分即可
                }
            }
        }        
        return dp[s.length()];
    }
}

动态规划思路：

dp[i]表示字符串前i个字符能否被拆分成字典中的单词

初始化：dp[0]=true（空字符串可以被拆分）

状态转移：对于每个位置i，检查所有j < i，如果dp[j]为true且s.substring(j,i)在字典中，则dp[i]=true

最终返回dp[s.length()]的值

9. 数组与矩阵问题

9.1 杨辉三角

杨辉三角（LeetCode 118）是经典的二维数组问题。

java复制class Solution {
        public List<List<Integer>> generate(int numRows) {
            //创建返回列表
            List<List<Integer>> res=new ArrayList<>();
            //构建第一行并加入
            List<Integer> first=new ArrayList<>();
            first.add(1);
            res.add(first);
            //构建其他行
            for(int i=1;i<numRows;i++){
                //取出前一行
                List<Integer> lastList=res.get(res.size()-1);
                List<Integer> row=new ArrayList<>();
                //挨个加入元素
                for(int j=0;j<=lastList.size();j++){
                    //加入前后元素
                    if(j==0||j==lastList.size()){
                        row.add(1);
                        continue;
                    }  
                    //状态转换方程
                    row.add(lastList.get(j-1)+lastList.get(j));
                }
                //加入返回列表
                res.add(row);
            }
            return res;
        }
    }

算法要点：

每一行的第一个和最后一个元素都是1

其他元素等于上一行相邻两个元素之和

使用动态规划的思想逐行构建

时间复杂度O(n^2)，空间复杂度O(n^2)

9.2 乘积最大子数组

乘积最大子数组（LeetCode 152）需要考虑负负得正的情况。

java复制class Solution {
    public int maxProduct(int[] nums) {
        //构建两条数组min和max，构建min是因为需要考虑
        int[] max=new int[nums.length];
        int[] min=new int[nums.length];
        //初始化头元素
        max[0]=nums[0];
        min[0]=nums[0];
        //填表
        for(int i=1;i<nums.length;i++){
            int num=nums[i];
            //状态转换方程：cur=max(当前位置，当前位置*max[上一个]，当前位置*min[上一个]
            max[i]=Math.max(num, Math.max(max[i-1]*num, num*min[i-1]));
            min[i]=Math.min(num, Math.min(min[i-1]*num, num*max[i-1]));
        }
        //查询结果并返回
        int res=max[0];
        for(int i=0;i<max.length;i++){
            res=Math.max(max[i], res);
        }
        return res;
    }
}

解题思路：

因为需要考虑负负得正的情况，所以需要同时维护当前最大值和最小值

对于每个元素，计算它与前一个最大值和最小值的乘积

新的最大值是当前元素、当前元素乘以前一个最大值、当前元素乘以前一个最小值三者中的最大者

新的最小值同理取三者中的最小者

最后遍历整个数组找出最大的乘积值

9.3 分割等和子集

分割等和子集（LeetCode 416）可以转化为背包问题。

java复制class Solution {
    public boolean canPartition(int[] nums) {
        //判断和是否为奇
        int sum=0;
        for(int