求一算法题解

Question

请将1,2,2,3,4,5这六个数字,用java语言写一个main函数,能实现打印出所有不同的排列(如:413225,212345)
要求:4不能出现在第三个位置,3和5不能相连,要求代码规范,注释清晰

Answer 1

public class Pailie {    public Pailie() {
    }
    
    public static void main(String []args){
     int []a={1,2,2,3,4,5};
     int temp;
     boolean x;
     for(int i=0;i<6;i++)
     {
     for(int j=i+1;j<6;j++){
     temp=a[i];a[i]=a[j];a[j]=temp;
     if(a[2]==4) {continue;}
     x=false;
     for(int k=0;k+1<6;k++){
     if(a[k]==3&&a[k+1]==5){
     x=true;
     break;
     }
     }
     if(x==true) continue;
     for(int m=0;m<6;m++) {System.out.print(a[m]+" ");}
     System.out.println();
     temp=a[i];a[i]=a[j];a[j]=temp;
     }
     }
    }
}

Answer 2

    private static void sort(List<String> datas, List<String> target,List<String> temp) {  
        if (temp.size() == 6) { 
            String ss = "";
            for (String s : temp)  
                ss += s;  
            if ((!ss.matches(".*35.*"))&&ss.indexOf("4") != 2)
            target.add(ss); 
            return;  
        }  
        for (int i = 0; i < datas.size(); i++) {  
            List<String> newDatas = new ArrayList<String>(datas);  
            List<String> newTemp = new ArrayList<String>(temp);  
            newTemp.add(newDatas.get(i));  
            newDatas.remove(i);  
            sort(newDatas, target, newTemp);  
        }  
    }  
  
    public static void main(String[] args) {  
        String[] datas = new String[] { "1", "2", "2", "3", "4", "5"};  
        List<String> target = new ArrayList<String>();
        List<String> temp = new ArrayList<String>();
        sort(Arrays.asList(datas), target, temp);  
        for (String s : target)  
            System.out.println(s);  
    }
    

Answer 3

import java.util.Set;
import java.util.TreeSet;
public class Combination {
public static void main(String[] args) {
int[] num = {1,2,3,4,5,6};
long n;
Set<Long> result = new TreeSet<Long>();
Set<Long> result2 = new TreeSet<Long>();

//构造出一个数列，由1，2,3,4,5,6六个数字构成的排列
for(int a=0; a<num.length; a++) {
for(int b=0; b<num.length; b++) {
if(b == a) 
continue;
for(int c=0; c<num.length; c++) {
if(c == a || c == b || c == 3)
continue;
for(int d=0; d<num.length; d++) {
if(d == a || d == b || d == c) 
continue;
for(int e=0; e<num.length; e++) {
if(e == a || e == b || e == c || e == d)
continue;
for(int f=0; f<num.length; f++) {
if(f == a || f == b || f == c || f == d || f == e)
continue;
n = num[a] * 100000 + num[b] * 10000 + 
num[c] * 1000 + num[d] * 100 + num[e] * 10 +
num[f];
result.add(n);
}
}
}
}
}
}

//把6换为2,并且3和5没有连的输出
String temp;
for(Long l : result) {
temp = l + "";
temp = temp.replace("6", "2");
if(temp.indexOf("35") == -1 && temp.indexOf("53") == -1)
result2.add(Long.parseLong(temp));
}

//每行打印10个数，先打印行号，然后打印10个数
int count = 0;
System.out.println("count:" + result2.size());
System.out.print("1:");
for(Long l : result2) {
System.out.print(l + " ");
count ++;
if(count % 10 == 0) {
System.out.println();
System.out.print(count / 10 + 1 + ":");
}
}
}
}

Answer 4

