贪心算法：程序员的“先下手为强“生存法则（C++实战篇）_贪心算法的三个典型代表有哪三个-优快云博客

本文链接：https://blog.youkuaiyun.com/pythoneer1/article/details/148054726

文章目录

当程序员的直觉遇见数学之美

“哎！这个问题看起来用暴力解法要超时啊…”（抓头发）相信每个程序员都经历过这种时刻。这时候不妨试试贪心算法——这个看似简单实则暗藏玄机的解题思路！

贪心算法（Greedy Algorithm）就像它的名字一样"贪心"：每次选择当前看起来最优的解决方案。这种"活在当下"的思维方式，让它在某些问题上展现出惊人的效率（特别是在笔试面试中！）

一、解密贪心算法的"三板斧"

1.1 算法核心思想（划重点！）

局部最优 → 全局最优
不做回溯（这点和动态规划完全不同！）
需要数学证明支撑（翻车重灾区！）

举个栗子🌰：超市找零问题。假设有面值100、50、20、10、5、1元的纸币，要找给客人36元。收银员会怎么做？

vector<int> greedyChange(int amount) {
    vector<int> coins = {100,50,20,10,5,1};
    vector<int> result;
    
    for(int coin : coins) {
        while(amount >= coin) {
            result.push_back(coin);
            amount -= coin;
        }
    }
    return result;
}
// 输入36 → 输出20+10+5+1*1

1.2 三个必备条件（缺一不可！）

贪心选择性质：局部最优能导致全局最优
最优子结构：问题的最优解包含子问题的最优解
无后效性：选择之后不会影响后续选择

（敲黑板）很多同学在这里踩坑！比如经典的旅行商问题(TSP)，用贪心算法就得不到最优解！

二、C++实现三大经典案例

2.1 活动选择问题（面试必考题！）

假设有N个活动，如何安排最多数量不冲突的活动？

struct Activity {
    int start;
    int end;
};

bool compare(Activity a, Activity b) {
    return a.end < b.end; // 按结束时间排序
}

vector<Activity> selectActivities(vector<Activity>& activities) {
    sort(activities.begin(), activities.end(), compare);
    vector<Activity> result;
    int lastEnd = 0;
    
    for(auto& act : activities) {
        if(act.start >= lastEnd) {
            result.push_back(act);
            lastEnd = act.end;
        }
    }
    return result;
}

2.2 霍夫曼编码（压缩算法核心）

这个实现稍微复杂些，咱们看关键部分：

struct Node {
    char data;
    unsigned freq;
    Node *left, *right;
    
    Node(char data, unsigned freq) 
        : data(data), freq(freq), left(nullptr), right(nullptr) {}
};

struct compare {
    bool operator()(Node* l, Node* r) {
        return l->freq > r->freq; // 最小堆
    }
};

// 构建霍夫曼树的关键代码
priority_queue<Node*, vector<Node*>, compare> minHeap;
for(auto& pair : freqMap)
    minHeap.push(new Node(pair.first, pair.second));

while(minHeap.size() != 1) {
    Node *left = minHeap.top(); minHeap.pop();
    Node *right = minHeap.top(); minHeap.pop();
    
    Node *top = new Node('$', left->freq + right->freq);
    top->left = left;
    top->right = right;
    minHeap.push(top);
}

2.3 加油站问题（LeetCode 134）

这个问题的贪心解法非常巧妙：

int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
    int total = 0, current = 0, start = 0;
    
    for(int i=0; i<gas.size(); i++) {
        total += gas[i] - cost[i];
        current += gas[i] - cost[i];
        
        if(current < 0) {
            start = i + 1;
            current = 0;
        }
    }
    return total >=0 ? start : -1;
}

三、贪心算法的"生存法则"

3.1 适用场景（重点标记！）

任务调度（CPU/线程调度）
网络路由优化
数据压缩
图论中的最短路径（部分情况）
资源分配问题

3.2 翻车预警（血的教训！）

硬币问题变种：如果硬币面值不是标准值（比如有7元硬币），贪心就会出错！
0-1背包问题：贪心只能得到近似解
股票买卖问题：部分变种不能用贪心

（真实案例）当年做电商促销系统，想用贪心算法分配优惠券，结果因为没考虑用户历史消费数据，导致大客户流失…😭

四、进阶技巧：如何证明贪心策略

4.1 三大证明方法

交换论证法：通过交换元素位置证明最优
归纳法：数学归纳法证明
反证法：假设存在更优解导出矛盾

4.2 实战演练：活动选择问题的证明

假设存在一个最优解B，我们构造的解是A：

比较第一个不同的活动
用A中的活动替换B中的活动
证明替换后的解仍然有效且数量相同

（思考题）尝试证明霍夫曼编码的最优性！

五、从C++实现看优化技巧

5.1 性能优化点

优先使用sort()替代手动排序
灵活使用优先队列（priority_queue）
注意STL容器的选择（vector vs list）

5.2 常见坑点

// 错误示例：忘记传递引用导致拷贝开销
bool compare(Activity a, Activity b) { ... } // 应该用const&

// 正确写法
bool compare(const Activity& a, const Activity& b) {
    return a.end < b.end;
}