回溯法解决八人过河问题

一、题目描述

一家六口，一个爸爸，一个妈妈，俩儿子，俩女儿，还有一个警察，一个坏蛋，过一条河，爸爸不在妈妈伤害儿子，妈妈不在爸爸伤害女儿，警察不在坏蛋伤害一家六口，只有妈妈爸爸警察会开船，一次只能过两个人，只有一艘船。
为怎样过河才能使他们安全度过

二、大脑解题思路

我们当然是一个一个试试啦，百度百科解题如下

三、程序解题

其实人解这道题和计算机解答是一样的，就是往过一个一个的试试，只不过是人的思维太活跃的一时半会找不到思考顺序的规律，捋一捋就清楚了，下面是java代码
（复制即可运行）

public class Test {
    //1  1  1   1   1   1   1   1
    //警察犯人爸爸  妈妈    男1 男2   女1  女2
    public static int[] c = new int[]{0,2,3};
    public static void main(String[] args) {
        //a,b两个数组，a代表河这边的人存在为1，不存在为0，本来一组就可以了，但是河对岸的人还要往过来走
        //记录河对岸的测试情况，所以采用两个数组
        int[] a = new int[]{1,1,1,1,1,1,1,1};
        int[] b = new int[]{0,0,0,0,0,0,0,0};
        Boat(a, b,-1,-1);   
    }
    //将题的条件理出来，判断是否方法可行
    public static boolean ifsuccess(int a[],int b[]){
        if(a[0]==0&&a[1]==1){
            for(int i=2;i<8;i++){
                if(a[i]>0){
                    return false;
                }
            }
        }
        if(a[2]==1){
            if(a[3]!=1){
                for(int i=6;i<8;i++){
                    if(a[i]==1){
                        return false;
                    }
                }
            }
        }

        if(a[3]==1){
            if(a[2]!=1){
                for(int i=4;i<6;i++){
                    if(a[i]==1){
                        return false;
                    }
                }
            }
        }


        if(b[0]==0&&b[1]==1){
            for(int i=2;i<8;i++){
                if(b[i]>0){
                    return false;
                }
            }
        }
        if(b[2]==1){
            if(b[3]!=1){
                for(int i=6;i<8;i++){
                    if(b[i]==1){
                        return false;
                    }
                }
            }
        }

        if(b[3]==1){
            if(b[2]!=1){
                for(int i=4;i<6;i++){
                    if(b[i]==1){
                        return false;
                    }
                }
            }
        }

        return true;

    }

    //河这边的往过走
    public static void Boat(int a[],int b[],int a1,int b1){
        System.out.println("--------");
        for(int i = 0;i<3;i++){
            if(a[c[i]]!=0){
                a[c[i]]=0;
                b[c[i]]=1;

                for(int j=0;j<8;j++){
                    if(a[j]!=0&&(c[i]!=a1||j!=b1)&&(c[i]!=b1||j!=a1)){
                        a[j]=0;
                        b[j]=1;
                        //如果满足条件就开始从河对岸往回走
                        if(ifsuccess(a, b)){
                            print(a, b);
                            Boatreturn(a, b,c[i],j);
                        }
                        //不成功继续判断，回溯
                        a[j]=1;
                        b[j]=0;
                    }

                }
                a[c[i]]=1;
                b[c[i]]=0;  
            }
        }
        return;
    }
public static void Boatreturn(int a[],int b[],int a1,int b1){

        for(int i = 0;i<3;i++){
            if(b[c[i]]!=0){
                b[c[i]]=0;
                a[c[i]]=1;
                if(ifsuccess(a, b)){
                    print(a, b);
                    Boat(a, b,c[i],-1);
                }
                for(int j=0;j<8;j++){
                    if(b[j]!=0&&(c[i]!=a1||j!=b1)&&(c[i]!=b1||j!=a1)){
                        b[j]=0;
                        a[j]=1;
                        if(ifsuccess(a, b)){
                            print(a, b);
                            Boat(a, b,c[i],j);
                        }
                        b[j]=1;
                        a[j]=0;
                    }


                }
                b[c[i]]=1;
                a[c[i]]=0;

            }
        }


        return;
    }



   public static void print(int a[],int b[]){
       //判断是否全部过河
       int flag = 0;
       for (int i : a) {
           if(i==0)
           flag++;
       }
       for (int i : b) {
            System.out.print(i);
       }
       if(flag==8){
           System.out.println("成功---------");
           for (int i = 0; i < b.length; i++) {
            b[i]=0;
        }
           for (int i = 0; i < a.length; i++) {
                a[i]=1;
            }
       }
       System.out.println();
   }



}

程序运行只出现一种对的结果，答案是一种以上，如果有什么好的想法或方法可以一起留言讨论