图

最新推荐文章于 2020-12-03 00:58:52 发布

kguazju

最新推荐文章于 2020-12-03 00:58:52 发布

阅读量308

点赞数 1

分类专栏：数据结构

本文链接：https://blog.csdn.net/weixin_44153124/article/details/89309726

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

图

什么是图

表示多对多的关系
包含：

一组顶点：通常用V(Vertex)表示顶点集合
一组边：通常用E(Edge)表示边的集合

抽象数据类型定义：

类型名称：图
数据对象集：G(V,E)由一个非空的有限顶点集合V和一个有限边集合E组成。
操作集：对于任意图G $\in$ Graph，以及v $\in$ V，e $\in$ E

Graph Create()：建立并返回空图；
Graph InsertVertex(Graph G, Vertex v)：将v插入G；
Graph InsertEdge(Graph G, Edge e)：将e插入G；
void DFS(Graph G, Vertex v)：从顶点v出发深度优先遍历图G；
void BFS(Graph G, Vertex v)：从顶点v出发宽度优先遍历图G；
void Shortest Path(Graph G, Vertex v, int Dis[])：计算图G中顶点v到任意其他顶点的最短距离；
void MST(Graph G)：计算图G的最小生成树；
…

怎么在程序中表示一个图：

邻接矩阵
邻接表：G[N]为指针数组，对应矩阵每行一个链表，只存非零元素

在这里插入图片描述

建立图的C语言实现：

用邻接矩阵表示图：思路

图的定义

typedef int WeightType;

typedef struct GNode *PtrToGNode; // 指向GNode的指针
struct GNode{
    int Nv; // 顶点数
    int Ne; // 边数
    WeightType G[MaxVertexNum][MaxVertexNum];
    DataType Data[MaxVertexNum]; // 存顶点的数据
};
typedef PtrToGNode MGraph; // MatrixGraph，以邻接矩阵存储的图类型

MGraph初始化

// 初始化一个有VertexNum个顶点但没有边的图

typedef int Vertex; //用顶点下标来表示顶点，为整型

MGraph CreateGraph( int VertexNum )
{
    Vertex V, W;
    MGraph Graph;
    
    Graph = (MGraph) malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    
    // 这里默认顶点编号从0开始到(Graph->Nv-1)
    for ( V=0; V<Graph->Nv; V++)
        for ( W=0; W<Graph->Nv; W++)
            Graph->G[V][W] = 0; // 或INFINITY(有权图)
    
    return Graph;
}

向MGraph中插入边

typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2; //有向边<V1,V2>
    WeightType Weight; //  权重
};
typedef PtrToENode Edge;

void InsertEdge( MGraph Graph, Edge E )
{
    // 插入边<V1,V2>
    Graph->G[E->V1][E->V2] = E->Weight;
    
    // 若是无向图，还要插入边<V2,V1>
    Graph->G[E->V2][E->V1] = E->Weight;
}

完整地建立一个MGraph

// 输入格式：
// Nv Ne
// V1 V2 Weight
// ...

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;
    
    scanf("%d", &Nv);
    Graph = CreateGraph(Nv);
    scanf("%d", &(Graph->Ne));
    if (Graph->Ne != 0){
        E = (Edge) malloc(sizeof(struct ENode));
        for (i=0; i<Graph->Ne; i++)
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight);
        InsertEdge( Graph, E);
    }
    //如果顶点有数据的话，读入数据
    for (V=0; V<Graph->Nv ;V++)
        scanf("%c", &Graph->Data[V]);
    
    return Graph;
}

如果不要这么麻烦

int G[MAXN][MAXN], Nv,Ne;
void BuildGraph()
{
    int i,j,v1,v2,w;
    scanf("%d",&Nv);
    for (i=0;i<Nv;i++)
        for(j=0;j<Nv;j++)
            G[i][j]=0;
    scanf("%d", &Ne);
    for (i=0;i<Ne;i++)
    {
        scanf("%d %d %d",&v1,&v2,&w);
        G[v1][v2]=w;
        G[v2][v1]=w;
    }
}

图的邻接矩阵表示法实现代码：

/* 图的邻接矩阵表示法 */
 
#define MaxVertexNum 100    /* 最大顶点数设为100 */
#define INFINITY 65535        /* ∞设为双字节无符号整数的最大值65535*/
typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
typedef int WeightType;        /* 边的权值设为整型 */
typedef char DataType;        /* 顶点存储的数据类型设为字符型 */
 
/* 边的定义 */
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* 有向边<V1, V2> */
    WeightType Weight;  /* 权重 */
};
typedef PtrToENode Edge;
        
/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;  /* 顶点数 */
    int Ne;  /* 边数   */
    WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
    DataType Data[MaxVertexNum];      /* 存顶点的数据 */
    /* 注意：很多情况下，顶点无数据，此时Data[]可以不用出现 */
};
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */
 
 
 
MGraph CreateGraph( int VertexNum )
{ /* 初始化一个有VertexNum个顶点但没有边的图 */
    Vertex V, W;
    MGraph Graph;
     
    Graph = (MGraph)malloc(sizeof(struct GNode)); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化邻接矩阵 */
    /* 注意：这里默认顶点编号从0开始，到(Graph->Nv - 1) */
    for (V=0; V<Graph->Nv; V++)
        for (W=0; W<Graph->Nv; W++)  
            Graph->G[V][W] = INFINITY;
             
    return Graph; 
}
        
void InsertEdge( MGraph Graph, Edge E )
{
     /* 插入边 <V1, V2> */
     Graph->G[E->V1][E->V2] = E->Weight;    
     /* 若是无向图，还要插入边<V2, V1> */
     Graph->G[E->V2][E->V1] = E->Weight;
}
 
MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;
     
    scanf("%d", &Nv);   /* 读入顶点个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */ 
     
    scanf("%d", &(Graph->Ne));   /* 读入边数 */
    if ( Graph->Ne != 0 ) { /* 如果有边 */ 
        /* 读入边，格式为"起点 终点 权重"，插入邻接矩阵 */
        for (i=0; i<Graph->Ne; i++) {
            E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点 */ 
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight); 
            /* 注意：如果权重不是整型，Weight的读入格式要改 */
            InsertEdge( Graph, E );
        }
    } 
 
    /* 如果顶点有数据的话，读入数据 */
    for (V=0; V<Graph->Nv; V++) 
        scanf(" %c", &(Graph->Data[V]));
 
    return Graph;
}

图的邻接表表示法

定义

// 图结点的定义
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv; // 顶点数
    int Ne; // 边数
    AdjList G; // 邻接表
};
typedef PtrToGNode LGraph; // 以邻接表方式存储的图类型

// 邻接点的定义
typedef struct AdjVNode *PtrToAdjVNode;
struct AdjVNode{
    Vertex AdjV; // 邻接点下标
    WeightType Weight; //边权重
    PtrToAdjVNode Next;
};

// 顶点表头结点的定义
typedef struct VNode{
    PtrToAdjVNode FirstEdge;
    DataType Data; // 存顶点的数据
} AdjList[MaxVertexNum]; // AdjList是邻接表类型

LGraph 初始化

typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
LGraph CreateGraph ( int VertexNum )
{
    Vertex V ;
    LGraph Graph;
    
    Graph = (LGraph) malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    
    // 注意：这里默认顶点编号从0开始，到Graph->Nv-1
    for(V=0;V<Graph->Nv;V++)
        Graph->G[V].FirstEdge = NULL;
    
    return Graph;
}

向LGraph中插入边

typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* 有向边<V1, V2> */
    WeightType Weight;  /* 权重 */
};
typedef PtrToENode Edge;

void InsertEdge( LGraph Graph, Edge E )
{
    PtrToAdjVNode NewNode;
    /************* 插入边<V1,V2>**********/
    // 为V2建立新的邻接点
    NewNode = (PtrToAdjVNode) malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    // 将V2插入V1的表头
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;
    
    /* 若是无向图，还要插入边 <V2, V1> */
    /* 为V1建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->Weight;
    /* 将V1插入V2的表头 */
    NewNode->Next = Graph->G[E->V2].FirstEdge;
    Graph->G[E->V2].FirstEdge = NewNode;
}

完整地一个建立一个LGraph

图的邻接表表示法实现代码：

/* 图的邻接表表示法 */
 
#define MaxVertexNum 100    /* 最大顶点数设为100 */
typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
typedef int WeightType;        /* 边的权值设为整型 */
typedef char DataType;        /* 顶点存储的数据类型设为字符型 */
 
/* 边的定义 */
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* 有向边<V1, V2> */
    WeightType Weight;  /* 权重 */
};
typedef PtrToENode Edge;
 
/* 邻接点的定义 */
typedef struct AdjVNode *PtrToAdjVNode; 
struct AdjVNode{
    Vertex AdjV;        /* 邻接点下标 */
    WeightType Weight;  /* 边权重 */
    PtrToAdjVNode Next;    /* 指向下一个邻接点的指针 */
};
 
/* 顶点表头结点的定义 */
typedef struct Vnode{
    PtrToAdjVNode FirstEdge;/* 边表头指针 */
    DataType Data;            /* 存顶点的数据 */
    /* 注意：很多情况下，顶点无数据，此时Data可以不用出现 */
} AdjList[MaxVertexNum];    /* AdjList是邻接表类型 */
 
/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{  
    int Nv;     /* 顶点数 */
    int Ne;     /* 边数   */
    AdjList G;  /* 邻接表 */
};
typedef PtrToGNode LGraph; /* 以邻接表方式存储的图类型 */
 
 
 
LGraph CreateGraph( int VertexNum )
{ /* 初始化一个有VertexNum个顶点但没有边的图 */
    Vertex V;
    LGraph Graph;
     
    Graph = (LGraph)malloc( sizeof(struct GNode) ); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化邻接表头指针 */
    /* 注意：这里默认顶点编号从0开始，到(Graph->Nv - 1) */
       for (V=0; V<Graph->Nv; V++)
        Graph->G[V].FirstEdge = NULL;
             
    return Graph; 
}
        
void InsertEdge( LGraph Graph, Edge E )
{
    PtrToAdjVNode NewNode;
     
    /* 插入边 <V1, V2> */
    /* 为V2建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    /* 将V2插入V1的表头 */
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;
         
    /* 若是无向图，还要插入边 <V2, V1> */
    /* 为V1建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->Weight;
    /* 将V1插入V2的表头 */
    NewNode->Next = Graph->G[E->V2].FirstEdge;
    Graph->G[E->V2].FirstEdge = NewNode;
}
 
LGraph BuildGraph()
{
    LGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;
     
    scanf("%d", &Nv);   /* 读入顶点个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */ 
     
    scanf("%d", &(Graph->Ne));   /* 读入边数 */
    if ( Graph->Ne != 0 ) { /* 如果有边 */ 
        E = (Edge)malloc( sizeof(struct ENode) ); /* 建立边结点 */ 
        /* 读入边，格式为"起点 终点 权重"，插入邻接矩阵 */
        for (i=0; i<Graph->Ne; i++) {
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight); 
            /* 注意：如果权重不是整型，Weight的读入格式要改 */
            InsertEdge( Graph, E );
        }
    } 
 
    /* 如果顶点有数据的话，读入数据 */
    for (V=0; V<Graph->Nv; V++) 
        scanf(" %c", &(Graph->G[V].Data));
 
    return Graph;
}

图的遍历：

DFS(Depth First Search):

类似于树的先序遍历。

void DFS ( Vertex V )
{
    visited[ V ] = true;
    for ( V 的每个临接点W )
        if ( !visited[W] )
            DFS( W );
}

若有N个顶点、N条边，时间复杂度是：

用邻接表存储图，有O(N+E) （每个点访问了一次，每条边访问了一次）
用邻接矩阵存储图，有O( $N^2$ )

BFS(Breadth First Search):

类似于树的层序遍历。

void BFS( Vertex V )
{
    visited[V] = true;
    Enqueue( V, Q );
    while ( !IsEmpty(Q) ){
        V = Dequeue(Q);
        for ( V 的每个邻接点W ){
            visited[W] = true;
            Enqueue( W, Q );
        }
    }
}

若有N个顶点、E条边，时间复杂度是：

用邻接表存储图，有O(N+E) （每个点访问了一次，每条边访问了一次）
用邻接矩阵存储图，有O( $N^2$ )

图不连通

连通
路径/简单路径
回路
连通图
连通分量:无向图的极大连通子图
强连通
强连通图
强连通分量：有向图的极大强连通子图

void ListComponents ( Graph G )
{
    for ( each V in G )
        if ( !visited[V] )
            DFS( V ); /* or BFS(V) */
}

/* 邻接表存储的图 - DFS */
 
void Visit( Vertex V )
{
    printf("正在访问顶点%d\n", V);
}
 
