HDU - 6415 - Rikka with Nash Equilibrium（DP）

HDU - 6415 - Rikka with Nash Equilibrium

题意：

在一个 n*m 的矩阵中放入 1～n*m 这 n*m 个数，每个数字只能出现一次，矩阵要填满

求有几种放置的方案，使得矩阵中只有一个纳什均衡（即整个矩阵中只有一个数在它所在的那一行那一列均为最大值）

即要构造在整个矩阵中只有 n*m 这个数是矩阵中唯一的在他那一行那一列均为最大的数。

所以 n*m 这个数可以随便放，但是接下来的数就得根据当前可以放的位置来放了

第一个数放下去会产生一行一列的位置可以放，第二、三个会产生一行或一列，第四个就可能放了也不增加新的位置。

所以对于除了第一个数，后面的数放置后的状态改变一共就有三种

1、增加了一行

2、增加了一列

3、没有变化

有 h 行 l 列最多可以放置 h*l 个数

从大到小放置

dp[i][j][k] 表示放了 k 个数，占了 i 行 j 列的方案数，dp[n][m][n*m]即为答案

dp[i][j][k] = dp[i][j][k-1] * (i*j - k + 1) % mod; // 放了第i个点行列不变，再放一个的种数为i*j - k + 1

dp[i][j][k] = (dp[i][j][k] + dp[i-1][j][k-1] * (n-i+1) * j) % mod; // 行增加，可以挑剩下的(n-i+1)行然后和列的交点都能选

dp[i][j][k] = (dp[i][j][k] + dp[i][j-1][k-1] * (m-j+1) * i) % mod; // 列增加

 

#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
typedef long long int LL;
LL T, n, m, mod, dp[88][88][2], p;
int main()
{
    scanf("%lld", &T);
    while(T--) {
        scanf("%lld%lld%lld", &n, &m, &mod);
        memset(dp, 0, sizeof dp); p = 0;
        dp[1][1][1] = n * m % mod;
        for(int i=2;i<=n*m;i++,p^=1) {
            for(int j=1;j<=n;j++) {
                for(int k=1;k<=m;k++) {
                    dp[j][k][p] = 0;
                    if(j * k < i) continue;
                    dp[j][k][p] = dp[j][k][p^1] * (j*k-i+1) % mod;
                    dp[j][k][p] = (dp[j][k][p] + dp[j-1][k][p^1] * (n-j+1) * k) % mod;
                    dp[j][k][p] = (dp[j][k][p] + dp[j][k-1][p^1] * (m-k+1) * j) % mod;
                }
            }
        }
        printf("%lld\n", dp[n][m][p^1]);
    }
    return 0;
}

不知道为什么不用滚动数组像上面那样写就超时了。。不过稍微跳过一些操作就快了很多

#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
typedef long long int LL;
LL T, n, m, mod, dp[88][88][6500];
int main()
{
    scanf("%lld", &T);
    while(T--) {
        scanf("%lld%lld%lld", &n, &m, &mod);
        dp[1][1][1] = n * m % mod;
        for(int i=2;i<=n*m;i++) {
            for(int j=1;j<=n;j++) {
                for(int k=max(i/j-1,1);k<=m;k++) { //在这将一些不操作的部分跳过
                    dp[j][k][i] = 0;
                    if(j * k < i) continue;
                    dp[j][k][i] = dp[j][k][i-1] * (j*k-i+1) % mod;
                    dp[j][k][i] = (dp[j][k][i] + dp[j-1][k][i-1] * (n-j+1) * k) % mod;
                    dp[j][k][i] = (dp[j][k][i] + dp[j][k-1][i-1] * (m-k+1) * j) % mod;
                }
            }
        }
        printf("%lld\n", dp[n][m][n*m]);
    }
    return 0;
}