终稿- -算法设计与分析实验报告格式 3

算法设计与分析实验报告一

实验名称统计数字问题评分

实验日期2013 年11 月 4 日指导教师*&&*

姓名** 专业班级学号20101

一.实验要求

1、掌握算法的计算复杂性概念。

2、掌握算法渐近复杂性的数学表述。

3、掌握用C++语言描述算法的方法。

4．实现具体的编程与上机实验，验证算法的时间复杂性函数。

二.实验内容

统计数字问题

1、问题描述

一本书的页码从自然数1 开始顺序编码直到自然数n。书的页码按照通常的习惯编排，每个页码都不含多余的前导数字0。例如，第6 页用数字6 表示，而不是06 或006 等。数字计数问题要求对给定书的总页码n，计算出书的全部页码中分别用到多少次数字0，1，2， (9)

2、编程任务

给定表示书的总页码的10 进制整数n (1≤n≤109) 。编程计算书的全部页码中分别用到多少次数字0，1，2， (9)

三.程序算法

定义数组a[10]存放0到9这10个数出现的次数；个位为第0位，第j位的数字为r。采用while循环从低位向高位统计：a.统计从个位算起前j位0~9个数；b.如果j+1位为0，去掉第j+1位补0个数；c.统计第j+1位出现1~(r-1)个数；d. 统计第j+1位出现r个数。

四.程序代码

#include"stdafx.h"

#include

#include

#include

#include//c++串流控制

using namespace std;

int result_num[10]={0};

void process(int m);

int main(int argc, char* argv[])

{ //cout<

int file_count=0;//文本文件的标题序号

char ctu='y';

while(ctu=='y'||ctu=='Y')

{ process(file_count);

cout<<"是否继续（y/Y）"<

cin>>ctu;

++file_count; }

return 0;}

void process(int m)

{

memset(result_num,0,sizeof(result_num));//每次新的运算均需要把数组值都置为

ostringstream tstr;

int paper_page;

tstr<<"input"<

ofstream fout_test(tstr.str().c_str());//保存页码的文件

tstr.str("");

tstr<<"output"<

ofstream fout_result(tstr.str().c_str());//保存结果的文件

cout<<"请输入页码数：";

cin>>paper_page;

fout_test<

fout_test.close();

for(int i=1;i<=paper_page;++i)

{

int tmp=i;

while(tmp)

{

int num=tmp%10;

++result_num[num];

tmp=tmp/10;

//cout<

} }

for(int j=0;j<10;++j)

{

fout_result<

}

fout_result.close();

}

五.程序调试中的问题

出现一些小错误，修改后程序可运行。

六.实验结果

定义数组a[10]存放0到9这10个数出现的次数，个位为第0位，第j位的数字为r。采用while循环从低位向高位统计： a. 统计从个位算起前j位0~9个数； b. 如果j+1位为0，去掉第j+1位补0个数； c. 统计第j+1位出现1~(r-1)个数； d. 统计第j+1位出现r个数。

基本满足实验要求。

算法设计与分析实验报告二

实验名称分治法实现归并排序算法评分

实验日期2013 年11 月 4 日指导教师

姓名专业班级计算机学号201

一.实验要求

1.了解用分治法求解的问题：当要求解一个输入规模为n，且n的取值相当大

的问题时，

如果问题可以分成k个不同子集合，得到k个不同的可独立求解的子问题，其中1

2.掌握分治法的一般控制流程。

DanC(p,q)

global n，A[1:n]; integer m,p,q; // 1≤p≤q≤n

if Small(p,q) then return G(p,q);

else m=Divide(p,q); // p≤m

return Combine(DanC(p,m),DanC(m+1,q));

endif

end DanC

3．实现典型的分治算法的编程与上机实验，验证算法的时间复杂性函数。

二.实验内容

1.编程实现归并排序算法，程序中加入比较次数的计数功能，输出排序结果和比较次数。

2.输入10组相同的数据，验证排序结果和完成排序的比较次数。

3.与复杂性函数所计算的比较次数比较。

4.用表格列出比较结果。

5.给出文字分析。

三.程序算法

1. 归并排序算法

procedure MERGESORT(low，high)

//A(low；high)是一个全程数组，它含

有high-low+1≥0个待排序的元素//

integer low，high；

if low

then mid←， //求这个集合的分割点//

