算法 on zcys univ II Hugo ver

树状数组和线段树

Sat, 11 Apr 2026 00:00:00 +0800

树状数组模板

n,m = map(int,input().split())
t = list(map(int,input().split()))
c = [0] * (n+1)

def lowbit(x):
    return x & (-x)

def add(idx,d):
    while idx <= n:
        c[idx] += d
        idx += lowbit(idx)

    
def query(idx):
    res = 0
    while idx > 0:
        res += c[idx]
        idx -= lowbit(idx)
    return res

def rs(l,r):
    return query(r) - query(l)


for i,v in enumerate(t, start = 1):
    add(i,v)

for i in range(m):
    k,a,b = map(int,input().split())
    if k == 0:
        print(rs(a-1,b)) #注意需要包含第a个元素
    else:
        add(a,b)

操作	普通数组	前缀和数组	树状数组
单点更新	O(1)	O(n)	O(log n)
区间查询	O(n)	O(1)	O(log n)

Chapter 4 贪心

Wed, 12 Nov 2025 00:00:00 +0800

为什么需要贪心算法

在算法设计中，贪心算法是一种通过在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是全局最好或最优的算法。贪心算法通常用于解决优化问题。

贪心算法的核心思想是通过局部最优选择来达到全局最优解。它适用于那些具有“最优子结构”和“贪心选择性质”的问题。

与动态规划的区别：动态规划通常用于解决具有重叠子问题和最优子结构的问题，而贪心算法则侧重于通过局部最优选择来构建全局最优解。动态规划通常需要保存中间结果，而贪心算法则不需要。贪心不依赖子问题的解决策，而动态规划依赖。

贪心算法的步骤

选择策略：确定在每一步中如何选择当前的最优解。这通常涉及定义一个贪心选择标准。
可行性检查：确保每次选择都不会违反问题的约束条件。
构建解：通过不断应用选择策略，逐步构建最终的解决方案。
验证最优性：在某些情况下，可能需要证明贪心选择确实能导致全局最优解。

证明贪心选择性质的方法：

存在整体最优解
修改最优解，是其以贪心选择开始
该问题转化为规模更小的相同形式的子问题
数学归纳法证明每一步都如此

k = 1 时，该解就是最优解 k > 1 时，令活动1替换活动k（因为活动1结束时间最早），得到新的解仍然是最优解

反证法？

最优子结构性质证明的方法：

假设一个问题的最优解包含其子问题的解。
通过构造或反证法证明，如果子问题的解不是最优的，那么整个问题的解也不会是最优的。

纸币找零问题

假设你是一个收银员，需要找零给顾客。你有面值为1元、5元、10元和20元的纸币。顾客需要找零37元。使用贪心算法，你会选择尽可能大的面值，直到达到所需的金额。

选择一张20元纸币，剩余17元。
选择一张10元纸币，剩余7元。
选择一张5元纸币，剩余2元。
选择两张1元纸币，剩余0元。

最终，你会使用1张20元、1张10元、1张5元和2张1元纸币来找零37元。

为什么贪心算法在这个问题中有效？因为每次选择最大的面值都能确保剩余金额最小，从而减少了总的纸币数量。

但是！如果纸币的面值是1元、3元和4元，顾客需要找零6元。使用贪心算法：

选择一张4元纸币，剩余2元。
选择两张1元纸币，剩余0元。

最终，你会使用1张4元和2张1元纸币，共3张纸币。 然而，最优解是使用两张3元纸币，共2张纸币。 这说明贪心算法并不总是能找到最优解。 但是可以找到近似解。

活动选择问题

活动选择问题是指在给定一组活动的开始和结束时间的情况下，选择尽可能多的互不冲突的活动。贪心算法在这个问题中表现出色。

排序活动：首先，根据活动的结束时间对活动进行排序。
选择活动：选择第一个活动，然后选择下一个与已选择活动不冲突且结束时间最早的活动，重复此过程直到没有更多活动可以选择。

代码实现

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct Activity {
    int start;
    int end;
};
bool compare(Activity a1, Activity a2) {
    return a1.end < a2.end;
}
void greedyActivitySelector(vector<Activity>& activities) {
    sort(activities.begin(), activities.end(), compare);
    int n = activities.size();
    cout << "Selected activities: " << endl;
    int lastEndTime = -1;
    for (int i = 0; i < n; i++) {
        if (activities[i].start >= lastEndTime) {
            cout << "Activity(" << activities[i].start << ", " << activities[i].end << ")" << endl;
            lastEndTime = activities[i].end;
        }
    }
}
int main() {
    vector<Activity> activities = { {1, 3}, {2, 5}, {4, 6}, {6, 7}, {5, 8}, {8, 9} };
    greedyActivitySelector(activities);
    return 0;
}

复杂度分析：排序活动的时间复杂度为O(n log n)，选择活动的时间复杂度为O(n)，因此总的时间复杂度为O(n log n)。

霍夫曼编码

霍夫曼编码是一种用于无损数据压缩的贪心算法。它通过为频率较高的符号分配较短的编码，而为频率较低的符号分配较长的编码，从而实现数据的压缩。

