C++算法题解析：动态规划与STL应用实战

1. 题目背景与考察要点解析

这道来自3月12日机试的C++编程题序列（t88-t92）属于典型的算法与数据结构综合应用题。根据题号规律判断，这组题目很可能出自某高校研究生复试机试或大厂校招笔试环节，主要考察以下核心能力：

• STL容器的高级应用（特别是map/set的灵活使用）
• 动态规划思想的变种实现
• 图论算法的场景化应用
• 边界条件处理与代码鲁棒性

2. 题目详解与解题思路

2.1 t88：字符串模式匹配

问题描述：
给定主串S和模式串P，实现支持通配符"?"的匹配算法，其中"?"可匹配任意单个字符。

核心解法：

cpp复制bool isMatch(const string& s, const string& p) {
    int m = s.size(), n = p.size();
    vector<vector<bool>> dp(m+1, vector<bool>(n+1, false));
    dp[0][0] = true;
    
    for (int j = 1; j <= n; ++j) {
        if (p[j-1] == '?') {
            for (int i = 1; i <= m; ++i) {
                dp[i][j] = dp[i-1][j-1];
            }
        } else {
            for (int i = 1; i <= m; ++i) {
                dp[i][j] = (s[i-1] == p[j-1]) && dp[i-1][j-1];
            }
        }
    }
    return dp[m][n];
}

优化技巧：

• 使用滚动数组可将空间复杂度从O(mn)降至O(n)
• 提前终止条件：当模式串剩余字符全是"?"时可直接返回true

2.2 t89：二叉树最大路径和

问题描述：
给定非空二叉树，寻找路径（节点序列）使得各节点值之和最大，路径至少包含一个节点且不必经过根节点。

关键实现：

cpp复制int maxPathSum(TreeNode* root) {
    int maxSum = INT_MIN;
    dfs(root, maxSum);
    return maxSum;
}

int dfs(TreeNode* node, int &maxSum) {
    if (!node) return 0;
    int left = max(0, dfs(node->left, maxSum));
    int right = max(0, dfs(node->right, maxSum));
    maxSum = max(maxSum, left + right + node->val);
    return max(left, right) + node->val;
}

注意事项：

• 处理节点值为负的情况时，需要与0比较取max
• 全局变量maxSum的更新时机要放在后序遍历位置

3. 进阶题目解析

3.1 t90：带限制条件的最短路径

问题场景：
在有权图中，求从起点到终点的最短路径，且路径必须经过指定的中间节点集合。

解法框架：

1. 使用Dijkstra算法预处理各关键点到其他点的最短距离
2. 状态压缩DP处理必经节点的访问顺序
3. 时间复杂度：O(k*(ElogV) + k!*k)，其中k为必经节点数

核心代码段：

cpp复制int shortestPathWithKeys(vector<vector<int>>& graph, vector<int>& mustPass) {
    // Step 1: Precompute all pairs shortest paths
    vector<vector<int>> dist = floydWarshall(graph);
    
    // Step 2: DP state transition
    int k = mustPass.size();
    vector<vector<int>> dp(1<<k, vector<int>(k, INT_MAX));
    
    // Initialization
    for (int i = 0; i < k; ++i) {
        dp[1<<i][i] = dist[start][mustPass[i]];
    }
    
    // State transition
    for (int mask = 1; mask < (1<<k); ++mask) {
        for (int last = 0; last < k; ++last) {
            if (!(mask & (1<<last))) continue;
            for (int next = 0; next < k; ++next) {
                if (mask & (1<<next)) continue;
                int new_mask = mask | (1<<next);
                dp[new_mask][next] = min(dp[new_mask][next], 
                    dp[mask][last] + dist[mustPass[last]][mustPass[next]]);
            }
        }
    }
    
    // Combine with end point
    int final_mask = (1<<k)-1;
    int res = INT_MAX;
    for (int i = 0; i < k; ++i) {
        res = min(res, dp[final_mask][i] + dist[mustPass[i]][end]);
    }
    return res;
}

3.2 t91：数据流的中位数

设计要求：
实现支持以下两种操作的数据结构：

• addNum(num)：添加数字
• findMedian()：返回当前中位数

双堆解法：

cpp复制class MedianFinder {
    priority_queue<int> maxHeap; // 存储较小的一半
    priority_queue<int, vector<int>, greater<int>> minHeap; // 存储较大的一半
    
public:
    void addNum(int num) {
        maxHeap.push(num);
        minHeap.push(maxHeap.top());
        maxHeap.pop();
        
        if (minHeap.size() > maxHeap.size()) {
            maxHeap.push(minHeap.top());
            minHeap.pop();
        }
    }
    
    double findMedian() {
        return maxHeap.size() > minHeap.size() ? 
               maxHeap.top() : 
               (maxHeap.top() + minHeap.top()) / 2.0;
    }
};