/* Visited[]为全局变量，已经初始化为false */
void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) )
{   /* 以V为出发点对邻接表存储的图Graph进行DFS搜索 */
    PtrToAdjVNode W;
     
    Visit( V ); /* 访问第V个顶点 */
    Visited[V] = true; /* 标记V已访问 */
 
    for( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 对V的每个邻接点W->AdjV */
        if ( !Visited[W->AdjV] )    /* 若W->AdjV未被访问 */
            DFS( Graph, W->AdjV, Visit );    /* 则递归访问之 */
}

/* 邻接矩阵存储的图 - BFS */
 
/* IsEdge(Graph, V, W)检查<V, W>是否图Graph中的一条边，即W是否V的邻接点。  */
/* 此函数根据图的不同类型要做不同的实现，关键取决于对不存在的边的表示方法。*/
/* 例如对有权图, 如果不存在的边被初始化为INFINITY, 则函数实现如下:         */
bool IsEdge( MGraph Graph, Vertex V, Vertex W )
{
    return Graph->G[V][W]<INFINITY ? true : false;
}
 
/* Visited[]为全局变量，已经初始化为false */
void BFS ( MGraph Graph, Vertex S, void (*Visit)(Vertex) )
{   /* 以S为出发点对邻接矩阵存储的图Graph进行BFS搜索 */
    Queue Q;     
    Vertex V, W;
 
    Q = CreateQueue( MaxSize ); /* 创建空队列, MaxSize为外部定义的常数 */
    /* 访问顶点S：此处可根据具体访问需要改写 */
    Visit( S );
    Visited[S] = true; /* 标记S已访问 */
    AddQ(Q, S); /* S入队列 */
     
    while ( !IsEmpty(Q) ) {
        V = DeleteQ(Q);  /* 弹出V */
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            /* 若W是V的邻接点并且未访问过 */
            if ( !Visited[W] && IsEdge(Graph, V, W) ) {
                /* 访问顶点W */
                Visit( W );
                Visited[W] = true; /* 标记W已访问 */
                AddQ(Q, W); /* W入队列 */
            }
    } /* while结束*/
}

列出连通集

给定一个有 $N$ 个顶点和 $E$ 条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到 $N - 1$ 编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:

输入第1行给出2个整数 $N (0 < N \leq 10)$ 和E，分别是图的顶点数和边数。随后 $E$ 行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

输出格式:

按照"{ $v_1$ $v_2$ … $v_k$ }"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例:

输出样例:

{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }

代码:

#include <stdio.h>
#include <stdlib.h>

#define MaxVertexNum 10

typedef struct GNode *PtrToGNode;

struct GNode{
    int Nv;
    int Ne;
    int G[MaxVertexNum][MaxVertexNum];
};

typedef PtrToGNode MGraph;

typedef int Vertex;

typedef struct ENode *PtrToENode;

struct ENode{
    Vertex V1,V2;
};

typedef PtrToENode Edge;

int DFSVisited[MaxVertexNum];
int BFSVisited[MaxVertexNum];


// 链表的头插入与删除均可,但链表的尾部只适合插入(删除找不到前一个结点在哪里),故而尾部Rear
typedef int ElementType;
typedef int Position;

struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;

Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

int IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

int AddQ( Queue Q, ElementType X )
{
    Q->Rear = (Q->Rear+1)%Q->MaxSize;
    Q->Data[Q->Rear] = X;
    return 1;
}

int IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}

ElementType DeleteQ( Queue Q )
{
    Q->Front =(Q->Front+1)%Q->MaxSize;
    return  Q->Data[Q->Front];
}





MGraph CreateGraph( int VertexNum )
{
    Vertex V, W;
    MGraph Graph;
    
    Graph = (MGraph) malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    
    for ( V=0; V<Graph->Nv; V++ )
        for ( W=0; W<Graph->Nv; W++ )
            Graph->G[V][W] = 0;
    
    return Graph;
}



void InsertEdge( MGraph Graph, Edge E )
{
    Graph->G[E->V1][E->V2] = 1;
    Graph->G[E->V2][E->V1] = 1;
}

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    int Nv, i;
    
    scanf("%d", &Nv);
    Graph = CreateGraph(Nv);
    scanf("%d", &Graph->Ne);
    if ( Graph->Ne != 0 ){
        for ( i=0; i<Graph->Ne; i++ )
        {
            E = (Edge) malloc(sizeof(struct ENode));
            scanf("%d %d", &E->V1, & E->V2 );
            InsertEdge( Graph, E );
        }
    }
    
    return Graph;
}

void PrintGraph( MGraph Graph )
{
    Vertex V ,W;
    for ( V=0; V<Graph->Nv; V++ )
        for ( W=0; W<Graph->Nv; W++ )
            printf("Graph->G[%d][%d] = %d\n", V, W, Graph->G[V][W]);
}

int IsEdge( MGraph Graph, Vertex V, Vertex W )
{
    return Graph->G[V][W];
}

void Visit( Vertex V )
{
    printf(" %d", V);
}

void BFS( MGraph Graph, Vertex S )
{
    // 以S为出发点堆邻接矩阵存储的图Graph进行BFS搜索
    Queue Q;
    Vertex V, W;
    
    Q = CreateQueue( MaxVertexNum );
    
    Visit (S);
    BFSVisited[S] = 1;
    AddQ(Q,S);
    
    while ( !IsEmpty(Q) ){
        V = DeleteQ(Q);
        for ( W=0; W<Graph->Nv; W++)
        {
            if ( !BFSVisited[W] && IsEdge(Graph, V, W))
            {
                Visit( W);
                BFSVisited[W] = 1;
                AddQ(Q, W);
            }
        }
    }
}

void DFS( MGraph Graph, Vertex S )
{
    Vertex W;
    Visit(S);
    DFSVisited[S] = 1;
    
    for ( W=0; W<Graph->Nv; W++ )
    {
        if ( S!=W && !DFSVisited[W] && IsEdge( Graph, S, W ) )
            DFS(Graph, W);
    }
}


void ListComponentsBFS ( MGraph Graph )
{
    int V;
    for ( V=0; V<Graph->Nv; V++ )
    {
        if ( !BFSVisited[V] )
        {
            printf("{");
            BFS(Graph, V);
            printf(" }");
            printf("\n");
        }
    }
}


void ListComponentsDFS ( MGraph Graph )
{
    int V;
    for ( V=0; V<Graph->Nv; V++ )
    {
        if ( !DFSVisited[V] )
        {
            printf("{");
            DFS(Graph, V);
            printf(" }");
            printf("\n");
        }
    }
}



int main()
{
    MGraph Graph;
    
    Graph = BuildGraph();
    
    ListComponentsDFS ( Graph );
    ListComponentsBFS ( Graph );
}

Saving James Bond - Easy Version

This time let us consider the situation in the movie “Live and Let Die” in which James Bond, the world’s most famous spy, was captured by a group of drug dealers. He was sent to a small piece of land at the center of a lake filled with crocodiles. There he performed the most daring action to escape – he jumped onto the head of the nearest crocodile! Before the animal realized what was happening, James jumped again onto the next big head… Finally he reached the bank before the last crocodile could bite him (actually the stunt man was caught by the big mouth and barely escaped with his extra thick boot).

Assume that the lake is a 100 by 100 square one. Assume that the center of the lake is at (0,0) and the northeast corner at (50,50). The central island is a disk centered at (0,0) with the diameter of 15. A number of crocodiles are in the lake at various positions. Given the coordinates of each crocodile and the distance that James could jump, you must tell him whether or not he can escape.

Input Specification:

Each input file contains one test case. Each case starts with a line containing two positive integers $N (\leq 100)$ , the number of crocodiles, and $D$ , the maximum distance that James could jump. Then $N$ lines follow, each containing the $(x, y)$ location of a crocodile. Note that no two crocodiles are staying at the same position.

Output Specification:

For each test case, print in a line “Yes” if James can escape, or “No” if not.

Sample Input 1:

Sample Output 1:

Yes

Sample Input 2:

Sample Output 2:

No

代码：

这里没有采用邻接表或者邻接矩阵的方法存储图，而是采用一个结构体数组（包含横纵坐标）来存储图。此外，解决此题需要考虑到第一跳，与实际边界情况的问题。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MaxVertexNum 100

typedef int Position;

typedef struct GNode Vertex;

struct GNode{
    Position x;
    Position y;
}Graph[MaxVertexNum];


int Visited[MaxVertexNum];

int Jump( int i, int j ,int distance )
{
    return pow(Graph[i].x-Graph[j].x,2) + pow(Graph[i].y-Graph[j].y,2) <= distance*distance;
}

