Vertex Cover Problem | Set 1 (Introduction and Approximate Algorithm)

18 Aug, 2021
A vertex cover of an undirected graph is a subset of its vertices such that for every edge (u, v) of the graph, either ‘u’ or ‘v’ is in the vertex cover. Although the name is Vertex Cover, the set covers all edges of the given graph. Given an undirected graph, the vertex cover problem is to find minimum size vertex cover. The following are some examples.  
Vertex Cover Problem is a known NP Complete problem, i.e., there is no polynomial-time solution for this unless P = NP. There are approximate polynomial-time algorithms to solve the problem though. Following is a simple approximate algorithm adapted from CLRS book.
Naive Approach:
Consider all the subset of vertices one by one and find out whether it covers all edges of the graph. For eg. in a graph consisting only 3 vertices the set consisting of the combination of vertices are:{0,1,2,{0,1},{0,2},{1,2},{0,1,2}} . Using each element of this set check whether these vertices cover all  all the edges of the graph. Hence update the optimal answer. And hence print the subset having minimum number of vertices which also covers all the edges of the graph.
Approximate Algorithm for Vertex Cover:  
1) Initialize the result as {}
2) Consider a set of all edges in given graph.  Let the set be E.
3) Do following while E is not empty
...a) Pick an arbitrary edge (u, v) from set E and add 'u' and 'v' to result
...b) Remove all edges from E which are either incident on u or v.
4) Return result 
Below diagram to show the execution of the above approximate algorithm:  
How well the above algorithm perform? It can be proved that the above approximate algorithm never finds a vertex cover whose size is more than twice the size of the minimum possible vertex cover (Refer this for proof)Implementation: The following are C++ and Java implementations of the above approximate algorithm.  
C++
Java
Python3
C#
Javascript
// Program to print Vertex Cover of a given undirected graph#include<iostream>#include <list>using namespace std; // This class represents a undirected graph using adjacency listclass Graph{    int V;    // No. of vertices    list<int> *adj;  // Pointer to an array containing adjacency listspublic:    Graph(int V);  // Constructor    void addEdge(int v, int w); // function to add an edge to graph    void printVertexCover();  // prints vertex cover}; Graph::Graph(int V){    this->V = V;    adj = new list<int>[V];} void Graph::addEdge(int v, int w){    adj[v].push_back(w); // Add w to v’s list.    adj[w].push_back(v); // Since the graph is undirected} // The function to print vertex covervoid Graph::printVertexCover(){    // Initialize all vertices as not visited.    bool visited[V];    for (int i=0; i<V; i++)        visited[i] = false;     list<int>::iterator i;     // Consider all edges one by one    for (int u=0; u<V; u++)    {        // An edge is only picked when both visited[u] and visited[v]        // are false        if (visited[u] == false)        {            // Go through all adjacents of u and pick the first not            // yet visited vertex (We are basically picking an edge            // (u, v) from remaining edges.            for (i= adj[u].begin(); i != adj[u].end(); ++i)            {                int v = *i;                if (visited[v] == false)                {                     // Add the vertices (u, v) to the result set.                     // We make the vertex u and v visited so that                     // all edges from/to them would be ignored                     visited[v] = true;                     visited[u]  = true;                     break;                }            }        }    }     // Print the vertex cover    for (int i=0; i<V; i++)        if (visited[i])          cout << i << " ";} // Driver program to test methods of graph classint main(){    // Create a graph given in the above diagram    Graph g(7);    g.addEdge(0, 1);    g.addEdge(0, 2);    g.addEdge(1, 3);    g.addEdge(3, 4);    g.addEdge(4, 5);    g.addEdge(5, 6);     g.printVertexCover();     return 0;}
// Java Program to print Vertex// Cover of a given undirected graphimport java.io.*;import java.util.*;import java.util.LinkedList; // This class represents an undirected// graph using adjacency listclass Graph{    private int V;   // No. of vertices     // Array  of lists for Adjacency List Representation    private LinkedList<Integer> adj[];     // Constructor    Graph(int v)    {        V = v;        adj = new LinkedList[v];        for (int i=0; i<v; ++i)            adj[i] = new LinkedList();    }     //Function to add an edge into the graph    void addEdge(int v, int w)    {        adj[v].add(w);  // Add w to v's list.        adj[w].add(v);  //Graph is undirected    }     // The function to print vertex cover    void printVertexCover()    {        // Initialize all vertices as not visited.        boolean visited[] = new boolean[V];        for (int i=0; i<V; i++)            visited[i] = false;         Iterator<Integer> i;         // Consider all edges one by one        for (int u=0; u<V; u++)        {            // An edge is only picked when both visited[u]            // and visited[v] are false            if (visited[u] == false)            {                // Go through all adjacents of u and pick the                // first not yet visited vertex (We are basically                //  picking an edge (u, v) from remaining edges.                i = adj[u].iterator();                while (i.hasNext())                {                    int v = i.next();                    if (visited[v] == false)                    {                         // Add the vertices (u, v) to the result                         // set. We make the vertex u and v visited                         // so that all edges from/to them would                         // be ignored                         visited[v] = true;                         visited[u]  = true;                         break;                    }                }            }        }         // Print the vertex cover        for (int j=0; j<V; j++)            if (visited[j])              System.out.print(j+" ");    }     // Driver method    public static void main(String args[])    {        // Create a graph given in the above diagram        Graph g = new Graph(7);        g.addEdge(0, 1);        g.addEdge(0, 2);        g.addEdge(1, 3);        g.addEdge(3, 4);        g.addEdge(4, 5);        g.addEdge(5, 6);         g.printVertexCover();    }} // This code is contributed by Aakash Hasija
# Python3 program to print Vertex Cover# of a given undirected graphfrom collections import defaultdict # This class represents a directed graph# using adjacency list representationclass Graph:     def __init__(self, vertices):                 # No. of vertices        self.V = vertices                 # Default dictionary to store graph        self.graph = defaultdict(list)     # Function to add an edge to graph    def addEdge(self, u, v):        self.graph[u].append(v)     # The function to print vertex cover    def printVertexCover(self):                 # Initialize all vertices as not visited.        visited = [False] * (self.V)                 # Consider all edges one by one        for u in range(self.V):                         # An edge is only picked when            # both visited[u] and visited[v]            # are false            if not visited[u]:                                 # Go through all adjacents of u and                # pick the first not yet visited                # vertex (We are basically picking                # an edge (u, v) from remaining edges.                for v in self.graph[u]:                    if not visited[v]:                                                 # Add the vertices (u, v) to the                        # result set. We make the vertex                        # u and v visited so that all                        # edges from/to them would                        # be ignored                        visited[v] = True                        visited[u] = True                        break         # Print the vertex cover        for j in range(self.V):            if visited[j]:                print(j, end = ' ')                         print() # Driver code # Create a graph given in# the above diagramg = Graph(7)g.addEdge(0, 1)g.addEdge(0, 2)g.addEdge(1, 3)g.addEdge(3, 4)g.addEdge(4, 5)g.addEdge(5, 6) g.printVertexCover() # This code is contributed by Prateek Gupta
// C# Program to print Vertex// Cover of a given undirected// graphusing System;using System.Collections.Generic; // This class represents an// undirected graph using// adjacency listclass Graph{   // No. of verticespublic int V; // Array of lists for// Adjacency List Representationpublic List<int> []adj; // Constructorpublic Graph(int v){  V = v;  adj = new List<int>[v];   for (int i = 0; i < v; ++i)    adj[i] = new List<int>();} //Function to add an edge// into the graphvoid addEdge(int v, int w){   // Add w to v's list.  adj[v].Add(w);     //Graph is undirected  adj[w].Add(v);} // The function to print// vertex covervoid printVertexCover(){  // Initialize all vertices  // as not visited.  bool []visited = new bool[V];   // Consider all edges one  // by one  for (int u = 0; u < V; u++)  {    // An edge is only picked    // when both visited[u]    // and visited[v] are false    if (visited[u] == false)    {      // Go through all adjacents      // of u and pick the first      // not yet visited vertex      // (We are basically picking      // an edge (u, v) from remaining      // edges.      foreach(int i in adj[u])      {        int v = i;        if (visited[v] == false)        {          // Add the vertices (u, v)          // to the result set. We          // make the vertex u and          // v visited so that all          // edges from/to them would          // be ignored          visited[v] = true;          visited[u] = true;          break;        }      }    }  }   // Print the vertex cover  for (int j = 0; j < V; j++)    if (visited[j])      Console.Write(j + " ");} // Driver methodpublic static void Main(String []args){  // Create a graph given in  // the above diagram  Graph g = new Graph(7);  g.addEdge(0, 1);  g.addEdge(0, 2);  g.addEdge(1, 3);  g.addEdge(3, 4);  g.addEdge(4, 5);  g.addEdge(5, 6);   g.printVertexCover();}} // This code is contributed by gauravrajput1
<script>// Javascript Program to print Vertex// Cover of a given undirected graph // This class represents an undirected// graph using adjacency listclass Graph{       // Constructor    constructor(v)    {        this.V=v;        this.adj = new Array(v);        for (let i = 0; i < v; ++i)            this.adj[i] = [];    }         // Function to add an edge into the graph    addEdge(v, w)    {        this.adj[v].push(w);  // Add w to v's list.        this.adj[w].push(v);  //Graph is undirected    }          // The function to print vertex cover    printVertexCover()    {        // Initialize all vertices as not visited.        let visited = new Array(this.V);        for (let i = 0; i < this.V; i++)            visited[i] = false;                     // Consider all edges one by one        for (let u = 0; u < this.V; u++)        {            // An edge is only picked when both visited[u]            // and visited[v] are false            if (visited[u] == false)            {                // Go through all adjacents of u and pick the                // first not yet visited vertex (We are basically                //  picking an edge (u, v) from remaining edges.                                 for(let i = 0; i < this.adj[u].length; i++)                {                    let v = this.adj[u][i];                    if (visited[v] == false)                    {                                              // Add the vertices (u, v) to the result                         // set. We make the vertex u and v visited                         // so that all edges from/to them would                         // be ignored                         visited[v] = true;                         visited[u]  = true;                         break;                    }                }            }        }          // Print the vertex cover        for (let j = 0; j < this.V; j++)            if (visited[j])              document.write(j+" ");    }} // Driver method// Create a graph given in the above diagramlet g = new Graph(7);g.addEdge(0, 1);g.addEdge(0, 2);g.addEdge(1, 3);g.addEdge(3, 4);g.addEdge(4, 5);g.addEdge(5, 6); g.printVertexCover(); // This code is contributed by patel2127</script>
Output: 
0 1 3 4 5 6
The Time Complexity of the above algorithm is O(V + E).Exact Algorithms: Although the problem is NP complete, it can be solved in polynomial time for the following types of graphs. 1) Bipartite Graph 2) Tree GraphThe problem to check whether there is a vertex cover of size smaller than or equal to a given number k can also be solved in polynomial time if k is bounded by O(LogV) (Refer this)We will soon be discussing exact algorithms for vertex cover.This article is contributed by Shubham. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 
PrateekGupta10
GauravRajput1
patel2127
riyaprasad01
NPHard
Graph
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Dijkstra's shortest path algorithm | Greedy Algo-7
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Find if there is a path between two vertices in a directed graph
Detect Cycle in a Directed Graph
Introduction to Data Structures
What is Data Structure: Types, Classifications and Applications
Bellman–Ford Algorithm | DP-23
Find if there is a path between two vertices in an undirected graph
Minimum number of swaps required to sort an array
m Coloring Problem | Backtracking-5