算法设计与分析实验指导

文章目录

算法设计与分析实验指导
- 1. 快速排序及第k小数
- - 1.1 快速排序
  - 1.1.1 Implementation 1
  - 1.1.2 算法特性分析
  - 1.1.3 Improvement 1: 降低空间复杂度——Tail Call
  - 1.1.3 Improvement 2:避免最坏情况——随机基准数
  - 1.2 第k小数
  - - 1.2.1 Implementation 1: 基于快排
  - 1.2.2 Implementation 2: 基于堆排序
  - 1.3 正确性验证
  - - 1.3.1 题目：[215. 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/)
    - 1.3.2 基于快排的实现
    - 1.3.3 基于堆排序的实现
- 2. 棋盘覆盖问题
- - 2.1 思路分析
  - 2.2 代码
  - 2.3 测试数据
- 3. 背包问题
- - 3.1 0-1背包问题
  - - 3.1.1 思路分析
    - 3.1.2 动态规划
    - 3.1.3 空间优化
  - 3.2 背包问题
  - - 3.2.1 题目描述
    - 3.2.2 思路分析
    - 3.2.3 代码实现
- 4.照亮山景
- - 4.1 思路分析
  - 4.2 代码实现
  - 4.3 时间复杂度分析
- 5. 汽车加油问题
- - 5.1 思路分析
  - 5.2 代码实现
  - 5.3 时间复杂度分析
- 6. 最长公共子序列
- - 6.1 思路分析
  - 6.2 代码实现
  - 6.3 LeetCode测试结果
  - 6.4 空间优化
- 7. 皇后看守
- - 7.1 思路分析
  - 7.2 代码实现

1. 快速排序及第k小数

1.1 快速排序

1.1.1 Implementation 1

核心代码如下：

int partition(vector<int> &nums, int l, int r) {int i = l;int j = r;while (i < j) {while (i < j && nums[j] >= nums[l]) j--;while (i < j && nums[i] <= nums[l]) i++;swap(nums[i], nums[j]);}swap(nums[i], nums[l]);return i;
}void quickSort(vector<int> &nums, int l, int r) {if (l >= r) return;int i = partition(nums, l, r);quickSort(nums, l, i - 1);quickSort(nums, i + 1, r);
}

1.1.2 算法特性分析

时间复杂度：

最佳Ω(NlogN) ：最佳情况下，每轮哨兵划分操作将数组划分为等长度的两个子数组；哨兵划分操作为线性时间复杂度 O(N)；递归轮数共 O(logN) 。

平均Θ(NlogN) ：在随机输入数组下，哨兵划分操作的递归轮数也为O(logN) 。

最差 O(N^2)：在某些特殊输入数组下，每轮哨兵划分操作都将长度为 N 的数组划分为长度为1和N−1的两个子数组，此时递归轮数达到N 。

虽然平均时间复杂度与「归并排序」和「堆排序」一致，但在实际使用中快速排序效率更高，这是因为：

最差情况稀疏性：虽然快速排序的最差时间复杂度为 O(N^2)，差于归并排序和堆排序，但统计意义上看，这种情况出现的机率很低。大部分情况下，快速排序以 O(NlogN) 复杂度运行。

缓存使用效率高：哨兵划分操作时，将整个子数组加载入缓存中，访问元素效率很高；堆排序需要跳跃式访问元素，因此不具有此特性。

常数系数低：在提及的三种算法中，快速排序的比较、赋值、交换三种操作的综合耗时最低（类似于插入排序快于冒泡排序的原理）。

原地：不用借助辅助数组的额外空间，递归仅使用O(logN) 大小的栈帧空间。

非稳定：哨兵划分操作可能改变相等元素的相对顺序。

自适应：若每轮哨兵划分操作都将长度为 NN 的数组划分为长度1和N−1两个子数组，则时间复杂度劣化至O(N^2)。

1.1.3 Improvement 1: 降低空间复杂度——Tail Call

最坏情况进行N次递归，那么最差时间复杂度会达到O(N)。

每轮递归时，仅对较短的子数组执行哨兵划分 partition() ，就可将最差的递归深度控制在O(logN) （每轮递归的子数组长度都≤ 当前数组长度），即实现最差空间复杂度 O(logN) 。

