我需要解决【TSP旅行商】问题，请列出【2】个可以用【Java】编程的优化路径算法，展开写出这【2】个算法的编程难度级别和时间复杂度，罗列出每个算法编程要用到的库。一键高性能模式

【TSP旅行商问题（Traveling Salesman Problem, TSP）】是一个经典的组合优化问题，目标是最短路径，即找到访问所有城市的最短路线并返回起点。以下是两个常用的解决TSP问题的Java算法：

1. **贪心算法** (Approximation Algorithm)
- 编程难度：中等偏下
- 时间复杂度：O(n^2)，其中n是城市数量。这是因为每次选择下一个城市时都需要遍历剩余的城市。
- 库依赖：基本的Java集合框架（List/Tuple），无需额外库。

import java.util.*;

public class GreedyTSP {
   public List<Integer> greedyTSP(int[][] distances) {
       // 初始化和存储已访问的城市
       int[] currentCities = new int[distances.length];
       Arrays.fill(currentCities, 0);
       currentCities[0] = 0;

       // 计算贪心路线
       for (int i = 1; i < distances.length; i++) {
           int minDistance = Integer.MAX_VALUE;
           int nextCityIndex = 0;
           for (int j = 0; j < currentCities.length; j++) {
               if (j != currentCities[i - 1]) { // 避免重复访问
                   minDistance = Math.min(minDistance, distances[currentCities[i - 1]][j]);
               }
           }
           currentCities[i] = minDistance == Integer.MAX_VALUE ? 0 : Collections.binarySearch(Arrays.asList(currentCities), minDistance).abs(); // 添加最小距离的城市
       }

       return Arrays.asList(currentCities);
   }
}

2. **遗传算法** (Heuristic Search)
- 编程难度：较高
- 时间复杂度：取决于搜索策略，一般认为是NP-hard问题，实际运行可能较慢。因为涉及到随机搜索和进化过程，所以没有精确的时间复杂度。
- 库依赖：除了基本的Java集合，可能需要第三方库如JAlgo（用于遗传算法）、MathUtils（概率计算）等。

import org.jalgo GeneticAlgorithm;
import org.jalgo.functions.Function;
import java.util.ArrayList;

public class GeneticTSP {
   public List<Integer> geneticTSP(int[][] distances) {
       // ... 实现遗传算法的编码、适应度函数、交叉、变异等步骤
       Function<List<Integer>, Double> fitnessFunction = cities -> distanceFunction(cities, distances); // 自定义距离计算函数
       GeneticAlgorithm<List<Integer>> ga = new GeneticAlgorithm<>(fitnessFunction);
       Population population = ga.evolve(distances.length);

       // 返回最佳解
       return population.getBestSolution();
   }

   private double distanceFunction(List<Integer> cities, int[][] distances) {
       double totalDistance = 0;
       for (int i = 1; i < cities.size(); i++) {
           totalDistance += distances[cities.get(i - 1)][cities.get(i)];
       }
       totalDistance += distances[cities.get(cities.size() - 1)][cities.get(0)]; // 回到起点
       return totalDistance;
   }
}