【逆序思考最短路 BFS】P5683 [CSP-J2019 江西] 道路拆除|普及+

最新推荐文章于 2026-08-20 08:00:00 发布

原创最新推荐文章于 2026-08-20 08:00:00 发布 · 2k 阅读

36 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

洛谷普及+

本文涉及知识点

C++图论最短路
C++BFS算法

P5683 [CSP-J2019 江西] 道路拆除

题目描述

A 国有 $n$ 座城市，从 $\sim n$ 编号。 $1$ 号城市是 A 国的首都。城市间由 $m$ 条双向道路连通，通过每一条道路所花费的时间均为 $1$ 单位时间。

现在 A 国打算拆除一些不实用的道路以减小维护的开支，但 A 国也需要保证主要线路不受影响。因此 A 国希望道路拆除完毕后，利用剩余未被拆除的道路，从 A 国首都出发，能到达 $s_1$ 号与 $s_2$ 号城市，且所要花费的最短时间分别不超过 $t_1$ 与 $t_2$ （注意这是两个独立的条件，互相之间没有关联，即不需要先到 $s_1$ 再到 $s_2$ ）。

A 国想请你帮他们算算，在满足上述条件的情况下，他们最多能拆除多少条道路。若上述条件永远无法满足，则输出 $- 1$ 。

输入格式

第一行两个正整数 $n, m$ ，表示城市数与道路数。

接下来 $m$ 行，每行两个正整数 $x, y$ ，表示一条连接 $x$ 号点与 $y$ 号点的道路。

最后一行四个整数，分别为 $s_1,t_1,s_2,t_2$ 。

输出格式

仅一行一个整数，表示答案。

输入输出样例 #1

输入 #1

输出 #1

输入输出样例 #2

输入 #2

输出 #2

-1

说明/提示

【数据范围】
对于 $30\%$ 的数据， $\le 15$ ；
另有 $20\%$ 的数据， $\le 100$ ， $m = n - 1$ ；
另有 $30\%$ 的数据， $s_1 = s_2$ ；
对于 $100\%$ 的数据， $\le n,m \le 3000$ ， $1\le x,y \le n$ ， $\le s_1,s_2 \le n$ ， $\le t_1,t_2 \le n$ 。

【样例 $1$ 解释】
拆除 $(1, 2), (2, 3), (3, 4)$ 三条边。
注意：不需要令首都与除了 $s_1,s_2$ 外的点在拆除之后依然连通。

【样例 $2$ 解释】
即使一条边都不拆除，首都到 $3$ 号点的最短时间也都达到了 $2$ 单位时间。

testdata by @DYH060310

最短路逆序思路

拆除最多即保留最少。
性质一：0到s1的路径p01，和p到s2的路径p02。一定包括相同的前缀，此前缀至少1。除了此前缀外，不包括相同的节点。令相同的前缀长度为len。 $\ge len,y \ge len$ path01[len-1…x]和path02[len-1…y]换成较短的，就变成相同前缀了。
枚举z = path01[len-1]
z0、zs1、zs2之和就是最少保留道路，必须满足z0+zs0 <=t1,z0+zs2<=t2。
注意：本题的测试数据有重边和自环，等不需要特殊处理。

代码

核心代码

#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;
};

class CNeiBo
{
public:
	static vector<vector<int>> Two(int n, const vector<pair<int, int>>& edges, bool bDirect, int iBase = 0)
	{
		vector<vector<int>>  vNeiBo(n);
		for (const auto& [i1, i2] : edges)
		{
			vNeiBo[i1 - iBase].emplace_back(i2 - iBase);
			if (!bDirect)
			{
				vNeiBo[i2 - iBase].emplace_back(i1 - iBase);
			}
		}
		return vNeiBo;
	}
	static vector<vector<int>> Two(int n, const vector<vector<int>>& edges, bool bDirect, int iBase = 0)
	{
		vector<vector<int>>  vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase);
			}
		}
		return vNeiBo;
	}
	static vector<vector<std::pair<int, int>>> Three(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0)
	{
		vector<vector<std::pair<int, int>>> vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase, v[2]);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase, v[2]);
			}
		}
		return vNeiBo;
	}
	static vector<vector<std::pair<int, int>>> Three(int n, const vector<tuple<int, int, int>>& edges, bool bDirect, int iBase = 0)
	{
		vector<vector<std::pair<int, int>>> vNeiBo(n);
		for (const auto& [u, v, w] : edges)
		{
			vNeiBo[u - iBase].emplace_back(v - iBase, w);
			if (!bDirect)
			{
				vNeiBo[v - iBase].emplace_back(u - iBase, w);
			}
		}
		return vNeiBo;
	}
	static vector<vector<int>> Mat(vector<vector<int>>& neiBoMat)
	{
		vector<vector<int>> neiBo(neiBoMat.size());
		for (int i = 0; i < neiBoMat.size(); i++)
		{
			for (int j = i + 1; j < neiBoMat.size(); j++)
			{
				if (neiBoMat[i][j])
				{
					neiBo[i].emplace_back(j);
					neiBo[j].emplace_back(i);
				}
			}
		}
		return neiBo;
	}
};

