0037算法笔记——【分支限界法】最大团问题

最新推荐文章于 2023-04-10 11:33:26 发布
最新推荐文章于 2023-04-10 11:33:26 发布
阅读量3.9k 收藏 9
点赞数 1
分类专栏： 数据结构与算法

        问题描述

     给定无向图G=(V, E)，其中V是非空集合，称为顶点集；E是V中元素构成的无序二元组的集合，称为边集，无向图中的边均是顶点的无序对，无序对常用圆括号“( )”表示。如果U∈V，且对任意两个顶点u，v∈U有(u, v)∈E，则称U是G的完全子图(完全图G就是指图G的每个顶点之间都有连边)。G的完全子图U是G的团当且仅当U不包含在G的更大的完全子图中。G的最大团是指G中所含顶点数最多的团。

     如果U∈V且对任意u，v∈U有(u, v)不属于E，则称U是G的空子图。G的空子图U是G的独立集当且仅当U不包含在G的更大的空子图中。G的最大独立集是G中所含顶点数最多的独立集。

     对于任一无向图G=(V, E)，其补图G'=(V', E')定义为：V'=V，且(u, v)∈E'当且仅当(u, v)∈E。
     如果U是G的完全子图，则它也是G'的空子图，反之亦然。因此，G的团与G'的独立集之间存在一一对应的关系。特殊地，U是G的最大团当且仅当U是G'的最大独立集。

     例：如图所示，给定无向图G={V, E}，其中V={1,2,3,4,5}，E={(1,2), (1,4), (1,5),(2,3), (2,5), (3,5), (4,5)}。根据最大团(MCP)定义，子集{1,2}是图G的一个大小为2的完全子图，但不是一个团，因为它包含于G的更大的完全子图{1,2,5}之中。{1,2,5}是G的一个最大团。{1,4,5}和{2,3,5}也是G的最大团。右侧图是无向图G的补图G'。根据最大独立集定义，{2,4}是G的一个空子图，同时也是G的一个最大独立集。虽然{1,2}也是G'的空子图，但它不是G'的独立集，因为它包含在G'的空子图{1,2,5}中。{1,2,5}是G'的最大独立集。{1,4,5}和{2,3,5}也是G'的最大独立集。


     算法设计

      最大团问题的解空间树也是一棵子集树。子集树的根结点是初始扩展结点，对于这个特殊的扩展结点，其cliqueSize的值为0。 算法在扩展内部结点时，首先考察其左儿子结点。在左儿子结点处，将顶点i加入到当前团中，并检查该顶点与当前团中其它顶点之间是否有边相连。当顶点i与当前团中所有顶点之间都有边相连，则相应的左儿子结点是可行结点，将它加入到子集树中并插入活结点优先队列，否则就不是可行结点。

     接着继续考察当前扩展结点的右儿子结点。当upperSize>bestn时，右子树中可能含有最优解，此时将右儿子结点加入到子集树中并插入到活结点优先队列中。算法的while循环的终止条件是遇到子集树中的一个叶结点(即n+1层结点)成为当前扩展结点。
    对于子集树中的叶结点，有upperSize＝cliqueSize。此时活结点优先队列中剩余结点的upperSize值均不超过当前扩展结点的upperSize值，从而进一步搜索不可能得到更大的团，此时算法已找到一个最优解。

     算法具体实现如下：

     1、MaxHeap.h