call MERGESORT(low，mid) //将一个子集合排序//

call MERGESORT(mid+1，high) //将另一个子集合排序

call MERGE(low，mid，high) //归并两个已排序的子集合// endif

end MERGESORT

归并两个已排序的集合

procedure MERGE(low，mid，high)

//A(low：high)是一个全程数组//

//辅助数组B(low；high)//

integer h，i，j，k；

h←low；i←low；j←mid+1；

while h≤mid and j≤high do //当两个集合都没取尽时// if A(h)≤A(j) then B(i) ←A(h)；h←h+1

else B(i) ←A(j)；j←j+1

endif

i←i+1

repeat

if h>mid then

for k←j to high do //处理剩余的元素//

B(i) ←A(k)；i←i+1

repeat

else for k←h to mid do

B(i) ←A(k)；i←i+1

repeat

endif

将已归并的集合复制到A

end MERGE

2. 快速排序算法

QuickSort(p,q)

//将数组A[1:n]中的元素

A[p], A[p+1], , A[q]按不降次序排列，

并假定A[n+1]是一个确定的、且大于

A[1:n]中所有的数。//

int p,q; global n, A[1:n];

if p

j=Partition(p, q+1); // 划分后j成为划分元素的位置

QuickSort(p,j-1);

QuickSort(j+1,q);

endif

end QuickSort

procedure PARTITION(m，p)

//退出过程时，p带着划分元素所在的下标位置。//

integer m，p，i；global A(m：p-1)

v←A(m)；i←m //A(m)是划分元素//

loop

loop i←i+1 until A(i)≥v repeat //i由左向右移//

loop p←p-1 until A(p)≤v repeat //p由右向左移//

if i

then call INTERCHANGE(A(i)，A(p)) //A(i)和A(p)换位// else exit

endif

repeat

A(m) ←A(p)；A(p) ←v //划分元素在位置p//

End PARTITION

四.程序代码

1.归并排序

#include

#include

#include

#include

#define M 11

typedef int KeyType;

typedef int ElemType;

struct rec{

KeyType key;

ElemType data;

};

typedef rec sqlist[M];