构建优先队列：将所有符号及其频率插入一个优先队列（最小堆）。
构建霍夫曼树：重复以下步骤直到队列中只剩一个节点：
- 从队列中取出两个频率最小的节点。
- 创建一个新节点，其频率为这两个节点频率之和，并将这两个节点作为新节点的子节点。
- 将新节点插入队列中。
生成编码：从根节点开始，为每个左子节点分配一个“0”，为每个右子节点分配一个“1”，直到到达叶节点，生成每个符号的编码。

代码实现

#include <iostream>
#include <queue>
#include <vector>
#include <unordered_map>
using namespace std;
struct Node {
    char ch;
    int freq;
    Node* left;
    Node* right;
    Node(char c, int f) : ch(c), freq(f), left(nullptr), right(nullptr) {}
};
struct compare {
    bool operator()(Node* l, Node* r) {
        return l->freq > r->freq;
    }
};
void generateCodes(Node* root, string str, unordered_map<char, string>& codes) {
    if (!root) return;
    if (!root->left && !root->right) {
        codes[root->ch] = str;
    }
    generateCodes(root->left, str + "0", codes);
    generateCodes(root->right, str + "1", codes);
}
void huffmanCoding(vector<pair<char, int>>& frequencies) {
    priority_queue<Node*, vector<Node*>, compare> minHeap;
    for (auto& freq : frequencies) {
        minHeap.push(new Node(freq.first, freq.second));
    }
    while (minHeap.size() > 1) {
        Node* left = minHeap.top(); minHeap.pop();
        Node* right = minHeap.top(); minHeap.pop();
        Node* newNode = new Node('\0', left->freq + right->freq);
        newNode->left = left;
        newNode->right = right;
        minHeap.push(newNode);
    }
    Node* root = minHeap.top();
    unordered_map<char, string> codes;
    generateCodes(root, "", codes);
    cout << "Huffman Codes: " << endl;
    for (auto& code : codes) {
        cout << code.first << ": " << code.second << endl;
    }
}
int main() {
    vector<pair<char, int>> frequencies = { {'a', 5}, {'b', 9}, {'c', 12}, {'d', 13}, {'e', 16}, {'f', 45} };
    huffmanCoding(frequencies);
    return 0;
}

Chapter 3 动态规划

Wed, 05 Nov 2025 00:00:00 +0800

最优子结构性质重叠子问题性质 (期末一章一个大题，就这么问)

矩阵连乘、最长公共子序列、最大子段和、背包最优质、极大极小、全局最优

引言

使用动态规划可以优化分治算法解决Fabonacci数列的问题。分治算法的时间复杂度为O(2^n)，而动态规划通过保存中间结果将时间复杂度降低到O(n)。

零、矩阵连乘问题

矩阵连乘问题是指给定一系列矩阵，求它们的最优乘法顺序，以使得计算所需的标量乘法次数最少。设有n个矩阵A1, A2, …, An，矩阵Ai的维数为pi-1 × pi。定义一个n维数组dp，其中dp[i][j]表示矩阵Ai到Aj的最优乘法次数。

2 动态规划解法

2.1 递归结构

$$dp[i][j] = \begin{cases} 0 & , i = j \\ \min_{i \leq k < j} \{dp[i][k] + dp[k+1][j] + p_{i-1}p_kp_j\} & , i < j \end{cases}$$

2.2 代码

void MatrixChainOrder(int p[], int n){
    int dp[n][n];
    for(int i = 1; i < n; i++) dp[i][i] = 0;

    for(int l = 2; l < n; l++){ // l is chain length
        for(int i = 1; i < n - l + 1; i++){
            int j = i + l - 1;
            dp[i][j] = INT_MAX;
            for(int k = i; k <= j - 1; k++){
                int q = dp[i][k] + dp[k+1][j] + p[i-1]*p[k]*p[j];
                if(q < dp[i][j]) dp[i][j] = q;
            }
        }
    }
}

复杂度分析：时间复杂度为$O(n^{3})$，空间复杂度为$O(n^{2})$。

一、凸多边形最优三角剖分

凸n边形的三角剖分与n-1个叶子的语法树之间存在一一对应关系。由于n个矩阵的完全加括号乘积与n个叶子的语法树之间存在一一对应关系，因此n个矩阵的完全加括号乘积也与凸(n+1)边形的三角剖分之间存在一一对应关系。事实上，矩阵连乘积的最优计算次序问题是凸多边形最优三角剖分问题的一个特殊情形。对于给定的矩阵链A1A2..An，定义一个与之相应的凸(n+1)边形P={v0 ,v1 ,… ,vn}，使得矩阵Ai与凸多边形的边vi-1vi一一对应。若矩阵Ai的维数为pi-1×pi,i=1,2,…,n，则定义三角形vivjvk上的权函数值为： ω(vivjvk)=pipjpk。依此权函数的定义，凸多边形P的最优三角剖分所对应的语法树给出矩阵链A1A2..An的最优完全加括号方式。

1 最优子结构性质

2 递归结构

