排列组合与回溯算法

转载 2006年06月01日 22:45:00

 

kuibing

感谢bambooleemars的帮助

 

[前言] 这篇论文主要针对排列组合对回溯算法展开讨论,在每一个讨论之后,还有相关的推荐题。在开始之前,我们先应该看一下回溯算法的概念,所谓回溯:就是搜索一棵状态树的过程,这个过程类似于图的深度优先搜索(dfs),在搜索的每一步(这里的每一步对应搜索树的第i层)中产生一个正确的解,然后在以后的每一步搜索过程中,都检查其前一步的记录,并且它将有条件的选择以后的每一个搜索状态(即第i+1层的状态节点)。

需掌握的基本算法:

排列:就是从n个元素中同时取r个元素的排列,记做p(n,r)。(当r=n时,我们称p(n,n)=n!为全排列)例如我们有集合or = {1,2,3,4},那么n = |or| = 4,切规定r=3,那么p(4,3)就是:

{1,2,3}; {1,2,4}; {1,3,2}; {1,3,4};{1,4,2};{1,4,3};{2,1,3};{2,1,4}; {2,3,1}; {2,3,4}; {2,4,1}; {2,4,3}; {3,1,2}; {3,1,4}; {3,2,1}; {3,2,4}; {3,4,1}; {3,4,2}; {4,1,2}; {4,1,3}; {4,2,1}; {4,2,3}; {4,3,1}; {4,3,2}

算法如下:

int  n, r;
char used[maxn];
int  p[maxn];
 
void permute(int pos)
{ int i;
/*如果已是第r个元素了,则可打印r个元素的排列 */
    if (pos==r) {
        for (i=0; i<r; i++)
            cout << (p[i]+1);
        cout << endl;
        return;
    }
    for (i=0; i<n; i++)
        if (!used[i]) { /*如果第i个元素未用过*/
/*使用第i个元素,作上已用标记,目的是使以后该元素不可用*/
            used[i]++;
/*保存当前搜索到的第i个元素*/
            p[pos] = i;
/*递归搜索*/
           permute(pos+1);
 
/*恢复递归前的值,目的是使以后改元素可用*/
 used[i]--;
        }
}

可重排列就是从任意n个元素中r个可重复的元素的排列。例如,对于集合or={1,1,2,2}, n = |or| = 4, r = 2,那么排列如下:

{1,1}; {1,2}; {1,2}; {1,1}; {1,2}; {1,2}; {2,1}; {2,1}; {2,2}; {2,1}; {2,1}; {2,2}

则可重排列是:

{1,1}; {1,2}; {2,1}; {2,2}.

算法如下:

#define free -1
int n, r;
/*使元素有序*/
int e[maxn] = {0,0,1,1,1};
int p[maxn];
char used[maxn];
 
void permute(int pos)
{
int i;
/*如果已选了r个元素了,则打印它们*/
    if (pos==r)  {
        for (i=0; i<r; i++)
            cout << p[i];
        cout << endl;
        return;
    }
/*标记下我们排列中的以前的元素表明是不存在的*/
    p[pos] = free;
    for (i=0; i<n; i++)
/*如果第i个元素没有用过,并且与先前的不同*/
        if (!used[i] && e[i]!=p[pos]) {
/*使用这个元素*/
            used[i]++;
/*选择现在元素的位置*/
            p[pos] = e[i];
/*递归搜索*/
            permute(pos+1);
/*恢复递归前的值*/
            used[i]--;
        }
}

 

组合:n个不同元素中取r个不重复的元素组成一个子集,而不考虑其元素的顺序,称为从n个中取r个的无重组合,例如or = {1,2,3,4}, n = 4, r = 3则无重组合为:

{1,2,3}; {1,2,4}; {1,3,4}; {2,3,4}.

算法如下:

int n, r;
int c[5];
char used[5];
 
void combine(int pos, int h)
{
int i;
/*如果已选了r个元素了,则打印它们*/
    if (pos==r) {
        for (i=0; i<r; i++)
            cout<< c[i];
        cout<< endl;
        return;
    }
    for (i=h; i<=n-r+pos; i++) /*对于所有未用的元素*/
        if (!used[i]) {
/*把它放置在组合中*/
            c[pos] = i;
/*使用该元素*/
 used[i]++;
/*搜索第i+1个元素*/
     combine(pos+1,i+1);
/*恢复递归前的值*/
 used[i]--;
        }
}

 

