图的邻接矩阵法寻找关键路径

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
#include<stack>
#include <bits/stdc++.h>
using namespace std;
typedef int Safe;
typedef int Arrive;
#define OK 1;
#define NO 0;
/*
#define MAXSIZE 100 


typedef struct Graph{
    int vexnumber;
    string vex[MAXSIZE];
    int adjMatrix[MAXSIZE][MAXSIZE];
};
typedef struct ArcNode{
    int to;
    ArcNode *nextarc;
};
typedef struct VexNode{
   int data;
   ArcNode *firstarc=NULL;
};



typedef struct LinkGraph{
    int vexnumber;
    VexNode vex[MAXSIZE];
};

void InitLinkGraph(LinkGraph&G,const Graph &g){
    G.vexnumber=g.vexnumber;
    for(int i=0;i<G.vexnumber;i++){//扫描线性表图的所有节点，每一个节点为i
        for(int j=0;j<g.vexnumber;j++){//寻找此节点的所有边（扫描i号行，每一个列j）
            if(g.adjMatrix[i][j]==1){//如果有边即adjMatrix（ij）==1,则放入点节点的线性表中
                if(G.vex[i].firstarc==NULL){//放入线性表先判断是否为空，为空先建立第一个边节点firstarc
                    G.vex[i].firstarc=new ArcNode;
                    G.vex[i].firstarc->to=j;
     //如果有边权重，G.vex[i].firstarc->weight=adjMartrix[i][j];
                    G.vex[i].firstarc->nextarc=NULL;
                    
                }
                else{//不为空利用头插法，增加点的邻接边节点
                    ArcNode* arcnode=new ArcNode;
                    arcnode->nextarc=G.vex[i].firstarc;
                    arcnode->to=j;
                    //arcnode->weight=adjMartrix[i][j];
                    G.vex[i].firstarc=arcnode;

                }
            }
        }
    }

}
static int DFSvisited[MAXSIZE];
static int BFSvisited[MAXSIZE];
void visit(const Graph g,int v0){
   DFSvisited[v0]=1;
   BFSvisited[v0]=1;
  cout<<g.vex[v0]<<"->";
}

void DFS(const Graph&g,int v0,int DFSvisited[]){
    visit(g,v0);
    for(int l;l<g.vexnumber;l++){
        if(g.adjMatrix[v0][l]==1&&DFSvisited[l]==0){
             DFS(g,l,DFSvisited);
        }
    }



}

void BFS(const Graph&g,int v0,int BFSvisited[]){
   queue<int>queue;
   queue.push(v0);
   while(!queue.empty())
   {  visit(g,v0);
      for(int l;l<g.vexnumber;l++){
          if(g.adjMatrix[queue.front()][l]&&!BFSvisited[l])
           queue.push(l);
         }
      queue.pop();
   }
   

}

void test(){
    int n;
    Graph g;
    cin>>n;
    g.vexnumber=n; 
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            cin>>g.adjMatrix[i][j];
        }
    }
    for(int i=0;i<n;i++){
         cin>>g.vex[i];
    }
    cout<<g.vexnumber<<endl;;
   for(int i=0;i<g.vexnumber;i++){
       for(int j=0;j<g.vexnumber;j++){
           cout<<g.adjMatrix[i][j]<<" ";
       }cout<<endl;
   }
cout<<endl;
for(int i=0;i<g.vexnumber;i++){
  cout<<g.vex[i];
}
cout<<endl;
 for(int i=0;i<g.vexnumber;i++){
     if(DFSvisited[i]==0) DFS(g,i,DFSvisited);
 }
cout<<endl;
for(int i=0;i<g.vexnumber;i++)
BFS(g,i,BFSvisited);



   LinkGraph G;
   InitLinkGraph(G,g);
   

}
int main(){
    freopen("/config/workspace/answer/test","r",stdin);
    test();
    return 0;
}*/




