松鼠配对？

题意：

给出一张无向图，有n(<=100)个点，m条边，这n个点上一开始有ai个特殊点，这些特殊点一个单位时间移动一次，求移动T(<=1e9)次后，每个点上的点对的期望值(答案对1e9+7)取模（假如一个点上有4个特殊点，那么这个点上就有6个点对）。

题解：

首先看到T的数据范围，这个提示的是要用log级别的算法，很容易就想到了矩阵，现在的问题就是验证矩阵是否可行。

很容易知道初始矩阵是n * n的，那么这个矩阵表示的是什么？很容易知道是表示概率，因为刚好满足了乘法原理和加法原理，到此说明矩阵是可行的。

用矩阵就可以知道一个点到达另外一个点的概率，而E = P * w，现在可以很容易得到一个点到达另外一个点的期望值。

但是要求的却是 点对的期望值，那么就是两个点间的期望值相乘，现在的问题就是求到达此点的所有点的期望值的两两之积，由公式[(a+b+c+d...)² - a² - b² - c² - d² - ...]/ 2可以容易得到。

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

#define LL long long
const int N = 1e3 + 7;
const int mod = 1e9 + 7;
struct Matrix
{
	LL map[107][107];
} F;

LL inv[N], ans, a[N][N];
int n, c[N][N], num[N], T;

Matrix Mul (Matrix a, Matrix b)
{
	Matrix ret;
	memset (ret.map, 0, sizeof ret.map);
	for (int i = 1; i <= n; ++ i)
		for (int j = 1; j <= n; ++ j)
			for (int k = 1; k <= n; ++ k)
				ret.map[i][j] = (ret.map[i][j] + a.map[i][k] * b.map[k][j] % mod) % mod;
	return ret;
}

Matrix Pow (Matrix x, int cnt)
{
	Matrix ret;
	memset (ret.map, 0, sizeof ret.map);
	for (int i = 0; i <= n; ++ i) ret.map[i][i] = 1;
	while (cnt)
	{
		if (cnt & 1) ret = Mul(ret, x);
		x = Mul(x, x);
		cnt >>= 1;
	}
	return ret;
}

LL pow (LL x, int n)
{
	LL ret = 1;
	while (n)
	{
		if (n & 1) ret = ret * x % mod;
		x = x * x % mod;
		n >>= 1;
	}
	return ret;
}

int main ()
{
	scanf ("%d%d", &n, &T);
	for (int i = 1; i <= n; ++ i) scanf ("%d", &num[i]);

	for (int i = 1; i <=1000; ++ i) inv[i] = pow (i, mod - 2);

	for (int i = 1; i <= n; ++ i)
		for (int j = 1; j <= n; ++ j)
			scanf ("%d", &c[i][j]);
	for (int i = 1; i <= n; ++ i)
	{
		int cnt = 0;
		for (int j = 1; j <= n; ++ j) cnt += c[i][j];
		for (int j = 1; j <= n; ++ j) a[i][j] = c[i][j] * inv[cnt];
	}
	if (T != 1)
	{
		for (int i = 1; i <= n; ++ i)
			for (int j = 1; j <= n; ++ j)
				F.map[i][j] = a[i][j];
		F = Pow (F, T);
		for (int i = 1; i <= n; ++ i)
			for (int j = 1; j <= n; ++ j)
				a[i][j] = F.map[i][j];
	}
	for (int i = 1; i <= n; ++ i)
	{
		LL ret1 = 0, ret2 = 0;
		for (int j = 1; j <= n; ++ j)
		{
			LL ret = (a[j][i] * num[j]) % mod;
			ret1 = (ret1 + ret) % mod;
			ret2 = (ret2 + ret * a[j][i]) % mod;
		}
		ans = (ans + (ret1 * ret1 - ret2 + mod) % mod * inv[2] % mod) % mod;
	}
	cout << ans << endl;
	return 0;
}

总结：

1.这个题个人觉得不是很难，但是暴露出概率和期望确实学得不是一般的水啊~

2.这个矩阵就写得很蠢了，明明可以直接用数组写，而且还可能更快。