C常用经典算法及其实现修订稿

C常用经典算法及其实

现

公司标准化编码 [QQX96QT-XQQB89Q8-NQQJ6Q8-MQM9N]

常用算法经典代码（C++版）

一、快速排序

void qsort(int x,int y) a[n]数组中

{int h=x,r=y;

int m=a[(x+y)>>1]; a[n]数组中

{for(int i=1;i

{for(int i=1;i

{d);d);d);d);d);d);child=l; ather=i; child=r; ather=i;

a=a[l].da+a[r].da; a>a[s].da)&&(a[s].father==0)) ather=0,说明这个结点还不是别个结点

mins=s; ather==0) {a[x].code=”“;}ather].lchild==x)

a[x].code=a[a[x].father].code+'0';

if(a[a[x].father].rchild==x) a[x].code=a[a[x].father].code+'1';

if(a[x].lchild!=0)

inorder(a[x].lchild);child==0)&&(a[x].rchild==0))a<<':'<

if(a[x].rchild!=0) inorder(a[x].rchild);rom=1;

elist[i].to=i+1;

elist[i].w=a[1][i+1];

}

for (int i=1;i<=n-1;i++)

if(m!=i) >a[elist[i].to][elist[j].to])

elist[j].w=a[elist[i].to][elist[j].to];}

}

for(int i=1;i<=n-1;i++);

}

?

如果要求出哪些边构成最小生成树，在更新第i+1至n-1条边到已经生成的树中最小距离时(上面代码中加粗的部分)，还要加上

elist[j].from=elist[i].to;语句，即在更新权值时，还应该更新起点。

Prime算法适用于顶点不是太多的稠密图，如果对于顶点数较多的稀疏图，就不太适用了。

?

十九、Dijkstra算法

void dijkstra(int x) ;

while(h

{while(elist[h].w

while(elist[r].w>m) r--;

if(h<=r)

{edge tmp=elist[h];elist[h]=elist[r];elist[r]=tmp;h++;r--;}

}

if(x

if(h

}

?

int getfather(int x)rom);o);;}//不在同一个集合，合并，即第i条边可以选取。

if(sum>n-1)

break;//已经确定了n-1条边了，最小生成树已经生成了，可以提前退出循环了

}

if(sum

cout<<"Impossible"<

else

cout<

}

?

克鲁斯卡尔算法，只用了边集数组，没有用到图的邻接矩阵，因此当图的结点数比较多的时候，输入数据又是边的信息时，就要考虑用Kruscal算法。对于岛国问题，我们就要选择此算法，如果用Prim算法，还要开一个二维的数组来表示图的邻接矩阵，对于10000个点的数据，显然在空间上是无法容忍的。

?

二十一、Floyed算法

void floyed(void)// a[i][j]表示结点i到结点j的最短路径长度，初始时值为的权值。

{for(int k=1;k<=n;k++) //枚举中间加入的结点不超过K时f[i][j]最短路径长度，K相当DP中的阶段

for(int i=1;i<=n;i++) //i，j是结点i到结点J，相当于DP中的状态

for(int j=1;j<=n;j++)

if (a[i][j]>a[i][k]+a[k][j]) a[i][j]=a[i][k]+a[k][j];//这是决策，加和不加中间点，取最小的值

}

?

弗洛伊德算法适合于求没有负权回路的图的最短路径长度，利用FLOYED算法，可写出判断结点i和结点J是否连通的算法。

?

二十二、01背包问题

n为物品的数量，w[i]表示第i个物品的重量，c[i]表示第i个物品的价值，v 为背包的最大重量。

有状态转移方程f[i][j]=max{f[i-1][j],f[i-1][j-w[i]]+c[i]}。f[i][j]表示前i个物品，在背包载重为j时获得的最大价值。显然f[n][v]即为所求。边界条件为f[0][s]=0,s=0,1, (v)

for(int i=1;i<=n;i++)//枚举阶段

for(int j=0;j<=v;j++)//枚举状态，当然此处也可写成:for(int

j=v;j>=0;j--)

{

f[i][j]=f[i-1][j];//不选第i个物品

if(f[i][j]

}

cout<

?

优化：用一维数组实现，把第i-1阶段和第i阶段数据存在一块。

for(int i=1;i<=n;i++)//枚举阶段

for(int j=v;j>=0;j--)//枚举状态，当然此处也可写成:for(int

j=v;j>=0;j--)

{

f[j]=f[j];//不选第i个物品，可省略此语句。

if((j>w[i])&&(f[j]

}

cout<

?

对比优化前后，我们不难发现，优化后的代码实际上就是在原来基本的代码基础上，减少了阶段这一维，同时在枚举状态时，为了保证结果的正确性，枚举的顺序只能是v到0，而不能是0到v。大家细想一下为什么就是保证在求第i 阶段j状态时，f[j-w[i]]为第i-1阶段的值。

?

进一步优化，在上面代码中，枚举状态时，还可以写成for(int

j=v;j>=w[i];j--)，此时下面的判断条件j>=w[i]就可以省略了。

?

二十三、完全背包问题

和01背包问题不同的是，完全背包，对于任何一个物品i，只要背包重量允许，可以多次选取，也就是在决策上，可以选0个，1个，2个，…，v/w[i]个。

状态转移方程f[i][j]=max{f[i-1][j],f[i-1][j-w[i]]+c[i]，f[i-1][j-

2*w[i]]+2*c[i]，...，f[i-1][j-k*w[i]]+k*c[i]}。k=0，1，2，...，v/w[i]。f[i][j]表示前i个物品，在背包载重为j时获得的最大价值。显然f[n][v]即为所求。边界条件为f[0][s]=0,s=0,1, (v)

for(int i=1;i<=n;i++)//枚举阶段

for(int j=0;j<=v;j++)//枚举状态，当然此处也可写成:for(int

j=v;j>=0;j--)

{f[i][j]=f[i-1][j];//k=0的情况作为f[i][j]的初始值，然后在

k=1,2,…,v/w[i]中找最大值

for(int k=1;k<=v/w[i];k++)

if(f[i][j]

k*w[i]]+k*c[i];//选第i个物品

}

cout<

?

二十四、多属性背包问题

?

二十五、多背包问题

?

二十六、最长不降（上升）子序列问题

?

f[i]表示从第1个数开始，以第i个数结尾的最长递增子序列。

?

状态转移方程：f[i]=max{f[j]}+1 （1≤j≤i-1，1≤i≤n，a[i]≥a[j]）

临界状态：f[1]=1;

?

二十七、最长公共子序列问题

?

f[i][j]表示第一个串前i个字符和第二个串前j个字符的最长公共子序列数。

状态转移方程：

f[i-1][j-1] (若a[i]==b[j])

f[i][j]=

max{f[i-1][j],f[i][j-1]}+1 (若a[i]≠b[j]) ?

临界状态:f[0][j]=0，f[i][0]=0