Java中TSP问题的动态规划方法

我是一个初学者，我正在尝试使用动态规划方法编写一个工作旅行推销员问题

这是我的计算函数的代码：

public static int compute(int[] unvisitedSet, int dest) {
    if (unvisitedSet.length == 1)
        return distMtx[dest][unvisitedSet[0]];

    int[] newSet = new int[unvisitedSet.length-1];
    int distMin = Integer.MAX_VALUE;

    for (int i = 0; i < unvisitedSet.length; i++) {

        for (int j = 0; j < newSet.length; j++) {
            if (j < i)          newSet[j] = unvisitedSet[j];
            else                newSet[j] = unvisitedSet[j+1];
        }

        int distCur;

        if (distMtx[dest][unvisitedSet[i]] != -1) {
            distCur = compute(newSet, unvisitedSet[i]) + distMtx[unvisitedSet[i]][dest];

            if (distMin > distCur)
                distMin = distCur;
        }
        else {
            System.out.println("No path between " + dest + " and " + unvisitedSet[i]);
        }
    }
    return distMin;
}

样本输入：

-1 3 2 7
3 -1 10 1
2 10 -1 4
7 1 4 -1

预期产出：

10

---

我想你得对你的计划做些改变

这里有一个实现

---

我知道这是一个很老的问题，但它可能会在将来帮助别人

这是一篇关于TSP的动态规划方法的很好的论文

---

这是一个使用动态规划的TSP迭代解决方案。让您的生活更轻松的是将当前状态存储为位掩码，而不是存储在数组中。这样做的优点是状态表示是紧凑的，并且可以很容易地缓存

我在Youtube上详细介绍了这个问题的解决方案，请欣赏！代码是从我的

