TC SRM573 div2 p1000

题目大意

给一个矩阵，某些点里面有狼，现在这些狼要在m次移动内都聚合到同一个点上，每次移动只能移动到当前格子的四个相邻的格子内，问有多少种方案让这些狼都移动到相同的点上？

解题思路

首先，一个非常直观的dp方程能很快想出——dp[k][i][j]表示到[i,j]格子内，经过k次移动，有多少种方案，那么这道题的方程也就很容易能想到，该点的上一个状态一定是相邻的四个点，那么把那四个相邻点的方案算出来，这个点的方案自然也就知道了。但是一个巨大的问题是这道题有很多的起点（很多的狼），同时终点也是不一定的，这个要怎么办呢（实际上，这是卡住我的一个非常大的问题）？

我们可以这么做，首先，所有点的到达方案不用说，很快就能得到。鉴于这个平面的范围很小，我们可以这么办，暴力枚举终点！在枚举终点的时候，由于已经预处理出来了其他的点到这个点的方案数，也就是说，所有的狼到这个点的方案数已经是已知的了，那么以当前点为所有狼聚合的终点的方案数就是已知的了，利用乘法原理就能得到方案数。那么所有终点的方案数加起来就可以了。

（我会说实际上这道题最终枚举终点是借鉴了其他大牛的先进思想么……）

代码

const int mod = (int)1e9 + 7;
const int dir[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
typedef long long ll;
class WolfPackDivTwo {
public:
	int calc(vector <int> sx, vector <int> sy, int m){
	    vector<vector<vector<int> > >dp(m + 1, vector<vector<int> >(101, vector<int>(101, 0)));
        dp[0][50][50] = 1;
        for (int j = 0; j < m; j++)
        for (int x = 1; x < 100; x++)
            for (int y = 1; y < 100; y++)
                for (int i = 0; i < 4; i++){
                    int xx = x + dir[i][0];
                    int yy = y + dir[i][1];
                    dp[j + 1][xx][yy] = (dp[j + 1][xx][yy] + dp[j][x][y]) % mod;
                }
        int n = sx.size();
        ll ans = 0;
        for (int gy = -50; gy <= 100; gy++)
            for (int gx = -50; gx <= 100; gx++){
                ll tmp = 1;
                for (int i = 0; i < n; i++){
                    int dy = abs(gy - sy[i]);
                    int dx = abs(gx - sx[i]);
                    if (dx + dy > m){
                        tmp = 0; break;
                    }
                    tmp = (tmp * dp[m][50 + dy][50 + dx]);
                    tmp %= mod;
                }
                ans = (ans + tmp) % mod;
            }
        return ans;
	}
};