int FirstJump( int i, int distance )
{
    return pow(Graph[i].x,2)+pow(Graph[i].y,2) <= pow(distance+7.5,2);
}

int IsSafe( int i, int distance )
{
    return(pow(Graph[i].x-50,2)<=pow(distance,2) ||
           pow(Graph[i].x+50,2)<=pow(distance,2) ||
           pow(Graph[i].y+50,2)<=pow(distance,2) ||
           pow(Graph[i].y-50,2)<=pow(distance,2) );
}

int DFS( int i ,int distance, int N)
{
    int answer = 0;
    Visited[i] = 1;
    int j;
    if ( IsSafe(i, distance) ) answer = 1;
    else
    {
        for ( j=0; j<N; j++ )
            if ( !Visited[j] && Jump(i,j,distance) ){
                answer = DFS(j,distance,N);
                if (answer) break;
            }
    }
    return answer;
}

void Save007( int N ,int distance)
{
    int i;
    int answer = 0;
    for ( i=0; i<N; i++ ){
        if ( !Visited[i] && FirstJump(i,distance) ){
            answer = DFS(i,distance, N);
            if (answer ) break;
        }
    }
    if (answer) printf("Yes\n");
    else printf("No\n");
}

int main()
{
    int i, N, D;
    scanf("%d", &N);
    scanf("%d", &D);
    for ( i=0; i<N; i++)
        scanf("%d %d", &Graph[i].x, &Graph[i].y);
    Save007(N,D);
}

六度空间

“六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”如图所示。
在这里插入图片描述
“六度空间”理论虽然得到广泛的认同，并且正在得到越来越多的应用。但是数十年来，试图验证这个理论始终是许多社会学家努力追求的目标。然而由于历史的原因，这样的研究具有太大的局限性和困难。随着当代人的联络主要依赖于电话、短信、微信以及因特网上即时通信等工具，能够体现社交网络关系的一手数据已经逐渐使得“六度空间”理论的验证成为可能。

假如给你一个社交网络图，请你对每个节点计算符合“六度空间”理论的结点占结点总数的百分比。

输入格式:

输入第1行给出两个正整数，分别表示社交网络图的结点数 $N$ （ $1<N≤10^4$ ，表示人数）、边数 $M$ （ $\leq 33 \times N$ ，表示社交关系数）。随后的 $M$ 对应 $M$ 条边，每行给出一对正整数，分别是该条边直接连通的两个结点的编号（节点从 $1$ 到 $N$ 编号）。

输出格式:

对每个结点输出与该结点距离不超过6的结点数占结点总数的百分比，精确到小数点后2位。每个结节点输出一行，格式为“结点编号:（空格）百分比%”。
输出格式:

输入样例:

输出样例:

1: 70.00%
2: 80.00%
3: 90.00%
4: 100.00%
5: 100.00%
6: 100.00%
7: 100.00%
8: 90.00%
9: 80.00%
10: 70.00%

算法思路：

对每个结点，进行BFS
搜索过程中累计访问的结点数
需要记录“层”数，仅计算6层以内的结点数

在这里插入图片描述

代码:

#include <stdio.h>
#include <stdlib.h>

#define MaxVerTexNum 10000

typedef int Vertex;

typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1,V2;
};
typedef PtrToENode Edge;

typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;
    int Ne;
    int G[MaxVerTexNum][MaxVerTexNum];
};
typedef PtrToGNode MGraph;

int Visited[MaxVerTexNum];

MGraph CreateGraph( int VertexNum )
{
    MGraph Graph;
    
    Graph = (MGraph) malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    
    return Graph;
}

void InsertEdge( MGraph Graph, Edge E )
{
    Graph->G[E->V1][E->V2] = 1;
    Graph->G[E->V2][E->V1] = 1;
}

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    int Nv, i;
    
    scanf("%d", &Nv);
    Graph = CreateGraph( Nv);
    scanf("%d", &Graph->Ne);
    if (Graph->Ne !=0 )
        for ( i=0; i<Graph->Ne; i++ ){
            E = (Edge) malloc(sizeof(struct ENode));
            for ( i=0; i<Graph->Ne; i++ ){
                scanf("%d %d", &E->V1, &E->V2);
                E->V1--;
                E->V2--; // 结点从1开始编号
                InsertEdge( Graph, E );
            }
        }
    return Graph;
}


typedef int Position;
typedef int ElementType;
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;

Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

int IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

int AddQ( Queue Q, ElementType X )
{
    Q->Rear = (Q->Rear+1)%Q->MaxSize;
    Q->Data[Q->Rear] = X;
    return 1;
}

int IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}

ElementType DeleteQ( Queue Q )
{
    Q->Front =(Q->Front+1)%Q->MaxSize;
    return  Q->Data[Q->Front];
}

int IsEdge( Vertex V, Vertex W, MGraph Graph )
{
    return Graph->G[V][W];
}

int BFS( MGraph Graph, Vertex V )
{
    int count, level, last, tail;
    Vertex W;
    Queue Q = CreateQueue(MaxVerTexNum);
    Visited[V] = 1; count = 1;
    level = 0; last = V;
    AddQ(Q,V);
    while ( !IsEmpty(Q)){
        V = DeleteQ(Q);
        for ( W=0; W<Graph->Nv; W++ ){
            if ( !Visited[W] && IsEdge(V,W,Graph) ){
                Visited[W] = 1;
                AddQ(Q,W);
                count++;
                tail = W;
            }
        }
        if (V==last){
            level++;
            last = tail;
        }
        if ( level==6 ) break;
    }
    return count;
}

void SDS(MGraph Graph)
{
    double count;
    double result;
    Vertex V, W;
    for ( V=0; V<Graph->Nv; V++){
        for (W=0; W<Graph->Nv; W++)
            Visited[W]=0;
        count = BFS(Graph, V);
        result = 100*count/Graph->Nv;
        printf("%d: %.2f%%\n",V+1,result);
    }
}

int main()
{
    MGraph Graph;
    Graph = BuildGraph();
    SDS(Graph);
}

最短路径问题

问题分类

单源最短路径问题：从某固定源点出发，求其道所有其他顶点的最短路径

无权图
有权图

多源最短路径问题：求任意两顶点间的最短路径

无权图的单源最短路算法

思路：按照递增（非递减）的顺序找出各个顶点的最短路（从路径长度为0，到路径长度为1、2、…）
在这里插入图片描述

有权图的单源最短路算法

按照递增的顺序找出各个顶点的最短路— Djikstra算法

Djikstra算法

令S={源点s+已经确定了最短路径的顶点v $_i$ }
对任一未收录的顶点v，定义dist[v]为s到v的最短路径长，但该路径仅经过S中的顶点（但不一定是最终的最短路！）。即路径{s $\rightarrow$ (v $_i$ $\in$ S) $\rightarrow$ v}的最小长度
若路径是按照递增的顺序生成的，则

