c++算法之基本算法篇 - 贪心与拟阵

一、贪心法的基本概念

1.1 什么是贪心法？

贪心法（Greedy Algorithm）是一种简单而强大的算法设计思想。它的核心策略是：在每一步选择中都采取当前状态下最优的选择，从而希望导致结果是全局最优的。

1.2 生活中的贪心法例子

想象一下你在自助餐厅吃饭，目标是吃到最多价值的食物：

• 贪心策略：每次只拿眼前看起来最贵的食物
• 现实结果：你可能拿了一堆昂贵的但吃不下的食物，反而错过了性价比高的组合
  这个例子揭示了贪心法的本质：局部最优选择不一定能保证全局最优，但在某些特定条件下，贪心法确实能找到全局最优解。

1.3 贪心算法的基本步骤

1. 建立数学模型：将问题转化为数学形式
2. 分解问题：将问题分解为若干个子问题
3. 贪心选择：在每一步做出当前看起来最优的选择
4. 求解子问题：解决剩下的子问题
5. 合并解：将所有子问题的解合并为原问题的解

二、贪心算法的核心要素

2.1 贪心选择性质

贪心选择性质是指：所求问题的全局最优解可以通过一系列局部最优的选择得到。这是贪心算法适用的关键条件。

2.2 最优子结构性质

最优子结构性质是指：问题的最优解包含其子问题的最优解。这意味着我们可以通过解决子问题来构建原问题的解。

2.3 贪心算法的适用条件

贪心算法适用于满足以下条件的问题：

1. 具有贪心选择性质
2. 具有最优子结构性质
3. 局部最优选择能导致全局最优解

三、拟阵：贪心算法的理论基础

3.1 什么是拟阵？

拟阵（Matroid）是组合数学中的一个概念，它为贪心算法的正确性提供了理论基础。简单来说，拟阵是能够保证贪心算法正确求解的一类组合优化问题的抽象结构。

3.2 拟阵的通俗理解

想象你在玩一个收集卡牌的游戏：

• 游戏规则：你有一堆卡牌，有些卡牌可以组合成有效的"套牌"，有些则不行
• 拟阵性质：
  • 如果你能收集一套卡牌，那么这套卡牌的任何子集也是有效的（遗传性）
  • 如果你有一套小卡牌A和一套大卡牌B，且A比B小，那么你总能从B中拿一张卡牌加入A，形成一套更大的有效卡牌（交换性）
    这个游戏规则就构成了一个拟阵，而贪心算法就像你每次都选择当前最稀有的卡牌加入你的收藏。

3.3 拟阵的数学定义

拟阵M是一个有序对(S, I)，其中：

• S 是有限集合（称为基础集）
• I 是S的子集族（称为独立集族），满足以下条件：
  1. 遗传性：如果B ∈ I且A ⊆ B，则A ∈ I
  2. 交换性：如果A, B ∈ I且|A| < |B|，则存在x ∈ B - A，使得A ∪ {x} ∈ I

3.4 拟阵与贪心算法的关系

关键定理：对于加权拟阵问题，贪心算法总能找到最优解。
这意味着，如果我们能将一个问题建模为拟阵，那么贪心算法就是解决这个问题的正确方法。

四、经典贪心算法问题详解

4.1 活动选择问题

4.1.1 问题描述

有n个活动，每个活动都有开始时间s_i和结束时间f_i。目标是安排尽可能多的活动，且这些活动之间不冲突（即一个活动开始时，另一个活动已经结束）。

4.1.2 贪心策略

按结束时间排序：每次选择结束时间最早的活动，这样可以为后续活动留出更多时间。

