6. Five shortest paths for applications that link C ++ charts (1)

I will introduce the basic storage methods, DFS and BFS, undirected graphs, Minimum Spanning Tree, shortest path, and active network (AOV and AOE) in detail.C ++Graph application. We have already introduced basic storage methods, DFS and BFS, undirected graphs, and minimum spanning tree. Today we will introduce the shortestPath.

Shortest Path

The shortest path may be the most eye-catching algorithm in the graph. You may have tried finding the shortest path on the map. Next we will use computers to fulfill our previous "aspirations ".

An interesting phenomenon in graph algorithms is that the larger the problem is, the simpler the algorithm is. A graph is a complex structure. For a specific problem, the result of solving a specific vertex will be affected by other vertices. It is better to solve the state of a specific sphere than a heap of a collision sphere, the status of other sphere must be considered. Since each vertex needs to be scanned, if we solve all the vertices, then the algorithm is very simple-nothing more than traversing. However, when we reduce the scale of the problem, it is natural that we want the scale of the algorithm to also decrease-if not, isn't it a cool-killing tool? However, because of the complexity of the graph, this reduction is not easy to achieve. Therefore, in order to reduce the size of the algorithm, the algorithm becomes complicated.

In the following introduction, we have clearly confirmed the above conclusion. The human cognitive process is from simple to complex. Although the surface looks like, it is complicated to find the shortest path between each pair of vertices to set the vertex to the shortest path between other vertices. However, as mentioned above, in essence, the former is simpler. The following section does not take into account the historical factors (that is, the algorithm first), or the actual ideas of the algorithm author (who has referenced or who has not referenced ), I will only elaborate on the relationship between algorithms. If any omission occurs, please forgive me.

Preparations

All the way down, the graph class is already very "bloated". To better illustrate the problem, we need to "restart the stove and open another one", and also to separate algorithms from storage methods, to facilitate reuse.

First, you must add several interfaces to the basic graph class.

 
 

  
  
template <class name, class dist, class mem>  
  
  
class Network  
  
  
{  
  
  
public:  
  
  
int find(const name& v) { int n; if (!data.find(v, n)) return -1; return n; }  
  
  
dist& getE(int m, int n) { return data.getE(m, n); }  
  
  
const dist& NoEdge() { return data.NoEdge; }  
  
  
};  
  
  
template <class name, class dist>  
  
  
class AdjMatrix  
  
  
{  
  
  
public:  
  
  
dist& getE(int m, int n) { return edge[m][n]; }  
  
  
};  
  
  
template <class name, class dist>  
  
  
class Link  
  
  
{  
  
  
public:  
  
  
dist& getE(int m, int n)  
  
  
{  
  
  
for (list  ::iterator iter = vertices[m].e->begin();   
  
  
iter != vertices[m].e->end() && iter->vID < n; iter++);  
  
  
if (iter == vertices[m].e->end()) return NoEdge;  
  
  
if (iter->vID == n) return iter->cost;  
  
  
return NoEdge;  
  
  
}  
  
  
}; 
 
 

Then the "algorithm class" is customized for the shortest path algorithm ". When finding the shortest path of a graph, bind the graph to the algorithm. For example:

 
 

  
  
Network <Char,Int, Link <Char,Int> A (100 );
  
  
// Insert vertex, edge ...... 
  
  
Weight <Char,Int, Link <Char,Int> B (& );
  
  
 
  
  
# Include "Network. h" 
  
  
Template<ClassName,ClassDist,ClassMem>
  
  
ClassWeight
  
  
{
  
  
Public:
  
  
Weight (Network  * G): G (G), all ( False), N (G-> vNum ())
  
  
{
  
  
Length =NewDist * [N]; path =New Int* [N];
  
  
Shortest =New Bool[N];IntI, j;
  
  
For(I = 0; I <N; I ++)
  
  
{
  
  
Length [I] =NewDist [N]; path [I] =New Int[N];
  
  
}
  
  
For(I = 0; I <N; I ++)
  
  
{
  
  
Shortest [I] =False;
  
  
For(J = 0; j <N; j ++)
  
  
{
  
  
Length [I] [j] = G-> getE (I, j );
  
  
If(Length [I] [j]! = G-> NoEdge () path [I] [j] = I;
  
  
ElsePath [I] [j] =-1;
  
  
}
  
  
}
  
  
}
  
  
~ Weight ()
  
  
{
  
  
For(IntI = 0; I <N; I ++ ){Delete[] Length [I];Delete[] Path [I];}
  
  
Delete[] Length;Delete[] Path;Delete[] Shortest;
  
  
}
  
  
Private:
  
  
VoidPrint (IntI,IntJ)
  
  
{
  
  
If(Path [I] [j] =-1) cout <"No Path"<Endl;Return;
  
  
Cout <"Shortest Path :"; Out (I, j); cout <G-> getV (j) <endl;
  
  
Cout <"Path Length :"<Length [I] [j] <endl;
  
  
}
  
  
VoidOut (IntI,IntJ)
  
  
{
  
  
If(Path [I] [j]! = I) out (I, path [I] [j]);
  
  
Cout <G-> getV (path [I] [j]) <"->";
  
  
}
  
  
Dist ** length;Int** Path;Bool* Shortest;BoolAll;IntN;
  
  
Network  * G; 
  
  
};
 
 

It is good to find that the constructor is used. The initialization of the algorithm result array is separated from the algorithm itself. As a result, the basic steps of the algorithm are easy to understand.