对于已经收进S的顶点，到该顶点真正的最短路必须只经过S中的顶点（反证法：假如把下一个v收进集合S时，从s到v存在另外一个点w，从s到v需从s到w再从w到v，则s到w的距离小于s到v的距离，而v是下一个要收进去的顶点，这矛盾了！）
每次从未收录的顶点中选一个dist最小的收录（贪心）
增加一个v进入S，可能影响另外一个w的dist值（如果收录v使得s到w的路径变短，则s到w的路径一定经过v，并且v到w有一条边(如果v到w之间还有另外一个顶点，则此顶点到源点的距离一定比v到源点的距离大，但w的dist值是s到w仅仅经过集合S里面的顶点的路径长度，如果另外有一个结点在v后面话，则该顶点不可能在S里面，因为v是新增进去的，所以v是集合里面dist最长的）–从而只需检查更新新增顶点的邻接点的dist值–dist[w] = min{dist[w], dist[v]+<v,w>的权重}

多源最短路算法

在这里插入图片描述

Floyd算法

$D^k[i][j]$ = 路径 $\{i\rightarrow\{l\leq k\}\rightarrow j\}$ 的最小长度
$D^0D^1,...,D^{|V|-1}[i][j]$ 即给出了 $i$ 到 $j$ 的真正最短距离
最初的 $D^{-1}$ ：邻接矩阵，对角元为0
当 $D^{k-1}$ 已经完成，递推到 $D^k$ 时：

或者 $k\notin$ 最短路径 $\{i\rightarrow\{l\leq k\}\rightarrow j\}$ ，则 $D^k=D^{k-1}$
或者 $k\in$ 最短路径 $\{i\rightarrow\{l\leq k\}\rightarrow j\}$ ，则该路径必定由两段最短路径组成： $D^k[i][j]=D^{k-1}[i][k]+D^{k-1}[k][j]$

在这里插入图片描述

/* 邻接表存储 - 无权图的单源最短路算法 */
 
/* dist[]和path[]全部初始化为-1 */
void Unweighted ( LGraph Graph, int dist[], int path[], Vertex S )
{
    Queue Q;
    Vertex V;
    PtrToAdjVNode W;
     
    Q = CreateQueue( Graph->Nv ); /* 创建空队列, MaxSize为外部定义的常数 */
    dist[S] = 0; /* 初始化源点 */
    AddQ (Q, S);
 
    while( !IsEmpty(Q) ){
        V = DeleteQ(Q);
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 对V的每个邻接点W->AdjV */
            if ( dist[W->AdjV]==-1 ) { /* 若W->AdjV未被访问过 */
                dist[W->AdjV] = dist[V]+1; /* W->AdjV到S的距离更新 */
                path[W->AdjV] = V; /* 将V记录在S到W->AdjV的路径上 */
                AddQ(Q, W->AdjV);
            }
    } /* while结束*/
}

/* 邻接矩阵存储 - 有权图的单源最短路算法 */
 
Vertex FindMinDist( MGraph Graph, int dist[], int collected[] )
{ /* 返回未被收录顶点中dist最小者 */
    Vertex MinV, V;
    int MinDist = INFINITY;
 
    for (V=0; V<Graph->Nv; V++) {
        if ( collected[V]==false && dist[V]<MinDist) {
            /* 若V未被收录，且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距离 */
            MinV = V; /* 更新对应顶点 */
        }
    }
    if (MinDist < INFINITY) /* 若找到最小dist */
        return MinV; /* 返回对应的顶点下标 */
    else return ERROR;  /* 若这样的顶点不存在，返回错误标记 */
}
 
bool Dijkstra( MGraph Graph, int dist[], int path[], Vertex S )
{
    int collected[MaxVertexNum];
    Vertex V, W;
 
    /* 初始化：此处默认邻接矩阵中不存在的边用INFINITY表示 */
    for ( V=0; V<Graph->Nv; V++ ) {
        dist[V] = Graph->G[S][V];
        if ( dist[V]<INFINITY )
            path[V] = S;
        else
            path[V] = -1;
        collected[V] = false;
    }
    /* 先将起点收入集合 */
    dist[S] = 0;
    collected[S] = true;
 
    while (1) {
        /* V = 未被收录顶点中dist最小者 */
        V = FindMinDist( Graph, dist, collected );
        if ( V==ERROR ) /* 若这样的V不存在 */
            break;      /* 算法结束 */
        collected[V] = true;  /* 收录V */
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            /* 若W是V的邻接点并且未被收录 */
            if ( collected[W]==false && Graph->G[V][W]<INFINITY ) {
                if ( Graph->G[V][W]<0 ) /* 若有负边 */
                    return false; /* 不能正确解决，返回错误标记 */
                /* 若收录V使得dist[W]变小 */
                if ( dist[V]+Graph->G[V][W] < dist[W] ) {
                    dist[W] = dist[V]+Graph->G[V][W]; /* 更新dist[W] */
                    path[W] = V; /* 更新S到W的路径 */
                }
            }
    } /* while结束*/
    return true; /* 算法执行完毕，返回正确标记 */
}

/* 邻接矩阵存储 - 多源最短路算法 */
 
bool Floyd( MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[][MaxVertexNum] )
{
    Vertex i, j, k;
 
    /* 初始化 */
    for ( i=0; i<Graph->Nv; i++ )
        for( j=0; j<Graph->Nv; j++ ) {
            D[i][j] = Graph->G[i][j];
            path[i][j] = -1;
        }
 
    for( k=0; k<Graph->Nv; k++ )
        for( i=0; i<Graph->Nv; i++ )
            for( j=0; j<Graph->Nv; j++ )
                if( D[i][k] + D[k][j] < D[i][j] ) {
                    D[i][j] = D[i][k] + D[k][j];
                    if ( i==j && D[i][j]<0 ) /* 若发现负值圈 */
                        return false; /* 不能正确解决，返回错误标记 */
                    path[i][j] = k;
                }
    return true; /* 算法执行完毕，返回正确标记 */
}

哈利·波特的考试

哈利·波特要考试了，他需要你的帮助。这门课学的是用魔咒将一种动物变成另一种动物的本事。例如将猫变成老鼠的魔咒是haha，将老鼠变成鱼的魔咒是hehe等等。反方向变化的魔咒就是简单地将原来的魔咒倒过来念，例如ahah可以将老鼠变成猫。另外，如果想把猫变成鱼，可以通过念一个直接魔咒lalala，也可以将猫变老鼠、老鼠变鱼的魔咒连起来念：hahahehe。

现在哈利·波特的手里有一本教材，里面列出了所有的变形魔咒和能变的动物。老师允许他自己带一只动物去考场，要考察他把这只动物变成任意一只指定动物的本事。于是他来问你：带什么动物去可以让最难变的那种动物（即该动物变为哈利·波特自己带去的动物所需要的魔咒最长）需要的魔咒最短？例如：如果只有猫、鼠、鱼，则显然哈利·波特应该带鼠去，因为鼠变成另外两种动物都只需要念4个字符；而如果带猫去，则至少需要念6个字符才能把猫变成鱼；同理，带鱼去也不是最好的选择。

输入格式:

输入说明：输入第1行给出两个正整数 $N (\leq 100)$ 和 $M$ ，其中 $N$ 是考试涉及的动物总数， $M$ 是用于直接变形的魔咒条数。为简单起见，我们将动物按 $1 N$ 编号。随后 $M$ 行，每行给出了3个正整数，分别是两种动物的编号、以及它们之间变形需要的魔咒的长度 $(\leq 100)$ ，数字之间用空格分隔。

输出格式:

输出哈利·波特应该带去考场的动物的编号、以及最长的变形魔咒的长度，中间以空格分隔。如果只带1只动物是不可能完成所有变形要求的，则输出0。如果有若干只动物都可以备选，则输出编号最小的那只。

输入样例:

输出样例:

4 70

分析： 在这里插入图片描述

代码：

#include <stdio.h>
#include <stdlib.h>

/* 图的邻接矩阵表示法 */

#define MaxVertexNum 100    /* 最大顶点数设为100 */
#define INFINITY 65535        /* ∞设为双字节无符号整数的最大值65535*/
typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
typedef int WeightType;        /* 边的权值设为整型 */

/* 边的定义 */
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* 有向边<V1, V2> */
    WeightType Weight;  /* 权重 */
};
typedef PtrToENode Edge;

/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;  /* 顶点数 */
    int Ne;  /* 边数   */
    WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
};
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */



MGraph CreateGraph( int VertexNum )
{ /* 初始化一个有VertexNum个顶点但没有边的图 */
    Vertex V, W;
    MGraph Graph;
    
    Graph = (MGraph)malloc(sizeof(struct GNode)); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化邻接矩阵 */
    for (V=0; V<Graph->Nv; V++)
        for (W=0; W<Graph->Nv; W++)
            Graph->G[V][W] = INFINITY;
    
    return Graph;
}

void InsertEdge( MGraph Graph, Edge E )
{
    /* 插入边 <V1, V2> */
    Graph->G[E->V1][E->V2] = E->Weight;
    /* 若是无向图，还要插入边<V2, V1> */
    Graph->G[E->V2][E->V1] = E->Weight;
}

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    int Nv, i;
    
    scanf("%d", &Nv);   /* 读入顶点个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */
    
    scanf("%d", &(Graph->Ne));   /* 读入边数 */
    if ( Graph->Ne != 0 ) { /* 如果有边 */
        /* 读入边，格式为"起点 终点 权重"，插入邻接矩阵 */
        for (i=0; i<Graph->Ne; i++) {
            E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点 */
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight);
            E->V1--;  E->V2--;
            /* 注意：如果权重不是整型，Weight的读入格式要改 */
            InsertEdge( Graph, E );
        }
    }
    return Graph;
}
/* 邻接矩阵存储 - 多源最短路算法 */

void Floyd( MGraph Graph, WeightType D[][MaxVertexNum] )
{
    Vertex i, j, k;
    
    /* 初始化 */
    for ( i=0; i<Graph->Nv; i++ )
        for( j=0; j<Graph->Nv; j++ ) {
            D[i][j] = Graph->G[i][j];
        }
    
    for( k=0; k<Graph->Nv; k++ )
        for( i=0; i<Graph->Nv; i++ )
            for( j=0; j<Graph->Nv; j++ )
                if( D[i][k] + D[k][j] < D[i][j] )
                    D[i][j] = D[i][k] + D[k][j];
}

WeightType FindMaxDist( WeightType D[][MaxVertexNum], Vertex i, int N )
{
    WeightType MaxDist;
    Vertex j;
    
    MaxDist = 0;
    for ( j=0; j<N; j++ )
        if ( i!=j && D[i][j] > MaxDist )
            MaxDist = D[i][j];
    return MaxDist;
}

void FindAnimal( MGraph Graph )
{
    WeightType MinDist, MaxDist;
    Vertex Animal, i;
    WeightType D[MaxVertexNum][MaxVertexNum];
    Floyd( Graph, D );
    // FindMin: 从每个动物i的最短距离的最大值中，找到最小值MinDist,以及对应的动物
    MinDist = INFINITY;
    for ( i=0; i<Graph->Nv;i++ ){
        MaxDist = FindMaxDist( D, i, Graph->Nv );
        if ( MaxDist == INFINITY ){
            printf("0\n");
            return;
        }
        if( MinDist > MaxDist ){
            MinDist = MaxDist;
            Animal = i+1;
        }
    }
    printf("%d %d\n", Animal, MinDist);
}

int main()
{
    MGraph G = BuildGraph();
    FindAnimal( G );
    return 0;
}

旅游规划

有了一张自驾旅游路线图，你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序，帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的，那么需要输出最便宜的一条路径。

输入格式:

输入说明：输入数据的第1行给出4个正整数 $N 、 M 、 S 、 D$ ，其中 $N （ 2 \leq N \leq 500 ）$ 是城市的个数，顺便假设城市的编号为0~ $(N - 1)$ ； $M$ 是高速公路的条数； $S$ 是出发地的城市编号； $D$ 是目的地的城市编号。随后的 $M$ 行中，每行给出一条高速公路的信息，分别是：城市1、城市2、高速公路长度、收费额，中间用空格分开，数字均为整数且不超过500。输入保证解的存在。

输出格式:

在一行里输出路径的长度和收费总额，数字间以空格分隔，输出结尾不能有多余空格。

输入样例:

输出样例:

3 40

代码: 在这里插入图片描述

// 单源最短路
// Dijkstra-距离
// 等距离时按收费更新


#include <stdio.h>
#include <stdlib.h>

/* 图的邻接矩阵表示法 */

#define MaxVertexNum 500
#define INFINITY 65535        /* ∞设为双字节无符号整数的最大值65535*/
typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
typedef int LengthType;        /* 边的权值设为整型 */
typedef int CostType;

/* 边的定义 */
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* 有向边<V1, V2> */
    LengthType Length;
    CostType Cost;
};
typedef PtrToENode Edge;

/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;  /* 顶点数 */
    int Ne;  /* 边数   */
    LengthType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
    CostType H[MaxVertexNum][MaxVertexNum];
};
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */

int S, D;

MGraph CreateGraph( int VertexNum )
{ /* 初始化一个有VertexNum个顶点但没有边的图 */
    Vertex V, W;
    MGraph Graph;
    
    Graph = (MGraph)malloc(sizeof(struct GNode)); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化邻接矩阵 */
    /* 注意：这里默认顶点编号从0开始，到(Graph->Nv - 1) */
    for (V=0; V<Graph->Nv; V++)
        for (W=0; W<Graph->Nv; W++)
        {
            Graph->G[V][W] = INFINITY;
            Graph->H[V][W] = INFINITY;
        }
    return Graph;
}

void InsertEdge( MGraph Graph, Edge E )
{
    /* 插入边 <V1, V2> */
    Graph->G[E->V1][E->V2] = E->Length;
    Graph->H[E->V1][E->V2] = E->Cost;
    /* 若是无向图，还要插入边<V2, V1> */
    Graph->G[E->V2][E->V1] = E->Length;
    Graph->H[E->V2][E->V1] = E->Cost;
}

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    int Nv, i;
    
    scanf("%d", &Nv);   /* 读入顶点个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */
    
    scanf("%d", &(Graph->Ne));   /* 读入边数 */
    scanf("%d %d", &S, &D);
    if ( Graph->Ne != 0 ) { /* 如果有边 */
        /* 读入边，格式为"起点 终点 权重"，插入邻接矩阵 */
        for (i=0; i<Graph->Ne; i++) {
            E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点 */
            scanf("%d %d %d %d", &E->V1, &E->V2, &E->Length, &E->Cost);
            InsertEdge( Graph, E );
        }
    }
    return Graph;
}