class CBFSDis
{
public:
	CBFSDis(vector<vector<int>>& vNeiB, vector<int> start)
	{
		m_vDis.assign(vNeiB.size(), m_iNotMayDis);
		queue<int> que;
		for (const auto& n : start)
		{
			m_vDis[n] = 0;
			que.emplace(n);
		}
		while (que.size())
		{
			const int cur = que.front();
			que.pop();
			for (const auto next : vNeiB[cur])
			{
				if (m_iNotMayDis != m_vDis[next])
				{
					continue;
				}
				m_vDis[next] = m_vDis[cur] + 1;
				que.emplace(next);
			}
		}
	}
public:
	const int m_iNotMayDis = 1e9;
	vector<int> m_vDis;
};
class Solution {
		public:
			int Ans(const int N, vector<pair<int, int>>& edge, int s1,int t1,int s2,int t2) {
				auto neiBo = CNeiBo::Two(N, edge, false, 1);
				auto dis0 =CBFSDis(neiBo, { 0 }).m_vDis;
				auto dis1 = CBFSDis(neiBo, { s1-1 }).m_vDis;
				auto dis2 = CBFSDis(neiBo, { s2 - 1 }).m_vDis;
				int iNeed = INT_MAX / 2;
				for (int n = 0; n < N; n++) {
					if (dis0[n] + dis1[n] > t1) { continue; }
					if (dis0[n] + dis2[n] > t2) { continue; }
					iNeed = min(iNeed,dis0[n] + dis1[n] + dis2[n]);
				}
				if (INT_MAX / 2 == iNeed) { return -1; }
				return edge.size()- iNeed;
			}
		};
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 N, s1, t1, s2, t2;
	cin >> N;
	auto edge = Read<pair<int, int>>();
	cin >> s1 >> t1 >> s2 >> t2;
#ifdef _DEBUG	
		printf("N=%d,s1=%d,t1=%d,s2=%d,t2=%d",N,s1,t1,s2,t2);
		Out(edge, ",edge=");
		//Out(que, ",que=");
		//Out(B, ",B=");
		//Out(edge, ",edge=");	

#endif // DEBUG	
	auto res = Solution().Ans(N,edge,s1,t1,s2,t2);	
	cout << res << "\n";
	return 0;
};

单元测试

int N, s1, t1, s2, t2;
		vector<pair<int, int>> edge;
		TEST_METHOD(TestMethod11)
		{
			N = 5, s1 = 5, t1 = 3, s2 = 4, t2 = 3, edge = { {1,2},{2,3},{1,3},{3,4},{4,5},{3,5} };
			auto res = Solution().Ans(N, edge, s1, t1, s2, t2);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod12)
		{
			N = 3, s1 = 2, t1 = 2, s2 = 3, t2 = 1, edge = { {1,2},{2,3} };
			auto res = Solution().Ans(N, edge, s1, t1, s2, t2);
			AssertEx(-1, res);
		}
		TEST_METHOD(TestMethod13)
		{
			N = 9, s1 = 2, t1 = 2, s2 = 3, t2 = 6, edge = { {1,3},{3,3},{1,6},{6,2},{2,4},{5,7},{2,5},{1,3},{2
,4},{2,4},{4,7},{4,5},{5,8},{2,7},{5,7} };
			auto res = Solution().Ans(N, edge, s1, t1, s2, t2);
			AssertEx(12, res);
		}

# 扩展阅读

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