版权声明:请尊重原创成果,未经允许,禁止转载 https://blog.csdn.net/qq_31441951/article/details/87814102
一、什么是贪心算法
贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,他所做出的是在某种意义上的局部最优解。
1.1 基本要素
- 贪心选择
贪心选择是指所求问题的整体最优解可以通过一系列局部最优的选择,即贪心选择来达到。
通常可以首先证明问题的一个整体最优解,是从贪心选择开始的,而且作了贪心选择后,原问题简化为一个规模更小的类似子问题。然后,用数学归纳法证明,通过每一步贪心选择,最终可得到问题的一个整体最优解。
- 最优子结构
当一个问题的最优解包含其子问题的最优解时,称此问题具有最优子结构性质。
贪心算法的基本思路是从问题的某一个初始解出发一步一步地进行,根据某个优化测度,每一步都要确保能获得局部最优解。每一步只考虑一个数据,他的选取应该满足局部优化的条件。若下一个数据和部分最优解连在一起不再是可行解时,就不把该数据添加到部分解中,直到把所有数据枚举完,或者不能再添加算法停止。
二、经典案例
2.1 加勒比海盗船 ——最优装载问题
按重量货物,每次由小到大。
2.2 背包问题
按性价比转载货物,每次由大到小。
2.3 会议安排问题
要求有限时间开更多的会议。(挑选每次最早结束,同时相容的会议子集)
2.4 最短路径问题
从一个顶点到其余各顶点的最短路径算法,解决的是有向图中最短路径问题。
Dijkstra算法(迪杰斯特拉算法)
参考代码:
#include<cstdio>
#include<iostream>
#include<cstring>
#include<Windows.h>
#include<stack>
using namespace std;
const int N = 10;
const int INF = 1e7;
int map[N][N], dist[N], p[N], n, m;//n:城市的个数,m:城市间路线的条数
bool flag[N];//如果flag[i]=true,说明顶点i已加入到集合S;
void Dijkstra(int u)
{
//1.初始化当前所知最小距离dist[i]、两点之间是否相连
for (int i = 1; i <= n; i++)
{
dist[i] = map[u][i];//源点u到顶点i距离
flag[i] = false;
if (dist[i] == INF)
p[i] = -1;
else
p[i] = u;
}
//2.初始时,集合S中只有一个元素:源点u
dist[u] = 0;
flag[u] = true;
for (int i = 1; i <= n; i++)
{
int temp = INF,t=u;
for (int j = 1; j <= n;j++)//3.在集合V-S中找距离u最近的顶点t
if (!flag[j] && dist[j] < temp)
{
t = j;
temp = dist[j];
}
if (t == u)return;//找不到t,跳出循环
flag[t] = true;
for (int j = 1; j <= n;j++)//4.找到t,更新集合V-S中的t与源点的距离
if (!flag[j] && map[t][j]<INF)
if (dist[j]>(dist[t] + map[t][j]))
{
dist[j] = dist[t] + map[t][j];
p[j] = t;
}
}
}
void findpath(int u)
{
int x;
stack<int>s;
cout << "源点为:" << u << endl;
for (int i = 1; i <= n; i++)
{
x = p[i];
while (x != -1)
{
s.push(x);
x = p[x];
}
cout << "源点到各顶点最短路径为:";
while (!s.empty())
{
cout << s.top() << "--";
s.pop();
}
cout << i << ";最短距离为:" << dist[i] << endl;
}
}
int main()
{
int u, v, w, st;
system("color 0d");
cout << "请输入城市的个数:" << endl;
cin >> n;
cout << "请输入城市之间的路线的个数:" << endl;
cin >> m;
cout << "请输入城市之间的路线及距离:" << endl;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
map[i][j] = INF;
while (m--)
{
cin >> u >> v >> w;
map[u][v] = min(map[u][v], w);//邻接矩阵储存,保留最小的距离
}
cout << "请输入小明所在的位置:" << endl;
cin >> st;
Dijkstra(st);
cout << "小明所在位置:" << st << endl;
for (int i = 1; i < n; i++)
{
cout << "小明:" << st << " - 要去的位置:" << i << " ";
if (dist[i] == INF)
cout << "no way!!" << endl;
else
cout << "最短距离为:" << dist[i] << endl;
}
findpath(st);
while (1);
return 0;
}
2.5 哈夫曼编码
按使用频率优先,最后形成Huffman树。
参考代码:
//haffman 树的结构
typedef struct
{
//叶子结点权值
unsigned int weight;
//指向双亲,和孩子结点的指针
unsigned int parent;
unsigned int lChild;
unsigned int rChild;
} Node, *HuffmanTree;
//动态分配数组,存储哈夫曼编码
typedef char *HuffmanCode;
//选择两个parent为0,且weight最小的结点s1和s2的方法实现
//n 为叶子结点的总数,s1和 s2两个指针参数指向要选取出来的两个权值最小的结点
void select(HuffmanTree *huffmanTree, int n, int *s1, int *s2)
{
//标记 i
int i = 0;
//记录最小权值
int min;
//遍历全部结点,找出单节点
for(i = 1; i <= n; i++)
{
//如果此结点的父亲没有,那么把结点号赋值给 min,跳出循环
if((*huffmanTree)[i].parent == 0)
{
min = i;
break;
}
}
//继续遍历全部结点,找出权值最小的单节点
for(i = 1; i <= n; i++)
{
//如果此结点的父亲为空,则进入 if
if((*huffmanTree)[i].parent == 0)
{
//如果此结点的权值比 min 结点的权值小,那么更新 min 结点,否则就是最开始的 min
if((*huffmanTree)[i].weight < (*huffmanTree)[min].weight)
{
min = i;
}
}
}
//找到了最小权值的结点,s1指向
*s1 = min;
//遍历全部结点
for(i = 1; i <= n; i++)
{
//找出下一个单节点,且没有被 s1指向,那么i 赋值给 min,跳出循环
if((*huffmanTree)[i].parent == 0 && i != (*s1))
{
min = i;
break;
}
}
//继续遍历全部结点,找到权值最小的那一个
for(i = 1; i <= n; i++)
{
if((*huffmanTree)[i].parent == 0 && i != (*s1))
{
//如果此结点的权值比 min 结点的权值小,那么更新 min 结点,否则就是最开始的 min
if((*huffmanTree)[i].weight < (*huffmanTree)[min].weight)
{
min = i;
}
}
}
//s2指针指向第二个权值最小的叶子结点
*s2 = min;
}
//创建哈夫曼树并求哈夫曼编码的算法如下,w数组存放已知的n个权值
void createHuffmanTree(HuffmanTree *huffmanTree, int w[], int n)
{
//m 为哈夫曼树总共的结点数,n 为叶子结点数
int m = 2 * n - 1;
//s1 和 s2 为两个当前结点里,要选取的最小权值的结点
int s1;
int s2;
//标记
int i;
// 创建哈夫曼树的结点所需的空间,m+1,代表其中包含一个头结点
*huffmanTree = (HuffmanTree)malloc((m + 1) * sizeof(Node));
//1--n号存放叶子结点,初始化叶子结点,结构数组来初始化每个叶子结点,初始的时候看做一个个单个结点的二叉树
for(i = 1; i <= n; i++)
{
//其中叶子结点的权值是 w【n】数组来保存
(*huffmanTree)[i].weight = w[i];
//初始化叶子结点(单个结点二叉树)的孩子和双亲,单个结点,也就是没有孩子和双亲,==0
(*huffmanTree)[i].lChild = 0;
(*huffmanTree)[i].parent = 0;
(*huffmanTree)[i].rChild = 0;
}// end of for
//非叶子结点的初始化
for(i = n + 1; i <= m; i++)
{
(*huffmanTree)[i].weight = 0;
(*huffmanTree)[i].lChild = 0;
(*huffmanTree)[i].parent = 0;
(*huffmanTree)[i].rChild = 0;
}
printf("\n HuffmanTree: \n");
//创建非叶子结点,建哈夫曼树
for(i = n + 1; i <= m; i++)
{
//在(*huffmanTree)[1]~(*huffmanTree)[i-1]的范围内选择两个parent为0
//且weight最小的结点,其序号分别赋值给s1、s2
select(huffmanTree, i-1, &s1, &s2);
//选出的两个权值最小的叶子结点,组成一个新的二叉树,根为 i 结点
(*huffmanTree)[s1].parent = i;
(*huffmanTree)[s2].parent = i;
(*huffmanTree)[i].lChild = s1;
(*huffmanTree)[i].rChild = s2;
//新的结点 i 的权值
(*huffmanTree)[i].weight = (*huffmanTree)[s1].weight + (*huffmanTree)[s2].weight;
printf("%d (%d, %d)\n", (*huffmanTree)[i].weight, (*huffmanTree)[s1].weight, (*huffmanTree)[s2].weight);
}
printf("\n");
}
//哈夫曼树建立完毕,从 n 个叶子结点到根,逆向求每个叶子结点对应的哈夫曼编码
void creatHuffmanCode(HuffmanTree *huffmanTree, HuffmanCode *huffmanCode, int n)
{
//指示biaoji
int i;
//编码的起始指针
int start;
//指向当前结点的父节点
int p;
//遍历 n 个叶子结点的指示标记 c
unsigned int c;
//分配n个编码的头指针
huffmanCode=(HuffmanCode *)malloc((n+1) * sizeof(char *));
//分配求当前编码的工作空间
char *cd = (char *)malloc(n * sizeof(char));
//从右向左逐位存放编码,首先存放编码结束符
cd[n-1] = '\0';
//求n个叶子结点对应的哈夫曼编码
for(i = 1; i <= n; i++)
{
//初始化编码起始指针
start = n - 1;
//从叶子到根结点求编码
for(c = i, p = (*huffmanTree)[i].parent; p != 0; c = p, p = (*huffmanTree)[p].parent)
{
if( (*huffmanTree)[p].lChild == c)
{
//从右到左的顺序编码入数组内
cd[--start] = '0'; //左分支标0
}
else
{
cd[--start] = '1'; //右分支标1
}
}// end of for
//为第i个编码分配空间
huffmanCode[i] = (char *)malloc((n - start) * sizeof(char));
strcpy(huffmanCode[i], &cd[start]);
}
free(cd);
//打印编码序列
for(i = 1; i <= n; i++)
{
printf("HuffmanCode of %3d is %s\n", (*huffmanTree)[i].weight, huffmanCode[i]);
}
printf("\n");
}
int main(void)
{
HuffmanTree HT;
HuffmanCode HC;
int *w,i,n,wei,m;
printf("\nn = " );
scanf("%d",&n);
w=(int *)malloc((n+1)*sizeof(int));
printf("\ninput the %d element's weight:\n",n);
for(i=1; i<=n; i++)
{
printf("%d: ",i);
fflush(stdin);
scanf("%d",&wei);
w[i]=wei;
}
createHuffmanTree(&HT, w, n);
creatHuffmanCode(&HT,&HC,n);
return 0;
}