排列组合

liyanan21

于 2018-08-16 17:08:26 发布

阅读量994

点赞数

一排列问题

排列问题可以按输入数据分为两大类：输入数据有重复和无重复，又可以按输出数据分为两大类：输出数据有重复和无重复；而排列问题也偶尔会考非递归。

首先提一下全排列的几种算法：

　　1——字典序法
　　2——递增进位数制法;
　　3——递减进位数制法
　　4——邻位交换法
　　5——n进制数法
　　6——递归生成法
　　7——循环移位法
　　8——回溯法

由本文的目的是总结排列的各种题型，而不是针对某个题型的各种算法，并且由于篇幅有限，感兴趣的朋友可以参考：

http://cache.baidu.com/cm=9f65cb4a8c8507ed4fece763104c8c711923d030678197027fa3c215cc790b1a0161e4bf233f405a8e90613c47f81641e1a43379360622e4cb998e4c8beb932e7f8a2633734ad74705d36ef58d197bd565cd1abfa00e96b0e741e3b9d3a3c82554dd22026df1f39c2c0203cb1fe76541f4d1985f655a07c9e7&p=8b2a9f0e96934eab5bacd3204a4c&user=baidu

由于侧重点在输入数据无重复，所以先看输入数据无重复类型：

其中又可以分为全排列和分组后排列：

首先写基本的全排列：

1.输出数组a的全排列(不可重复取)

如a={1,2,3}。输出123，132，213，231，312，321

这个是最基本，也是最经典的排列

算法思想：可以输出1加上23的全排列，2加13的全排列，3加上12的全排列，运用递归求比如23的全排列..依次递归下去；比如现在要2开头求全排，首先要交换1，2的位置，让a[0]变为2，在用递归求13的所有全排列，前面加个2就是2开头的所有全排列了，最后运用回溯再把1，2调换回来。

代码清单：

public class PaiLie {
	
	public void runPermutation(int[] a){
		getAllPermutation(a, 0);
	}
	/*index用于控制如上述分析中2加上13的所有全列的*/
	public void getAllPermutation(int[] a,int index){
 
		/*与a的元素个数相同则输出*/
		if(index == a.length-1){
			for(int i = 0; i < a.length; i++){
				System.out.print(a[i] + " ");
			}
			System.out.println();
			return;
		}
		
		for(int i = index; i < a.length; i++){
			
			swap(a ,index, i);
			getAllPermutation(a, index+1);
			swap(a ,index, i);
		}
	}
	public void swap(int[] a, int i, int j) {
	
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
 
	public static void main(String[] args) {
		
		PaiLie robot = new PaiLie();
		int[] a = {1,2,3};
		robot.runPermutation(a);
		
	}
}

2.输出数组a的全排列(可重复取)

如a={1,2}。输出11,12,21,22

如果知道a的length，可以用暴力法求解(n的循环)

如果不知道a的length的情况下：

算法思想：用一个辅助空间b数组存储待输出的排列，用一个参数index记录一个排列的个数

代码清单：

public class PaiLie {
	
	public void runPermutation(int[] a) {
		
		if(null == a || a.length == 0)
			return;
			
		int[] b = new int[a.length];//辅助空间，保存待输出排列数
		getAllPermutation(a, b, 0);
	}
 
	public void getAllPermutation(int[] a, int[] b, int index) {
		
		if(index == a.length){
			for(int i = 0; i < index; i++){
				System.out.print(b[i] + " ");
			}
			System.out.println();
			return;
		}
			
		for(int i = 0; i < a.length; i++){
			
			b[index] = a[i];
			getAllPermutation(a, b, index+1);
		}
		
	}
	