代码只需修改quick_sort()：

void quickSort(vector<int> &nums, int l, int r) {while (l < r) {int i = partition(nums, l, r);if (i - l < r - i) {quickSort(nums, l, i - 1);l = i + 1;}else {quickSort(nums, i + 1, r);r = i - 1;}}
}

1.1.3 Improvement 2:避免最坏情况——随机基准数

通过随机函数，随机选取哨兵值，极大程度避免完全有序或者完全倒序的情况下时间复杂度为O(n²)的情况。

partition()代码修改如下：

int partition(vector<int>& nums, int l, int r) {// 在闭区间 [l, r] 随机选取任意索引，并与 nums[l] 交换int ra = l + rand() % (r - l + 1);swap(nums[l], nums[ra]);// 以 nums[l] 作为基准数int i = l, j = r;while (i < j) {while (i < j && nums[j] >= nums[l]) j--;while (i < j && nums[i] <= nums[l]) i++;swap(nums[i], nums[j]);}swap(nums[i], nums[l]);return i;
}

1.2 第k小数

1.2.1 Implementation 1: 基于快排

继承快排的思想，当哨兵位置为k时返回对应值。

partition部分可以继续沿用1.1.3的改进，将quickSort段代码改成如下：

int kMin(vector<int>& nums, int l, int r, int k) {int i = partition(nums, l, r);if (i == k) {return nums[k];}if (i < k) {return kMin(nums, i + 1, r, k);}else return kMin(nums, l, i - 1, k);
}

该方法的时间复杂度为θ(n)，但是最坏情况达到了O(n²)。

空间复杂度为O(logn)，即递归调用栈空间的空间代价。

1.2.2 Implementation 2: 基于堆排序

堆的性质是每次弹出最小的一个值，那么找第k小的数，也就是调用k次堆的弹出函数。

堆的API如下：

#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;template<class T> class myHeap {private:T* heap;int capacity;const int REFACTOR = 2;void heapSort(int n);void switchSons(int i, int size);void topDownHeapify(int maxPos);
public:myHeap();myHeap(T* array, int size);void insert(T item);void pop();void print();T peek();
};template<class T> myHeap<T>::myHeap() {heap = new T[11];capacity = 10;heap[0] = 0;
}template<class T> myHeap<T>::myHeap(T* array, int size) {heap = new T[size + 1];heap[0] = size;capacity = size;for (int i = 1; i <= size; i++) {heap[i] = array[i - 1];}heapSort(heap[0]);
}template<class T> void myHeap<T>::heapSort(int size) {if (size == 1) return;int n = size / 2;for (int i = n; i >= 1; i--) {switchSons(i, size);}swap(heap[1], heap[size]);heapSort(size - 1);
}template<class T> void myHeap<T>::switchSons(int i, int size) {if (2 * i + 1 > size) {if (heap[i] < heap[2 * i]) {swap(heap[i], heap[2 * i]);}return;}T left = heap[2 * i];T right = heap[2 * i + 1];if (right > left && right > heap[i]) {swap(heap[i], heap[2 * i + 1]);}else if (left > heap[i]) {swap(heap[i], heap[2 * i]);}
}template<class T> void myHeap<T>::print() {for (int i = 1; i <= heap[0]; i++) {cout << heap[i] << " ";}cout << endl;
}template<class T> void myHeap<T>::insert(T item) {if (heap[0] == capacity) {capacity *= REFACTOR;T* tmp = new T[capacity];for (int i = 0; i <= heap[0]; i++) {tmp[i] = heap[i];}heap = tmp;}heap[heap[0] + 1] = item;int i = heap[0]++ + 1;int j = heap[0] / 2;while (j >= 0 && i != 1) {if (heap[j] <= item) break;heap[i] = heap[j];i = j;j = i / 2;}heap[i] = item;
}template<class T> void myHeap<T>::pop() {if (heap[0] == 0) return;// print();cout << heap[1] << endl;swap(heap[1], heap[heap[0]--]);// print();topDownHeapify(1);
}template<class T> void myHeap<T>::topDownHeapify(int maxPos) {// 已到达叶子结点if (maxPos * 2 > heap[0]) return;if (maxPos * 2 == heap[0]) {if (heap[heap[0]] < heap[maxPos]) swap(heap[maxPos], heap[heap[0]]);return;}int left = heap[maxPos * 2];int right = heap[maxPos * 2 + 1];if (right < left && right < heap[maxPos]) {swap(heap[maxPos], heap[maxPos * 2 + 1]);// print();topDownHeapify(maxPos * 2 + 1);}else if (left < heap[maxPos]) {swap(heap[maxPos], heap[maxPos * 2]);// print();topDownHeapify(maxPos * 2);}
}template<class T> T myHeap<T>::peek() {if (heap[0] == 0) {exit(1);}return heap[1];
}

