中南大学算法实验报告

中南大学算法分析与设计

实验报告

学生姓名涂茂麟

学号

专业班级计算机科学与技术1303

指导老师

学院信息科学与工程学院

目录

实验一 DFS与BFS 3

实验二最近点对问题 7

实验三拓扑排序 10

实验四 N皇后问题 12

实验五 0-1背包问题 16

实验六最短路径 20

实验一 DFS与BFS

实验目的：实现深度优先算法、宽度优先算法

实现原理：

深度优先搜索：

从图中某顶点v出发：

（1）访问顶点v；

（2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；

（3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。

广度优先搜索：

已知图G=(V,E)和一个源顶点s，宽度优先搜索以一种系统的方式探寻G的边，从而“发现”s所能到达的所有顶点，并计算s到所有这些顶点的距离(最少边数)，该算法同时能生成一棵根为s且包括所有可达顶点的宽度优先树。对从s 可达的任意顶点v，宽度优先树中从s到v的路径对应于图G中从s到v的最短路径，即包含最小边数的路径。该算法对有向图和无向图同样适用。

具体设计：

1. 数据结构

采用邻接链表作为图的数据结构。

public class Graph {//图

public VNode[] arrVnode=new VNode[100] ;//头结点数组

public int vexmun,arcmun;//节点总数、边界总数

public int time;//记录打开、关闭节点的时间

}

