HDU 2962 Trucking 三种解法。

640 MS

8280 KB

#include <iostream> #include <cstring> #include <cstdio> #include <queue> using namespace std; #define MAXN 1010 #define INF 0x3fffffff int map[MAXN][MAXN]; int h[MAXN][MAXN]; int dis[MAXN]; bool hash[MAXN]; struct Dij { int id; int dis; bool friend operator < (const Dij a, const Dij b) { return a.dis > b.dis; } }; Dij now, next; int Bfs(int st, int ed, int n, int mid) { memset(hash, false, sizeof(hash)); for (int i = 1; i <= n; i++) { dis[i] = INF; } priority_queue<Dij> Q; now.id = st; now.dis = 0; dis[st] = 0; Q.push(now); while (!Q.empty()) { now = Q.top(); Q.pop(); if (hash[now.id]) { continue; } if (now.id == ed) { return now.dis; } hash[now.id] = true; for (int j = 1; j <= n; j++) { if (!hash[j] && (h[now.id][j] >= mid || h[now.id][j] == -1) && dis[j] > dis[now.id] + map[now.id][j]) { dis[j] = dis[now.id] + map[now.id][j]; next.id = j; next.dis = dis[j]; Q.push(next); } } } return -1; } void Init(int n) { memset(h, -1, sizeof(h)); for (int i = 1; i <= n; i++) { map[i][i] = 0; for (int j = i + 1; j <= n; j++) { map[i][j] = map[j][i] = INF; } } } int main() { int test = 1; int n, m, s, e, i, j, safe, a, b, c, w; while (scanf("%d %d", &n, &m) != EOF) { if (n == 0 && m == 0) { break; } if (test != 1) { puts(""); } Init(n); for (i = 0; i < m; i++) { scanf("%d %d %d %d", &a, &b, &c, &w); h[a][b] = h[b][a] = c; map[a][b] = map[b][a] = w; } scanf("%d %d %d", &s, &e, &safe); int low = 0; int high = safe; int mid; int ans = -1, hi; while(low <= high) { mid = (low + high) / 2; int tmp = Bfs(s, e, n, mid); if(tmp != -1) {//可通，则往高度增加的方向，看更大的高度是否可通 low = mid + 1; hi = mid; ans = dis[e]; } else {//不通，则说明高度太大，往高度低的方向找，降低上限 high = mid - 1; } } printf("Case %d:/n", test++); if (ans == -1) { printf("cannot reach destination/n"); } else { printf("maximum height = %d/nlength of shortest route = %d/n", hi, ans); } } return 0; }

采用的第二种算法是，两次最短路，去年比赛的时候还不会二分，就在那里想改Dijkstra来求最小高度的最大值。

比赛时高度和距离放一个Dijkstra里更新，错的，呵呵，赛后改用两次最短路最朴素的Dijkstra跑了500ms。

Dijkstra是贪心的策略，稍微想一下，就可以发现采用贪心同样可以求得路径上最小高度的最大值。

像一般的Dijkstra一样更新，只是更新的dis保存最小高度的当前最大值。每次找的是更新得到的最小高度里的最大值（确定其为最大）...

pass:

因为一条路径st->v0->v1->...->vn。

从st 到当前点 vi 的最小高度的值总是越往后越小的。

所以每次从更新的点里找一个最小高度里最大的点，因为 current（最大） >= else >= 所有的从（else->j）else出发更新的值。

所以就可以确定当前取得的就是最大的。

其实Dijkstra本质上就是广搜。现在习惯了用priority_queue来写。

下面是邻接阵的。

00445409

2010-07-02 20:29:30

Accepted

359 MS

8248 KB

#include <iostream> #include <cstring> #include <cstdio> #include <queue> using namespace std; #define INF 0x3fffffff #define MAXN 1010 int map[MAXN][MAXN]; int h[MAXN][MAXN]; int dis[MAXN]; bool hash[MAXN]; struct Hight { int id; int dis; bool friend operator < (const Hight a, const Hight b) { return a.dis < b.dis; } }; Hight now, next; inline int min(const int a, const int b) { return (a > b ? b : a); } inline int Bfs_hight(int st, int ed, int n) { memset(hash, false, sizeof(hash)); memset(dis, -1, sizeof(dis)); priority_queue<Hight> Q; now.id = st; now.dis = INF; dis[st] = INF; Q.push(now); while (!Q.empty()) { now = Q.top(); Q.pop(); if (hash[now.id]) { continue; } if (now.id == ed) { return now.dis; } hash[now.id] = true; for (int j = 1; j <= n; j++) { int now_h = min(dis[now.id], h[now.id][j]); if (!hash[j] && now_h > dis[j]) {//不通 now_h = -2 < -1 dis[j] = now_h; next.id = j; next.dis = dis[j]; Q.push(next); } } } return -1; } inline void Init(int n) { for (int i = 1; i <= n; i++) { map[i][i] = 0; h[i][i] = INF; for (int j = i + 1; j <= n; j++) { map[i][j] = map[j][i] = INF; h[i][j] = h[j][i] = -2; } } } struct Dij { int id; int dis; bool friend operator < (const Dij a, const Dij b) { return a.dis > b.dis; } }; Dij now2, next2; int Bfs_road(int st, int ed, int n, int safe) { memset(hash, false, sizeof(hash)); for (int i = 1; i <= n; i++) { dis[i] = INF; } priority_queue<Dij> Q; now2.id = st; now2.dis = 0; dis[st] = 0; Q.push(now2); while (!Q.empty()) { now2 = Q.top(); Q.pop(); if (hash[now2.id]) { continue; } if (now2.id == ed) { return now2.dis; } hash[now2.id] = true; for (int j = 1; j <= n; j++) { if (!hash[j] && h[now2.id][j] >= safe && dis[j] > dis[now2.id] + map[now2.id][j]) { dis[j] = dis[now2.id] + map[now2.id][j]; next2.id = j; next2.dis = dis[j]; Q.push(next2); } } } return -1; } int main() { int s, e, safe, test = 1; int n, m, i, j, a, b, c, w, ans, sh; while (scanf("%d %d", &n, &m) != EOF) { if (n == 0 && m == 0) { break; } if (test != 1) { puts(""); } Init(n); for (i = 0; i < m; i++) { scanf("%d %d %d %d", &a, &b, &c, &w); if (c == -1) { h[a][b] = h[b][a] = INF; } else { h[a][b] = h[b][a] = c; } map[a][b] = map[b][a] = w; } scanf("%d %d %d", &s, &e, &safe); printf("Case %d:/n", test++); sh = Bfs_hight(s, e, n); sh = sh > safe ? safe : sh; if (sh == -1) { printf("cannot reach destination/n"); continue; } ans = Bfs_road(s, e, n, sh); if (ans == -1) { printf("cannot reach destination/n"); } else { printf("maximum height = %d/nlength of shortest route = %d/n", sh, ans); } } return 0; }

