【数据结构与算法暑期实习】PTA 分而治之（邻接表）

一、题目

分而治之，各个击破是兵家常用的策略之一。在战争中，我们希望首先攻下敌方的部分城市，使其剩余的城市变成孤立无援，然后再分头各个击破。为此参谋部提供了若干打击方案。本题就请你编写程序，判断每个方案的可行性。

输入格式：
输入在第一行给出两个正整数 N 和 M（均不超过10 000），分别为敌方城市个数（于是默认城市从 1 到 N 编号）和连接两城市的通路条数。随后 M 行，每行给出一条通路所连接的两个城市的编号，其间以一个空格分隔。在城市信息之后给出参谋部的系列方案，即一个正整数 K （≤ 100）和随后的 K 行方案，每行按以下格式给出：

Np v[1] v[2] ... v[Np]

其中 Np 是该方案中计划攻下的城市数量，后面的系列 v[i] 是计划攻下的城市编号。

输出格式：
对每一套方案，如果可行就输出YES，否则输出NO。

输入样例：

10 11
8 7
6 8
4 5
8 4
8 1
1 2
1 4
9 8
9 1
1 10
2 4
5
4 10 3 8 4
6 6 1 7 5 4 9
3 1 8 4
2 2 8
7 9 8 7 6 5 4 2

输出样例：

NO
YES
YES
NO
NO

二、思路

关键点仍然为2个：
（1）图的存储方式，这里我采用的是邻接表。邻接表很多情况下比邻接矩阵好用，它可以减少不必要的遍历！尽管它的建立和相关的函数写起来比较麻烦，不过写出来一个模板后今后就可直接用了。（邻接表抠了好几天，这里终于搞出来了！）
（2）处理题目逻辑：判断攻城方案是否可行。有了清晰的邻接表后你会发现这个问题很好解决。

三、代码

邻接表结构定义和函数定义

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
using namespace std;

#define MaxVertexNum 10001	/* 最大顶点数设为10001 */
typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
typedef int WeightType;		/* 边的权值设为整型 */
typedef int Elementype;

/* 边的定义 */
typedef struct ENode* PtrToENode;
struct ENode {
    Vertex v1, v2;      
    int weight;  
};
typedef PtrToENode Edge;


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


/*顶点表头结点的定义*/
typedef struct VNode {
    PtrToAdjVNode firstEdge;//边表头指针

}AdjList[MaxVertexNum]; //AdjList是邻接表类型


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


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

    Graph = (LGraph)malloc(sizeof(struct GNode)); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化邻接表头指针 */
    for (v = 1; v <= Graph->Nv; v++) {
        Graph->G[v].firstEdge = NULL;
    }
    return Graph;
}


/* 插入边 <V1, V2>，有向图 */
void InsertEdge(LGraph Graph, Edge E)
{
    PtrToAdjVNode newNode;
    /*插入边，为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;

    /*无向图*/
    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;
    int Nv, i;
    PtrToAdjVNode w;

    scanf("%d", &Nv);   /* 读入顶点个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */
    scanf("%d", &(Graph->Ne));   /* 读入边数 */
    /*
    for (i = 0; i < Graph->Nv; i++) {
        for (w = Graph->G[i].firstEdge; w; w = w->next) {
            Graph->G[i].firstEdge->weight = NULL;
            Graph->G[i].firstEdge = Graph->G[i].firstEdge->next;
        }
    }
    */

    /*
    for(i=0;i<Graph->Nv; i++){
        while (w == Graph->G[i].firstEdge){
            Graph->G[i].firstEdge->weight = NULL;
            w=w->next;
        }
    }
    */


    if (Graph->Ne != 0) { /* 如果有边 */
        E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点 */
        /* 读入边，格式为"起点 终点"，插入邻接矩阵 */
        for (i = 1; i <= Graph->Ne; i++) {
            scanf("%d %d", &E->v1, &E->v2);
            E->weight = 1;
            InsertEdge(Graph, E);
        }
    }

    return Graph;
}

主程序

/* 函数声明 */
LGraph CreateGraph(int VertexNum);
void InsertEdge(LGraph Graph, Edge E);
LGraph BuildGraph();
bool Judge(LGraph Graph);

/* 主程序 */
int compromised[MaxVertexNum];
int flag[MaxVertexNum];

int main() {
    
    LGraph map = BuildGraph();
    //memset(flag, 0, sizeof(flag));
    int k, n, t, v;
    scanf("%d", &k); //输入方案个数

    for (int i = 1; i <= k; i++) {
        memset(compromised, 0, sizeof(compromised));
        scanf("%d", &n);
        for (int j = 1; j <= n; j++) {
            scanf("%d", &t);//逐个输入攻陷的城市序号
            compromised[t] = 1;//标记已攻陷的城市
        }

        if (Judge(map)) {
            flag[i] = 1;

        }
        else {
            flag[i] = 0;
        }
    }

    for (int i = 1; i <= k; i++) {
        if (flag[i] == 0) {
            printf("NO\n");
        }
        else {
            printf("YES\n");
        }
    }

    return 0;

}



bool Judge(LGraph Graph) {
    int v;
    PtrToAdjVNode u;
    for (v = 1; v <= Graph->Nv;v++) {
        if (compromised[v] == 1) continue;
        u= Graph->G[v].firstEdge;
        while (u!=NULL) {

            if (compromised[u->AdjV] == 0) {
                return 0;
                break;
            }
            u = u->next;
        }
    }
    return 1;
}