通过上述建立的myHeap类，我们求第k小数也可以用如下方法：

int kMin(myHeap<int> &nums, int k) {for (int i = 1; i < k; i++) {nums.pop();}return nums.peek();
}

该方法的时间复杂度为θ(nlogn)，但是最坏情况同样达到了O(n²)。

空间复杂度为O(logn)，即递归调用栈空间的空间代价。

1.3 正确性验证

为了验证正确性，选择了LeetCode中的一道题目进行验证。

1.3.1 题目：215. 数组中的第K个最大元素

给定整数数组 nums 和整数 k，请返回数组中第 k个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

1.3.2 基于快排的实现

#include <vector>
#include <string>
#include <algorithm>
using namespace std;class Solution {public:int findKthLargest(vector<int>& nums, int k) {int n = nums.size();k = n - k;return kMin(nums, 0, n - 1, k);}int partition(vector<int>& nums, int l, int r) {int i = l;int j = r;while (i < j) {while (i < j && nums[j] >= nums[l]) j--;while (i < j && nums[i] <= nums[l]) i++;swap(nums[i], nums[j]);}swap(nums[i], nums[l]);return i;}int kMin(vector<int>& nums, int l, int r, int k) {int i = partition(nums, l, r);if (i == k) {return nums[k];}if (i < k) {return kMin(nums, i + 1, r, k);}else return kMin(nums, l, i - 1, k);}
};

1.3.3 基于堆排序的实现

#include <vector>
#include <string>
#include <algorithm>
using namespace std;class Solution {public:int findKthLargest(vector<int>& nums, int k) {int n = nums.size();k = n - k + 1;vector<int> ans(n + 1);ans[0] = n;for (int i = 1; i <= n; i++) {ans[i] = nums[i - 1];}heapSort(ans, n);return ans[k];}void heapSort(vector<int>& heap, int size) {if (size == 1) return;int n = size / 2;for (int i = n; i >= 1; i--) {switchSons(heap, i, size);}swap(heap[1], heap[size]);heapSort(heap, size - 1);}void switchSons(vector<int>& heap, int i, int size) {if (2 * i + 1 > size) {if (heap[i] < heap[2 * i]) {swap(heap[i], heap[2 * i]);}return;}int left = heap[2 * i];int right = heap[2 * i + 1];if (right > left && right > heap[i]) {swap(heap[i], heap[2 * i + 1]);}else if (left > heap[i]) {swap(heap[i], heap[2 * i]);}}
};

2. 棋盘覆盖问题

2.1 思路分析

利用分治的思想：

当k=0时，结束递归；
当k>1时，将2^k * 2^k的棋盘分成四个2^k-1*2^k-1的子棋盘，其中有一个子棋盘必然包含一个残缺的方块，另外三个是完整的，这时候在三个完整的子棋盘的边界放一个跨越边界的L型骨牌，作为残缺方块，这样所有四个子棋盘都有了残缺方块，相当于变成了四个规模减小的子问题。

2.2 代码

