POJ 2263 Heavy Cargo （SPFA+Dijkstra，最短路变形）

题目链接： POJ 2263 Heavy Cargo

【题目大意】

某公司生产了一种巨型卡车，它的载重量并不在于它本身的载重量， 而只在于公路的载重量！

题目给你 开车运送的起点和终点 ， 以及一些可供选择的道路， 每个道路标明了载重量。

让你求出从起点开到终点，卡车的最大载重量是多少 ， 也就是起点到终点的通路中，载重量最小的道路的载重量。

【思路】

小技巧： 用map 实现字符串与数字的对应，注意要从1开始。

Dijkstra算法的变形 。

之前学图论的时候这个算法学的太快 没怎么练过，，以为用SPFA完全可以替代，，然而这两种算法的思想并不一样。

Dijkstra算法是从起点开始 ，每次在它相邻的节点中选出距离起点最近的那个点，更新时，将刚选出的节点临近的节点“显化”，也就是将minDist【】的值从INF 更新为当前到起点的距离， 缺点是要遍历n个节点 来找临近的点； 效率 O（n^2）

SPFA算法仅仅把比当前距离短的节点推入队列，再不断的从子节点中通过 松弛操作 找出当前的最短路。

本题是最短路的变形，， 每次寻找的是当前节点 附近节点的最大值而不是最短路，因为要让载重量尽可能的大，用Dijkstra的贪心思想很好想到，

int tmpmin = 0;
int addnode;
for(int i=1;i<=n;i++){
if(!inqueue[i]&&minDist[i]>tmpmin){ 找出临近节点最大的值
tmpmin = minDist[i];
addnode = i;
}
}

在节点更新的时候 minDist【】 并不是储存当前最短距离了，而是当前最小的载重量。

所以更新的时候 用临近节点的载重量 与 根节点（刚添加的节点）的载重量 比较选出最小的。

for(int i=0;i<G[addnode].size();i++){
          int vex = G[addnode][i].v;
          int value = G[addnode][i].len;
          if(!inqueue[vex]&&minDist[vex]<min(value,minDist[addnode])){
                minDist[vex]=min(value,minDist[addnode]);
          }
  }

【Dijkstra】

#include <iostream>
#include <cstdio>
#include <map>
#include <cstring>
#include <vector>
using namespace std;
const int maxn = 220;
struct node{
int v,len;
node(int v=0,int len=0):v(v),len(len){}
};
int minDist[maxn];
bool inqueue[maxn];
vector<node>G[maxn];
int  n,m;
void dijkstra(int st,int end){
memset(minDist,0,sizeof(minDist));
memset(inqueue,0,sizeof(inqueue));
minDist[st]=0;
inqueue[st]=true;
for(int i=0;i<G[st].size();i++){
int vex = G[st][i].v;
minDist[vex]=G[st][i].len;
}
for(int nodenum=1;nodenum<n;nodenum++){
int tmpmin = 0;
int addnode;
for(int i=1;i<=n;i++){
if(!inqueue[i]&&minDist[i]>tmpmin){
tmpmin = minDist[i];
addnode = i;
}
}
inqueue[addnode]=true;
for(int i=0;i<G[addnode].size();i++){
int vex = G[addnode][i].v;
int value = G[addnode][i].len;
if(!inqueue[vex]&&minDist[vex]<min(value,minDist[addnode])){
minDist[vex]=min(value,minDist[addnode]);
}
}
}
}
int main(){
map<string,int>mp; //
int cas=0;
while(scanf("%d%d",&n,&m)!=EOF&&(n||m)){
printf("Scenario #%d\n",++cas);
string a,b;
mp.clear();
for(int i=0;i<maxn;i++)
G[i].clear();
int len;
int cnt=0;
for(int i=0;i<m;i++){
cin>>a>>b>>len;
if(!mp[a]){ //用map 做string 与 int对应的时候，不要从0 开始 ，不好判断
mp[a]=++cnt; //从零开始 这个判断就错了
}
if(!mp[b])
mp[b]=++cnt;
G[mp[a]].push_back(node(mp[b],len));
G[mp[b]].push_back(node(mp[a],len));
}
cin>>a>>b;
dijkstra(mp[a],mp[b]);
cout<<minDist[mp[b]]<<" tons"<<endl<<endl;
}
return 0;
}

搞懂了上述传递状态的方法，SPFA的代码就很容易写出来了

【SPFA】

#include <iostream>
#include <cstdio>
#include <map>
#include <cstring>
#include <queue>
#include <vector>
#define INF 0xfffffff
using namespace std;
const int maxn = 220;
struct node{
int v,len;
node(int v=0,int len=0):v(v),len(len){}
};
int minDist[maxn];
bool inqueue[maxn];
vector<node>G[maxn];
int  n,m;
void SPFA(int st,int end){
memset(minDist,0,sizeof(minDist));
memset(inqueue,0,sizeof(inqueue));

inqueue[st]=true;
queue<int >Q;
minDist[st]=INF;
Q.push(st);
while(!Q.empty()){
int vex = Q.front();
Q.pop();
inqueue[vex]=0;
for(int i=0;i<G[vex].size();i++){
int v = G[vex][i].v;
int value = G[vex][i].len;
int tmp = max(minDist[v],min(minDist[vex],value));
if(tmp>minDist[v]){
minDist[v]=tmp;
if(!inqueue[v])
{
inqueue[v]=1;
Q.push(v);
}
}

}
}
}
int main(){
map<string,int>mp; //
int cas=0;
while(scanf("%d%d",&n,&m)!=EOF&&(n||m)){
printf("Scenario #%d\n",++cas);
string a,b;
mp.clear();
for(int i=0;i<maxn;i++)
G[i].clear();
int len;
int cnt=0;
for(int i=0;i<m;i++){
cin>>a>>b>>len;
if(!mp[a]){ //用map 做string 与 int对应的时候，不要从0 开始 ，不好判断
mp[a]=++cnt; //从零开始 这个判断就错了
}
if(!mp[b])
mp[b]=++cnt;
G[mp[a]].push_back(node(mp[b],len));
G[mp[b]].push_back(node(mp[a],len));
}
cin>>a>>b;
SPFA(mp[a],mp[b]);
cout<<minDist[mp[b]]<<" tons"<<endl<<endl;
}
return 0;
}

这一题在比赛的时候没有想出来怎么写，还是对算法原理掌握的不够清晰，光看模板是敲不出来新题的！