2018 Multi-University Training Contest 9----hdu 6415 Rikka with Nash Equilibrium

Bryce1010模板

2018 Multi-University Training Contest 9—-hdu 6415 Rikka with Nash Equilibrium

题意：
在一个矩阵中，如果某一个数字是该行该列的最大值，则这个数满足纳什均衡。

要求构造一个n*m的矩阵，里面填的数字各不相同且范围是【1，m*n】，问有多少种构造方案。

The first line contains a single integer t(1≤t≤20), the number of the testcases.

The first line of each testcase contains three numbers n,m and K(1≤n,m≤80,1≤K≤109).

The input guarantees that there are at most 3 testcases with max(n,m)>50.

补题写了三种思路：
不过dfs和dp的思想是一样的。
考虑三种求情况：
(1）添加一个数，覆盖的行数+1
(2）添加一个数，覆盖的列数+1
(3) 添加一个数，覆盖的行数和列数不变化

---

　1. dfs

但是tle了，据说多交几次有可能卡过。

#include
using namespace std;
#define ll long long 

int n,m,k;
ll dp[85*85][85][85];
//dfs i x y i表示放置数字的个数，x表示行，y表示列
ll dfs(ll i,ll x,ll y)
{
    if(dp[i][x][y]!=-1)return dp[i][x][y];
    ll tmp=0;
    if(xy*(n-x)%k*dfs(i+1,x+1,y)%k%k;
    if(y<m)tmp=tmp+x*(m-y)%k*dfs(i+1,x,y+1)%k%k;
    if(x*y>i)tmp=tmp+(x*y-i)%k*dfs(i+1,x,y)%k%k;
    return dp[i][x][y]=tmp;
}



int main()
{
  //  ios::sync_with_stdio(false);

    int t;
    scanf("%d",&t);

    while(t--)
    {
        scanf("%d%d%d",&n,&m,&k);
        memset(dp,-1,sizeof(dp));
        dp[m*n][n][m]=1;
        ll ans=m*n%k*dfs(1,1,1)%k;
        printf("%lld\n",ans);
    }

    return 0;
}

2. DP

#include
using namespace std;
#define ll long long

int n,m,mod;
ll dp[85*85][85][85];



int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(dp,0,sizeof(dp));

        scanf("%d%d%d",&n,&m,&mod);
        dp[1][1][1]=n*m;
        for(int i=1;i<m*n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                for(int k=1;k<=m;k++)
                {
                    dp[i+1][j+1][k]=dp[i+1][j+1][k]+(n-j)*k*dp[i][j][k];
                    dp[i+1][j][k+1]=dp[i+1][j][k+1]+(m-k)*j*dp[i][j][k];
                    if(dp[i+1][j+1][k]>=mod)dp[i+1][j+1][k]%=mod;
                    if(dp[i+1][j][k+1]>=mod)dp[i+1][j][k+1]%=mod;
                    ll p=j*k-i;
                    if(p<=0)continue;
                    dp[i+1][j][k]=dp[i+1][j][k]+p*dp[i][j][k];
                    if(dp[i+1][j][k]>=mod)dp[i+1][j][k]%=mod;
                }
            }
        }
        printf("%lld\n",dp[n*m][n][m]%mod);
    }
    return 0;
}

３. 套公式

公式如下：
n!∗m!∗(m∗n)!/(m+n−1)! n ! ∗ m ! ∗ ( m ∗ n ) ! / ( m + n − 1 ) !
分母可以消掉，取模就很方便了。