	public static void main(String[] args){
		
		PaiLie robot = new PaiLie();
		
		int[] a = {1,2,3};
		robot.runPermutation(a);
 
	}
 
}

3.输出数组a的全排列(非递归)

如a={1,2,3}。输出123,132,213,231,312,321

全排列的非递归算法也不唯一，我写一个最常用的按字典序非递归算法

所谓字典序就是按照排列数的从大到小或从小到大输出，如123，132，2..，3...

算法思想：如果能按顺序输出序列是这个算法的核心，为了保证按顺序输出先对数组a进行排序。然后从后向前找到第一个顺序对（12是顺序对，21不是）标记为i，然后再从后面向前找到第一个比i大的数，记录为j，随后交换i,j对应的值，再逆序数组a[i+1]到a[length-1]。听到这里大家一定很迷糊，我们来举个例子，比如说2431这个数我们先在i，因为31是逆序，43是逆序，24是顺序，所以i=0；接着我们找j，第一个比2大的数是3，所以j=3，然后交换i，j变成（3，4，2，1）我们看看为什么要交换2,3？因为这个算法的核心思想是按字典序，而2431是以2开头的最大排列，下一个数就得是以3开头了（如果原数是2341按算法就是先要变成2431），接着3421这个数要进行i+1到length-1之间的逆序，变成3124，这个是2431的下一个数。所以可以看出交换后的数从下位开始到最后一定是一个逆序排列，所以逆序后才变成了相对的“最小值”。

代码清单：

import java.util.Arrays;
 
 
public class PaiLie {
	
