算法分析与设计课程复习之贪心法

算法分析与设计课程复习之贪心法

一、定义

贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。

二、贪心算法与动态规划算法的区别

贪心算法通常用来于求解最优化问题，即量的最大化或最小化。
然而，贪心算法不像动态规划算法，它通常包含一个用以寻找局部最优解的迭代过程。在某些实例中，这些局部最优解转变成了全局最优解，而在另外一些情况下，则无法找到最优解。

三、贪心算法的基本要素

• 贪心选择性质

所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。

• 最优子结构性质

当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。

四、经典问题

1.分数背包问题

给出n个大小为s1, s2,… , sn，价值为v1 ,v2,…,vn的物品，并设背包容量为C。试设计一个贪心算法，找到非负实数x1,x2,…xn使和在约束下最大。

贪心算法体现：每次选择比率最大的物品

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e2+10;
int n;
double V;
double w[N],v[N];
struct Goods{
    double w,v;
    bool operator<(const Goods x)const{
        return w/v<x.w/x.v;//按照比率从小到大进行排序
    }
}goods[N];
int main()
{
    cin>>n>>V;
    for(int i=1;i<=n;i++)
    {
        cin>>goods[i].w;
    }
    for(int i=1;i<=n;i++)
    {
        cin>>goods[i].v;
    }
    sort(goods+1,goods+n+1);
    double sumW=0.0;
    double sumV=0.0;
    for(int i=n;i>=1;i--)//从比率大的开始选择
    {
        if(sumV<V)
        {
            sumV+=goods[i].v;
            sumW+=goods[i].w;
            if(sumV>V)//当体积超过最大体积后，按照比例放入当前的物品
            {
                sumW-=goods[i].w;
                sumV-=goods[i].v;
                sumW+=((V-sumV)/goods[i].v)*goods[i].w;
                break;
            }
        }
    }
    cout<<sumV<<endl;
    return 0;
}

2.最短路径问题

单源最短路径问题，或者简称为最短路径问题，是要确定从s到V中每一个其他顶点的距离，这里从顶点s到顶点x的距离定义为从s到x的最短路径的长度。

Dijkstra算法

贪心算法体现：每次选择最短距离的点

int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < n - 1; i ++ )
    {
        int t = -1;     // 在还未确定最短路的点中，寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);

        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

3.最小生成树

设G = (V, E)是一个具有含权边的连通无向图。G的一裸生成树(V, T)是G的作为树的子图。如给G加权并且T的各边的权的和为最小值，那么(V,T)就称为最小耗费生成树或简称为最小生成树

3.1Kruskal算法（加边法）

贪心算法体现：每次选择边权最小的边

int n, m;       // n是点数，m是边数
int p[N];       // 并查集的父节点数组

struct Edge     // 存储边
{
    int a, b, w;

    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

int find(int x)     // 并查集核心操作
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edges, edges + m);

    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集

    int res = 0, cnt = 0;
    for (int i = 0; i < m; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        a = find(a), b = find(b);
        if (a != b)     // 如果两个连通块不连通，则将这两个连通块合并
        {
            p[a] = b;
            res += w;
            cnt ++ ;
        }
    }

    if (cnt < n - 1) return INF;
    return res;
}

3.2Prim算法（加点法）

贪心算法体现：每次选择边权最小的点

int n;      // n表示点数
int g[N][N];        // 邻接矩阵，存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中

// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
    memset(dist, 0x3f, sizeof dist);

    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if (i && dist[t] == INF) return INF;//表明图不连通

        if (i) res += dist[t];
        st[t] = true;

        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);//更新距离
    }
    return res;
}

4.哈夫曼树（前缀码）

哈夫曼树的特点：树的带权路径长度之和最小

贪心算法体现：每次选择权重最小的两个点

//采用小根堆维护所有的节点，每次弹出两个节点，并将其合并，合并之后的权重再次插入小根堆中
//priority_queue<int, vector<int>, greater<int>> heap;//定义一个小根堆
//此题为变式题，仅体现贪心算法思想
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
int main()
{
    int n;cin>>n;
    priority_queue<int,vector<int>,greater<int>> heap;
    int sum=0;
    while(n--)
    {
        int x;cin>>x;
        heap.push(x);
    }
    while(heap.size()>1)
    {
        int a=heap.top();heap.pop();
        int b=heap.top();heap.pop();
        heap.push(a+b);
        sum+=a+b;
    }
    cout<<sum<<endl;
    return 0;
}

5.会场安排问题

假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。设计一个有效的贪心算法进行安排。(这个问题实际上是著名的 。若将每一个活动作为图的一个顶点，不相容活动间用边相连。使相邻顶点着有不同颜色的最小着色数，相应于要找的最小会场数。)

贪心算法体现：对活动的开始时间进行从小到大排序，根据活动结束时间快慢判断是否需要增加会场

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
struct node{
    int start;
    int end;
    bool operator <(const node p)const
    {
        return start<p.start;//按照开始时间的大小从小到大排序
    }
};
int n;
int main()
{
    cin>>n;
    node p[n];
    for(int i=0;i<n;i++)
    {
        cin>>p[i].start>>p[i].end;
    }
    sort(p,p+n);
    priority_queue<int, vector<int>, greater<int> > heap;//小根堆维护结束时间
    for(int i=0;i<n;i++)
    {
        node r = p[i];
        if(heap.empty()||heap.top()>=r.start)//活动结束的时间大于下一个活动开始的时间，下一个活动需要另外一个会场，即数量+1
        {
            heap.push(r.end);
        }
        else//不需要另外一个会场
        {
            heap.pop();
            heap.push(r.end);//更新该会场的结束时间
        }
    }
    cout<<heap.size()<<endl;
    return 0;
}

6.程序存储问题

设有n个程序{1,2,…, n }要存放在长度为L 的磁带上。程序i存放在磁带上的长度是li，1≤i≤n 。程序存储问题要求确定这n个程序在磁带上的一个存储方案，使得能够在磁带上存储尽可能多的程序。

贪心算法体现：每次选择长度最小的程序

#include <iostream>
#include <algorithm>
using namespace std;
bool cmp(int x,int y)
{
    return x<y;
}
int main()
{
    int n;cin>>n;
    int Max;cin>>Max;
    int a[n];
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    sort(a,a+n,cmp);//按照从小到大排序
    int k=0;
    int sum=0;
    while(sum<=Max)
    {
        sum+=a[k++];
    }
    cout<<k-1<<endl;
    return 0;
}

7.最优分解问题

设n 是一个正整数。现在要求将n 分解为若干个互不相同的自然数的和，且使这些自然数的乘积最大。

整数的一个性质：若 a + b =N(常数)，则| a - b |越小， a * b 越大

贪心算法体现：将n分成从2开始的连续自然数的和，如果最后剩下一个数，将此数在后项优先的方式下均匀地分给前面各项。

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n;cin>>n;
	int x=n;
	int i=2,j=0,a[99999];
	while(x>=i)
  {
		a[j++]=i;
		x=x-i;
		i++;
	}
	int p=j;//记录分解的因数的个数
	j--;//最后一个a数组所在位置的下标 
	while(x--)
  {
		a[j]++;
		j=(j-1+p)%p;//考虑到剩余的数大于分解的因数的个数的情况 
	}
	int sum=1;
	for(int s=0; s<p; s++) {
		sum=sum*a[s];
	}
	cout<<sum<<endl;
	return 0;
}