秒杀排列组合（下）————组合篇

最新推荐文章于 2023-04-10 19:38:44 发布
最新推荐文章于 2023-04-10 19:38:44 发布
阅读量755 收藏
点赞数
分类专栏： 数学算法

首先为什么要写排列组合？因为排列组合在数学中占有重要的地位，其与概率论也有密切关系；并且排列组合问题在求职的笔试，面试出现的概率特别高，而我在网上又没有搜到比较全面题型的文章；同时，我觉得编写排列组合程序对学习递归也是很有帮助的；当然，最重要的原因是排列组合本身就很有趣！所以就总结下排列组合的各种问法，分两篇写：上篇写排列，下篇写组合。



组合篇

排列篇地址：http://blog.csdn.net/nash_/article/details/8351611


首先从各大IT公司的题中总结出排列组合的对象都是整形数组或字符数组，而且绝大部分组合问题都是无重复数字或者字符的；所以组合问题可以按输入数据分为两大类：输入数据有重复和无重复，又可以按输出数据分为两大类：输出数据有重复和无重复。


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


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

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

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

代码清单：

[java] view plain copy print ?
  1. public class ZuHe {  
  2.       
  3.     public void combine(int[] a, int n) {  
  4.           
  5.         if(null == a || a.length == 0 || n <= 0 || n > a.length)  
  6.             return;  
  7.               
  8.         int[] b = new int[n];//辅助空间，保存待输出组合数   
  9.         getCombination(a, n , 0, b, 0);  
  10.     }  
  11.   
  12.     private void getCombination(int[] a, int n, int begin, int[] b, int index) {  
  13.           
  14.         if(n == 0){//如果够n个数了，输出b数组   
  15.             for(int i = 0; i < index; i++){  
  16.                 System.out.print(b[i] + " ");  
  17.             }  
  18.             System.out.println();  
  19.             return;  
  20.         }  
  21.               
  22.         for(int i = begin; i < a.length; i++){  
  23.               
  24.             b[index] = a[i];  
  25.             getCombination(a, n-1, i+1, b, index+1);  
  26.         }  
  27.           
  28.     }  
  29.       
  30.     public static void main(String[] args){  
  31.           
  32.         ZuHe robot = new ZuHe();  
  33.           
  34.         int[] a = {1,2,3,4};  
  35.         int n = 2;  
  36.         robot.combine(a,n);  
  37.   
  38.     }  
  39.   
  40. }  
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开始遍历，但每个组合都是升序排列，所以为了去重加上升序的判断

代码清单：

[java] view plain copy print ?
  1. import java.util.Arrays;  
  2.   
  3. public class ZuHe {  
  4.       
  5.     public void combine(int[] a, int n) {  
  6.           
  7.         if(null == a || a.length == 0 || n <= 0 || n > a.length)  
  8.             return;  
  9.               
  10.         Arrays.sort(a);  
  11.         int[] b = new int[n];//辅助空间，保存待输出组合数   
  12.         getCombination(a, n , 0, b, 0);  
  13.     }  
  14.   
  15.     private void getCombination(int[] a, int n, int begin, int[] b, int index) {  
  16.           
  17.         if(n == 0){//如果够n个数了，输出b数组   
  18.             for(int i = 0; i < index; i++){  
  19.                 System.out.print(b[i] + " ");  
  20.             }  
  21.             System.out.println();  
  22.             return;  
  23.         }  
  24.               
  25.         for(int i = 0; i < a.length; i++){  
  26.               
  27.             if(index == 0 || a[i] >= b[index-1]){  
  28.                 b[index] = a[i];  
  29.                 getCombination(a, n-1, i+1, b, index+1);  
  30.             }  
  31.         }  
  32.           
  33.     }  
  34.       
  35.     public static void main(String[] args){  
  36.           
  37.         ZuHe robot = new ZuHe();  
  38.           
  39.         int[] a = {1,2,3,4};  
  40.         int n = 3;  
  41.         robot.combine(a,n);  
  42.   
  43.     }  
  44.   
  45. }  
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不装包，输出所有情况。

代码清单：

