【分治法 容斥原理 矩阵快速幂】P6692 出生点|普及+

本文涉及知识点

组合数学汇总
容斥原理
【矩阵快速幂】封装类及测试用例及样例

P6692 出生点

题目背景

小 L、小 W 和小 H 在一起van♂游戏。

由于小 L 太菜了所以导致他一直在看着小 W 和小 H 打游戏。

题目描述

这款游戏的地图可以抽象成一张有 n n n 行 m m m 列的网格图，网格图上有 k k k 个障碍点，相邻两点间边长为 1 1 1。游戏开始时小 L、小 W 和小 H 会各自 随机出生在一个点。当然，他们不会出生在障碍点。

经常开局死的小 L 看着小 W 和小 H 每次在地图上汇合时经过的路径，很想知道他们每次出生后两个人之间的期望距离。（这里的距离指两点间曼哈顿距离，即 ∣ x 1 − x 2 ∣ + ∣ y 1 − y 2 ∣ \left|x_1-x_2\right|+\left|y_1-y_2\right| ∣x1−x2∣+∣y1−y2∣）

由于小 L 可以非常容易算出有多少种出生点安排方案，所以你实际上只需要告诉他所有情况中他们两人距离之和。

注意 ：小 W 出生在点 A A A，小 H 出生在点 B B B，跟小 W 出生在点 B B B，小 H 出生在点 A A A，这两种情况视作同一种情况。

输入格式

第一行有三个整数 n , m , k n,m,k n,m,k，分别表示地图行数、列数以及障碍物点数。

接下来有 k k k 行，第 i i i 行有两个正整数 x i , y i x_i,y_i xi,yi，表示第 i i i 个障碍物的位置。

输出格式

一个整数，表示所有情况中小 W 和小 H 两人出生点距离之和。

由于小 L 十分无聊，所以他让你将答案对 10 9 + 7 10^9+7 109+7 取模。

输入输出样例 #1

输入 #1

3 3 2
2 1
3 3

输出 #1

42

输入输出样例 #2

输入 #2

9 8 8
3 2
4 6
7 3
9 5
3 7
2 2
1 6
6 4

输出 #2

11552

说明/提示

对于样例一，地图样式如下（其中蓝点为障碍点，红点为可能的出生点）：