public static void main(String[] args) {
    int count = 0;
    int[] nums = { 1, 2, 2, 3, 4, 5 };
    int[] appear = { 0, 0, 0, 0, 0, 0 };
    int[] arr = new int[6];    int index = 0, val = 0;
    while (true) {
        if (index == 6) {
            count++;
            System.out.println(toString(nums, arr));
            index--;
            val = arr[index];
            appear[val] = 0;
            val++;
            continue;
        }
        if (val >= 6) {
            index--;
            if (index < 0)
                break;
            val = arr[index];
            appear[val] = 0;
            val++;
            continue;
        }
        if (appear[val] > 0) {
            val++;
            continue;
        }
        if (val == 2 && appear[1] == 0) {
            val++;
            continue;
        }
        if (nums[val] == 4 && index == 2) {
            val++;
            continue;
        }
        if (index > 0 && nums[val] == 3 && nums[arr[index - 1]] == 5) {
            val++;
            continue;
        }
        if (index > 0 && nums[val] == 5 && nums[arr[index - 1]] == 3) {
            val++;
            continue;
        }
        arr[index] = val;
        appear[val] = 1;
        val = 0;
        index++;
    }
    System.out.printf("count: %d\n", count);
}public static String toString(int[] nums, int[] arr) {
    if (arr == null)
        return null;
    StringBuilder sb = new StringBuilder();
    for (int i : arr)
        sb.append(nums[i]);
    return sb.toString();
}

Answer 5

额，那个appear改为boolean数组应该更好……

Answer 6

下边这个是用回溯做的
思路是先把 1345 全排列好
再把 两个 2 往里插， 在插入的过程中把 4为第 3 位，3,5 相邻剔除package com.keeya.answer.test;public class CombinationTest { public static void main(String[] args) {
// 本题的思路是先用 1,3,4,5 进行全排列
// 后边再将另外两个 2 往里插入，并判断是否符合要求
int[] arr = { 1, 3, 4, 5 };
printCom(arr, 0);
} public static void printCom(int[] arr, int index) {
if (index == arr.length - 1) {
insertTwo(arr, 0);
return;
}
printCom(arr, index + 1);
for (int i = index + 1; i < arr.length; i++) {
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
printCom(arr, index + 1);
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
}
} // 将 2 在符合要求的情况下插入数组
private static void insertTwo(int[] arr, int index) {
if (index == arr.length + 1)
return;
for (int i = index + 1; i < arr.length + 2; i++) {
int[] tar = new int[arr.length + 2];
tar[i] = 2;
tar[index] = 2;
innerInsert(arr, tar);
}
insertTwo(arr, index + 1);
} private static void innerInsert(int[] arr, int[] tar) {
int index = 0;
int indexArr = 0;
while (index < tar.length) {
if (tar[index] == 0) {
if (index > 0 && tar[index - 1] + arr[indexArr] == 8
|| (index == 2 && arr[indexArr] == 4))
return;
tar[index] = arr[indexArr++];
}
index++;
}
for (int i = 0; i < tar.length; i++) {
System.out.print(tar[i] + " ");
}
System.out.println();
}
}

Answer 7

