请教java的几道算法题(树、堆、最小周游路径)

captaintao 2008-04-26 05:09:29

1、用java语言编写一个java应用程序根据给定图实现最小生成树(Minimal Spinning Tree),可以采用Prim算法和Kruskal算法，并用动画的方式表示最小生成树的生成过程。

2、编写一个java程序实现Min堆(Heap)或者Max堆的只要功能，并用动画的方式表示Min堆或者Max堆的变化过程。

3、编写一个求解图的最小周游路径的算法，并用动画的方式表示最小周游路径的生成过程。

我也不太明白这个动画的方式是指的什么，是Flash？还是java有动画的一个功能？

...全文

315 21 打赏收藏转发到动态举报

写回复

用AI写文章

21 条回复

切换为时间正序

请发表友善的回复…

发表回复

dayong05141123 2012-10-28

打赏
举报

1、用java语言编写一个java应用程序根据给定图实现最小生成树(Minimal Spinning Tree),可以采用Prim算法和Kruskal算法，并用动画的方式表示最小生成树的生成过程。
2、编写一个java程序实现Min堆(Heap)或者Max堆的主要功能，并用动画的方式表示Min堆或者Max堆的变化过程。
3、编写一个求解图的最小周游路径的算法，并用动画的方式表示最小周游路径的生成过程。路径的生成过程。
答：第一题：
import java.util.*;
public class Main {
static int MAXCOST=Integer.MAX_VALUE;
static int Prim(int graph[][], int n){ /* lowcost[i]记录以i为终点的边的最小权值，当lowcost[i]=0时表示终点i加入生成树 */
int lowcost[]=new int[n+1]; /* mst[i]记录对应lowcost[i]的起点，当mst[i]=0时表示起点i加入生成树 */
int mst[]=new int[n+1];
int min, minid, sum = 0; /* 默认选择1号节点加入生成树，从2号节点开始初始化 */
for (int i = 2; i <= n; i++){ /* 最短距离初始化为其他节点到1号节点的距离 */
lowcost[i] = graph[1][i]; /* 标记所有节点的起点皆为默认的1号节点 */
mst[i] = 1; } /* 标记1号节点加入生成树 */
mst[1] = 0; /* n个节点至少需要n-1条边构成最小生成树 */
for (int i = 2; i <= n; i++){
min = MAXCOST; minid = 0; /* 找满足条件的最小权值边的节点minid */
for (int j = 2; j <= n; j++){ /* 边权值较小且不在生成树中 */
if (lowcost[j] < min && lowcost[j] != 0)
{ min = lowcost[j];
minid = j;
}
} /* 输出生成树边的信息:起点，终点，权值 */
System.out.printf("%c - %c : %d\n", mst[minid] + 'A' - 1, minid + 'A' - 1, min); /* 累加权值 */
sum += min; /* 标记节点minid加入生成树 */
lowcost[minid] = 0; /* 更新当前节点minid到其他节点的权值 */
for (int j = 2; j <= n; j++){ /* 发现更小的权值 */
if (graph[minid][j] < lowcost[j]){ /* 更新权值信息 */
lowcost[j] = graph[minid][j]; /* 更新最小权值边的起点 */
mst[j] = minid; }
}
} /* 返回最小权值和 */
return sum; }
public static void main(String args[]){
Scanner sc=new Scanner(System.in);
int cost;
char chx, chy; /* 读取节点和边的数目 */
int n=sc.nextInt(); //节点
int m=sc.nextInt(); //边数
int graph[][]=new int[n+1][n+1]; /* 初始化图，所有节点间距离为无穷大 */
for (int i = 1; i <= n; i++){
for (int j = 1; j <= n; j++)
{
graph[i][j] = MAXCOST;
}
} /* 读取边信息 */
for (int k = 0; k < m; k++){
chx=sc.next().charAt(0);
chy=sc.next().charAt(0);
cost=sc.nextInt();
int i = chx - 'A' + 1;
int j = chy - 'A' + 1;
graph[i][j] = cost;
graph[j][i] = cost; } /* 求解最小生成树 */
cost = Prim(graph, n); /* 输出最小权值和 */
System.out.println("Total:"+cost); }
}

第二题：
public class MinHeap {
private int[ ] Heap;
private int maxsize;
private int size;
public MinHeap(int max) {
maxsize = max;
Heap = new int[maxsize];
size = 0 ;
Heap[0] = Integer.MIN_VALUE; }
private int leftchild(int pos)
{ return 2*pos; }
private int rightchild(int pos)
{ return 2*pos + 1; }
private int parent(int pos)
{ return pos / 2; }
private boolean isleaf(int pos)
{ return ((pos > size/2) && (pos <= size)); }
private void swap(int pos1, int pos2)
{ int tmp;
tmp = Heap[pos1];
Heap[pos1] = Heap[pos2];
Heap[pos2] = tmp;
}
public void insert(int elem)
{ size++; Heap[size] = elem;
int current = size;
while (Heap[current] < Heap[parent(current)])
{ swap(current, parent(current));
current = parent(current);
}
}
public void print()
{ int i;
for (i=1; i<=size;i++)
System.out.print(Heap[i] + " ");
System.out.println();
}
public int removemin()
{ swap(1,size);
size--;
if (size != 0)
pushdown(1);
return Heap[size+1];
}
private void pushdown(int position)
{ int smallestchild;
while (!isleaf(position))
{smallestchild = leftchild(position);
if ((smallestchild < size) && (Heap[smallestchild] > Heap[smallestchild+1]))
smallestchild = smallestchild + 1;
if (Heap[position] <= Heap[smallestchild])
return;
swap(position,smallestchild);
position = smallestchild;
}
}
}