复杂度分析：

• 插入操作：O(logN)
• 查询操作：O(1)
• 空间复杂度：O(N)

4. 调试技巧与常见错误

4.1 边界条件检查清单

1. 空输入处理
2. 整数溢出判断（特别是累加/乘法场景）
3. 指针/迭代器有效性验证
4. 容器越界访问预防
5. 浮点数精度控制

4.2 典型错误案例

错误示例1：未处理负权边

cpp复制// 错误：直接使用Dijkstra处理负权图
vector<int> dist(n, INT_MAX);
dist[start] = 0;
priority_queue<pair<int,int>> pq;
pq.push({0, start});

while (!pq.empty()) {
    auto [d, u] = pq.top(); pq.pop();
    if (d > dist[u]) continue;
    for (auto &[v, w] : graph[u]) {
        if (dist[v] > dist[u] + w) {  // 当w为负数时可能出错
            dist[v] = dist[u] + w;
            pq.push({dist[v], v});
        }
    }
}

修正方案：改用SPFA或Bellman-Ford算法

错误示例2：STL容器迭代器失效

cpp复制vector<int> nums = {1,2,3,4};
for (auto it = nums.begin(); it != nums.end(); ++it) {
    if (*it % 2 == 0) {
        nums.erase(it);  // 错误：erase后it失效
    }
}

正确写法：

cpp复制for (auto it = nums.begin(); it != nums.end(); ) {
    if (*it % 2 == 0) {
        it = nums.erase(it);
    } else {
        ++it;
    }
}

5. 性能优化策略

5.1 时间复杂度优化技巧

1. 预处理思想：

   • 前缀和数组（区间求和O(1)）
   • 稀疏表（RMQ问题）
   • 欧拉序+LCA（树查询优化）

2. 空间换时间：

   • 记忆化搜索
   • 查表法（如素数判定）
   • 位压缩状态

5.2 实际案例优化

原始代码（O(n^2)）：

cpp复制int maxArea(vector<int>& height) {
    int res = 0;
    for (int i = 0; i < height.size(); ++i) {
        for (int j = i + 1; j < height.size(); ++j) {
            res = max(res, min(height[i], height[j]) * (j - i));
        }
    }
    return res;
}

优化后（O(n)双指针）：

cpp复制int maxArea(vector<int>& height) {
    int res = 0, l = 0, r = height.size() - 1;
    while (l < r) {
        res = max(res, min(height[l], height[r]) * (r - l));
        height[l] < height[r] ? ++l : --r;
    }
    return res;
}

6. 测试用例设计

6.1 通用测试模板

cpp复制void test() {
    struct TestCase {
        string name;
        vector<int> input;
        int expected;
    };
    
    vector<TestCase> tests = {
        {"empty", {}, 0},
        {"single", {1}, 1},
        {"all_negative", {-1,-2,-3}, -1},
        {"mixed", {-2,1,-3,4,-1,2,1,-5,4}, 6},
        {"large_input", vector<int>(10000, 1), 10000}
    };
    
    for (auto &t : tests) {
        int actual = solution(t.input);
        assert(actual == t.expected && t.name.c_str());
    }
}

6.2 特殊场景覆盖

1. 整数边界值（INT_MAX/MIN）
2. 重复元素序列
3. 完全有序/逆序输入
4. 随机大数据量测试
5. 内存泄漏检测（对于指针操作）

7. 工程实践建议

7.1 代码规范要点

1. 变量命名：

   • 循环计数器：i,j,k（简单循环），idx/pos（需要语义时）
   • 临时变量：tmp/temp
   • 结果存储：res/result/ret

2. 函数设计：

   • 单一职责原则
   • 参数不超过5个
   • 明确const修饰

3. 异常处理：

   • 非法输入提前返回
   • 资源获取即初始化(RAII)

7.2 调试辅助技巧

1. 条件断点设置：

   cpp复制// 在循环内设置条件断点（gdb命令）
   break if i == 42
   

2. 内存诊断工具：

   • Valgrind（内存泄漏检测）
   • AddressSanitizer（越界访问）

3. 性能分析：

   bash复制perf stat ./program
   gprof ./program gmon.out > analysis.txt
   

8. 扩展学习资源

8.1 推荐书目

1. 《算法导论》 - 经典算法理论
2. 《Effective C++》 - 工程实践指南
3. 《剑指Offer》 - 面试题型精讲
4. 《STL源码剖析》 - 底层实现解析

8.2 在线练习平台

1. LeetCode（分类题库）
2. Codeforces（竞赛训练）
3. NowCoder（企业真题）
4. AcWing（算法竞赛进阶）