4.1.3 C++实现

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 活动结构体
struct Activity {
    int start;
    int finish;
};
// 按结束时间排序的比较函数
bool compareActivities(Activity a1, Activity a2) {
    return (a1.finish < a2.finish);
}
// 打印最大活动集合
void printMaxActivities(vector<Activity>& activities) {
    int n = activities.size();
    
    // 按结束时间排序
    sort(activities.begin(), activities.end(), compareActivities);
    
    cout << "选择的活动如下：" << endl;
    
    // 第一个活动总是被选择
    int i = 0;
    cout << "活动 " << i << ": (" << activities[i].start << ", " << activities[i].finish << ")" << endl;
    
    // 考虑剩余活动
    for (int j = 1; j < n; j++) {
        // 如果当前活动的开始时间大于等于上一个选择活动的结束时间
        if (activities[j].start >= activities[i].finish) {
            cout << "活动 " << j << ": (" << activities[j].start << ", " << activities[j].finish << ")" << endl;
            i = j;
        }
    }
}
int main() {
    vector<Activity> activities = {
        {1, 4}, {3, 5}, {0, 6}, {5, 7}, 
        {3, 8}, {5, 9}, {6, 10}, {8, 11}, 
        {8, 12}, {2, 13}, {12, 14}
    };
    
    printMaxActivities(activities);
    return 0;
}

4.1.4 为什么贪心算法有效？

这个问题满足贪心选择性质和最优子结构性质：

• 贪心选择性质：选择结束时间最早的活动不会影响后续选择的最优性
• 最优子结构性质：在选择了第一个活动后，剩余问题仍然是活动选择问题

4.2 哈夫曼编码

4.2.1 问题描述

给定一组字符及其出现频率，为每个字符设计一个二进制编码，使得：

1. 没有编码是另一个编码的前缀（前缀码）
2. 所有字符的编码长度乘以其频率的总和（加权路径长度）最小

4.2.2 贪心策略

合并最小频率：每次合并频率最低的两个节点，形成一个新的节点，其频率为两者之和。

4.2.3 C++实现

#include <iostream>
#include <queue>
#include <vector>
#include <unordered_map>
using namespace std;
// 哈夫曼树节点
struct HuffmanNode {
    char data;
    int freq;
    HuffmanNode *left, *right;
    
    HuffmanNode(char data, int freq) : data(data), freq(freq), left(nullptr), right(nullptr) {}
};
// 用于优先队列的比较函数
struct Compare {
    bool operator()(HuffmanNode* l, HuffmanNode* r) {
        return l->freq > r->freq;
    }
};
// 打印哈夫曼编码
void printCodes(HuffmanNode* root, string str) {
    if (!root) return;
    
    // 如果是叶子节点，打印字符和编码
    if (!root->left && !root->right) {
        cout << root->data << ": " << str << endl;
    }
    
    printCodes(root->left, str + "0");
    printCodes(root->right, str + "1");
}
// 构建哈夫曼树并生成编码
void HuffmanCodes(const vector<char>& data, const vector<int>& freq) {
    int n = data.size();
    
    // 创建优先队列（最小堆）
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, Compare> minHeap;
    
    // 为每个字符创建节点并加入堆
    for (int i = 0; i < n; ++i) {
        minHeap.push(new HuffmanNode(data[i], freq[i]));
    }
    
    // 构建哈夫曼树
    while (minHeap.size() != 1) {
        // 取出两个频率最低的节点
        HuffmanNode* left = minHeap.top();
        minHeap.pop();
        
        HuffmanNode* right = minHeap.top();
        minHeap.pop();
        
        // 创建新节点，频率为两者之和
        HuffmanNode* newNode = new HuffmanNode('$', left->freq + right->freq);
        newNode->left = left;
        newNode->right = right;
        
        minHeap.push(newNode);
    }
    
    // 剩下的节点是哈夫曼树的根
    HuffmanNode* root = minHeap.top();
    
    // 打印编码
    cout << "哈夫曼编码：" << endl;
    printCodes(root, "");
}
int main() {
    vector<char> data = {'a', 'b', 'c', 'd', 'e', 'f'};
    vector<int> freq = {5, 9, 12, 13, 16, 45};
    
    HuffmanCodes(data, freq);
    
    return 0;
}

4.2.4 为什么贪心算法有效？

哈夫曼编码问题可以建模为拟阵问题：

