1780. 判断一个数字是否可以表示成三的幂的和

题目

给你一个整数 n ，如果你可以将 n 表示成若干个不同的三的幂之和，请你返回 true ，否则请返回 false 。

对于一个整数 y ，如果存在整数 x 满足 y == 3x ，我们称这个整数 y 是三的幂。

 

示例 1：

输入：n = 12
输出：true
解释：12 = 31 + 32

示例 2：

输入：n = 91
输出：true
解释：91 = 30 + 32 + 34

示例 3：

输入：n = 21
输出：false

 

提示：

• 1 <= n <= 107

深搜（不超时）

可以深度搜索的原因是，3⁰,3¹ … 3ⁿ 是任意组合，只是每个只能选择一次，又因为10⁷ < 3¹⁶，所以数据量只有16个，是可以暴力的。
比如12，红色圈圈表示选或者不选

class Solution {
    public boolean checkPowersOfThree(int n) {
        return dfs(n, 0);
    }

    public boolean dfs(int target, int num) {
        if (target == 0) return true;
        if (target < 0) return false;
        int count = num;
        int ans = (int)Math.pow(3, count);
        boolean temp = false;
        while (ans <= target) {
            temp |= dfs(target - ans, count + 1);
            count++;
            ans = (int)Math.pow(3, count);
        }
        return temp;
    }
}

动态规划（超时写法）

思路跟01背包问题一样，这个算法会超时。其实主要是练习一下动态规划的思想。

二维

根据 3⁰,3¹ … 3^m （这里可以用 w[i]表示每一个项）划分阶段，为了方便理解，状态可以先用dp[i][j]表示，i是代表 3⁰,3¹ ,3ⁱ … 3^m，前i项是已经处理好的问题。j是1 <= n <= 10⁷。状态转移是 j <= w[i] dp[i][j] = dp[i - 1][j] || j == wi; j > wi时 dp[i][j] = dp[i - 1][j - w[i]];

class Sulution{
	public boolean checkPowersOfThree(int n) {
        int m = 0;
        while (Math.pow(3, m) <= n) m++;
        boolean[][] dp = new boolean[m][n + 1];
        int[] w = new int[m];

        for (int i = 0; i < m; i++) {
            w[i] = (int)Math.pow(3, i);
        }

        dp[0][1] = true;

        for (int i = 1; i < m; i++) {
            for (int j = 1; j <= n; j++) {
                if (j <= w[i]) {
                    dp[i][j] = dp[i - 1][j] || j == w[i];
                } else {
                    dp[i][j] = dp[i - 1][j - w[i]];
                }
            }
        }
        return dp[m - 1][n];
    }
}

空间优化（一维）

因为阶段之间是相隔的，既dp[i]的解依赖与dp[i - 1]的解，所以用一维数组就行了，时间复杂度跟二维一样，这里需要记录的是 第二层循环，需要从后面遍历。如果从前面遍历的话就是用dp[i]的解求dp[i]的解，就是完全背包问题，我们这里是01背包问题。

class Solution{
	public boolean checkPowersOfThree(int n) {
        boolean[] dp = new boolean[n + 1];
        dp[0] = true;
        int len = 0;
        while (Math.pow(3, len) <= n) len++;

        int[] w = new int[len];

        for (int i = 0; i < len; ++i) w[i] = (int)Math.pow(3, i);

        for (int i = 0; i < len; ++i) {
            for (int j = n; j >= w[i]; j--) {
                if ((j == w[i]) || (dp[j - w[i]] && j - w[i] != j)) {
                    dp[j] = true;
                }
            }
        }
        return dp[n];
    }
}