DFS（全排列）-leetcode-869. 重新排序得到 2 的幂

869. 重新排序得到 2 的幂

题目描述

给定正整数 N ，我们按任何顺序（包括原始顺序）将数字重新排序，注意其前导数字不能为零。
如果我们可以通过上述方式得到 2 的幂，返回 true；否则，返回 false。

提示：

• $1<=N<=10^9$

DFS 暴搜

由于数据较小，最大只有 10 位数，使用 dfs 暴搜 也能过。

最简单的思路，就是利用 dfs 将 n 中所有 数位 进行 前排列后，判断每个 排列是否 “有效”：

1. 使用 set 保存 1e9 以内的 所有2的次幂；
2. 将 n 中每个位置分别存放在 String s 中；
3. 对 s 中所有字符进行 全排列，判断每个排列的结果是否符合题意（不可含有前导0、且是2的次幂）。

class Solution {
    Set<Integer> set = new HashSet<>();

    public boolean reorderedPowerOf2(int n) {
        // 存 1e9 以内的 所有2的次幂
        long cnt = 1L;
        while (cnt < Integer.MAX_VALUE) {
            set.add((int)cnt);
            cnt *= 2L;
        }
        System.out.println(set);
        // 将 n 中每个位置分别存放在 int[] 中
        StringBuilder sb = new StringBuilder();
        while (n != 0) {
            sb.append(n % 10);
            n /= 10;
        } 
        sb.reverse();
        System.out.println("sb = " + sb);
        // dfs
        return dfs(new boolean[sb.length()], sb.toString(), new StringBuilder());
    }

    public boolean dfs(boolean[] visited, String s, StringBuilder sb) {
        // System.out.println("sb = " + sb);
        if (sb.length() == s.length()) {
            if (isValid(sb.toString())) return true;
            else return false;
        }
        for (int i = 0; i < s.length(); i++) {
            if (visited[i]) continue;
            visited[i] = true;
            sb.append(s.charAt(i));
            if (dfs(visited, s, sb)) { // 只用遍历 树枝（满足条件，就返回）
                return true;
            }
            visited[i] = false;
            sb.deleteCharAt(sb.length() - 1);
        }
        return false;
    }

    public boolean isValid(String s) {
        // 不能有前导 0
        if (s.length() == 0) return false;
        if (s.charAt(0) == '0') return false;
        // 判断 s 是否为 2 的次幂
        if (set.contains(Integer.parseInt(s))) {
            return true;
        } else {
            return false;
        }
    }
}