[cpp] view plain copy print ?
  1. template<class T>  
  2. class MaxHeap  
  3. {  
  4.     public:  
  5.         MaxHeap(int MaxHeapSize = 10);  
  6.         ~MaxHeap() {delete [] heap;}  
  7.         int Size() const {return CurrentSize;}  
  8.   
  9.         T Max()   
  10.         {          //查   
  11.            if (CurrentSize == 0)  
  12.            {  
  13.                 throw OutOfBounds();  
  14.            }  
  15.            return heap[1];  
  16.         }  
  17.   
  18.         MaxHeap<T>& Insert(const T& x); //增   
  19.         MaxHeap<T>& DeleteMax(T& x);   //删   
  20.   
  21.         void Initialize(T a[], int size, int ArraySize);  
  22.   
  23.     private:  
  24.         int CurrentSize, MaxSize;  
  25.         T *heap;  // element array   
  26. };  
  27.   
  28. template<class T>  
  29. MaxHeap<T>::MaxHeap(int MaxHeapSize)  
  30. {// Max heap constructor.   
  31.     MaxSize = MaxHeapSize;  
  32.     heap = new T[MaxSize+1];  
  33.     CurrentSize = 0;  
  34. }  
  35.   
  36. template<class T>  
  37. MaxHeap<T>& MaxHeap<T>::Insert(const T& x)  
  38. {// Insert x into the max heap.   
  39.     if (CurrentSize == MaxSize)  
  40.     {  
  41.         cout<<"no space!"<<endl;   
  42.         return *this;   
  43.     }  
  44.   
  45.     // 寻找新元素x的位置   
  46.     // i——初始为新叶节点的位置，逐层向上，寻找最终位置   
  47.     int i = ++CurrentSize;  
  48.     while (i != 1 && x > heap[i/2])  
  49.     {  
  50.         // i不是根节点，且其值大于父节点的值，需要继续调整   
  51.         heap[i] = heap[i/2]; // 父节点下降   
  52.         i /= 2;              // 继续向上，搜寻正确位置   
  53.     }  
  54.   
  55.    heap[i] = x;  
  56.    return *this;  
  57. }  
  58.   
  59. template<class T>  
  60. MaxHeap<T>& MaxHeap<T>::DeleteMax(T& x)  
  61. {// Set x to max element and delete max element from heap.   
  62.     // check if heap is empty   
  63.     if (CurrentSize == 0)  
  64.     {  
  65.         cout<<"Empty heap!"<<endl;   
  66.         return *this;   
  67.     }  
  68.   
  69.     x = heap[1]; // 删除最大元素   
  70.     // 重整堆   
  71.     T y = heap[CurrentSize--]; // 取最后一个节点，从根开始重整   
  72.   
  73.     // find place for y starting at root   
  74.     int i = 1,  // current node of heap   
  75.        ci = 2; // child of i   
  76.   
  77.     while (ci <= CurrentSize)   
  78.     {  
  79.         // 使ci指向i的两个孩子中较大者   
  80.         if (ci < CurrentSize && heap[ci] < heap[ci+1])  
  81.         {  
  82.             ci++;  
  83.         }  
  84.         // y的值大于等于孩子节点吗？   
  85.         if (y >= heap[ci])  
  86.         {  
  87.             break;   // 是，i就是y的正确位置，退出   
  88.         }  
  89.   
  90.         // 否，需要继续向下，重整堆   
  91.         heap[i] = heap[ci]; // 大于父节点的孩子节点上升   
  92.         i = ci;             // 向下一层，继续搜索正确位置   
  93.         ci *= 2;  
  94.     }  
  95.   
  96.     heap[i] = y;  
  97.     return *this;  
  98. }  
  99.   
  100. template<class T>  
  101. void MaxHeap<T>::Initialize(T a[], int size,int ArraySize)  
  102. {// Initialize max heap to array a.   
  103.     delete [] heap;  
  104.     heap = a;  
  105.     CurrentSize = size;  
  106.     MaxSize = ArraySize;  
  107.   
  108.     // 从最后一个内部节点开始，一直到根，对每个子树进行堆重整   
  109.    for (int i = CurrentSize/2; i >= 1; i--)  
  110.    {  
  111.         T y = heap[i]; // 子树根节点元素   
  112.         // find place to put y   
  113.         int c = 2*i; // parent of c is target   
  114.                    // location for y   
  115.         while (c <= CurrentSize)   
  116.         {  
  117.             // heap[c] should be larger sibling   
  118.             if (c < CurrentSize && heap[c] < heap[c+1])  
  119.             {  
  120.                 c++;  
  121.             }  
  122.             // can we put y in heap[c/2]?   
  123.             if (y >= heap[c])  
  124.             {  
  125.                 break;  // yes   
  126.             }  
  127.   
  128.             // no   
  129.             heap[c/2] = heap[c]; // move child up   
  130.             c *= 2; // move down a level   
  131.         }  
  132.         heap[c/2] = y;  
  133.     }  
  134. }  
