算法篇-7-贪心算法-Huffman编码&Dijkstra单源最短路径&Kruskal最小生成树

本系列所有代码https://github.com/YIWANFENG/Algorithm-github

huffman编码

题目：

依据给定字符以及相应频率构造该字符的哈夫曼编码。

 

算法思路分析与相关公式：

Haffman即前缀码，用一棵二叉树即可标示，树叶表示给定的字符，每个字符的前缀码就是从树根到该字符所在的树叶的一条道路。二叉树的每一路分支的路径我们在向右时即为1 ，向左时即为0。构造一棵haffman树即可得出我们的编码。

 

要使空间节约，那么使用频率低的字符编码长点，使用频率高的编码短点，对应的为相应的叶子节点的深度值大或者小。我们每次选择总频率小的子树的合并为新子树（频率为子树总频率之和），然后如此重复来得到最终编码树。（叶子结点视为频率为该节点的频率）。

 

 

程序源代码：

class cmp {
public:
booloperator() (const int &a,const int &b) {
if(a>b) return true;
return false;
}
};

class CHuffmanChar {
public:
charc_;                   //保存字符
CHuffmanChar*parent_; //指向父节点
intchild_type_ ;            //1==left子节点  0 == right
};

class CHuffmanChar_Heap {
public:
intindex_;                    //原始编号
floatweight_;        //权重
booloperator < (const CHuffmanChar_Heap &c2) const {
return weight_ > c2.weight_;
}
};

void HuffmanEncoding(int n, const chardata[], float fre[])
{
//Huffman编码
//n字符数量
//data[]原始字符
//fre[]字符出现的频率
CHuffmanCharhc[n + n-1]; //中间出现节点数n-1
inti, j;
for(i=0;i<n; ++i)
hc[i].c_ = data[i];
for(i=0;i<n+n-1; ++i)
hc[i].parent_ = NULL;

priority_queue<CHuffmanChar_Heap>q;
CHuffmanChar_Heaph, hr;
for(i=0;i<n; ++i) {
h.index_= i;
h.weight_ = fre[i];
q.push(h);
}

for(i=0;i<n-1; ++i) {
h = q.top();
q.pop();
hr = q.top();
q.pop();
hc[h.index_].parent_ = &hc[n+i];
hc[h.index_].child_type_ = 1;
hc[hr.index_].parent_ = &hc[n+i];
hc[hr.index_].child_type_ = 0;
h.weight_ += hr.weight_;
h.index_ = n+i;
q.push(h);
}

charcode
;
for(i=0;i<n; ++i) {
//从子节点寻根而上
j = 0;
CHuffmanChar *pc = &hc[i];
while(pc->parent_!=NULL) {
code[j++]='1'-pc->child_type_;
pc= pc->parent_;
}
cout<<hc[i].c_<<':';
for(j--; j>=0; j--) {
cout<<code[j];
}
cout<<'\n';
}

}

Dijkstra单源最短路径

题目：

给定一带权有向图G=(V,E),求指定顶点X顶点的最短路径长度。

 

算法思路分析以及相关公式：

基本思想：设置顶点集合S并不断贪心扩充此集合。

首先确认两点，1：设从X到最短的顶点为x1（肯定是直达的），那么比这次短的顶点一定是直达的或者是从x1间接到达。 2：由1可知，设从X 到其他顶点第k短的是xk,(xk加入到S中)，那么第k+1短的顶点一定是直达或者经过S中某点间接到达的。

 

做法是设置集合S，来收集已经知道X到该点的最短路径的点。E保存不知最短路径的点

1．  首先选择一个属于E的点u，使X到u路径最短。

2．  将u加入到S，在E中取出u,并计算在u加入S后对在E中的点与X的最短距离的影响。

即判断所有在E中的点c，是否存在从X到u,再从u到c的距离比原本X到c的距离小，若小则更新，否则不处理。

1.若S包含所有点，则结束否则重复上述过程。

 

程序源代码:

template <class T_>
void Dijkstra_ShortestPath(int n,int v,T_dist[],int prev[],
const T_ *c,const T_ INF)
{
//n：(in)顶点数量
//v：(in)源顶点索引（0-...）
//dist[]"(out)从源定点 到每个定点的距离
//prev[]：(out) 在最短路径上每个定点的前面的一个顶点
//c(in)：两个顶点间的距离
bools
; // s[i]表示该点是否在最短路径已知的顶点集合内。
for(inti=0;i<n;i++) s[i] = false;

for(inti=0; i<n; ++i) {
dist[i]=c[v*n+i];
if(dist[i]==INF) prev[i] = -1;
else prev[i]=v;
}
//addv to s
dist[v]= 0;
s[v]= true;

for(inti=1; i<n; ++i) {
T_ dist_tmp = INF;
int u = v;
//选出该次到v最短的点，该点不属于s
for(int j=0; j<n; ++j) {
if(s[j])continue;
if(dist_tmp==INF|| dist[j]<dist_tmp) {
dist_tmp = dist[j];
u = j;
}
}
s[u] = true;
//加入该点后对其他点的影响
for(int j=0; j<n; ++j) {
if(s[j]|| c[u*n+j]==INF) continue;
T_dist_new = dist[u]+c[u*n+j];
if(dist_new<dist[j]){
dist[j]=dist_new;
prev[j] = u;
}
}
}
}

