902. 最大为 N 的数字组合

传送门：https://leetcode-cn.com/contest/weekly-contest-101/problems/numbers-at-most-n-given-digit-set/

我们有一组排序的数字 D，它是  {'1','2','3','4','5','6','7','8','9'} 的非空子集。（请注意，'0' 不包括在内。）

现在，我们用这些数字进行组合写数字，想用多少次就用多少次。例如 D = {'1','3','5'}，我们可以写出像 '13', '551', '1351315' 这样的数字。

返回可以用 D 中的数字写出的小于或等于 N 的正整数的数目。

示例 1：

输入：D = ["1","3","5","7"], N = 100
输出：20
解释：
可写出的 20 个数字是：
1, 3, 5, 7, 11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57, 71, 73, 75, 77.

示例 2：

输入：D = ["1","4","9"], N = 1000000000
输出：29523
解释：
我们可以写 3 个一位数字，9 个两位数字，27 个三位数字，
81 个四位数字，243 个五位数字，729 个六位数字，
2187 个七位数字，6561 个八位数字和 19683 个九位数字。
总共，可以使用D中的数字写出 29523 个整数。

提示：

1. D 是按排序顺序的数字 '1'-'9' 的子集。
2. 1 <= N <= 10^9

//对于定义如s[MAXN]的函数，由于编译器优化(跳过不编译)，产生的空间复杂度为O(1)

//最坏S: O(log(D.size())^bits(N)), T: O(max{D.size(),bits(N)})
class Solution {
//可以对p[i]((D.size())^i)预处理
public:
    int getLessPos(int match, vector<string> D) {//最后一个小于match的坐标(二分)
        // int p = -1;
        int low = 0, high = D.size()-1;
        while(low <= high) { //
            int mid = (low + high) >> 1;
            if(D[mid][0]-'0' < match) low = mid+1; //
            else high = mid-1;
        }
        // for(int i = 0; i < D.size(); i++) {
        //     if(D[i][0]-'0' < match) p = i; 
        // }
        return high;
    }
    
    //找到D中最后一个小于top的元素位置p，从而可以确定组合数字中第一位的选择情况，top出栈之后递归进行即可
    int recur(vector<string> D, stack<int> IQ) {
        if(IQ.empty()) return 0;
        int p = getLessPos(IQ.top(), D);
        if(p != -1) {
            int ans = (p+1)*(int)pow(D.size(), IQ.size()-1);
            if(p < D.size()-1 && D[p+1][0]-'0' == IQ.top()) {
                IQ.pop();
                if(IQ.empty()) ans += 1;
                else ans += recur(D, IQ);
            }
            return ans;
        }  
        if(IQ.top() == D[0][0]-'0') {
            IQ.pop();
            if(IQ.empty()) return 1; //递归出口
            return recur(D, IQ);   
        }
        else return 0;
    }
    
    int atMostNGivenDigitSet(vector<string>& D, int N) {
        int ans = 0;
        //N的位数
        stack<int> IQ;
        int cur = N;
        while(cur) {
            IQ.push(cur%10);
            cur /= 10;
        }
        /*统计D中1~bits(N)位的组合数不大于N的情形*/
        //1~bits(N)-1位
        int s = D.size();
        for(int i = 1; i < IQ.size(); i++) {
            ans += s;
            s *= D.size();
        }
        //bits(N)
        ans += recur(D, IQ);
        return ans;
    }
};