template<class T>
class MaxHeap
{
	public:
		MaxHeap(int MaxHeapSize = 10);
		~MaxHeap() {delete [] heap;}
        int Size() const {return CurrentSize;}

        T Max() 
		{          //查
           if (CurrentSize == 0)
		   {
                throw OutOfBounds();
		   }
           return heap[1];
        }

		MaxHeap<T>& Insert(const T& x); //增
		MaxHeap<T>& DeleteMax(T& x);   //删

		void Initialize(T a[], int size, int ArraySize);

	private:
		int CurrentSize, MaxSize;
		T *heap;  // element array
};

template<class T>
MaxHeap<T>::MaxHeap(int MaxHeapSize)
{// Max heap constructor.
	MaxSize = MaxHeapSize;
	heap = new T[MaxSize+1];
	CurrentSize = 0;
}

template<class T>
MaxHeap<T>& MaxHeap<T>::Insert(const T& x)
{// Insert x into the max heap.
	if (CurrentSize == MaxSize)
	{
		cout<<"no space!"<<endl; 
		return *this; 
	}

    // 寻找新元素x的位置
    // i——初始为新叶节点的位置，逐层向上，寻找最终位置
	int i = ++CurrentSize;
	while (i != 1 && x > heap[i/2])
	{
		// i不是根节点，且其值大于父节点的值，需要继续调整
		heap[i] = heap[i/2]; // 父节点下降
		i /= 2;              // 继续向上，搜寻正确位置
    }

   heap[i] = x;
   return *this;
}

template<class T>
MaxHeap<T>& MaxHeap<T>::DeleteMax(T& x)
{// Set x to max element and delete max element from heap.
	// check if heap is empty
	if (CurrentSize == 0)
	{
		cout<<"Empty heap!"<<endl; 
		return *this; 
	}

	x = heap[1]; // 删除最大元素
	// 重整堆
	T y = heap[CurrentSize--]; // 取最后一个节点，从根开始重整

	// find place for y starting at root
	int i = 1,  // current node of heap
	   ci = 2; // child of i

	while (ci <= CurrentSize) 
    {
		// 使ci指向i的两个孩子中较大者
		if (ci < CurrentSize && heap[ci] < heap[ci+1])
		{
			ci++;
		}
		// y的值大于等于孩子节点吗？
		if (y >= heap[ci])
		{
			break;   // 是，i就是y的正确位置，退出
		}

		// 否，需要继续向下，重整堆
		heap[i] = heap[ci]; // 大于父节点的孩子节点上升
		i = ci;             // 向下一层，继续搜索正确位置
		ci *= 2;
    }

	heap[i] = y;
	return *this;
}

template<class T>
void MaxHeap<T>::Initialize(T a[], int size,int ArraySize)
{// Initialize max heap to array a.
	delete [] heap;
	heap = a;
	CurrentSize = size;
	MaxSize = ArraySize;

	// 从最后一个内部节点开始，一直到根，对每个子树进行堆重整
   for (int i = CurrentSize/2; i >= 1; i--)
   {
		T y = heap[i]; // 子树根节点元素
		// find place to put y
		int c = 2*i; // parent of c is target
                   // location for y
		while (c <= CurrentSize) 
		{
			// heap[c] should be larger sibling
			if (c < CurrentSize && heap[c] < heap[c+1])
			{
				c++;
			}
			// can we put y in heap[c/2]?
			if (y >= heap[c])
			{
				break;  // yes
			}

			// no
			heap[c/2] = heap[c]; // move child up
			c *= 2; // move down a level
        }
		heap[c/2] = y;
	}
}
     2、6d6.cpp

