LeetCode精选56-100题解：动态规划与二分查找实战

1. LeetCode精选56-100题解：算法核心思路与实战技巧

作为一名长期奋战在算法刷题一线的开发者，我深知掌握经典算法题目的重要性。今天我将分享LeetCode第56到100题中的精选题目解析，涵盖动态规划、二分查找、双指针、栈等高频考点。这些题目不仅面试中经常出现，更是提升编程思维能力的绝佳材料。

1.1 动态规划经典：最长重复子数组

问题描述：给定两个整数数组nums1和nums2，返回两个数组中公共的、长度最长的子数组的长度。

这道题是典型的动态规划问题。我们先来看一个具体例子：

python复制输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是[3,2,1]

DP五部曲分析：

1. DP数组定义：dp[i][j]表示以nums1[i-1]和nums2[j-1]结尾的最长公共子数组长度
2. 递推公式：当nums1[i-1] == nums2[j-1]时，dp[i][j] = dp[i-1][j-1] + 1
3. 初始化：dp[0][0]初始化为0，其他元素默认0
4. 遍历顺序：外层遍历nums1，内层遍历nums2
5. 举例验证：通过手动计算小规模案例验证正确性

优化技巧：

• 使用一维DP数组可以优化空间复杂度到O(n)
• 在遍历过程中记录最大值，避免最后再遍历整个DP表

cpp复制class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size()+1, vector<int>(nums2.size()+1, 0));
        int res = 0;
        for(int i=1; i<=nums1.size(); i++){
            for(int j=1; j<=nums2.size(); j++){
                if(nums1[i-1] == nums2[j-1]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                    res = max(res, dp[i][j]);
                }
            }
        }
        return res;
    }
};

1.2 二分查找系列：从基础到变种

二分查找是算法中的基础但极其重要的技术，下面我们看几个典型变种。

1.2.1 基本二分查找（704题）

最基础的二分查找，适合作为模板记忆：

cpp复制int search(vector<int>& nums, int target) {
    int left = 0, right = nums.size()-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;
    }
    return -1;
}

1.2.2 寻找边界（34题）

在排序数组中查找元素的第一个和最后一个位置，需要两次二分查找：

cpp复制vector<int> searchRange(vector<int>& nums, int target) {
    if(nums.empty()) return {-1,-1};
    
    // 找左边界
    int l = 0, r = nums.size()-1;
    while(l < r){
        int mid = l + (r-l)/2;
        if(nums[mid] >= target) r = mid;
        else l = mid+1;
    }
    if(nums[r] != target) return {-1,-1};
    
    // 找右边界
    int L = r;
    l = 0, r = nums.size()-1;
    while(l < r){
        int mid = l + (r-l+1)/2;
        if(nums[mid] <= target) l = mid;
        else r = mid-1;
    }
    return {L, r};
}

1.2.3 旋转数组中的最小值（153题）

旋转排序数组的二分查找需要特别注意边界条件：

cpp复制int findMin(vector<int>& nums) {
    int left = 0, right = nums.size()-1;
    while(left < right){
        int mid = left + (right-left)/2;
        if(nums[mid] > nums[right]) left = mid+1;
        else right = mid;
    }
    return nums[right];
}

二分查找的常见陷阱：

1. 循环条件是left <= right还是left < right？
2. 中间值计算使用(left+right)/2可能导致整数溢出
3. 更新边界时是mid还是mid±1？
4. 如何处理重复元素的情况？

1.3 双指针技巧实战

双指针是解决数组/字符串问题的利器，下面看几个典型应用。

1.3.1 两数之和II（167题）

在有序数组中找出两个数使它们的和等于目标值：

cpp复制vector<int> twoSum(vector<int>& numbers, int target) {
    int left = 0, right = numbers.size()-1;
    while(left < right){
        int sum = numbers[left] + numbers[right];
        if(sum == target) return {left+1, right+1};
        else if(sum < target) left++;
        else right--;
    }
    return {};
}

