最大团问题－－优先队列式分支界限法

#include <iostream>
#include <algorithm>
#include <vector>
#include <cassert>
using namespace std;

typedef struct Node{
        int choose;
        int cn;
        int un;
        int level;
        Node *pre;
}Node;

const int n = 100;
int graph[n+1][n+1] = {0};
int bestx[n+1] = {0};
int max_node = 0;
vector<Node *> heap;

void initParament()
{

}

bool compareNode(Node *node1, Node *node2)
{
        return node1->un > node2->un;
}

void insertNode(int cn, int un, Node *parent, int level, int choose)
{
        Node *new_node = new Node;
        new_node->cn = cn;
        new_node->un = un;
        new_node->level = level;
        new_node->choose = choose;
        new_node->pre = parent;

        heap.push_back(new_node);
        push_heap(heap.begin(), heap.end(), compareNode);
}

void deleteNode(Node **current)
{
        if(heap.empty()){
                return;
        }
        pop_heap(heap.begin(), heap.end(), compareNode);
        current = &(*heap.rbegin());
        heap.erase(heap.end()-1);

}

void maxClique()
{
        Node *current = NULL;
        int current_node = 0;
        int i = 1;

        while( i != n+1 ){
                Node *node = current;
                bool OK = true;
                for(int j=i-1; j>0; j--){
                        assert(node);
                        if(node->choose && graph[i][j]==0){
                                OK = false;
                                break;
                        }
                        node = node->pre;
                }

                if( OK ){
                        max_node = max(max_node, current->cn+1);
                        insertNode(current_node+1, current_node+n-i+1, current, i+1, true);
                        if(current_node + n-i >= max_node){
                                insertNode(current_node, current_node+n-i, current, i+1, false);
                        }

                        deleteNode(&current);
                        assert(current);
                        i = current->level;
                        current_node = current->cn;
                }
        }

        for(i=n; i>0; i--){
                bestx[n] = current->choose;
                current = current->pre;
        }
}

int main()
{
        initParament();

        maxClique();

        return 0;
}