[java] view plain copy print ?
  1. public class ZuHe {  
  2.       
  3.     public void combine(int m, int n) {  
  4.           
  5.         if(m < 1 || n < 1)  
  6.             return;  
  7.               
  8.         if(n > m)//如果n>m,把n>m的数去掉   
  9.             n = m;  
  10.           
  11.         boolean[] b = new boolean[n+1];//保存是否装包   
  12.         getCombination(m, n, b);  
  13.     }  
  14.     public void getCombination(int m, int n, boolean[] b){  
  15.           
  16.         if(m < 1 || n < 1)//递归出口   
  17.             return;  
  18.                   
  19.         if(m == n){//输出组合   
  20.             b[n] = true;  
  21.             for(int i = 1; i < b.length; i++){  
  22.                 if(b[i] == true)  
  23.                     System.out.print(i + " ");  
  24.                   
  25.             }  
  26.             System.out.println();  
  27.             b[n] = false;  
  28.         }  
  29.         b[n] = true;//装包   
  30.         getCombination(m-n, n-1, b);  
  31.         b[n] = false;//不装包   
  32.         getCombination(m, n-1, b);  
  33.     }  
  34.       
  35.     public static void main(String[] args){  
  36.           
  37.         ZuHe robot = new ZuHe();  
  38.           
  39.         int[] a = {1,2,3,4};  
  40.         int n = 3;  
  41.         robot.combine(10,12);  
  42.   
  43.     }  
  44.   
  45. }  
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时候输出结果。

代码清单：

[java] view plain copy print ?
  1. import java.util.ArrayList;  
  2.   
  3. public class ZuHe {  
  4.       
  5.     public void combine(int m,int n) {  
  6.           
  7.         if(m < 1 || n < 1)  
  8.             return;  
  9.         if(m > n)  
  10.             n = m;  
  11.         ArrayList<Integer> arr = new ArrayList<Integer>();  
  12.         getCombination(m,n, arr);  
  13.     }  
  14.     public void getCombination(int m, int n,ArrayList<Integer> arr) {  
  15.           
  16.         if(m < 0)  
  17.             return;  
  18.         if (m == 0 && arr.size() > 1) {  
  19.             for (int i = 0; i < arr.size(); i++) {  
  20.                   
  21.                 System.out.print(arr.get(i) + " ");  
  22.             }  
  23.             System.out.println();  
  24.             return;  
  25.         }  
  26.         for (Integer i = 1; i <= n; i++) {  
  27.               
  28.             if (!arr.isEmpty() && i < arr.get(arr.size() - 1))//使集合内元素递增，防止重复   
  29.                 continue;  
  30.             arr.add(i);  
  31.             getCombination(m - i, n, arr);  
  32.             arr.remove(i);  
  33.               
  34.         }  
  35.     }  
  36.       
  37.     public static void main(String[] args){  
  38.           
  39.         ZuHe robot = new ZuHe();  
  40.         robot.combine(3,2);  
  41.   
  42.     }  
  43.   
  44. }  
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,返回

代码清单：

[java] view plain copy print ?
  1. public class ZuHe {  
  2.       
  3.     public void combine(int m, int n) {  
  4.           
  5.         if(m < 1 || n < 1)  
  6.             return;  
  7.           
  8.         int[] b = new int[n];  
  9.         getCombination(m, n, b, 0, 1);  
  10.     }  
  11.     private void getCombination(int m, int n,int b[], int index,int begin) {  
  12.         // TODO Auto-generated method stub   
  13.         if(n == 0 && m == 0){  
  14.             for(int i = 0; i < b.length; i++)  
  15.                 System.out.print(b[i] + " ");  
  16.             System.out.println();  
  17.         }  
  18.         if(n == 0)  
  19.             return;  
  20.           
  21.         for(int i = begin; i <= m; i++){  
  22.             b[index] = i;  
  23.             getCombination(m-i,n-1,b ,index+1,i);  
  24.           
  25.         }  
  26.           
  27.     }  
  28.       
  29.     public static void main(String[] args){  
  30.           
  31.         ZuHe robot = new ZuHe();  
  32.         robot.combine(5,3);  
  33.   
  34.     }  
  35.   
  36. }  
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

代码清单：

[java] view plain copy print ?
  1. public class ZuHe {  
  2.       
  3.     public void combine(int m, int n) {  
  4.           
  5.         if(m < 1 || n < 1)  
  6.             return;  
  7.           
  8.         int[] b = new int[n];  
  9.         getCombination(m, n, b, 0, 1);  
  10.     }  
  11.     private void getCombination(int m, int n,int b[], int index,int begin) {  
  12.         // TODO Auto-generated method stub   
  13.         if(n == 0 && m == 0){  
  14.             for(int i = 0; i < b.length; i++)  
  15.                 System.out.print(b[i] + " ");  
  16.             System.out.println();  
  17.         }  
  18.         if(n == 0)  
  19.             return;  
  20.           
  21.         for(int i = begin; i <= m; i++){  
  22.             b[index] = i;  
  23.             getCombination(m-i,n-1,b ,index+1,i+1);  
  24.           
  25.         }  
  26.           
  27.     }  
  28.       
  29.     public static void main(String[] args){  
  30.           
  31.         ZuHe robot = new ZuHe();  
  32.         robot.combine(5,3);  
  33.   
  34.     }  
  35.   
  36. }  
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时候输出结果