二、最大子段和

最大子段和问题是指在一个给定的一维数列中，找出一个连续子段，使得该子段的元素和最大。

1 分治解法

2 动态规划解法

2.1 递归结构

$$dp[i] = \max_{0 \leq j \leq i} \left\{ \sum_{k=j}^{i} a[k] \right\} \quad i \leq n$$$$dp[i] = \begin{cases} a[i] + dp[i-1] & , dp[i-1] > 0 \\ a[i] & , dp[i-1] \leq 0 \end{cases}$$$$rec[i] = \begin{cases} rec[i-1] & , dp[i-1] > 0 \\ i & , dp[i-1] \leq 0 \end{cases}$$

2.2 代码（从前向后）

void MAXSUB(int a[], int n){
    int *b = new int[MAX];
    int *rec = new int[max];
    b[0] = a[0];
    rec[0] = 0;

    int max = b[0];
    
    for(int i = 1; i < n; i++){
        if(b[i-1] > 0) {
            b[i] = b[i-1] + a[i];
            rec = rec[i-1];
        }
        else{
            b[i] = a[i];
            rec = i;
        }
        if(b[i] > max) max = b[i];
    }
}

三、最长公共子序列

1 递归结构

设有两个序列X=x1,x2,…,xm和Y=y1,y2,…,yn，定义X的前i个元素组成的序列为Xi=x1,x2,…,xi，Y的前j个元素组成的序列为Yj=y1,y2,…,yj。设LCS[i][j]表示序列Xi和Yj的最长公共子序列的长度，则有如下递归关系：

$$ LCS[i][j] = \begin{cases} LCS[i-1][j-1] + 1 & , X[i] = Y[j] \\ \max(LCS[i-1][j], LCS[i][j-1]) & , X[i] \neq Y[j] \end{cases} $$

2 动态规划解法

2.1 递归结构

$$dp[i][j] = \begin{cases} dp[i-1][j-1] + 1 & , X[i] = Y[j] \\ \max(dp[i-1][j], dp[i][j-1]) & , X[i] \neq Y[j] \end{cases}$$

2.2 代码

void LCS(char X[], char Y[], int m, int n){
    int dp[m+1][n+1];
    for(int i = 0; i <= m; i++) dp[i][0] = 0;
    for(int j = 0; j <= n; j++) dp[0][j] = 0;

    for(int i = 1; i <= m; i++){
        for(int j = 1; j <= n; j++){
            if(X[i-1] == Y[j-1]){
                dp[i][j] = dp[i-1][j-1] + 1;
            }
            else{
                dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
    }
}

四、0-1背包问题

1 递归结构

设有n件物品和一个容量为W的背包。每件物品i有一个重量wi和一个价值vi。定义dp[i][j]表示前i件物品在背包容量为j时的最大价值，则有如下递归关系：

$$ dp[i][j] = \begin{cases} dp[i-1][j] & , j < w_i \\ \max(dp[i-1][j], dp[i-1][j-w_i] + v_i) & , j \geq w_i \end{cases} $$

2 动态规划解法

2.1 递归结构

$$dp[i][j] = \begin{cases} dp[i-1][j] & , j < w_i \\ \max(dp[i-1][j], dp[i-1][j-w_i] + v_i) & , j \geq w_i \end{cases} $$$$dp[0][j] = 0, \quad 0 \leq j \leq W$$

2.2 代码

void Knapsack(int w[], int v[], int n, int W){
    int dp[n+1][W+1];
    for(int i = 0; i <= n; i++) dp[i][0] = 0;
    for(int j = 0; j <= W; j++) dp[0][j] = 0;

    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= W; j++){
            if(j < w[i-1]){
                dp[i][j] = dp[i-1][j];
            }
            else{
                dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i-1]] + v[i-1]);
            }
        }
    }
}

五、完全背包问题

六、最优二叉搜索树

七、流水作业调度

八、图像压缩

Chapter 2 分治

Sun, 01 Jan 2023 00:00:00 +0800

思想

递归

分治的条件

规模缩小到一定程度可以容易解决
具有最优子结构性质
子问题的解可以合并为该问题的解（与动态规划的区别）（不能：贪心、DP）
不包含公共子问题（各个子问题相互独立，否则使用DP）快速排序：原地排序、$nlogn$

2.3 二分搜索

2.4 大整数乘法

2.5 Strassen矩阵乘法

2.7 合并排序

2.8 快速排序

2.9 选择问题

长度为$n$线性有序集合，找出第$k$小分治，$pivot$ 线性时间选择问题，问题规模 $0<\epsilon<1$

步骤

划分成$\frac{n}{5}$个组
各组内任意排序
每组中，$pivot_{i}$ = 中位数
一共$\frac{n}{5}$个$pivot$，再找出中位数只有75个元素以上才能缩小$\frac{1}{4}$

补充

划分因子选择3、7：7可以，3不行

2.10 最近点对问题

直线

暴力$O(n^{2})$ 一次排序、一维扫描，$O(nlogn)$

二维

蛮力；分治（平衡子问题）如何分治？能在线性时间内完成？