最优灌溉10分垃圾

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class A {
		static int Max=10000;
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		int vnum=scanner.nextInt();
		int rnum=scanner.nextInt();
		VNode[] adjlist=new VNode[vnum+1];
		for (int i = 1; i <= vnum; i++) {
			adjlist[i]=new VNode();
			adjlist[i].queue=new ArrayList<ArcNode>();
		}
		for (int i = 0; i < rnum; i++) {
			int start=scanner.nextInt();
			int end=scanner.nextInt();
			int cost=scanner.nextInt();
			ArcNode arcNode=new ArcNode();
			arcNode.cost=cost;
			arcNode.adjvex=end;
			adjlist[start].queue.add(arcNode);
			ArcNode arcNode1=new ArcNode();
			arcNode1.cost=cost;
			arcNode1.adjvex=start;
			adjlist[end].queue.add(arcNode1);
		}
		for (int i = 1; i <= rnum; i++) {
			Collections.sort(adjlist[i].queue,new Comparator<ArcNode>() {
				public int compare(ArcNode o1, ArcNode o2) {
					return o1.cost<o2.cost? -1:1;
				}
			});
		}
		Graph graph=new Graph(vnum, rnum, adjlist);
		int count=0;
		int[] visited=new int[vnum+1];
		visited[1]=1;
		int u=1,v=1;
		int ans=0;
		while (count<vnum-1) {
			int mincost=Max;
			for (int i = 1; i <= vnum; i++) {
				u=i;
				if (visited[i]==1) {
					for (ArcNode arcNode:graph.adjList[i].queue) {
						if (arcNode.cost<mincost&&visited[arcNode.adjvex]!=1) {
							mincost=arcNode.cost;
							v=arcNode.adjvex;
							break;
						}
					}
				}
			}
			if (visited[v]==0||visited[u]==0) {
				count++;
				ans+=mincost;
				visited[v]=1;
			}		
		}
		System.out.println(ans);
	}

}
class ArcNode{
	int adjvex;
	int cost;
}
class VNode{
	List<ArcNode> queue;
}
class Graph{
	int vnum;
	int arcnum;
	VNode[] adjList;
	public Graph(int v,int e,VNode[] vnode){
		vnum=v;
		arcnum=e;
		adjList=vnode;
	}
}

之前那个运行超时，使用邻接矩阵表示的，但是为了简便一下算法，使用邻接表，然后对所有的邻接边进行按照花费进行排序了，这样在prim算法中可以省点麻烦，但是

虽然运行结果是对的，但是提交之后又是错的，这几天就没有做出几道题，也是心真累。