这个题目结果有 198 种package com.keeya.answer.test;public class CombinationTest { private static int count = 0;
private static int newRow = 0;
public static void main(String[] args) {
// 本题的思路是先用 1,3,4,5 进行全排列
// 后边再将另外两个 2 往里插入，并判断是否符合要求
int[] arr = { 1, 3, 4, 5 };
printCom(arr, 0);
System.out.printf("符合要求的排列共有 %d 种", count);
} public static void printCom(int[] arr, int index) {
if (index == arr.length - 1) {
insertTwo(arr, 0);
return;
}
printCom(arr, index + 1);
for (int i = index + 1; i < arr.length; i++) {
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
printCom(arr, index + 1);
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
}
} // 将 2 在符合要求的情况下插入数组
private static void insertTwo(int[] arr, int index) {
if (index == arr.length + 1)
return;
for (int i = index + 1; i < arr.length + 2; i++) {
int[] tar = new int[arr.length + 2];
tar[i] = 2;
tar[index] = 2;
innerInsert(arr, tar);
}
insertTwo(arr, index + 1);
} private static void innerInsert(int[] arr, int[] tar) {
int index = 0;
int indexArr = 0;
while (index < tar.length) {
if (tar[index] == 0) {
if (index > 0 && tar[index - 1] + arr[indexArr] == 8
|| (index == 2 && arr[indexArr] == 4))
return;
tar[index] = arr[indexArr++];
}
index++;
}
count++;
System.out.printf("[%d]", count);
for (int i = 0; i < tar.length; i++) {
System.out.print(tar[i] + " ");
}
if(count % 5 == 0){
System.out.println();
}
}
}
测试结果
[1]2 2 1 3 4 5 [2]2 1 2 3 4 5 [3]2 1 3 2 4 5 [4]2 1 3 4 2 5 [5]2 1 3 4 5 2 
[6]1 2 2 3 4 5 [7]1 2 3 2 4 5 [8]1 2 3 4 2 5 [9]1 2 3 4 5 2 [10]1 3 2 2 4 5 
[11]1 3 2 4 2 5 [12]1 3 2 4 5 2 [13]2 1 3 2 5 4 [14]1 2 3 2 5 4 [15]1 3 2 2 5 4 
[16]1 3 2 5 2 4 [17]1 3 2 5 4 2 [18]1 4 2 3 2 5 [19]1 4 3 2 2 5 [20]1 4 3 2 5 2 
[21]1 4 2 5 2 3 [22]1 4 5 2 2 3 [23]1 4 5 2 3 2 [24]2 2 1 5 4 3 [25]2 1 2 5 4 3 
[26]2 1 5 2 4 3 [27]2 1 5 4 2 3 [28]2 1 5 4 3 2 [29]1 2 2 5 4 3 [30]1 2 5 2 4 3 
[31]1 2 5 4 2 3 [32]1 2 5 4 3 2 [33]1 5 2 2 4 3 [34]1 5 2 4 2 3 [35]1 5 2 4 3 2 
[36]2 1 5 2 3 4 [37]1 2 5 2 3 4 [38]1 5 2 2 3 4 [39]1 5 2 3 2 4 [40]1 5 2 3 4 2 
[41]2 2 3 1 4 5 [42]2 3 2 1 4 5 [43]2 3 1 2 4 5 [44]2 3 1 4 2 5 [45]2 3 1 4 5 2 
[46]3 2 2 1 4 5 [47]3 2 1 2 4 5 [48]3 2 1 4 2 5 [49]3 2 1 4 5 2 [50]3 1 2 2 4 5 
[51]3 1 2 4 2 5 [52]3 1 2 4 5 2 [53]2 2 3 1 5 4 [54]2 3 2 1 5 4 [55]2 3 1 2 5 4 
[56]2 3 1 5 2 4 [57]2 3 1 5 4 2 [58]3 2 2 1 5 4 [59]3 2 1 2 5 4 [60]3 2 1 5 2 4 
[61]3 2 1 5 4 2 [62]3 1 2 2 5 4 [63]3 1 2 5 2 4 [64]3 1 2 5 4 2 [65]3 1 5 2 2 4 
[66]3 1 5 2 4 2 [67]3 1 5 4 2 2 [68]2 2 3 4 1 5 [69]2 3 2 4 1 5 [70]3 2 2 4 1 5 
[71]3 4 2 2 1 5 [72]3 4 2 1 2 5 [73]3 4 2 1 5 2 [74]3 4 1 2 2 5 [75]3 4 1 2 5 2 
[76]3 4 1 5 2 2 [77]2 2 3 4 5 1 [78]2 3 2 4 5 1 [79]3 2 2 4 5 1 [80]3 4 2 2 5 1 
[81]3 4 2 5 2 1 [82]3 4 2 5 1 2 [83]3 4 5 2 2 1 [84]3 4 5 2 1 2 [85]3 4 5 1 2 2 
[86]2 3 2 5 4 1 [87]3 2 2 5 4 1 [88]3 2 5 2 4 1 [89]3 2 5 4 2 1 [90]3 2 5 4 1 2 
[91]2 3 2 5 1 4 [92]3 2 2 5 1 4 [93]3 2 5 2 1 4 [94]3 2 5 1 2 4 [95]3 2 5 1 4 2 
[96]2 4 2 3 1 5 [97]2 4 3 2 1 5 [98]2 4 3 1 2 5 [99]2 4 3 1 5 2 [100]4 2 2 3 1 5 
[101]4 2 3 2 1 5 [102]4 2 3 1 2 5 [103]4 2 3 1 5 2 [104]4 3 2 2 1 5 [105]4 3 2 1 2 5 
[106]4 3 2 1 5 2 [107]4 3 1 2 2 5 [108]4 3 1 2 5 2 [109]4 3 1 5 2 2 [110]2 4 3 2 5 1 
[111]4 2 3 2 5 1 [112]4 3 2 2 5 1 [113]4 3 2 5 2 1 [114]4 3 2 5 1 2 [115]2 4 1 3 2 5 
[116]4 2 1 3 2 5 [117]4 1 2 3 2 5 [118]4 1 3 2 2 5 [119]4 1 3 2 5 2 [120]2 4 1 5 2 3 
[121]4 2 1 5 2 3 [122]4 1 2 5 2 3 [123]4 1 5 2 2 3 [124]4 1 5 2 3 2 [125]2 4 2 5 1 3 
[126]2 4 5 2 1 3 [127]2 4 5 1 2 3 [128]2 4 5 1 3 2 [129]4 2 2 5 1 3 [130]4 2 5 2 1 3 
[131]4 2 5 1 2 3 [132]4 2 5 1 3 2 [133]4 5 2 2 1 3 [134]4 5 2 1 2 3 [135]4 5 2 1 3 2 
[136]4 5 1 2 2 3 [137]4 5 1 2 3 2 [138]4 5 1 3 2 2 [139]2 4 5 2 3 1 [140]4 2 5 2 3 1 
[141]4 5 2 2 3 1 [142]4 5 2 3 2 1 [143]4 5 2 3 1 2 [144]2 5 2 3 4 1 [145]5 2 2 3 4 1 
[146]5 2 3 2 4 1 [147]5 2 3 4 2 1 [148]5 2 3 4 1 2 [149]2 5 2 3 1 4 [150]5 2 2 3 1 4 
[151]5 2 3 2 1 4 [152]5 2 3 1 2 4 [153]5 2 3 1 4 2 [154]2 2 5 4 3 1 [155]2 5 2 4 3 1 
[156]5 2 2 4 3 1 [157]5 4 2 2 3 1 [158]5 4 2 3 2 1 [159]5 4 2 3 1 2 [160]5 4 3 2 2 1 
[161]5 4 3 2 1 2 [162]5 4 3 1 2 2 [163]2 2 5 4 1 3 [164]2 5 2 4 1 3 [165]5 2 2 4 1 3 
[166]5 4 2 2 1 3 [167]5 4 2 1 2 3 [168]5 4 2 1 3 2 [169]5 4 1 2 2 3 [170]5 4 1 2 3 2 
[171]5 4 1 3 2 2 [172]2 2 5 1 4 3 [173]2 5 2 1 4 3 [174]2 5 1 2 4 3 [175]2 5 1 4 2 3 
[176]2 5 1 4 3 2 [177]5 2 2 1 4 3 [178]5 2 1 2 4 3 [179]5 2 1 4 2 3 [180]5 2 1 4 3 2 
[181]5 1 2 2 4 3 [182]5 1 2 4 2 3 [183]5 1 2 4 3 2 [184]2 2 5 1 3 4 [185]2 5 2 1 3 4 
[186]2 5 1 2 3 4 [187]2 5 1 3 2 4 [188]2 5 1 3 4 2 [189]5 2 2 1 3 4 [190]5 2 1 2 3 4 
[191]5 2 1 3 2 4 [192]5 2 1 3 4 2 [193]5 1 2 2 3 4 [194]5 1 2 3 2 4 [195]5 1 2 3 4 2 
[196]5 1 3 2 2 4 [197]5 1 3 2 4 2 [198]5 1 3 4 2 2 符合要求的排列共有 198 种

