2017-04-13 1 views
0

J'essaye de convertir mon 2-opt du problème du vendeur itinérant en un 3-opt. Je comprends que c'est, par rapport à 2-opt, enlever 3 bords et les remplacer pour espérer obtenir une meilleure distance. J'ai de la difficulté à trouver ce qu'il faut changer/ajouter à mon swap 2-opt pour le rendre trois opt. Le principal problème que j'ai est de savoir comment s'assurer que les 8 variétés de swaps sont comptabilisées dans une seule fonction d'échange. Merci2-opt à 3-opt pour Traveller Salesman

Code 2-opt:

private static int[] TwoOpt(int[] TSP) { 
     double best = totalDistance; 
     int numCities = TSP.length; 
     int visited = 0; 
     int current = 0; 
     int[] newTour = TSP; 
     while (visited < numCities) { 
      for (int i = 0; i < numCities - 1; i++) { 
       for (int j = i + 1; j < numCities; j++) { 
        int[] newerTour = Swap(i, j, newTour); 
        int newDistance = distance(newerTour); 
        if (newDistance < best) { 
         visited = 0; 
         best = newDistance; 
         newTour = newerTour; 
        } 
       } 
      } 
      visited++; 

     } 
     return newTour; 

    } 

    private static int distance(int[] newTour) { 
     int distance = 0; 
     for (int i = 0; i < newTour.length - 1; i++) { 
      distance += mstList.get(i).get(i + 1).p; 
     } 
     distance += mstList.get(newTour.length).get(0).p; 
     return distance; 
    } 

    private static int[] Swap(int i, int j, int[] tour) { 
     int size = tour.length; 
     int[] newerTour = new int[tour.length]; 
     for (int c = 0; c <= i - 1; c++) { 
      newerTour[c] = tour[c]; 
     } 
     int change = 0; 
     for (int d = i; d <= j; d++) { 
      newerTour[d] = tour[d - change]; 
      change++; 
     } 
     for (int e = j + 1; e < size; e++) { 
      newerTour[e] = tour[e]; 
     } 
     return newerTour; 

    } 

et voici ce que j'ai pour les trois-opt, pas de swap encore mis en œuvre.

private static int[] ThreeOpt(int[] TSP) { 
     double best = totalDistance; 
     int numCities = TSP.length; 
     int visited = 0; 
     int current = 0; 
     int[] newTour = TSP; 
     while (visited < numCities) { 
      for (int i = 0; i < numCities - 2; i++) { 
       for (int j = i + 1; j < numCities - 1; j++) { 
        for (int k = j + 1; k < numCities; k++) { 
         int[] newerTour = Swap(i, j, k, newTour); 
         int newDistance = distance(newTour); 
         if (newDistance < best) { 
          visited = 0; 
          best = newDistance; 
          newTour = newerTour; 
         } 
        } 
       } 
      } 
      visited++; 

     } 
     return newTour; 
    } 

Répondre

0

Il existe actuellement seulement 4 formes de 3-opt.

briser le tour en trois parties A -> B -> C->

le 2-opt sur les deux bords de liaison B à A et C sont les suivants:

  • A-> , < -B, C>

dire juste inverser la tournée de B.

maintenant 3-opt

  • A->, < -B, -C <
  • A -> C -> B->
  • A -> C->, < -B
  • A->, < C, B->

noter que A->, < -B, C->, et A -> B->, < C et A->, -C <, < - B sont tous 2-opt.

Les inversions sont faciles à mettre en œuvre et il suffit de considérer 4 variantes.