运lucky

运

【问题背景】

　　zhx 和妹子们玩数数游戏。

【问题描述】
　　仅包含 4 或7 的数被称为幸运数。
　　一个序列的子序列被定义为从序列中删去若干个数， 剩下的数组成的新序列。
　　两个子序列被定义为不同的当且仅当其中的元素在原始序列中的下标的集合不
　　相等。 对于一个长度为N的序列， 共有2^N个不同的子序列。包含一个空序列） 。
　　一个子序列被称为不幸运的，当且仅当其中不包含两个相同的幸运数。
　　对于一个给定序列， 求其中长度恰好为 K 的不幸运子序列的个数， 答案mod
　　10^9+7输出。

【输入格式】
　　第一行两个正整数N，K，表示原始序列的长度和题目中的 K。
　　接下来一行N个整数ai，表示序列中第i 个元素的值。

【输出格式】
　　仅一个数，表示不幸运子序列的个数。（mod

【样例输入】
　　3 2
　　1 1 1

【样例输出】

　　3

【样例输入】
　　4 2
　　4 7 4 7

【样例输出】
　　4

【样例解释】
对于样例 1，每个长度为 2的子序列都是符合条件的。
对于样例2， 4个不幸运子序列元素下标分别为： {1, 2}, {3, 4}, {1, 4}, {2, 3}。
注意下标集{1, 3}对应的子序列不是“不幸运”的，因为它包含两个相同的幸运数
4.

【数据规模与约定】
对于50%的数据，1 ≤ N≤ 16。
对于70%的数据，1 ≤ N≤ 1000, ai ≤ 10000。
对于100%的数据，1 ≤ N≤ 100000,K ≤ N, 1 ≤ ai ≤ 109。

这道题前70%的数据显然可以搜索

但是我一开始认为“仅包含4或仅包含7的数为幸运数”，然而竟过了50分

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 using namespace std;
 #define int long long
 #define MOD 1000000007
 #define N 1000100
 int n,k,a[N];
 int ans,path[N];
 int ok[N][],vis[][];
 inline int read(){
     int x=; char c=getchar();
     while(c<''||c>'') c=getchar();
     while(''<=c&&c<='') { x=(x<<)+(x<<)+c-''; c=getchar(); }
     return x;
 }
 inline void check(){
     memset(vis,,sizeof(vis));
     for(int i=;i<=k;i++){
         int j=path[i];
         if(!ok[j][]) continue;
         if(vis[ok[j][]][ok[j][]]) return;
         vis[ok[j][]][ok[j][]]=;
     }
     ans++;
 }
 void dfs(int minn,int t){
     if(t==k+){
         check();
         return;
     }
     for(int i=minn;i<=n;i++){
         path[t]=i;
         dfs(i+,t+);
     }
 }
 #undef int
 int main()
 #define int long long
 {
     scanf("%lld%lld",&n,&k);
     if(n<=){
         for(int i=;i<=n;i++){
             a[i]=read();
             int k=,b=a[i];
             while(b%==){
                 b/=; k++;
             }
             if(k&&!b) {
                 ok[i][]=;
                 ok[i][]=; ok[i][]=k;
             }
             k=,b=a[i];
             while(b%==){
                 b/=; k++;
             }
             if(k&&!b){
                 ok[i][]=;
                 ok[i][]=; ok[i][]=k;
             }
         }
         dfs(,);
         printf("%lld\n",ans);
         return ;
     }
     return ;
 }

我们考虑仅包含4或7的数，我们可以用map

其实数本身对本题是没有影响的，

只有每种相同幸运数的个数对答案产生影响

其实我一开始是想出了正解的一半的

一开始做题时的思路：枚举k个数中不幸运数的个数i，用组合数求出；

再求出从幸运数中每种不重地选择k-i个数的方案数，相乘

然而我并不会求后者，于是直接用C（num,k-i）乘了（num为出现的幸运数的总数）

然而它可以DP

f[i][j]表示前i中幸运数选j个数的方案数

lucky[i]表示第i种幸运数的个数

f[i][j]=f[i-1][j]+f[i-1][j-1]*lucky[i]

滚动数组可以降一维空间

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<map>
 using namespace std;
 #define int long long
 #define MOD 1000000007
 #define N 100010
 map<int,int> M;
 int n,k,jc[N];
 int lucky[N],f[N],num,sum,ans;
 inline int read(){
     int x=; char c=getchar();
     while(c<''||c>'') c=getchar();
     while(''<=c&&c<='') { x=(x<<)+(x<<)+c-''; c=getchar(); }
     return x;
 }
 inline int qpow(int x,int k){
     int s=;
     while(k){
         if(k&) s=s*x%MOD;
         k>>=;
         x=x*x%MOD;
     }
     return s;
 }
 int C(int m,int n){
     if(m<n) return ;
     if(m==n) return ;
     if(n>m-n) n=m-n;
     int x=jc[m]*qpow(jc[m-n]*jc[n]%MOD,MOD-)%MOD;
     return x;
 }
 #undef int
 int main()
 #define int long long
 {
     freopen("lucky10.in","r",stdin);
     scanf("%lld%lld",&n,&k);
     int x;
     for(int i=;i<=n;i++){
         x=read();
         int k=,y=x;
         while(y%==||y%==)
         { y/=; k++; }
         if(k&&!y){
             if(!M[x]){
                 lucky[++num]++;
                 M[x]=num;
             }
             else lucky[M[x]]++;
             sum++;
         }
     }
     f[]=;
     for(int i=;i<=num;i++)
      for(int j=min(k,i);j>=;j--)
       f[j]=(f[j]+f[j-]*lucky[i])%MOD;
     jc[]=;
     for(int i=;i<=n;i++)
      jc[i]=jc[i-]*i%MOD;
     for(int i=;i<=k;i++)
      ans=(ans+C(n-sum,i)*f[k-i]%MOD)%MOD;
     printf("%lld\n",ans);
     return ;
 }