[cpp] view plain copy print ?
  1. //最大团问题 优先队列分支限界法求解    
  2. #include "stdafx.h"   
  3. #include "MaxHeap.h"   
  4. #include <iostream>   
  5. #include <fstream>   
  6. using namespace std;  
  7.   
  8. const int N = 5;//图G的顶点数   
  9. ifstream fin("6d6.txt");     
  10.   
  11. class bbnode  
  12. {  
  13.     friend class Clique;  
  14.     private:  
  15.         bbnode *parent;     //指向父节点的指针   
  16.         bool LChild;        //左儿子节点标识   
  17. };  
  18.   
  19. class CliqueNode  
  20. {  
  21.     friend class Clique;  
  22.     public:  
  23.         operator int() const  
  24.         {     
  25.             return un;  
  26.         }  
  27.     private:  
  28.         int cn,         //当前团的顶点数   
  29.             un,         //当前团最大顶点数的上界   
  30.             level;      //节点在子集空间树中所处的层次   
  31.         bbnode *ptr;    //指向活节点在子集树中相应节点的指针   
  32. };  
  33.   
  34. class Clique  
  35. {  
  36.     friend int main(void);  
  37.     public:  
  38.         int BBMaxClique(int []);  
  39.     private:  
  40.         void AddLiveNode(MaxHeap<CliqueNode>&H,int cn,int un,int level,bbnode E[],bool ch);  
  41.         int **a,        //图G的邻接矩阵   
  42.             n;          //图G的顶点数   
  43. };  
  44.   
  45. int main()  
  46. {  
  47.     int bestx[N+1];  
  48.     int **a = new int *[N+1];    
  49.     for(int i=1;i<=N;i++)      
  50.     {      
  51.         a[i] = new int[N+1];      
  52.     }   
  53.       
  54.     cout<<"图G的邻接矩阵为:"<<endl;  
  55.     for(int i=1; i<=N; i++)    
  56.     {    
  57.         for(int j=1; j<=N; j++)    
  58.         {    
  59.             fin>>a[i][j];        
  60.             cout<<a[i][j]<<" ";      
  61.         }    
  62.         cout<<endl;    
  63.     }  
  64.   
  65.     Clique c;  
  66.     c.a = a;  
  67.     c.n = N;  
  68.   
  69.     cout<<"图G的最大团顶点个数为："<<c.BBMaxClique(bestx)<<endl;  
  70.     cout<<"图G的最大团解向量为："<<endl;  
  71.     for(int i=1;i<=N;i++)      
  72.     {     
  73.         cout<<bestx[i]<<" ";  
  74.     }   
  75.     cout<<endl;  
  76.   
  77.     for(int i=1;i<=N;i++)      
  78.     {     
  79.         delete[] a[i];     
  80.     }   
  81.     delete []a;  
  82.     return 0;  
  83. }  
  84.   
  85. //将活节点加入到子集空间树中并插入到最大堆中   
  86. void Clique::AddLiveNode(MaxHeap<CliqueNode> &H, int cn, int un, int level, bbnode E[], bool ch)  
  87. {  
  88.     bbnode *b = new bbnode;  
  89.     b->parent = E;  
  90.     b->LChild = ch;  
  91.   
  92.     CliqueNode N;  
  93.     N.cn = cn;  
  94.     N.ptr = b;  
  95.     N.un = un;  
  96.     N.level = level;  
  97.     H.Insert(N);  
  98. }  
  99.   
  100. //解最大团问题的优先队列式分支限界法   
  101. int Clique::BBMaxClique(int bestx[])  
  102. {  
  103.     MaxHeap<CliqueNode> H(1000);  
  104.   
  105.     //初始化   
  106.     bbnode *E = 0;  
  107.     int i = 1,  
  108.         cn = 0,  
  109.         bestn = 0;  
  110.   
  111.     //搜集子集空间树   
  112.     while(i!=n+1)//非叶节点   
  113.     {  
  114.         //检查顶点i与当前团中其他顶点之间是否有边相连   
  115.         bool OK = true;  
  116.         bbnode *B = E;  
  117.         for(int j=i-1; j>0; B=B->parent,j--)  
  118.         {  
  119.             if(B->LChild && a[i][j]==0)  
  120.             {  
  121.                 OK = false;  
  122.                 break;  
  123.             }  
  124.         }  
  125.   
  126.         if(OK)//左儿子节点为可行结点   
  127.         {  
  128.             if(cn+1>bestn)  
  129.             {  
  130.                 bestn = cn + 1;  
  131.             }  
  132.             AddLiveNode(H,cn+1,cn+n-i+1,i+1,E,true);  
  133.         }  
  134.   
  135.         if(cn+n-i>=bestn)//右子树可能含有最优解   
  136.         {  
  137.             AddLiveNode(H,cn,cn+n-i,i+1,E,false);  
  138.         }  
  139.   
  140.         //取下一扩展节点   
  141.         CliqueNode N;  
  142.         H.DeleteMax(N); //堆非空   
  143.         E = N.ptr;  
  144.         cn = N.cn;  
  145.         i = N.level;  
  146.     }  
  147.   
  148.     //构造当前最优解   
  149.     for(int j=n; j>0; j--)  
  150.     {  
  151.         bestx[j] = E->LChild;  
  152.         E = E->parent;  
  153.     }  
  154.   
  155.     return bestn;  
  156. }  
