貪心演算法哈夫曼編碼
㈠ 幾種經典演算法回顧
今天無意中從箱子里發現了大學時學演算法的教材《演算法設計與分析》，雖然工作這么幾年沒在什麼地方用過演算法，但演算法的思想還是影響深刻的，可以在系統設計時提供一些思路。大致翻了翻，重溫了一下幾種幾種經典的演算法，做一下小結。分治法動態規劃貪心演算法回溯法分支限界法分治法1）基本思想將一個問題分解為多個規模較小的子問題，這些子問題互相獨立並與原問題解決方法相同。遞歸解這些子問題，然後將這各子問題的解合並得到原問題的解。2）適用問題的特徵該問題的規模縮小到一定的程度就可以容易地解決該問題可以分解為若干個規模較小的相同問題，即該問題具有最優子結構性質該問題所分解出的各個子問題是相互獨立的，即子問題之間不包含公共的子問題3）關鍵如何將問題分解為規模較小並且解決方法相同的問題分解的粒度4）步驟分解->遞歸求解->合並 divide-and-conquer(P) { if ( | P | <= n0) adhoc(P); //解決小規模的問題 divide P into smaller subinstances P1,P2,...,Pk；//分解問題 for (i=1,i<=k,i++) yi=divide-and-conquer(Pi); //遞歸的解各子問題 return merge(y1,...,yk); //將各子問題的解合並為原問題的解 }google的核心演算法MapRece其實就是分治法的衍生5）分治法例子：合並排序規約過程：動態規劃1）基本思想將待求解問題分解成若干個子問題，但是經分解得到的子問題往往不是互相獨立的，如果能夠保存已解決的子問題的答案，而在需要時再找出已求得的答案，就可以避免大量重復計算2）適用問題的特徵最優子結構在遞歸計算中，許多子問題被重復計算多次3）步驟找出最優解的性質，並刻劃其結構特徵。遞歸地定義最優值。以自底向上的方式計算出最優值。根據計算最優值時得到的信息，構造最優解。貪心演算法1）基本思想貪心演算法總是作出在當前看來最好的選擇。也就是說貪心演算法並不從整體最優考慮，它所作出的選擇只是在某種意義上的局部最優選擇2）適用問題的特徵貪心選擇性質，即所求問題的整體最優解可以通過一系列局部最優的選擇，即貪心選擇來達到。最優子結構性質3）步驟：不斷尋找局部最優解4）例子：找硬幣，哈夫曼編碼，單源最短路徑，最小生成樹（Prim和Kruskal） 最小生成樹圖示：回溯法1）基本思想在問題的解空間樹中，按深度優先策略，從根結點出發搜索解空間樹。演算法搜索至解空間樹的任意一點時，先判斷該結點是否包含問題的解。如果肯定不包含，則跳過對該結點為根的子樹的搜索，逐層向其祖先結點回溯；否則，進入該子樹，繼續按深度優先策略搜索2）適用問題的特徵：容易構建所解問題的解空間3）步驟定義問題的解空間 確定易於搜索的解空間結構以深度優先方式搜索解空間，並在搜索過程中用剪枝函數避免無效搜索 4）回溯法例子：N皇後問題分支限界法1）基本思想分支限界法常以廣度優先或以最小耗費（最大效益）優先的方式搜索問題的解空間樹。 在分支限界法中，每一個活結點只有一次機會成為擴展結點。活結點一旦成為擴展結點，就一次性產生其所有兒子結點。在這些兒子結點中，導致不可行解或導致非最優解的兒子結點被舍棄，其餘兒子結點被加入活結點表中。此後，從活結點表中取下一結點成為當前擴展結點，並重復上述結點擴展過程。這個過程一直持續到找到所需的解或活結點表為空時為止。2）分支限界法例子：單源最短路徑問題問題描述：在下圖所給的有向圖G中，每一邊都有一個非負邊權。
㈡ 霍夫曼編程採用的是哪種編程原理
霍夫曼編碼的matlab實現一、實驗內容：用Matlab語言編程實現霍夫曼（Huffman）編碼。二、實驗原理及編碼步驟：霍夫曼（Huffman）編碼演算法是滿足前綴條件的平均二進制碼長最短的編-源輸出符號，而將較短的編碼碼字分配給較大概率的信源輸出。演算法是：在信源符號集合中，首先將兩個最小概率的信源輸出合並為新的輸出，其概率是兩個相應輸出符號概率之和。這一過程重復下去，直到只剩下一個合並輸出為止，這個最後的合並輸出符號的概率為1。這樣就得到了一張樹圖，從樹根開始，將編碼符號1和0分配在同一節點的任意兩分支上，這一分配過程重復直到樹葉。從樹根到樹葉途經支路上的編碼最後就構成了一組異前置碼，就是霍夫曼編碼輸出。
㈢ 霍夫曼編碼 用c語言實現
以前寫的，證明最優子結構，隨便一本演算法書上就有.
#include<stdio.h>
#include<stdlib.h>
#define
NIL
-2
#define
Size_Max_bm
30
#define
left(i)
(2*(i)+1)
#define
right(i)
(2*(i)+2)
#define
swap(a,b)
{cjys
t;t=(a);(a)=(b);(b)=t;}
#define
parent(i)
((i)%2?((i)-1)/2:((i)-2)/2)typedef
struct
cjys
{
char
sj;
int
pl;
struct
cjys
*left;
struct
cjys
*right;
}cjys;typedef
struct
cjdl
{
int
size;
int
leapsize;
cjys
*p;
}cjdl;
cjys
*fpnn(void);
void
input(cjdl
*p);
cjys
*fpnn(void);
void
zxdwh(cjys
*p,
int
i,
int
leapsize);
void
rd(cjdl
*p,
cjys
tp);
cjys
cd(cjdl
*p);
void
hbs(cjdl
*p);
cjys
*cjs(cjdl
*p);
void
bls(cjys
*p,int
*jl,
int
i);
void
disp(char
*tp,
cjys
*p);int
main()
{
cjdl
p;
char
x[255];
cjys
*re=NULL;
int
jl[Size_Max_bm];
input(&p);
re=cjs(&p);
printf("對照編碼圖為:\n");
bls(re,jl,0);
freopen("CON","r",stdin);
printf("輸入Huffman碼(VLC):");
scanf("%s",x);
disp(x,re);
system("pause");
}
void
input(cjdl
*p)
{
int
i;
cjys
*tp;
tp=fpnn();
printf("輸入字母個數:");
scanf("%d",
&p->size);
p->p=malloc(sizeof(cjys)*p->size);
p->leapsize=0;
for(i
=
0;
i
<
p->size;i++)
{
printf("輸入第%d字母:",i+1),scanf("
%c",&tp->sj);
printf("輸入出現次數(頻率整數):"),scanf("%d",&tp->pl);
rd(p,*tp);
}
free(tp);
}
cjys
*fpnn(void)
{
cjys
*p=NULL;
p=malloc(sizeof(cjys));
p->left=NULL;
p->right=NULL;
return
p;
}
void
zxdwh(cjys
*p,
int
i,
int
leapsize)
{
int
l=left(i),
r=right(i),
mini=i;
if(l<leapsize
&&
p[l].pl<p[mini].pl)
mini=l;
if(r<leapsize
&&
p[r].pl<p[mini].pl)
mini=r;
if(mini
!=
i)
{
swap(p[i],p[mini]);
zxdwh(p,mini,leapsize);
}
}
void
rd(cjdl
*p,
cjys
tp)
{
if(p->leapsize
==
p->size)
{
printf("隊列已滿!");
exit(0);
}
p->p[p->leapsize]=tp;
int
j=p->leapsize,k=parent(j);
while(k>=0
&&
p->p[j].pl
<
p->p[k].pl)
{
swap(p->p[j],p->p[k]);
j=k;
k=parent(j);
}
p->leapsize++;
}
cjys
cd(cjdl
*p)
{
if(p->leapsize
==
0)
{
printf("隊列已空!");
exit(0);
}
cjys
tp=p->p[0];
p->leapsize--;
p->p[0]=p->p[p->leapsize];
zxdwh(p->p,0,p->leapsize);
return
tp;
}
void
hbs(cjdl
*p)
{
cjys
*p1=NULL,
*p2=NULL;
cjys
tp;
p1=fpnn();
p2=fpnn();
*p1=cd(p);
*p2=cd(p);
tp.left=p1;
tp.right=p2;
tp.pl=p1->pl+p2->pl;
tp.sj=NIL;
rd(p,tp);
}cjys
*cjs(cjdl
*p)
{
int
i,
n=p->leapsize;
cjys
*tp=NULL;
tp=fpnn();
for(i
=
0;
i
<
n-1;
i++)
hbs(p);
*tp=p->p[0];
return
tp;
}
void
bls(cjys
*p,
int
*jl,
int
i)
{
if(p
==
NULL)
return;
if(p->sj!=NIL)
{
int
i2;
printf("%c:",p->sj);
for(i2
=
0;
i2
<
i;
i2++)
printf("%d",jl[i2]);
printf("\n");
}
jl[i]=0;
bls(p->left,jl,i+1);
jl[i]=1;
bls(p->right,jl,i+1);
}
void
disp(char
*tp,
cjys
*p)
{
cjys
*ttp=NULL;
int
pd=0;
while(1)
{
ttp=p;
while(1)
{
if(ttp->sj
!=
NIL)
{
printf("%c",ttp->sj);
break;
}
if(*tp
==
'\0')
{
pd=1;
break;
}
if(*tp++
==
'0'
)
ttp=ttp->left;
else
ttp=ttp->right;
}
if(pd)
break;
}
}
㈣ 貪心演算法：最小生成樹，霍夫曼編碼
連通圖： 在無向圖中，若任意兩個頂點vi與vj都有路徑相通，則稱該無向圖為連通圖。
強連通圖（Strongly Connected Graph） 是指在有向圖G中，如果對於每一對vi、vj，vi≠vj，從vi到vj和從vj到vi都存在路徑，則稱G是強連通圖。
連通網： 在連通圖中，若圖的邊具有一定的意義，每一條邊都對應著一個數，稱為權；權代表著連接連個頂點的代價，稱這種連通圖叫做連通網。
生成樹： 一個連通圖的生成樹是指一個連通子圖，它含有圖中全部n個頂點，但只有足以構成一棵樹的n-1條邊。一顆有n個頂點的生成樹有且僅有n-1條邊，如果生成樹中再添加一條邊，則必定成環。
最小生成樹： 在連通網的所有生成樹中，所有邊的代價和最小的生成樹，稱為最小生成樹。
示例：
分別使用 Kruskal演算法 和 Prim演算法 ，找出下圖的最小生成樹。
使用變長編碼表對源符號（如文件中的一個字母）進行編碼，其中變長編碼表是通過一種評估來源符號出現機率的方法得到的，出現機率高的字母使用較短的編碼，反之出現機率低的則使用較長的編碼，這便使編碼之後的字元串的平均長度、期望值降低，從而達到無損壓縮數據的目的。
具體步驟
1.將信源符號的概率按減小的順序排隊。
2.把兩個最小的概率相加，並繼續這一步驟，始終將較高的概率分支放在右邊，直到最後變成概率1。
3.畫出由概率1處到每個信源符號的路徑，順序記下沿路徑的0和1，所得就是該符號的霍夫曼碼字。
4.將每對組合的左邊一個指定為0，右邊一個指定為1（或相反）。
示例：
假設字元a,b,c,d,e出現的概率分別為1/2,1/4,1/8,1/16,1/16。
1.求出各字元哈夫曼編碼表。
2.假設一個文件有1,000,000個字元，求出編碼之後文件的位元組長度。
A:0
B:10
C:110
D:1110
E:1111
a所佔長度l1為：（1,000,000/2） 1
b所佔長度l2為：（1,000,000/4） 2
c所佔長度l3為：（1,000,000/8） 3
d所佔長度l4為：（1,000,000/16） 4
e所佔長度l5為：（1,000,000/16）*4
文件的總長度l = l1 + l2 + l3 + l4 + l5 = 1875000
㈤ 演算法09-貪心演算法
貪心演算法與動態規劃的不同在於它對每個子問題的解決方案都作出選擇，不能回退。動態規劃則會保存以前的運算結果，並根據以前的結果對當前進行選擇，有回退功能。
很多情況下，可以在某一步用貪心演算法，全局再加一個搜索或遞歸或動態規劃之類
貪心法可以解決一些最優化問題，如:求圖中的最小生成樹、求哈夫曼編碼等。然而對於工程和生活中的問題，貪心法一般不能得到我們所要求的答案。
一單一個問題可以通過貪心法來解決，那麼貪心法一般是解決這個問題的最好辦法。由於貪心法的高效性以及其所求得的答案比較接近最優結果，貪心法也可以用作輔助演算法或者直接解決一些要求結果不特別精確的問題。
當硬幣可選集合固定:Coins = [20,10,5,1],求最少幾個硬幣可以拼出總數。比如total=36。
36 - 20 = 16 20
16 - 10 = 6 20 10
6 - 5 = 1 20 10 5
1 - 1 = 0 20 10 5 1
前面這些硬幣依次是後面硬幣的整數倍，可以用貪心法，能得到最優解，
貪心法的反例
非整除關系的硬幣，可選集合:Coins = [10,9,1],求拼出總數為18最少需要幾個硬幣？
最優化演算法:9 + 9 = 18 兩個9
貪心演算法:18 - 10 = 8 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 = 0 八個1
簡單地說，問題能夠分解成子問題來解決，子問題的最優解能遞推到最終問題的最優解。這種子問題最優解成為最優子結構。
貪心演算法與動態規劃的不同在於它對每個子問題的最終方案都作出選擇，不能回退。
動態規劃則會保存以前的運算結果，並根據以前的結果對當前進行選擇，有回退功能。
假設你是一位很棒的家長，想要給你的孩子們一些小餅干。但是，每個孩子最多隻能給一塊餅干。
對每個孩子 i，都有一個胃口值 g[i]，這是能讓孩子們滿足胃口的餅乾的最小尺寸；並且每塊餅干 j，都有一個尺寸 s[j] 。如果 s[j] >= g[i]，我們可以將這個餅干 j 分配給孩子 i ，這個孩子會得到滿足。你的目標是盡可能滿足越多數量的孩子，並輸出這個最大數值。
示例 1:
輸入: g = [1,2,3], s = [1,1]
輸出: 1
解釋:
你有三個孩子和兩塊小餅干，3個孩子的胃口值分別是：1,2,3。
雖然你有兩塊小餅干，由於他們的尺寸都是1，你只能讓胃口值是1的孩子滿足。
所以你應該輸出1。
示例 2:
輸入: g = [1,2], s = [1,2,3]
輸出: 2
解釋:
你有兩個孩子和三塊小餅干，2個孩子的胃口值分別是1,2。
你擁有的餅干數量和尺寸都足以讓所有孩子滿足。
所以你應該輸出2.
提示：
1 <= g.length <= 3 * 104
0 <= s.length <= 3 * 104
1 <= g[i], s[j] <= 231 - 1
給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。
設計一個演算法來計算你所能獲取的最大利潤。你可以盡可能地完成更多的交易（多次買賣一支股票）。
注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。
示例 1:
輸入: [7,1,5,3,6,4]
輸出: 7
解釋: 在第 2 天（股票價格 = 1）的時候買入，在第 3 天（股票價格 = 5）的時候賣出, 這筆交易所能獲得利潤 = 5-1 = 4 。
隨後，在第 4 天（股票價格 = 3）的時候買入，在第 5 天（股票價格 = 6）的時候賣出, 這筆交易所能獲得利潤 = 6-3 = 3 。
示例 2:
輸入: [1,2,3,4,5]
輸出: 4
解釋: 在第 1 天（股票價格 = 1）的時候買入，在第 5 天 （股票價格 = 5）的時候賣出, 這筆交易所能獲得利潤 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接連購買股票，之後再將它們賣出。
因為這樣屬於同時參與了多筆交易，你必須在再次購買前出售掉之前的股票。
示例 3:
輸入: [7,6,4,3,1]
輸出: 0
解釋: 在這種情況下, 沒有交易完成, 所以最大利潤為 0。
給定一個非負整數數組 nums ，你最初位於數組的 第一個下標 。
數組中的每個元素代表你在該位置可以跳躍的最大長度。
判斷你是否能夠到達最後一個下標。
示例 1：
輸入：nums = [2,3,1,1,4]
輸出：true
解釋：可以先跳 1 步，從下標 0 到達下標 1, 然後再從下標 1 跳 3 步到達最後一個下標。
示例 2：
輸入：nums = [3,2,1,0,4]
輸出：false
解釋：無論怎樣，總會到達下標為 3 的位置。但該下標的最大跳躍長度是 0 ， 所以永遠不可能到達最後一個下標。
給定一個非負整數數組，你最初位於數組的第一個位置。
數組中的每個元素代表你在該位置可以跳躍的最大長度。
你的目標是使用最少的跳躍次數到達數組的最後一個位置。
示例:
輸入: [2,3,1,1,4]
輸出: 2
解釋: 跳到最後一個位置的最小跳躍數是 2。
從下標為 0 跳到下標為 1 的位置，跳 1 步，然後跳 3 步到達數組的最後一個位置。
說明:
假設你總是可以到達數組的最後一個位置。
移動下標只要遇到當前覆蓋最遠距離的下標，直接步數加一，不考慮是不是終點的情況。
想要達到這樣的效果，只要讓移動下標，最大隻能移動到nums.size - 2的地方就可以了。
因為當移動下標指向nums.size - 2時：
如果移動下標等於當前覆蓋最大距離下標， 需要再走一步（即ans++），因為最後一步一定是可以到的終點。（題目假設總是可以到達數組的最後一個位置），如圖：
如果移動下標不等於當前覆蓋最大距離下標，說明當前覆蓋最遠距離就可以直接達到終點了，不需要再走一步。如圖：
機器人在一個無限大小的 XY 網格平面上行走，從點 (0, 0) 處開始出發，面向北方。該機器人可以接收以下三種類型的命令 commands ：
-2 ：向左轉 90 度
-1 ：向右轉 90 度
1 <= x <= 9 ：向前移動 x 個單位長度
在網格上有一些格子被視為障礙物 obstacles 。第 i 個障礙物位於網格點 obstacles[i] = (xi, yi) 。
機器人無法走到障礙物上，它將會停留在障礙物的前一個網格方塊上，但仍然可以繼續嘗試進行該路線的其餘部分。
返回從原點到機器人所有經過的路徑點（坐標為整數）的最大歐式距離的平方。（即，如果距離為 5 ，則返回 25 ）
注意：
北表示 +Y 方向。
東表示 +X 方向。
南表示 -Y 方向。
西表示 -X 方向。
示例 1：
輸入：commands = [4,-1,3], obstacles = []
輸出：25
解釋：
機器人開始位於 (0, 0)：
在檸檬水攤上，每一杯檸檬水的售價為 5 美元。
顧客排隊購買你的產品，（按賬單 bills 支付的順序）一次購買一杯。
每位顧客只買一杯檸檬水，然後向你付 5 美元、10 美元或 20 美元。你必須給每個顧客正確找零，也就是說凈交易是每位顧客向你支付 5 美元。
注意，一開始你手頭沒有任何零錢。
如果你能給每位顧客正確找零，返回 true ，否則返回 false 。
示例 1：
輸入：[5,5,5,10,20]
輸出：true
解釋：
前 3 位顧客那裡，我們按順序收取 3 張 5 美元的鈔票。
第 4 位顧客那裡，我們收取一張 10 美元的鈔票，並返還 5 美元。
第 5 位顧客那裡，我們找還一張 10 美元的鈔票和一張 5 美元的鈔票。
由於所有客戶都得到了正確的找零，所以我們輸出 true。
示例 2：
輸入：[5,5,10]
輸出：true
示例 3：
輸入：[10,10]
輸出：false
示例 4：
輸入：[5,5,10,10,20]
輸出：false
解釋：
前 2 位顧客那裡，我們按順序收取 2 張 5 美元的鈔票。
對於接下來的 2 位顧客，我們收取一張 10 美元的鈔票，然後返還 5 美元。
對於最後一位顧客，我們無法退回 15 美元，因為我們現在只有兩張 10 美元的鈔票。
由於不是每位顧客都得到了正確的找零，所以答案是 false。
給定不同面額的硬幣 coins 和一個總金額 amount。編寫一個函數來計算可以湊成總金額所需的最少的硬幣個數。如果沒有任何一種硬幣組合能組成總金額，返回 -1。
你可以認為每種硬幣的數量是無限的。
示例 1：
輸入：coins = [1, 2, 5], amount = 11
輸出：3
解釋：11 = 5 + 5 + 1
示例 2：
輸入：coins = [2], amount = 3
輸出：-1
示例 3：
輸入：coins = [1], amount = 0
輸出：0
示例 4：
輸入：coins = [1], amount = 1
輸出：1
示例 5：
輸入：coins = [1], amount = 2
輸出：2
㈥ 哈夫曼編碼碼長怎麼算
設某信源產生有五種符號u1、u2、u3、u4和u5，對應概率P1=0.4，P2=0.1，P3=P4=0.2，P5=0.1。
霍夫曼編碼是變長編碼，思路：對概率大的編的碼字短，概率小的編的碼字長，這樣一來所編的總碼長就小，這樣編碼效率就高。上面那樣求是不對的，除非你這6個碼字是等概率的，各佔1/6。應該用對應的概率*其對應得碼長，再求和。
實際應用中
除採用定時清洗以消除誤差擴散和採用緩沖存儲以解決速率匹配以外，主要問題是解決小符號集合的統計匹配，例如黑（1）、白（0）傳真信源的統計匹配，採用0和1不同長度遊程組成擴大的符號集合信源。遊程，指相同碼元的長度（如二進碼中連續的一串0或一串1的長度或個數）。
按照CCITT標准，需要統計2×1728種遊程（長度），這樣，實現時的存儲量太大。事實上長遊程的概率很小，故CCITT還規定：若l表示遊程長度，則l=64q+r。
㈦ 貪心演算法實現哈夫曼編碼
// 哈夫曼編碼(演算法)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef char *HuffmanCode; //動態分配數組，存儲哈夫曼編碼
typedef struct
{
unsigned int weight; //用來存放各個結點的權值
unsigned int parent,LChild,RChild; //指向雙親、孩子結點的指針
} HTNode, *HuffmanTree; //動態分配數組，存儲哈夫曼樹
//選擇兩個parent為0，且weight最小的結點s1和s2
void Select(HuffmanTree *ht,int n,int *s1,int *s2)
{
int i,min;
for(i=1; i<=n; i++)
{
if((*ht)[i].parent==0)
{
min=i;
break;
}
}
for(i=1; i<=n; i++)
{
if((*ht)[i].parent==0)
{
if((*ht)[i].weight<(*ht)[min].weight)
min=i;
}
}
*s1=min;
for(i=1; i<=n; i++)
{
if((*ht)[i].parent==0 && i!=(*s1))
{
min=i;
break;
}
}
for(i=1; i<=n; i++)
{
if((*ht)[i].parent==0 && i!=(*s1))
{
if((*ht)[i].weight<(*ht)[min].weight) min=i;
}
}
*s2=min;
}
//構造哈夫曼樹ht。w存放已知的n個權值
void CrtHuffmanTree(HuffmanTree *ht,int *w,int n)
{
int m,i,s1,s2;
m=2*n-1;
*ht=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
for(i=1; i<=n; i++) //1--n號存放葉子結點，初始化
{
(*ht)[i].weight=w[i];
(*ht)[i].LChild=0;
(*ht)[i].parent=0;
(*ht)[i].RChild=0;
}
for(i=n+1; i<=m; i++)
{
(*ht)[i].weight=0;
(*ht)[i].LChild=0;
(*ht)[i].parent=0;
(*ht)[i].RChild=0;
} //非葉子結點初始化
printf("\nHuffmanTree: \n");
for(i=n+1; i<=m; i++) //創建非葉子結點，建哈夫曼樹
{ //在(*ht)[1]~(*ht)[i-1]的范圍內選擇兩個parent為0
//且weight最小的結點，其序號分別賦值給s1、s2
Select(ht,i-1,&s1,&s2);
(*ht)[s1].parent=i;
(*ht)[s2].parent=i;
(*ht)[i].LChild=s1;
(*ht)[i].RChild=s2;
(*ht)[i].weight=(*ht)[s1].weight+(*ht)[s2].weight;
printf("%d (%d, %d)\n",(*ht)[i].weight,(*ht)[s1].weight,(*ht)[s2].weight);
}
printf("\n");
} //哈夫曼樹建立完畢
//從葉子結點到根，逆向求每個葉子結點對應的哈夫曼編碼
void CrtHuffmanCode(HuffmanTree *ht, HuffmanCode *hc, int n)
{
char *cd;
int i,start,p;
unsigned int c;
hc=(HuffmanCode *)malloc((n+1)*sizeof(char *)); //分配n個編碼的頭指針
cd=(char *)malloc(n*sizeof(char)); //分配求當前編碼的工作空間
cd[n-1]='\0'; //從右向左逐位存放編碼，首先存放編碼結束符
for(i=1; i<=n; i++) //求n個葉子結點對應的哈夫曼編碼
{
start=n-1; //初始化編碼起始指針
for(c=i,p=(*ht)[i].parent; p!=0; c=p,p=(*ht)[p].parent) //從葉子到根結點求編碼
if( (*ht)[p].LChild==c) cd[--start]='0'; //左分支標0
else cd[--start]='1'; //右分支標1
hc[i]=(char *)malloc((n-start)*sizeof(char)); //為第i個編碼分配空間
strcpy(hc[i],&cd[start]);
}
free(cd);
for(i=1; i<=n; i++)
printf("HuffmanCode of %3d is %s\n",(*ht)[i].weight,hc[i]);
printf("\n");
}
void main()
{
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;
}
CrtHuffmanTree(&HT,w,n);
CrtHuffmanCode(&HT,&HC,n);
}
㈧ 用動態規劃解決鋼條切割問題時它的最優子結構是什麼
1、兩種重要演算法思想： 動態規劃，貪心演算法
2、動態規劃：
基本原理：動態規劃英文名dynamic programming。其中pogramming指的是表格法，而非編寫計算機程序。因此，可以初步得出動態規劃的基本思想：將一個具有最優子結構性質的問題分成若干個子問題，在求解過程中，記錄下子問題的結果，存儲在一個表格中，使得公共的子問題只需要計算一次。書中給出的基本原理：動態規劃將問題分成若干個相互重疊的子問題，遞歸的求解子問題，保存子問題的解，再將它們的解組合起來，求出原問題的解。
從基本原理中可以看出動態規劃需要滿足兩個條件，最優子結構和子問題重疊。
最優子結構：書中定義：問題的最優解由相關子問題的最優解組合而成，一個問題的最優解包含其子問題的最優解。典型的有背包問題和鋼條切割我問題。所謂子問題就是一中組合，將一個問題分成許多子問題的集合。某個子問題轉化為問題時，所需要的代價是固定的。
一般這類問題的解題過程：（自己總結）
畫出子問題圖（類似於逆拓撲排序的圖，子問題必須在問題前面完成）
用數學表達式構建出問題的最優解和子問題最優解之間的代數表達式
通常採用自底向上的方法進行遞歸地求解問題的解，自底下上的含義是從最小的子問題求起。
保存每一步求出的子問題的最優解
利用計算出的信息構造一個最優解
3、貪心演算法：
基本原理：從初始狀態出發，每步都經過貪心選擇，最終得到問題的最優解。
含義： 將每一步都看成是當前最佳的選擇，做到局部最優化，直到無法選擇為止。寄希望於局部最優的選擇能夠導致全局最優解。
兩個實例：最小生成樹演算法和單源最短路徑演算法，以及集合覆蓋問題的貪心啟發式演算法。
prim演算法：將集合A看成是一棵樹，每次選擇剩餘的節點中與這棵樹形成的邊的權值最小的點加入到集合A中形成新的樹，循壞調用該過程，知道所有的點都已經放入到集合A中。初始時隨機選擇一個節點放入到集合A中。
kruskal演算法：在所有連接森林中兩顆不同樹的邊裡面，找到權重最小的邊（u，v），並將其加入到集合A中，循環調用該過程，直到所有的點已經放入到集合A中
貪心選擇：當進行選擇時，我們直接作在當前問題看來是最優的選擇，而不必考慮子問題的解。這與動態規劃不同，動態規劃當前問題依賴於較小的子問題。而貪心演算法中做當前問題最優選擇，這樣每步之後只需要做一個子問題的解。
也必須滿足最優子結構的性質，即一個問題的最優解包含其子問題的最優解。
那麼，如何區分什麼時候使用動態規劃，什麼時候使用貪心演算法呢？
典型的兩個問題，0-1背包和分數背包。兩者都具有最優子結構性質，但是貪心演算法只能用來求分數背包的問題，而不能用來求0-1背包的問題。即只有分數背包具有貪心選擇性。
我得總結（不一定對）：具有貪心選擇性的一類問題是：每次做選擇時只有性能不同，而代價是一樣的。那麼這樣每次的選擇都是最好的，最終會得到最好的結果。
哈夫曼編碼也使用貪心選擇演算法。每次選擇待編碼的字元都選擇在剩餘的字元中出現次數最多的
㈨ 劉汝佳的演算法藝術與信息學竟賽13頁1.2.2節貪心法例一：釣魚！分析部分第一段話怎樣理解
貪心法(Greedy algorithm)是一種在每一步選擇中都採取在當前狀態下最好/優的選擇，從而希望導致結果是最好/優的演算法。比如在旅行推銷員問題中，如果旅行員每次都選擇最近的城市， 那這就是一種貪心演算法。
貪心演算法在有最優子結構的問題中尤為有效。最優子結構的意思是局部最優解能決定全局最優解。簡單地說，問題能夠分解成子問題來解決，子問題的最優解能遞推到最終問題的最優解。
貪心演算法與動態規劃的不同在於它每對每個子問題的解決方案都做出選擇，不能回退。動態規劃則會保存以前的運算結果，並根據以前的結果對當前進行選擇，有回退功能。
貪心法可以解決一些最優性問題，如：求圖中的最小生成樹、求哈夫曼編碼……對於其他問題，貪心法一般不能得到我們所要求的答案。一旦一個問題可以通過貪心法來解決，那麼貪心法一般是解決這個問題的最好辦法。由於貪心法的高效性以及其所求得的答案比較接近最優結果，貪心法也可以用作輔助演算法或者直接解決一些要求結果不特別精確的問題。
貪心法解題特點
貪心法有一個共同的點就是在最優求解的過程中都採用一種局部最優策略，把問題范圍和規模縮小最後把每一步的結果合並起來得到一個全局最優解。
貪心法解題的一般步驟
（1）從問題的某個初始解出發；
（2）採用循環語句，當可以向求解目標前進一部時，就根據局部最優策略，得到一個部分解，縮小問題的范圍和規模；
（3）將所有部分解綜合起來，得到問題最終解。
㈩ 哈夫曼編碼的貪心演算法所需的計算時間
哈夫曼編碼的貪心演算法所需的計算時間O(nlogn)。根據查詢相關公開信息顯示，O(nlogn)是一個程序的效率，表示如果有n個數，最多要進行多少次運算，如exhaustivesearch的時間就是o(n)，因為如果有n個數，最壞情況就要經過n次比較，而binarysearch就是o(logn).因為只要log2（2在下面）n的時間就可以。