1.学习总结(2)

1.1图的思维导图

1.2 图结构学习体会

深度遍历算法

其利用深度优先搜索算法可以产生目标图的相应拓扑排序表,利用拓扑排序表可以方便的解决很多相关的图论问题,如最大路径问题等等。

广度遍历算法

广度优先遍历连通图的一种遍历策略。因为它的思想是从一个顶点V0开始,辐射状地优先遍历其周围较广的区域,

Prim和Kruscal算法

Prim算法:就是点优先,原始集合里面存放所有的点,目标集合最初为空,先任意从原始集合取一个点放在目标集合,此时开始搜索,原始集合到目标集合最近的一个点,找到后将他放入目标集合,更新原始集合中的点到目标集合的距离,一直将原始集合中的点全部加入到目标集合中,完成搜索。

Kruskal算法:就是边优先,先将每一条边从大到小排序,每次去最小的一条边连接两个点,但是需要判断,是否形成回路。

Dijkstra算法

Dijkstra算法一般的表述通常有两种方式,一种用永久和临时标号方式,一种是用OPEN, CLOSE表的方式,这里均采用永久和临时标号的方式。注意该算法要求图中不存在负权边。

拓扑排序算法

对一个有向无环图G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若边(u,v)∈E(G),则u在线性序列中出现在v之前

2.PTA实验作业(4分)


2.1 题目1:7-1 图着色问题

2.2 设计思路(伪代码或流程图)

2.3 代码截图

 

 

2.4 PTA提交列表说明。


一开始因为自己的疏忽 没有事先在Dev上很好的运行,导致基础的编译错误,理解问题以后仔细检查之后发现是非常不应该的错误,改正以后得以解决。

2.1 7-2 排座位

2.2 设计思路(伪代码或流程图)

2.3 代码截图

 

2.4 PTA提交列表说明。

 

一开始因为自己的疏忽 没有事先在Dev上很好的运行,没有全面考虑问题,理解问题以后仔细检查之后发现是非常不应该的错误,改正以后得以解决。

2.1 题目1:7-4 公路村村通

2.2 设计思路(伪代码或流程图)

2.3 代码截图

 

2.4 PTA提交列表说明。

 

一开始因为自己的疏忽 没有事先在Dev上很好的运行,导致基础的编译错误,理解问题以后仔细检查之后发现是非常不应该的错误,改正以后得以解决。

3.截图本周题目集的PTA最后排名(3分)

3.1 PTA排名(截图带自己名字的排名)

 

3.2 我的总分:

 200

4. 阅读代码(必做,1分)

#include <stdio.h>   

#include <stdlib.h>  

#include <math.h> 

#include <time.h>

 

#define MAXVEX 6 // 最大顶点数

#define INF 65535

 

typedef int Status; //Status是函数的类型,其值是函数结果状态代码,如OK等

typedef char VertexType; //顶点类型 

typedef int EdgeType; // 边上的权值类型

typedef struct

{

    VertexType vexs[MAXVEX]; //顶点表

    EdgeType arc[MAXVEX][MAXVEX];//邻接矩阵,可看作边表

    int numNodes, numEdges; // 图中当前的顶点数和边数

}MGraph;

 

// 建立无向网图的邻接矩阵表示

void CreateMGraph(MGraph *G)

{

    int i,j,k,w;

    printf("输入顶点数和边数:\n");

   scanf("%d,%d",&G->numNodes,&G->numEdges); // 输入顶点数和边数

    for(i = 0;i <G->numNodes;i++) // 读入顶点信息,建立顶点表

        scanf("%c",&G->vexs[i]);

    for(i = 0;i <G->numNodes;i++)

        for(j = 0;j <G->numNodes;j++)

            G->arc[i][j]=INF;   // 邻接矩阵初始化

    for(k = 0;k <G->numEdges;k++) // 读入numEdges条边,建立邻接矩阵

    {

        printf("输入边(vi,vj)上的下标i,下标j和权w:\n");

       scanf("%d,%d,%d",&i,&j,&w); // 输入边(vi,vj)上的权w

        G->arc[i][j]=w;

        G->arc[j][i]= G->arc[i][j]; //因为是无向图,矩阵对称

    }

}

 

int main(void)

{   

    MGraph G;   

    CreateMGraph(&G);

    return 0;

}

 

#include<stdio.h>

#include<iostream.h>

 

#define MAXVEX 100 //最大顶点数

typedef char VertexType; //顶点类型应由用户定义

typedef int EdgeType; //边上的权值类型应由用户定义

 

typedef struct EdgeNode//边表结点

{

    int adjvex;//邻接点域,存储该顶点对应的下标

    EdgeType weight;//用于存储权值,对于非网图可以不需要

    struct EdgeNode *next; //链域,指向下一个邻接点

} EdgeNode;

 