        public void runNoRecursionOfPermutation(int[] a){
		
		Arrays.sort(a);//对数组排序
		while(true){
			
			printArray(a);//输出一个排列
			
			int i;//从后向前，记录一对顺序值中的小值下标
			int j;//从后向前，记录比i大的第一个数
			
			for(i = a.length-2; i >= 0; i--){
				
				if(a[i] < a[i+1])//如果找到i跳出
					break;
				else if(i == 0)//说明是最大逆序数退出函数
					return;
			}
			for(j = a.length-1; j > i; j--){
				if(a[j] > a[i])//找到j跳出
					break;
			}
			swap(a, i, j);//交换i，j
			reverse(a, i+1, a.length-1);//翻转
		}
	}
	public void swap(int[] a, int i, int j) {
	
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
	public void reverse(int[] a, int i, int j){
		while(i < j)
			swap(a, i++, j--);
	}
	
        public void printArray(int[] a) {
		
		for(int i = 0; i < a.length; i++){
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		
		PaiLie robot = new PaiLie();
		int[] a = {1,2,3};
		robot.runNoRecursionOfPermutation(a);
		
	}
}

4.输出从数组a中取n个数的所有排列

如a={1,2,3} n=2输出12，21，13，31，23，32

这道题可以看作是排列组合的综合题，有关组合问题也可以参考我写的组合篇

http://blog.csdn.net/nash_/article/details/8315418

算法思想：求出a中选取n个数的所有组合，分别对其进行全排列。

代码清单：

public class PaiLie {
	
	public void runPermutation(int[] a, int n) {
		
		if(null == a || a.length == 0 || n <= 0 || n > a.length)
			return;
			
		int[] b = new int[n];//辅助空间，保存待输出组合数
		getCombination(a, n , 0, b, 0);
	}
 
	public void getCombination(int[] a, int n, int begin, int[] b, int index) {
		
		if(n == 0){//如果够n个数了，输出b数组
			
			getAllPermutation(b,0);//得到b的全排列
			return;
		}
			
		for(int i = begin; i < a.length; i++){
			
			b[index] = a[i];
			getCombination(a, n-1, i+1, b, index+1);
		}
		
	}
	public void getAllPermutation(int[] a,int index){
 
		/*与a的元素个数相同则输出*/
		if(index == a.length-1){
			for(int i = 0; i < a.length; i++){
				System.out.print(a[i] + " ");
			}
			System.out.println();
			return;
		}
		
		for(int i = index; i < a.length; i++){
			
			swap(a ,index, i);
			getAllPermutation(a, index+1);
			swap(a ,index, i);
		}
	}
	public void swap(int[] a, int i, int j) {
	
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
	public static void main(String[] args){
		
		PaiLie robot = new PaiLie();
		
		int[] a = {1,2,3};
		int n = 2;
		robot.runPermutation(a,n);
 
	}
 
}

输入数据有重复类型：

这类如a={1,3,2,3} 3出现了两次，用以上排列会造成输出重复。

5.输出数组a的全排列(递归)

如a={1,1,2}输出112,121,211

算法思想：我们改进一下1的算法，在for中判断是否有包含重复元素，也就是index和i之间是否有和a[i]相等的值，比如对于2313这个数列，当index=0(a[index] = 2),i=3(a[i] = 3)的时候,如果要交换这两个数变成3312的话就是计算重复了，因为它们之间有1个3，当i=1的时候，它已经转换过3312了。所以加一个函数判断中间有没有包含重复元素，如有没有重复元素，再做交换。

代码清单：

public class PaiLie {
	
	public void runPermutation(int[] a){
		getAllPermutation(a, 0);
	}
	/*index用于控制如上述分析中2加上13的所有全列的*/
	public void getAllPermutation(int[] a,int index){
 
		/*与a的元素个数相同则输出*/
		if(index == a.length-1){
			for(int i = 0; i < a.length; i++){
				System.out.print(a[i] + " ");
			}
			System.out.println();
			return;
		}
		
		for(int i = index; i < a.length; i++){
			
			if(contains(a, index ,i))
				continue;
			swap(a ,index, i);
			getAllPermutation(a, index+1);
			swap(a ,index, i);
		}
	}
	
	public boolean contains(int[] a, int m, int n) {
		
		 for (int i = m; i < n; i++) {
 
			   if (a[i] == a[n])
			    return true;
			  }
		return false;
	}
	public void swap(int[] a, int i, int j) {
	
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
 
	public static void main(String[] args) {
		
		PaiLie robot = new PaiLie();
		int[] a = {1,1,2};
		robot.runPermutation(a);
		
	}
}

6.输出数组a的全排列(非递归)

如a={1,1,2}输出112,121,211

算法思想：对于重复输入数据的非递归，我们仍然可以用算法3，因为排序后，相等的数都挨着，而我们认为相等的两个数不构成“有序”，所以就不会造成重复，并且按字典序输出所有排列。

代码清单：

import java.util.Arrays;
 
 
public class PaiLie {
	
       public void runNoRecursionOfPermutation(int[] a){
		
		Arrays.sort(a);//对数组排序
		while(true){
			
			printArray(a);//输出一个排列
			
			int i;//从后向前，记录一对顺序值中的小值下标
			int j;//从后向前，记录比i大的第一个数
			
			for(i = a.length-2; i >= 0; i--){
				
				if(a[i] < a[i+1])//如果找到i跳出
					break;
				else if(i == 0)//说明是最大逆序数退出函数
					return;
			}
			for(j = a.length-1; j > i; j--){
				if(a[j] > a[i])//找到j跳出
					break;
			}
			swap(a, i, j);//交换i，j
			reverse(a, i+1, a.length-1);//翻转
		}
	}
	public void swap(int[] a, int i, int j) {
	
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
	public void reverse(int[] a, int i, int j){
		while(i < j)
			swap(a, i++, j--);
	}
	public void printArray(int[] a) {
		
		for(int i = 0; i < a.length; i++){
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		
		PaiLie robot = new PaiLie();
		int[] a = {1,2,3};
		robot.runNoRecursionOfPermutation(a);
		
	}
}

二组合问题

绝大部分组合问题都是无重复数字或者字符的；所以组合问题可以按输入数据分为两大类：输入数据有重复和无重复，又可以按输出数据分为两大类：输出数据有重复和无重复。

由于侧重点在输入数据无重复，所以先看输入数据无重复类型：

1. 从数组a中，取出n个数的所有组合(不可重复取)

如a={1,2,3}。当n=2时候的所有组合数为12，13，23

算法思想：按递增顺序输出，如12,13,14,15.....23.24.25........34,35.............用一个变量begin遍历的第一个数

代码清单：

public class ZuHe {
	
	public void combine(int[] a, int n) {
		
		if(null == a || a.length == 0 || n <= 0 || n > a.length)
			return;
			
		int[] b = new int[n];//辅助空间，保存待输出组合数
		getCombination(a, n , 0, b, 0);
	}
 
	private void getCombination(int[] a, int n, int begin, int[] b, int index) {
		
		if(n == 0){//如果够n个数了，输出b数组
			for(int i = 0; i < index; i++){
				System.out.print(b[i] + " ");
			}
			System.out.println();
			return;
		}
			
		for(int i = begin; i < a.length; i++){
			
			b[index] = a[i];
			getCombination(a, n-1, i+1, b, index+1);
		}
		
	}
	
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		
		int[] a = {1,2,3,4};
		int n = 2;
		robot.combine(a,n);
 
	}
 
}

2.从数组a中，取出n个数的所有组合(可重复取)

如a={1,2,3}。当n=2时候的所有组合数为11,12,13,22,23,33

算法思想：首先对数组a排序，再利用1的算法，把i=begin,改成i=0,让它每次从0开始遍历，但每个组合都是升序排列，所以为了去重加上升序的判断

代码清单：

import java.util.Arrays;
 
public class ZuHe {
	
	public void combine(int[] a, int n) {
		
		if(null == a || a.length == 0 || n <= 0 || n > a.length)
			return;
			
		Arrays.sort(a);
		int[] b = new int[n];//辅助空间，保存待输出组合数
		getCombination(a, n , 0, b, 0);
	}
 
	private void getCombination(int[] a, int n, int begin, int[] b, int index) {
		
		if(n == 0){//如果够n个数了，输出b数组
			for(int i = 0; i < index; i++){
				System.out.print(b[i] + " ");
			}
			System.out.println();
			return;
		}
			
		for(int i = 0; i < a.length; i++){
			
			if(index == 0 || a[i] >= b[index-1]){
				b[index] = a[i];
				getCombination(a, n-1, i+1, b, index+1);
			}
		}
		
	}
	
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		
		int[] a = {1,2,3,4};
		int n = 3;
		robot.combine(a,n);
 
	}
 
}

3.输入两个整数 n 和 m，从数列1，2，3.......n 中随意取几个数，使其和等于 m ,要求将其中所有的可能组合列出来（不可重复取）

如m =5,n=4 输出14，23

这种问法是典型01背包问题，因为要求是输出所有组合，所以我们不用DP，而用回溯

算法思想：从最大数n开始尝试装包，输出所有情况，再尝试n不装包，输出所有情况。

代码清单：

public class ZuHe {
	
	public void combine(int m, int n) {
		
		if(m < 1 || n < 1)
			return;
			
		if(n > m)//如果n>m,把n>m的数去掉
			n = m;
		
		boolean[] b = new boolean[n+1];//保存是否装包
		getCombination(m, n, b);
	}
	public void getCombination(int m, int n, boolean[] b){
		
		if(m < 1 || n < 1)//递归出口
			return;
				
		if(m == n){//输出组合
			b[n] = true;
			for(int i = 1; i < b.length; i++){
				if(b[i] == true)
					System.out.print(i + " ");
				
			}
			System.out.println();
			b[n] = false;
		}
		b[n] = true;//装包
		getCombination(m-n, n-1, b);
		b[n] = false;//不装包
		getCombination(m, n-1, b);
	}
	
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		
		int[] a = {1,2,3,4};
		int n = 3;
		robot.combine(10,12);
 
	}
 
}

4.输入两个整数 n 和 m，从数列1，2，3.......n 中随意取几个数，使其和等于 m ,要求将其中所有的可能组合列出来（可重复取）

如m =3,n=2 输出111，12

算法思想：由于组合元素个数未知，所以改用集合存储，使集合内元素有序为了去重，当m=0时候输出结果。

代码清单：

import java.util.ArrayList;
 
public class ZuHe {
	
	public void combine(int m,int n) {
		
		if(m < 1 || n < 1)
			return;
		if(m > n)
			n = m;
		ArrayList<Integer> arr = new ArrayList<Integer>();
		getCombination(m,n, arr);
	}
	public void getCombination(int m, int n,ArrayList<Integer> arr) {
		
		if(m < 0)
			return;
		if (m == 0 && arr.size() > 1) {
			for (int i = 0; i < arr.size(); i++) {
				
				System.out.print(arr.get(i) + " ");
			}
			System.out.println();
			return;
		}
		for (Integer i = 1; i <= n; i++) {
			
			if (!arr.isEmpty() && i < arr.get(arr.size() - 1))//使集合内元素递增，防止重复
				continue;
			arr.add(i);
			getCombination(m - i, n, arr);
			arr.remove(i);
			
		}
	}
	
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		robot.combine(3,2);
 
	}
 
}

5.求将m分解成n个正整数相加之和的所有组合（可重复取）

如m=5，n=3 输出113，122

算法思想：按递增序列递归求解，如果 n==0 && m==0 输出结果，如果n==0,m!=0,返回

代码清单：

public class ZuHe {
	
	public void combine(int m, int n) {
		
		if(m < 1 || n < 1)
			return;
		
		int[] b = new int[n];
		getCombination(m, n, b, 0, 1);
	}
	private void getCombination(int m, int n,int b[], int index,int begin) {
		// TODO Auto-generated method stub
		if(n == 0 && m == 0){
			for(int i = 0; i < b.length; i++)
				System.out.print(b[i] + " ");
			System.out.println();
		}
		if(n == 0)
			return;
		
		for(int i = begin; i <= m; i++){
			b[index] = i;
			getCombination(m-i,n-1,b ,index+1,i);
		
		}
		
	}
	
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		robot.combine(5,3);
 
	}
 
}

6.求将m分解成n个正整数相加之和的所有组合（不可重复取）

如m=6，n=3 输出123

算法思想：按递增序列递归求解，如果 n==0 && m==0 输出结果，如果n==0,m!=0,返回，将递归调用设置成i+1

代码清单：

public class ZuHe {
	