1.3.2 判断子序列（392题）

判断字符串s是否为t的子序列：

cpp复制bool isSubsequence(string s, string t) {
    int i = 0, j = 0;
    while(i < s.size() && j < t.size()){
        if(s[i] == t[j]) i++;
        j++;
    }
    return i == s.size();
}

双指针的三种常见模式：

1. 同向快慢指针（如删除重复元素）
2. 相向指针（如两数之和）
3. 滑动窗口（如最小覆盖子串）

1.4 栈与队列的巧妙应用

栈和队列虽然是基础数据结构，但能解决许多看似复杂的问题。

1.4.1 最小栈（155题）

设计一个支持push、pop、top操作，并能常数时间检索最小元素的栈：

cpp复制class MinStack {
    stack<int> data;
    stack<int> min_stack;
public:
    MinStack() { min_stack.push(INT_MAX); }
    
    void push(int val) {
        data.push(val);
        min_stack.push(min(min_stack.top(), val));
    }
    
    void pop() {
        data.pop();
        min_stack.pop();
    }
    
    int top() { return data.top(); }
    
    int getMin() { return min_stack.top(); }
};

1.4.2 棒球比赛（682题）

根据特殊规则计算棒球比赛得分：

cpp复制int calPoints(vector<string>& ops) {
    vector<int> scores;
    for(auto& op : ops){
        if(op == "C") scores.pop_back();
        else if(op == "D") scores.push_back(scores.back()*2);
        else if(op == "+") scores.push_back(scores.back() + scores[scores.size()-2]);
        else scores.push_back(stoi(op));
    }
    return accumulate(scores.begin(), scores.end(), 0);
}

栈的典型应用场景：

1. 括号匹配问题
2. 表达式求值
3. 函数调用栈模拟
4. 浏览器的前进后退功能

1.5 字符串处理技巧

字符串处理是算法面试中的常客，下面看几个典型问题。

1.5.1 简化路径（71题）

简化Unix风格的绝对路径：

cpp复制string simplifyPath(string path) {
    vector<string> dirs;
    stringstream ss(path);
    string dir;
    while(getline(ss, dir, '/')){
        if(dir.empty() || dir == ".") continue;
        if(dir == ".." && !dirs.empty()) dirs.pop_back();
        else if(dir != "..") dirs.push_back(dir);
    }
    string res;
    for(auto& d : dirs) res += "/" + d;
    return res.empty() ? "/" : res;
}

1.5.2 字符串解码（394题）

解码形如k[encoded_string]的字符串：

cpp复制string decodeString(string s) {
    stack<string> chars;
    stack<int> nums;
    string res;
    int num = 0;
    for(char c : s){
        if(isdigit(c)) num = num*10 + (c-'0');
        else if(isalpha(c)) res += c;
        else if(c == '['){
            chars.push(res);
            nums.push(num);
            res = "";
            num = 0;
        }
        else if(c == ']'){
            string tmp = res;
            res = chars.top();
            chars.pop();
            int repeat = nums.top();
            nums.pop();
            while(repeat--) res += tmp;
        }
    }
    return res;
}

字符串处理的注意事项：

1. 边界条件处理（空字符串、单字符等）
2. 特殊字符的转义处理
3. 字符串拼接的性能优化（使用stringstream或reserve预分配空间）
4. 编码问题（特别是涉及Unicode时）

1.6 算法优化与调试技巧

在实际刷题过程中，我总结了一些实用的优化和调试技巧：

1. 测试用例设计：

   • 常规情况
   • 边界情况（空输入、极值等）
   • 特殊模式（如全相同元素、升序/降序排列等）

2. 调试方法：

   • 打印关键变量值
   • 使用小规模测试用例手动模拟
   • 对比暴力解法的结果

3. 性能优化：

   • 分析时间复杂度瓶颈
   • 减少不必要的计算和存储
   • 利用位运算等底层优化

