排列组合算法

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/zwj5361826/article/details/56280334

排列组合算法

组合算法

非递归算法

组合算法的思路是开一个数组,其下标表示1到m个数,数组元素的值为1表示其下标代表的数被选中,为0则没选中。

  1. 初始化,将数组前n个元素置1,表示第一个组合为前n个数。
  2. 从左到右扫描数组元素值的“10”组合,找到第一个“10”组合后将其变为“01”组合,同时将其左边的所有“1”全部移动到数组的最左端。

当第一个“1”移动到数组的m-n的位置,即n个“1”全部移动到最右端时,就得到了最后一个组合。

例如求5中选3的组合:

  1   1   1   0   0   //1,2,3     
  1   1   0   1   0   //1,2,4     
  1   0   1   1   0   //1,3,4     
  0   1   1   1   0   //2,3,4     
  1   1   0   0   1   //1,2,5     
  1   0   1   0   1   //1,3,5     
  0   1   1   0   1   //2,3,5     
  1   0   0   1   1   //1,4,5     
  0   1   0   1   1   //2,4,5     
  0   0   1   1   1   //3,4,5  

c++代码如下:

class Combination {
public:
    void combination(int n, int m) {
        int *a = new int[n];
        for (int i = 0; i < m; i++)
            a[i] = 1;
        for (int i = m; i < n; i++)
            a[i] = 0;
        bool tag = true;
        while (tag) {
            displayArray(a, n);
            for (int i = 0; i < n - 1; i++)
                if (a[i] == 1 && a[i + 1] == 0) {
                    tag = true;
                    a[i] = 0;
                    a[i + 1] = 1;
                    moveZeros(a, i);
                    break; 
                }
                else
                    tag = false;
        }
    }

private:
    void displayArray(int *a, int n) {
        for (int i = 0; i < n; i++)
            cout << a[i] << " ";
        cout << endl;
    }

    // 0到n-1,把1移到最左边
    void moveZeros(int *a, int n) {
        int left = 0, right = 0;
        while (right < n) {
            if (a[left] == 1)
                left++;
            else if (a[left] == 0 && a[right] == 1) {
                int t = a[left];
                a[left] = a[right];
                a[right] = t;
                left++;
            }
            right++;
        }

    }
};

递归算法

  1. 从n个数中选取编号最大的数,然后在剩下的n-1个数里面选取m-1个数,直到从n-(m-1)个数中选取1个数为止。
  2. 从n个数中选取编号次小的一个数,继续执行1步,直到当前可选编号最大的数为m。

c++代码如下

class Combination {
public:
    void combination(int n, int m) {
        int *a = new int[n];
        for (int i = 0; i < n; i++)
            a[i] = 0;
        func(a, n, m, n);
    }

private:
    void displayArray(int *a, int n) {
        for (int i = 0; i < n; i++)
            cout << a[i] << " ";
        cout << endl;
    }

    void func(int *a, int n, int m, const int N) {
        if (m == 0) {
            displayArray(a, N);
            return;
        }
        for (int i = n - 1; i >= m - 1; i--) {
            a[i] = 1;
            func(a, i, m - 1, N);
            a[i] = 0;
        }
    }
};

排列算法

递归算法

如果集合是{a,b,c},那么这个集合中元素的所有排列是{(a,b,c),(a,c,b),(b,a,c),(b,c,a),(c,a,b),(c,b,a)},显然,给定n个元素共有n!种不同的排列.
如果给定集合是{a,b,c,d},可以用下面给出的简单算法产生其所有排列,即集合(a,b,c,d)的所有排列有下面的排列组成:
(1)以a开头后面跟着(b,c,d)的排列
(2)以b开头后面跟着(a,c,d)的排列
(3)以c开头后面跟着(a,b,d)的排列
(4)以d开头后面跟着(a,b,c)的排列

这显然是一种递归的思路,于是我们得到了以下的实现:

c++代码如下