template<class  T_>
void Out(int n,int v,T_ dist[],int prev[])
{
//n：(in)顶点数量
//v：(in)源顶点索引（0-...）
//dist[]"(out)从源定点 到每个定点的距离
//prev[]：(out) 在最短路径上每个定点的前面的一个顶点
intpath_points[n*(n-1)/2+1];
inti,j,k;
for(i=0;i<n; ++i) {
if(i==v) continue;
cout<<"顶点"<<i<<",最短路径长度="<<dist[i]<<endl;

j=1;
path_points[0] =i;
k = i;
while(prev[k]!=v && prev[k]!=-1){
path_points[j++]= prev[k];
k=prev[k];
}
for(--j; j>=0; j--) {
cout<<path_points[j]<<" ";
}
cout<<endl;
}

}

int main() {

intn=5;
constfloat  INF = 65535;
floatdist
;
intprev
;
floatc[n*n];
constfloat graph_edges[] = {
0,10,INF,30,100,
10,0,50,INF,INF,
INF,50,0,20,10,
30,INF,20,0,60,
100,INF,10,60,0
};
for(inti=0;i<n*n;i++) {
c[i]=graph_edges[i];
}
Dijkstra_ShortestPath<float>(n,0,dist,prev,c,INF);
Out<float>(n,0,dist,prev);

cin.get();
return0;
}

 

Kruskal最小生成树

题目：

已知一幅图的顶点数n、边e以及边的权重w[i]，求一权重最小的生成树。

 

算法思路分析以及相关数学公式：

将G的n个顶点看成n个孤立的联通分支，将所有边按权从小到大排序，然后依次增加权重最小的边来连接两个独立的联通分支，在加边时，注意不可以让加入的边在图中构成回路。

直至加入了n-1条边或者加入的边数为e。

另一种求最小生成树的算法是prim算法，他是从顶点的角度考虑。

 

 

 

//////////并差集实现//////////////////
class CUnionFind {
public:
CUnionFind();
~CUnionFind();
voidInit(int num_elem) ;

intFindSubSet(int elem_id) ;

voidSubSetUnion(int set1,int ste2);
protected:
intn_;                   //元素数量
int*parent_id_;      //每个元素的父节点索引,-1表示该点为根节点
int*depth_;           //每个元素所属子树的深度
voidRelease();
};

void CUnionFind::Release() {
n_= 0;
if(parent_id_){
delete [] parent_id_;
parent_id_ = NULL;
}

if(depth_){
delete [] depth_;
depth_ = NULL;
}
}

CUnionFind::CUnionFind() {
n_= 0;
parent_id_= NULL;
depth_= NULL;
}

CUnionFind::~CUnionFind() {
Release();
}
void CUnionFind::Init(int num_elem) {
//元素编号从1开始
Release();
n_= num_elem;
parent_id_= new int[n_];
depth_= new int[n_];
for(inti=0;i<n_;++i) {
parent_id_[i]=-1;
depth_[i]=0;
}
}

int CUnionFind::FindSubSet(int elem_id) {
//返回元素elem_id所属自己的编号
inti = elem_id-1;
while(parent_id_[i]!=-1)
i = parent_id_[i];
returni;
}
void CUnionFind::SubSetUnion(int set1,intset2) {
//合并set1,set2
if(set1== set2) return ;
if(depth_[set1]==depth_[set2]){
parent_id_[set2] = set1;
depth_[set1]++;
}else if(depth_[set1]<depth_[set2]){
parent_id_[set1] = set2;
}else {
parent_id_[set2] = set1;
}
}

class Edge{
public:
intweight;
intu,v;
};
class cmp {
public:
booloperator() (Edge &a,Edge&b) {
return a.weight > b.weight;
}
};

bool Kruskal(int n,int e,Edge E[],Edge t[])
{
//n顶点数
//e边数
//E[]具体边
//t[](out)筛选出的边

priority_queue<Edge,vector<Edge>,cmp> q;
for(inti=0; i<e; ++i) {
q.push(E[i]);
}
CUnionFindU;
U.Init(n);

intk =0;
while(e&& k<n-1) {            //正常树应该会有n-1条边
Edge x;
x = q.top();
q.pop();
e--;
int a = U.FindSubSet(x.u);
int b = U.FindSubSet(x.v);

if(a!=b) {
t[k++]= x;
//cout<<"["<<x.u<<','<<x.v<<"]"<<endl;
U.SubSetUnion(a,b);
}
}

}
void Out(int n,Edge t[]) {
//n顶点数
//t[] 筛选出的边
for(inti=0;i<n-1;++i) {
cout<<"["<<t[i].u<<','<<t[i].v<<"]"<<endl;
}
}

int main() {
intn = 6;
EdgeE[10];
Edget[10];
E[0].u= 1;        E[1].u = 1;          E[2].u = 1;
E[0].v= 2;        E[1].v = 3;                 E[2].v = 4;
E[0].weight= 6;   E[1].weight = 1;     E[2].weight = 5;

E[3].u= 3;        E[4].u = 5;          E[5].u = 3;
E[3].v= 2;        E[4].v = 2;                 E[5].v = 4;
E[3].weight= 5;   E[4].weight = 3;     E[5].weight = 5;

E[6].u= 3;        E[7].u = 3;          E[8].u = 4;
E[6].v= 5;        E[7].v = 6;                 E[8].v = 6;
E[6].weight= 6;   E[7].weight = 4;     E[8].weight = 2;

E[9].u= 5;
E[9].v= 6;
E[9].weight= 6;

Kruskal(n,10,E,t);
Out(n,t);
cin.get();
return0;
}