CF-1105D Kilani and the Game（多源bfs）

p个人（最多9个）抢地盘，轮流抢，每个人可以从自己的所有据点向上下左右扩展自己的扩展能力次（同时向上下左右），问终局每个人的占领个数，每个人的初始地盘可以不止一个。

考虑扩张能力为1的情况，就是一个很裸的宽搜，只要把每个人的初始位置按顺序塞入队列，bfs就可以完美模拟出轮流扩张的过程。

但是当扩张能力大于1的时候，每个人不止扩张一次，从队列中取出这个人的所有起点之后，实际上还要再进行扩张能力 - 1轮。

解决方法也很简单，就是多开一个队列，每一轮都在这个队列里搜到扩张次数用完or不能走为止，然后把最后一轮搜索的点，丢回原来的队列里，作为下一次搜索的起点。

ac代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int maxn = 1e3 + 5;

int n, m, p;
char G[maxn][maxn];
int sp[15], ans[15];
int op[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

struct point {
	int x, y, id;
};


struct point2 {
	int x, y, val, id;
};

vector<point> st[12];


void bfs() {
	queue<point> q;
	for(int i = 1; i <= p; i++) {
		for(int j = 0; j < st[i].size(); j++) {
			q.push(st[i][j]);
		}
	}
	while(!q.empty()) {

		point now = q.front();
		queue<point2> q2;

		while(!q.empty() && q.front().id == now.id) {
			q2.push({q.front().x, q.front().y, sp[q.front().id], q.front().id});
			q.pop();
		}

		while(!q2.empty()) {
			point2 noww = q2.front();
			q2.pop();

			if(noww.val == 0) {
				q.push({noww.x, noww.y, noww.id});
				continue;
			}

			for(int i = 0; i < 4; i++) {
				int nx = noww.x + op[i][0];
				int ny = noww.y + op[i][1];

				if(G[nx][ny] == '.') {
					G[nx][ny] = '#';
					++ans[noww.id];
					q2.push({nx, ny, noww.val - 1, noww.id});
				}
			}

		}
	}
}

int main() {

	for(int i = 0; i <= n + 1; i++) {
		for(int j = 0; j <= m + 1; j++) {
			G[i][j] = '#';
		}
	}

	cin >> n >> m >> p;
	for(int i = 1; i <= p; i++) {
		cin >> sp[i];
	}

	for(int i = 1; i <= n; i++) {
		cin >> G[i] + 1;
	}


	for(int i = 1; i <= n; i++) {
		for(int j = 1; j <= m; j++) {
			if(isdigit(G[i][j])) {
				st[G[i][j] - '0'].push_back({i, j, G[i][j] - '0'});
				++ans[G[i][j] - '0'];
			}
		}
	}


	bfs();

	for(int i = 1; i <= p; i++) {
		cout << ans[i] << " ";
	}
	return 0;
}