/* 邻接矩阵存储 - 有权图的单源最短路算法 */

Vertex FindMinDist( MGraph Graph, int dist[], int collected[] )
{ /* 返回未被收录顶点中dist最小者 */
    Vertex MinV=-1, V;
    int MinDist = INFINITY;
    
    for (V=0; V<Graph->Nv; V++) {
        if ( collected[V]==0 && dist[V]<MinDist) {
            /* 若V未被收录，且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距离 */
            MinV = V; /* 更新对应顶点 */
        }
    }
    return MinV; /* 返回对应的顶点下标 */
}

void Dijkstra( MGraph Graph, int dist[], int path[], int cost[], Vertex S )
{
    int collected[MaxVertexNum];
    Vertex V, W;
    
    /* 初始化：此处默认邻接矩阵中不存在的边用INFINITY表示 */
    for ( V=0; V<Graph->Nv; V++ ) {
        dist[V] = Graph->G[S][V];
        cost[V] = Graph->H[S][V];
        if ( dist[V]<INFINITY )
            path[V] = S;
        else
            path[V] = -1;
        collected[V] = 0;
    }
    /* 先将起点收入集合 */
    dist[S] = 0;
    collected[S] = 1;
    
    while (1) {
        /* V = 未被收录顶点中dist最小者 */
        V = FindMinDist( Graph, dist, collected );
        if ( V==-1 ) /* 若这样的V不存在 */
            break;      /* 算法结束 */
        collected[V] = 1;  /* 收录V */
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
        /* 若W是V的邻接点并且未被收录 */
            if ( collected[W]==0 && Graph->G[V][W]<INFINITY ) {
                if ( Graph->G[V][W]<0 ) /* 若有负边 */
                    return; /* 不能正确解决，返回错误标记 */
                /* 若收录V使得dist[W]变小 */
                if ( dist[V]+Graph->G[V][W] < dist[W] ) {
                    dist[W] = dist[V]+Graph->G[V][W]; /* 更新dist[W] */
                    path[W] = V; /* 更新S到W的路径 */
                    cost[W] = cost[V] + Graph->H[V][W];
                }
                else if ( dist[V]+Graph->G[V][W] == dist[W] && cost[V] +Graph->H[V][W] < cost[W]){
                    cost[W] = cost[V] + Graph->H[V][W];
                    path[W] = V;
                }
            }
    } /* while结束*/
    return; /* 算法执行完毕，返回正确标记 */
}

int main()
{
    MGraph Graph;
    Graph = BuildGraph();
    int dist[MaxVertexNum], path[MaxVertexNum], cost[MaxVertexNum];
    Dijkstra(Graph, dist, path, cost, S);
    printf("%d %d\n",dist[D],cost[D]);
}

最小生成树问题(Minimum spanning Tree)

一棵树

无回路
|V|个顶点一定有|V|-1条边

是生成树

包含全部顶点
|V|-1条边都在图里

边的权重和最小

贪心算法：

“贪”：每一步都要最好的
“好”：权重最小的边
需要约束：

只能用图里有的边
只能正好用掉|V|-1条边
不能有回路

实现代码：

/* 邻接矩阵存储 - Prim最小生成树算法 */
 
Vertex FindMinDist( MGraph Graph, WeightType dist[] )
{ /* 返回未被收录顶点中dist最小者 */
    Vertex MinV, V;
    WeightType MinDist = INFINITY;
 
    for (V=0; V<Graph->Nv; V++) {
        if ( dist[V]!=0 && dist[V]<MinDist) {
            /* 若V未被收录，且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距离 */
            MinV = V; /* 更新对应顶点 */
        }
    }
    if (MinDist < INFINITY) /* 若找到最小dist */
        return MinV; /* 返回对应的顶点下标 */
    else return ERROR;  /* 若这样的顶点不存在，返回-1作为标记 */
}
 
int Prim( MGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType dist[MaxVertexNum], TotalWeight;
    Vertex parent[MaxVertexNum], V, W;
    int VCount;
    Edge E;
     
    /* 初始化。默认初始点下标是0 */
       for (V=0; V<Graph->Nv; V++) {
        /* 这里假设若V到W没有直接的边，则Graph->G[V][W]定义为INFINITY */
           dist[V] = Graph->G[0][V];
           parent[V] = 0; /* 暂且定义所有顶点的父结点都是初始点0 */ 
    }
    TotalWeight = 0; /* 初始化权重和     */
    VCount = 0;      /* 初始化收录的顶点数 */
    /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
    MST = CreateGraph(Graph->Nv);
    E = (Edge)malloc( sizeof(struct ENode) ); /* 建立空的边结点 */
            
    /* 将初始点0收录进MST */
    dist[0] = 0;
    VCount ++;
    parent[0] = -1; /* 当前树根是0 */
 
    while (1) {
        V = FindMinDist( Graph, dist );
        /* V = 未被收录顶点中dist最小者 */
        if ( V==ERROR ) /* 若这样的V不存在 */
            break;   /* 算法结束 */
             
        /* 将V及相应的边<parent[V], V>收录进MST */
        E->V1 = parent[V];
        E->V2 = V;
        E->Weight = dist[V];
        InsertEdge( MST, E );
        TotalWeight += dist[V];
        dist[V] = 0;
        VCount++;
         
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            if ( dist[W]!=0 && Graph->G[V][W]<INFINITY ) {
            /* 若W是V的邻接点并且未被收录 */
                if ( Graph->G[V][W] < dist[W] ) {
                /* 若收录V使得dist[W]变小 */
                    dist[W] = Graph->G[V][W]; /* 更新dist[W] */
                    parent[W] = V; /* 更新树 */
                }
            }
    } /* while结束*/
    if ( VCount < Graph->Nv ) /* MST中收的顶点不到|V|个 */
       TotalWeight = ERROR;
    return TotalWeight;   /* 算法执行完毕，返回最小权重和或错误标记 */
}

/* 邻接表存储 - Kruskal最小生成树算法 */
 
/*-------------------- 顶点并查集定义 --------------------*/
typedef Vertex ElementType; /* 默认元素可以用非负整数表示 */
typedef Vertex SetName;     /* 默认用根结点的下标作为集合名称 */
typedef ElementType SetType[MaxVertexNum]; /* 假设集合元素下标从0开始 */
 
void InitializeVSet( SetType S, int N )
{ /* 初始化并查集 */
    ElementType X;
 
    for ( X=0; X<N; X++ ) S[X] = -1;
}
 
void Union( SetType S, SetName Root1, SetName Root2 )
{ /* 这里默认Root1和Root2是不同集合的根结点 */
    /* 保证小集合并入大集合 */
    if ( S[Root2] < S[Root1] ) { /* 如果集合2比较大 */
        S[Root2] += S[Root1];     /* 集合1并入集合2  */
        S[Root1] = Root2;
    }
    else {                         /* 如果集合1比较大 */
        S[Root1] += S[Root2];     /* 集合2并入集合1  */
        S[Root2] = Root1;
    }
}
 