• 基础集S：所有可能的二进制编码树
• 独立集I：满足前缀码性质的编码树集合
• 权重函数：编码树的加权路径长度
  贪心算法（合并最小频率）保证了每一步都做出局部最优选择，最终得到全局最优解。

4.3 最小生成树问题

4.3.1 问题描述

给定一个无向连通图，每条边都有权重，求一棵生成树（包含所有顶点的无环子图），使得所有边的权重总和最小。

4.3.2 贪心策略

有两种经典的贪心算法：

1. Kruskal算法：按权重从小到大选择边，只要不形成环
2. Prim算法：从一个顶点开始，每次选择连接当前树与未加入顶点的最小权重边

4.3.3 Kruskal算法的C++实现

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 边结构体
struct Edge {
    int src, dest, weight;
};
// 图结构体
struct Graph {
    int V, E;    // 顶点数和边数
    vector<Edge> edges;
    
    Graph(int V, int E) : V(V), E(E) {}
};
// 并查集结构
struct DisjointSet {
    int *parent, *rank;
    int n;
    
    DisjointSet(int n) {
        this->n = n;
        parent = new int[n];
        rank = new int[n];
        
        for (int i = 0; i < n; i++) {
            parent[i] = i;
            rank[i] = 0;
        }
    }
    
    // 查找根节点
    int find(int u) {
        if (parent[u] != u) {
            parent[u] = find(parent[u]);  // 路径压缩
        }
        return parent[u];
    }
    
    // 合并两个集合
    void merge(int x, int y) {
        int xRoot = find(x);
        int yRoot = find(y);
        
        if (xRoot == yRoot) return;
        
        // 按秩合并
        if (rank[xRoot] < rank[yRoot]) {
            parent[xRoot] = yRoot;
        } else if (rank[xRoot] > rank[yRoot]) {
            parent[yRoot] = xRoot;
        } else {
            parent[yRoot] = xRoot;
            rank[xRoot]++;
        }
    }
};
// 按权重排序的比较函数
bool compareEdges(Edge a, Edge b) {
    return a.weight < b.weight;
}
// Kruskal算法
void KruskalMST(Graph& graph) {
    int V = graph.V;
    vector<Edge> result(V - 1);  // 最小生成树有V-1条边
    int e = 0;  // 结果边的索引
    int i = 0;  // 排序后边的索引
    
    // 按权重排序所有边
    sort(graph.edges.begin(), graph.edges.end(), compareEdges);
    
    // 创建并查集
    DisjointSet ds(V);
    
    // 遍历所有边
    while (e < V - 1 && i < graph.E) {
        Edge next_edge = graph.edges[i++];
        
        int x = ds.find(next_edge.src);
        int y = ds.find(next_edge.dest);
        
        // 如果加入这条边不会形成环
        if (x != y) {
            result[e++] = next_edge;
            ds.merge(x, y);
        }
    }
    
    // 打印最小生成树
    cout << "最小生成树的边：" << endl;
    int minimumCost = 0;
    for (i = 0; i < e; ++i) {
        cout << result[i].src << " -- " << result[i].dest << " == " << result[i].weight << endl;
        minimumCost += result[i].weight;
    }
    cout << "最小总权重: " << minimumCost << endl;
}
int main() {
    int V = 4;  // 顶点数
    int E = 5;  // 边数
    Graph graph(V, E);
    
    // 添加边
    graph.edges = {
        {0, 1, 10},
        {0, 2, 6},
        {0, 3, 5},
        {1, 3, 15},
        {2, 3, 4}
    };
    
    KruskalMST(graph);
    
    return 0;
}

4.3.4 为什么贪心算法有效？

最小生成树问题可以建模为拟阵问题：

• 基础集S：图的所有边
• 独立集I：不形成环的边集合（即森林）
• 权重函数：边的权重
  这个拟阵称为图拟阵，它满足：

1. 遗传性：森林的任何子集仍然是森林
2. 交换性：如果A和B是森林且|A| < |B|，则存在边e ∈ B - A，使得A ∪ {e}仍然是森林
   因此，贪心算法（Kruskal或Prim）能够找到最小生成树。