Answer 8

keeya0416递归和非递归的方法不错额

Answer 9

if (val == 2 && appear[1] == 0) {
    val++;
    continue;
}
就是这个，appear数组表示对应的数字是否已经出现了
val==2表示当前判断到的是第2个数(也就是后一个2)，appear[1]==0表示第1个数(也就是前一个2)没有出现，于是就跳了

Answer 10

我的逻辑是这样的
不过我只得到了一个结果。因为随机数产生不同的和要符合条件的情况
机率很小，看运气
多重运行几次会得到结果/** 请将1,2,2,3,4,5这六个数字
 * 能实现打印出所有不同的排列(如:413225,212345)
要求:4不能出现在第三个位置,3和5不能相连*/
public class Test {
public static void main(String[] args) {
f();
}

private static void f(){
/*初步设想 随机取出数字拼接成字符串
 * 对字符串进行判断*/
String s = "122345";
StringBuilder  builder = new StringBuilder();
Set set = new LinkedHashSet();

Set resultSet = new HashSet();
int resultCount = -1;
while(true){
int random = (int)(Math.random()*6);//产生0~5随机数
//System.out.println(random);
//不能用HashSet
//因为HashSet底层是用HashMap实现有自己默认的排序算法
//应用插入有序的LinkedHashSet

set.add(random);
if(set.size() == 6){
Iterator it = set.iterator();
while(it.hasNext()){
char tempChar = s.charAt((Integer)it.next());
builder.append(tempChar);
}

String result = new String(builder);
//System.out.println(result);
//&& !result.matches(".*35.*")
//&& !result.matches(".*53.*")
if(result.matches("..[^4]...") 
&& !result.matches(".*35.*")
&& !result.matches(".*53.*")){
System.out.println(result);
resultSet.add(result);
//1 > -1
int x = resultSet.size();
System.out.println(x);
if ( x> resultCount){
resultCount++;//0
//当长度等于resultCount时
//也就是说resultSet的长度不再变化了,从而找出所有的情况
if(resultCount == x)
return;
}

}
}
}
}
}

