PAT甲级1134. Vertex Cover (25) 题解

题目原文

A vertex cover of a graph is a set of vertices such that each edge of the graph is incident to at least one vertex of the set. Now given a graph with several vertex sets, you are supposed to tell if each of them is a vertex cover or not.

Input Specification:

Each input file contains one test case. For each case, the first line gives two positive integers N and M (both no more than 104), being the total numbers of vertices and the edges, respectively. Then M lines follow, each describes an edge by giving the indices (from 0 to N-1) of the two ends of the edge.

After the graph, a positive integer K (<= 100) is given, which is the number of queries. Then K lines of queries follow, each in the format:

Nv v[1] v[2] … v[Nv]

where Nv is the number of vertices in the set, and v[i]’s are the indices of the vertices.

Output Specification:

For each query, print in a line “Yes” if the set is a vertex cover, or “No” if not.
Sample Input:

10 11
8 7
6 8
4 5
8 4
8 1
1 2
1 4
9 8
9 1
1 0
2 4
5
4 0 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

Sample Output:

No
Yes
Yes
No
No

解题思路

输入给出了边的集合，首先要做的是保存图。题目要求的是边的覆盖，所以为了方便查找每个顶点分别覆盖了那些边，所以每个顶点里面我保存的是，他所覆盖的边的集合。为了方便我用了容器map < int ,vector< int > > 。具体思路可以看下面我的代码片段。其实这里更方便的是用两个vecter迭代，即vector < vector < int > >。
下面就是根据输入去判断每个case是否完全覆盖了图上的所有的边，就挨个点集合中每个点所覆盖的边，但是可能会有重合，所以要避重。

存储图

/*
**@map<int,vector<int> >graph_node key(int)代表的是点，value(vector<int>)代表的是点覆盖的边的集合。
*/
for (int i = 0; i < M; ++i)
  {
    //根据要求读取每一条边
    int u,v;
    cin >> u >> v;
    //分别代表的是u,v所覆盖的边的集合
    vector<int> uList,vList;
    //首先先把已经存储的信息取出来
    if(graph_node.find(u)!=graph_node.end()){
      uList = graph_node[u];
    }
    //在动态数组末尾增加新的信息，i就是边的代号
    uList.push_back(i);
    //将更新后的边的集合再放回map中。
    graph_node[u] = uList;
    //同上
    if(graph_node.find(v)!=graph_node.end()){
      vList = graph_node[v];
    }
    vList.push_back(i);
    graph_node[v] = vList;
  }

根据点去找覆盖的边

/*
**@indix 所要查找的点
**
**@visit[] 存储边是否已经被查询过，目的就是思路中提到的判重
**@total 初始值为0，记录所有被查询的点共计覆盖的不重复边的总数。最终只要判断total与边的总数是否相等就知道点集是否完全覆盖整个图
*/
void traversal(int indix){
  //取出被查询点所覆盖的集合
  vector<int> temp = graph_node[indix];
  for (int i = 0,length=temp.size(); i < length; ++i)
  {
    //首先判断是否被点集中其他的点覆盖过
    if(!visit[temp[i]]){
      //将边标记被覆盖过
      visit[temp[i]] = true;
      //将total增1
      total++;
    }
  }
}

完整代码

#include <iostream>
#include <map>
#include <vector>
#include <cstring>

using namespace std;

struct Vertux{
  int u,v;
  Vertux(int u1,int v1):u(u1),v(v1){}
};

int N,M;
map< int , vector<int> > graph_node;
//vector<Vertux> vertuxList;
bool *visit;

int total;

void traversal(int indix){
  vector<int> temp = graph_node[indix];
  for (int i = 0,length=temp.size(); i < length; ++i)
  {
    if(!visit[temp[i]]){
      visit[temp[i]] = true;
      total++;
    }
  }
}

int main(int argc, char const *argv[])
{
  cin >> N >> M;
  visit = new bool[M];
  for (int i = 0; i < M; ++i)
  {
    int u,v;
    cin >> u >> v;
    //vertuxList.push_back(Vertux(u,v));
    vector<int> uList,vList;
    if(graph_node.find(u)!=graph_node.end()){
      uList = graph_node[u];
    }
    uList.push_back(i);
    graph_node[u] = uList;
    if(graph_node.find(v)!=graph_node.end()){
      vList = graph_node[v];
    }
    vList.push_back(i);
    graph_node[v] = vList;
  }
  int K;
  cin >> K;
  for (int i = 0; i < K; ++i)
  {
    memset(visit,0,sizeof(bool)*M);
    total = 0;
    int num;
    cin >> num;
    for (int j = 0; j < num; ++j)
    {
      int indix;
      cin >> indix;
      //int u = vertuxList[indix].u;
      //int v = vertuxList[indix].v;
      //traversal(u);
      //traversal(v);
      traversal(indix);
    }
    cout << ((total==M)?"Yes":"No") << endl;
  }
  return 0;
}