算法设计与分析实验指导（完整版）

ShowM3TheCode

已于 2022-05-23 23:17:37 修改

阅读量1k

点赞数 1

分类专栏：学校课程作业之路文章标签：算法排序算法数据结构

于 2022-05-22 23:06:15 首次发布

本文链接：https://blog.csdn.net/ShowMeTheCod3/article/details/124918307

版权

学校课程作业之路专栏收录该内容

5 篇文章 5 订阅

订阅专栏

算法设计与分析实验指导

文章目录

算法设计与分析实验指导

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号），测试结果如下：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XWZSz6nz-1653231374907)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20220521234255845.png)]$

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])$

（3）确定初始状态：

$i < a [0] : d p [0] [i] = 0$
$i > = a [0] : d p [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 here
        vector<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 here
        vector<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];
    }
};

测试结果如下：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xAsBG70b-1653231325669)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20220522140106675.png)]$

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，测试结果如下：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k3zwzoGR-1653231325670)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20220522143130912.png)]$

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$ ；
每次要遍历 $n u m s (l i g h t s) * n u m s (s e c t i o n)$ 个点；

假设山上的点数量为 $n$ ，那么 $s e c t i o n$ 的数量为 $n - 2$ ，假设 $l i g h t s$ 的数量为 $m$ ，那么时间复杂度的上界为 $O(n^2*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)$ 。

6. 最长公共子序列

6.1 思路分析

动态规划三步走：

（1）确定状态：

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

（2）确定状态转换：如果字符相等，那么 $L C S$ 为 $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]$

否则，取 $d p [i - 1] [j], d p [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]$

（3）确定初始状态：

$d p [0] [j] = 0, d p [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测试结果

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6tKShWlK-1653231325671)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20220522162523730.png)]$

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];
        }
};

可以看到有所进步：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0WbjMakL-1653231325672)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20220522163517060.png)]$

7. 皇后看守

7.1 思路分析

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

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

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

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

下面讨论状态转移方程：

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

$f [i] [0] + = m i n (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] [2] + = m i n (m i n (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]);
    }
}

ShowM3TheCode

关注

1
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
算法设计与分析实验指导（完整版）

算法设计与分析实验指导文章目录算法设计与分析实验指导1. 快速排序及第k小数1.1 快速排序1.1.1 Implementation 11.1.2 算法特性分析1.1.3 Improvement 1: 降低空间复杂度——Tail Call1.1.3 Improvement 2:避免最坏情况——随机基准数1.2 第k小数1.2.1 Implementation 1: 基于快排1.2.2 Implementation 2: 基于堆排序1.3 正确性验证1.3.1 题目：[215. 数组中的第K个最大元素](h
复制链接

扫一扫

专栏目录