第11周项目4-利用遍历思想求解图问题

1. /* 
2. *Copyright(c)2017,烟台大学计算机学院 
3. *All right reserved. 
4. *文件名：sk.cpp btree.h btree.cpp 
5. *作者：盛凯 
6. *完成日期：2017年12月14日 
7. *版本号：v1.0 
8. * 
9. *问题描述:利用遍历思想求解图问题
10. *输入描述：无 

1. *程序输出：见运行结果
2. 
   

   1、是否有简单路径? 
   问题：假设图G采用邻接表存储，设计一个算法，判断顶点u到v是否有简单路径。

   #include <stdio.h>
   #include <malloc.h>
   #include "graph.h"
   int visited[MAXV];     //定义存放节点的访问标志的全局数组
   void ExistPath(ALGraph *G,int u,int v, bool &has)
   {
       int w;
       ArcNode *p;
       visited[u]=1;
       if(u==v)
       {
           has=true;
           return;
       }
       p=G->adjlist[u].firstarc;
       while (p!=NULL)
       {
           w=p->adjvex;
           if (visited[w]==0)
               ExistPath(G,w,v,has);
           p=p->nextarc;
       }
   }
   
   void HasPath(ALGraph *G,int u,int v)
   {
       int i;
       bool flag = false;
       for (i=0; i<G->n; i++)
           visited[i]=0; //访问标志数组初始化
       ExistPath(G,u,v,flag);
       printf(" 从 %d 到 %d ", u, v);
       if(flag)
           printf("有简单路径\n");
       else
           printf("无简单路径\n");
   }
   
   int main()
   {
       ALGraph *G;
       int A[5][5]=
       {
           {0,0,0,0,0},
           {0,0,1,0,0},
           {0,0,0,1,1},
           {0,0,0,0,0},
           {1,0,0,1,0},
       };  //请画出对应的有向图
       ArrayToList(A[0], 5, G);
       HasPath(G, 1, 0);
       HasPath(G, 4, 1);
       return 0;
   }

   程序运行结果如图所示：
3. 
   

4. 2、输出简单路径 
   问题：假设图G采用邻接表存储，设计一个算法输出图G中从顶点u到v的一条简单路径（假设图G中从顶点u到v至少有一条简单路径）。

   #include <stdio.h>
   #include <malloc.h>
   #include "graph.h"
   int visited[MAXV];     //定义存放节点的访问标志的全局数组
   void FindAPath(ALGraph *G,int u,int v,int path[],int d)
   {
       //d表示path中的路径长度，初始为-1
       int w,i;
       ArcNode *p;
       visited[u]=1;
       d++;
       path[d]=u;  //路径长度d增1，顶点u加入到路径中
       if (u==v)   //找到一条路径后输出并返回
       {
           printf("一条简单路径为:");
           for (i=0; i<=d; i++)
               printf("%d ",path[i]);
           printf("\n");
           return;         //找到一条路径后返回
       }
       p=G->adjlist[u].firstarc;  //p指向顶点u的第一个相邻点
       while (p!=NULL)
       {
           w=p->adjvex;    //相邻点的编号为w
           if (visited[w]==0)
               FindAPath(G,w,v,path,d);
           p=p->nextarc;   //p指向顶点u的下一个相邻点
       }
   }
   
   void APath(ALGraph *G,int u,int v)
   {
       int i;
       int path[MAXV];
       for (i=0; i<G->n; i++)
           visited[i]=0; //访问标志数组初始化
       FindAPath(G,u,v,path,-1);  //d初值为-1，调用时d++，即变成了0
   }
   
   int main()
   {
   
       ALGraph *G;
       int A[5][5]=
       {
           {0,0,0,0,0},
           {0,0,1,0,0},
           {0,0,0,1,1},
           {0,0,0,0,0},
           {1,0,0,1,0},
       };  //请画出对应的有向图
       ArrayToList(A[0], 5, G);
       APath(G, 1, 0);
       APath(G, 4, 1);
       return 0;
   }

   程序运行结果如图所示：
5. 
   

6. 3、输出所有路径 
   问题：输出从顶点u到v的所有简单路径。

   #include <stdio.h>
   #include <malloc.h>
   #include "graph.h"
   int visited[MAXV];     //定义存放节点的访问标志的全局数组
   void FindPaths(ALGraph *G,int u,int v,int path[],int d)
   //d是到当前为止已走过的路径长度，调用时初值为-1
   {
       int w,i;
       ArcNode *p;
       visited[u]=1;
       d++;            //路径长度增1
       path[d]=u;              //将当前顶点添加到路径中
       if (u==v && d>1)            //输出一条路径
       {
           printf("  ");
           for (i=0; i<=d; i++)
               printf("%d ",path[i]);
           printf("\n");
       }
       p=G->adjlist[u].firstarc; //p指向u的第一条边
       while(p!=NULL)
       {
           w=p->adjvex;     //w为u的邻接顶点
           if (visited[w]==0)      //若顶点未标记访问，则递归访问之
               FindPaths(G,w,v,path,d);
           p=p->nextarc; //找u的下一个邻接顶点
       }
       visited[u]=0;   //恢复环境
   }
   
   
   void DispPaths(ALGraph *G,int u,int v)
   {
       int i;
       int path[MAXV];
       for (i=0; i<G->n; i++)
           visited[i]=0; //访问标志数组初始化
       printf("从%d到%d的所有路径:\n",u,v);
       FindPaths(G,u,v,path,-1);
       printf("\n");
   }
   
   int main()
   {
       ALGraph *G;
       int A[5][5]=
       {
           {0,1,0,1,0},
           {1,0,1,0,0},
           {0,1,0,1,1},
           {1,0,1,0,1},
           {0,0,1,1,0}
       };  //请画出对应的有向图
       ArrayToList(A[0], 5, G);
       DispPaths(G, 1, 4);
       return 0;
   }

   程序运行结果如图所示：
7. 
   

8. 4、输出一些简单回路 
   问题：输出图G中从顶点u到v的长度为s的所有简单路径。

   #include <stdio.h>
   #include <malloc.h>
   #include "graph.h"
   int visited[MAXV];     //定义存放节点的访问标志的全局数组
   void SomePaths(ALGraph *G,int u,int v,int s, int path[],int d)
   //d是到当前为止已走过的路径长度，调用时初值为-1
   {
       int w,i;
       ArcNode *p;
       visited[u]=1;
       d++;            //路径长度增1
       path[d]=u;              //将当前顶点添加到路径中
       if (u==v && d==s)           //输出一条路径
       {
           printf("  ");
           for (i=0; i<=d; i++)
               printf("%d ",path[i]);
           printf("\n");
       }
       p=G->adjlist[u].firstarc; //p指向u的第一条边
       while(p!=NULL)
       {
           w=p->adjvex;     //w为u的邻接顶点
           if (visited[w]==0)      //若顶点未标记访问，则递归访问之
               SomePaths(G,w,v,s,path,d);
           p=p->nextarc; //找u的下一个邻接顶点
       }
       visited[u]=0;   //恢复环境
   }
   
   void DispSomePaths(ALGraph *G,int u,int v, int s)
   {
       int i;
       int path[MAXV];
       for (i=0; i<G->n; i++)
           visited[i]=0; //访问标志数组初始化
       printf("从%d到%d长为%d的路径:\n",u,v,s);
       SomePaths(G,u,v,s,path,-1);
       printf("\n");
   }
   
   int main()
   {
       ALGraph *G;
       int A[5][5]=
       {
           {0,1,0,1,0},
           {1,0,1,0,0},
           {0,1,0,1,1},
           {1,0,1,0,1},
           {0,0,1,1,0}
       };  //请画出对应的有向图
       ArrayToList(A[0], 5, G);
       DispSomePaths(G, 1, 4, 3);
       return 0;
   }

   程序运行结果如图所示：
9. 
   

10. 5、输出通过一个节点的所有简单回路 
    问题：求图中通过某顶点k的所有简单回路（若存在）

    #include <stdio.h>
    #include <malloc.h>
    #include "graph.h"
    int visited[MAXV];       //全局变量
    void DFSPath(ALGraph *G,int u,int v,int path[],int d)
    //d是到当前为止已走过的路径长度，调用时初值为-1
    {
        int w,i;
        ArcNode *p;
        visited[u]=1;
        d++;
        path[d]=u;
        p=G->adjlist[u].firstarc;   //p指向顶点u的第一条边
        while (p!=NULL)
        {
            w=p->adjvex;            //w为顶点u的相邻点
            if (w==v && d>0)        //找到一个回路，输出之
            {
                printf("  ");
                for (i=0; i<=d; i++)
                    printf("%d ",path[i]);
                printf("%d \n",v);
            }
            if (visited[w]==0)          //w未访问，则递归访问之
                DFSPath(G,w,v,path,d);
            p=p->nextarc;       //找u的下一个邻接顶点
        }
        visited[u]=0;           //恢复环境：使该顶点可重新使用
    }
    
    void FindCyclePath(ALGraph *G,int k)
    //输出经过顶点k的所有回路
    {
        int path[MAXV],i;
        for (i=0; i<G->n; i++)
            visited[i]=0; //访问标志数组初始化
        printf("经过顶点%d的所有回路\n",k);
        DFSPath(G,k,k,path,-1);
        printf("\n");
    }
    
    int main()
    {
        ALGraph *G;
        int A[5][5]=
        {
            {0,1,1,0,0},
            {0,0,1,0,0},
            {0,0,0,1,1},
            {0,0,0,0,1},
            {1,0,0,0,0}
        };  //请画出对应的有向图
        ArrayToList(A[0], 5, G);
        FindCyclePath(G, 0);
        return 0;
    }

    程序运行结果如图所示：
11. 
    
12.