• 出生点为 ( 1 , 1 ) (1,1) (1,1) 和 ( 1 , 1 ) (1,1) (1,1)，距离为 0 0 0。
• 出生点为 ( 1 , 1 ) (1,1) (1,1) 和 ( 1 , 2 ) (1,2) (1,2)，距离为 1 1 1。
• 出生点为 ( 1 , 1 ) (1,1) (1,1) 和 ( 1 , 3 ) (1,3) (1,3)，距离为 2 2 2。
• 出生点为 ( 1 , 1 ) (1,1) (1,1) 和 ( 2 , 2 ) (2,2) (2,2)，距离为 2 2 2。
• 出生点为 ( 1 , 1 ) (1,1) (1,1) 和 ( 2 , 3 ) (2,3) (2,3)，距离为 3 3 3。
• 出生点为 ( 1 , 1 ) (1,1) (1,1) 和 ( 3 , 1 ) (3,1) (3,1)，距离为 2 2 2。
• 出生点为 ( 1 , 1 ) (1,1) (1,1) 和 ( 3 , 2 ) (3,2) (3,2)，距离为 3 3 3。
• 出生点为 ( 1 , 2 ) (1,2) (1,2) 和 ( 1 , 2 ) (1,2) (1,2)，距离为 0 0 0。
• 出生点为 ( 1 , 2 ) (1,2) (1,2) 和 ( 1 , 3 ) (1,3) (1,3)，距离为 1 1 1。
• 出生点为 ( 1 , 2 ) (1,2) (1,2) 和 ( 2 , 2 ) (2,2) (2,2)，距离为 1 1 1。
• 出生点为 ( 1 , 2 ) (1,2) (1,2) 和 ( 2 , 3 ) (2,3) (2,3)，距离为 2 2 2。
• 出生点为 ( 1 , 2 ) (1,2) (1,2) 和 ( 3 , 1 ) (3,1) (3,1)，距离为 3 3 3。
• 出生点为 ( 1 , 2 ) (1,2) (1,2) 和 ( 3 , 2 ) (3,2) (3,2)，距离为 2 2 2。
• 出生点为 ( 1 , 3 ) (1,3) (1,3) 和 ( 1 , 3 ) (1,3) (1,3)，距离为 0 0 0。
• 出生点为 ( 1 , 3 ) (1,3) (1,3) 和 ( 2 , 2 ) (2,2) (2,2)，距离为 2 2 2。
• 出生点为 ( 1 , 3 ) (1,3) (1,3) 和 ( 2 , 3 ) (2,3) (2,3)，距离为 1 1 1。
• 出生点为 ( 1 , 3 ) (1,3) (1,3) 和 ( 3 , 1 ) (3,1) (3,1)，距离为 4 4 4。
• 出生点为 ( 1 , 3 ) (1,3) (1,3) 和 ( 3 , 2 ) (3,2) (3,2)，距离为 3 3 3。
• 出生点为 ( 2 , 2 ) (2,2) (2,2) 和 ( 2 , 2 ) (2,2) (2,2)，距离为 0 0 0。
• 出生点为 ( 2 , 2 ) (2,2) (2,2) 和 ( 2 , 3 ) (2,3) (2,3)，距离为 1 1 1。
• 出生点为 ( 2 , 2 ) (2,2) (2,2) 和 ( 3 , 1 ) (3,1) (3,1)，距离为 2 2 2。
• 出生点为 ( 2 , 2 ) (2,2) (2,2) 和 ( 3 , 2 ) (3,2) (3,2)，距离为 1 1 1。
• 出生点为 ( 2 , 3 ) (2,3) (2,3) 和 ( 2 , 3 ) (2,3) (2,3)，距离为 0 0 0。
• 出生点为 ( 2 , 3 ) (2,3) (2,3) 和 ( 3 , 1 ) (3,1) (3,1)，距离为 3 3 3。
• 出生点为 ( 2 , 3 ) (2,3) (2,3) 和 ( 3 , 2 ) (3,2) (3,2)，距离为 2 2 2。
• 出生点为 ( 3 , 1 ) (3,1) (3,1) 和 ( 3 , 1 ) (3,1) (3,1)，距离为 0 0 0。
• 出生点为 ( 3 , 1 ) (3,1) (3,1) 和 ( 3 , 2 ) (3,2) (3,2)，距离为 1 1 1。
• 出生点为 ( 3 , 2 ) (3,2) (3,2) 和 ( 3 , 2 ) (3,2) (3,2)，距离为 0 0 0。

总和为 42 42 42。

数据范围

本题采用捆绑测试。

• Subtask 1( 10 % 10\% 10% )： n , m ≤ 80 n,m\leq 80 n,m≤80。
• Subtask 2( 20 % 20\% 20% )： n , m ≤ 5000 n,m\leq 5000 n,m≤5000。
• Subtask 3( 15 % 15\% 15% )： k = 0 k=0 k=0。
• Subtask 4( 15 % 15\% 15% )： m = 1 m=1 m=1。
• Subtask 5( 40 % 40\% 40% )：无特殊限制。

对于 100 % 100\% 100% 的数据， 1 ≤ n , m ≤ 10 9 , 1 ≤ x i ≤ n , 1 ≤ y i ≤ m , 0 ≤ k ≤ 5 × 10 5 , k < n × m 1\leq n,m\leq 10^9,1\leq x_i\leq n,1\leq y_i\leq m,0\leq k\leq 5\times 10^5,k<n\times m 1≤n,m≤109,1≤xi≤n,1≤yi≤m,0≤k≤5×105,k<n×m，保证所有障碍点各不相同。

分治法 容斥原理

分治法：哈曼顿距离的横坐标和总坐标可以分开计算。

f(1): 所有方案的距离之和。

f(2):W在障碍，H在任何格子的距离之和。

f(3):W在任何格子，H在障碍的距离之和。

f(4):都在障碍的距离之和。

根据容斥原理，至少一个在障碍（不重复）：f(2)+f(3) - f(4) ，

故：x=f(1)-f(2)-f(3)+f(4) 都不在障碍不重复的距离之和。x/2 便是答案。
注意 ：两人不能在同一单格，同一单格距离和为0，无影响。