typedef struct VextexNode//顶点表结点

{

    VertexType data;//顶点域,存储顶点信息

    EdgeNode *firstedge;//边表头指针

} VextexNode, AdjList[MAXVEX];

 

typedef struct

{

    AdjList adjList;

    int numNodes, numEdges; // 图中当前顶点数和边数

} GraphAdjList;

voidCreateALGraph(GraphAdjList *Gp)

{

    int i, j, k;

    EdgeNode *pe;

    printf("输入顶点数和边数(空格分隔):");

   scanf("%d%d",&Gp->numNodes,&Gp->numEdges);

 

    for (i = 0 ; i < Gp->numNodes; i++)

    {

        printf("输入顶点信息:");

       scanf("%c",&Gp->adjList[i].data);

        Gp->adjList[i].firstedge = NULL;//将边表置为空表

    }

 

    for (k = 0; k <  Gp->numEdges; k++)//建立边表

    {

        printf("输入边(vi,vj)的顶点序号i,j(空格分隔:");

        scanf("%d%d",&i,&j);

        pe = (EdgeNode*)malloc(sizeof(EdgeNode));

        pe->adjvex = j;//邻接序号为j

        //将pe的指针指向当前顶点上指向的结点

        pe->next =Gp->adjList[i].firstedge;

        Gp->adjList[i].firstedge = pe;//将当前顶点的指针指向pe

 

        pe = (EdgeNode*)malloc(sizeof(EdgeNode));

        pe->adjvex = i;

        pe->next =Gp->adjList[j].firstedge;

        Gp->adjList[j].firstedge = pe;

 

    }

}

int main(void)

{

    GraphAdjList GL;

    CreateALGraph(&GL);

 

    return 0;

}

pim算法和Kruskal两种实现方法

#include<stdio.h> 

int arr[101][101]; 

int main()

    int n,ttt = 0; 

    scanf("%d",&n); 

    for(int i=1;i<=n;i++)

    { 

        for(int j=1;j<=n;j++)

       { 

           scanf("%d",&arr[i][j]); 

        } 

    }    

    for(int j=2;j<=n;j++)

    { 

        int min = 100000000; 

        int index = 0; 

        for(int i=1;i<=n;i++)

       { 

            if(arr[1][i]==0) continue; 

            if(arr[1][i]<min)

           { 

                min = arr[1][i]; 

                index = i; 

            } 

        } 

        ttt += arr[1][index]; 

        for(int i=1;i<=n;i++)

       { 

            arr[1][i] =arr[1][i]<arr[index][i]?arr[1][i]:arr[index][i]; 

        } 

    } 

    printf("%d\n",ttt); 

    return 0; 

#include <stdio.h>

#include <stdlib.h>

#define MAX_VEX_NUM 50

#define MAX_ARC_NUM 100

#define UN_REACH 1000

typedef char VertexType;

typedef enum

{

    DG, UDG

}GraphType;

typedef struct

{

    VertexType vexs[MAX_VEX_NUM];

    int arcs[MAX_VEX_NUM][MAX_VEX_NUM];

    int vexnum, arcnum;

    GraphType type;

}MGraph;

/**

 * 根据名称得到指定顶点在顶点集合中的下标

 * vex  顶点

 * return 如果找到,则返回下标,否则,返回0

 */

int getIndexOfVexs(char vex,MGraph *MG)

 {

    int i;

    for (i = 1; i <= MG->vexnum; i++)

    {

        if (MG->vexs[i] == vex)

       {

            return i;

        }

    }

    return 0;

}

/**

 * 创建邻接矩阵

 */

void create_MG(MGraph *MG)

 {

    int i, j, k,weight;

    int v1, v2, type;

    char c1, c2;

    printf("请输入图类型DG(0)和图(1) :");

    scanf("%d", &type);

    if (type == 0)

        MG->type = DG;

    else if (type == 1)

        MG->type = UDG;

    else

    {

        printf("请输入正确的图形类型DG(0)和图(1)");

        return;

    }

 printf("请输入vexmun : ");

    scanf("%d", &MG->vexnum);

    printf("请输入 arcnum :" );

    scanf("%d", &MG->arcnum);

    getchar();

    for (i = 1; i <= MG->vexnum; i++)

    {

        printf("请输入 %dth vex(char):", i);

        scanf("%c",&MG->vexs[i]);

        getchar();

    }

  //初始化邻接矩阵

    for (i = 1; i <= MG->vexnum; i++)

    {

        for (j = 1; j <= MG->vexnum; j++)

       {

            if(i == j)

                MG->arcs[i][j] = 0;

            else

                MG->arcs[i][j] = UN_REACH;

        }

    }

  //输入边的信息,建立邻接矩阵

    for (k = 1; k <= MG->arcnum; k++)

    {

        printf("请输入 %dth arc v1(char) v2(char) weight(int):", k);

 

        scanf("%c %c %d", &c1,&c2,&weight);

       v1 = getIndexOfVexs(c1, MG);

        v2 = getIndexOfVexs(c2, MG);

        if (MG->type == 1)

            MG->arcs[v1][v2] =MG->arcs[v2][v1] = weight;

        else

            MG->arcs[v1][v2] = weight;

        getchar();

    }

 

 

 

 

}