class Permutation {
public:
    void permutation(int n) {
        int *a = new int[n];
        for (int i = 0; i < n; i++)
            a[i] = 0;
        func(a, 1, n);
    }

private:
    void displayArray(int *a, int n) {
        for (int i = 0; i < n; i++)
            cout << a[i] << " ";
        cout << endl;
    }

    void func(int *a, int m, const int n) {
        if (m == n + 1) {
            displayArray(a, n);
            return;
        }
        for (int i = 0; i < n; i++) {
            if (a[i] == 0) {
                a[i] = m;
                func(a, m + 1, n);
                a[i] = 0;
            }
        }
    }
};

非递归算法

全排列生成算法的一个重要思路,就是将集合A中的元素的排列,与某种顺序建立一一映射的关系,按照这种顺序,将集合的所有排列全部输出。这种顺序需要保证,既可以输出全部的排列,又不能重复输出某种排列,或者循环输出一部分排列。
字典序就是用此种思想输出全排列的一种方式。这里以A{1,2,3,4}来说明用字典序输出全排列的方法。
首先,对于集合A的某种排列所形成的序列,字典序是比较序列大小的一种方式。
以A{1,2,3,4}为例,其所形成的排列1234<1243,比较的方法是从前到后依次比较两个序列的对应元素,如果当前位置对应元素相同,则继续比较下一个位置,直到第一个元素不同的位置为止,元素值大的元素在字典序中就大于元素值小的元素。
上面的a1[1…4]=1234和a2[1…4]=1243,对于i=1,i=2,两序列的对应元素相等,但是当i=2时,有a1[2]=3 < a2[2]=4,所以1234 < 1243。
使用字典序输出全排列的思路是,首先输出字典序最小的排列,然后输出字典序次小的排列,……,最后输出字典序最大的排列。
这里就涉及到一个问题,对于一个已知排列,如何求出其字典序中的下一个排列。这里给出算法。
对于排列a[1…n],找到所有满足a[k] < a[k+1] (0< k < n-1)的k的最大值,如果这样的k不存在,则说明当前排列已经是a的所有排列中字典序最大者,所有排列输出完毕。
在a[k+1…n]中,寻找满足这样条件的元素l,使得在所有a[l]>a[k]的元素中,a[l]取得最小值。也就是说a[l]>a[k],但是小于所有其他大于a[k]的元素。
交换a[l]与a[k].
对于a[k+1…n],反转该区间内元素的顺序。也就是说a[k+1]与a[n]交换,a[k+2]与a[n-1]交换,……,这样就得到了a[1…n]在字典序中的下一个排列。
这里我们以排列a[1…8]=13876542为例,来解释一下上述算法。首先我们发现,1(38)76542,括号位置是第一处满足a[k] < a[k+1]的位置,此时k=2。
所以我们在a[3…8]的区间内寻找比a[2]=3大的最小元素,找到a[7]=4满足条件,交换a[2]和a[7]得到新排列14876532,对于此排列的3~8区间,反转该区间的元素,将a[3]-a[8],a[4]-a[7],a[5]-a[6]分别交换,就得到了13876542字典序的下一个元素14235678。

下面是该算法的实现代码:

class Permutation {
public:
    void permutation(int n) {
        int *a = new int[n];
        for (int i = 0; i < n; i++)
            a[i] = i + 1;
        while (true) {
            displayArray(a, n);

            //找到k
            int k = n - 2;
            while (k != -1 && a[k] > a[k + 1])
                k--;
            if (k == -1)
                return;

            // 交换比k稍大的数
            int l = k + 1;
            for (int i = k + 1; i < n; i++)
                if (a[i] > a[k] && a[i] < a[l])
                    l = i;
            int t = a[k];
            a[k] = a[l];
            a[l] = t;

            //反转
            for (int i = 1; 2 * i < n - k; i++) {
                int t = a[k + i];
                a[k + i] = a[n - i];
                a[n - i] = t;
            }
        }
    }

private:
    void displayArray(int *a, int n) {
        for (int i = 0; i < n; i++)
            cout << a[i] << " ";
        cout << endl;
    }
};
阅读更多

没有更多推荐了,返回首页