#define MAX_SIZE 100
struct Graph{
    int vexNumber;
    string vexInfo[MAX_SIZE];
    int adjMatrix[MAX_SIZE][MAX_SIZE];
};
//这个用于关键路径的计算
typedef struct e{
  int start;
  int end;
  int weight;
  int time;
}e;


struct ArcNode{
    int weight;
    int adj;
    ArcNode *nextarc;
};
struct VexNode{
    string Info;
    ArcNode* fistarc;
};
struct linkGraph{
   VexNode *vexes;
   int vexnumber;
};

int InitGraph(linkGraph &G,int vexnumber){
    G.vexnumber=vexnumber;
    G.vexes=new VexNode[vexnumber];
    for(int i=0;i<vexnumber;i++){
        G.vexes[i].fistarc=NULL;
    }
    return 0;
}

ArcNode* getArcNode(int adj){
    ArcNode* node=new ArcNode;
    node->adj=adj;
    node->nextarc=NULL;
    return node;
}


void InputlinkGraph(linkGraph&LG){
    int vexnumber;
    cin>>vexnumber;
    InitGraph(LG,vexnumber);
    string Info;
    for(int i=0;i<vexnumber;i++){
       cin>>Info;
       LG.vexes[i].Info=Info[0];
       ArcNode *p=LG.vexes[i].fistarc;
       int j=1;
       while(j<Info.length()){
           if(Info[j]>'a'&&Info[j]<'z'){
               ArcNode *arcnode=getArcNode(Info[j]-'a');        
               if(LG.vexes[i].fistarc==NULL){   
                   LG.vexes[i].fistarc=arcnode;
                   p=arcnode;

                   
               }
               else
               {
                   p->nextarc=arcnode;
                   p=arcnode;
               }
               //头插法
              // arcnode->nextarc=LG.vexes[i].fistarc;
               //LG.vexes[i].fistarc=arcnode;
           }

           j++;
       }
       Info.clear();
      
    }
}
void PrintlinkGraph(const linkGraph &G){
    
   for(int i=0;i<G.vexnumber;i++){
       cout<<G.vexes[i].Info;
       ArcNode* p;
       p=G.vexes[i].fistarc;
       while(p){
         cout<<" --> "<<G.vexes[p->adj].Info;
         p=p->nextarc;  
       }
       cout<<endl;
       
   }
}





void linkGraph2Graph(const linkGraph&LG,Graph &G){
    G.vexNumber=LG.vexnumber;
    for(int i=0;i<LG.vexnumber;i++){
        
        ArcNode* p=LG.vexes[i].fistarc;
        G.vexInfo[i]=LG.vexes[i].Info; 
        if(p==NULL) continue;//判断是否存在第一个边
        G.adjMatrix[i][p->adj]=1;
        p=p->nextarc;
        while(p!=NULL){
           G.adjMatrix[i][p->adj]=1;
           p=p->nextarc;
        }
    }
    
}

void printGraph(const Graph &G){
    for(int i=0;i<G.vexNumber;i++){
        for(int j=0;j<G.vexNumber;j++){
            cout<<G.adjMatrix[i][j]<<" ";
        }       
        cout<<endl; 
    }
}


static int visited[MAX_SIZE];
int findAdjVex(const Graph&G,int v0,int visited[]){
    for(int i=0;i<G.vexNumber;i++){
        if(G.adjMatrix[v0][i]==1&&visited[i]!=1){
            return i;
        }
    }
    return -1;
}




//从某个顶点开始DFS
string pointDFS(const Graph &G,int v0,int visited[]){
   string result="";
       // result+=G.vexInfo[v0];
       // visited[v0]=1;
    
    stack<int>stack;
    int p=v0;
   // cout<<findAdjVex(G,v0,visited);
   //要么栈不为空，还能回退；要么未访问p存在，还能访问
   while(!stack.empty()||p!=-1){ 
       //访问的条件是，不是一个不存在的点
        while(p!=-1){
             stack.push(p);
             result+=G.vexInfo[p];
             result+=" ";
             visited[p]=1; 
             p=findAdjVex(G,p,visited);           
        } //回退，要么进行while，要么不进行while
        //不进行while，再次回退；进行while到达不存在的节点回退
        p=stack.top();//途径到空，取栈顶（栈顶元素一定不存在相邻的未访问的节点）
        stack.pop();
        p=findAdjVex(G,p,visited);
 
}

return result;

}