//最大团问题 优先队列分支限界法求解 
#include "stdafx.h"
#include "MaxHeap.h"
#include <iostream>
#include <fstream>
using namespace std;

const int N = 5;//图G的顶点数
ifstream fin("6d6.txt");   

class bbnode
{
	friend class Clique;
	private:
		bbnode *parent;		//指向父节点的指针
		bool LChild;		//左儿子节点标识
};

class CliqueNode
{
	friend class Clique;
	public:
		operator int() const
		{	
			return un;
		}
	private:
		int cn,			//当前团的顶点数
			un,			//当前团最大顶点数的上界
			level;		//节点在子集空间树中所处的层次
		bbnode *ptr;	//指向活节点在子集树中相应节点的指针
};

class Clique
{
	friend int main(void);
	public:
		int BBMaxClique(int []);
	private:
		void AddLiveNode(MaxHeap<CliqueNode>&H,int cn,int un,int level,bbnode E[],bool ch);
		int **a,		//图G的邻接矩阵
			n;			//图G的顶点数
};

int main()
{
	int bestx[N+1];
	int **a = new int *[N+1];  
    for(int i=1;i<=N;i++)    
    {    
        a[i] = new int[N+1];    
    } 
	
	cout<<"图G的邻接矩阵为:"<<endl;
	for(int i=1; i<=N; i++)  
    {  
        for(int j=1; j<=N; j++)  
        {  
            fin>>a[i][j];      
            cout<<a[i][j]<<" ";    
        }  
        cout<<endl;  
    }

	Clique c;
	c.a = a;
	c.n = N;

	cout<<"图G的最大团顶点个数为："<<c.BBMaxClique(bestx)<<endl;
	cout<<"图G的最大团解向量为："<<endl;
	for(int i=1;i<=N;i++)    
    {   
		cout<<bestx[i]<<" ";
    } 
	cout<<endl;

	for(int i=1;i<=N;i++)    
    {   
        delete[] a[i];   
    } 
	delete []a;
	return 0;
}

//将活节点加入到子集空间树中并插入到最大堆中
void Clique::AddLiveNode(MaxHeap<CliqueNode> &H, int cn, int un, int level, bbnode E[], bool ch)
{
	bbnode *b = new bbnode;
	b->parent = E;
	b->LChild = ch;

	CliqueNode N;
	N.cn = cn;
	N.ptr = b;
	N.un = un;
	N.level = level;
	H.Insert(N);
}

//解最大团问题的优先队列式分支限界法
int Clique::BBMaxClique(int bestx[])
{
	MaxHeap<CliqueNode> H(1000);

	//初始化
	bbnode *E = 0;
	int i = 1,
		cn = 0,
		bestn = 0;

	//搜集子集空间树
	while(i!=n+1)//非叶节点
	{
		//检查顶点i与当前团中其他顶点之间是否有边相连
		bool OK = true;
		bbnode *B = E;
		for(int j=i-1; j>0; B=B->parent,j--)
		{
			if(B->LChild && a[i][j]==0)
			{
				OK = false;
				break;
			}
		}

		if(OK)//左儿子节点为可行结点
		{
			if(cn+1>bestn)
			{
				bestn = cn + 1;
			}
			AddLiveNode(H,cn+1,cn+n-i+1,i+1,E,true);
		}

		if(cn+n-i>=bestn)//右子树可能含有最优解
		{
			AddLiveNode(H,cn,cn+n-i,i+1,E,false);
		}

		//取下一扩展节点
		CliqueNode N;
		H.DeleteMax(N); //堆非空
		E = N.ptr;
		cn = N.cn;
		i = N.level;
	}

	//构造当前最优解
	for(int j=n; j>0; j--)
	{
		bestx[j] = E->LChild;
		E = E->parent;
	}

	return bestn;
}