代码清单：

[java] view plain copy print ?
  1. public class ZuHe {  
  2.       
  3.     public void combine(int m) {  
  4.           
  5.         if(m < 1 )  
  6.             return;  
  7.           
  8.         ArrayList<Integer> arr = new ArrayList<Integer>();  
  9.         getCombination(m, arr);  
  10.     }  
  11.     public void getCombination(int m, ArrayList<Integer> arr) {  
  12.           
  13.         if (m == 0 && arr.size() > 1) {  
  14.             for (int i = 0; i < arr.size(); i++) {  
  15.                   
  16.                 System.out.print(arr.get(i) + " ");  
  17.             }  
  18.             System.out.println();  
  19.             return;  
  20.         }  
  21.         for (Integer i = 1; i <= m; i++) {  
  22.               
  23.             if (!arr.isEmpty() && i < arr.get(arr.size() - 1))//使集合内元素递增，防止重复   
  24.                 continue;  
  25.             arr.add(i);  
  26.             getCombination(m - i, arr);  
  27.             arr.remove(i);  
  28.               
  29.         }  
  30.     }  
  31.       
  32.     public static void main(String[] args){  
  33.           
  34.         ZuHe robot = new ZuHe();  
  35.         robot.combine(5);  
  36.   
  37.     }  
  38. }  
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控制输出范围。
代码清单：

[java] view plain copy print ?
  1. public class ZuHe {  
  2.       
  3.     public void combine(int[] a) {  
  4.           
  5.         if(null == a || a.length == 0)  
  6.             return;  
  7.         int[] b = new int[a.length];  
  8.         getCombination(a, 0, b, 0);  
  9.     }  
  10.     private void getCombination(int[] a, int begin, int b[], int index) {  
  11.           
  12.         if(index >= a.length)  
  13.             return;  
  14.         for(int i = begin; i < a.length; i++){  
  15.               
  16.             b[index] = a[i];  
  17.             printArray(b,index);  
  18.             getCombination(a, i+1, b, index+1);  
  19.         }  
  20.     }  
  21.         private void printArray(int[] b, int index) {  
  22.               
  23.             for(int i = 0; i < index+1; i++){  
  24.                 System.out.print(b[i] + " ");  
  25.             }  
  26.             System.out.println();  
  27.         }  
  28.           
  29.     public static void main(String[] args){  
  30.           
  31.         ZuHe robot = new ZuHe();  
  32.         int[] a = {1,2,3};  
  33.         robot.combine(a);  
  34.   
  35.     }  
  36.   
  37. }  
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参数，保持序列递增有序。

代码清单：

[java] view plain copy print ?
  1. public class ZuHe {  
  2.       
  3.     public void combine(int[] a) {  
  4.           
  5.         if(null == a || a.length == 0)  
  6.             return;  
  7.         int[] b = new int[a.length];  
  8.         getCombination(a,  b, 0);  
  9.     }  
  10.     private void getCombination(int[] a, int b[], int index) {  
  11.           
  12.         if(index >= a.length)  
  13.             return;  
  14.         for(int i = 0; i < a.length; i++){  
  15.               
  16.             if(index == 0 || a[i] >= b[index-1]){  
  17.                 b[index] = a[i];  
  18.                 printArray(b,index);  
  19.                 getCombination(a,  b, index+1);  
  20.             }  
  21.         }  
  22.     }  
  23.         private void printArray(int[] b, int index) {  
  24.               
  25.             for(int i = 0; i < index+1; i++){  
  26.                 System.out.print(b[i] + " ");  
  27.             }  
  28.             System.out.println();  
  29.         }  
  30.           
  31.     public static void main(String[] args){  
  32.           
  33.         ZuHe robot = new ZuHe();  
  34.         int[] a = {1,2,3};  
  35.         robot.combine(a);  
  36.   
  37.     }  
  38.   
  39. }  
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

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

代码清单：

