라우팅 문제를 풀고 있습니다.
다익스트라 알고리즘으로 풀고 있는데요.
예제 입출력은 잘 나옵니다.
그러나 제출하면 아래와 같이
RTE (nonzero return code)
라고 뜨는데요, 원인을 모르겠습니다.
혹시 Main 이외의 클래스를 선언해서 쓰면 안되는건가요?;;

import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {

static int x;
static int y;
static double val;

static int size = 0;
static double sol = 0.0;

public static void main(String[] args) throws FileNotFoundException {
    long start = System.currentTimeMillis();
    int cases = 0;
    int lineCnt = 0;

    Scanner in = new Scanner(System.in);
    //Scanner in = new Scanner(new File("./src/routing_dijkstra_opti_1/input.txt"));

    cases = in.nextInt();

    for(int caseNum=0; caseNum<cases; caseNum++) {          
        sol = 0.0;
        size = 0;

        size = in.nextInt();
        lineCnt = in.nextInt();

        //arr = new double[size][size];
        Map<Integer, Map<Integer, Double>> arr = new HashMap<Integer, Map<Integer, Double>>();

        for(int i=0; i<lineCnt; i++) {
            x = in.nextInt();   //x에서
            y = in.nextInt();   //y로 가는 비용
            val = in.nextDouble();      

            if(!arr.containsKey(x))
                arr.put(x, new HashMap<Integer, Double>());

            arr.get(x).put(y, val);
        }           

        //입력 잘되었는지 테스트

// for(int i=0; i // for(int j=0; j // System.out.print(arr[i][j] + "\t");
// }
// System.out.println();
// }
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//여기부터 알고리즘 시작.
//거리를 저장할 배열을 선언
ArrayList Q = new ArrayList();
ArrayList Q2 = new ArrayList();
//초기 거리 세팅
Q.add(new Node(0, 1.0, 0));
for(int i=1; i<size; i++) {
Q.add(new Node(i,-1.0,0));
}

//size 만큼 뺄거니까 size 만큼 for 문 돌리자.

        double selectCost;
        double beforeCost;
        double lineCost;
        double newCost;
        int end = size-1;
        for(int i=0; i<size; i++) {
            //로직 시작

            //원본을 백업떠둔다.    정렬하여 선택되지 않은 노드들 중 선택할 노드를 찾기 위하여
            Q2 = (ArrayList<Node>) Q.clone();
            Node select = getMin(Q2);//before 중에 있는 것 중에 거리가 가장 작은것을 선택한다.
            int n = select.n;   //선택한 노드번호
            if(n == end) {
                sol = select.dist;
                break;
            }
            Q.get(n).selected = true;

            selectCost = select.dist;   //선택한 노드까지 오는 코스트
            //System.out.println(selectCost);
            for(int j=0; j<size; j++) {
                //lineCost = arr[n][j]; //선택한 노드에서 j노드로 가는 비용
                Map<Integer, Double> temp = null;
                if(!arr.containsKey(n)) {
                    continue;
                }
                temp = arr.get(n);
                if(!temp.containsKey(j)) {
                    continue;
                }
                lineCost = temp.get(j);
                if(lineCost == 0)
                    continue;

                newCost = selectCost * lineCost;
                beforeCost = Q.get(j).dist;
                if( newCost < beforeCost || beforeCost == -1.0 ) { //원래 거리보다 작거나 원래거리가 무한대이면
                    //j번째 노드에 새cost를 넣어줌.
                    Q.remove(j);
                    Q.add(j, new Node(j, newCost, n));
                }
            }
        }

        System.out.println(String.format("%.10f", sol));


    }//한 케이스 종료

    long end = System.currentTimeMillis();
    //System.out.println("실행시간 : " + (end-start) + "ms");

}//메인함수 종료

private static Node getMin(ArrayList<Node> q) {
    // TODO Auto-generated method stub
    Collections.sort(q, new Comparator<Node>() {

        @Override
        public int compare(Node o1, Node o2) {
            // TODO Auto-generated method stub
            double x = o1.dist;
            double y = o2.dist;
            if(o1.selected == true)
                return 1;
            if(o2.selected == true)
                return -1;
            if(x == -1.0) {
                return 1;
            }
            if(y == -1.0) {
                return -1;
            }
            if(x-y < 0.0) {
                return -1;
            }
            return 1;
        }
    });

    return q.get(0);
}

}

class Node {
int n;
double dist;
boolean selected = false;

public Node(int n, double dist, int way) {
    super();
    this.n = n;
    this.dist = dist;
}

}