//棋盘覆盖问题
/*
(tr，tc)是棋盘左上角的方格坐标
(dr,dc)是特殊方格所在的坐标
size是棋盘的行数和列数
*/
#include<iostream>
using namespace std;
int board[100][100];
static int tile = 1;void ChessBoard(int tr, int tc, int dr, int dc, int size)
{if (size == 1) return;//递归边界 int t = tile++;//L型骨牌号 int s = size / 2;//分割棋盘 //覆盖左上角子棋盘 if (dr < tr + s && dc < tc + s) ChessBoard(tr, tc, dr, dc, s);//特殊方格在此棋盘中 else { //此棋盘中无特殊方格，用t号L型骨牌覆盖右下角 board[tr + s - 1][tc + s - 1] = t;//覆盖其余方格 ChessBoard(tr, tc, tr + s - 1, tc + s - 1, s);}//覆盖右上角子棋盘 if (dr < tr + s && dc >= tc + s) ChessBoard(tr, tc + s, dr, dc, s);//特殊方格在此棋盘中else { //此棋盘中无特殊方格，用t号L型骨牌覆盖左下角board[tr + s - 1][tc + s] = t;//覆盖其余方格 ChessBoard(tr, tc + s, tr + s - 1, tc + s, s);}//覆盖左下角子棋盘 if (dr >= tr + s && dc < tc + s) ChessBoard(tr + s, tc, dr, dc, s);else { //此棋盘中无特殊方格，用t号L型骨牌覆盖右上角board[tr + s][tc + s - 1] = t;//覆盖其余方格 ChessBoard(tr + s, tc, tr + s, tc + s - 1, s);}//覆盖右下角子棋盘 if (dr >= tr + s && dc >= tc + s) ChessBoard(tr + s, tc + s, dr, dc, s);else { //此棋盘中无特殊方格，用t号L型骨牌覆盖左上角 board[tr + s][tc + s] = t;//覆盖其余方格 ChessBoard(tr + s, tc + s, tr + s, tc + s, s);}
}int main()
{int i, j;int k;while (cin >> k){int size = 1 << k;int x, y;cin >> x >> y;board[x][y] = 0;ChessBoard(0, 0, x, y, size);for (i = 0; i < size; i++){for (j = 0; j < size; j++)cout << board[i][j] << "\t";cout << "\n";}}return 0;
}

2.3 测试数据

假设一个2²*2²的棋盘，在[2, 2]位置插入残缺子块（记为0号），测试结果如下：

3. 背包问题

3.1 0-1背包问题

3.1.1 思路分析

动态规划三步走：

（1）确定状态：

dp_ij：检查过前i个物品，空间限度为j的背包最大价值

（2）确定状态转换：要么将第i个物品加进来，要么不加进来

d p [ i ] [ j ] = m a x ( d p [ i − 1 ] [ j ] , d p [ i − 1 ] [ j − a [ i ] ] + v [ i ] ) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - a[i]] + v[i]) dp[i][j]=max(dp[i−1][j],dp[i−1][j−a[i]]+v[i])

（3）确定初始状态：

i < a [ 0 ] : d p [ 0 ] [ i ] = 0 i < a[0]:dp[0][i] = 0 i<a[0]:dp[0][i]=0
i > = a [ 0 ] : d p [ 0 ] [ i ] = v [ i ] i >= a[0]:dp[0][i] = v[i] i>=a[0]:dp[0][i]=v[i]

3.1.2 动态规划