/**

 * 打印邻接矩阵和顶点信息

 */

void print_MG(MGraph MG)

{

    int i, j;

    if(MG.type == DG)

    {

        printf("Graph type: Directgraph");

    }

    else

    {

        printf("Graph type: Undirectgraph");

    }

 

    printf("图的顶点数: %d,MG.vexnum");

    printf("图弧数: %d,MG.arcnum");

 

    printf("Vertex set:");

    for (i = 1; i <= MG.vexnum; i++)

        printf("%c", MG.vexs[i]);

    printf("邻接矩阵:");

 

    for (i = 1; i <= MG.vexnum; i++)

    {

        j = 1;

        for (; j < MG.vexnum; j++)

       {

            printf("%d", MG.arcs[i][j]);

        }

        printf("%d", MG.arcs[i][j]);

    }

}

 

 

// 定义边结构体

typedef struct

{

    int start;

    int end;

    int cost;

}Edge;

 

 

/* *

 * 由邻接矩阵得到边的信息

 *

 * */

void init_edge(MGraph MG,Edgeedge[])

{

    int i,j;

    int count = 0;

    if(MG.type == 0)

    {

        for(i = 1; i <= MG.vexnum;i++)

       {

            for (j = 1;j <= MG.vexnum;j++)

           {

                if(MG.arcs[i][j] != 0&& MG.arcs[i][j] != UN_REACH)

              {

                    edge[count].start = i;

                    edge[count].end = j;

                    edge[count].cost =MG.arcs[i][j];

                    count++;

                }

            }

        }

    }

    else

    {

        for(i = 1; i <= MG.vexnum;i++)

       {

            for (j = i;j <= MG.vexnum;j++)

           {

                if(MG.arcs[i][j] != 0 &&MG.arcs[i][j] != UN_REACH)

              {

                    edge[count].start = i;

                    edge[count].end = j;

                    edge[count].cost =MG.arcs[i][j];

                    count++;

                }

            }

        }

    }

    

}

 

 

 

 

/* *

 * 将边按权值从大到小排序

 * */

void sort_edge(Edge edge[],intarcnum)

{

    int i,j;

    Edge temp;

    for(i = 0; i < arcnum - 1;i++)

    {

        for (j = i+1;j < arcnum;j++)

       {

            if(edge[i].cost > edge[j].cost)

           {

                temp = edge[i];

                edge[i] = edge[j];

                edge[j] = temp;

            }

        }

    }

}

 

/* *

 * 输出边的信息

 * */

void print_edge(Edgeedge[],int arcnum)

{

    int i = 0;

    while(i < arcnum)

    {

        printf("%d,%d,%d",edge[i].start,edge[i].end,edge[i].cost);

        i++;

    }

}

/**

*    找出指定节点的所属的连通分量,这里是找出其根节点在father数组中下标。

**/ int findFather(intfather[],int v)

{

    int t = v;

    while(father[t] != -1)

        t = father[t];

    return t;

}

 

/* *

 *Kruskal算法求最小生成树

 * */

void Kruskal_MG(MGraph MG,Edgeedge[])

{

    int father[MAX_VEX_NUM];

    int i,count,vf1,vf2;

    // 初始化father数组

    for(i = 0;i < MAX_VEX_NUM;i++)

    {

        father[i] = -1;

    }

    i = 0;

    count = 0; // 统计加入最小生树中的边数

    // 遍历任意两个结点之间的边

    while(i < MG.arcnum && count< MG.arcnum)

    {

        vf1 = findFather(father,edge[i].start);

        vf2 = findFather(father,edge[i].end);

        // 如果这两个节点不属于同一个连通分量,则加入同一个连通分量

        if (vf1 != vf2)

       {

            father[vf2] = vf1;

            count++;

           printf("%c,%c,%d",MG.vexs[edge[i].start],MG.vexs[edge[i].end],edge[i].cost);

        }

        i++;

    }

}

/**

 * 主函数

 */

int main(void)

 {

    MGraph MG;

    Edge edge[MAX_ARC_NUM];

    create_MG(&MG);

    print_MG(MG);

    init_edge(MG,edge);

    sort_edge(edge,MG.arcnum);

    printf("the result of Kruskal:");

    Kruskal_MG(MG,edge);     

    

    return EXIT_SUCCESS;

}

posted @ 2018-06-18 22:50  Potattto  阅读(333)  评论(0编辑  收藏  举报