F. Igor and Interesting Numbers

http://codeforces.com/contest/747/problem/F

cf #387 div2 problem f

非常好的一道题。看完题，然后就不知道怎么做，感觉是dp，但是不知道怎么枚举。还有就是一般求第k小的思路一般是什么？对这类题目理解的不是很好。

这道题，跟上一篇的题解里面写的hdu 1002 递增数的题目的解法差不多，但是底层的求解需要花一些时间去推敲！

不会做，就看官方题解，看不懂说的什么。就从下面的讨论找大神的题解。

I can describe my solution
Binary search on what is the answer(mi). So, the problem reduces to counting number of numbers <= mi such that each digit occurs <= t times.
In fact, we solve a more general problem — find number of numbers of length i such that each digit j occurs <= b[j] times. 0 complicates the matter somewhat but for the time assume that 0 can be placed anywhere and obeys constraint like the normal digits. Then formulate dp[i][j] = number of numbers with i digits and place only digits <= j. Iterate k = how many j digits will be there — 0 to min(i,b[j]) then dp[i][j] = sum((i choose k)*dp[i-k][j-1]). Base cases are simple to write.
Overall count can be calculated by fixing highest digit(depends on mi) and then a dp call, then next digits etc.. similar to what we do in offline digits dp solution. The prefix digits that are fixed decide what array b is(t — number of times digit has occurred till now).
Finally for 0, simply calculate for lesser lengths using a similar logic. Checkout my solution for more details.
Time complexity = O(p^3*d^3) where p=max digits in answer=9 and d=16 and = runs in 15 ms :)

看完这个之后，思路就清晰很多了，然后接下来就是二分的判断条件，对于给定mi，如何判断比它小的满足要求的数的个数呢？ 这个求解思路跟上面写的hdu的1002思路一致， 按长度进行累加和， 因为一个数的长度很小，这里int的16进制表示，最大长度为32/4 = 8， 这个长度很短， 可以通过预处理来快速求解。所以，首先需要解决，长度为k的满足要求的数的个数这个问题！由于题目要求的是每个数出现次数小于等于t， 所以如果按位枚举的话，需要记住每一个数的出现次数，这个好像不容易解决，然后考虑可以使用的数的最大值，使用排列组合的方式，就是上面的思路进行解决。这个问题解决之后， 然后就是对于一个数，先求长度比它小的数的个数，然后求解跟他长度一致的数的个数，依次从高位到低位， 进行求解，枚举每一个数字的方式进行。讲的好乱，我都听不懂了！

注意上面的复杂度分析：代码运行速度非常快。

又掌握一种套路，就是上面的dp求解的过程，这个不好思考，求解每个数字出现此小于等于t的数字的个数，使用组合的方式，注意对0的单独处理。

 #include <vector>
 #include <list>
 #include <map>
 #include <set>
 #include <deque>
 #include <queue>
 #include <stack>
 #include <bitset>
 #include <algorithm>
 #include <functional>
 #include <numeric>
 #include <utility>
 #include <sstream>
 #include <iostream>
 #include <iomanip>
 #include <cstdio>
 #include <cmath>
 #include <cstdlib>
 #include <cctype>
 #include <string>
 #include <cstring>
 #include <cstdio>
 #include <cmath>
 #include <cstdlib>
 #include <ctime>
 #include <string.h>
 #include <fstream>
 #include <cassert>
 using namespace std;

 #define boost ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
 #define sz(a) int((a).size())
 #define rep(i, s, n)  for(int i = s; i <= (n); ++i)
 #define rev(i, n, s)  for(int i = (n); i >= s; --i)
 #define fore(x, a) for(auto &&x : a)
 typedef long long ll;
 const int mod = ;
 const int N = ;

 int a[];
 int t;
 int b[];
 ll dp[][];
 ll c[][];

 ll go(int p, int x) {
   if (p == -) return ;
   if (x == ) {
     if (t - b[x] >= p + ) return ;
     return ;
   }
   ll &res = dp[p][x];
   if (res >= ) return res;
   res = ;
   rep(i, , min(p + ,t-b[x])) {
     res += c[p+][i]*go(p - i, x - );
   }
   return res;
 }

 char hex(int x) {
   if (x >= ) return 'a' + (x - );
   return '' + x;
 }

 ll g[];

 ll f(int x) {
   ll res = ;
   memset(b, , sizeof(b));
   rep(i, , ) {
     memset(dp, -, sizeof(dp));
     b[i]++;
     res += go(x - , );
     b[i]--;
   }
   return res;
 }

 int main() {
 #ifdef loc
   if (!freopen((string(FOLDER) + "inp.txt").c_str(), "r", stdin)) {
     assert();
   }
   freopen((string(FOLDER) + "out.txt").c_str(), "w", stdout);
 #endif
   boost;
   ll k;
   cin >> k >> t;
   rep(i, , ) {
     c[i][] = ;
     rep(j, , i) {
       c[i][j] = c[i - ][j] + c[i - ][j - ];
     }
   }
   rep(i, , ) {
     g[i] = f(i);
     if (i > ) g[i] += g[i - ];
   }
   ll lo = , hi = (1LL << ) - ;
   while (lo < hi) {
     ll mi = (lo + hi) / ;
     ll p = mi + ;
     int td = ;
     rep(i, , ) {
       a[i] = p % ;
       p /= ;
       td = i;
       if (p == ) {
         break;
       }
     }
     ll tot = td >  ? g[td - ] : ;
     memset(b, , sizeof(b));
     rev(i, td, ) {
       rep(j,(i==td)?:, a[i] - ) {
         b[j]++;
         if (b[j] <= t) {
           memset(dp, -, sizeof(dp));
           tot += go(i - , );
         }
         b[j]--;
       }
       b[a[i]]++;
       if (b[a[i]] > t) break;
     }
     if (tot >= k) hi = mi;
     else lo = mi + ;
   }
   vector<int> ans;
   while (lo > ) {
     ans.push_back(lo % );
     lo /= ;
   }
   reverse(ans.begin(), ans.end());
   fore(x, ans) {
     cout << hex(x);
   }
   cout << endl;
   return ;
 }