Answer 11

4在第三位置有P5/5=120种排法，
3,5在一起有p5/5=120种排法
总排列为p6/6=720种排法
符合要求的应该为720-2*120=480种，
怎么为198呢？

Answer 12

1、有重复数字2，那么全排列本身就应该6P6/2P2=360种
2、你的3和5相连个数是对的但算法上有遗漏……应该是5P5/2P2*2P2，前一个2P2和上面一样是排除重复的2，后一个是3与5互换
3、可能出现同时满足4在第三位和3与5相连的情况

Answer 13

 198种吧..程序比较乱 代码就不发了 也是递归出所有组合 开始用的set 直接去重复 然后再过滤 不过现在一次过滤过不干净  - - 要过滤个3遍才出来198  

Answer 14

public class Pailie {    public Pailie() {
    }
    
    public static void main(String []args){
        int []a={1,2,2,3,4,5};
        int temp;
        boolean x;
        for(int i=0;i<6;i++)
        {
            for(int j=i+1;j<6;j++){
                temp=a[i];a[i]=a[j];a[j]=temp;
                if(a[2]==4) {continue;}
                x=false;
                for(int k=0;k+1<6;k++){
                    if(a[k]==3&&a[k+1]==5){
                        x=true;
                        break;
                    }
                }
                if(x==true) continue;
                for(int m=0;m<6;m++) {System.out.print(a[m]+" ");}
                System.out.println();
                temp=a[i];a[i]=a[j];a[j]=temp;
            }
        }
    }
}

Answer 15