class guibing{

public:

guibing(sqlist b)

{

for(int i=0;i

r[i]=b[i];

}

void output(sqlist r,int n)

{

for(int i=0;i

cout<

cout<

}

void xuanze(sqlist b,int m,int n)

{

int i,j,k;

for(i=m;i

{

k=i;

for(j=i;j

if(b[k].key>b[j].key) k=j;

if(k!=i)

{

rec temp=b[k];

b[k]=b[i];

b[i]=temp;

}

}

}

void merge(int l,int m,int h,sqlist r2)

{

xuanze(r,l,m);

xuanze(r,m,h);

output(r,M);

int i,j,k;

k=i=l;

for(j=m;i

{

if(r[i].key<=r[j].key)

{

r2[k]=r[i];

i++;

}

else

{

r2[k]=r[j];

j++;

}

output(r2,M);

}

while(j

{

r2[k]=r[j];

j++;

k++;

}

while(i<=m)

{

r2[k]=r[i];

i++;

k++;

}

output(r2,M);

}

private:

sqlist r;

};

void main()

{

cout<<"guibingfa1运行结果:\n";

sqlist a,b;

int i,j=0,k=M/2,n=M;

srand(time(0));

for(i=0;i

{

a[i].key=rand()%80;b[i].key=0;

}

guibing gx(a);

cout<<"排序前数组:\n";

gx.output(a,M);

cout<<"数组排序过程演示:\n";

gx.merge(j,k,n,b);

cout<<"排序后数组:\n";

gx.output(b,M);

cin.get();

}

2.快速排序

#include

#include

#include

#include

#define MAXI 10

typedef int KeyType;

typedef int ElemType;

struct rec{

KeyType key;

ElemType data;

};

typedef rec sqlist[MAXI];

class kuaisu

{

public:

kuaisu(sqlist a,int m):n(m)

{

for(int i=0;i

}

void quicksort(int s,int t)

{

int i;

if(s

i=part(s,t);

quicksort(s,i-1);

quicksort(i+1,t);

}

else return;

}

int part(int s,int t)

{

int i,j;

rec p;

i=s;j=t;p=b[s];

while(i

{

while(i=p.key)j--;

b[i]=b[j];

while(i

b[j]=b[i];

}

b[i]=p;

output();

return i;

}

void output()

{

for(int i=0;i

cout<

cout<

}

private:

sqlist b;

int n;

};

void main()

{ cout<<"kuaisu1.cpp运行结果:\n";

sqlist a1;

int i,n=MAXI,low=0,high=9;

srand(time(0));

for(i=0;i

a1[i].key=rand()%80;

kuaisu px(a1,n);

cout<<"数组排序过程演示:\n";

px.quicksort(low,high);

cout<<"排序后数组:\n";

px.output();

cin.get();

}

五.程序调试中的问题

排序算法设计比较经典也比较难，调试中不乏出现各种问题，借鉴了经典算法最终完成实验。

六.实验结果

1.归并排序

2.快速排序

算法设计与分析实验报告三

实验名称 动态规划算法实现多段图的最短路径问题 评分 实验日期 2013 年 11 月 4 日 指导教师 姓名 专业班级 计算机 学号 2 104

一.实验要求

1. 理解最优子结构的问题。

有一类问题的活动过程可以分成若干个阶段，而且在任一阶段后的行为依赖于该阶段的状态，与该阶段之前的过程如何达到这种状态的方式无关。这类问题的解决是多阶段的决策过程。在50年代，贝尔曼（Richard Bellman ）等人提出了解决这类问题的“最优化原理”，从而创建了最优化问题的一种新的算法设计方法－动态规划。

对于一个多阶段过程问题，是否可以分段实现最优决策，依赖于该问题是否有最优子结构性质，能否采用动态规划的方法，还要看该问题的子问题是否具有重叠性质。 最优子结构性质：原问题的最优解包含了其子问题的最优解。

子问题重叠性质：每次产生的子问题并不总是新问题，有些子问题被反复计算多次。问题的最优子结构性质和子问题重叠性质是采用动态规划算法的两个基本要素。

2.理解分段决策Bellman 方程。

每一点最优都是上一点最优加上这段长度。即当前最优只与上一步有关。 U s 初始值，u j 第j 段的最优值。

3.一般方法

1） 找出最优解的性质，并刻画其结构特征；

2） 递归地定义最优值（写出动态规划方程）；

3） 以自底向上的方式计算出最优值；

4） 根据计算最优值时得到的信息，构造一个最优解。

步骤1-3是动态规划算法的基本步骤。在只需要求出最优值的情形，步骤4可以省略，步骤3中记录的信息也较少；若需要求出问题的一个最优解，则必须执行步骤4，步骤3中记录的信息必须足够多以便构造最优解。

二.实验内容

1.编程实现多段图的最短路径问题的动态规划算法。

2.图的数据结构采用邻接表。

3.要求用文件装入5个多段图数据，编写从文件到邻接表的函数。

??

???+==≠}.{min ,0ij i j i j s w u u u

4.验证算法的时间复杂性。

三.程序算法

四.程序代码

五.程序调试中的问题

六.实验结果

算法设计与分析实验报告四

实验名称贪心算法实现背包问题评分

实验日期2013 年11 月 4 日指导教师

姓名专业班级计算机10 1 学号201013

一.实验要求

1. 优化问题

有n个输入，而它的解就由这n个输入满足某些事先给定的约束条件的某个子集组成，而把满足约束条件的子集称为该问题的可行解。可行解一般来说是不唯一的。那些使目标函数取极值(极大或极小)的可行解，称为最优解。

2.贪心法求优化问题

算法思想：在贪心算法中采用逐步构造最优解的方法。在每个阶段，都作出一个看上去最优的决策（在一定的标准下）。决策一旦作出，就不可再更改。作出贪心决策的依据称为贪心准则（greedy criterion）。

3.一般方法

1）根据题意，选取一种量度标准。

2）按这种量度标准对这n个输入排序

3）依次选择输入量加入部分解中。如果当前这个输入量的加入，不满足约束条件，则不把此输入加到这部分解中。

procedure GREEDY(A，n) /*贪心法一般控制流程*/

//A(1：n)包含n个输入//

solutions←φ //将解向量solution初始化为空／

for i←1 to n do

x←SELECT(A)

if FEASIBLE(solution，x)

then solutions←UNION(solution，x)

endif

repeat

return(solution)

end GREEDY

4.实现典型的贪心算法的编程与上机实验，验证算法的时间复杂性函数。

二.实验内容

1. 编程实现背包问题贪心算法。通过具体算法理解如何通过局部最优实现全局最优，

并验证算法的时间复杂性。

2.输入5个的图的邻接矩阵，程序加入统计prim算法访问图的节点数和边数的语句。

3.将统计数与复杂性函数所计算的比较次数比较，用表格列出比较结果，给出文字分析。

三.程序算法

从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。当达到某算法中的某一步不能再继续前进时，算法停止。该算法存在问题：

1. 不能保证求得的最后解是最佳的；

2. 不能用来求最大或最小解问题；

3. 只能求满足某些约束条件的可行解的范围。

(i) 一种贪婪准则为：从剩余的物品中，选出可以装入背包的价值最大的物品，利用这种规则，价值最大的物品首先被装入（假设有足够容量），然后是下一个价值最大的物品，如此继续下去。这种策略不能保证得到最优解。例如，考虑n=2, w=[100,10,10], p =[20,15,15], c = 105。当利用价值贪婪准则时，获得的解为x= [ 1 , 0 , 0 ]，这种方案的总价值为2 0。而最优解为[ 0 , 1 , 1 ]，其总价值为3 0。

(ii) 另一种方案是重量贪婪准则是：从剩下的物品中选择可装入背包的重量最小的物品。虽然这种规则对于前面的例子能产生最优解，但在一般情况下则不一定能得到最优解。考虑n= 2 ,w=[10,20], p=[5,100], c= 2 5。当利用重量贪婪策略时，获得的解为x =[1,0], 比最优解[ 0 , 1 ]要差。

(iii) 还有一种贪婪准则，就是我们教材上提到的，认为，每一项计算yi=vi/si,即该项值和大小的比，再按比值的降序来排序，从第一项开始装背包，然后是第二项，依次类推，尽可能的多放，直到装满背包。

有的参考资料也称为价值密度pi/wi贪婪算法。这种策略也不能保证得到最优解。利用此策略试解n= 3 ,w=[20,15,15], p=[40,25,25], c=30 时的最优解。虽然按pi /wi 非递（增）减的次序装入物品不能保证得到最优解，但它是一个直觉上近似的解。

而且这是解决普通背包问题的最优解，因为在选择物品i装入背包时，可以选择物品i的一部分，而不一定要全部装入背包，1≤i≤n。

四.程序代码

#include "iostream"

using namespace std;

struct goodinfo

{

float p; //物品效益

float w; //物品重量

float X; //物品该放的数量

int flag; //物品编号

};//物品信息结构体

void Insertionsort(goodinfo goods[],int n)

{

int j,i;

for(j=2;j<=n;j++)

{

goods[0]=goods[j];

i=j-1;

while (goods[0].p>goods[i].p)

{

goods[i+1]=goods[i];

i--;

}

goods[i+1]=goods[0];

}

}//按物品效益，重量比值做升序排列

void bag(goodinfo goods[],float M,int n)

{

float cu;

int i,j;

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

goods[i].X=0;

cu=M; //背包剩余容量

for(i=1;i

{

if(goods[i].w>cu)//当该物品重量大与剩余容量跳出break;

goods[i].X=1;

cu=cu-goods[i].w;//确定背包新的剩余容量}

if(i<=n)

goods[i].X=cu/goods[i].w;//该物品所要放的量//按物品编号做降序排列

for(j=2;j<=n;j++)

{

goods[0]=goods[j];

i=j-1;

while (goods[0].flag

{

goods[i+1]=goods[i];

i--;

}

goods[i+1]=goods[0];

}

cout<<"最优解为:"<

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

{

cout<<"第"<

cout<

}

}

int main(void)

{

cout<<"|--------运用贪心法解背包问题---------|"<

cout<<"|-------------------------------------|"<

int i,j,n;

float M;

goodinfo *goods; //定义一个指针

cout<<"press <1> to run the program"<

cout<<"press <0> to exit"<

cin>>j;

while(j)

{

cout<<"请输入物品的总数量：";

cin>>n;

goods=new struct goodinfo [n+1];

cout<<"请输入背包的最大容量：";

cin>>M;

cout<

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

{

goods[i].flag=i;

cout<<"请输入第"<

cin>>goods[i].w;

cout<<"请输入第"<

cin>>goods[i].p;

goods[i].p=goods[i].p/goods[i].w; //得出物品的效益，重量比

cout<

}