class Solution {public:/*** @param m: An integer m denotes the size of a backpack* @param a: Given n items with size A[i]* @param v: Given n items with value V[i]* @return: The maximum value*/int backPackII(int m, vector<int> &a, vector<int> &v) {// write your code herevector<vector<int>> dp(a.size(), vector<int>(m + 1));for (int i = 0; i < a[0]; i++) {dp[0][i] = 0;}for (int i = a[0]; i <= m; i++) {dp[0][i] = v[0];}for (int i = 1; i < a.size(); i++) {for (int j = 0; j <= m; j++) {if (j >= a[i]) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - a[i]] + v[i]);else dp[i][j] = dp[i - 1][j];}}return dp[a.size() - 1][m];}
};

3.1.3 空间优化

发现在dp的过程中与前一个状态有关，所以可以将空间复杂度降低到O(m)。

class Solution {public:/*** @param m: An integer m denotes the size of a backpack* @param a: Given n items with size A[i]* @param v: Given n items with value V[i]* @return: The maximum value*/int backPackII(int m, vector<int> &a, vector<int> &v) {// write your code herevector<int> dp(m + 1);for (int i = 0; i < a[0]; i++) {dp[i] = 0;}for (int i = a[0]; i <= m; i++) {dp[i] = v[0];}for (int i = 1; i < a.size(); i++) {for (int j = m; j >= 0; j--) {if (j >= a[i]) dp[j] = max(dp[j], dp[j - a[i]] + v[i]);}}return dp[m];}
};

测试结果如下：

3.2 背包问题

3.2.1 题目描述

物品	A	B	C	D	E	F	G
重量	35	30	60	50	40	10	25
价值	10	40	30	50	35	40	30

有一个背包，背包容量是M=150。有7个物品，物品可以分割成任意大小。要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。

3.2.2 思路分析

与0-1问题不同，这题要换个思路，采用贪心的思想：

对物品的单位价值进行排序；
从单位价值从高到低，依次加入背包，如果能全部装得下，就全部装进去，直到没办法将所有的装入为止；
当没办法全部装入之后，将物品装入至装满；

3.2.3 代码实现

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;double packetProblem(int size, vector<int> weights, vector<int> values) {vector<pair<double, int>> selector;for (int i = 0; i < weights.size(); i++) {selector.push_back(make_pair(values[i] / double(weights[i]), i));}sort(selector.begin(), selector.end());int totalSize = 0;double ans = 0;int j = selector.size() - 1;while (totalSize < size || j == -1) {if (weights[selector[j].second] + totalSize > size) break;ans += values[selector[j].second];totalSize += weights[selector[j].second];j--;}if (j != -1) ans += selector[j].first * double(size - totalSize);return ans;
}int main() {int size = 150;vector<int> weights = { 35, 30, 60, 50, 40, 10, 25 };vector<int> values = { 10, 40, 30, 50, 35, 40, 30 };cout << "最大价值：" << packetProblem(size, weights, values);
}

根据计算，最大价值为190.625，测试结果如下：

4.照亮山景

4.1 思路分析

找到所有的山峰，对每对山峰之间的坡进行区间划分，当一盏灯在左山峰的右坡，和右山峰的左坡之间时，该灯可以照亮山峰之间的所有坡；利用贪心的思想，每次对灯可以处理的坡数进行计算，选出能照亮最多坡的灯，加入答案，然后重新寻找，直到所有坡都被点亮

4.2 代码实现

vector<int> findTops(vector<int> x, vector<int> y) {vector<int> tops;// 判断左右边界是否为山峰if (y[0] > y[1]) tops.push_back(0);if (y[y.size() - 1] > y[y.size() - 2]) tops.push_back(y.size() - 1);for (int i = 1; i < y.size() - 1; i++) {if (y[i] > y[i - 1] && y[i] > y[i + 1]) {tops.push_back(i);}}return tops;
}vector<int> leastLightNum(vector<int> x, vector<int> y, int height, vector<int> lights) {/* 1.找到所有山峰 */vector<int> tops = findTops(x, y);/* 2.处理坡数与区间 */// 计算延长线的变量int x1, x2, x3, x4, y1, y2, y3, y4;// 每个区间的坡数vector<int> slopeNumber;// 区间范围vector<pair<double, double>> sections;// 处理左边界double left, right;if (tops[0] > 0) {x1 = x[tops[0] - 1];x2 = x[tops[0]];y1 = y[tops[0] - 1];y2 = y[tops[0]];right = (height - y1) * (x2 - x1) / double(y2 - y1) + x1;slopeNumber.push_back(tops[0]);sections.push_back(make_pair(INT_MIN, right));}// 处理山峰之间for (int i = 0; i < tops.size() - 1; i++) {x1 = x[tops[i]];y1 = y[tops[i]];x2 = x[tops[i] + 1];y2 = y[tops[i] + 1];x3 = x[tops[i + 1] - 1];y3 = y[tops[i + 1] - 1];x4 = x[tops[i + 1]];y4 = y[tops[i + 1]];left = (height - y1) * (x2 - x1) / double(y2 - y1) + x1;right = (height - y3) * (x4 - x3) / double(y4 - y3) + x3;slopeNumber.push_back(tops[i + 1] - tops[i] + 1);sections.push_back(make_pair(left, right));}// 处理右边界if (tops[tops.size() - 1] < x.size() - 1) {x1 = x[tops[tops.size() - 1]];x2 = x[tops[tops.size() - 1]];y1 = y[tops[tops.size() - 1] + 1];y2 = y[tops[tops.size() - 1] + 1];left = (height - y1) * (x2 - x1) / double(y2 - y1) + x1;slopeNumber.push_back(x.size() - 1 - tops[tops.size() - 1]);sections.push_back(make_pair(left, INT_MAX));}/* 3.利用贪心依次亮灯 */vector<int> ans;int count = sections.size();int max, index;while (count > 0) {vector<int> tmp; // 存选出的灯所关联的区间int nums = 0; // 该灯点亮的坡数max = 0;index = -1;for (int i = 0; i < lights.size(); i++) {vector<int> relatedSection; // 存储当前灯关联的区间for (int j = 0; j < sections.size(); j++) {// 如果灯在照亮的区间范围内if (lights[i] > sections[j].first && lights[i] < sections[j].second) {relatedSection.push_back(j);nums += slopeNumber[j];}}// 选出点亮最多区域的灯if (nums > max) {max = nums;index = i;tmp = relatedSection;}}// 更新剩余的区域数count -= tmp.size();ans.push_back(index);// 将已被覆盖的点移出for (int i : tmp) {sections[i].first = sections[i].second = -1;}}return ans;
}

4.3 时间复杂度分析

在最坏的情况下：

每次只能减少一个 s e c t i o n section section；
每次要遍历 n u m s ( l i g h t s ) ∗ n u m s ( s e c t i o n ) nums(lights)*nums(section) nums(lights)∗nums(section)个点；

假设山上的点数量为 n n n，那么 s e c t i o n section section的数量为 n − 2 n-2 n−2，假设 l i g h t s lights lights的数量为 m m m，那么时间复杂度的上界为 O ( n 2 ∗ m ) O(n^2*m) O(n2∗m)。

5. 汽车加油问题

5.1 思路分析

在每次出发前判断：如果能跑到下一个站就不加油，如果跑不到就加油。

5.2 代码实现

int leastOilTime(int N, int K, vector<int> a) {int gasCapacity = N;int time = 0;for (int i = 1; i <= K; i++) {// 如果能跑到下一个站就不加油if (a[i] < gasCapacity) {gasCapacity -= a[i];continue;}if (a[i] > N) {cerr << "汽车不可能跑到终点" << endl;exit(1);}// 跑不到就加油gasCapacity = N;time++;}return time;
}

5.3 时间复杂度分析

O ( K ) O(K) O(K)。

6. 最长公共子序列

6.1 思路分析

动态规划三步走：

（1）确定状态：

dp_ij： t e x t 1 text1 text1前 i i i个字符构成的子串与 t e x t 2 text2 text2前 j j j个字符构成的子串的最长公共子序列长度。

（2）确定状态转换：如果字符相等，那么 L C S LCS LCS为 i − 1 , j − 1 i-1,j-1 i−1,j−1时加一，

d p [ i ] [ j ] = d p [ i − 1 ] [ j − 1 ] + 1 < = t e x t 1 [ i − 1 ] = t e x t [ j − 1 ] dp[i][j] = dp[i - 1][j-1]+1<=text1[i-1]=text[j-1] dp[i][j]=dp[i−1][j−1]+1<=text1[i−1]=text[j−1]

否则，取 d p [ i − 1 ] [ j ] , d p [ i ] [ j − 1 ] dp[i-1][j],dp[i][j-1] dp[i−1][j],dp[i][j−1]中的最大值

d p [ i ] [ j ] = m a x ( d p [ i ] [ j − 1 ] , d p [ i − 1 ] [ j ] ) < = t e x t 1 [ i − 1 ] ! = t e x t [ j − 1 ] dp[i][j] = max(dp[i][j-1],dp[i-1][j])<=text1[i-1]!=text[j-1] dp[i][j]=max(dp[i][j−1],dp[i−1][j])<=text1[i−1]!=text[j−1]

（3）确定初始状态：

d p [ 0 ] [ j ] = 0 , d p [ i ] [ 0 ] = 0 dp[0][j] = 0, dp[i][0] = 0 dp[0][j]=0,dp[i][0]=0

6.2 代码实现

class Solution {public:int longestCommonSubsequence(string text1, string text2) {int m = text1.size();int n = text2.size();vector<vector<int>> dp(m + 1, vector<int>(n + 1));for (int i = 1; i <= m; i++) {for (int j = 1; j <= n; j++) {if (text1[i - 1] == text2[j - 1])dp[i][j] = dp[i - 1][j - 1] + 1;else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);}}return dp[m][n];}
};

6.3 LeetCode测试结果

6.4 空间优化

注意到dp只和前一轮状态有关，所以可以进行空间优化：

class Solution {public:int longestCommonSubsequence(string text1, string text2) {int m = text1.size();int n = text2.size();if (m > n) return longestCommonSubsequence(text2, text1);vector<int> dp(n + 1);for (int i = 1; i <= m; i++) {int last = dp[0];for (int j = 1; j <= n; j++) {int temp = last;last = dp[j];if (text1[i - 1] == text2[j - 1])dp[j] = temp + 1;else dp[j] = max(dp[j], dp[j - 1]);}}return dp[n];}
};

可以看到有所进步：

7. 皇后看守

7.1 思路分析

首先这道题的题意是：给定一棵树，要在一些节点上放置守卫，每个守卫可以看护当前节点以及与此节点连通的节点，在不同节点放置守卫的代价不同，如何选取节点使代价最小，这是个典型的树形DP问题，显然每个节点有放置守卫和不放置守卫两种，但是从计算的过程看，不放置守卫的状态有两种，一种是有其父节点上的守卫看护，一种是由其子节点的守卫看护，因此可将每个节点的看护情况分为三种：

该节点由父节点处放置的守卫看护；
该节点由子节点处放置的守护看护；
该节点由在该节点放置的守卫看护；

下面考虑状态转移的过程，建立数组f[i][3]，其中:

f [ i ] [ 0 ] f[i][0] f[i][0]表示第 i i i个节点由父节点处放置的守卫看护下的最小代价；
f [ i ] [ 1 ] f[i][1] f[i][1]表示第 i i i个节点由子节点处放置的守卫看护下的最小代价；
f [ i ] [ 2 ] f[i][2] f[i][2]表示第 i i i个节点由在该节点放置的守卫看护下的最小代价；

下面讨论状态转移方程：

由父节点放置守卫看守时，儿子结点只能由自身或者儿子来看守：

f [ i ] [ 0 ] + = m i n ( f [ j ] [ 1 ] , f [ j ] [ 2 ] ) f[i][0] += min(f[j][1], f[j][2]) f[i][0]+=min(f[j][1],f[j][2])

由子节点放置守卫看守时，选择一个儿子，必须放置看守，其他儿子只能由自身或者儿子的儿子进行看守：

f [ i ] [ 1 ] = m i n ( f [ i ] [ 1 ] , s u m − m i n ( f [ j ] [ 1 ] , f [ j ] [ 2 ] ) + f [ j ] [ 2 ] ) f[i][1] = min(f[i][1], sum - min(f[j][1], f[j][2]) + f[j][2]) f[i][1]=min(f[i][1],sum−min(f[j][1],f[j][2])+f[j][2])

当在自身放置看守时，儿子结点已经被看守了，选择三种情况中最小的即可：

f [ i ] [ 2 ] + = m i n ( m i n ( f [ j ] [ 0 ] , f [ j ] [ 1 ] ) , f [ j ] [ 2 ] ) f[i][2] += min(min(f[j][0], f[j][1]), f[j][2]) f[i][2]+=min(min(f[j][0],f[j][1]),f[j][2])

7.2 代码实现

// 省略数据处理部分// u指的是当前讨论的结点号void dfs(int u) {f[u][2] = w[u];  // 初始化在该节点设置守卫的代价int sum = 0;for (int i = h[u]; i != -1; i = ne[i]) {// j是孩子结点int j = e[i];dfs(j);f[u][0] += min(f[j][1], f[j][2]);f[u][2] += min(min(f[j][0], f[j][1]), f[j][2]);sum += min(f[j][1], f[j][2]);}f[u][1] = 1e9;for (int i = h[u]; i != -1; i = ne[i]){// 选择代价最小的节点作为看守int j = e[i];f[u][1] = min(f[u][1], sum - min(f[j][1], f[j][2]) + f[j][2]);}
}