Codeforces Round #826 (Div. 3) G // bfs + 状压dp

题目来源：Codeforces Round #826 (Div. 3) G - Kirill and Company

题目链接：Problem - G - Codeforces

---

题意

给定一个有\(n\)个点\(m\)条边的无向图，有\(f\)个人初始位于结点\(1\)，他们各自的家在结点\(h_i\)处，在这些人中，有\(k\)个人（\(p_1,p_2,...,p_k\)）没有自己的车子。现在这些人要从结点\(1\)回到各自的家，而有车子的人在走一条最短路的前提下，可以顺路载其他人回家。

问：最少的需要走路回家的人数。

数据范围：\(\sum{n},\sum{m},\sum{f} \le 10^4\)，\(2 \le h_i \le n\)，\(1 \le k \le min(6, f)\).

思路：bfs + 状压dp

由于\(k\)最大只有\(6\)，考虑用状态压缩表示能顺路搭载他们的情况。

\(dp[u][status]\)：表示从\(1\)到\(u\)，是否可以给\(status\)状态的人搭便车。

先做一次bfs，预处理出所有的\(dp\)值：由于必须走最短路的限制，用\(dist[i]\)表示结点\(1\)到\(i\)的最短距离。将所有点的\(dist\)初值置为\(-1\)，那么当搜到 \(u \rightarrow v\) 时，只有\(dist[v] = -1\ or\ dist[v] = dist[u]+1\)，才是合法的。

之后，再做一次dp：\(f[i][status]\)，表示在考虑前\(i\)个人的情况下，是否能顺路搭载\(status\)的人。那么转移时，二维枚举\(i-1\)和\(i\)的状态，若\(i\)有车，且\(dp[h_i][status_i]=1\)，则\(f[i][status_i\ |\ status_{i-1}] = f[i][status_i\ |\ status_{i-1}]\ |\ f[i-1][status_{i-1}]\)。

使用滚动数组可以优化第一维的空间，使用bitset可以优化转移的计算速度，这样每次转移的计算复杂度就是\(O({\large\frac{2^k}{64}})\)，可以认为是\(O(1)\).

时间复杂度：\(O(n·2^k)\).

代码

#include <bits/stdc++.h>
#define endl '\n'
#define PII pair<int,int>
using namespace std;

const int N = 10010, M = 10;

int n, m, f, h[N], k, p[M], dist[N];
vector<int> g[N];
bool dp[N][1 << 6];

void bfs()
{
	queue<PII> q;
	q.push({1, 0}), dist[1] = 0, dp[1][0] = true;
	while(q.size()) {
		int u = q.front().first, status = q.front().second;
		q.pop();
		for(auto v : g[u]) {
			int new_status = status;
			for(int i = 1; i <= k; i++) {
				if(v == h[p[i]]) new_status |= 1 << (i - 1);
			}
			if((dist[v] == -1 || dist[v] == dist[u] + 1) && !dp[v][new_status]) {
				q.push({v, new_status});
				dist[v] = dist[u] + 1, dp[v][new_status] = true;
			}
		}
	}
}

void solve()
{
	cin >> n >> m;
	for(int i = 1; i <= n; i++) {
		g[i].clear(), g[i].shrink_to_fit();
	}
	while(m--) {
		int x, y;
		cin >> x >> y;
		g[x].push_back(y), g[y].push_back(x);
	}
	cin >> f;
	for(int i = 1; i <= f; i++) cin >> h[i];
	cin >> k;
	for(int i = 1; i <= k; i++) cin >> p[i];

	for(int i = 1; i <= n; i++) {
		dist[i] = -1;
		for(int j = 0; j < 1 << k; j++) dp[i][j] = false;
	}
	bfs();

	bitset<64> pre, now;
	pre[0] = 1;
	for(int i = 1; i <= k; i++) h[p[i]] = -1;
	for(int i = 1; i <= f; i++) {
		if(h[i] == -1) continue;
		int u = h[i];
		now = pre;
		for(int x = 0; x < 1 << k; x++) {
			for(int y = 0; y < 1 << k; y++) {
				if(dp[u][y]) now[x | y] = now[x | y] | pre[x];
			}
		}
		pre = now;
	}

	int ans = k;
	for(int i = 0; i < 1 << k; i++) {
		if(now[i]) ans = min(ans, k - __builtin_popcount(i));
	}
	cout << ans << endl;
	
}

int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	int test;
	cin >> test;
	while(test--) solve();

	return 0;
}