[java] view plain copy print ?
  1. import java.util.ArrayList;  
  2. import java.util.Collections;  
  3. import java.util.Comparator;  
  4. import java.util.List;  
  5.   
  6. public class ZuHe {  
  7.       
  8.     /*保存序列集合*/  
  9.     ArrayList<List<Integer>> _arr = new ArrayList<List<Integer>>();  
  10.       
  11.     public void combine(int[] a) {  
  12.           
  13.         if(null == a || a.length == 0)  
  14.             return;  
  15.         List<Integer> b = new ArrayList<Integer>();//序列存储空间   
  16.         getCombination(a,b);  
  17.         printArr();//输出所有组合   
  18.     }  
  19.     public void getCombination(int[] a, List<Integer> b){  
  20.           
  21.         if(a.length == b.size()){  
  22.               
  23.             /*自定义按List中升序排序*/  
  24.             Collections.sort(b, new Comparator() {  
  25.   
  26.                 public int compare(Object o1, Object o2) {  
  27.                     return (Integer)o1 - (Integer)o2;  
  28.                 }  
  29.                 });  
  30.             if(!haveArray(b)){//如果序列b不存在   
  31.                   
  32.                 /*拷贝一个序列b*/  
  33.                 List<Integer> new_list = new ArrayList<Integer>();  
  34.                 for(int i = 0; i < b.size(); i++){  
  35.                     new_list.add(b.get(i));  
  36.                 }  
  37.               
  38.                 _arr.add(new_list);//加入集合中   
  39.             }  
  40.             return;  
  41.         }  
  42.         for(int i = 0; i < a.length; i++){  
  43.               
  44.             Integer num = a[i];  
  45.             b.add(num);  
  46.             getCombination(a, b);  
  47.             b.remove(num);  
  48.         }  
  49.     }  
  50.     private boolean haveArray(List<Integer> b) {  
  51.           
  52.         for(int i = 0; i < _arr.size(); i++){  
  53.             List<Integer> temp = _arr.get(i);  
  54.             int j;  
  55.             for(j = 0; j < temp.size(); j++){  
  56.                 if(temp.get(j) != b.get(j))  
  57.                     break;  
  58.             }  
  59.             if(j >= temp.size())  
  60.                 return true;  
  61.         }  
  62.         return false;  
  63.     }  
  64.     public void printArr(){  
  65.         for(int i = 0; i < _arr.size(); i++){  
  66.             List<Integer> temp = _arr.get(i);  
  67.             for(int j = 0; j < temp.size(); j++)  
  68.                 System.out.print(temp.get(j) + " ");  
  69.             System.out.println();  
  70.         }  
  71.     }  
  72.     public static void main(String[] args){  
  73.           
  74.         ZuHe robot = new ZuHe();  
  75.         int[] a = {1,2,2};  
  76.         robot.combine(a);  
  77.   
  78.     }  
  79.   
  80. }  
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);

	}

}


以上组合问题如果您有好的建议或者有其他的组合问题，请您留言，谢谢!


==================================================================================================

  作者：nash_  欢迎转载，与人分享是进步的源泉！

  转载请保留原文地址：http://blog.csdn.net/nash_/article/details/8315418

===================================================================================================