/**
*旅行商问题的Java动态实现
*编程将时间复杂度从O（n！）提高到O（n^2*2^n）。
*
*时间复杂度：O（n^2*2^n）
*空间复杂度：O（n*2^n）
*
**/
导入java.util.List；
导入java.util.ArrayList；
导入java.util.Collections；
公共类TSPDynamicProgramming迭代{
私有最终整数N，开始；
私人最终双[][]距离；
private List tour=new ArrayList（）；
私人双minTourCost=double.正无穷大；
私有布尔ranSolver=false；
公共TspDynamicProgrammingIterative（双[]距离）{
这（0，距离）；
} 
公共TspDynamicProgrammingIterative（整数开始，双[]距离）{
N=距离。长度；
如果（N=N）抛出新的IllegalArgumentException（“无效的开始节点”）；
this.start=start；
这个距离=距离；
}
//返回旅行推销员问题的最优旅行路线。
公共列表getTour（）{
如果（！ranSolver）solve（）；
回程旅游；
}
//返回最小的游览成本。
公共双getTourCost（）{
如果（！ranSolver）solve（）；
返回成本；
}
//解决旅行商问题并缓存解决方案。
公共空间解决方案（）{
如果（勒索者）返回；
java C++（1）你能添加一些关于你如何运行程序的信息吗？也可以添加输入和预期的输出。
10

/**
 * An implementation of the traveling salesman problem in Java using dynamic 
 * programming to improve the time complexity from O(n!) to O(n^2 * 2^n).
 *
 * Time Complexity: O(n^2 * 2^n)
 * Space Complexity: O(n * 2^n)
 *
 **/

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

public class TspDynamicProgrammingIterative {

  private final int N, start;
  private final double[][] distance;
  private List<Integer> tour = new ArrayList<>();
  private double minTourCost = Double.POSITIVE_INFINITY;
  private boolean ranSolver = false;

  public TspDynamicProgrammingIterative(double[][] distance) {
    this(0, distance);
  } 

  public TspDynamicProgrammingIterative(int start, double[][] distance) {
    N = distance.length;

    if (N <= 2) throw new IllegalStateException("N <= 2 not yet supported.");
    if (N != distance[0].length) throw new IllegalStateException("Matrix must be square (n x n)");
    if (start < 0 || start >= N) throw new IllegalArgumentException("Invalid start node.");

    this.start = start;
    this.distance = distance;
  }

  // Returns the optimal tour for the traveling salesman problem.
  public List<Integer> getTour() {
    if (!ranSolver) solve();
    return tour;
  }

  // Returns the minimal tour cost.
  public double getTourCost() {
    if (!ranSolver) solve();
    return minTourCost;
  }

  // Solves the traveling salesman problem and caches solution.
  public void solve() {

    if (ranSolver) return;

    final int END_STATE = (1 << N) - 1;
    Double[][] memo = new Double[N][1 << N];

    // Add all outgoing edges from the starting node to memo table.
    for (int end = 0; end < N; end++) {
      if (end == start) continue;
      memo[end][(1 << start) | (1 << end)] = distance[start][end];
    }

    for (int r = 3; r <= N; r++) {
      for (int subset : combinations(r, N)) {
        if (notIn(start, subset)) continue;
        for (int next = 0; next < N; next++) {
          if (next == start || notIn(next, subset)) continue;
          int subsetWithoutNext = subset ^ (1 << next);
          double minDist = Double.POSITIVE_INFINITY;
          for (int end = 0; end < N; end++) {
            if (end == start || end == next || notIn(end, subset)) continue;
            double newDistance = memo[end][subsetWithoutNext] + distance[end][next];
            if (newDistance < minDist) {
              minDist = newDistance;
            }
          }
          memo[next][subset] = minDist;
        }
      }
    }

    // Connect tour back to starting node and minimize cost.
    for (int i = 0; i < N; i++) {
      if (i == start) continue;
      double tourCost = memo[i][END_STATE] + distance[i][start];
      if (tourCost < minTourCost) {
        minTourCost = tourCost;
      }
    }

    int lastIndex = start;
    int state = END_STATE;
    tour.add(start);

    // Reconstruct TSP path from memo table.
    for (int i = 1; i < N; i++) {

      int index = -1;
      for (int j = 0; j < N; j++) {
        if (j == start || notIn(j, state)) continue;
        if (index == -1) index = j;
        double prevDist = memo[index][state] + distance[index][lastIndex];
        double newDist  = memo[j][state] + distance[j][lastIndex];
        if (newDist < prevDist) {
          index = j;
        }
      }

      tour.add(index);
      state = state ^ (1 << index);
      lastIndex = index;
    }

    tour.add(start);
    Collections.reverse(tour);

    ranSolver = true;
  }

  private static boolean notIn(int elem, int subset) {
    return ((1 << elem) & subset) == 0;
  }

  // This method generates all bit sets of size n where r bits 
  // are set to one. The result is returned as a list of integer masks.
  public static List<Integer> combinations(int r, int n) {
    List<Integer> subsets = new ArrayList<>();
    combinations(0, 0, r, n, subsets);
    return subsets;
  }

  // To find all the combinations of size r we need to recurse until we have
  // selected r elements (aka r = 0), otherwise if r != 0 then we still need to select
  // an element which is found after the position of our last selected element
  private static void combinations(int set, int at, int r, int n, List<Integer> subsets) {

    // Return early if there are more elements left to select than what is available.
    int elementsLeftToPick = n - at;
    if (elementsLeftToPick < r) return;

    // We selected 'r' elements so we found a valid subset!
    if (r == 0) {
      subsets.add(set);
    } else {
      for (int i = at; i < n; i++) {
        // Try including this element
        set |= 1 << i;

        combinations(set, i + 1, r - 1, n, subsets);

        // Backtrack and try the instance where we did not include this element
        set &= ~(1 << i);
      }
    }
  }

  public static void main(String[] args) {
    // Create adjacency matrix
    int n = 6;
    double[][] distanceMatrix = new double[n][n];
    for (double[] row : distanceMatrix) java.util.Arrays.fill(row, 10000);
    distanceMatrix[5][0] = 10;
    distanceMatrix[1][5] = 12;
    distanceMatrix[4][1] = 2;
    distanceMatrix[2][4] = 4;
    distanceMatrix[3][2] = 6;
    distanceMatrix[0][3] = 8;

    int startNode = 0;
    TspDynamicProgrammingIterative solver = new TspDynamicProgrammingIterative(startNode, distanceMatrix);

    // Prints: [0, 3, 2, 4, 1, 5, 0]
    System.out.println("Tour: " + solver.getTour());

    // Print: 42.0
    System.out.println("Tour cost: " + solver.getTourCost());
  }
}