第三题：
package wjcsq;
class Edge {
char vexa;
char vexb;
int weight;
Edge(char vexa, char vexb, int weight) {
this.vexa = vexa;
this.vexb = vexb;
this.weight = weight;
}
}
public class prim {
static Edge[] e = { new Edge('a', 'b', 2), new Edge('b', 'c', 1),
new Edge('c', 'd', 2), new Edge('d', 'e', 9),
new Edge('e', 'f', 4), new Edge('f', 'g', 1),
new Edge('g', 'h', 9), new Edge('h', 'a', 1),
new Edge('a', 'i', 8), new Edge('b', 'i', 6),
new Edge('c', 'j', 3), new Edge('d', 'k', 7),
new Edge('e', 'k', 2), new Edge('f', 'k', 1),
new Edge('g', 'j', 4), new Edge('h', 'i', 7),
new Edge('i', 'j', 1), new Edge('j', 'k', 6) };
static int w(int x, int y) {
char from = (char) (x + 97);
char to = (char) (y + 97);
for (int i = 0; i < 18; i++) {
if (e[i].vexa == from && e[i].vexb == to) {
return e[i].weight;
}
if (e[i].vexa == to && e[i].vexb == from) {
return e[i].weight;
}
}
return 1000; }
public static void main(String[] args) {
int[] vex_mst = new int[11];
for (int i = 0; i < 11; i++)
vex_mst[i] = 0;
vex_mst[0] = 1;
for (int i = 0; i < 10; i++) {
int add_vex = 0;
int min_weight = 1000;
Edge adde = new Edge(' ', ' ', 0);
for (int j = 0; j < 11; j++)
if (vex_mst[j] == 1) {
for (int k = 0; k < 11; k++) {
if (vex_mst[k] == 0 && w(j, k) < min_weight) {
add_vex = k;
min_weight = w(j, k);
adde.vexa = (char) (j + 97);
adde.vexb = (char) (k + 97);
adde.weight = min_weight;
}
}
}
vex_mst[add_vex] = 1;
char avex = (char) (add_vex + 97);
system.out.println("addedge:" + adde.vexa + "-" + adde.vexb + " w:"+ adde.weight);
}
}
}

markmiss023 2011-04-08

打赏
举报

关注ing。。。我也想知道这个是怎么解决的。

zb_1225 2011-04-08

打赏
举报

关注。。。。。。。。。。。。。。。。。

jiazhengjing 2008-04-27

打赏
举报

晕，关注。
你老师给你们答案了记得来这里贴啊，顺便问下，你们几年级啊。

captaintao 2008-04-27

打赏
举报

那请你们就写写算法吧，图像不做

captaintao 2008-04-27

打赏
举报

- -!，摆脱，我们老师都没有教过JAVA，只是学了C++面向对象编程，而且都只是自己简单的自学了一下java，了解到和C++有点相识，本人算法学的烂，更不用说java的画图了，难，没办法，只好请教大家了。摆脱了，这不算是作弊

sigmod 2008-04-27

打赏
举报

最后一个是TSP？？都NP-hard了还搞动画。。。。

云上飞翔 2008-04-27

打赏
举报

答：即每求出一个状态（就是一个数组中的数据），就画出一步。再求出一个状态（数据还在数组中），再画出一步图。老师来了！！！

云上飞翔 2008-04-27

打赏
举报

[Quote=引用 6 楼 taotaox 的回复:]
我问了一下一个朋友（算是一般的高手吧），他都说这题有点难度，真的很难吗？
[/Quote]
答：谁说难的？上课老师都讲过的。算法都讲过的。你只要把算法中的每一步状态（放在一个数组或其它数据结构中），然后再在一个JPanel中一步一步画一下就行了。

云上飞翔 2008-04-27

打赏
举报

[Quote=引用楼主 taotaox 的帖子:]
1、用java语言编写一个java应用程序根据给定图实现最小生成树(Minimal Spinning Tree),可以采用Prim算法和Kruskal算法，并用动画的方式表示最小生成树的生成过程。

2、编写一个java程序实现Min堆(Heap)或者Max堆的只要功能，并用动画的方式表示Min堆或者Max堆的变化过程。

3、编写一个求解图的最小周游路径的算法，并用动画的方式表示最小周游路径的生成过程。

我也不太明白这个动画的方式是指的什么，是Flash…
[/Quote]
答：哪个把作业贴到这儿来了？不自己做？我去告诉老师去。