package com;
public class PaiLie {  public static void main(String[] args) {
   String s = "122345";// 这里是要用到的所有数组成的一个字符串,其它字符同样适用
   char[] c = s.toCharArray();
   new PaiLie().zuhe(c, c.length, 0);
   System.out.println("可能的组合数：" + kk);
} static int kk = 0; private void zuhe(char[] array, int n, int k) {
   if (n == k) {
    if (array[2] != '4') {// 第三个位置不能出现4
     String str = new String(array);
     if (str.indexOf("53") < 0 && str.indexOf("35") < 0) {// 3，5不能连续出现
      System.out.println(str);
      ++kk;
     }
    }
   } else {
    for (int i = k; i < n; i++) {
     swap(array, k, i);
     zuhe(array, n, k + 1);
     swap(array, i, k);
    }
   }
} private void swap(char[] a, int x, int y) {
   char temp = a[x];
   a[x] = a[y];
   a[y] = temp;
}
}

Answer 16

package com;import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class PaiLie {
        private static Set set=new HashSet();
 public static void main(String[] args) {
   String s = "122345";// 这里是要用到的所有数组成的一个字符串,其它字符同样适用
   char[] c = s.toCharArray();
   new PaiLie().zuhe(c, c.length, 0);
  Iterator it=   set.iterator();
  while(it.hasNext()){
  String str=(String)it.next();
  System.out.println(str);
  }
   System.out.println("可能的组合数：" +set.size());
}
private void zuhe(char[] array, int n, int k) {
   if (n == k) {
    if (array[2] != '4') {// 第三个位置不能出现4
     String str = new String(array);
     if (str.indexOf("53") < 0 && str.indexOf("35") < 0) {// 3，5不能连续出现
      set.add(str);
     }
    }
   } else {
    for (int i = k; i < n; i++) {
     swap(array, k, i);
     zuhe(array, n, k + 1);
     swap(array, i, k);
    }
   }
} private void swap(char[] a, int x, int y) {
   char temp = a[x];
   a[x] = a[y];
   a[y] = temp;
}
}修改了一下，用set去掉了重复的

Answer 17

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class Num123456 {
/**
 * 获取不包含重复元素的数组的所有排列组合。共有 (arr.length)! 种排列。
 * @param arr
 * @return
 */
public static List<String[]> getAllSort(String[] arr){
List list = new ArrayList();
if(arr.length == 1){
list.add(arr);
}else{
//递归
for(int i=0;i<arr.length;i++){
List arrList = new ArrayList(Arrays.asList(arr));
arrList.remove(i);
String[] subArr = (String[])arrList.toArray(new String[arrList.size()]);
List<String[]> subList = getAllSort(subArr);
for(int j = 0;j<subList.size();j++){
String[] dest = new String[arr.length];
dest[0] = arr[i];
System.arraycopy(subList.get(j), 0, dest, 1, subList.get(j).length);
list.add(dest); 
}
}
}
return list;
}
/**
 * 将{"1","3","5"} 这样的数组转换成数字 135
 * @param arr
 * @return
 */
public static int arrToNum(String[] arr){
int num = 0;
for(int i=0;i<arr.length;i++){
num += Math.pow(10, arr.length-1-i) * Integer.valueOf(arr[i]);
}
return num;
}
public static void main(String[] args){
List<String[]> l = getAllSort(new String[]{"1","2","3","4","5","2"});
Iterator it = l.iterator();
while(it.hasNext()){
String[] arr = (String[])it.next();
//过滤第三位是4的。
if(arr[2].equals("4")){
it.remove();
continue;
}
//过滤3和5相邻的。
for(int i=0;i<arr.length-1;i++){
if(Integer.valueOf(arr[i])*Integer.valueOf(arr[i+1]) == 15){
it.remove();
continue;
}
}
}
//过滤重复的。
Set<Integer> set = new HashSet();
for(String[] arr:l){
set.add(arrToNum(arr));
}
//打印结果。
int count = 0;
for(Integer i:set){
System.out.print(i);
System.out.print(",");
count++;
if(count % 10 ==0 ){
System.out.println(count);
}
}
System.out.println("total count ="+count);
}
}198....

Answer 18

