数据结构学习第二十一天

23:34:47 2019-09-06

学校未开课 继续接着暑假学习

PTA第21题 Prim最小树生成

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
#define INIFITY 65635

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

typedef struct Graph* MGraph;
struct Graph
{
    int Nv;
    int Ne;
    int G[1001][1001];
};

MGraph CreateGraph(int VertexNum)
{
    MGraph Graph = (MGraph)malloc(sizeof(struct Graph));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    for (int i = 0; i < Graph->Nv; i++)
        for (int j = 0; j < Graph->Nv; j++)
            Graph->G[i][j] = INIFITY;
    return Graph;
}

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

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

int IsEdge(MGraph Graph, Vertex V, Vertex W)
{
    return (Graph->G[V][W] < INIFITY) ? 1 : 0;
}
//利用Prim算法 解决最小生成树的问题

int Dist[1001];  //表示某点到树的距离
int Parent[1001];
int TotalWeight;    //表示总的成本
int VCount;  //表示收录的点数
int FindMinDist(MGraph Graph)
{
    int MinDist = INIFITY;
    int MinV;
    for (int i = 0; i < Graph->Nv; i++)
    {
        if (Dist[i]!=-1&& Dist[i] < MinDist)
        {
            MinDist = Dist[i];
            MinV = i;
        }
    }
    if (MinDist < INIFITY)
        return MinV;
    else
        return 0;
}
int Prim(MGraph Graph, Vertex S)
{
    for (int i = 0; i < Graph->Nv; i++)
    {
        Dist[i] = Graph->G[S][i];
        if (Dist[i] < INIFITY)
            Parent[i] = S;
        else
            Parent[i] = -1;
    }
    Dist[S] = -1;
    Parent[S] = -1;
    VCount++;
    while (1)
    {
        int V = FindMinDist(Graph);
        if (!V)
            break;
        TotalWeight += Dist[V];
        Dist[V] = -1;
        VCount++;
        for (int i = 0; i < Graph->Nv; i++)
        {
            if (Dist[i]!=-1&& IsEdge(Graph, V, i))
            {
                if (Graph->G[V][i] < Dist[i])
                {
                    Dist[i] = Graph->G[V][i];
                    Parent[i] = V;
                }
            }
        }
    }
    if (VCount <Graph->Nv)
        return -1;
    else
        return TotalWeight;
}
int main()
{
    MGraph Graph = BuildGraph();
    printf("%d", Prim(Graph, 0));
    return 0;
}

拓扑排序

拓扑序:如果图中从V到W有一条有向路径,则V一定排在W之前.满足此条件的顶点序列称为一个拓扑序

获得一个拓扑序的过程就是拓扑排序

AOV(Acitivity On Vertex)网络 如果有合理的拓扑序,则必定是有向无环图(Directed Acyclic Graph,DAG)

关键路径问题(拓扑排序应用)

AOE(Acitivity On Edge)网络  （os:PTA上有道题看了我好长时间都不会 。。果然我不看教程就啥也不会)

　　一般用于安排项目的工序

关键路径问题 中

最短时间

$Earliest[0]=0; \ Earliest[j]=mathop{max}limits_{<i,j>in E} {Earliest[i]+C_<i,j>}$

在保证最短时间下计算机动时间

机动时间: $D_<i,j>=Latest[j]-Earliest[i]-C_<i,j>$

$Latest[Last]=Earliest[Last]$     //Last表示最后一个节点

$Latest[i]=mathop{min}limits_{<i,j>in E} {Earlist[j]-C_<i,j>}$

关键路径 由绝对不允许延误的活动组成的路径(没有机动时间)

