题目一

leetcode.cn/problems/ca…

// 1~choose 拥有的数字
// total 一开始的剩余
// 返回先手会不会赢
public static boolean canIWin0(int choose, int total) {
   if (total == 0) {
      return true;
   }
   if ((choose * (choose + 1) >> 1) < total) {
      return false;
   }
   int[] arr = new int[choose];
   for (int i = 0; i < choose; i++) {
      arr[i] = i + 1;
   }
   // arr[i] != -1 表示arr[i]这个数字还没被拿走
   // arr[i] == -1 表示arr[i]这个数字已经被拿走
   // 集合，arr，1~choose
   return process(arr, total);
}

// 当前轮到先手拿，
// 先手只能选择在arr中还存在的数字，
// 还剩rest这么值，
// 返回先手会不会赢
public static boolean process(int[] arr, int rest) {
   if (rest <= 0) {
      return false;
   }
   // 先手去尝试所有的情况
   for (int i = 0; i < arr.length; i++) {
      if (arr[i] != -1) {
         int cur = arr[i];
         arr[i] = -1;
         boolean next = process(arr, rest - cur);
         arr[i] = cur;
         if (!next) {
            return true;
         }
      }
   }
   return false;
}

// 这个是暴力尝试，思路是正确的，超时而已
public static boolean canIWin1(int choose, int total) {
   if (total == 0) {
      return true;
   }
   if ((choose * (choose + 1) >> 1) < total) {
      return false;
   }
   return process1(choose, 0, total);
}

// 当前轮到先手拿，
// 先手可以拿1~choose中的任何一个数字
// status   i位如果为0，代表没拿，当前可以拿
//          i位为1，代表已经拿过了，当前不能拿
// 还剩rest这么值，
// 返回先手会不会赢
public static boolean process1(int choose, int status, int rest) {
   if (rest <= 0) {
      return false;
   }
   for (int i = 1; i <= choose; i++) {
      if (((1 << i) & status) == 0) { // i 这个数字，是此时先手的决定！
         if (!process1(choose, (status | (1 << i)), rest - i)) {
            return true;
         }
      }
   }
   return false;
}

// 暴力尝试改动态规划而已
public static boolean canIWin2(int choose, int total) {
   if (total == 0) {
      return true;
   }
   if ((choose * (choose + 1) >> 1) < total) {
      return false;
   }
   int[] dp = new int[1 << (choose + 1)];
   // dp[status] == 1  true
   // dp[status] == -1  false
   // dp[status] == 0  process(status) 没算过！去算！
   return process2(choose, 0, total, dp);
}

// 为什么明明status和rest是两个可变参数，却只用status来代表状态(也就是dp)
// 因为选了一批数字之后，得到的和一定是一样的，所以rest是由status决定的，所以rest不需要参与记忆化搜索
public static boolean process2(int choose, int status, int rest, int[] dp) {
   if (dp[status] != 0) {
      return dp[status] == 1 ? true : false;
   }
   boolean ans = false;
   if (rest > 0) {
      for (int i = 1; i <= choose; i++) {
         if (((1 << i) & status) == 0) {
            if (!process2(choose, (status | (1 << i)), rest - i, dp)) {
               ans = true;
               break;
            }
         }
      }
   }
   dp[status] = ans ? 1 : -1;
   return ans;
}

题目二

TSP问题 有N个城市，任何两个城市之间的都有距离，任何一座城市到自己的距离都为0。所有点到点的距 离都存在一个N*N的二维数组matrix里，也就是整张图由邻接矩阵表示。

现要求一旅行商从k城市 出发必须经过每一个城市且只在一个城市逗留一次，最后回到出发的k城，返回总距离最短的路的 距离。

参数给定一个matrix，给定k。

public static int t1(int[][] matrix) {
   int N = matrix.length; // 0...N-1
   // set
   // set.get(i) != null i这座城市在集合里
   // set.get(i) == null i这座城市不在集合里
   List<Integer> set = new ArrayList<>();
   for (int i = 0; i < N; i++) {
      set.add(1);
   }
   return func1(matrix, set, 0);
}

// 任何两座城市之间的距离，可以在matrix里面拿到
// set中表示着哪些城市的集合，
// start这座城一定在set里，
// 从start出发，要把set中所有的城市过一遍，最终回到0这座城市，最小距离是多少
public static int func1(int[][] matrix, List<Integer> set, int start) {
   int cityNum = 0;
   for (int i = 0; i < set.size(); i++) {
      if (set.get(i) != null) {
         cityNum++;
      }
   }
   if (cityNum == 1) {
      return matrix[start][0];
   }
   // cityNum > 1  不只start这一座城
   set.set(start, null);
   int min = Integer.MAX_VALUE;
   for (int i = 0; i < set.size(); i++) {
      if (set.get(i) != null) {
         // start -> i i... -> 0
         int cur = matrix[start][i] + func1(matrix, set, i);
         min = Math.min(min, cur);
      }
   }
   set.set(start, 1);
   return min;
}

public static int t2(int[][] matrix) {
   int N = matrix.length; // 0...N-1
   // 7座城 1111111
   int allCity = (1 << N) - 1;
   return f2(matrix, allCity, 0);
}

// 任何两座城市之间的距离，可以在matrix里面拿到
// set中表示着哪些城市的集合，
// start这座城一定在set里，
// 从start出发，要把set中所有的城市过一遍，最终回到0这座城市，最小距离是多少
public static int f2(int[][] matrix, int cityStatus, int start) {
   // cityStatus == cityStatux & (~cityStaus + 1)

   if (cityStatus == (cityStatus & (~cityStatus + 1))) {
      return matrix[start][0];
   }

   // 把start位的1去掉，
   cityStatus &= (~(1 << start));
   int min = Integer.MAX_VALUE;
   // 枚举所有的城市
   for (int move = 0; move < matrix.length; move++) {
      if ((cityStatus & (1 << move)) != 0) {
         int cur = matrix[start][move] + f2(matrix, cityStatus, move);
         min = Math.min(min, cur);
      }
   }
   cityStatus |= (1 << start);
   return min;
}

public static int t3(int[][] matrix) {
   int N = matrix.length; // 0...N-1
   // 7座城 1111111
   int allCity = (1 << N) - 1;
   int[][] dp = new int[1 << N][N];
   for (int i = 0; i < (1 << N); i++) {
      for (int j = 0; j < N; j++) {
         dp[i][j] = -1;
      }
   }
   return f3(matrix, allCity, 0, dp);
}

// 任何两座城市之间的距离，可以在matrix里面拿到
// set中表示着哪些城市的集合，
// start这座城一定在set里，
// 从start出发，要把set中所有的城市过一遍，最终回到0这座城市，最小距离是多少
public static int f3(int[][] matrix, int cityStatus, int start, int[][] dp) {
   if (dp[cityStatus][start] != -1) {
      return dp[cityStatus][start];
   }
   if (cityStatus == (cityStatus & (~cityStatus + 1))) {
      dp[cityStatus][start] = matrix[start][0];
   } else {
      // 把start位的1去掉，
      cityStatus &= (~(1 << start));
      int min = Integer.MAX_VALUE;
      // 枚举所有的城市
      for (int move = 0; move < matrix.length; move++) {
         if (move != start && (cityStatus & (1 << move)) != 0) {
            int cur = matrix[start][move] + f3(matrix, cityStatus, move, dp);
            min = Math.min(min, cur);
         }
      }
      cityStatus |= (1 << start);
      dp[cityStatus][start] = min;
   }
   return dp[cityStatus][start];
}