我是三楼的，由于初学java，水平很菜，所以写了两天才终于得出正确结果。
我用的方法主要是递归，涉及的也是最初级的语法，代码写的不好，恳请LZ和各路高人批评指正public class Pailie {
    
    boolean check(PL []a,int []r,int i,int []seqCtr){
     for(int p=0;p<i;p++){
     if(r[p]==r[i]) {
     return true;
     }
     if(a[r[p]].x==a[r[i]].x){
     if(a[r[p]].ctr!=a[r[i]].ctr) {
     System.out.println("出错："+"a[r["+p+"]].ctr!=a[r["+i+"]].ctr");
     }
     else{
     if(a[r[p]].ctr==1){
     return true;
     }
     else if(a[r[p]].ctr==0){
     System.out.println("出错：a[r[p]].ctr=0");
     }
     else{
     if(seqCtr[0]>a[r[i]].ctr){
     System.out.println("出错：seqCtr[0]>ctr");
     }
     else if(seqCtr[0]<a[r[i]].ctr){
     seqCtr[0]++;
     a[r[i]].time=seqCtr[0];
     if(a[r[i]].time>a[r[i]].ctr){
     System.out.println("出错!!!!!!!!!!!");
     }
     }
     else if(seqCtr[0]==a[r[i]].ctr){
     return true;
     }
     }
     }
     }
     }
     return false;
    }
    
    void digui(PL []a,int []r,int i,int size,int [][]result,int dimension,boolean repeat,int []resultCtr,int []seqCtr){
     if(i>=size||i<0||repeat==true){
     System.out.println("无法递归");
     }
     else if(i==size-1){
     for(r[i]=0;r[i]<size;r[i]++){
     if(this.check(a,r,i,seqCtr)==true) {
     continue;
     }
     int equalsCtr=0;
     for(int j=0;j<dimension;j++){
     for(int k=0;k<size;k++){
     if(result[j][k]==a[r[k]].x){
     equalsCtr++;
     }
     }
     if(equalsCtr==size){
     equalsCtr=0;
     repeat =true;
     break;
     }
     equalsCtr=0;
     }
     a[1].time=0;a[2].time=0;seqCtr[0]=0;
    
     if(a[r[2]].x==4){
     repeat =true;
     }
     for(int k=0;k<size-1;k++){
     if(a[r[k]].x==3&&a[r[k+1]].x==5)
     {
     repeat =true;break;
     }
     if(a[r[k]].x==5&&a[r[k+1]].x==3)
     {
     repeat =true;break;
     }
     }
  if(repeat==true){
  repeat=false;
  continue;
  }
     for(int l=0;l<size;l++){
     result[resultCtr[0]][l]=a[r[l]].x;
     }
     resultCtr[0]++;
     if(resultCtr[0]>=dimension)
     System.out.println("数组越界");
     }
     }
     else if(i>0&&i<size-1){
     for(r[i]=0;r[i]<size;r[i]++){
    
     if(this.check(a,r,i,seqCtr)==true) {continue;}
    
     digui(a,r,i+1,size,result,dimension,repeat,resultCtr,seqCtr);
     }
     }
     else if(i==0){
     for(r[i]=0;r[i]<size;r[i]++){
     /*if(a[r[i]].ctr>0&&seqCtr[0]==0){
     seqCtr[0]++;
     a[r[i]].time=seqCtr[0];
     }*/
     //if(a[r[0]].x==3)  System.out.println("~~~~~~~~~~~");
     digui(a,r,i+1,size,result,dimension,repeat,resultCtr,seqCtr);
     }
     }
    }
    
    public static void main(String []args){
     int []b={1,2,2,3,4,5};
     int []seqCtr={0};//计数器，在生成序列过程中记录已经生成2的次数
     int size=b.length;
     PL []a=new PL[size];
     for(int i=0;i<size;i++){
     if(i==1||i==2){
     a[i]=new PL(b[i],2);
     }
     else
     a[i]=new PL(b[i],1);
     }
     int []r=new int[size];
     int dimension=10000;
     int [][]result=new int[dimension][size];
     int []resultCtr={0};
     for(int i=0;i<dimension;i++)
     for(int j=0;j<size;j++){
     result[i][j]=0;
     }
     boolean repeat=false;
     for(int i=0;i<size;i++){
     System.out.println(a[i].x+" "+a[i].ctr+" "+a[i].time);
     }
     System.out.println("************************************");
     Pailie pail=new Pailie();
     pail.digui(a,r,0,size,result,dimension,repeat,resultCtr,seqCtr);
     for(int i=0;i<resultCtr[0];i++)
     {
     for(int j=0;j<size;j++){
     }
     }
     System.out.println(resultCtr[0]);
     for(int i=0;i<resultCtr[0];i++)
     {
     for(int j=0;j<size;j++){
     System.out.print(result[i][j]+" ");
     }
     System.out.println("");
     }
    }
}class PL{
int x;//元素
int ctr;//重复次数
int time;//出现顺序
PL(int x,int ctr){
this.x=x;
this.ctr=ctr;
time=0;
}
}