	public void combine(int m, int n) {
		
		if(m < 1 || n < 1)
			return;
		
		int[] b = new int[n];
		getCombination(m, n, b, 0, 1);
	}
	private void getCombination(int m, int n,int b[], int index,int begin) {
		// TODO Auto-generated method stub
		if(n == 0 && m == 0){
			for(int i = 0; i < b.length; i++)
				System.out.print(b[i] + " ");
			System.out.println();
		}
		if(n == 0)
			return;
		
		for(int i = begin; i <= m; i++){
			b[index] = i;
			getCombination(m-i,n-1,b ,index+1,i+1);
		
		}
		
	}
	
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		robot.combine(5,3);
 
	}
 
}

7.求将m分解成任意个正整数相加之和的所有组合

如m=3 输出111，12，3

算法思想（与算法4相同）：由于组合元素个数未知，所以改用集合存储，使集合内元素有序为了去重，当m=0时候输出结果

代码清单：

public class ZuHe {
	
	public void combine(int m) {
		
		if(m < 1 )
			return;
		
		ArrayList<Integer> arr = new ArrayList<Integer>();
		getCombination(m, arr);
	}
	public void getCombination(int m, ArrayList<Integer> arr) {
		
		if (m == 0 && arr.size() > 1) {
			for (int i = 0; i < arr.size(); i++) {
				
				System.out.print(arr.get(i) + " ");
			}
			System.out.println();
			return;
		}
		for (Integer i = 1; i <= m; i++) {
			
			if (!arr.isEmpty() && i < arr.get(arr.size() - 1))//使集合内元素递增，防止重复
				continue;
			arr.add(i);
			getCombination(m - i, arr);
			arr.remove(i);
			
		}
	}
	
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		robot.combine(5);
 
	}
}