AC_XXZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法-把n个数的每一种排列情况都列出来(排列组合)-全排列-字典序算法（一看就懂）
qq_36523667的博客
11-14 3707
首先需要介绍字典序算法
Web系统大规模并发——电商秒杀与抢购
02-25
电商的秒杀和抢购，对我们来说，都不是一个陌生的东西。...我们现在一起来讨论下，优化的思路和方法哈。一个秒杀或者抢购页面，通常分为2个部分，一个是静态的HTML等内容，另一个就是参与秒杀的Web后台
回溯算法秒杀所有排列组合子集问题（摘自labuladong）
wd20180718的博客
04-10 50
剪枝逻辑，固定相同的元素在排列中的相对位置。# 剪枝逻辑，跳过值相同的相邻树枝。子集/组合（元素可重不可复选）# 组合/子集问题回溯算法框架。# 组合/子集问题回溯算法框架。子集/组合（元素无重可复选）# 回溯算法标准框架。# 回溯算法标准框架。# 回溯算法标准框架。
n个数字生成排列组合对象的算法（Johnson-Trotter）
YCCX_LHH21的博客
10-24 672
排列组合算法
输出n个数字的所有排列组合
gb5332360的专栏
03-23 2238
例如，，有数字1，2，3.，输出的组合共有15中，1,2,3,12,123,13，等等。。 [code="java"] public static void main(String[] args){ String[] aList=new String[]{"1","2","3"}; outAll(Arrays.aLi...
排列组合解析与例题总结
热门推荐
在下李逍遥的博客
07-27 2万+
排列数公式 公式P是排列公式，从N个元素取M个进行排列（即排序）。（P是旧用法，现在教材上多用A，即Arrangement）排列及计算公式 从n个不同元素中，任取m(m≤n)个元素按照一定的顺序排成一列，叫做从n个不同元素中取出m个元素的一个排列；从n个不同元素中取出m(m≤n)个元素的所有排列的个数，叫做从n个不同元素中取出m个元素的排列数，用符号 p(n,m)表示。 p(n,m)=n(n-1)
Java秒杀系统方案优化——高性能高并发实战
04-10
第3章秒杀功能开发及管理后台 第4章秒杀压测-Jmeter压力测试 第5章-页面级高并发秒杀优化(Redis缓存+静态化分离) 第6章-服务级高并发秒杀优化(RabbitMQ+接口优化) 第7章-图形验证码及恶意防刷 第8章-课程总结及重...
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记
12-27
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记
徐汉彬：Web系统大规模并发——电商秒杀与抢购
02-26
电商的秒杀和抢购，从技术的角度来说，会对Web系统产生巨大的考验。本期《问底》，徐汉彬将带大家关注秒杀和抢购的技术实现和优化，同时，从技术层面揭开，为什么我们总是不容易抢到火车票的原因。徐汉彬曾在阿里...
java毕业设计——基于B2C的网上拍卖、秒杀与竞价设计与实现(论文+源代码+答辩PPT+数据库).zip
05-29
java毕业设计——基于B2C的网上拍卖、秒杀与竞价设计与实现(论文+源代码+答辩PPT+数据库).zip java毕业设计——基于B2C的网上拍卖、秒杀与竞价设计与实现(论文+源代码+答辩PPT+数据库).zip java毕业设计——基于B2C...
7.行测秒杀技巧——资料分析.rar
09-15
7.行测秒杀技巧——资料分析.rar
黑米——抢手机神器
11-04
用于自动在京东、魅族官网、小米官网、华为商城、天猫等购物网站自动下单抢购手机的脚本软件。 使用说明：需更新至最新版，有收费内容！
微信小程序——仿小米有品.zip
最新发布
11-01
微信小程序——仿小米有品.zip
二卷杀手系列——秒杀任务型.doc
11-12
二卷杀手系列——秒杀任务型.doc
OC代码排列组合代码
07-20
秒杀排列组合（上）————排列篇 秒杀排列组合（下）————组合篇
去重排序（输入n个整数，排序后输出）
qq_46032918的博客
02-27 1896
排序时的去重处理
排列组合中的去重问题
我的心里只有代码
12-04 3434
排列组合是笔试面试中常见的题目类型，普通排列组合难度较简单，但如果包含去重问题时候，还是有些规律可循的 Leetcode47 全排列 II **题目描述** 给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用一次。 说明： 所有数字（包括目标数）都是...
C++ STL 全排列函数使用例子 - N个数的全排列
gongfuyd的博客
11-04 1206
C++ STL 全排列函数使用例子 - N个数的全排列 一、问题描述 n个数字的全排列数为n!个。比如1，2，3的全排列一共有3！= 6 种，分别是{1, 2, 3}、{1, 3, 2}、{2, 1, 3}、{2, 3, 1}、{3, 1, 2}、{3, 2, 1}。 二、C++ STL 中排列算法的说明 相关函数包含在#include 中。主要有两个：next_permutation，prev_...
【算法设计与分析】—— 排列组合问题（三种方法）
❀雾里看花花里看雾❀
05-15 1491
排列组合问题算法题目算法分析代码实现结果示例 算法题目 算法分析 第一种和第二种都是利用三重循环来控制，但是对于输入的任意m，我们就不能通过一个程序来控制所有的循环重数来实现，所以我们想到了递归。 第三种的话，可以简单认为是从任意的n个数中挑选m个数，m个数从小到大排列的话，最后一个的范围是从n到m，所以从这个地方开始逐步挑选，挑选完了之后就到了倒数第二个，其是从n-1个选出m-1个，在此基础上再倒数第三个，其是从n-2个选出m-2，依此类推，直到最后只剩下一个数，挑选完毕就开始回溯。
springboot秒杀
09-12
对于实现秒杀功能，Spring Boot 是一个很好的选择。下面是一个简单的步骤来实现基本的秒杀功能： 1. 创建数据库表：创建一个包含商品信息、库存数量和秒杀活动时间的数据库表。 2. 编写实体类：根据数据库表结构...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值