Answer 19

四楼的代码很有创意，顶一个，那个return虽然写不写都可以,但是我感觉写了很别扭，还有就是只考虑了35没有考虑53，更改如下：import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class TextAlgorithm {
private static void sort(List<String> datas, List<String> target,
List<String> temp) {
if (temp.size() == 6) {
String ss = "";
for (String s : temp)
ss += s;
if ((!ss.matches(".*35.*")) &&(!ss.matches(".*53.*")) && ss.indexOf("4") != 2)
target.add(ss);
//return;
}
for (int i = 0; i < datas.size(); i++) {
List<String> newDatas = new ArrayList<String>(datas);
List<String> newTemp = new ArrayList<String>(temp);
newTemp.add(newDatas.get(i));
newDatas.remove(i);
sort(newDatas, target, newTemp);
}
} public static void main(String[] args) {
String[] datas = new String[] { "1", "2", "2", "3", "4", "5" };
List<String> target = new ArrayList<String>();
List<String> temp = new ArrayList<String>();
sort(Arrays.asList(datas), target, temp);
for (String s : target)
System.out.println(s);
}}

Answer 20

而且4楼的还有重复的值，是由于有俩个2造成的，正确的代码是：import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;public class TextAlgorithm {
private static void sort(List<String> datas, HashSet<String> target,
List<String> temp) {
if (temp.size() == 6) {
String ss = "";
for (String s : temp)
ss += s;
if ((!ss.matches(".*35.*")) &&(!ss.matches(".*53.*")) && ss.indexOf("4") != 2)
target.add(ss);
//return;
}
for (int i = 0; i < datas.size(); i++) {
List<String> newDatas = new ArrayList<String>(datas);
List<String> newTemp = new ArrayList<String>(temp);
newTemp.add(newDatas.get(i));
newDatas.remove(i);
sort(newDatas, target, newTemp);
}
} public static void main(String[] args) {
String[] datas = new String[] { "1", "2", "2", "3", "4", "5" };
HashSet<String> target = new HashSet<String>();
List<String> temp = new ArrayList<String>();
sort(Arrays.asList(datas), target, temp);
int i=0;
for (String s : target) {
System.out.println(s);
i++;
}
System.out.println(i);
}}

Answer 21

package test;import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;public class PrintNumber {
public static void printNum(List<String> list, String num, Set<String> set) {
if (list.size() == 0) {
if (!num.contains("35")&&!num.contains("53")&&num.indexOf("4") != 2) {
set.add(num);
}
}

for(int i =0; i < list.size(); i ++) {
String sub = list.get(i);
list.remove(i);//去除传给下一层
printNum(list, num + sub, set);
list.add(i, sub);//还原
}

}

public static void main(String[] args) {
String[] nums = {"1","2","2","3","4", "5"};
Set<String> set = new HashSet<String>();
List<String> list = new ArrayList<String>();
for (int i = 0; i < nums.length; i++) {
list.add(nums[i]);
}

printNum(list,"", set);

System.out.println("total: " + set.size());
for (String string : set) {
System.out.println(string);
}
}

}我的实现很简单，用的是全排列的递归结构。运行结果是198。用set排重。

Answer 22

因为我用的是Set，就过滤掉了重复的值！