五、拟阵在贪心算法中的应用

5.1 拟阵如何保证贪心算法的正确性？

拟阵理论为贪心算法提供了坚实的理论基础：

1. 问题建模：将优化问题建模为拟阵上的加权问题
2. 贪心选择：在每一步选择权重最大的独立元素
3. 最优性保证：拟阵的性质确保这种贪心选择能得到全局最优解

5.2 拟阵与贪心算法的通用框架

// 通用贪心算法框架（基于拟阵）
template<typename S, typename I, typename W>
I GreedyAlgorithm(S baseSet, I independentSets, W weight) {
    I solution = emptySet();
    
    // 按权重降序排序所有元素
    sort(baseSet.begin(), baseSet.end(), 
         [&](auto a, auto b) { return weight(a) > weight(b); });
    
    for (auto element : baseSet) {
        // 如果加入当前元素后仍然是独立集
        if (isIndependent(solution ∪ {element})) {
            solution = solution ∪ {element};
        }
    }
    
    return solution;
}

5.3 拟阵理论的实际意义

拟阵理论不仅具有理论价值，还有实际意义：

1. 算法设计指导：帮助我们识别哪些问题适合用贪心算法解决
2. 正确性证明：为贪心算法的正确性提供严格证明
3. 问题分类：将组合优化问题分类，便于选择合适的算法

六、贪心算法的局限性

6.1 贪心算法的陷阱

贪心算法并不总是有效的，以下是几个经典例子：

6.1.1 零钱问题

问题：给定不同面额的硬币和一个总金额，计算凑成总金额所需的最少硬币个数。

• 贪心策略：每次选择面额最大的硬币
• 反例：硬币面额为{1, 3, 4}，目标金额为6
  • 贪心解：4 + 1 + 1 = 6（3枚硬币）
  • 最优解：3 + 3 = 6（2枚硬币）

6.1.2 旅行商问题

问题：给定一组城市和每对城市之间的距离，求访问每座城市一次并回到起始城市的最短回路。

• 贪心策略：每次选择最近的未访问城市
• 问题：这种策略容易陷入局部最优，无法保证全局最优

6.2 如何判断贪心算法是否适用？

判断贪心算法是否适用于某个问题，可以尝试以下方法：

1. 数学证明：证明问题具有贪心选择性质和最优子结构性质
2. 拟阵建模：尝试将问题建模为拟阵问题
3. 小规模测试：在小规模问题上测试贪心策略是否总能得到最优解
4. 反例搜索：尝试寻找贪心策略失效的反例

七、总结与展望

7.1 贪心算法的核心思想

贪心算法的核心思想是**“局部最优导致全局最优”**。虽然这个假设并不总是成立，但在许多实际问题中，贪心算法能够提供简单而高效的解决方案。

7.2 拟阵的理论价值

拟阵理论为贪心算法提供了坚实的理论基础，它：

• 揭示了贪心算法适用的本质条件
• 提供了证明贪心算法正确性的通用方法
• 将组合优化问题系统化分类

7.3 实践建议

在实际应用中，建议：

1. 优先考虑贪心算法：对于简单问题，先尝试贪心策略
2. 验证正确性：通过数学证明或测试验证贪心策略的正确性
3. 结合其他方法：当贪心算法失效时，考虑动态规划、回溯等方法
4. 理解拟阵理论：深入理解拟阵理论有助于设计更高效的算法

7.4 未来发展方向

贪心算法和拟阵理论仍在不断发展：

1. 在线贪心算法：处理信息不完全 revealed 的问题
2. 随机贪心算法：结合随机化技术提高性能
3. 近似贪心算法：对于NP难问题，设计保证近似比的贪心算法
4. 拟阵的扩展：研究更广泛的组合结构，如 gammoid、bipartite matching 等
   贪心算法和拟阵理论是计算机科学中优雅而强大的工具，掌握它们不仅能解决实际问题，还能培养算法思维和问题解决能力。

到这里c++基本算法就讲完了，接下来进入跟深搜索纪元。