求解组合数方法:
public class Combination {
public List<List<Integer>> combination(int[] a,int m){
dfs(-1,0,m,a);
return re;
}
List<List<Integer>> re=new ArrayList<List<Integer>>();
List<Integer> trace=new ArrayList<Integer>();
public void dfs(int k,int level,int m,int[] a){
if(level==m){
re.add(new ArrayList<Integer>(trace));
return;
}
for(int i=k+1;i<a.length;i++){
trace.add(a[i]);
dfs(i,level+1,m,a);
trace.remove(trace.size()-1);
}
}
public static void main(String[] args) {
Combination c=new Combination();
System.out.println(c.combination(new int[]{1,2,3,4},2));
}
}
组合数去重两种做法:
做法1:
public class Combination2 {
//去重
public List<List<Integer>> combination(int[] a,int m){
Arrays.sort(a);//组合数的去重一定要先排序
dfs(-1,0,m,a);
return re;
}
List<List<Integer>> re=new ArrayList<List<Integer>>();
List<Integer> trace=new ArrayList<Integer>();
public void dfs(int k,int level,int m,int[] a){
if(level==m){
re.add(new ArrayList<Integer>(trace));
return;
}
HashSet<Integer> set=new HashSet<Integer>();
for(int i=k+1;i<a.length;i++){
if(set.contains(a[i])) continue;
set.add(a[i]);
trace.add(a[i]);
dfs(i,level+1,m,a);
trace.remove(trace.size()-1);
}
}
public static void main(String[] args) {
Combination2 c=new Combination2();
System.out.println(c.combination(new int[]{1,2,1,4},2));
}
}
做法2:
public class Combination3 {
//去重
public List<List<Integer>> combination(int[] a,int m){
Arrays.sort(a);//组合数的去重一定要先排序
dfs(-1,0,m,a);
return re;
}
List<List<Integer>> re=new ArrayList<List<Integer>>();
List<Integer> trace=new ArrayList<Integer>();
public void dfs(int k,int level,int m,int[] a){
if(level==m){
re.add(new ArrayList<Integer>(trace));
return;
}
for(int i=k+1;i<a.length;i++){
if(i!=k+1&&a[i]==a[i-1]) continue;
trace.add(a[i]);
dfs(i,level+1,m,a);
trace.remove(trace.size()-1);
}
}
public static void main(String[] args) {
Combination3 c=new Combination3();
System.out.println(c.combination(new int[]{1,2,1,4},2));
}
}
求解排列数:
两种做法:
1 通过swap的方式
2 通过boolean flag[] 数组标记已取得 数组的方法
方法1:
public class Permutation {
public List<List<Integer>> permutatation(int[] a,int m){
if(a.length==0) return re;
dfs(0,a,m);
return re;
}
List<List<Integer>> re=new ArrayList<List<Integer>>();
public void dfs(int k,int[] a,int m){
if(k==m){
List<Integer> temp=new ArrayList<Integer>();
for(int i=0;i<m;i++) temp.add(a[i]);
re.add(temp);
return;
}
for(int i=k;i<a.length;i++){
swap(a,k,i);
dfs(k+1,a,m);
swap(a,k,i);
}
}
private 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) {
Permutation s=new Permutation();
System.out.println(s.permutatation(new int[]{1,2,3,4},2));
}
}
针对这种方法的去重:
public class Permutation2 {
public List<List<Integer>> permutatation(int[] a,int m){
if(a.length==0) return re;
dfs(0,a,m);
return re;
}
List<List<Integer>> re=new ArrayList<List<Integer>>();
public void dfs(int k,int[] a,int m){
if(k==m){
List<Integer> temp=new ArrayList<Integer>();
for(int i=0;i<m;i++) temp.add(a[i]);
re.add(temp);
return;
}
for(int i=k;i<a.length;i++){
if(!isSwap(k,i,a)) continue;
swap(a,k,i);
dfs(k+1,a,m);
swap(a,k,i);
}
}
public boolean isSwap(int start,int end,int[] a){
for(int i=start;i<end;i++){
if(a[i]==a[end]) return false;
}
return true;
}
private 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) {
Permutation2 s=new Permutation2();
System.out.println(s.permutatation(new int[]{1,1,1,4},2));
}
}
方法二:
public class Permutation3 {
public List<List<Integer>> permutatation(int[] a,int m){
if(a.length==0) return re;
flag=new boolean[a.length];
dfs(0,a,m);
return re;
}
List<List<Integer>> re=new ArrayList<List<Integer>>();
List<Integer> trace=new ArrayList<Integer>();
boolean[] flag;
public void dfs(int k,int[] a,int m){
if(k>m) return;
if(k==m){
re.add(new ArrayList<Integer>(trace));
return;
}
for(int i=0;i<a.length;i++){
if(flag[i]) continue;
trace.add(a[i]);
flag[i]=true;
dfs(k+1,a,m);
flag[i]=false;
trace.remove(trace.size()-1);
}
}
public static void main(String[] args) {
Permutation3 s=new Permutation3();
System.out.println(s.permutatation(new int[]{1,2,3,4},2));
}
}
方法二的去重:
去重1:
public class Permutation4 {
//去重
public List<List<Integer>> permutatation(int[] a,int m){
if(a.length==0) return re;
flag=new boolean[a.length];
dfs(0,a,m);
return re;
}
List<List<Integer>> re=new ArrayList<List<Integer>>();
List<Integer> trace=new ArrayList<Integer>();
boolean[] flag;
public void dfs(int k,int[] a,int m){
if(k>m) return;
if(k==m){
re.add(new ArrayList<Integer>(trace));
return;
}
HashSet<Integer> set=new HashSet<Integer>();
for(int i=0;i<a.length;i++){
if(flag[i]) continue;
if(set.contains(a[i])) continue;
set.add(a[i]);
trace.add(a[i]);
flag[i]=true;
dfs(k+1,a,m);
flag[i]=false;
trace.remove(trace.size()-1);
}
}
public static void main(String[] args) {
Permutation4 s=new Permutation4();
System.out.println(s.permutatation(new int[]{1,2,1,4},2));
}
}
去重2:
public class Permutation5 {
//去重
public List<List<Integer>> permutatation(int[] a,int m){
if(a.length==0) return re;
Arrays.sort(a);
flag=new boolean[a.length];
dfs(0,a,m);
return re;
}
List<List<Integer>> re=new ArrayList<List<Integer>>();
List<Integer> trace=new ArrayList<Integer>();
boolean[] flag;
public void dfs(int k,int[] a,int m){
if(k>m) return;
if(k==m){
re.add(new ArrayList<Integer>(trace));
return;
}
for(int i=0;i<a.length;i++){
if(flag[i]) continue;
if(i!=0&&!flag[i-1]&&a[i]==a[i-1]) continue;
trace.add(a[i]);
flag[i]=true;
dfs(k+1,a,m);
flag[i]=false;
trace.remove(trace.size()-1);
}
}
public static void main(String[] args) {
Permutation5 s=new Permutation5();
System.out.println(s.permutatation(new int[]{1,2,1,4},2));
}
}