8.输出数组a的所有组合(不可重复取)

如a={1,2,3}输出1，2，3，12，13，23，123
算法思想：我们把输出顺序重新排列：1，12，123，13，2，23，3可以看出规律以1开头加上以非1开头的所有组合就构成了以1开头的所有组合，2，3同理，用一个参数index控制输出范围。
代码清单：

public class ZuHe {
	
	public void combine(int[] a) {
		
		if(null == a || a.length == 0)
			return;
		int[] b = new int[a.length];
		getCombination(a, 0, b, 0);
	}
	private void getCombination(int[] a, int begin, int b[], int index) {
		
		if(index >= a.length)
			return;
		for(int i = begin; i < a.length; i++){
			
			b[index] = a[i];
			printArray(b,index);
			getCombination(a, i+1, b, index+1);
		}
	}
		private void printArray(int[] b, int index) {
			
			for(int i = 0; i < index+1; i++){
				System.out.print(b[i] + " ");
			}
			System.out.println();
		}
		
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		int[] a = {1,2,3};
		robot.combine(a);
 
	}
 
}

9.输出数组a的所有组合(可重复取)

如a={1,2}输出1，11，12，2，22

算法思想：我们把输出顺序重新排列：1，12，123，13，2，23，3可以看出规律以1开头加上以非1开头的所有组合就构成了以1开头的所有组合，2，3同理，用一个参数index控制输出范围，去掉begin参数，保持序列递增有序。

