ACM/ICPC 之 最短路径-Bellman Ford范例(POJ1556-POJ2240)

　　两道Bellman Ford解最短路的范例，Bellman Ford只是一种最短路的方法，两道都可以用dijkstra, SPFA做。

　　Bellman Ford解法是将每条边遍历一次，遍历一次所有边可以求得一点到任意一点经过一条边的最短路，遍历两次可以求得一点到任意一点经过两条边的最短路...如 此反复，当遍历m次所有边后，则可以求得一点到任意一点经过m条边后的最短路（有点类似离散数学中邻接矩阵的连通性判定）

---

POJ1556-The Doors

　　初学就先看POJ2240吧

　　题意：求从(0,5)到(10,5)的最短折线距离，中间会给最多十八道墙。

　　题解：本题设计简单的计算几何知识和最短路的知识，读完题后要将墙的端点看做一个坐标，先求出所有的可行边，然后做一次最短路就可以了

 //门
 //POJ1556-ZOJ1721
 //简单几何+最短路
 //Time:0Ms    Memory:204K
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 #define INF 0x7f7f7f7f
 #define MAX 20*5
 #define POW2(x) ((x)*(x))
 #define DIS(i,j) sqrt(POW2(i.x - j.x) + POW2(i.y - j.y))
 #define P(i,j) (4*i+j)    //第i组第j个点的序列号
 struct Point {
     double x, y;
 }p[MAX];
 struct Edge {
     int u, v;
     double d;
 }e[MAX*MAX];
 int n, m;
 double d[MAX];
 int en;    //edge_num
 //判断两点是否能在maxn组点内连通
 bool access(Point p1, Point p2, int maxn)
 {
     for (int i = ; i < maxn; i++)
         if (p[P(i, )].x > p1.x && p[P(i, )].x < p2.x)    //该组点在两点之间
         {
             //算出线段在该横坐标下的纵坐标
             double y = (p1.y - p2.y) / (p2.x - p1.x) * (p2.x - p[P(i, )].x) + p2.y;
             if (y > p[P(i, )].y || y < p[P(i, )].y || (y > p[P(i, )].y && y < p[P(i, )].y))    //相交
                 return false;
         }
     return true;
 }
 //记录x组第y个点作为终点的线段
 void add(int x, int y)
 {
     for (int k = ; k <=  * x; k++)
         if (access(p[k], p[P(x, y)], x)) {
             e[en].u = k;
             e[en].v = P(x, y);
             e[en++].d = DIS(p[e[en].u], p[e[en].v]);
         }
 }
 void bellman_ford(int x)
 {
     memset(d, INF, sizeof(d));
     d[] = ;
     for (int i = ; i <= n; i++)    //扩展n+1次
         for (int j = ; j < en; j++)    //遍历每条边
             d[e[j].v] = min(d[e[j].u] + e[j].d, d[e[j].v]);
 }
 int main()
 {
     //起点
     p[].x = ;
     p[].y = ;
     while (scanf("%d", &n), n != -)
     {
         en = ;    //Init
         double x, y;
         for (int i = ; i < n; i++)
         {
             scanf("%lf", &x);
             for (int j = ; j <= ; j++)
             {
                 scanf("%lf", &y);
                 p[P(i,j)].x = x;
                 p[P(i,j)].y = y;
                 add(i, j);
             }
         }
         //终点
         p[P(n, )].x = ;
         p[P(n, )].y = ;
         add(n, );

         bellman_ford();
         printf("%.2f\n", d[P(n, )]);
     }

     return ;
 }

---

POJ2240-Arbitrage

　　题意：从一种货币A经过多次转换后可以得到更多的货币A，则称为套汇，求给定货币转换语句，判断是否存在套汇。

　　题解：将货币看做结点，转换比率看做路长（乘积关系），建立一个图模型就可以知道实际上是在求是否存在最长路的路长超过1。

 //套汇
 //POJ2240-ZOJ1092
 //求最长路（乘积） - 回路 路长 > 1 则为套汇
 //Time:63Ms    Memory:200K
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<algorithm>
 using namespace std;
 #define MAX 32
 #define MAXS 20
 struct Edge {
     int u, v;
     double d;
 }e[MAX*MAX];
 int n, m;
 char city[MAX][MAXS];
 double d[MAX];    //到某一点的最长路
 int find(char s[MAXS])
 {
     for (int i = ; i < n;i++)
         if (!strcmp(s, city[i]))    return i;
     return -;
 }
 //是否套汇
 bool bellman_ford(int x)
 {
     memset(d, , sizeof(d));
     d[x] = ;
     for (int i = ; i <= n; i++)    //最多经过n条边回到x(若更多次变更也只能是套汇)
         for (int j = ; j < m; j++)
         {
             d[e[j].v] = max(d[e[j].u] * e[j].d, d[e[j].v]);
             if (d[x] > ) return true;
         }
     return false;
 }
 int main()
 {
     int cas = ;
     while (scanf("%d", &n), n)
     {
         for (int i = ; i < n; i++)
             scanf("%s", city[i]);
         scanf("%d", &m);
         for (int i = ; i < m; i++)
         {
             char s1[MAXS], s2[MAXS];
             double dis;
             scanf("%s%lf%s", s1, &dis, s2);
             e[i].u = find(s1);
             e[i].v = find(s2);
             e[i].d = dis;
         }

         bool flag = false;
         for (int i = ; i < n; i++)
         {
             if (bellman_ford(i)) {
                 flag = true;
                 break;
             }
         }
         if (flag == true)
             printf("Case %d: Yes\n", cas++);
         else printf("Case %d: No\n", cas++);
     }
     return ;
 }