POJ 1125 Stockbroker Grapevine (求两点间最短路径)

由于Floyd-Warshall算法采用了DP，所以这道题被大家一致归类为DP的问题。
这里题目的翻译。需要注意的是输入，如：
3
2 2 4 3 5
2 1 2 3 6
2 1 2 2 2
表示3个点的图，接下来每一行的行号代表一个点，如第一行 2 2 4 3 5 表示编号为 1（行号）的点出去有 2（第一个数字）条边，分别为指向2号边且长度为4，指向3号边且长度为5。再如：
5
3 4 4 2 8 5 3
1 5 8
4 1 6 4 10 2 7 5 2
0
2 2 5 1 5
这里倒数第2行为0，说明编号为4（行号）的点没有从自己出去的边。
另外如果不是连通图，输出“disjoint”。
最显然的两点间最短路径问题，Floyd-Warshall 算法时间复杂度o(n^3)。交上去0MS过的，可能是OJ的测试数据不是很大。找出任意两点间最短距离后，如果存在某点 i 和某点 j， i 到 j 和 j 到 i 的距离都是无穷大，则是非连通图。再扫描全部点，这点到其他点的距离中最长的，就是从这点出发点最少时间sum；所有点扫完后，所有sum中的最短时间则是所求。我的代码如下：

1: #include <iostream>

2: #include <cstdlib>

3: using namespace std;

4: const int MAX_INT = (1<<15);

5: 

6: class Stockbrokers

7: {

8: public:

9:     Stockbrokers(int** graph, const int vSize);

10:     ~Stockbrokers();

11:     void floyd();

12:     void getMinTime();

13: private:

14:     int** g;

15:     int size;

16: };

17: 

18: Stockbrokers::Stockbrokers(int** graph, const int vSize)

19: {

20:     size = vSize;

21:     if (size==0)

22:         exit(-1);

23:     g = graph;

24: }

25: Stockbrokers::~Stockbrokers()

26: {

27:

28: }

29: void Stockbrokers::floyd()

30: {

31:     for (int k=1; k<size; k++)

32:     {

33:         for (int i=1; i<size; i++)

34:         {

35:             for (int j=1; j<size; j++)

36:             {

37:                 if (g[i][k]>=MAX_INT || g[k][j]>=MAX_INT)

38:                     continue;

39:                 int temp = g[i][k] + g[k][j];

40:                 g[i][j] = g[i][j]<temp ? g[i][j] : temp;

41:             }

42:         }

43:     }

44: }

45: 

46: void Stockbrokers::getMinTime()

47: {

48:     int minTime = MAX_INT,  pos=1;

49:     for (int from=1; from<size; from++)

50:     {

51:         int sum=0;

52:         for (int to=1; to<size; to++)

53:         {

54:             if (g[from][to]>=MAX_INT)

55:             {

56:                 sum = MAX_INT;

57:                 if (g[to][from]>=MAX_INT)

58:                 {

59:                     cout << "disjoint" << endl;

60:                     return;

61:                 }

62:                 break;

63:             }

64:             if (sum<g[from][to])

65:             {

66:                 sum = g[from][to];

67:             }

68:         }

69:         if (minTime>sum)

70:         {

71:             minTime = sum;

72:             pos = from;

73:         }

74:     }

75:     cout << pos << ' ' << minTime << endl;

76: }

77: 

78: int main()

79: {

80:     int size=0;

81:     while(cin>>size && size!=0)

82:     {

83:         size++;

84:         int** graph;

85:         graph = new int*[size];

86:         graph[0] = new int[size*size];

87:         for (int i=1; i<size; i++)

88:         {

89:             graph[i] = graph[i-1] + size;

90:         }

91:         for (int i=1; i<size; i++)

92:         {

93:             for (int j=1; j<size; j++)

94:             {

95:                 if (i==j)    graph[i][j] = 0;

96:                 else        graph[i][j] = MAX_INT;

97:             }

98:

99:             int pair=0;

100:             cin >> pair;

101:             while(pair--)

102:             {

103:                 int vertex, val;

104:                 cin >> vertex >> val;

105:                 if (vertex>=size || (val<1 || val>10))

106:                     exit(-1);

107:                 else

108:                     graph[i][vertex] = val;

109:             }

110:         }

111:

112:         Stockbrokers s(graph, size);

113:         s.floyd();

114:         s.getMinTime();

115:

116:         delete[] graph[0];

117:         delete[] graph;

118:     }

119:     return 0;

120: }