算法122345

java（122345）的一道面试题  

2010-06-10 17:12:49|  分类： 数据结构--基础知 |举报 |字号 订阅

看到网上有一个不过的算法：

 

 /**
  * @param eleStr -
  *            待分配字符组成的串
  * @param rstStr -
  *            已分配字符组成的串
  */
 public void depthSearch(String eleStr, String rstStr) {
  if (eleStr.length() == 0) {
   count++;
   System.out.println(rstStr);
   return;
  }
  for (int i = 0; i < eleStr.length(); i++) {
   String currEle = eleStr.substring(i, i + 1); // 取出当前位的值
   if (rstStr.length() == 2 && "4".equals(currEle))
    continue; // 剪掉第三位为4的分支
   if (rstStr.endsWith("3") && "5".equals(currEle))
    continue; // 剪掉"35"相连的分支
   if (rstStr.endsWith("5") && "3".equals(currEle))
    continue; // 剪掉"53"相连的分支
   if(eleStr.substring(0, i).indexOf(currEle) !=  -1)
    continue; // 剪掉同一位上字符重复的分支(此题即剪掉重复的2)
  
   depthSearch(eleStr.substring(0, i) + eleStr.substring(i + 1),
     rstStr + currEle); // 用剩余的合法串继续递归
  }
 }

其中要处以的地方就是：eleStr.substring(0, i).indexOf(currEle) !=  -1

这个是去除重复的。即在一次循环中，在同一个位置上，如果这个数字已经出现过，

那就continue。比如有输入的：2365837，现在循环到后面的3的位置了，显然对于同一层的for循环是在一个位置上（第一次调用for循环，则该次循环的数字全都是在第一个位置），这样在这个for循环中已经出现过了3（意思就是这个位置上已经考虑过3了），所以在同一层循环上如果再有3，这是就要退出。

import java.util.Set;
import java.util.TreeSet;

public class MyTest {

    public static Set<String> set = new TreeSet<String>();

    public static void perm(char[] n, int beg, int end) {
        if (beg == end) {
            addNumber(String.valueOf(n));
        } else {
            for (int i = beg; i <= end; ++i) {
                swap(n, beg, i);
                perm(n, beg + 1, end);
                swap(n, beg, i);
            }
        }
    }

    public static void swap(char[] n, int x, int y) {
        if (x == y || n[x] == n[y]) {
            return;
        }
        char temp = n[x];
        n[x] = n[y];
        n[y] = temp;
    }

    public static void addNumber(String str) {
        if (str.charAt(2) == '4' || str.contains("35") || str.contains("53")) {
            return;
        }
        set.add(str);
    }

    public static void main(String args[]) {
        char[] number = new char[] { '1', '2', '2', '3', '4', '5' };
        perm(number, 0, number.length - 1);
        System.out.println(set.size());
        int cols = 10;
        for (String s : set) {
            System.out.print(s + " ");
            if (cols-- == 1) {
                System.out.println();
                cols = 10;
            }
        }
    }

package com.sw.suanfa.first.ten;

import java.util.ArrayList;
import java.util.List;

/**
 * 用java语言实现，一个组数：122345这6个数，打印出它所有可能的组合；要求4不能在第3位，3和5不能相连。
 * 我的做法：首先，我确定用递归实现。
 *          其次，不排除任何条件，打出所有的组合。
 *          在递归中增加了preNum，和level参数，可方便的对条件【4不能在第3位，3和5不能相连】进行过滤。
 *          在递归正增加了intList，便于排除重复。比如122345这个串中有2个2.则按照以上的算法会出现重复的情况。
 *          这里用了一个intList主要是利用其方法indexOf,实际也可以通过数组循环的方式来查找，这里为了方便就用了list。
 *
 * @author songwei
 * @date 2010.3.24
 *
 */
public class ComposeArray {
    
    public static void main(String[] args) {
        int len = 6;
        int[] numArray = {1,2,2,3,4,5};
        int[] currentArray = new int[len];
        getNextNumber(0,1,numArray,currentArray);
        
    }
    
    /**
     *
     * @param preNum 前一个数值
     * @param level 当前层数
     * @param numArray 当前层中能够选择的数值集合
     * @param currentArray 正在操作的数组，当这个数组中的所有值均覆值后，则为条件允许情况下的一个数值集合。
     */
    private static void getNextNumber(int preNum,int level,int[] numArray,int[] currentArray){
        List<Integer> intList = new ArrayList<Integer>();
        for(int i=0;i<numArray.length;i++){
            int currentNum = numArray[i];
            if(intList.indexOf(Integer.valueOf(currentNum))>-1) continue ;
            intList.add(currentNum);            
            
            //4不能在第3位出现
            if(level == 3 && currentNum == 4) continue ;
            if(level != 1){
                //3和5不能相连
                if((currentNum ==5 && preNum == 3) || (currentNum ==3 && preNum == 5)){
                    continue ;
                }
            }
            currentArray[level-1] = currentNum ;
            int nextLevel = level +1 ;
            if(level == currentArray.length){
                OutArray(currentArray);
                return ;
            }else{
                getNextNumber(currentNum,nextLevel,createNewArray(numArray,i),currentArray);
            }
        }
    }
    
    /**
     * 创建一个新的数组，这个数组为该次排列中，下一个level可以出现的数值集合。
     * @param oldArray
     * @param orderNumber
     * @return
     */
    private static int[] createNewArray(int[] oldArray,int orderNumber){
        if(oldArray.length<=1) return null ;
        int newLen = oldArray.length-1 ;
        int[] newArray =new int[newLen];
        int newOrderNumber = 0 ;
        for(int i=0;i<oldArray.length;i++){
            if(i == orderNumber) continue ;
            newArray[newOrderNumber] = oldArray[i];
            newOrderNumber ++ ;
        }
        return newArray;
    }
    
    private static void OutArray(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]);
        }
        System.out.println("");
    }
}