编辑：

Question

我想我对如何解决算法有一般的想法，但实现似乎没有我。到目前为止我所拥有的是：

public class GreedySalesman {


public static int[] greedySalesmanSolution(int[][] distances) {
    List cityList = new ArrayList();
            for(int[] array: distances) {
               cityList.add(Arrays.asList(array));
            }
    List<Integer> initialResult = new ArrayList();
    initialResult.add(0);
    List<Integer> finalResult = findMinDistance(cityList, cityList, initialResult, 0);
          /*int finalResultArray = new int[finalResult.size()+1];
    int i = 0;
    while (!(finalResult.isEmpty)) {
                finalResultArray[i] = finalResult.poll();
                i++;
    }

    return finalResultArray;
    */
          return null;
        }

public static List<Integer> findMinDistance(List<List<Integer>> initialCityInput, List<List<Integer>> cityInput, List<Integer> distanceResult, int index) {
        if(cityInput.isEmpty()) {
            distanceResult.add(0);
            return distanceResult;
        }
        int min = Collections.min(initialCityInput.get(index));
        List<Integer> city = initialCityInput.get(index);
        index = city.indexOf(min);
        distanceResult.add(index);
        cityInput.remove(city);

        return findMinDistance(initialCityInput,cityInput,distanceResult,index);

}
}

也就是说，算法将采用二维int数组作为输入，然后将List cityList引用为distance，然后将其传递给findMinDistance。注释掉的部分是将findMinDistance的结果转换为int数组并作为finalResultArray返回但该部分尚不重要的地方。

findMinDistance将获取两次Integers的二维列表，一个将成为结果的整数List和一个表示索引的int。当cityInput被清空时，该函数将返回distanceResult。否则，它将从基于索引的第一个城市开始，获取该列表及其索引的最小距离，并将索引添加到distanceResult。完成后，城市将从cityInput中删除，程序将进行递归，直到cityInput被清空。

我目前遇到的问题是I cannot be cast to java.lang.Integer 在

int min = Collections.min(initialCityInput.get(index));

主要是尝试使用一些测试数据运行程序。任何帮助将不胜感激。

==

编辑：

我对代码进行了一些更改

public class GreedyTSP {

    public int[] greedySalesmanSolution(int[][] distances) {
                List<List<Integer>> cityList = new ArrayList();
                List<List<Integer>> initialCityList = new ArrayList();
                int iLength = distances.length;
                for (int i = 0; i < iLength; ++i) {
                    int jLength = distances[0].length;
                    cityList.add(new ArrayList(jLength));
                    initialCityList.add(new ArrayList(jLength));
                    for (int j = 0; j < jLength; ++j) {
                      cityList.get(i).add(distances[i][j]);
                      initialCityList.get(i).add(distances[i][j]);
                    }
                }

        List<Integer> initialResult = new ArrayList();
        initialResult.add(0);
        List<Integer> finalResult = findMinDistance(initialCityList, cityList, initialResult, 0);
                int[] finalResultArray = new int[finalResult.size()];
                Iterator<Integer> iterator = finalResult.iterator();
                for (int i = 0; i < finalResultArray.length; i++){
                    finalResultArray[i] = iterator.next().intValue();
                }
        return finalResultArray;


            }

        public List<Integer> findMinDistance(List<List<Integer>> initialCityInput, List<List<Integer>> cityInput, List<Integer> distanceResult, int initialIndex) {
            if(cityInput.isEmpty()) {
                distanceResult.add(0);
                return distanceResult;
            }  
            List<Integer> city = initialCityInput.get(initialIndex);
            Integer min = findMin(city, distanceResult, initialIndex);
            int resultIndex = city.indexOf(min);
            distanceResult.add(resultIndex);
            cityInput.remove(city);
            return findMinDistance(initialCityInput,cityInput,distanceResult,resultIndex);
    }

        public Integer findMin(List<Integer> city, List<Integer> distanceResult, int inputIndex) {
            Integer min = Integer.MAX_VALUE;
            for(int i = 0; i < city.size();i++) {
                if (city.get(i) > inputIndex && city.get(i) < min) min = city.get(i);
            }
            int resultIndex = city.indexOf(min);
            if(distanceResult.contains(resultIndex)) {
                return findMin(city, distanceResult, inputIndex);
            }

            return min;
        }   
}

我目前没有任何强制转换错误，但似乎我的程序中处理递归的部分导致了StackOverflowError-s。我现在一直在搞这个东西16个小时，而且我完全不知道为什么。有什么想法吗？

Answer 1

您的投射问题如下

List<List<Integer>> initialCityInput是一个包含带整数列表的List。

因此initalCityInput.get(index)返回一个List而不是Int，它不能转换为int。

Answer 2

嗯，我看了一下，我基本上通过使用多维arraylists使任务过于复杂。我更改了代码：

public class GreedyTSP {

  public static int[] greedySolution(int[][] adjacencyMatrix) {
      List<Integer> visitedCities = new ArrayList<>();
        int min = Integer.MAX_VALUE;
        int startLocation = 0;
        int tempStartLocation = 0;
        int[] resultArray = new int[adjacencyMatrix.length+1];
        visitedCities.add(0);


        while(visitedCities.size() < adjacencyMatrix.length ){
            for(int i = 0; i < adjacencyMatrix.length; i++){
                if(!visitedCities.contains(i) && adjacencyMatrix[startLocation][i] < min){
                    min = adjacencyMatrix[startLocation][i];
                    tempStartLocation = i;
                }

            }
            startLocation = tempStartLocation;
            visitedCities.add(tempStartLocation);
            min = Integer.MAX_VALUE;
        }

        visitedCities.add(0);
        for(int i = 0; i < resultArray.length; i++){
            int temp = visitedCities.get(i);
            resultArray[i] = temp;
        }
        return resultArray;
    }
}

这将使用贪婪算法解决任务

使用贪婪算法与旅行销售员发生铸造问题

编辑：

2 个答案: