Rikka with Nash Equilibrium-hdu

Problem Description

Nash Equilibrium is an important concept in game theory.

Rikka and Yuta are playing a simple matrix game. At the beginning of the game, Rikka shows an n×m integer matrix A . And then Yuta needs to choose an integer in [1,n] , Rikka needs to choose an integer in [1,m] . Let i be Yuta's number and j be Rikka's number, the final score of the game is Ai,j .

In the remaining part of this statement, we use (i,j) to denote the strategy of Yuta and Rikka.

For example, when n=m=3 and matrix A is

⎡⎣⎢111241131⎤⎦⎥

If the strategy is (1,2) , the score will be 2 ; if the strategy is (2,2) , the score will be 4 .

A pure strategy Nash equilibrium of this game is a strategy (x,y) which satisfies neither Rikka nor Yuta can make the score higher by changing his(her) strategy unilaterally. Formally, (x,y) is a Nash equilibrium if and only if:

{Ax,y≥Ai,y  ∀i∈[1,n]Ax,y≥Ax,j  ∀j∈[1,m]

In the previous example, there are two pure strategy Nash equilibriums: (3,1) and (2,2) .

To make the game more interesting, Rikka wants to construct a matrix A for this game which satisfies the following conditions:
1. Each integer in [1,nm] occurs exactly once in A .
2. The game has at most one pure strategy Nash equilibriums.

Now, Rikka wants you to count the number of matrixes with size n×m which satisfy the conditions.

 

 

Input

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 .

 

 

Output

For each testcase, output a single line with a single number: the answer modulo K .

 

 

Sample Input

2 3 3 100 5 5 2333

 

 

Sample Output

64 1170

一个神仙dp，第一维填入了k个数，第二维已填入i行，第三维已填入j行

然后状态转移 

 

#include<stdio.h>
#include<string.h>
long long dp[6405][85][85];
int main()
{
	int n,m,mod;
	int t;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d%d",&n,&m,&mod);
		memset(dp,0,sizeof(dp));
		dp[1][1][1]=n*m;
		long long x=n*m;
		for(int k=1;k<=n*m;k++)
		{
			for(int i=1;i<=n;i++)
			{
				for(int j=1;j<=m;j++)
				{
					if(dp[k][i][j])
					{
						//printf("%d\n",dp[k][i][j]);
						dp[k+1][i+1][j]=(dp[k+1][i+1][j]+j*(n-i)*dp[k][i][j])%mod;
						dp[k+1][i][j+1]=(dp[k+1][i][j+1]+i*(m-j)*dp[k][i][j])%mod;
						dp[k+1][i][j]=(dp[k+1][i][j]+(i*j-k)*dp[k][i][j])%mod;
					}
				}
			}
		}
		printf("%lld\n",dp[x][n][m]);
	}

 }