又用邻接表写了下，快了200多ms。

0445514

2010-07-03 10:11:39

Accepted

140 MS

7956 KB

#include <iostream> #include <cstring> #include <cstdio> #include <queue> using namespace std; #define INF 0x3fffffff #define MAXN 1010 struct Edge {//边 int adj; int weight; int hight; Edge *next; }; Edge *map[MAXN], vex[MAXN];//vex顶点 bool hash[MAXN]; struct Hight { int id; int dis; bool friend operator < (const Hight a, const Hight b) { return a.dis < b.dis; } }; Hight now, next; inline int min(const int a, const int b) { return (a > b ? b : a); } inline void Creat(int a, int b, int w, int h) {//建邻接表与a邻接是b Edge *pa = new Edge; pa->adj = b; pa->hight = h; pa->weight = w; pa->next = NULL; map[a]->next = pa; map[a] = map[a]->next; } inline int Bfs_hight(int st, int ed, int n) { memset(hash, false, sizeof(hash)); priority_queue<Hight> Q; now.id = st; now.dis = INF; Q.push(now); while (!Q.empty()) { now = Q.top(); Q.pop(); if (hash[now.id]) { continue; } if (now.id == ed) { return now.dis; } hash[now.id] = true; Edge *first = vex[now.id].next; for (Edge *j = first; j != NULL; j = j->next) { if (hash[j->adj]) { continue; }//puts("---- "); int now_h = min(now.dis, j->hight); next.id = j->adj; next.dis = now_h; Q.push(next); } //puts(""); } return -1; } struct Dij { int id; int dis; bool friend operator < (const Dij a, const Dij b) { return a.dis > b.dis; } }; Dij now2, next2; inline int Bfs_road(int st, int ed, int n, int safe) { memset(hash, false, sizeof(hash)); priority_queue<Dij> Q; now2.id = st; now2.dis = 0; Q.push(now2); while (!Q.empty()) { now2 = Q.top(); Q.pop(); if (hash[now2.id]) { continue; } if (now2.id == ed) { return now2.dis; } hash[now2.id] = true; Edge *first = vex[now2.id].next; for (Edge *j = first; j != NULL; j = j->next) { if (hash[j->adj] || j->hight < safe) { continue; }//可以加个判断，int now_h = min(dis[now.id], h[now.id][j]); //if (now_h > dis[j])时才更新入队列，不过并没有得到优化，因为判断本身需要时间。 // ... 当now_h <= dis[j]时入列也只是下一次的直接弹出，所以差不多。。。 next2.id = j->adj; next2.dis = now2.dis + j->weight; Q.push(next2); } } return -1; } int main() { int s, e, safe, test = 1; int n, m, i, j, a, b, c, w, ans, sh; while (scanf("%d %d", &n, &m) != EOF) { if (n == 0 && m == 0) { break; } if (test != 1) { puts(""); } for (i = 0; i < MAXN; i++) { map[i] = &vex[i];//初始指向顶点 } for (i = 0; i < m; i++) { scanf("%d %d %d %d", &a, &b, &c, &w); if (c == -1) { Creat(a, b, w, INF); Creat(b, a, w, INF); } else { Creat(a, b, w, c); Creat(b, a, w, c); } } scanf("%d %d %d", &s, &e, &safe); printf("Case %d:/n", test++); sh = Bfs_hight(s, e, n); sh = sh > safe ? safe : sh; if (sh == -1) { printf("cannot reach destination/n"); continue; } ans = Bfs_road(s, e, n, sh); if (ans == -1) { printf("cannot reach destination/n"); } else { printf("maximum height = %d/nlength of shortest route = %d/n", sh, ans); } } return 0; }

算法三：并查+最短路

昨天写了1598 / find the most comfortable road

总算过了，不过算法是从网上看的，在最短路的专题里，一直考虑用最短路，思维定势了，wa无数次，

根本想不到去用并查。

后来继续尝试用最短路--超时了，应该能用最短路做，暂时只会并查的做法，比较直白也相对简单。

早上起来想到Trucking这题也可以用并查的，用并查可以很容易求得最小高度的最大值。

于是又重写了下，跑了203ms，比两次最短路稍微还慢一点，可能是因为边数比较多把。

一条路径上的最小高度，可想而知是使这条路径（st->ed）连通的权值里最小的。

所以我们可以先对边sort（大->小），那么最小高度的最大值即是，在不断加边的过程中第一个使st->ed 连通的高度值。

下面是这题并查+最短路的邻接表实现

00448133

2010-07-06 08:00:32

Accepted

203 MS

7980 KB