拓扑排序

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
//表示图的两种方法
//邻接矩阵 G[N][N] N个顶点从0到N-1编号
//邻接表 表示
/*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 ShortestPath(Graph G, Vertex v, int Dist[]); //计算图G中顶点v到任意其它顶点的最短距离
void MST(Graph G); //计算图G的最小生成树*/
//图的邻接表表示法
#define MaxVerterNum 100    //最大顶点数
#define INFINITY 65535        //
typedef int Vertex;            //顶点下标表示顶点
typedef int WeightType;        //边的权值
typedef char DataType;        //顶点存储的数据类型

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

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

//顶点表头节点的定义
typedef struct Vnode
{
    PtrToAdjVNode FirstEdge;  //边表头指针
    DataType Data;            //存顶点的数据
    int Indegree;            //入度
}AdjList[MaxVerterNum];        //AdjList是邻接表类型

//图节点的定义
typedef struct GNode* PtrToGNode;
typedef PtrToGNode LGraph;
struct GNode
{
    int Nv;  //顶点数
    int Ne;  //边数
    AdjList G;  //邻接表
};

LGraph CreateGraph(int VertexNum)
{//初始化一个有VertexNum个顶点但没有边的图
    Vertex V;
    LGraph Graph;

    Graph = (LGraph)malloc(sizeof(struct GNode)); //建立图
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    //初始化邻接表头指针
    for (V = 0; V < Graph->Nv; V++)
        Graph->G[V].FirstEdge = NULL;
    return Graph;
}
void InsertEdge(LGraph Graph, Edge E)
{
    PtrToAdjVNode NewNode;
    //插入边<V1,V2>
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;
    Graph->G[E->V2].Indegree++;

    //若是无向图 还要插入边<V2,V1>
    /*NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->Weight;
    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);
            InsertEdge(Graph, E);
        }
    }
    /* 如果顶点有数据的话，读入数据 */
    for (V = 0; V < Graph->Nv; V++)
        scanf(" %c", &(Graph->G[V].Data));
    return Graph;
}

#define Size 100
int Queue[Size];
int Front = 1;
int Rear = 0;
int size = 0;
int Succ(int Num)
{
    if (Num < Size)
        return Num;
    else
        return 0;
}
void EnQueue(int Num)
{
    Rear = Succ(Rear + 1);
    Queue[Rear] = Num;
    size++;
}
int DeQueue()
{
    int Num = Queue[Front];
    Front = Succ(Front + 1);
    size--;
    return Num;
}
int IsEmpty()
{
    return (size == 0) ? 1 : 0;
}

//利用邻接表实现拓扑排序
int TopOrder[100];  //顺序存储排序后的顶点下标
int TopSort(LGraph Graph)
{        //对Graph进为拓扑排序 ,TopOrder[] 顺序存储排序后的顶点下标
    int Indegree[100];
    int cnt = 0;
    for (int i = 0; i < Graph->Nv; i++)    //初始化Indegree
        Indegree[i] = 0;
    for(int i=0;i<Graph->Nv;i++)
        for (PtrToAdjVNode W = Graph->G[i].FirstEdge; W; W = W->Next)
        {
            Indegree[W->AdjV]++;
        }
    for (int i = 0; i < Graph->Nv; i++)
        if (Indegree[i] == 0)
            EnQueue(i);

    //进入拓扑排序
    while (!IsEmpty())
    {
        int V = DeQueue();
        TopOrder[cnt++] = V;
        for (PtrToAdjVNode W = Graph->G[V].FirstEdge; W; W = W->Next)
            if (--Indegree[W->AdjV] == 0)
                EnQueue(W->AdjV);
    }
    if (cnt != Graph->Nv)
        return 0;
    else
        return 1;
}

PTA 第22题 拓扑排序(关键路径)  注意关键路径找完成时间时 取所有中最大值

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
//表示图的两种方法
//邻接矩阵 G[N][N] N个顶点从0到N-1编号
//邻接表 表示
/*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 ShortestPath(Graph G, Vertex v, int Dist[]); //计算图G中顶点v到任意其它顶点的最短距离
void MST(Graph G); //计算图G的最小生成树*/
//图的邻接表表示法
#define MaxVerterNum 100    //最大顶点数
#define INFINITY 65535        //
typedef int Vertex;            //顶点下标表示顶点
typedef int WeightType;        //边的权值
typedef char DataType;        //顶点存储的数据类型

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

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

