poj1932 XYZZY (Bellman-Ford + Floyd! 经典！)

不得不说：本题很经典，用到了单元最短路径中的两个主要算法：Bellman-Ford + Floyd，只差Dijkstra、还有什么差分约束了。应该再好好消化巩固。

不得不看：1、http://zh.wikipedia.org/wiki/Bellman-Ford算法

　　　　　　2、http://www.nocow.cn/index.php/Bellman-Ford%E7%AE%97%E6%B3%95

　　　　　　3、http://www.nocow.cn/index.php/SPFA

题　意：一人开始有能量100，有n个房间，走到每个房间都能够增加或减少一定的能量（若该房间所存为负则减少，反　　　　　　　　之），若在途中能量耗尽（<=0）,则hopeless，反之winnable。

思　路：

　　　一、通过floyd传递闭包，求证是否存在原点到终点的一条路径，若无，直接hopeless；

　　　二、Bllman-Ford算法，这个算法原本是用来求有负权边的情况下图的最短路径（负环），本题可以稍微改下，求正　　　　　　　环。分情况：1、若存在若在求松弛过程中，已经能够到达终点，winnable；2、若存在正环，winnable，反之　　　　　　　hopeless。

学习点：Bellman-Ford + Floyd

注意点：在Floyd后，可以去掉不能够到达终点的点，即去除无效分支。

源代码：

#include <stdio.h> #define SIZE 101 #define INF -10001 typedef struct { int nFrom; int nTo; int nWeight; }sNode; sNode nE[SIZE * SIZE]; int nNum, nFlag; int nT[SIZE][SIZE], nMap[SIZE][SIZE]; int nCost[SIZE * SIZE], nDis[SIZE * SIZE], validNum; void funcInit(); void funcInput(); void funcSolve(); void funcOutput(); void transitiveClosure(); /*floyd判断是否存在从s到e的路径*/ void procSelect(); /*取出能够达到终点的点，也可以说是排除无关分支*/ void bellmanFord(); /*改变的bellmanFord算法（负环到正环）*/ int main() { while (1 == scanf("%d", &nNum)) { if (nNum == -1) break; funcInit(); funcInput(); funcSolve(); funcOutput(); } return 0; } void funcInit() { int i, j; nFlag = 0; for (i = 0; i <= nNum; ++i) { for (j = 0; j <= nNum; ++j) { nMap[i][j] = 0; if (i == j) { nT[i][j] = 1; continue; } nT[i][j] = 0; } } } void funcInput() { int i, j; int nPathNum, nTo; for (i = 1; i <= nNum; ++i) { scanf("%d %d", &nCost[i], &nPathNum); for (j = 1; j <= nPathNum; ++j) { scanf("%d", &nTo); nMap[i][nTo] = 1; nT[i][nTo] = 1; } } } void funcSolve() { transitiveClosure(); /*floyd判断是否存在从s到e的路径*/ if (!nT[1][nNum]) return; procSelect();/*取出能够达到终点的点，也可以说是排除无关分支*/ bellmanFord(); } void funcOutput() { printf("%s/n", nFlag ? "winnable" : "hopeless"); } void transitiveClosure() { int i, j, k; for (k = 1; k <= nNum; ++k) { for (i = 1; i <= nNum; ++i) { for (j = 1; j <= nNum; ++j) { nT[i][j] |= (nT[i][k] && nT[k][j]); } } } } void procSelect() { int i, j; validNum = 0; for (i = 1; i <= nNum; ++i) { for (j = 1; j <= nNum; ++j) { if (nMap[i][j] && nT[j][nNum]) { ++validNum; nE[validNum].nFrom = i; nE[validNum].nTo = j; nE[validNum].nWeight = nCost[j]; } } } } void bellmanFord() { int i, j; int nF, nT, nW, tmp; nDis[1] = 100; for (i = 2; i <= nNum; ++i) { nDis[i] = INF; } for (i = 1; i < nNum; ++i) { for (j = 1; j <= validNum; ++j) { nF = nE[j].nFrom; nT = nE[j].nTo; nW = nE[j].nWeight; tmp = nDis[nF] + nW; if (tmp > nDis[nT] && tmp > 0) { nDis[nT] = tmp; if (nDis[nNum] > 0) /*若存在负环，判断是否连通终点*/ { nFlag = 1; return; } } } } for (i = 1; i < validNum; ++i) { nF = nE[i].nFrom; nT = nE[i].nTo; nW = nE[i].nWeight; tmp = nDis[nF] + nW; if (tmp > nDis[nT] && tmp > 0) { nFlag = 1; break; } } }