public class VNode {//节点类

public int data;//节点的内容

public boolean visited=false;//是否访问过

public boolean ifclosed=false;//是否被放在关闭的表中

public int distance=10000;//距离某一点的最短距离

public int front=10000;//前驱节点

public ArcNode nextarc=null;//下一条边

public int entertime,exittime;//打开、关闭节点的时间}

public class ArcNode{//边类

public int adjvex;//该弧所指向的顶点的位置

public int weight=0;//该边的权值

public ArcNode nextarc=null;//下一条边

}

2. DFS

public void DFS(Graph G){//DFS的起始调用方法

int vexmun=G.vexmun;

G.time=0;

for(int v=1;v<=vexmun;v++){

if(G.arrVnode[v].visited==false){

DFS_VISIT(G,v);

}

}

}

public void DFS_VISIT(Graph G,int v){//应用递归的DFS访问G.arrVnode[v].visited=true;

G.time++;//time是给后面的拓扑排序实验用的

G.arrVnode[v].entertime=G.time;

System.out.println(G.arrVnode[v].data);

ArcNode node=G.arrVnode[v].nextarc;

while(node!=null){

int p=node.adjvex;

if(G.arrVnode[p].visited==false&&G.arrVnode[p]!=null){ DFS_VISIT( G , p);

}

node=node.nextarc;

}

G.time++;

G.arrVnode[v].exittime=G.time;

}

3. BFS

public void BFS(Queue Queue , Graph G ,int v){

if(visited[v]==false){

visited[v]=true;

System.out.print(G.arrVnode[v].data);System.out.print(" "); ArcNode node =G.arrVnode[v].nextarc;

// QueueFunction.EnQueue(Queue, v);

// while(Queue!=null){

while(node!=null){

if(visited[node.adjvex]==false&&queueed[node.adjvex]==false){ QueueFunction.EnQueue(Queue, node.adjvex);

queueed[node.adjvex]=true;

}

node=node.nextarc;

}

BFS(Queue,G,QueueFunction.DeQueue(Queue));

}

}

实验结果：

数据说明：5个节点，10条边，每行数字分别是起始节点、终止节点、权值。

实验总结：

DFS与BFS较为简单，是图论的基础。在以后的实验中，不管是动态规划、贪心算法、回溯法都会以DFS或BFS为基础，应当是我们每个人都要掌握的。

实验二最近点对问题

实验目的：运用分治算法，解决最近点对问题。

实现原理：

使用分治法解决最近点对问题就是将集合S分成两个子集是S1和S2,每个子集中有N/2个点。然后再每个子集中递归的求其最接近的点对，求出每个子集的最接近点对后，如果集合S中最接近的点对都在两个子集中，问题解决。当两个点分别在两个子集中时，则最近点对为S1和S2的最接近点。其时间复杂度为

O(nlogn)。

具体设计：

1. 排序

第一步是将所有从文件获取的点按照X轴升序排列，若X坐标相同则按Y轴坐标由小到大排列。

// 按照X轴坐标升序排序

Arrays.sort(point, new Comparator() {

public int compare(Neighborpoint o1, Neighborpoint o2) {

if (o1.x < o2.x)

return -1;

if (o1.x > o2.x)

return 1;

if (o1.y < o2.y)

return -1;

if (o1.y > o2.y)

return 1;

return 0;

}

});

2. 分治法求最近点对

public static double Close_pair(Neighborpoint[] point,int left, int right){

double d = 1e20;

if(right == left)//同一点，返回很大值

return d;

if(left+1 == right)

return distance(left,right);

int mid =(left+right)>>1;//除以2

double d1 = Close_pair(point,left,mid); double d2 = Close_pair(point,mid+1,right);

d = min(d1,d2);

int i,j,k=0;

tmpt = new int[10000];

//分离d区域

for(i=left;i<=right;i++){

if(Math.abs(point[mid].x-point[i].x) < d) tmpt[k++] = i;

}

实验结果：

数据文件：

点的显示：

结果显示：

实验总结：按照分治法，可以很方便的解决这个问题。虽然心里还是很排斥递归，但是真正用到的话还是比较简洁的。另外最开始做这个实验的时候，还不太熟悉比较器，本来是可以直接把点记录下来的，但当时是将点的值存入到数组以后再排序的，所以没能很方便的读出最近点的坐标，这个有时间再进行改进。

实验三拓扑排序

实验目的：实现一个拓扑排序

实现原理：

由AOV网构造拓扑序列的拓扑排序算法主要是循环执行以下两步，直到不存在入度为0的顶点为止。

(1) 选择一个入度为0的顶点并输出之；

(2) 从网中删除此顶点及所有出边。

循环结束后，若输出的顶点数小于网中的顶点数，则输出“有回路”信息，否则输出的顶点序列就是一种拓扑序列。

具体设计：

1. 数据结构与DFS

拓扑排序基本上和DFS没什么区别，它的本质其实就是DFS关闭节点的倒序输出。

所以在数据结构上，和第一个实验用的是相同的数据结构来保存图。

public int time;//记录打开、关闭节点的时间

public int entertime,exittime;//打开、关闭节点的时间

值得注意的是，以上两个变量，是用来实现拓扑排序的关键部分。2. 拓扑排序的实现

public void Toposortmethod(Graph G){

MaxPQ pq1= new MaxPQ(new Comparator() { public int compare(VNode o1, VNode o2) {

if (o1.exittime < o2.exittime) return -1;

else if (o1.exittime == o2.exittime) return 0;

else return 1;

}

});

GrahpFuntion.DFS1(G);

for(int i=1;i<=G.vexmun;i++){

pq1.insert(G.arrVnode[i]);

}

System.out.println("拓扑排序顺序:");

VNode Vnode;

for(int i=1;i<=G.vexmun;i++){ Vnode=pq1.delMax();

System.out.println(Vnode.data); }

}

实验结果：

数据文件：

结果显示：

上面那个是因为调用了DFS而产生的DFS输出结果

实验总结：由于有了之前的铺垫，所以拓扑排序相对来说比较简单，我只是在图的设计类中添加了一个时间变量，而在节点的打开、关闭的过程中增加了时间。拓扑排序是计算机网络的基础，在很多地方都有体现，值得我们注意。

实验四 N皇后问题

实验目的：应用回溯法解决N皇后问题

实现原理：

（1）针对所给问题，定义问题的解空间；

（2）确定易于搜索的解空间结构；

（3）以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

首先找出解空间：给棋盘的行和列都编上1到N的号码，皇后也给编上1到N的号码。由于一个皇后应在不同的行上，为不失一般性，可以假定第i个皇后将放在第i行上的某列。因此N皇后问题的解空间可以用一个N元组（X1，

X2，.....Xn）来表示，其中Xi是放置皇后i所在的列号。这意味着所有的解都是N元组（1，2，3，.......，N）的置换。解空间大小为N！。其次我们看约束条件：因为解空间已经给我们排除了不在同一行（因为每个皇后分别已经对应不同的行号）的约束条件。我们要判断的是不在同一列和不在同一斜线的约束。因为Xi 表示皇后所在的列号，所以如果存在X（k）=X（i）那么肯定存在第k个皇后和第i个皇后同列。所以不同列的判段条件是X（k）！=X（i），1

具体设计：

关于N皇后问题，我设计了两种方式，一个是递归回溯，另一个是非递归回溯版本。

1. 判断是否可以放置的place方法

boolean place(int k){

int i;

for(i=1;i

if(column[i]==column[k]||Math.abs(i-k)==Math.abs(column[i]-

column[k]))

return false;

}

return true;

}

2.递归回溯

void backtrack(int t){//递归版本

int i=0;

if(t>N){

System.out.println("第"+count+"组");

count++;

for(i=1;i<=N;i++){

System.out.println("("+i+","+column[i]+")"); }

}else{

for(i=1;i<=N;i++){

column[t]=i;

if(place(t)) backtrack(t+1);

}

}

}

3.非递归回溯

void backtrack2(){//非递归

int i;

count=1;

column[1]=0;

int k=1;

while(k>0){

column[k]++;

while((column[k]<=N)&&!place(k)){ column[k]++;

}

if(column[k]<=N){

if(k==N){

System.out.println("第"+count+"组");

count++;

for(i=1;i<=N;i++){

System.out.println("("+i+","+column[i]+")"); }

}else{

k++;

column[k]=0;

}

}

else{//回溯

k--;

}

}

}

实验结果：

当参数设置N=4，即四皇后问题。

实验总结：N皇后问题是回溯法的经典问题，在通过多次减枝以后，可以有效的减少时间复杂度。

实验五 0-1背包问题

实验目的：应用动态规划解决0-1背包问题

实现原理：

f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：

f[i][v]=max{ f[i-1][v], f[i-1][v-w[i]]+v[i] }。

可以压缩空间，f[v]=max{f[v],f[v-w[i]]+v[i]}

“将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”，价值