//对整个图进行DFS；
string DFS(const Graph &G){
    string result="";       

    //第一步，初始化visited数组
    for(int i=0;i<G.vexNumber;i++){
        visited[i]=0;
    } 
    //第二步，以每个未被遍历的顶点为起点，进行DFS
      for(int i=0;i<G.vexNumber;i++){ 
       if(visited[i]==0){       
        result+=pointDFS(G,i,visited);
        }
   }
    return result;
}
void AddArc(linkGraph &G,int start,int adj){
    int flag=0;
    ArcNode *arcnode=getArcNode(adj);
   if(G.vexes[start].fistarc==NULL)
   G.vexes[start].fistarc=arcnode;
   else{
       ArcNode*p=G.vexes[start].fistarc;
       if(p->adj>adj){
       arcnode->nextarc=p;
       G.vexes[start].fistarc=arcnode;           
       }
      else{
       while(p->nextarc){
           if(p->nextarc->adj>adj){
               arcnode->nextarc=p->nextarc;
               p->nextarc=arcnode;
                flag=1;
               break;
           }
           p=p->nextarc;
         }
   if(flag==0)
       p->nextarc=arcnode;


        }

     
   }


}
//static int  visited[MAX_SIZE];
void pointBFS(const linkGraph &G,int v0){

   queue<int>queue;
   for(int i=0;i<G.vexnumber;i++){
       visited[i]=0;
   }
 int pvex;
 ArcNode* parc;
  queue.push(v0);

   while(!queue.empty()){      
    pvex=queue.front();
    cout<<pvex<<" ";
    queue.pop(); 
    //visited[pvex]=1;
       parc=G.vexes[pvex].fistarc;
       while(parc!=NULL){//遍历pvex对于点节点的adj边
           //把与pvex相邻的未被访问的节点放入队列
           if(visited[parc->adj]!=1)
          { queue.push(parc->adj);
          visited[parc->adj]=1;}
          //进入队列必定访问，所以入队必须登记
           parc=parc->nextarc;
       }
   }
}

void DestroylinkGraph(linkGraph &LG){
}

string pointDFS_finished(const Graph&G,int v0,int visited[]){
    string result="";
    visited[v0]=1;//标记已访问
    for(int i=0;i<G.vexNumber;i++){
        if(G.adjMatrix[v0][i]==1&&visited[i]!=1){
            result+=pointDFS_finished(G,i,visited);
        }
     
    }   result+=G.vexInfo[v0];
        return result;
}

