#include<bits/stdc++.h>
#define ll long long
#define fir first
#define sec second
#define pii pair<int,int>
#define isz(v) (int)(v.size())
using namespace std;

const int maxn=305;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;

namespace Solve {
	struct mint {
		int val;
		mint():val(0) {}
		mint(ll tval) {
			if(-mod<=tval&&tval<2*mod) {
				if(tval>=mod) {
					tval-=mod;
				} 
				if(tval<0) {
					tval+=mod;
				}
			} else {
				tval%=mod;
				if(tval<0) {
					tval+=mod;
				}			
			}
			val=tval;
		}
		mint& operator += (const mint &b) {
			val=val+b.val>=mod?val+b.val-mod:val+b.val;
			return *this;
		}
		mint& operator -= (const mint &b) {
			val=val-b.val<0?val-b.val+mod:val-b.val;
			return *this;
		}
		mint& operator *= (const mint &b) {
			val=1ll*val*b.val>=mod?1ll*val*b.val%mod:val*b.val;
			return *this;
		}
		mint& operator /= (const mint &b) {
			*this*=b.inv();
			return *this;
		}
		friend mint operator + (const mint &a,const mint &b) {
			mint ans=a;
			ans+=b;
			return ans;
		}
		friend mint operator - (const mint &a,const mint &b) {
			mint ans=a;
			ans-=b;
			return ans;
		}
		friend mint operator * (const mint &a,const mint &b) {
			mint ans=a;
			ans*=b;
			return ans;
		}
		friend mint operator / (const mint &a,const mint &b) {
			mint ans=a;
			ans/=b;
			return ans;
		}
		friend bool operator ! (const mint &v) {
			return !v.val;
		}
		friend mint operator - (const mint &v) {
			return mod-v;
		}
		friend mint& operator ++ (mint &v) {
			v+=1;
			return v;
		}
		friend mint operator ++ (mint &v,signed _) {
			mint t=v;
			v+=1;
			return t;
		}
		friend mint& operator -- (mint &v) {
			v-=1; 
			return v;
		}
		friend mint operator -- (mint &v,signed _) {
			mint t=v;
			v-=1;
			return t;
		}
		friend bool operator < (const mint &a,const mint &b) {
			return a.val<b.val;
		}
		friend bool operator == (const mint &a,const mint &b) {
			return a.val==b.val;
		}
		friend bool operator != (const mint &a,const mint &b) {
			return a.val!=b.val;
		}
		friend istream& operator >> (istream &is,mint &x) {
			ll val;
			is>>val;
			x=mint(val); 
			return is;
		}
		friend ostream& operator << (ostream &os,const mint &x) {
			os<<x.val;
			return os;
		}
		mint qpow(ll y) const {
			mint x=*this,ans=1;
			if(y<0) {
				y=-y;
				x=inv();
			}
			while(y) {
				if(y&1) {
					ans*=x;
				} 
				x*=x;
				y>>=1;
			}
			return ans;
		}
		mint inv() const {
			// mod must be a prime
			return qpow(mod-2);
		}
		mint sqrt() {
			mint a=*this; 
			auto check=[&](mint x) {
				return x.qpow((mod-1)/2)==1;
			};
			static mt19937 rnd(73385);
			mint b=rnd()%mod;
			while(check(b*b-a)) {
				b=rnd()%mod;
			}
			static mint val=b*b-a;
			struct Complex {
				mint real,imag;
				Complex(mint treal=0,mint timag=0):real(treal),imag(timag) {}
				Complex operator * (const Complex &rhs) {
					return {real*rhs.real+imag*rhs.imag*val,real*rhs.imag+imag*rhs.real};
				}
				Complex& operator *= (const Complex &rhs) {
					return *this=*this*rhs;
				}
			};
			auto qpow=[&](Complex x,int y) {
				Complex ans={1};
				while(y) {
					if(y&1) {
						ans*=x;
					}
					x*=x;
					y>>=1;
				}
				return ans;
			};
			mint ans=qpow({b,1},(mod+1)/2).real;
			return min(ans,mod-ans);
		}
	};
	mint qpow(mint x,ll y) {
		return x.qpow(y);
	}
	mint inv(mint x) {
		return x.inv();
	}
	mint invf[maxn];
	mint fact[maxn];
	int n,k,sn;
	int cnt[maxn];
	mint w[maxn];
	mint f[maxn];
	mint v[maxn];
	mint g[maxn];
	void clear() {
		
	}
	void prepare(int n) {
		fact[0]=invf[0]=1;
		for(int i=1;i<=n;i++) {
			fact[i]=fact[i-1]*i;
		}
		invf[n]=inv(fact[n]);
		for(int i=n-1;i>=1;i--) {
			invf[i]=invf[i+1]*(i+1);
		}
	}
	mint C(int n,int m) {
//		assert(n>=0&&m>=0);
		return n<m?0:fact[n]*invf[m]*invf[n-m];
	}
	mint A(int n,int m) {
//		assert(n>=0&&m>=0);
		return n<m?0:fact[n]*invf[n-m];
	}
	mint invs(int x) {
//		assert(x>=0);
		return !x?0:invf[x]*fact[x-1];
	}
	mint calc(int n) {
		memset(g,0,sizeof(g));
		g[0]=1;
		for(int i=1;i<=n;i++) {
			for(int j=1;j<=i;j++) {
				g[i]+=g[i-j]*C(i-1,j-1)*sn*v[j]*j;
			}
		}
		// cerr<<g[n]<<"?\n";
		return g[n];
	}
	void main(int tid) {
		cin>>n>>k,sn=n;
		for(int i=1;i<=n;i++) {
			int c;
			cin>>c;
			cnt[c]++;
		}
		// if(*max_element(cnt+1,cnt+n+1)==n) {
		// 	cout<<(k==n?qpow(n,n-2):0)<<"\n";
		// 	return ;
		// }
		w[1]=1;
		for(int i=2;i<=n;i++) {
			w[i]=qpow(i,i-2);
		}
		for(int n=1;n<=sn;n++) {
			memset(f,0,sizeof(f));
			f[0]=-1;
			for(int i=1;i<=n;i++) {
				for(int j=1;j<=k&&j<=i;j++) {
					f[i]-=f[i-j]*C(i-1,j-1)*j*n*w[j];
				}
			}
			v[n]=f[n]/n/n;
		}
		// cerr<<v[1]<<" "<<v[2]<<" "<<v[3]<<"\n";
		mint ans=1;
		for(int i=1;i<=n;i++) {
			ans*=calc(cnt[i]);
		}
		// cout<<ans<<"\n";
		cout<<ans/n/n<<"\n";
	}
	void init() {
		prepare(maxn-1);
	}
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T=1;
//	cin>>T;
	Solve::init();
	for(int t=1;t<=T;t++) {
		Solve::main(t);
		Solve::clear();
	}
}