https://www.hrwhisper.me/leetcode-count-numbers-unique-digits/
https://blog.csdn.net/mrbcy/article/details/62883530
Given a non-negative integer n, count all numbers with unique digits, x, where 0 ≤ x < 10n.
Example:
Given n = 2, return 91. (The answer should be the total numbers in the range of 0 ≤ x < 100, excluding
Given n = 2, return 91. (The answer should be the total numbers in the range of 0 ≤ x < 100, excluding
[11,22,33,44,55,66,77,88,99])
题意：给定非负的整数n，求在 0 ≤ x < 10n 中，有多少每个位上的数字互不相同的数？ 如 n =2 时，范围为[0,100]， 共有91个数（除了11,22,33,44,55,66,77,88,99）
思路：
排列组合题。
https://leetcode.com/problems/count-numbers-with-unique-digits/discuss/83041/JAVA-DP-O(1)-solution.
https://leetcode.com/discuss/107945/java-dp-o-1-solution
Following the hint. Let f(n) = count of number with unique digits of length n.
f(1) = 10. (0, 1, 2, 3, ...., 9)
f(2) = 9 * 9. Because for each number i from 1, ..., 9, we can pick j to form a 2-digit number ij and there are 9 numbers that are different from i for j to choose from.
f(3) = f(2) * 8 = 9 * 9 * 8. Because for each number with unique digits of length 2, say ij, we can pick k to form a 3 digit number ijk and there are 8 numbers that are different from i and j for k to choose from.
Similarly f(4) = f(3) * 7 = 9 * 9 * 8 * 7....
...
f(10) = 9 * 9 * 8 * 7 * 6 * ... * 1
f(11) = 0 = f(12) = f(13)....
any number with length > 10 couldn't be unique digits number.
The problem is asking for numbers from 0 to 10^n. Hence return f(1) + f(2) + .. + f(n)
As @4acreg suggests, There are only 11 different ans. You can create a lookup table for it. This problem is O(1) in essence.
public int countNumbersWithUniqueDigits(int n) {
if (n == 0) return 1;
int res = 10;
int uniqueDigits = 9;
int availableNumber = 9;
while (n-- > 1 && availableNumber > 0) {
uniqueDigits = uniqueDigits * availableNumber;
res += uniqueDigits;
availableNumber--;
}
return res;
}
这道题让我们找一个范围内的各位上不相同的数字，比如123就是各位不相同的数字，而11,121,222就不是这样的数字。那么我们根据提示中的最后一条可以知道，一位数的满足要求的数字是10个(0到9)，二位数的满足题意的是81个，[10 - 99]这90个数字中去掉[11,22,33,44,55,66,77,88,99]这9个数字，还剩81个。通项公式为f(k) = 9 * 9 * 8 * ... (9 - k + 2)，那么我们就可以根据n的大小，把[1, n]区间位数通过通项公式算出来累加起来即可
int countNumbersWithUniqueDigits(int n) { if (n == 0) return 1; int res = 0; for (int i = 1; i <= n; ++i) { res += count(i); } return res; } int count(int k) { if (k < 1) return 0; if (k == 1) return 10; int res = 1; for (int i = 9; i >= (11 - k); --i) { res *= i; } return res * 9; }
int countNumbersWithUniqueDigits(int n) { if (n == 0) return 1; int res = 10, cnt = 9; for (int i = 2; i <= n; ++i) { cnt *= (11 - i); res += cnt; } return res; }
public int countNumbersWithUniqueDigits(int n) {
if( n == 0 ){
return 1;
}
if( n == 1 ){
return 10;
}
if( n >= 10 ){
return 0;
}
int current = 81; // n == 2; f(n) = f(n-1)*(11-n);
int total = 91; // n == 2;
for(int i = 3 ; i <= n; i++){
current *= (11-i);
total += current;
}
return total;
}
设i为长度为i的各个位置上数字互不相同的数。
- i==1 : 1 0（0~9共10个数，均不重复）
- i==2: 9 * 9 （第一个位置上除0外有9种选择，第2个位置上除第一个已经选择的数，还包括数字0，也有9种选择）
- i ==3: 9* 9 * 8 （前面两个位置同i==2，第三个位置除前两个位置已经选择的数还有8个数可以用）
- ……
- i== n: 9 * 9 * 8 *…… (9-i+2)
需要注意的是，9- i + 2 >0 即 i < 11，也就是i最大为10，正好把每个数都用了一遍。
so , 其实可以算出来然后打表的，然后速度就飞快→_→
public int countNumbersWithUniqueDigits(int n) {
n = Math.min(n,10);
int[] dp = new int[n+1];
dp[0] = 1;
for(int i = 1;i<=n;i++){
dp[i] = 9;
for(int x = 9; x >= 9 - i + 2;x--){
dp[i] *= x;
}
}
int ans = 0;
for(int i= 0;i<dp.length;i++) ans += dp[i];
return ans;
}
http://dullnull.org/?p=129
http://blog.csdn.net/ebowtang/article/details/51658886
public static int countNumbersWithUniqueDigits(int n) { int result = 0; for (int i = 1; i <= n; i++) result += getK(i); return result == 0 ? 1 : result; } public static int getK(int k) { if (k == 1) return 10; int val = 9; for (int i = 2; i <= k; i++) val *= (9 - i + 2); return val; } int countNumbersWithUniqueDigits(int n) {
int result=0;
for(int i=1;i<=n;i++)
result+=getfk(i);
return result==0?1:result;
}
int getfk(int k)
{
if(k==1)
return 10;
int val=9;
for(int i=2;i<=k;i++)
val*=(9-i+2);
return val;
}
};
https://leetcode.com/discuss/108119/java-concise-dp-solution
public int countNumbersWithUniqueDigits(int n) {
if (n == 0) {
return 1;
}
int ret = 10, count = 9;
for (int i = 2; i <= n; i++) {
count *= 9-i+2;
ret += count;
}
return ret;
}
int countNumbersWithUniqueDigits(int n) {
def countNumbersWithUniqueDigits(self, n): """ :type n: int :rtype: int """ nums = [9] for x in range(9, 0, -1): nums += nums[-1] * x, return sum(nums[:n]) + 1
X.brute force - backtrackint countNumbersWithUniqueDigits(int n) {
if ( n < 0 )
return 0;
int result = 1;
int multiplier = 9;
n = min(n, 10);
for (int i = 1; i <= n; i++) {
result += multiplier;
multiplier *= (i > 9 ? 0: (10 - i));
}
return result;
}
http://bookshadow.com/weblog/2016/06/13/leetcode-count-numbers-with-unique-digits/def countNumbersWithUniqueDigits(self, n): """ :type n: int :rtype: int """ nums = [9] for x in range(9, 0, -1): nums += nums[-1] * x, return sum(nums[:n]) + 1
https://blog.csdn.net/mrbcy/article/details/62883530
public int countNumbersWithUniqueDigits(int n) {
return doCount(n, new boolean[10], 0);
}
private int doCount(int n, boolean[] used, int d) {
if (d == n)
return 1;
int total = 1;
for (int i = (d == 0) ? 1 : 0; i <= 9; i++) {
if (!used[i]) {
used[i] = true;
total += doCount(n, used, d + 1);
used[i] = false;
}
}
return total;
}
https://leetcode.com/problems/count-numbers-with-unique-digits/discuss/83054/Backtracking-solution
The idea is to append one digit at a time recursively (only append digits that has not been appended before). Number zero is a special case, because we don't want to deal with the leading zero, so it is counted separately at the beginning of the program. The running time for this program is O(10!) worst case, or O(n!) if n < 10.
The OJ gives wrong answer when n = 0 and n = 1. The correct answer should be:
0, 11, 102, 913, 7394, 52755, 324916, 1685717, 7128918, 23458519, 561177110 and beyond, 8877691
public static int countNumbersWithUniqueDigits(int n) {
if (n > 10) {
return countNumbersWithUniqueDigits(10);
}
int count = 1; // x == 0
long max = (long) Math.pow(10, n);
boolean[] used = new boolean[10];
for (int i = 1; i < 10; i++) {
used[i] = true;
count += search(i, max, used);
used[i] = false;
}
return count;
}
private static int search(long prev, long max, boolean[] used) {
int count = 0;
if (prev < max) {
count += 1;
} else {
return count;
}
for (int i = 0; i < 10; i++) {
if (!used[i]) {
used[i] = true;
long cur = 10 * prev + i;
count += search(cur, max, used);
used[i] = false;
}
}
return count;
}- A direct way is to use the backtracking approach.
- Backtracking should contains three states which are (the current number, number of steps to get that number and a bitmask which represent which number is marked as visited so far in the current number). Start with state (0,0,0) and count all valid number till we reach number of steps equals to 10n.
- This problem can also be solved using a dynamic programming approach and some knowledge of combinatorics.
- Let f(k) = count of numbers with unique digits with length equals k.
- f(1) = 10, ..., f(k) = 9 * 9 * 8 * ... (9 - k + 2) [The first factor is 9 because a number cannot start with 0].
int countNumbersWithUniqueDigits(int n) { int res = 1, max = pow(10, n), used = 0; for (int i = 1; i < 10; ++i) { used |= (1 << i); res += search(i, max, used); used &= ~(1 << i); } return res; } int search(int pre, int max, int used) { int res = 0; if (pre < max) ++res; else return res; for (int i = 0; i < 10; ++i) { if (!(used & (1 << i))) { used |= (1 << i); int cur = 10 * pre + i; res += search(cur, max, used); used &= ~(1 << i); } } return res; }