f(2)的求法，枚举障碍物（r,c）以求横向距离为例：

(0+(c-1)）c/2 + (0 +(C-c)) (C-c+1)/2

f(3)=f(2)

f(4)的求法：

xs记录所有障碍的横坐标，升序。x1<x2且x1最大。有x2小的数有c1个，ls[x2] = ls[x1]+ (x2-x1)c1。Do函数求ls。rs = 翻转Do(翻转xs)。ls[i]是xs[i]到它左边的点的距离之和,rs[i]是xs[i]到它右边点的距离之和。
f(1)求法：
2 (C-1)个长度为1的距离。

2*(C-2)个长度为2的距离。
⋮ \vdots ⋮

2*(C-i)个长度为i的距离。i ∈ \in ∈[1,C-1]

2个C-1的距离。
每一行 g 1 = 2 ∑ i : 1 C − 1 ( i × ( C − i ) ) = 2 ( C ∑ i − ∑ ( i 2 ) ) 每一行g1=2\sum_{i:1}^{C-1}(i \times (C-i))=2(C\sum i -\sum(i^2)) 每一行g1=2∑i:1C−1(i×(C−i))=2(C∑i−∑(i2))

每个c1都可以选择任意一行，有 R 2 种选择 R^2种选择 R2种选择

即f1的列距离： R R g 1 RRg1 RRg1
s u m i sum i sumi可以用高斯定理计算， ∑ i i \sum ii ∑ii可以快速矩阵幂计算
总时间复杂度：O(k)+O(logm)+O(logm)

代码

核心代码

#include <iostream>
#include <sstream>
#include <vector>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<string>
#include<algorithm>
#include<functional>
#include<queue>
#include <stack>
#include<iomanip>
#include<numeric>
#include <math.h>
#include <climits>
#include<assert.h>
#include<cstring>
#include<list>
#include<array>

#include <bitset>
using namespace std;

template<class T1, class T2>
std::istream& operator >> (std::istream& in, pair<T1, T2>& pr) {
	in >> pr.first >> pr.second;
	return in;
}

template<class T1, class T2, class T3 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t);
	return in;
}

template<class T1, class T2, class T3, class T4 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3, T4>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
	return in;
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3, T4,T5,T6,T7>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t) >> get<4>(t) >> get<5>(t) >> get<6>(t);
	return in;
}

template<class T = int>
vector<T> Read() {
	int n;
	cin >> n;
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}
template<class T = int>
vector<T> ReadNotNum() {
	vector<T> ret;
	T tmp;
	while (cin >> tmp) {
		ret.emplace_back(tmp);
		if ('\n' == cin.get()) { break; }
	}
	return ret;
}

template<class T = int>
vector<T> Read(int n) {
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

template<int N = 1'000'000>
class COutBuff
{
public:
	COutBuff() {
		m_p = puffer;
	}
	template<class T>
	void write(T x) {
		int num[28], sp = 0;
		if (x < 0)
			*m_p++ = '-', x = -x;

		if (!x)
			*m_p++ = 48;

		while (x)
			num[++sp] = x % 10, x /= 10;

		while (sp)
			*m_p++ = num[sp--] + 48;
		AuotToFile();
	}
	void writestr(const char* sz) {
		strcpy(m_p, sz);
		m_p += strlen(sz);
		AuotToFile();
	}
	inline void write(char ch)
	{
		*m_p++ = ch;
		AuotToFile();
	}
	inline void ToFile() {
		fwrite(puffer, 1, m_p - puffer, stdout);
		m_p = puffer;
	}
	~COutBuff() {
		ToFile();
	}
private:
	inline void AuotToFile() {
		if (m_p - puffer > N - 100) {
			ToFile();
		}
	}
	char  puffer[N], * m_p;
};

template<int N = 1'000'000>
class CInBuff
{
public:
	inline CInBuff() {}
	inline CInBuff<N>& operator>>(char& ch) {
		FileToBuf();
		while (('\r' == *S) || ('\n' == *S) || (' ' == *S)) { S++; }//忽略空格和回车
		ch = *S++;
		return *this;
	}
	inline CInBuff<N>& operator>>(int& val) {
		FileToBuf();
		int x(0), f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行		
		return *this;
	}
	inline CInBuff& operator>>(long long& val) {
		FileToBuf();
		long long x(0); int f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行
		return *this;
	}
	template<class T1, class T2>
	inline CInBuff& operator>>(pair<T1, T2>& val) {
		*this >> val.first >> val.second;
		return *this;
	}
	template<class T1, class T2, class T3>
	inline CInBuff& operator>>(tuple<T1, T2, T3>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val);
		return *this;
	}
	template<class T1, class T2, class T3, class T4>
	inline CInBuff& operator>>(tuple<T1, T2, T3, T4>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val) >> get<3>(val);
		return *this;
	}
	template<class T = int>
	inline CInBuff& operator>>(vector<T>& val) {
		int n;
		*this >> n;
		val.resize(n);
		for (int i = 0; i < n; i++) {
			*this >> val[i];
		}
		return *this;
	}
	template<class T = int>
	vector<T> Read(int n) {
		vector<T> ret(n);
		for (int i = 0; i < n; i++) {
			*this >> ret[i];
		}
		return ret;
	}
	template<class T = int>
	vector<T> Read() {
		vector<T> ret;
		*this >> ret;
		return ret;
	}