string DFS_finished(const Graph&G){
    string result="";
    //初始化visited[]数组；
    for(int i=0;i<G.vexNumber;i++){
        visited[i]=0;
    }
    //从每个未被访问的vex开始进行BFS
    for(int i=0;i<G.vexNumber;i++){
        if(visited[i]!=1) 
        result+=pointDFS_finished(G,i,visited);
    }
    return result;
}
//计算每次划去后的入度
void INDEGREE(const Graph &G,int IN[]){
    for(int i=0;i<G.vexNumber;i++)
    IN[i]=0;

for(int i=0;i<G.vexNumber;i++){
    for(int j=0;j<G.vexNumber;j++){
        IN[i]+=G.adjMatrix[j][i];
    }
}
}
//划去i的出边
void Scrach(Graph &G,int i){
    for(int j=0;j<G.vexNumber;j++){
        G.adjMatrix[i][j]=0;
    }
}
//将一个不可改变的图，复制成一个傀儡图
void Copy(const Graph &G,Graph &dG){
    dG.vexNumber=G.vexNumber;
    for(int i=0;i<G.vexNumber;i++){
        for(int j=0;j<G.vexNumber;j++){
            dG.adjMatrix[i][j]=G.adjMatrix[i][j];
        }
    }
}
//为能够到达该节点,且toop序列在该节点之前的(该节点ve已知)
int ismax(const Graph G,int k,const int toop[],const int ve[]){
    int result=0;
    int puase;
    for(int i=0;i<k;i++){
        puase=0;//由于加入了一个判断，并不是每次都能把上次puase覆盖
        if(G.adjMatrix[toop[i]][toop[k]]!=0)
      {puase=ve[toop[i]]+G.adjMatrix[toop[i]][toop[k]];}
     if(result<=puase){
         result=puase;
     }      

    }
    return result;

}
//toop在目标点之后，且目标点邻接到该toop点的lv，
int ismin(const Graph G,int k,const int toop[],const int vl[]){
    int puase;
    int result=vl[toop[G.vexNumber-1]];
    for(int i=G.vexNumber-1;i>k;i--){
        puase=vl[toop[G.vexNumber-1]];
        if(G.adjMatrix[toop[k]][toop[i]]!=0)
        puase=vl[toop[i]]-G.adjMatrix[toop[k]][toop[i]];
        if(puase<result)
        result=puase;
    }
    return result;
}
int main(){
    int v,a;
   //freopen("/config/workspace/answer/test","r",stdin);
    cin>>v>>a;
    int input[MAX_SIZE];//是否以及放入toop序列
    int IN[MAX_SIZE];//入度，是否可以放入toop序列
        Graph G;
        G.vexNumber=v;
        int r,l,weight;
        //构造邻接矩阵
        //首先定义一个结构体数组e，储存边的信息
      struct e ee[100];
      struct e ll[100];
      int k=0;
      for(int i=0;i<a;i++){
          cin>>r>>l>>weight;
          G.adjMatrix[r][l]=weight;
          ee[k].start=ll[k].start=r;
          ee[k].end=ll[k].end=l;
          ee[k].weight=ll[k].weight=weight;
          k++;
      }


  //                         printGraph(G);
     Graph dG;
     Copy(G,dG);
     int toop[100];

//进行点数个循环，每一次循环使得一个点进入toop序列
//入度为0且未被入toop的点入toop
for(int k=0;k<dG.vexNumber;k++){
    INDEGREE(dG,IN);
    for(int i=0;i<dG.vexNumber;i++){
        if(IN[i]==0&&input[i]!=1){
            toop[k]=i;
            input[i]=1;
            Scrach(dG,i);
            break;
        }
    }
}

int ve[MAX_SIZE];
for(int i=0;i<G.vexNumber;i++){
    ve[i]=0;
}
ve[toop[0]]=0;
//顺toop序列计算最早发生时间
for(int k=1;k<G.vexNumber;k++){
    //上一个toop点加上上一个toop点到此点的边最大值
    ve[toop[k]]=ismax(G,k,toop,ve);

}
int vl[100];
//toop序列最后一个点，最早发生时间等于最晚发生时间
vl[toop[G.vexNumber-1]]=ve[toop[G.vexNumber-1]];
//逆拓扑序列计算点的最晚发生时间
for(int i=G.vexNumber-2;i>=0;i--){
    vl[toop[i]]=ismin(G,i,toop,vl);
}

for(int i=0;i<G.vexNumber;i++){
    for(int k=0;k<a;k++){
        if(ee[k].start==i)
        {
            ee[k].time=ve[i];
        }
    }
}

for(int i=0;i<a;i++){
    ll[i].time=vl[ll[i].end]-G.adjMatrix[ll[i].start][ll[i].end];

}

for(int k=0;k<a;k++){
    if(ee[k].time==ll[k].time){
        cout<<ee[k].start<<"-->"<<ee[k].end<<":"<<ee[k].time<<endl;
    }
}


}