代码清单：

public class ZuHe {
	
	public void combine(int[] a) {
		
		if(null == a || a.length == 0)
			return;
		int[] b = new int[a.length];
		getCombination(a,  b, 0);
	}
	private void getCombination(int[] a, int b[], int index) {
		
		if(index >= a.length)
			return;
		for(int i = 0; i < a.length; i++){
			
			if(index == 0 || a[i] >= b[index-1]){
				b[index] = a[i];
				printArray(b,index);
				getCombination(a,  b, index+1);
			}
		}
	}
		private void printArray(int[] b, int index) {
			
			for(int i = 0; i < index+1; i++){
				System.out.print(b[i] + " ");
			}
			System.out.println();
		}
		
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		int[] a = {1,2,3};
		robot.combine(a);
 
	}
 
}

输入数据有重复类型：

这类如a={1,3,2,3}，这种问题相对较少，博主可以没有什么特别好的想法，只想到了两种通用的思路：

思路一：每次添加一个序列时，判断此序列是否已添加过。

思路二：添加所有的序列，最后去重。

两种思路解法差不多，但由于判断的是一个序列存不存在，所以不能直接用Hash，博主按思路一写了一题的解法供参考：

题目：输出数组a的所有数的所有组合

如a={1,2,2}输出111，112，122，222

算法思想：在判断序列是否已添加之前，排序该序列，再验证；如果不存在，拷贝该序列添加到集合中。

代码清单：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class ZuHe {
	
	/*保存序列集合*/
	ArrayList<List<Integer>> _arr = new ArrayList<List<Integer>>();
	
	public void combine(int[] a) {
		
		if(null == a || a.length == 0)
			return;
		List<Integer> b = new ArrayList<Integer>();//序列存储空间
		getCombination(a,b);
		printArr();//输出所有组合
	}
	public void getCombination(int[] a, List<Integer> b){
		
		if(a.length == b.size()){
			
			/*自定义按List中升序排序*/
			Collections.sort(b, new Comparator() {
 
				public int compare(Object o1, Object o2) {
					return (Integer)o1 - (Integer)o2;
				}
			    });
			if(!haveArray(b)){//如果序列b不存在
				
				/*拷贝一个序列b*/
				List<Integer> new_list = new ArrayList<Integer>();
				for(int i = 0; i < b.size(); i++){
					new_list.add(b.get(i));
				}
			
				_arr.add(new_list);//加入集合中
			}
			return;
		}
		for(int i = 0; i < a.length; i++){
			
			Integer num = a[i];
			b.add(num);
			getCombination(a, b);
			b.remove(num);
		}
	}
	private boolean haveArray(List<Integer> b) {
		
		for(int i = 0; i < _arr.size(); i++){
			List<Integer> temp = _arr.get(i);
			int j;
			for(j = 0; j < temp.size(); j++){
				if(temp.get(j) != b.get(j))
					break;
			}
			if(j >= temp.size())
				return true;
		}
		return false;
	}
	public void printArr(){
		for(int i = 0; i < _arr.size(); i++){
			List<Integer> temp = _arr.get(i);
			for(int j = 0; j < temp.size(); j++)
				System.out.print(temp.get(j) + " ");
			System.out.println();
		}
	}
	public static void main(String[] args){
		
		ZuHe robot = new ZuHe();
		int[] a = {1,2,2};
		robot.combine(a);
 
	}
 
}

转自：

https://blog.csdn.net/zmazon/article/details/8351611

https://blog.csdn.net/zmazon/article/details/8315418

liyanan21

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
排列组合

一排列问题排列问题可以按输入数据分为两大类：输入数据有重复和无重复，又可以按输出数据分为两大类：输出数据有重复和无重复；而排列问题也偶尔会考非递归。首先提一下全排列的几种算法：　　1——字典序法　　2——递增进位数制法;　　3——递减进位数制法　　4——邻位交换法　　5——n进制数法　　6——递归生成法　　7——循环移位法　　8——回溯法由本文的目的是总结排列的各种...
复制链接

扫一扫