private:
	inline void FileToBuf() {
		const int canRead = m_iWritePos - (S - buffer);
		if (canRead >= 100) { return; }
		if (m_bFinish) { return; }
		for (int i = 0; i < canRead; i++)
		{
			buffer[i] = S[i];//memcpy出错			
		}
		m_iWritePos = canRead;
		buffer[m_iWritePos] = 0;
		S = buffer;
		int readCnt = fread(buffer + m_iWritePos, 1, N - m_iWritePos, stdin);
		if (readCnt <= 0) { m_bFinish = true; return; }
		m_iWritePos += readCnt;
		buffer[m_iWritePos] = 0;
		S = buffer;
	}
	int m_iWritePos = 0; bool m_bFinish = false;
	char buffer[N + 10], * S = buffer;
};

template<long long MOD = 1000000007, class T1 = int, class T2 = long long>
class C1097Int
{
public:
	C1097Int(T1 iData = 0) :m_iData(iData% MOD)
	{

	}
	C1097Int(T2 llData) :m_iData(llData% MOD) {

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((T2)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((T2)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = ((T2)MOD + m_iData - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)const
	{
		return C1097Int(((T2)MOD + m_iData - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((T2)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((T2)m_iData * o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator/(const C1097Int& o)const
	{
		return *this * o.PowNegative1();
	}
	C1097Int& operator/=(const C1097Int& o)
	{
		*this *= o.PowNegative1();
		return *this;
	}
	bool operator==(const C1097Int& o)const
	{
		return m_iData == o.m_iData;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(T2 n)const
	{
		C1097Int iRet = (T1)1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	T1 ToInt()const
	{
		return ((T2)m_iData + MOD) % MOD;
	}
private:
	T1 m_iData = 0;;
};

template<class T = long long>
class CMatMul
{
public:
	CMatMul(T llMod = 1e9 + 7) :m_llMod(llMod) {}
	// 矩阵乘法
	vector<vector<T>> multiply(const vector<vector<T>>& a, const vector<vector<T>>& b) {
		const int r = a.size(), c = b.front().size(), iK = a.front().size();
		assert(iK == b.size());
		vector<vector<T>> ret(r, vector<T>(c));
		for (int i = 0; i < r; i++)
		{
			for (int j = 0; j < c; j++)
			{
				for (int k = 0; k < iK; k++)
				{
					ret[i][j] = (ret[i][j] + a[i][k] * b[k][j]) % m_llMod;
				}
			}
		}
		return ret;
	}

	// 矩阵快速幂
	vector<vector<T>> pow(const vector<vector<T>>& a, vector<vector<T>> b, T n) {
		vector<vector<T>> res = a;
		for (; n; n /= 2) {
			if (n % 2) {
				res = multiply(res, b);
			}
			b = multiply(b, b);
		}
		return res;
	}
	vector<vector<T>> pow(vector<vector<T>> pre, vector<vector<T>> mat, const string& str)
	{
		for (int i = str.length() - 1; i >= 0; i--) {
			const int t = str[i] - '0';
			pre = pow(pre, mat, t);
			mat = pow(mat, mat, 9);
		}
		return pre;
	}
	vector<vector<T>> TotalRow(const vector<vector<T>>& a)
	{
		vector<vector<T>> b(a.front().size(), vector<T>(1, 1));
		return multiply(a, b);
	}
	vector<vector<T>> CreateRow(int C) {
		return vector<vector<T>>(1, vector<T>(C));
	}
	vector<vector<T>> CreateUint(int RC) {
		vector<vector<T>> ret(RC, vector<T>(RC));
		for (int i = 0; i < RC; i++) { ret[i][i] = 1; }
		return ret;
	}
protected:
	const  T m_llMod;
};

typedef C1097Int<> BI;
typedef C1097Int<> BI;
		class Solution {
		public:
			int Ans(int R,int C,vector<pair<int,int>>& rc) {	
				map<int, int> mrs, mcs;	
				vector<int> rs, cs;
				for (auto& [r, c] : rc) { r--, c--; mrs[r]++, mcs[c]++; rs.emplace_back(r); cs.emplace_back(c); }
				m_ans += F1(R, C);	
				m_ans -= F23(R, C, mcs)*2;
				m_ans -= F23(C, R, mrs)*2;
				m_ans += F4(R,rs);
				m_ans += F4(C, cs);
				m_ans /= 2;
				return m_ans.ToInt();
			}
			BI F1(const int R,const int C) {
				vector<vector<long long>> mat(4, vector<long long>(4));
				mat[0][0] = 1; mat[1][0] = 2; mat[2][0] = 1;
				mat[1][1] = 1; mat[2][1] = 1;
				mat[2][2] = 1;
				mat[0][3] = 1,mat[1][3] =2, mat[2][3] = mat[3][3] = 1;
				vector<vector<long long>> pre = { { 0,0,1,0 } };//{x^2,x,1,平方和}
				CMatMul<> mulMat;
				BI ans1 = BI(C)*(1+C-1)*(C-1)/2 - mulMat.pow(pre,mat,C-1)[0][3];
				BI ans2 = BI(R) * (1 + R - 1) * (R - 1) / 2 - mulMat.pow(pre, mat, R - 1)[0][3];
				return (ans1*R*R+ans2*C*C)*2;
			}
			BI F23(const int R, const int C, map<int,int>& cnt) {
				BI ans;
				BI leftCurSum = 0,leftCurCnt=0;
				BI total = BI(R)*(BI(C-1)+0)*BI(C)/2;
				int pre = -1;
				for (auto&[cur,cnt1]:cnt) {
					leftCurCnt += BI(R) * (cur - pre);
					leftCurSum += BI(R) * (BI(cur) + BI(pre + 1)) * (cur - pre)/2;
					const auto r = total - leftCurSum;
					BI acell = leftCurCnt * cur - leftCurSum + r - BI(cur) * (BI(R)*C-leftCurCnt);
					ans += acell * cnt1;
					pre = cur;
				}
				return ans;
			}
			BI F4(const int C,vector<int> cs) {
				sort(cs.begin(), cs.end());
				BI ans;		//只计算到左边的距离，然后乘以2	
				BI leftSum = 0,leftCnt=0;
				for (const auto& cur: cs) {
					ans += BI(cur) * leftCnt - leftSum;
					leftSum += cur;
					leftCnt+=1;
				}
				return ans*2;
			}
			BI m_ans = 0;
		};

int main() {
#ifdef _DEBUG
	freopen("a.in", "r", stdin);
#endif // DEBUG	
	ios::sync_with_stdio(0); cin.tie(nullptr);
	//CInBuff<> in; COutBuff<10'000'000> ob;	
	int R, C, M;
	cin >> R >> C >> M;
	auto rc = Read<pair<int, int>>(M);
#ifdef _DEBUG	
		printf("R=%d,C=%d",R,C);
		Out(rc, ",rc=");
		//Out(B, ",B=");
		//Out(edge, ",edge=");		
		/*Out(que, ",que=");*/
	   //Out(ab, ",ab=");
	   //Out(par, "par=");
	   //Out(que, "que=");
	   //Out(B, "B=");
#endif // DEBUG	
	auto res = Solution().Ans(R,C,rc);	
	cout << res << "\n";
	return 0;
};

单元测试

int R, C;
		vector<pair<int, int>> rc;
		BI Check1(int R, int C, const vector<pair<int, int>>& rc) {
			BI ans = 0;
			for (int r1 = 0; r1 < R; r1++) {
				for (int c1 = 0; c1 < C; c1++) {
					for (int r2 = 0; r2 < R; r2++) {
						for (int c2 = 0; c2 < C; c2++) {
							ans += abs(r1 - r2) + abs(c1 - c2);
						}
					}
				}
			}
			return ans;
		}
		BI Check2(int R, int C, const vector<pair<int, int>>& rc) {
			set<pair<int, int>> s;
			for (auto [r, c] : rc) { s.emplace(r, c); }
			BI ans = 0;
			for (int r1 = 0; r1 < R; r1++) {
				for (int c1 = 0; c1 < C; c1++) {
					if (!s.count({ r1, c1 })) { continue; }
					for (int r2 = 0; r2 < R; r2++) {
						for (int c2 = 0; c2 < C; c2++) {
							ans += abs(r1 - r2) + abs(c1 - c2);
						}
					}
				}
			}
			return ans;
		}
		BI Check3(int R, int C, const vector<pair<int, int>>& rc) {
			set<pair<int, int>> s;
			for (auto [r, c] : rc) { s.emplace(r, c); }
			BI ans = 0;
			for (int r1 = 0; r1 < R; r1++) {
				for (int c1 = 0; c1 < C; c1++) {
					if (!s.count({ r1, c1 })) { continue; }
					for (int r2 = 0; r2 < R; r2++) {
						for (int c2 = 0; c2 < C; c2++) {
							if (!s.count({ r2, c2 })) { continue; }
							ans += abs(r1 - r2) + abs(c1 - c2);
						}
					}
				}
			}
			return ans;
		}
		TEST_METHOD(TestMethod1)
		{
			R = 3, C = 3, rc = { {2,1},{3,3} };
			auto res = Solution().Ans(R, C, rc);
			BI act = Check1(R, C, rc)- Check2(R, C, rc)*2+Check3(R,C,rc);
			act /= 2;
			AssertEx(act.ToInt(), res);
			AssertEx(42, res);
		}
		TEST_METHOD(TestMethod2)
		{
			R = 9, C = 8, rc = { {3,2},{4,6},{7,3},{9,5},{3,7},{2,2},{1,6},{6,4} };
			auto res = Solution().Ans(R, C, rc);
			BI act = Check1(R, C, rc) - Check2(R, C, rc) * 2 + Check3(R, C, rc);
			act /= 2;
			AssertEx(act.ToInt(), res);
			AssertEx(11552, res);
		}
		TEST_METHOD(TestMethod3)
		{
			R = 1, C = 3, rc = { };
			BI act = Check1(R, C, rc) - Check2(R, C, rc) * 2 + Check3(R, C, rc);
			act /= 2;
			auto res = Solution().Ans(R, C, rc);
			AssertEx(act.ToInt(), res);	
		}
		TEST_METHOD(TestMethod4)
		{
			R = 2, C = 2, rc = { };
			auto res = Solution().Ans(R, C, rc);
			BI act = Check1(R, C, rc) - Check2(R, C, rc) * 2 + Check3(R, C, rc);
			act /= 2;
			AssertEx(act.ToInt(), res);
		}
		TEST_METHOD(TestMethod5)
		{
			R = 57, C = 11, rc = { {1,1},{5,5},{1,5},{5,1} };
			auto res = Solution().Ans(R, C, rc);
			BI act = Check1(R, C, rc) - Check2(R, C, rc) * 2 + Check3(R, C, rc);
			act /= 2;
			AssertEx(act.ToInt(), res);	
		}

# 扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标 及时的反馈 拉伸区（难度合适） 专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功 成功+反思=成功

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

测试环境

操作系统：win7 开发环境： VS2019 C++17

或者 操作系统：win10 开发环境： VS2022 C++17

如无特殊说明，本算法 用**C++**实现。