灰太狼1号
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最大团问题---分支限界算法
06-18
算法设计与分析课上的，最大团的分支限界算法解法
最大团分支限界法PPT
02-26
分支限界法-最大团问题
最大团问题(回溯法/分支限界法)
08-28
问题描述 图G=（V，E）的一个团是图G的一个完全子图，即该子图中任意两个相异的顶点都有一条边相连。最大团问题就是要找出图G中顶点数最多的一个团。 基本要求 (1) 用回溯法来求解最大团问题。 (2) 用分支限界法来求解最大团问题。 测试数据 由读者给定若干连通图。 实现提示 本课程设计的实现主要包括以下主要过程： (1) 关于解的编码形式（对应顶点i 的变量x[i]=1当且仅当顶点i属于找到的最大团）。 (2) 设计合适的上界函数，即如何确定当前团最大顶点数的上界。
图论--最大团问题
日拱一卒,功不唐捐
12-09 3634
一、定义 一个无向图 G=(V，E)，V 是点集，E 是边集。取 V 的一个子集 U，若对于 U 中任意两个点 u 和 v，有边 (u,v)∈E，那么称 U 是 G 的一个完全子图。 U 是一个团当且仅当 U 不被包含在一个更大的完全子图中。 G的最大团指的是定点数最多的一个团。 简单来说，极大团是增加任一顶点都不再符合定义的团，最大团是图中含顶点数最多的极大团，最大独立集是除去图中的团后的点集，...
回溯法--最大团问题
m0_56147044的博客
01-12 3669
回溯法--子集树--最大团问题 相似的最优装载问题分析
分支限界法之最大团问题
shimin520shimin的专栏
10-08 1万+
A，最大团问题：给定一个无向图G=（V，E），其中V代表顶点集合，E代表边的集合。,如果U是V的子集，且对于U中任意两个顶点u和v都是相连的，即u-->v属于E，则称顶点子集U是图G的完全子图或者G的图。显然最大团就是指满足上述条件且含有顶点数最多的团。比如下图所示： 子集{A, B}是G 的大小为2 的团。这个团不是极大团（因为顶点数不是最多的），因为它包含在G 的更大团{A,B, E}中。
分支限界法——最大团问题和旅行售货员问题
milu_ELK的博客
11-26 2219
其次这个问题需要我们形成回路，那么我们在最后一层也就是n-1层（从0开始，叶子节点为结束点）一定就要和我们的第0层（出发点）的选择是一样的了，也就是说我们无需直接遍历到叶子节点，只需判断n-2层的节点是否能到达叶子节点，如果能就代表是有回路的，否则就直接剪枝。在确定了分支条件和界限之后，我们要选择用堆的形式来判断分支选择，一般以每层来代表一个节点，然后对其进行上界和下界的剪枝，其中界限也是会动态变化的，因此也要用算法来确定动态变化的界限，最后当到达叶子节点则得到我们的答案。
最大团问题-分支限界算法
Gavin的专栏
06-18 1万+
算法设计与分析课上，老师布置了一个讲解最大团的分支限界算法的went
分支限界法
热门推荐
iron的博客
04-23 4万+
分支限界法的基本思想： 求解目标：分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出在某种意义下的最优解。 搜索方式：以广度优先或以最小耗费优先的方式搜索解空间树。分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。 在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，...
算法分析 | 分支限界法 | 01背包问题
01-07
分支限界法是对树的广度遍历,需要用到数据结构.而且每个状态都是一个数据结构实体 状态应该表示如下几个属性: int cp //已放入物品总价值 int rp //剩余物品的总价值 int rw //剩余容量 int id //物品序号,比如某...
五大常用算法——分支限界算法详解及经典例题，算法数据结构
04-07
五大常用算法——分支限界算法详解及经典例题，算法数据结构 五大常用算法
算法详解之分支限界法的具体实现
09-04
主要介绍了算法详解之分支限界法的具体实现,需要的朋友可以参考下
最大团问题(MPP)之回溯法、分支限界法
qq_44066464的博客
04-10 4102
分支限界算法、回溯法解最大团问题
最大团问题（Maximum Clique Problem）
haleyha的博客
12-12 1万+
最大团问题（Maximum Clique Problem）
图论——最大团问题和最大独立集、二分图相关
上总介的博客
03-18 5826
主要研究二分图性质，附带最大团问题
最大团算法（Maximum Clique）
GatsbyNewton
01-15 1万+
1.问题描述 最大团问题是图论中一个经典的组合优化问题，也是一类NP完全问题。在Wikipedia中Clique Problem的描述如下： In computer science, the clique problem refers to any of the problems related to finding particular complete subgraphs ("clique
分支限界——最大团问题
yangqiang1997的博客
12-10 4733
给定有一个无向图，找出最大团个数。 最大团也就是该图中最大的完全图（各顶点之间都有边）。 算法思想：设p为所有点集的集合，依次取出p中的顶点作为团的起始点，也就是以该点为起点开始拓展，每次查看相邻顶点是否与团内各点联通，若true，则加入该点。 为了进一步降低时间复杂度，采取记忆化递归的方式，从后向前遍历顶点，用cnt数组记录该点以后所成最大团的个数，以此知该点的潜力，达到剪枝的效果。 #include<bits/stdc++.h> using namespace std; #define.
node-v6.9.4-linux-s390x.tar.xz
最新发布
05-09
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
分支限界法 java_算法——分支限界法(装载问题)
06-12
好的，我可以为你介绍一下分支限界法和装载问题的相关内容。 分支限界法是一种求解最优化问题的算法，通过不断扩展解空间，逐步缩小搜索范围，最终找到最优解。它的核心思想是将问题划分成许多子问题，并采用优先队列（或优先级队列）来维护待扩展的子问题集合，每次取出优先级最高的子问题进行扩展，直到找到最优解或者队列为空。 而装载问题是一种典型的分支限界法应用场景，它的主要思想是在给定的一些物品中选出尽可能多的物品放入容量为C的背包中，使得背包中物品的总重量不超过C，并且背包中物品的总价值最大。这个问题可以通过分支限界法来求解。 下面是一个简单的 Java 代码实现，用于解决装载问题： ```java import java.util.*; public class BranchAndBound { public static void main(String[] args) { int[] w = {5, 10, 20, 30}; // 物品的重量 int[] v = {50, 60, 140, 120}; // 物品的价值 int C = 50; // 背包的容量 int n = w.length; // 物品的数量 int[] x = new int[n]; // 记录每个物品是否被选中 PriorityQueue<Node> queue = new PriorityQueue<>(); queue.offer(new Node(-1, 0, 0)); // 将根节点加入队列中 while (!queue.isEmpty()) { Node node = queue.poll(); // 取出优先级最高的子问题 if (node.level == n - 1) { // 如果是叶子节点，更新最优解 for (int i = 0; i < n; i++) { x[i] = node.x[i]; } } else { int level = node.level + 1; int weight = node.weight; int value = node.value; if (weight + w[level] <= C) { // 左子节点表示选中当前物品 int[] left = Arrays.copyOf(node.x, n); left[level] = 1; queue.offer(new Node(level, weight + w[level], value + v[level], left)); } // 右子节点表示不选当前物品 queue.offer(new Node(level, weight, value, node.x)); } } int max = 0; for (int i = 0; i < n; i++) { if (x[i] == 1) { System.out.println("第" + (i + 1) + "个物品被选中"); max += v[i]; } } System.out.println("最大价值为：" + max); } // 子问题节点 static class Node implements Comparable<Node> { int level; // 当前节点所在的层级 int weight; // 当前节点的背包重量 int value; // 当前节点的背包价值 int[] x; // 记录每个物品是否被选中 public Node(int level, int weight, int value) { this.level = level; this.weight = weight; this.value = value; this.x = new int[0]; } public Node(int level, int weight, int value, int[] x) { this.level = level; this.weight = weight; this.value = value; this.x = x; } @Override public int compareTo(Node o) { return o.value - this.value; // 根据价值进行优先级比较 } } } ``` 希望这个简单的例子能帮助你更好地理解分支限界法和装载问题。如果你还有其他问题或者疑惑，欢迎随时向我提出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值