可重组合:类似于可重排列。

[] 给出空间中给定n(n<10)个点,画一条简单路径,包括所有的点,使得路径最短。

:这是一个旅行售货员问题tsp。这是一个np问题,其实就是一个排列选取问题。

算法如下:

int  n, r;
char used[maxn];
int  p[maxn];
double min;
 
void permute(int pos, double dist)
{
int i;
    if (pos==n) {
        if (dist < min) min = dist;
        return;
    }
    for (i=0; i<n; i++)
        if (!used[i]) {
            used[i]++;
            p[pos] = i;
           if (dist + cost(point[p[pos-1]], point[p[pos]]) < min)
                permute(pos+1, dist + cost(point[p[pos-1]], point[p[pos]]));
 used[i]--;
        }
}

 

 

[]对于01的所有排列,从中同时选取r个元素使得01的数量不同。

这道题很简单,其实就是从02^r的二元表示。

算法如下:

void dfs(int pos)
{
   if (pos == r)
   {
       for (i=0; i<r; i++) cout<<p[i];
       cout<<endl;
       return;
   }
   p[pos] = 0;
   dfs(pos+1);
   p[pos] = 1;
   dfs(pos+1);}

 

 

[]找最大团问题。

一个图的团,就是包括了图的所有点的子图,并且是连通的。也就是说,一个子图包含了n个顶点和n*(n-1)/2条边,找最大团问题是一个np问题。算法如下:

#define maxn 50
 
int  n, max;
int  path[maxn][maxn];
int  inclique[maxn];
 
void dfs(int ingraph[])
{
int i, j;
int graph[maxn];
 
if ( inclique[0]+ingraph[0]<=max ) return;
if ( inclique[0]>max ) max=inclique[0];
 
/*对于图中的所有点*/
    for (i=1; i<=ingraph[0]; i++)
    {
/*把节点放置到团中*/
        ++inclique[0];
 inclique[inclique[0]]=ingraph[i];
/*生成一个新的子图*/
 graph[0]=0;
 for (j=i+1; j<=ingraph[0]; j++)

 if (path[ingraph[i]][ingraph[j]] )
          graph[++graph[0]]=ingraph[j];
     dfs(graph);
/*从团中删除节点*/
        --inclique[0];}
}
int main()
{
int ingraph[maxn];
int i, j;
  cin >>n;
  while (n > 0)
  {
        for (i=0; i<n; i++)
 for (j=0; j<n; j++)
     cin >>path[i][j];
        max = 1;
/*初始化*/
        inclique[0]= 0;
        ingraph[0] = n;
 for (i=0; i<n; i++) ingraph[i+1]=i;
        dfs(ingraph);
        cout<<max<<endl;
        cin >>n;
  }
  return 0;}



 

 

 

 参考论文 <a fast algorithm for the maximum clique problem>

相关问题:

acm.zju.edu.cn: 1492 maximum clique

 

相关网站

http://acm.uva.es/p

http://acm.timus.ru/

msn: bing0672@hotmail.com

 

相关文章推荐

【算法入门经典】 回溯法排列组合

 排列: #include using namespace std; void pailie(int*a , int pos,int size,int * r,bool* visit...
  • po_csdn
  • po_csdn
  • 2014年05月08日 13:36
  • 238

排列组合和回溯算法-面试题

排列组合和回溯算法的面试题

排列组合算法实现--基于JS

公司要做了个彩票的预测奖金业务,居然要用到高中的排列组合,好吧,这个时候不得不承认,高中没有白上啊..... 排列组合的思想大家都清楚(不清楚的请回高中自行面壁。)   C n n一下子理不清,于是我...

Java排列组合算法

  • 2016年07月31日 15:56
  • 95KB
  • 下载

排列组合算法(非递归)

/************************  * 排列组合算法  * 非递归方式  *  * 编译器:borland c++  * 时间:2013-10-10  * 笔名:Jungle  * ...

排列组合的高效算法

1。最近一直在考虑从m个数里面取n个数的算法。最容易理解的就是递归,但是其效率,实在不能使用。一直找寻中,今日得果 2。算法来源与互联网 组合算法      本程序的思路是开一个数组,其...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:排列组合与回溯算法
举报原因:
原因补充:

(最多只允许输入30个字)