HUD-5399 Too Simple（数学）

Too Simple

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Problem Description

Rhason Cheung had a simple problem, and asked Teacher Mai for help. But Teacher Mai thought this problem was too simple, sometimes naive. So she ask you for help.

Teacher Mai has  m  functions  f1,f2,⋯,fm:{1,2,⋯,n}→{1,2,⋯,n} (that means for all  x∈{1,2,⋯,n},f(x)∈{1,2,⋯,n} ). But Rhason only knows some of these functions, and others are unknown.

She wants to know how many different function series  f1,f2,⋯,fm  there are that for every  i(1≤i≤n) , f1(f2(⋯fm(i)))=i . Two function series  f1,f2,⋯,fm  and  g1,g2,⋯,gm  are considered different if and only if there exist  i(1≤i≤m),j(1≤j≤n) , fi(j)≠gi(j) .

 

Input

For each test case, the first lines contains two numbers  n,m(1≤n,m≤100) .

The following are  m  lines. In  i -th line, there is one number  −1  or  n  space-separated numbers.

If there is only one number  −1 , the function  fi  is unknown. Otherwise the  j -th number in the  i -th line means  fi(j) .

 

Output

For each test case print the answer modulo  10^9+7 .

 

Sample Input

   
   
   
   

    
    
    
    3 3
1 2 3
-1
3 2 1
   
   
   
   

 

Sample Output

   
   
   
   

    
    
    
    1

    
    
    
    
 
     
 
      Hint 
     
The order in the function series is determined. What she can do is to assign the values to the unknown functions. 
    
   
   
   
   

思路与官方的一样：

首先要求每个f_if​i​​是个排列，否则如果某个f_if​i​​将两个数映射向同一个数，那么最后这两个数得到的值一定相同。

如果还剩一个位置为$-1$，那么这个排列是唯一确定的，假设X*f_i*Y=IX∗f​i​​∗Y=I，那么f_i=X^{-1}*Y^{-1}f​i​​=X​−1​​∗Y​−1​​.

所以假设有$c(c\ge 1)$个$-1$，那么答案为(n!)^{c-1}(n!)​c−1​​个可行的方案。

注意特判所有函数都已知的情况。

#include <cstdio>
#include <cstring>

using namespace std;

const long long MOD=1000000007;

long long f[101];
int a[101][101];
bool vis[101];

void Init() {
    f[0]=f[1]=1;
    for(long long i=2;i<=100;++i)
        f[i]=(f[i-1]*i)%MOD;
}

long long quickpow(long long m,long long n) {
    long long b=1;
    while(n>0){
        if (n&1)
            b=(b*m)%MOD;
        n=n>>1;
        m=(m*m)%MOD;
    }
    return b;
}

int n,m;

bool Judge() {//特判所有函数已知的情形
    int i,j,x;
    for(i=1;i<=n;++i) {
        x=i;
        for(j=m-1;j>=0;--j)
            x=a[j][x];
        if(x!=i)
            return false;
    }
    return true;
}

int main() {
    int i,j,cnt;
    bool ok;
    Init();
    while(2==scanf("%d%d",&n,&m)) {
        cnt=0,ok=true;
        for(i=0;i<m;++i) {
            scanf("%d",&a[i][1]);
            if(a[i][1]==-1)
                ++cnt;
            else {
                memset(vis,false,sizeof(vis));
                vis[a[i][1]]=true;
                for(j=2;j<=n;++j) {
                    scanf("%d",&a[i][j]);
                    if(vis[a[i][j]])//刚开始以为是单射函数，结果WA了好久。如果存在非单射函数，则结果为0
                        ok=false;
                    else
                       vis[a[i][j]]=true;
                }
            }
        }
        if(cnt==0)
            printf("%d\n",Judge()?1:0);
        else
            printf("%I64d\n",ok?quickpow(f[n],cnt-1):0);
    }
    return 0;
}