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 = 0, f = 1; char ch = getchar(); for (; !isdigit(ch); ch=getchar()) if (ch=='-') f = -1;
    for (; isdigit(ch); ch=getchar()) x = x * 10 + ch - '0'; return x * f;
}

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

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

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

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

void init(int n) {
    dfs(1, 0);
    for (int i = 0; i < num.size(); ++i) Id[num[i]] = i + 1;
    fac[0] = 1;
    for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
    ifac[n] = ksm(fac[n], mod - 2);
    for (int i = n; i >= 1; --i) ifac[i - 1] = 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(100000);
    
    int n = read(), k = read(), m = num.size(), tot = n;
    for (int i = 1; i <= n; ++i) {
        a[i] = read();
        if (Id[a[i]]) cnt[Id[a[i]]] ++, tot --;
    }
    
    dp[0][0] = 1;
    for (int i = 1; i <= m; ++i) {
        for (int j = 0; j <= i; ++j) {
            if (j) add(dp[i][j], 1ll * dp[i - 1][j - 1] * cnt[i] % mod);
            add(dp[i][j], dp[i - 1][j]);
        }
    }
    
    LL ans = 0;
    int L = max(0, 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 0;
}