使用回溯功能从给定图获得最大独立集

给定具有V顶点和E边的无向图，任务是打印所有独立集，并找到最大独立集。

Independent set is a set of vertices such that any two vertices in the set do not have a direct edge between them.

Maximal independent set is an independent set having highest number of vertices.

注意：给定图可以有多个独立和最大独立集。

例子：

Input:
V = 3, E = 0
Graph:

Output:
{ }{ 1 }{ 1 2 }{ 1 2 3 }{ 1 3 }{ 2 }{ 2 3 }{ 3 }
{ 1 2 3 }
Explanation:
The first line represents all the possible indpendent sets for the given graph. The second line has the maximal independent sets possible for the given graph.

Input:
V = 4, E = 4
Graph:

Output:
{ }{ 1 }{ 1 3 }{ 2 }{ 2 4 }{ 3 }{ 4 }
{ 1 3 }{ 2 4 }

方法：
这个想法是使用回溯来解决问题。在每一步中，我们都需要检查当前节点是否具有与我们独立集中已存在的任何节点的直接边缘。如果没有，我们可以将其添加到我们的独立集中，然后对所有节点递归地重复相同的过程。

Illustration:
Recursion tree for the first example:

In the above backtracking tree we will choose only those sets which are produced after adding a safe node to maintain the set as an independent set.

下面是上述方法的实现：

CPP

// C++ Program to print the
// independent sets and
// maximal independent sets
// of the given graph
  
#include 
using namespace std;
  
// To store all the independent
// sets of the graph
set > independentSets;
  
// To store all maximal independent
// sets in the graph
set > maximalIndependentSets;
  
map, int> edges;
vector vertices;
  
// Function to print all independent sets
void printAllIndependentSets()
{
    for (auto iter : independentSets) {
        cout << "{ ";
        for (auto iter2 : iter) {
            cout << iter2 << " ";
        }
        cout << "}";
    }
    cout << endl;
}
  
// Function to extract all
// maximal independent sets
void printMaximalIndependentSets()
{
    int maxCount = 0;
    int localCount = 0;
    for (auto iter : independentSets) {
  
        localCount = 0;
        for (auto iter2 : iter) {
            localCount++;
        }
        if (localCount > maxCount)
            maxCount = localCount;
    }
    for (auto iter : independentSets) {
  
        localCount = 0;
        set tempMaximalSet;
  
        for (auto iter2 : iter) {
            localCount++;
            tempMaximalSet.insert(iter2);
        }
        if (localCount == maxCount)
            maximalIndependentSets
                .insert(tempMaximalSet);
    }
    for (auto iter : maximalIndependentSets) {
        cout << "{ ";
        for (auto iter2 : iter) {
            cout << iter2 << " ";
        }
        cout << "}";
    }
    cout << endl;
}
  
// Function to check if a
// node is safe node.
bool isSafeForIndependentSet(
    int vertex,
    set tempSolutionSet)
{
    for (auto iter : tempSolutionSet) {
        if (edges[make_pair(iter, vertex)]) {
            return false;
        }
    }
    return true;
}
  
// Recursive function to find
// all independent sets
void findAllIndependentSets(
    int currV,
    int setSize,
    set tempSolutionSet)
{
    for (int i = currV; i <= setSize; i++) {
        if (isSafeForIndependentSet(
                vertices[i - 1],
                tempSolutionSet)) {
            tempSolutionSet
                .insert(vertices[i - 1]);
            findAllIndependentSets(
                i + 1,
                setSize,
                tempSolutionSet);
            tempSolutionSet
                .erase(vertices[i - 1]);
        }
    }
    independentSets
        .insert(tempSolutionSet);
}
  
// Driver Program
int main()
{
    int V = 3, E = 0;
  
    for (int i = 1; i <= V; i++)
        vertices.push_back(i);
  
    vector > inputEdges;
  
    pair edge;
    int x, y;
    for (int i = 0; i < E; i++) {
        edge.first = inputEdges[i].first;
        edge.second = inputEdges[i].second;
        edges[edge] = 1;
        int t = edge.first;
        edge.first = edge.second;
        edge.second = t;
        edges[edge] = 1;
    }
  
    set tempSolutionSet;
  
    findAllIndependentSets(1,
                           V,
                           tempSolutionSet);
  
    printAllIndependentSets();
  
    printMaximalIndependentSets();
  
    return 0;
}

输出：

{ }{ 1 }{ 1 2 }{ 1 2 3 }{ 1 3 }{ 2 }{ 2 3 }{ 3 }
{ 1 2 3 }