我的PAT-ADVANCED代码仓:https://github.com/617076674/PAT-ADVANCED
原题链接:https://pintia.cn/problem-sets/994805342720868352/problems/994805396953219072
题目描述:
题目翻译:
1072 加油站
加油站的位置选取,应该使得其与任何住宅之间的最小距离尽可能远。同时又必须保证所有的居民都在自己的服务范围内。
现在给你一张城市的地图和几个加油站的候选位置,你需要给出最好的建议。如果有超过1种方案,选取离所有住宅平均距离最小的方案。如果方案还不唯一,输出编号最小的加油站位置。
输入格式:
每个输入文件包含一个测试用例。在每个测试用例中,第一行给出4个正整数:N(<= 1000),代表房子数量;M(<= 10),代表加油站的候选位置总数;K(<= 10000),代表连接加油站和房子的道路数目;Ds,代表加油站的最大服务距离。所有房子的编号为1 ~ N。所有加油站的候选位置编号从G1 ~ GM。
接下来的K行,每行以下述形式描述一条道路:
P1 P2 Dist
P1和P2代表道路的两端点,两端点均既有可能是房子编号也有可能是加油站的候选位置编号,Dist是道路的长度,是一个整数。
输出格式:
对每一个测试用例,在第一行输出最好的加油站选址。第二行输出该候选位置离房子的最近距离和平均距离。数字必须以一个空格分隔且每个数字精确到小数点后面1位。如果没有任何解决方案,只需输出No Solution。
输入样例1:
4 3 11 5
1 2 2
1 4 2
1 G1 4
1 G2 3
2 3 2
2 G2 1
3 4 2
3 G3 2
4 G1 3
G2 G1 1
G3 G2 2
输出样例1:
G1
2.0 3.3
输入样例2:
2 1 2 10
1 G1 9
2 G1 20
输出样例2:
No Solution
知识点:Dijkstra算法、Bellman-Ford算法、SPFA算法
思路一:Dijkstra算法(邻接表实现)
首先是输入的节点标号与加油站编号全部要转换成数字编号。我假设房子的编号为1 ~ N,加油站的编号为N + 1 ~ N + M。由于输入的道路两端有可能是数字也有可能是G开头的字符串,我们统一用字符串接收,并设置一个函数change()将接收的字符串转换为数字编号。
我的转换规则是对G开头的字符串,取其后面一个字符与字符'0'作差,再返回N + 差值。但是这样做忽略了G10的情况,因此,当G开头的字符串长度是3位时,我们需要返回N + 10。
而我一开始所犯的错误是,忽略了N的范围,N最大可以到达1000。所以这个编号不止有一个字符,我一开始只考虑了N是个位数的情况。因此我们需要用头文件<sstream>中的stringstream类型将数字字符串转换成数字。
对每个加油站都用Dijkstra算法求其到各个房子的最小距离。
对每个加油站点,首先判断其到每个房子的最小距离是否小于等于Ds,如果有任何一个值大于Ds,这个加油站点是不可取的。
其次,对可取的加油站点进行筛选。
(1)筛选条件一:与任何住宅之间的最小距离尽可能远。
(2)筛选条件二:选取离所有住宅平均距离最小的方案。由于住宅总量一定,因此只需选取离所有住宅总距离最小的方案即可。
(3)筛选条件三:输出编号最小的加油站位置。这个条件很容易满足,我们只需要按编号从小到大遍历即可,对于住宅总距离相等的后续方案不考虑。
注意,在发现离住宅更远的最小距离后,我们不仅要更新离住宅更远的最小距离值,还需要更新离所有住宅的总距离。
结果需要四舍五入,我的做法是将离所有住宅的总距离先乘以10再除以N,得到一个浮点数类型。再按同样的做法,不过这次得到的是一个int类型,将两者相减,如果差大于等于0.5,就将后面得到的int类型增1,最后输出结果时还需要再除以10,并保留1位小数。
时间复杂度是O(M * (N + M) ^ 2)。空间复杂度是O(N + M + K)。
C++代码:
#include<iostream>
#include<vector>
#include<string>
#include<sstream>
using namespace std;
struct node {
int v; //节点编号
int len; //道路长度
node(int _v, int _len) : v(_v), len(_len) {} //构造函数
};
int N; //房子数量
int M; //加油站数量
int K; //道路数量
int Ds; //加油站服务范围
int INF = 1000000000; //无穷大数
vector<node> graph[1020]; //无向图,房子的编号为1 ~ N,加油站的编号为N + 1 ~ N + M
int d[1020]; //记录最短长度
bool visited[1020]; //标记数组
int totalDistance();
bool validPosition();
int minDistance();
void init();
int change(string s);
void dijkstra(int s);
int main() {
cin >> N >> M >> K >> Ds;
string P1, P2;
int Dist;
for(int i = 0; i < K; i++) {
cin >> P1 >> P2 >> Dist;
int id1 = change(P1);
int id2 = change(P2);
graph[id1].push_back(node(id2, Dist));
graph[id2].push_back(node(id1, Dist));
}
int minLen = 0;
int minTotalLen = INF;
int result = 0;
for(int i = N + 1; i <= N + M; i++) {
dijkstra(i);
if(validPosition()) {
if(minDistance() > minLen) {
result = i;
minLen = minDistance();
minTotalLen = totalDistance(); //此处也要更新minTotalLen
} else if(minDistance() == minLen) {
if(minTotalLen > totalDistance()) {
result = i;
minTotalLen = totalDistance();
}
}
}
}
if(result == 0){
cout << "No Solution" << endl;
return 0;
}
cout << "G" << result - N << endl;
double average = minTotalLen * 10.0 / N;
int averageResult = minTotalLen * 10 / N;
if(average - averageResult >= 0.5){
averageResult++;
}
printf("%.1lf %.1lf\n", minLen * 1.0, averageResult * 1.0 / 10);
return 0;
}
int totalDistance() {
int sum = 0;
for(int i = 1; i <= N; i++) {
sum += d[i];
}
return sum;
}
bool validPosition() {
for(int i = 1; i <= N; i++) {
if(d[i] > Ds) {
return false;
}
}
return true;
}
int minDistance() {
int min = 1;
for(int i = 2; i <= N; i++) {
if(d[i] < d[min]) {
min = i;
}
}
return d[min];
}
void init() {
for(int i = 1; i <= N + M; i++) {
d[i] = INF;
visited[i] = false;
}
}
int change(string s) {
if(s[0] == 'G'){
if(s.length() == 3){
return 10 + N;
}else{
int num = s[1] - '0';
return num + N;
}
}else{
stringstream ss;
ss << s;
int result;
ss >> result;
return result;
}
}
void dijkstra(int s) {
init();
d[s] = 0;
for(int i = 0; i < N + M; i++) {
int u = -1, min = INF;
for(int j = 1; j <= N + M; j++) {
if(!visited[j] && min > d[j]) {
min = d[j];
u = j;
}
}
if(u == -1) {
return;
}
visited[u] = true;
for(int j = 0; j < graph[u].size(); j++) {
int v = graph[u][j].v;
int len = graph[u][j].len;
if(!visited[v]) {
if(d[u] + len < d[v]) {
d[v] = d[u] + len;
}
}
}
}
}
C++解题报告:
思路二:Bellman-Ford算法(邻接表实现)(测试点4会超时)
时间复杂度是O(M * K * (N + M))。空间复杂度是O(N + M + K)。
C++代码:
#include<iostream>
#include<vector>
#include<string>
#include<sstream>
using namespace std;
struct node {
int v; //节点编号
int len; //道路长度
node(int _v, int _len) : v(_v), len(_len) {} //构造函数
};
int N; //房子数量
int M; //加油站数量
int K; //道路数量
int Ds; //加油站服务范围
int INF = 1000000000; //无穷大数
vector<node> graph[1020]; //无向图,房子的编号为1 ~ N,加油站的编号为N + 1 ~ N + M
int d[1020]; //记录最短长度
int totalDistance();
bool validPosition();
int minDistance();
void init();
int change(string s);
bool bellmanFord(int s);
int main() {
cin >> N >> M >> K >> Ds;
string P1, P2;
int Dist;
for(int i = 0; i < K; i++) {
cin >> P1 >> P2 >> Dist;
int id1 = change(P1);
int id2 = change(P2);
graph[id1].push_back(node(id2, Dist));
graph[id2].push_back(node(id1, Dist));
}
int minLen = 0;
int minTotalLen = INF;
int result = 0;
for(int i = N + 1; i <= N + M; i++) {
bellmanFord(i);
if(validPosition()) {
if(minDistance() > minLen) {
result = i;
minLen = minDistance();
minTotalLen = totalDistance(); //此处也要更新minTotalLen
} else if(minDistance() == minLen) {
if(minTotalLen > totalDistance()) {
result = i;
minTotalLen = totalDistance();
}
}
}
}
if(result == 0) {
cout << "No Solution" << endl;
return 0;
}
cout << "G" << result - N << endl;
double average = minTotalLen * 10.0 / N;
int averageResult = minTotalLen * 10 / N;
if(average - averageResult >= 0.5) {
averageResult++;
}
printf("%.1lf %.1lf\n", minLen * 1.0, averageResult * 1.0 / 10);
return 0;
}
int totalDistance() {
int sum = 0;
for(int i = 1; i <= N; i++) {
sum += d[i];
}
return sum;
}
bool validPosition() {
for(int i = 1; i <= N; i++) {
if(d[i] > Ds) {
return false;
}
}
return true;
}
int minDistance() {
int min = 1;
for(int i = 2; i <= N; i++) {
if(d[i] < d[min]) {
min = i;
}
}
return d[min];
}
void init() {
for(int i = 1; i <= N + M; i++) {
d[i] = INF;
}
}
int change(string s) {
if(s[0] == 'G') {
if(s.length() == 3) {
return 10 + N;
} else {
int num = s[1] - '0';
return num + N;
}
} else {
stringstream ss;
ss << s;
int result;
ss >> result;
return result;
}
}
bool bellmanFord(int s) {
init();
d[s] = 0;
for(int i = 0; i < N + M - 1; i++) {
for(int u = 1; u <= N + M; u++) {
for(int j = 0; j < graph[u].size(); j++) {
int v = graph[u][j].v;
int len = graph[u][j].len;
if(d[u] + len < d[v]) {
d[v] = d[u] + len;
}
}
}
}
for(int u = 1; u <= N + M; u++) {
for(int j = 0; j < graph[u].size(); j++) {
int v = graph[u][j].v;
int len = graph[u][j].len;
if(d[u] + len < d[v]) {
return false;
}
}
}
return true;
}
C++解题报告:
思路三:SPFA算法(邻接表实现)
期望时间复杂度是O(k * M * (N + M)),其中k是一个常数,在很多情况下k不超过2,可见这个算法异常高效,并且经常性地优于堆优化的Dijkstra算法。空间复杂度是O(N + M + K)。
C++代码:
#include<iostream>
#include<vector>
#include<string>
#include<sstream>
#include<queue>
using namespace std;
struct node {
int v; //节点编号
int len; //道路长度
node(int _v, int _len) : v(_v), len(_len) {} //构造函数
};
int N; //房子数量
int M; //加油站数量
int K; //道路数量
int Ds; //加油站服务范围
int INF = 1000000000; //无穷大数
vector<node> graph[1020]; //无向图,房子的编号为1 ~ N,加油站的编号为N + 1 ~ N + M
int d[1020]; //记录最短长度
bool inq[1020];
int countInq[1020];
int totalDistance();
bool validPosition();
int minDistance();
void init();
int change(string s);
bool spfa(int s);
int main() {
cin >> N >> M >> K >> Ds;
string P1, P2;
int Dist;
for(int i = 0; i < K; i++) {
cin >> P1 >> P2 >> Dist;
int id1 = change(P1);
int id2 = change(P2);
graph[id1].push_back(node(id2, Dist));
graph[id2].push_back(node(id1, Dist));
}
int minLen = 0;
int minTotalLen = INF;
int result = 0;
for(int i = N + 1; i <= N + M; i++) {
spfa(i);
if(validPosition()) {
if(minDistance() > minLen) {
result = i;
minLen = minDistance();
minTotalLen = totalDistance(); //此处也要更新minTotalLen
} else if(minDistance() == minLen) {
if(minTotalLen > totalDistance()) {
result = i;
minTotalLen = totalDistance();
}
}
}
}
if(result == 0) {
cout << "No Solution" << endl;
return 0;
}
cout << "G" << result - N << endl;
double average = minTotalLen * 10.0 / N;
int averageResult = minTotalLen * 10 / N;
if(average - averageResult >= 0.5) {
averageResult++;
}
printf("%.1lf %.1lf\n", minLen * 1.0, averageResult * 1.0 / 10);
return 0;
}
int totalDistance() {
int sum = 0;
for(int i = 1; i <= N; i++) {
sum += d[i];
}
return sum;
}
bool validPosition() {
for(int i = 1; i <= N; i++) {
if(d[i] > Ds) {
return false;
}
}
return true;
}
int minDistance() {
int min = 1;
for(int i = 2; i <= N; i++) {
if(d[i] < d[min]) {
min = i;
}
}
return d[min];
}
void init() {
for(int i = 1; i <= N + M; i++) {
d[i] = INF;
inq[i] = false;
countInq[i] = 0;
}
}
int change(string s) {
if(s[0] == 'G') {
if(s.length() == 3) {
return 10 + N;
} else {
int num = s[1] - '0';
return num + N;
}
} else {
stringstream ss;
ss << s;
int result;
ss >> result;
return result;
}
}
bool spfa(int s) {
init();
d[s] = 0;
queue<int> q;
q.push(s);
inq[s] = true;
countInq[s]++;
while(!q.empty()){
int u = q.front();
q.pop();
inq[u] = false;
for(int j = 0; j < graph[u].size(); j++){
int v = graph[u][j].v;
int len = graph[u][j].len;
if(len + d[u] < d[v]){
d[v] = len + d[u];
if(!inq[v]){
q.push(v);
inq[v] = true;
countInq[v]++;
if(countInq[v] > M + N){
return false;
}
}
}
}
}
return true;
}
C++解题报告: