2021-06-18题解

---

一、LeetCode每日一题

题目链接

最小好进制

题目大意
对于给定的整数 $n$, 如果$n$的$k(k\ge 2)$进制数的所有数位全为$1$，则称$k$是$n$的一个好进制。请求出给定数字的最小好进制。

• $3$的好进制为$2$结果是$(11)$
• $13$的好进制为$3(111)$和$12(11)$,所以$13$的最小好进制为$3$

题解

观察数据范围 $3\le n\le 10^{18}$,提示我们可以设计最坏$O(lo{g}^{4}n)$的算法。

• 首先这道题正着思考很不好入手，因为给你的数字你也不知道它的最小好进制有什么性质，而且还不具备单调性，也就是不可二分查找。例如，$3$是$13$的好进制，但是$4、5、6$就不是$13$好进制。
• 正难则反，思考$n$的好进制下的数字一定是怎么样的呢?
• 一定是$1111...11$这样的形式对吧，那么我们想到能不能枚举这个数字的长度(记为$i$)，然后去检查呢？
• 答案是可以的，而且还可以贪心的利用$i$的性质，如果$i$越大，代表这个数字越长，那么对应的好进制就应该更小。所以我们现在的任务就是确定这个长度的边界。
  • 如果你要把这个$1111...11$转化为十进制要怎么做呢？
  • 首先假设这个数字是$n$在$k(k\ge )$进制转化后的结果。
  • 那么就有$1+1\ast k+1\ast k^2+..+1\ast k^{i-1}=n$
    • 例如: $111$在$3$进制下转化为$1+1\ast 3+1\ast 3^2=13$
  • 发现这是一个等比数列求和，套用求和公式得到$\frac{1-k^{i-1}}{1-k}=\frac{k^{i-1}-1}{k-1}=n$
  • 移项得到$k^{i-1}=n\ast (k-1)+1\le n\ast k⟹k^{i-2}\le n⟹i-2\le {\log }_{k}n$
  • 当$k$取$2,n$取$10^{18}$时$i$获得最大值$64$，加上$k\ge 2$就确定了$2\le i\le 64$
• 得到解法1
  • 倒序枚举$i$，然后利用二分查找去检查每个$k$,因为$k$现在是具有单调性的(对于所有的$k$当$\frac{k^{i-1}-1}{k-1}\ge n$时$k+1$也同时成立)。
  • 最后只用观察是否有满足条件的$k$即可，有则返回，否则继续递减$i$.

public String smallestGoodBase(String n) {
// 枚举111111的长度
    BigInteger res = new BigInteger(n);
    for (int i = 64; i >= 2; i--) {
        BigInteger k = lowerBound(res, i);
        if (k.equals(BigInteger.ONE)) continue;
        System.out.println(k.toString());
    }
    return "";
}

private BigInteger lowerBound(BigInteger res, int i) {
    int c = check(res, BigInteger.TWO, i);
    if (c > 0) return BigInteger.ONE;
    else if (c == 0) return BigInteger.TWO;
    BigInteger l = BigInteger.TWO, r = res;
    while (l.add(BigInteger.ONE).compareTo(r) < 0) {
        BigInteger mid = l.add(r).divide(BigInteger.TWO);
        if (check(res, mid, i) >= 0) r = mid;
        else l = mid;
    }
    return check(res, r, i) == 0 ? r : BigInteger.ONE;
}

private int check(BigInteger res, BigInteger k, int i) {
    BigInteger top = k.pow(i).subtract(BigInteger.ONE);
    BigInteger down = k.subtract(BigInteger.ONE);
    return top.divide(down).compareTo(res);
}

• 由于上述写法过于复杂所以我们可以继续探索有什么我们没有利用到的性质。
  • 观察$n=1+k^1+k^2+..+k^{i-1}>k^{i-1}⟹k<\sqrt[i-1]{n}$
  • 由二项式定理得$(k+1{)}^{i-1}=C_{i-1}^0\ast 1+C_{i-1}^1\ast k^1+...+C_{i-1}^{i-1}\ast k^{i-1}>n$
  • 所以$k<\sqrt[i-1]{n}<k+1$,又因为$k$进制一定是整数，所以$k=\lfloor \sqrt[i-1]{n}\rfloor$
• 得到解法2
  • 还是倒序枚举$i$，对于每一个$i$求得对应的$k$。
  • 检查$k$是否可行，是就返回，否则继续枚举$i$
  • 检查是指对于$\frac{k^{i-1}-1}{k-1}$判定是否等于$n$

public String smallestGoodBase(String n) {
    long nval = Long.parseLong(n);
    for (int i = 64; i >= 2; i--) {
        long k = (long)Math.pow(nval, 1./(i - 1));
        if (good(nval, k, i)) return k + "";
    }
    return nval - 1 + "";
}

private boolean good(long n, long k, int i) {
    if (k <= 1) return false;
    BigInteger kk = BigInteger.valueOf(k);
    BigInteger nn = BigInteger.valueOf(n);
    // (k^i - 1) / (k - 1) =?= n
    return kk.pow(i).subtract(BigInteger.ONE).
    	   divide((kk.subtract(BigInteger.ONE))).
           equals(nn);
}

时空复杂度分析

• 解法一
  • 由于大整数运算的时间复杂度可看作整数长度也就是$O(\log n)$，所以总的时间复杂度为$O({\log }^{2}n)$
  • 大整数存储贡献整个空间复杂度$O(\log n)$
• 解法二
  • 时间复杂度由$pow()$函数和大整数操作贡献，所以总的时间复杂度为$O(\log n)$
  • 大整数存储贡献整个空间复杂度$O(\log n)$