自己是真的笨
整整用了10个小时才吃透这个BF的两种优化
题目如下:
问题描述 给定一个n个顶点，m条边的有向图（其中某些边权可能为负，但保证没有负环）。请你计算从1号点到其他点的最短路（顶点从1到n编号）。 输入格式 第一行两个整数n, m。 接下来的m行，每行有三个整数u, v, l，表示u到v有一条长度为l的边。 输出格式 共n-1行，第i行表示1号点到i+1号点的最短路。 样例输入 3 3 1 2 -1 2 3 -1 3 1 2 样例输出 -1 -2 数据规模与约定 对于10%的数据，n = 2，m = 2。 对于30%的数据，n <= 5，m <= 10。 对于100%的数据，1 <= n <= 20000，1 <= m <= 200000，-10000 <= l <= 10000，保证从任意顶点都能到达其他所有顶点。
很简单的题,就是测试数据n居然有20000;
那么需要考虑的问题就有两个了,一是时间复杂度,二是空间复杂度
一开始上手我用的是floyd
代码如下:
#include <iostream> #define max 2001 #define inf 99999 using namespace std; int a[max][max]={0}; //邻接矩阵储存图的信息 int main() { int m,n,u,v,l; cin>>n>>m; for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) a[i][j]=inf; for(int i=1;i<=m;i++) { cin>>u>>v>>l; a[u][v]=l; } for(int k=1;k<=n;k++) //floyd主体 for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) if(a[i][j]>a[i][k]+a[k][j]) a[i][j]=a[i][k]+a[k][j]; for(int i=2;i<=n;i++) cout<<a[1][i]<<endl; return 0; }
过了50%的数据,意料之中,两个问题都犯了
o(n^3)的时间复杂度 20000是不可能的
二维数组开到20000也是不可能的,内存超出限制,oj显示编译错误
然后我用了BF,用了一个结构体数组来储存点与点之间的路径
class road{ public: int start; //起始点 int target; //终点 int distance;//距离 }; road roadque[max];
n个点需要n-1遍 每遍枚举每一条边 时间复杂度o(nm)
for(int k=1;k<=n-1;k++) //进行n-1次松弛 for(int i=1;i<=m;i++) //枚举每一条边 if(dis[roadque[i].target]>dis[roadque[i].start]+dis[roadque[i].distance])//尝试松弛每一条边 dis[roadque[i].target]=dis[roadque[i].start]+dis[roadque[i].distance];
按题中的数据的话是40亿次运算,emmmmm,TLE,GG
然后我去学了SPFA
队列优化了一遍,代码如下:
#include <iostream> #include <cstdio> #include <cstring> #include <queue> using namespace std; const int N = 20001; const int INF = 99999999;//理解成正无穷 int map[N][N], dist[N]; //map邻接矩阵,dis当前点到其他点的距离数组 bool book[N]; //判断是否已经在队列中 int n, m; void init() {//初始化 int i, j; for (i = 1; i <= N; i++) for (j = 1; j <= N; j++) { if (i == j) map[i][j] = 0; else map[i][j] = INF; } } void spfa(int start) { queue<int> Q; int i, now; memset(book, false, sizeof(book)); for (i = 1; i <= n; i++) dist[i] = INF; dist[start] = 0; //到自己的距离为0 Q.push(start); //把自己加入到队列中 book[start] = true;//不可以入队 while (!Q.empty()) { now = Q.front(); Q.pop(); book[now] = false; for (i = 1; i <= n; i++) if (dist[i] > dist[now] + map[now][i]) { dist[i] = dist[now] + map[now][i]; if (book[i] == 0) { Q.push(i); //如果松弛成功且当前点不在队列中,则加入到队列中 book[i] = true;//置为不可以入队状态 } } } } int main() { scanf("%d%d", &n, &m); init(); for (int i = 0; i < m; i++) { int a, b, c; scanf("%d%d%d", &a, &b, &c); if (map[a][b] > c) map[a][b] = c; } spfa(1); for (int i = 1; i <= n; i++) cout << dist[i] << endl; return 0; }
时间复杂度看西交大的论文里说大概是o(km) k一般为1-2
emmmmmm,1-2吗?我信了你的邪,这个图m有20w
平均一下20w/2w 差不多每个点进去10次吧 k≈10
吐血 不过还好,不是最坏的时间复杂度
嗯,那么到这里超时的问题就解决了
但是!
邻接矩阵要开到2w明显不可能
所以又一次编译错误,
然后我去学了邻接表
数组方法的邻接表太巧妙了,老实人用不了,溜了
这里使用stl里的list来实现邻接表
对于这样的数据
4 5
1 4 94 3 81 2 52 4 61 3 7这是示意图
#include <iostream> #include <list> #include <queue> #include <cstring> #define max 20001 const int inf = 1<<29; int sfpa(int v0); using namespace std; class road { public: int target; int distance; }; list<road> roadlist[max]; //邻接表 int dis[max]; //距离数组 int n, m; int main() { cin >> n >> m; int a, b, c; for (int i = 0; i<m; i++)//录入邻接表 { cin >> a >> b >> c; road ex; ex.target = b; ex.distance = c; roadlist[a].push_front(ex); } sfpa(1); for (int i = 2; i <= n; i++) cout << dis[i] << endl; return 0; } int sfpa(int v0) { queue<int> que; int book[max]; //判断是否在队列中 memset(book, 0, sizeof(book)); for (int i = 1; i <= n; i++)//初始化 dis[i] = inf; dis[v0] = 0; que.push(v0); book[v0] = 1; while (!que.empty()) { int now = que.front(); que.pop(); book[now] = 0; list<road>::iterator it = roadlist[now].begin(); for (it; it != roadlist[now].end(); it++)//遍历领接表 { if (dis[it->target] > dis[now] + (it->distance)) { dis[it->target] = dis[now] + (it->distance);//更新距离 if (book[it->target] == 0)//如果松弛成功且不在队列中,则把该点加入队列 { que.push(it->target); book[it->target] = 1; } } } } return 0; }
需要注意的是,只有松弛成功才允许把点加到队列中
到了这里终于ac了
= =呼
不知道为啥,用spfa总觉得不安心
dijkstra又解决不了负权边
希望蓝桥杯没有卡spfa的题
卡spfa真的丧心病狂!
