HDU6150-Vertex Cover（构造）

Vertex Cover

                                                                      Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 256000/256000 K (Java/Others)
                                                                                               Total Submission(s): 641    Accepted Submission(s): 249
                                                                                                                              Special Judge

Problem Description

As we know,  minimumvertexcover  is a classical NP-complete problem. There will not be polynomial time algorithm for it unless  P=NP .

You can see the definition of vertex cover in https://en.wikipedia.org/wiki/Vertex_cover.

Today, little M designs an "approximate" algorithm for vertex cover. It is a greedy algorithm. The main idea of her algorithm is that always choosing the maximum degree vertex into the solution set. The pseudo code of her algorithm is as follows:

We assume that the labels of the vertices are from 1 to n.

for (int i = 1; i <= n; ++i) {
  use[i] = false;
    deg[i] = degree of the vertex i;
}
int ans = 0;
while (true) {
  int mx = -1, u;
    for (int i = 1; i <= n; ++i) {
      if (use[i])
          continue;
        if (deg[i] >= mx) {
          mx = deg[i];
            u = i;
        }
    }
    if (mx <= 0)
      break;
    ++ans;
    use[u] = true;
    for (each vertex v adjacent to u)
      --deg[v];
}
return ans;

As a theory computer scientist, you immediately find that it is a bad algorithm. To show her that this algorithm dose not have a constant approximate factor, you need to construct an instance of vertex cover such that the solution get by this algorithm is much worse than the optimal solution.

Formally, your program need to output a simple undirected graph of at most  500  vertices. Moreover, you need to output a vertex cover solution of your graph. Your program will get Accept if and only if the solution size get by the above algorithm is at least three times as much as yours. 

 

Input

There is no input.

 

Output

First, output two integer  n  and  m  in a line, separated by a space, means the number of the vertices and the number of the edges in your graph.
In the next  m  lines, you should output two integers  u  and  v  for each line, separated by a space, which denotes an edge of your graph. It must be satisfied that  1≤u,v≤n  and your graph is a simple undirected graph.
In the next line, output an integer  k(1≤k≤n) , means the size of your vertex cover solution.
Then output  k  lines, each line contains an integer  u(1≤u≤n)  which denotes the label of a vertex in your solution. It must be satisfied that your solution is a vertex cover of your graph.

 

Sample Output

  
  

   
   4 4
1 2
2 3
3 4
4 1
2
1
3


   
   

    
    

     
     Hint
    
    
The sample output is just to exemplify the output format.

   
   
   
    
  
  

 

Source

2017中国大学生程序设计竞赛 - 网络选拔赛

 

Recommend

liuyiding

 

题意：有一个贪心算法求最小顶点覆盖是每次选出度数最大的点然后删去，输出一个图使得这个算法跑出来的答案是你给出的答案的三倍及以上。

解题思路：设左边有n个点，标号为1~n。对于每个i∈[1,n]，都在右边新建⌊n/i⌋个点，每个点都选择右边的i个点连一条边，使得左边每个点最多只被多加了一条边

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <bitset>
#include <functional>

using namespace std;

#define LL long long
const int INF = 0x3f3f3f3f;

int main()
{
    int n = 20, m = 20, ans = 0;
    for (int i = 1; i <= n; i++) m += n / i, ans += n / i*i;
    printf("%d %d\n", m, ans);
    m = 20;
    for (int i = 1; i <= n; i++)
    {
        int p = 0;
        for (int j = 1; j <= n / i; j++)
        {
            for (int k = 1; k <= i; k++)
                printf("%d %d\n", j + m, k + p);
            p += i;
        }
        m += n / i;
    }
    printf("%d\n", n);
    for (int i = 1; i <= n; i++) printf("%d\n", i);
    return 0;
}