图 - 小柠 - 博客园

图

一.学习总结

1.图的思维导图：

2.图结构学习体会：图是不同于顺序表和链表等线性存储结构的一种非线性存储结构，由顶点的有穷非空集合和顶点之间边的集合组成。图的概念，算法非常多，且较难理解，不注意就会混淆，必须多加复习来巩固对图的基本概念及算法代码的理解。

（1）几个经典算法学习体会

深度遍历算法：算法采用递归方法实现，代码比较易于理解

广度遍历算法：算法采用队列算法实现，代码比较易于理解

Prim和Kruscal算法：Prim算法采用两个辅助数组lowcost【】和closest【】来存储相关信息，Kruscal算法在Prim算法基础上多一个辅助数组vset【】，两个算法代码都较难理解

Dijkstra算法：Dijkstra算法的精髓是两个数组dist【】和path【】在每次加入顶点后的变化情况，算法代码比较难懂

拓扑排序算法：拓扑排序的核心在于找入度为零的顶点，并将其出度删除，算法代码较好理解

二.PTA实验作业

题目一：7-1 图着色问题

（1）设计思路：直接用图的遍历，遍历的时候判断颜色是否相等。

（2）代码截图：

（3）PTA提交列表说明：

1.情况考虑不全部导致部分错误

2.编译环境错误导致编译错误

题目二：7-2 排座位

（1）设计思路：采用图的深度遍历判断给出的两个宾格的关系，并存储在两个辅助数组中，递归调用判断是否满足题意

（2）代码截图：

（3）PTA提交列表说明：

1.考虑情况不全导致部分错误

题目三：7-4 公路村村通

（1）设计思路：该代码为参考代码，采用Prim算法和函数调用来实现，子函数FindMin查找到最小的公路路径，子函数Cost找到最少的公路花费

（2）代码截图：

#include <iostream>
using namespace std;
#define N_Max 1002
#define M_Max 3006
#define MaxValue 9999999

typedef struct MGraph *PGraph;
struct MGraph
{
    int G[N_Max][N_Max];
    int Nv;
    int Ne;
    int Flag;
};

PGraph CreateGraph(int N,int M)
{
    PGraph Graph=new(MGraph);
    Graph->Flag=0;
    Graph->Nv=N;
    Graph->Ne=M;
    for (int i=1; i<=Graph->Nv; ++i)
    {
        for (int k=1; k<=Graph->Nv; ++k)
        {
            Graph->G[i][k]=MaxValue;
            Graph->G[k][i]=MaxValue;
        }

    }
    return Graph;
}

int FindMin(int LowCost[],int n)
{
    int j=0,k=0,MinCost=MaxValue;
    for (k=1,j=1; j<=n; ++j)
    {
        if (LowCost[j]&&LowCost[j]<MinCost)
        {
            MinCost=LowCost[j];
            k=j;
        }
    }
    if (k==1)
    {
        return 0;
    }else
    {
        return k;
    }
}

void Prim(PGraph Graph,int Parent[])
{
    int LowCost[N_Max];
    for (int i=1; i<=Graph->Nv; ++i)
    {
        LowCost[i]=MaxValue;
    }
    int i,j,k;

    for (i=2; i<=Graph->Nv; ++i)
    {
        LowCost[i]=Graph->G[1][i];
        Parent[i]=1;
    }
    LowCost[1]=0;
    Parent[1]=-1;

    for (i=2;i<=Graph->Nv; ++i)
    {
        k=FindMin(LowCost,Graph->Nv);
        if (k)
        {
            LowCost[k]=0;
            for (j=2; j<=Graph->Nv; ++j)
            {
                if (LowCost[j]&&Graph->G[k][j]<LowCost[j])
                {
                    LowCost[j]=Graph->G[k][j];
                    Parent[j]=k;
                }
            }
        }else
        {
            Graph->Flag=1;
            break;
        }
    }

}

PGraph BuildGraph(PGraph Graph)
{
    int row=0,lie=0,weight=0;
    for (int i=1; i<=Graph->Ne; ++i)
    {
        cin>>row>>lie>>weight;
        Graph->G[row][lie]=weight;
        Graph->G[lie][row]=weight;
    }
    return Graph;
}

int Cost(int A[],PGraph Graph)
{
    int temp=0,cost=0;
    for (int i=2; i<=Graph->Nv; ++i)
    {
        temp=A[i];
        cost+=Graph->G[i][temp];
    }
    return cost;
}

int main(int argc, const char * argv[])
{
    //Input
    int N=0,M=0,cost=0;
    cin>>N>>M;
    PGraph Graph=CreateGraph(N, M);
    Graph=BuildGraph(Graph);

    int Parent[N_Max]={0};
    Prim(Graph, Parent);
    if (Graph->Flag==0)
    {
        cost=Cost(Parent,Graph);
    }


    if (N==1)
    {
        cout<<'0';
    }
    else
    {

        if (Graph->Flag==0)
        {
            cout<<cost;
        }else{
            cout<<"-1";
        }
    }
    return 0;
}