//顶点表头节点的定义
typedef struct Vnode
{
    PtrToAdjVNode FirstEdge;  //边表头指针
    DataType Data;            //存顶点的数据
    int Indegree;            //入度
}AdjList[MaxVerterNum];        //AdjList是邻接表类型

//图节点的定义
typedef struct GNode* PtrToGNode;
typedef PtrToGNode LGraph;
struct GNode
{
    int Nv;  //顶点数
    int Ne;  //边数
    AdjList G;  //邻接表
};

LGraph CreateGraph(int VertexNum)
{//初始化一个有VertexNum个顶点但没有边的图
    Vertex V;
    LGraph Graph;

    Graph = (LGraph)malloc(sizeof(struct GNode)); //建立图
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    //初始化邻接表头指针
    for (V = 0; V < Graph->Nv; V++)
        Graph->G[V].FirstEdge = NULL;
    return Graph;
}
void InsertEdge(LGraph Graph, Edge E)
{
    PtrToAdjVNode NewNode;
    //插入边<V1,V2>
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;
    Graph->G[E->V2].Indegree++;

    //若是无向图 还要插入边<V2,V1>
    /*NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->Weight;
    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);
            InsertEdge(Graph, E);
        }
    }
    return Graph;
}

#define Size 100
int Queue[Size];
int Front = 1;
int Rear = 0;
int size = 0;
int Succ(int Num)
{
    if (Num < Size)
        return Num;
    else
        return 0;
}
void EnQueue(int Num)
{
    Rear = Succ(Rear + 1);
    Queue[Rear] = Num;
    size++;
}
int DeQueue()
{
    int Num = Queue[Front];
    Front = Succ(Front + 1);
    size--;
    return Num;
}
int IsEmpty()
{
    return (size == 0) ? 1 : 0;
}

//利用邻接表实现拓扑排序
int TopOrder[100];  //顺序存储排序后的顶点下标
int Earliest[100];
int TopSort(LGraph Graph)
{        //对Graph进为拓扑排序 ,TopOrder[] 顺序存储排序后的顶点下标
    int Indegree[100];
    int cnt = 0;
    for (int i = 0; i < Graph->Nv; i++)    //初始化Indegree
        Indegree[i] = 0;
    for (int i = 0; i < Graph->Nv; i++)
        for (PtrToAdjVNode W = Graph->G[i].FirstEdge; W; W = W->Next)
        {
            Indegree[W->AdjV]++;
        }
    for (int i = 0; i < Graph->Nv; i++)
        if (Indegree[i] == 0)
        {
            EnQueue(i);
            Earliest[i] = 0;
        }
    //进入拓扑排序
    while (!IsEmpty())
    {
        int V = DeQueue();
        TopOrder[cnt++] = V;
        for (PtrToAdjVNode W = Graph->G[V].FirstEdge; W; W = W->Next)
        {
            if (--Indegree[W->AdjV] == 0)
            {
                if ((Earliest[V] + W->Weight) > Earliest[W->AdjV])
                    Earliest[W->AdjV] = Earliest[V] + W->Weight;
                EnQueue(W->AdjV);
            }
        }
    }
    if (cnt != Graph->Nv)
        return 0;
    else
    {
        int Max=-1;
        int V;
        for (int i = 0; i < Graph->Nv; i++)
        {
            if (Earliest[i]>Max)
            {
                Max = Earliest[i];
                V = i;
            }
        }
        return Max;
    }
}

int main()
{
    LGraph Graph = BuildGraph();
    int Sum;
    if (!(Sum = TopSort(Graph)))
        printf("Impossible");
    else   //找到最大的那个
        printf("%d", Sum);
}