力扣每日一题 特别的排列 DFS 记忆化搜索 位运算 状态压缩DP

Problem: 2741. 特别的排列

👨‍🏫 参考题解

🍻 暴搜

⏰ 时间复杂度：$O(N)$

class Solution {
    public int specialPerm(int[] nums) {
     
      boolean[] visited = new boolean[nums.length];
      return dfs(nums, 0, -1, visited);
    }
    // dfs(depth, prevPos) 定义为： 0到第depth个位置的特殊排列最后一位下标为prevPos 的特殊排列的总数目。
    private int dfs(int[] nums, int depth, int prevPos, boolean[] visited) {
    // 如果能枚举完整个数组，意味着这个排列是满足条件的特殊排列，那么返回一种方案
      if(depth == nums.length) {
        return 1;
      }
      int res = 0;
      for(int i = 0; i < nums.length; i++) {
        if(!visited[i]) {
            // 第0个数不需要考虑是否满足条件
          if (prevPos == -1 || nums[prevPos] % nums[i] == 0 || nums[i] % nums[prevPos] == 0) {
            visited[i] = true;
            res = (res + dfs(nums, depth + 1, i, visited)) % 1000000007;
            visited[i] = false;
          }
        }
      }
      return res;
    }
}

🍻 记忆化搜索

class Solution {

  public int specialPerm(int[] nums) {
    int n = nums.length;
    Map<String, Integer> memo = new HashMap<>(); 
    boolean[] visited = new boolean[nums.length];
    return dfs(nums, 0, -1, visited, 0, memo);

  }
  // dfs(depth, prevPos, u) 定义为： 0到第depth个位置的特殊排列最后一位下标为为prevPos，且排列对应的二进制占位为u，确定depth位的特殊排列的总数目。
  private int dfs(int[] nums, int depth, int prevPos, boolean[] visited, int u, Map<String, Integer> memo) {
    if(depth == nums.length) {
      return 1;
    }
    // 以 prevPos 和 二进制占位为key，只要二进制占位相同，数组长度也必然是相同的。
    String key = prevPos + "#" + u;
    if (memo.containsKey(key)) {
      return memo.get(key);
    }

    int res = 0;
    for(int i = 0; i < nums.length; i++) {
      if(!visited[i]) {
        if (prevPos == -1 || nums[prevPos] % nums[i] == 0 || nums[i] % nums[prevPos] == 0) {
          visited[i] = true;
          res = (res + dfs(nums, depth + 1, i, visited, u | (1 << i), memo)) % 1000000007;
          visited[i] = false;
        }
      }
    }
    memo.put(key, res);
    return res;
  }
}

🍻 位运算优化记忆化搜索

class Solution {

  public int specialPerm(int[] nums) {
    int n = nums.length;
    int[][] memo = new int[1 << nums.length][nums.length];
    for(int i = 0; i < 1 << nums.length; i++) {
      Arrays.fill(memo[i], -1);
    }
    return dfs(nums, 0, -1, memo);

  }
  // dfs(u, prePos) 定义为： 集合为u时，上一次选择的prePos时的特殊排列树目，prePos为-1代表第一次选择。
  private int dfs(int[] nums, int u, int prevPos, int[][] memo) {
    // 当集合为nums时，说明形成了特殊的排列
    // 注意 - 优先级 大于 <<，所以<<要上括号
    if(u == ((1 << nums.length) - 1)) {
      return 1;
    }
    // 以 prevPos 和 二进制占位为key，只要二进制占位相同，数组长度也必然是相同的。
    if (prevPos != -1 && memo[u][prevPos] != -1) {
      return memo[u][prevPos];
    }

    int res = 0;
    for(int i = 0; i < nums.length; i++) {
      // u >> i & 1 表明u向右移动i位，然后与1做与运算，等于1时表明i在集合u中，等于0则不在u中，代替了visited数组
      // i不在集合中，才继续遍历
      if((u >> i & 1) == 0) {
        if (prevPos == -1 || nums[prevPos] % nums[i] == 0 || nums[i] % nums[prevPos] == 0) {
          res = (res + dfs(nums, u | (1 << i),  i, memo)) % 1000000007;
        }
      }
    }

    if(prevPos == -1) {
      return res;
    }
    return memo[u][prevPos] = res;
  }
}

🍻 填表法 DP

class Solution {

  public int specialPerm(int[] nums) {
    int mod = (int) 1e9 + 7;
    int dp[][] = new int[1 << nums.length][nums.length ];
    // dp[u][j] := 当前集合为u，最后一次选择为j时的 特殊排列方案数 
    for (int i = 0; i < nums.length; i++) {
      // 选择i后，集合中增加i
      dp[1 << i][i] = 1;
    }

    for (int u = 0; u < 1 << nums.length; u++) {
      // 考虑当前集合为u时，加入新的数到集合中
      for (int j = 0; j < nums.length; j++) {
        // 集合u中不存在j时，j才能加入集合
        if ((u >> j & 1) == 0) {
          // 判断上一个选择的数k是否与j满足题意要求
          for (int k = 0; k < nums.length; k++) {
            // k不在集合中时 说明上一个数选择的数不可能是k
            if((u & 1 << k) > 0) {
              // k和j满足题意要求时才能形成特殊排列
              if ((nums[j] % nums[k] == 0 || nums[k] % nums[j] == 0)) {
                dp[u | 1 << j][j] = (dp[u | 1 << j][j] + dp[u][k]) % mod;
              }
            }
          }
        }
      }
    }

    int sum = 0;
    // 集合为nums，遍历最后一次选择的数
    for (int j = 0; j < nums.length; j++) {
      sum = (sum + dp[(1 << nums.length) - 1][j]) % mod;
    }

    return sum;
  }
}