邻接矩阵实现Dijkstra算法以及BFS与DFS算法

//============================================================================
// Name        : MatrixUDG.cpp
// Author      : fffff
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include<iostream>
#include<cstdlib>
#include<queue>
#define maxsize 100
#define far 10000
using namespace std;
class MatrixUDG{
public:
    char mVerxs[maxsize];
    int mVerNum;
    int mEdgeNum;
public:
    int mMatrix[maxsize][maxsize];
    MatrixUDG();
    MatrixUDG(char vexs[],int vlen,char edge[][],int elen);
    ~MatrixUDG();
    void print();
    int getPosition(char ch);
    char getChar(int place);
    char readChar();
};
MatrixUDG::MatrixUDG(char vexs[],int vlen,char edge[][],int elen){
    this->mVerNum = vlen;
    this->mEdgeNum = elen;
    for(int i=;i<mVerNum;i++)
        for(int j=;j<mVerNum;j++)
            mMatrix[i][j] = far;
    for(int i=;i<mVerNum;i++){
        mVerxs[i] = vexs[i];
    }
    for(int i=;i<mEdgeNum;i++){
        int start = getPosition(edge[i][]);
        int end = getPosition(edge[i][]);
        int weight;
        cout<<"input weight of ("<<edge[i][]<<","<<edge[i][]<<") : ";
        cin>>weight;
        mMatrix[start][end]=weight;
        mMatrix[end][start]=weight;
    }
};
MatrixUDG::MatrixUDG(){
    cout<<"input num of verx and edge:";
    cin>>mVerNum>>mEdgeNum;
    cout<<"input verxs:";
    for(int i=;i<mVerNum;i++){
        mVerxs[i] = readChar();
    }
    for(int i=;i<mEdgeNum;i++){
        cout<<"edge("<<i<<") : ";
        char startChar = readChar();
        char endChar = readChar();
        int start = getPosition(startChar);
        int end = getPosition(endChar);
        int weight;
        cout<<"input weight of ("<<startChar<<","<<endChar<<") : ";
        cin>>weight;
        mMatrix[start][end]=weight;
        mMatrix[end][start]=weight;
    }
};
MatrixUDG::~MatrixUDG(){

};
void MatrixUDG::print(){
    for(int i=;i<mVerNum;i++){
        for(int j=;j<mVerNum;j++){
            cout<<mMatrix[i][j]<<" ";
        }
        cout<<endl;
    }
}
int MatrixUDG::getPosition(char ch){
    for(int i=;i<mVerNum;i++){
        if(mVerxs[i]==ch)
            return i;
    }
    return -;
};
char MatrixUDG::getChar(int place){
    return mVerxs[place];
};
char MatrixUDG::readChar(){
    char cha;
    cin>>cha;
    while(!((cha>='a'&&cha<='z')||(cha>='A'&&cha<='Z')))
        cin>>cha;
    return cha;
};
void Dijkstra(int n,int v,int *dist,int *pre,int weight[][maxsize]){
    /*
     * 第一步:初始化s[n],dist,pre
     */
    bool s[n];
    for(int i=;i<n;i++){
        dist[i] = weight[v][i];
        s[i] = false;
        if(dist[i]==far)
            pre[i] = -;
        else
            pre[i] = v;
    }
    s[v] = true;
    dist[v] = ;
    /*
     * 第二步:寻找出dist最小的顶点加入到s中
     */
    for(int i=;i<n;i++){
        int temp = far;
        int u = v;
        for(int j=;j<n;j++){
            if(!s[j]&&dist[j]<temp){
                temp = dist[j];
                u = j;
            }
        }
        s[u] = true;
        /*
         * 第三步:更新dist
         */
        for(int j=;j<n;j++){
            if(!s[j]&&weight[u][j]<far){
                int newdist = dist[u]+weight[u][j];
                if(newdist<dist[j]){
                    dist[j] = newdist;
                    pre[j] = u;
                }
            }
        }
    }

}
void printTrace(MatrixUDG*PG,int *pre,int v,int u){
    int start = v;
    int end = u;
    char cha;
    while(end!=start){
        cha = PG->getChar(end);
        cout<<cha<<"<--";
        end = pre[end];
    }
    cout<<PG->getChar(start)<<endl;

}
bool visited[maxsize];
void Dfsk(MatrixUDG *PG,int k){
    visited[k] = true;
    cout<<PG->getChar(k)<<" ";
    for(int i=;i<PG->mVerNum;i++)
        if(PG->mMatrix[k][i]!=far&&visited[i]==false)
            Dfsk(PG,i);
}
void Dfs(MatrixUDG *PG){
    for(int i=;i<PG->mVerNum;i++)
        if(!visited[i])
            Dfsk(PG,i);
    cout<<endl;
}
void Bfs(MatrixUDG *PG){
    queue<int>que;
    que.push();
    int place;
    while(!que.empty()){
        place = que.front();
        que.pop();
        visited[place] = true;
        cout<<PG->getChar(place)<<" ";
        for(int i=;i<PG->mVerNum;i++){
            if(PG->mMatrix[place][i]!=far&&visited[i]==false){
                que.push(i);
                /*
                 * 开始时掉了visited[i] = true;导致出错
                 * 因为有可能在队列中的顶点还没有出来,在后面再一次的进入队列
                 * 因此必须在进入队列后将其设为已访问来防止再次进入而导致的重复访问
                 */
                visited[i] = true;
            }
        }
    }
}
int main(){
    char verx[] = {'A','B','C','D','E','F','G'};
    char edge[][] = {
            {'A','C'},
            {'A','E'},
            {'B','D'},
            {'B','E'},
            {'B','G'},
            {'C','F'},
            {'D','F'},
            {'E','G'},
            {'F','G'}
                    };
    int vlen = sizeof(verx)/sizeof(verx[]);
    int elen = sizeof(edge)/sizeof(edge[]);
    MatrixUDG *PG = new MatrixUDG(verx,vlen,edge,elen);
    int dist[vlen];
    int pre[vlen];
    int startVex =;
    Dijkstra(vlen,startVex,dist,pre,PG->mMatrix);
    PG->print();
    printTrace(PG,pre,,);
    for(int i=;i<maxsize;i++){
        visited[i] = false;
    }
    Dfs(PG);
    for(int i=;i<maxsize;i++){
        visited[i] = false;
    }
    Bfs(PG);
    return ;

}