[JAVA] Grafi non orientati: Dijkstra e Prim

[noipo]

Ho scritto questo codice sui grafi non orientati. I metodi vanno tutti apparte Dijkstra e Prim. Dato che Prim è una modifica di Dijkstra vorrei risolvere il problema di quest'ultimo.
Quando compilo il codice (commentando l'algoritmo di Prim quindi eseguendo solo Dijkstra), il compilatore mi dice che c'è un errore (not a statement) alla riga:

Nodo u = new Nodo(coda.estraiPrimo());

Non so come risolvere.. Sono bloccato..

package grafi;

import coda.*;
import arrays.*;
import grafo.unionFind.*;
import java.util.*;
import java.lang.*;
import java.io.*;

public class GrafoNonOrientatoListeDiAdiacenza implements GrafoNonOrientato {

	static final int dimStandard = 100;
	private static double INFINITO = Double.MAX_VALUE;
	Nodo[] arrayNodi;
	Arco[] arrayArchi;
	int ultimoNodi;
	int ultimoArchi;
	boolean[] visitato;
	double[] peso;
	int[] padre;
	CodaConPriorita coda;
	UnionFindInt unionFind;
	Hashtable<String, Integer> mapNodi;
	Hashtable<String, Integer> mapArchi;
	private static Random gen = new Random();

	private class Arco {
		String nodo1;
		String nodo2;
		String info;
		double peso;

		private Arco()	{
			nodo1 = "";
			nodo2 = "";
			info = null;
			peso = 0;
		}

		private Arco(String n1, String n2, double peso) {
			nodo1 = n1;
			nodo2 = n2;
			info = null;
			this.peso = peso;
		}
	}

	private class Nodo {
		String nome;
		LinkedList<String> listeAd;

		private Nodo() {
			nome = "";
			listeAd = new LinkedList<String>();
		}

		private Nodo(String nome) {
			this.nome = nome;
			listeAd = new LinkedList<String>();
		}
	}

	public GrafoNonOrientatoListeDiAdiacenza() {
		arrayNodi = new Nodo[dimStandard];
		arrayArchi = new Arco[dimStandard];
		ultimoNodi = 0;
		ultimoArchi = 0;
		visitato = new boolean[dimStandard];
		peso = new double[dimStandard];
		padre = new int[dimStandard];
		coda = FabbricaCodaConPriorita.crea(dimStandard);
		unionFind = FabbricaUnionFindInt.crea(dimStandard);
		mapNodi = new Hashtable<String, Integer>(dimStandard);
		mapArchi = new Hashtable<String, Integer>(dimStandard);
	}

	public GrafoNonOrientatoListeDiAdiacenza(int n) {
		arrayNodi = new Nodo[n];
		arrayArchi = new Arco[n];
		ultimoNodi = 0;
		ultimoArchi = 0;
		visitato = new boolean[n];
		peso = new double[n];
		padre = new int[n];
		coda = FabbricaCodaConPriorita.crea(n);
		unionFind = FabbricaUnionFindInt.crea(n);
		mapNodi = new Hashtable<String, Integer>(n);
		mapArchi = new Hashtable<String, Integer>(n);
	}

	public int numNodi() {
		return ultimoNodi;
	}


	public int numArchi() {
		return ultimoArchi;
	}

	public void aggiungiNodo(String v) {
		Integer x = mapNodi.get(v);
		if(x == null) {
			mapNodi.put(v, ultimoNodi);
			arrayNodi[ultimoNodi] = new Nodo(v);
			ultimoNodi++;
		}
		else
			System.out.println("Nodo gia' esistente");
	}

	public void aggiungiArco(String nodo1, String nodo2, double peso, String nome) {
		Integer x1 = mapNodi.get(nodo1);
		Integer x2 = mapNodi.get(nodo2);
		if((x2 != null) && (x1 != null)) {
			String n = nodo1 + nodo2;
			Object x = mapArchi.get(n);
			if(x == null) {
				mapArchi.put(n, ultimoArchi);
				mapArchi.put(nodo2 + nodo1, ultimoArchi);
				Arco nuovo = new Arco(nodo1, nodo2, peso);
				arrayArchi[ultimoArchi] = nuovo;
				int ind = mapNodi.get(nodo1).intValue();
				int ind1 = mapNodi.get(nodo2).intValue();
				arrayNodi[ind].listeAd.add(nodo2);
				arrayNodi[ind1].listeAd.add(nodo1);
				ultimoArchi++;
			}
			else
				System.out.println("Arco gia' esistente");
		}
		else
			System.out.println("Nodi inesistenti");
	}


	public void dijkstra(String nodoS) {
	     double[] dist = new double[dimStandard];
	     for(int x = 0; x < ultimoNodi; x++) { //per ogni nodo
		dist[x] = INFINITO; 
		padre[x] = -1;
	     }		
	     Integer inodoS = mapNodi.get(nodoS);
	     padre[inodoS] = inodoS; 
	     dist[inodoS] = 0;
	     CodaConPriorita coda = FabbricaCodaConPriorita.crea(dimStandard);
	     for(int x = 0; x < ultimoNodi; x++) { //per ogni nodo 
		String j = arrayNodi[x].nome;
		coda.inserisci(j, dist[x]);
	     }		
	     while(!coda.eVuota()) {
		Nodo u = new Nodo(coda.estraiPrimo()); //estraggo il primo cioe' quello con distanza minima
		Integer iU = mapNodi.get(u);
		for(int v = 0; v < arrayNodi[iU].listeAd.size(); v++) { //for each(Nodo v adiacente a u)
			double cuv = pesoArco(u.nome, arrayNodi[v].nome); 
			if(dist[iU] + cuv < dist[v]) {
				padre[v] = iU; 
				dist[v] = dist[iU] + cuv;
				coda.cambiaPriorita(arrayNodi[v].nome, dist[v]); //decreasePriority(v, dist[v], coda);
			}
		} //end for
	   } //end while
      }

public double pesoArco(String arco1, String arco2) {
	for(int i = 0; i < ultimoArchi; i++) {
		String nome1 = arrayArchi[i].nodo1 + arrayArchi[i].nodo2;
		String nome2 = arrayArchi[i].nodo2 + arrayArchi[i].nodo1;
		if(arrayArchi[i].info.compareTo(nome1) == 0 || arrayArchi[i].info.compareTo(nome2) == 0)
			return arrayArchi[i].peso;
	}
	throw new IllegalArgumentException();
}

	public GrafoNonOrientato prim(String nodoS) {
		Integer inodo1 = mapNodi.get(nodoS);
		if(inodo1 == null)
			return null;
		GrafoNonOrientatoListeDiAdiacenza gg = new GrafoNonOrientatoListeDiAdiacenza(ultimoNodi);
		for(int i = 0; i < ultimoNodi; i++)
			visitato[i] = false;
		int inodo = mapNodi.get(nodoS).intValue();
		peso = new double[ultimoNodi];
		padre = new int[ultimoNodi];
		for(int i = 0; i < ultimoNodi; i++) {
			peso[i] = Double.POSITIVE_INFINITY;
			padre[i] = -1;
		}
		coda = FabbricaCodaConPriorita.crea(ultimoNodi);
		coda.inserisci(nodoS, 0.0);
		peso[inodo] = 0;
		while(!coda.eVuota()) {
			nodoS = coda.estraiPrimo();
			String nodoCorrente = arrayNodi[inodo].nome;
			gg.aggiungiNodo(nodoCorrente);
			visitato[inodo] = true;
			for(int i = 0; i < arrayNodi[inodo].listeAd.size(); i++) {
				String nodoVicino = arrayNodi[inodo].listeAd.get(i);
				int iarco = mapArchi.get(nodoVicino + nodoCorrente).intValue();
				int iNodoVicino = mapNodi.get(nodoVicino).intValue();
				if(!visitato[iNodoVicino]) {
					if(peso[iNodoVicino] > arrayArchi[iarco].peso) {
						if(peso[iNodoVicino] == Double.POSITIVE_INFINITY)
							coda.inserisci(nodoVicino, arrayArchi[iarco].peso);
						else
							coda.cambiaPriorita(nodoVicino, arrayArchi[iarco].peso);
						padre[iNodoVicino] = inodo;
						peso[iNodoVicino] = arrayArchi[iarco].peso;
					}
				}
			}
		}
		for(int i = 0; i < padre.length; i++) {
			if(padre[i] != -1) {
				String arcoNome = arrayNodi[padre[i]].nome + arrayNodi[i].nome;
				gg.aggiungiArco(arrayNodi[padre[i]].nome, arrayNodi[i].nome, peso[i], arcoNome);
			}
		}
		return gg;
	} 

        <altri metodi>
}

Se qualcuno potesse aiutarmi ne sarei felicissimo...
Grazie!

[noipo]

Qualche idea?

[Rggb1]

Manca un bel po' di codice per poter valutare con esattezza. Comunque se l'interprete segnala 'not a statement' vuol dire che non è riuscito a fare correttamente il parsing e la riga indicata è l'ultima alla quale riesce a risalire; della serie: l'errore potrebbe non essere proprio quella riga.

[noipo]

Grazie per la risposta. Se ti posto il codice mancante gli da resti una controllata?