回溯法（1）

回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

1.组合问题

从n个数（1,2…n）中选出r个数的组合（不重复).

组合数是不考虑顺序的，不妨设：
a[r]>a[r-1]>…a[1],
从这里可以看出a[r]>r-1。

算法:
1)取初始状态a[0]=n,i=0.
2)当a[0]>r-1时，重复操作:
如果a[i]>r-i-1:
1.i=r,a[i]=a[i]-1.
2.i!=r,i=i+1,a[i]=a[i-1]-1.
如果a[i]<=r-i-1:
i=i-1,a[i]=a[i]-1.（这一步是回溯）
3)结束.

public class Combination {

    public static void main(String args[]){
        int n=10,r=5;
        int i=0,a[]=new int[r];
        a[0]=n;
        while(a[0]>r-1){
            if(a[i]>r-i-1){
                if(r==i+1){
                    output(a);
                    a[i]--;
                }
                else{
                    a[i+1]=a[i]-1;
                    i++;
                }
            }
            else{
                i--;
                a[i]--;
            }
        }
    }
    private static void output(int[] a) {
        // TODO Auto-generated method stub
        for(int j=0;j<a.length;j++){
            System.out.print(a[j]+"");
        }
        System.out.println();
    }
}

2.数的划分

整数n分成k份，每份不能为空，任意两份不能相同（不考虑顺序）。
例如：n=7，k=3，下面三种分法认为是相同的。
1,1,5 1,5,1, 5,1,1
问有多少种不同的分法。

由于不考虑顺序，不妨让分法有递增顺序(即采取1,1,5的表示方法)。

算法:
1)初始状态a[0]=1,i=0,sum=n-1,nk=n/k,t=0
(数组a[k]代表不同分法表示的k个数,t是用来计数有多少种不同分法的，a[0]的值是不能超过nk的,sum表示还剩下多少可以划分，比如n=7,a[0]=1,a[1]=1,这个时候sum=5,因为还有5可以划分)
2)当a[0]<=nk时，重复操作:
如果i=k,则t=t+1,a[i]=sum+a[i],输出数组a,i=i-1,a[i]+1,sum=a[i+1]-1。(回溯)
如果i< k:
1.如果sum>=a[i]:i=i+1,a[i]=a[i-1]
2.如果sum< a[i]:i=i-1,a[i]=a[i]+1 (回溯)
3)输出t，结束。

public class NumberDivide {

    public static void main(String args[]){
        int n=10,k=5;
        if(k>n){
            System.out.println("none");
            return;
        }
        int nk=n/k,t=0,i=0,sum=n-1;
        int a[]=new int[k];
        a[0]=1;
        while(a[0]<=nk){
            if(i==k-1){
                a[i]=sum+a[i];
                output(a);
                i--;
                a[i]++;
                sum=a[i+1]-1;
                t++;
            }
            else{
                if(sum>=a[i]){
                    i++;
                    a[i]=a[i-1];
                    sum=sum-a[i];
                }
                else{
                    i--;
                    a[i]++;
                    sum=sum+a[i+1]-1;
                }
            }
        }
        System.out.println(t);
    }

    private static void output(int[] a) {
        // TODO Auto-generated method stub
        for(int j=0;j<a.length;j++){
            System.out.print(a[j]+"");
        }
        System.out.println();
    }
}

3.老鼠走迷宫

问题：有一个迷宫，在迷宫的某个出口放着一块奶酪。将一只老鼠由某个入口处放进去，它必须穿过迷宫，找到奶酪。请找出它的行走路径。

class Position{
    int x,y;
    public Position(int x,int y){
        this.x=x;
        this.y=y;
    }
}
public class Maze {

    static int size;
    static int maze[][]=new int[size+2][size+2];

    private static boolean findPath(){
        ArrayStack path=new ArrayStack();

        Position offset[]=new Position[4];
        offset[0]=new Position(0,1);
        offset[1]=new Position(1,0);
        offset[2]=new Position(0,-1);
        offset[3]=new Position(-1,0);

        for(int i=0;i<=size+1;i++){
            maze[0][i]=maze[size+1][i]=1;
            maze[i][0]=maze[i][size+1]=1;
        }
        Position here=new Position(1,1);
        maze[1][1]=1;
        int option=0;
        int lastOption=3;

        while(here.x!=size||here.y!=size){
            int r=0,c=0;
            while(option<=lastOption){
                r=here.x+offset[option].x;
                c=here.y+offset[option].y;
                if(maze[r][c]==0)
                    break;
                option++;
            }
            if(option<=lastOption){
                path.push(here);
                here=new Position(r,c);
                maze[r][c]=1;
                option=0;
            }
            else{
                if(path.isEmpty())return false;
                Position next=(Position) path.pop();
                if(next.x==here.x){
                    option=2+next.y-here.y;
                }
                else
                    option=3+next.x-here.x;
                here=next;
            }
        }
        return true;
    }
}