4. 代码风格：

   • 有意义的变量命名
   • 适当的注释
   • 模块化设计（将复杂逻辑拆分为函数）

以二分查找为例，分享一个调试模板：

cpp复制int binarySearch(vector<int>& nums, int target) {
    int left = 0, right = nums.size()-1;
    while(left <= right){
        int mid = left + (right-left)/2;
        cout << "left=" << left << ", right=" << right 
             << ", mid=" << mid << ", nums[mid]=" << nums[mid] << endl;
        if(nums[mid] == target) return mid;
        else if(nums[mid] < target) left = mid+1;
        else right = mid-1;
    }
    return -1;
}

1.7 高频考题分类总结

根据我的面试经验，以下题型出现频率极高：

1. 数组/字符串处理：

   • 双指针技巧
   • 滑动窗口
   • 前缀和/差分数组

2. 链表操作：

   • 反转链表
   • 环检测
   • 合并链表

3. 树结构：

   • 遍历（前序、中序、后序）
   • 深度/广度优先搜索
   • 二叉搜索树操作

4. 动态规划：

   • 背包问题
   • 路径问题
   • 子序列问题

5. 图算法：

   • 拓扑排序
   • 最短路径
   • 并查集

建议按照专题进行系统性的学习和练习，每个专题掌握3-5道典型题目及其变种。

1.8 刷题路线建议

根据我的经验，推荐以下刷题路线：

1. 基础阶段（2-4周）：

   • 掌握基本数据结构（数组、链表、栈、队列、哈希表）
   • 学习基础算法（排序、二分查找、递归）
   • 完成LeetCode Easy难度题目50-100道

2. 提高阶段（4-8周）：

   • 学习高级数据结构（堆、树、图）
   • 掌握经典算法（DFS/BFS、动态规划、贪心算法）
   • 完成LeetCode Medium难度题目100-150道

3. 冲刺阶段（2-4周）：

   • 专题突破（重点攻克薄弱环节）
   • 模拟面试（限时完成题目）
   • 精选题解（研究最优解和多种解法）

4. 面试前（1-2周）：

   • 复习高频考题
   • 整理个人代码库
   • 准备算法题讲解思路

记住，刷题质量比数量更重要。每道题目都应该做到：

• 理解问题本质
• 掌握多种解法
• 分析时间/空间复杂度
• 总结解题套路

1.9 常见错误与避坑指南

在算法学习和面试过程中，我踩过不少坑，总结出以下常见错误：

1. 边界条件处理不当：

   • 数组越界访问
   • 空输入处理
   • 整数溢出问题

2. 复杂度分析错误：

   • 低估嵌套循环的复杂度
   • 忽视数据结构操作的成本（如哈希表冲突）
   • 误判递归的时空复杂度

3. 代码实现问题：

   • 变量初始化遗漏
   • 循环条件错误
   • 递归终止条件缺失

4. 面试表现问题：

   • 不沟通思考过程
   • 不测试代码就提交
   • 不处理特殊情况

建议在平时练习中养成良好习惯：

• 先理清思路再写代码
• 编写测试用例验证代码
• 做好时间管理（Easy题15分钟内，Medium题30分钟内）
• 总结每道题的收获和教训

1.10 资源推荐与学习建议

最后分享一些我认为优质的学习资源：

1. 书籍推荐：

   • 《算法导论》（理论基础）
   • 《剑指Offer》（面试必备）
   • 《算法图解》（入门友好）

2. 在线资源：

   • LeetCode官方题解
   • GeeksforGeeks算法教程
   • 算法可视化网站（如visualgo.net）

3. 学习建议：

   • 建立个人代码库，记录优秀解法
   • 参与编程竞赛（如LeetCode周赛）
   • 组建学习小组互相review代码
   • 定期复习已完成的题目

算法能力的提升需要时间和坚持，希望这些经验分享能帮助你在刷题路上少走弯路。记住，每解决一个问题都是对自己能力的一次提升，保持耐心和热情，你一定能看到进步！