SetName Find( SetType S, ElementType X )
{ /* 默认集合元素全部初始化为-1 */
    if ( S[X] < 0 ) /* 找到集合的根 */
        return X;
    else
        return S[X] = Find( S, S[X] ); /* 路径压缩 */
}
 
bool CheckCycle( SetType VSet, Vertex V1, Vertex V2 )
{ /* 检查连接V1和V2的边是否在现有的最小生成树子集中构成回路 */
    Vertex Root1, Root2;
 
    Root1 = Find( VSet, V1 ); /* 得到V1所属的连通集名称 */
    Root2 = Find( VSet, V2 ); /* 得到V2所属的连通集名称 */
 
    if( Root1==Root2 ) /* 若V1和V2已经连通，则该边不能要 */
        return false;
    else { /* 否则该边可以被收集，同时将V1和V2并入同一连通集 */
        Union( VSet, Root1, Root2 );
        return true;
    }
}
/*-------------------- 并查集定义结束 --------------------*/
 
/*-------------------- 边的最小堆定义 --------------------*/
void PercDown( Edge ESet, int p, int N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p )    */
  /* 将N个元素的边数组中以ESet[p]为根的子堆调整为关于Weight的最小堆 */
    int Parent, Child;
    struct ENode X;
 
    X = ESet[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;
        if( (Child!=N-1) && (ESet[Child].Weight>ESet[Child+1].Weight) )
            Child++;  /* Child指向左右子结点的较小者 */
        if( X.Weight <= ESet[Child].Weight ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            ESet[Parent] = ESet[Child];
    }
    ESet[Parent] = X;
}
 
void InitializeESet( LGraph Graph, Edge ESet )
{ /* 将图的边存入数组ESet，并且初始化为最小堆 */
    Vertex V;
    PtrToAdjVNode W;
    int ECount;
 
    /* 将图的边存入数组ESet */
    ECount = 0;
    for ( V=0; V<Graph->Nv; V++ )
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
            if ( V < W->AdjV ) { /* 避免重复录入无向图的边，只收V1<V2的边 */
                ESet[ECount].V1 = V;
                ESet[ECount].V2 = W->AdjV;
                ESet[ECount++].Weight = W->Weight;
            }
    /* 初始化为最小堆 */
    for ( ECount=Graph->Ne/2; ECount>=0; ECount-- )
        PercDown( ESet, ECount, Graph->Ne );
}
 
int GetEdge( Edge ESet, int CurrentSize )
{ /* 给定当前堆的大小CurrentSize，将当前最小边位置弹出并调整堆 */
 
    /* 将最小边与当前堆的最后一个位置的边交换 */
    Swap( &ESet[0], &ESet[CurrentSize-1]);
    /* 将剩下的边继续调整成最小堆 */
    PercDown( ESet, 0, CurrentSize-1 );
 
    return CurrentSize-1; /* 返回最小边所在位置 */
}
/*-------------------- 最小堆定义结束 --------------------*/
 
 
int Kruskal( LGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType TotalWeight;
    int ECount, NextEdge;
    SetType VSet; /* 顶点数组 */
    Edge ESet;    /* 边数组 */
 
    InitializeVSet( VSet, Graph->Nv ); /* 初始化顶点并查集 */
    ESet = (Edge)malloc( sizeof(struct ENode)*Graph->Ne );
    InitializeESet( Graph, ESet ); /* 初始化边的最小堆 */
    /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
    MST = CreateGraph(Graph->Nv);
    TotalWeight = 0; /* 初始化权重和     */
    ECount = 0;      /* 初始化收录的边数 */
 
    NextEdge = Graph->Ne; /* 原始边集的规模 */
    while ( ECount < Graph->Nv-1 ) {  /* 当收集的边不足以构成树时 */
        NextEdge = GetEdge( ESet, NextEdge ); /* 从边集中得到最小边的位置 */
        if (NextEdge < 0) /* 边集已空 */
            break;
        /* 如果该边的加入不构成回路，即两端结点不属于同一连通集 */
        if ( CheckCycle( VSet, ESet[NextEdge].V1, ESet[NextEdge].V2 )==true ) {
            /* 将该边插入MST */
            InsertEdge( MST, ESet+NextEdge );
            TotalWeight += ESet[NextEdge].Weight; /* 累计权重 */
            ECount++; /* 生成树中边数加1 */
        }
    }
    if ( ECount < Graph->Nv-1 )
        TotalWeight = -1; /* 设置错误标记，表示生成树不存在 */
 
    return TotalWeight;
}

AOV/g拓扑排序

拓扑序：如果图中从V到W有一条有向路径，则V一定排在W之前。满足此条件的顶点序列称为一个拓扑序。获得一个拓扑序的过程就是拓扑排序
AOV如果有合理的拓扑许，则必定是有向无环图(Directed Acyclic Graph, DAG)

在这里插入图片描述

AOE/关键路径问题

在这里插入图片描述

/* 邻接表存储 - 拓扑排序算法 */
 
bool TopSort( LGraph Graph, Vertex TopOrder[] )
{ /* 对Graph进行拓扑排序,  TopOrder[]顺序存储排序后的顶点下标 */
    int Indegree[MaxVertexNum], cnt;
    Vertex V;
    PtrToAdjVNode W;
       Queue Q = CreateQueue( Graph->Nv );
  
    /* 初始化Indegree[] */
    for (V=0; V<Graph->Nv; V++)
        Indegree[V] = 0;
         
    /* 遍历图，得到Indegree[] */
    for (V=0; V<Graph->Nv; V++)
        for (W=Graph->G[V].FirstEdge; W; W=W->Next)
            Indegree[W->AdjV]++; /* 对有向边<V, W->AdjV>累计终点的入度 */
             
    /* 将所有入度为0的顶点入列 */
    for (V=0; V<Graph->Nv; V++)
        if ( Indegree[V]==0 )
            AddQ(Q, V);
             
    /* 下面进入拓扑排序 */ 
    cnt = 0; 
    while( !IsEmpty(Q) ){
        V = DeleteQ(Q); /* 弹出一个入度为0的顶点 */
        TopOrder[cnt++] = V; /* 将之存为结果序列的下一个元素 */
        /* 对V的每个邻接点W->AdjV */
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
            if ( --Indegree[W->AdjV] == 0 )/* 若删除V使得W->AdjV入度为0 */
                AddQ(Q, W->AdjV); /* 则该顶点入列 */ 
    } /* while结束*/
     
    if ( cnt != Graph->Nv )
        return false; /* 说明图中有回路, 返回不成功标志 */ 
    else
        return true;
}

kguazju

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
图

文章目录图什么是图抽象数据类型定义：怎么在程序中表示一个图：建立图的C语言实现：图的邻接矩阵表示法实现代码：图的邻接表表示法实现代码：图的遍历：DFS(Depth First Search):BFS(Breadth First Search):图不连通列出连通集Saving James Bond - Easy Version六度空间最短路径问题问题分类无权图的单源最短路算法有权图的单源最短路算法D...
复制链接

扫一扫