1.边权都非负
1.朴素Dijkstra（稠密图效率高）O(n^2)
2.推优化Dijstra（稀疏图效率更高）O(m*logn)
2，有负权边的负权问题
1.spfa（时间复杂度最好的情况是）O（m）但是如果存在负权变的话就可能出现超时的情况，因为如果出现负权边的话，有些边就不止会遍历一次）
图论问题最难点：问题的转化和抽象
#include<iostream>
#include<cstring>
using namespace std;
const int N = 2510,M = 6210*2;
int e[M],w[M],ne[M],h[N],idx;
int q[N],hh;
int dist[N];
bool st[N];
void add(int a,int b,int c)
{
e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;//e[idx]存以idx为下标的边，w[idx]以idx为下标的边的权，ne[idx]=h[a]，h[a]=idx++;和表示idx的下一个idx是多少（这个就相当于是链表的头插法）
}
void spfa(int begin,int end)
{
memset(dist,0x3f,sizeof dist);
st[begin]=true;
dist[begin]=0;
int hh = 0,tt = 1;
q[0] = begin;
while(hh!=tt)
{
int t = q[hh ++];
if(hh==N) hh = 0;
st[t] = false;
for(int i = h[t];i!=0;i = ne[i])
{
int xb = e[i];
if(dist[xb] > dist[t]+w[i])
{
dist[xb] = dist[t]+w[i];
if(!st[xb])
{
q[tt++]=xb;
if(tt==N)tt=0;
st[xb]=true;
}
}
}
}
}
int main()
{
int T,C,S,E;
cin>>T>>C>>S>>E;
while(C--)
{
int a,b,c;
cin>>a>>b>>c;
add(a,b,c);
add(b,a,c);
}
spfa(S,E);
cout<<dist[E]<<endl;
}2.信使
战争时期，前线有 n 个哨所，每个哨所可能会与其他若干个哨所之间有通信联系。
信使负责在哨所之间传递信息，当然，这是要花费一定时间的（以天为单位）。
指挥部设在第一个哨所。
当指挥部下达一个命令后，指挥部就派出若干个信使向与指挥部相连的哨所送信。
当一个哨所接到信后，这个哨所内的信使们也以同样的方式向其他哨所送信。信在一个哨所内停留的时间可以忽略不计。
直至所有 n 个哨所全部接到命令后，送信才算成功。
因为准备充足，每个哨所内都安排了足够的信使（如果一个哨所与其他 k 个哨所有通信联系的话，这个哨所内至少会配备 k 个信使）。
现在总指挥请你编一个程序，计算出完成整个送信过程最短需要多少时间。
输入格式
第 1 行有两个整数 n 和 m，中间用 1 个空格隔开，分别表示有 n 个哨所和 m 条通信线路。
第 2 至 m+1 行：每行三个整数 i、j、k，中间用 1 个空格隔开，表示第 i 个和第 j 个哨所之间存在 双向 通信线路，且这条线路要花费 k 天。
输出格式
一个整数，表示完成整个送信过程的最短时间。
如果不是所有的哨所都能收到信，就输出-1。
数据范围
1≤n≤100,
1≤m≤200,
1≤k≤1000
输入样例：
4 4
1 2 4
2 3 7
2 4 1
3 4 6
输出样例：
11
核心：每个点接到信的时间就是它到指挥部的最短距离，只需要将每个点的最短路径求一个最大值，就是送完所有点的时间（因为最大值就是最远的那个点的时间，最远的那个点都已经送到了，那么所有的点也就全部都送到了）
#include<iostream>
#include<cstring>
using namespace std;
const int N = 110,M = 210;
int d[N][N];
int inf = 0x3f3f3f3f;
int main()
{
int n,m;
cin>>n>>m;
memset(d,0x3f,sizeof d);
while(m--)
{
int a,b,c;
cin>>a>>b>>c;
d[a][b]=d[b][a]=min(d[a][b],c);
}
for(int i = 0;i <= n;i ++)d[i][i]=0;
for(int k = 1;k <= n;k ++)
for(int i = 1;i <= n;i ++)
for(int j = 1;j <= n;j ++)
d[i][j] = min(d[i][j],d[i][k]+d[k][j]);
int res = 0;
for(int i = 1;i <= n;i ++)
if(d[1][i]==inf)
{
res = -1;
break;
}
else res = max(res,d[1][i]);
cout<<res<<endl;
}3.香甜的黄油
农夫John发现了做出全威斯康辛州最甜的黄油的方法：糖。
把糖放在一片牧场上，他知道 N 只奶牛会过来舔它，这样就能做出能卖好价钱的超甜黄油。
当然，他将付出额外的费用在奶牛上。
农夫John很狡猾，就像以前的巴甫洛夫，他知道他可以训练这些奶牛，让它们在听到铃声时去一个特定的牧场。
他打算将糖放在那里然后下午发出铃声，以至他可以在晚上挤奶。
农夫John知道每只奶牛都在各自喜欢的牧场（一个牧场不一定只有一头牛）。
给出各头牛在的牧场和牧场间的路线，找出使所有牛到达的路程和最短的牧场（他将把糖放在那）。
数据保证至少存在一个牧场和所有牛所在的牧场连通。
输入格式
第一行: 三个数：奶牛数 N，牧场数 P，牧场间道路数 C。
第二行到第 N+1 行: 1 到 N 头奶牛所在的牧场号。
第 N+2 行到第 N+C+1 行：每行有三个数：相连的牧场A、B，两牧场间距 D，当然，连接是双向的。
输出格式
共一行，输出奶牛必须行走的最小的距离和。
数据范围
1≤N≤500,
2≤P≤800,
1≤C≤1450,
1≤D≤255
输入样例：
3 4 5
2
3
4
1 2 1
1 3 5
2 3 7
2 4 3
3 4 5
输出样例：
8
做法：这个题的意思大概就是，对每个点求一次最短路，对每个点形成的最短路求和，需要求的是以那个点形成的最短路，将每个点到这个点的距离加起来最小。
下图分析使用什么算法。
1.Floyd算法：O（n^3）很有可能超时，所以用不了
2.朴素Dijkstra：因为需要对每个点都求一次最短路，所以时间复杂度也是O（n^3），所以也用不了
3.堆优化Dijkstra：n * O（m*logn）可以用。
4.spfa: n * O（m）非常快
代码：
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N = 810,M = 3000,INF = 0x3f3f3f3f;
int w[M],ne[M],e[M],h[M],idx;
int dist[N],st[N],g[N];
queue<int> q;
int n,p,c;
void add(int a,int b,int c)
{
e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa(int x)
{
int res = 0;
memset(st,0,sizeof st);
memset(dist,0x3f,sizeof dist);
dist[x]=0;
st[x]=true;
q.push(x);
while(!q.empty())
{
int t = q.front();
q.pop();
st[t]=false;
for(int i = h[t];i != 0;i = ne[i])
{
int j = e[i];
if(dist[j] > dist[t]+w[i])
{
dist[j]=dist[t]+w[i];
if(!st[j])
{
q.push(j);
st[j]=true;
}
}
}
}
for(int i = 0;i < n;i ++)
{
if(dist[g[i]]==INF)return INF;
res+=dist[g[i]];
}
return res;
}
int main()
{
int ans = 1e9;
cin>>n>>p>>c;
for(int i = 0;i < n;i ++)cin>>g[i];
for(int i = 0;i < c;i ++)
{
int a,b,c;
cin>>a>>b>>c;
add(a,b,c);
add(b,a,c);
}
for(int i = 1;i <= p;i ++)
{
ans = min(spfa(i),ans);
}
cout<<ans<<endl;
return 0;
}题解：
#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N = 2010;
double g[N][N];
bool st[N];
double dist[N];
int s,t,n,m;
void disktra()
{
dist[s]=1;
for(int i = 1;i <= n;i ++)
{
int t = -1;
for(int j = 1;j <= n;j ++)
{
if(!st[j]&&(t==-1||dist[t]<dist[j]))
t = j;
}
st[t]=true;
for(int j = 1;j <= n;j ++)
dist[j] = max(dist[j],dist[t]*g[t][j]);
}
}
int main()
{
cin>>n>>m;
while(m--)
{
int a,b;
double c;
cin>>a>>b>>c;
c = (100.0-c)/100;
g[a][b]=g[b][a]=max(g[a][b],c);
}
cin>>s>>t;
disktra();
printf("%0.8f\n",100/dist[t]);
return 0;
}4.最优乘车（建图）
H 城是一个旅游胜地，每年都有成千上万的人前来观光。
为方便游客，巴士公司在各个旅游景点及宾馆，饭店等地都设置了巴士站并开通了一些单程巴士线路。
每条单程巴士线路从某个巴士站出发，依次途经若干个巴士站，最终到达终点巴士站。
一名旅客最近到 H 城旅游，他很想去 S 公园游玩，但如果从他所在的饭店没有一路巴士可以直接到达 S 公园，则他可能要先乘某一路巴士坐几站，再下来换乘同一站台的另一路巴士，这样换乘几次后到达 S 公园。
现在用整数 1,2,…N 给 H 城的所有的巴士站编号，约定这名旅客所在饭店的巴士站编号为 1，S 公园巴士站的编号为 N。
写一个程序，帮助这名旅客寻找一个最优乘车方案，使他在从饭店乘车到 S 公园的过程中换乘的次数最少。
输入格式
第一行有两个数字 M 和 N，表示开通了 M 条单程巴士线路，总共有 N 个车站。
从第二行到第 M+1 行依次给出了第 1 条到第 M 条巴士线路的信息，其中第 i+1 行给出的是第 i 条巴士线路的信息，从左至右按运行顺序依次给出了该线路上的所有站号，相邻两个站号之间用一个空格隔开。
输出格式
共一行，如果无法乘巴士从饭店到达 S 公园，则输出 NO，否则输出最少换乘次数，换乘次数为 0 表示不需换车即可到达。
数据范围
1≤M≤100,
2≤N≤500
输入样例：
3 7
6 7
4 7 3 6
2 1 3 5
输出样例：
2
解法：因为这个题要计算的是换乘的次数，而不是坐车时间什么的，那么在经过一条站上的站点是不需要换成次数的，也就是说在一条公交站中在站点之间来回切换是不需要花费的，那么我们将一条公交站上的每个站点相互连一条权值为1的边，那么建图完成后就可以用最短路求出1站带n站的更换成次数了（dist[n]-1,明显多加了一次换成次数）。
#include<iostream>
#include<cstring>
#include<sstream>
#include<queue>
using namespace std;
const int N = 510;
bool st[N][N];
int stop[N];
int n,m;
int dist[N];
void bfs()
{
memset(dist,0x3f,sizeof dist);
queue<int> q;
q.push(1);
dist[1]=0;
while(!q.empty())
{
int t = q.front();
q.pop();
for(int k = 1;k <= n;k ++)
if(st[t][k]&&dist[k] > dist[t]+1)
{
dist[k] = dist[t]+1;
q.push(k);
}
}
}
int main()
{
cin>>m>>n;
string line;
getline(cin, line);
while(m--)
{
getline(cin,line);
stringstream ssin(line);
int cnt = 0,p;
while(ssin >> p)stop[cnt++] = p;
for(int i = 0;i < cnt; i++)
for(int j = i+1;j < cnt;j ++)
st[stop[i]][stop[j]]=true;
}
bfs();
if (dist[n] == 0x3f3f3f3f) puts("NO");
else cout << max(dist[n] - 1, 0) << endl;
}
扫一扫
705
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
