qbxt的题：运

运

题意：

　　包含4,7的数成为幸运数。给一个序列，求多少个长度为k子序列满足：不包含两个及以上的相同的幸运数。（4出现两次就是不合法的，而4,7各出现一次是合法的）。

分析：

　　1e9内幸运数只有2^10个，所以可以全搜出来。然后对于序列中出现的幸运数，分别统计其出现的次数。然后对这些幸运数求出合法的方案数就行了。（此处合法是指选的数字满足不能一个数出现两次及以上）。dp[i][j]表示到第i个选了j个幸运数，然后转移即可。

　　最后统计答案就是，枚举选了多少个幸运数，用上面的dp数组可以直接得到，然后在非幸运数中随便选了，构成k个即可。

代码：

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<iostream>
 #include<cctype>
 #include<cmath>
 #include<set>
 #include<queue>
 #include<vector>
 #include<map>
 using namespace std;
 typedef long long LL;

 int read() {
     int x = , f = ; char ch = getchar(); for (; !isdigit(ch); ch=getchar()) if (ch=='-') f = -;
     for (; isdigit(ch); ch=getchar()) x = x *  + ch - ''; return x * f;
 }

 #define add(x,y) x+=y, x>=mod?x-=mod:x;
 const int N = ;
 const int mod = 1e9 + ;

 vector<int> num;
 map<int,int> Id;
 int cnt[N], a[N], dp[][], fac[N], ifac[N];

 void dfs(int x,LL now) {
     if (x ==  || now > 1e9) return ;
     num.push_back(now);
     dfs(x + , now *  + );
     dfs(x + , now *  + );
 }

 int ksm(int a,int b) {
     int res = ;
     while (b) {
         if (b & ) res = 1ll * res * a % mod;
         a = 1ll * a * a % mod;
         b >>= ;
     }
     return res;
 }

 void init(int n) {
     dfs(, );
     for (int i = ; i < num.size(); ++i) Id[num[i]] = i + ;
     fac[] = ;
     for (int i = ; i <= n; ++i) fac[i] = 1ll * fac[i - ] * i % mod;
     ifac[n] = ksm(fac[n], mod - );
     for (int i = n; i >= ; --i) ifac[i - ] = 1ll * ifac[i] * i % mod;
 }

 int C(int n,int m) {
     return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
 }

 int main() {

     freopen("lucky.in","r",stdin);
     freopen("lucky.out","w",stdout);

     init();

     int n = read(), k = read(), m = num.size(), tot = n;
     for (int i = ; i <= n; ++i) {
         a[i] = read();
         if (Id[a[i]]) cnt[Id[a[i]]] ++, tot --;
     }

     dp[][] = ;
     for (int i = ; i <= m; ++i) {
         for (int j = ; j <= i; ++j) {
             if (j) add(dp[i][j], 1ll * dp[i - ][j - ] * cnt[i] % mod);
             add(dp[i][j], dp[i - ][j]);
         }
     }

     LL ans = ;
     int L = max(, k - m), R = min(k, tot);
     for (int i = L; i <= R; ++i) {
         add(ans, 1ll * dp[m][k - i] * C(tot, i) % mod);
     }

     cout << ans;
     return ;
 }