夫妻过河问题

题目简介：

有三对夫妻要过河，约束条件是，根据法律，任一女子不得在其丈夫不在场的情况下与另外男子在一起，问此时这三对夫妻能否过河？

解题思路：

在任何状态下，六人以及船的位置可以用七个boolean来表示：

船的位置用一个 boolean 类型的变量表示：

boolean ship；

三对夫妻用两个数组表示:

boolean a[3];//丈夫的位置

boolean b[3];//妻子的位置

则问题转化为：

由状态

State {
boolean ship=true;//表示船在此岸
boolean man[3]={true,true,true};//表示三名男子全在此岸
boolean woman[3]={true,true,true};//表示三名女子全在此岸
} 

 

经过怎样的安全路径到达状态：

State {
boolean ship=false;
boolean man[3]={false,false,false};
boolean woman[3]={false,false,false};
}

 

安全路径是指：

这条路径上的所有状态均是安全（合法）的

这条路径上的所有状态转换均是安全（合法）的

判断某个状态是否安全的标准是：

任意妻子不得在其丈夫不在身边的情况下与其它男人在一起，即：

所有妻子都和她的丈夫在一起，或三名丈夫在同侧。

/**
     * 判断该状态是否是合法的
     * 
     * @return true为合法，false为不合法
     */
    public boolean isLowful() {
        if (man[0] == man[1] && man[1] == man[2])
            return true;// 所有丈夫都在同一侧时一定是合法的
        for (int i = 0; i < 3; i++)
            if (man[i] != woman[i])
                return false;// 任意丈夫与妻子不在同一侧时一定是不合法的
        return true;// 所有妻子都和丈夫在同一侧，所以是合法的
    }

判断某个状态转换是否安全的标准是：

状态转换过程中船必须由一岸到了另一岸；

状态转换过程中一定有且仅有一或二名人员随船到了另一岸：

    /**
     * 判断两状态之间的迁移是否合法
     * 
     * @param state1
     * @param state2
     * @return 合法则返回true
     */
    private boolean isLowful(SpouseQuestionState state1, SpouseQuestionState state2) {
        if (state1 == null || state2 == null)
            return false;
        //System.out.println(Integer.toString(state1.hashCode(),2)+"比较"+Integer.toString(state2.hashCode(),2));
        if (state1.ship == state2.ship)
            return false;
        int count = 0;
        for (int i = 0; i < 3; i++) {
            if (state1.man[i] == state2.man[i])
                continue;// 两个状态中某个人位置没有变动
            if (state1.man[i] == state1.ship && state2.man[i] == state2.ship) {
                count++;
                continue;
            }
            // 一个人随船到了另一侧
            return false;// 其它情况
        }
        for (int i = 0; i < 3; i++) {
            if (state1.woman[i] == state2.woman[i])
                continue;// 两个状态中某个人位置没有变动
            if (state1.woman[i] == state1.ship && state2.woman[i] == state2.ship) {
                count++;
                continue;
            }
            // 一个人随船到了另一侧
            return false;// 其它情况
        }
        if (count == 1 || count == 2)
            return true;
        return true;// 超过两人乘船或无人驾驶

    }

对代码进行适量的优化：

显然以下两个状态是完全等价的：

State {
boolean ship=false;
boolean man[3]={true,false,false};
boolean woman[3]={true,false,false};
}
和
State {
boolean ship=false;
boolean man[3]={false,true,false};
boolean woman[3]={false,true,false};
}

我们可以重写State的hashCode()和equals()方法，使这两个对象等价：

public int hashCode(){
        if(hash==0){
            for(int ti=0;ti<3;ti++)
                for(int tj=0;tj<ti;tj++)
            {
            int hash1=ship?1:0;
            for(int x=0;x<3;x++){
                int i=x==ti?tj:x==tj?ti:x;
                hash1=hash1<<1;
                hash1+=man[i]?1:0;
                hash1=hash1<<1;
                hash1+=woman[i]?1:0;
            }
            hash1+=128;
            hash=hash1>hash?hash1:hash;
            }
        }
        return hash;
    }

    public boolean equals(SpouseQuestionState object){
        if(this==object)return true;
        if(object==null)return false;
        if(object.getClass()!=this.getClass())return false;
        return this.hashCode()==object.hashCode();
    }

算法设计：

使用回溯法，发现一条路走不通就返回并另选一条，一旦走到终点就将路径输出：

    private void Digui2(State start, LinkedList<State> last, State state, StateTransition stateTransition) {
        if (start.equals(state.getLastState())) {
            // System.out.println("\t抵达终点");
            if (last.size() <= 20) {
                for (State sta : last) {
                    System.out.println(Integer.toString(sta.hashCode(), 2));
                }
                System.out.println("抵达终点,耗时"+(last.size()+1));
            }
            last.pollLast();
            return;
        }
        Set<StateTransition> temp = new HashSet<>(stateTransition.getAllLowfulStateTranssitionFrom(start));
        // if(temp==null){
        // System.out.println("\t此路不通");
        // return;
        // }
        Iterator<StateTransition> iterator = temp.iterator();
        while (iterator.hasNext()) {
            StateTransition sta = iterator.next();
            if (last.contains(sta.getEnd())) {
                iterator.remove();
            }
        }
        // temp.removeAll(last);
        if (temp.isEmpty()) {
            // System.out.println("\t此路不通");
            last.pollLast();
            return;
        }
        for (StateTransition x : temp) {
            last.add(start);
            // System.out.print(x.toString()+"\t");
            Digui2(x.getEnd(), last, state, stateTransition);
        }
        last.pollLast();
        return;
    }

以下为全部代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
                        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean definitions here -->
    <bean id="State" class="com.lille.mathModel.riverCrossing.stateImpl.SpouseQuestionState">
    </bean>
    <bean id="StateTransition" class="com.lille.mathModel.riverCrossing.stateTransitionImpl.SpouseQuestionStateTransition"></bean>
</beans>

/**
 * 
 */
package com.lille.mathModel.riverCrossing.stateImpl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;

import com.lille.mathModel.riverCrossing.state.State;

/**
 * @author Lille qliujinming@qq.com
 * @time 2018-3-18
 *
 */
public class SpouseQuestionState implements State {

    public final static Map<Integer, SpouseQuestionState> ALL_LOWFUL_STATE=get_ALL_LOWFUL_STATE();
    private static Map<Integer,SpouseQuestionState> get_ALL_LOWFUL_STATE(){
        Map<Integer,SpouseQuestionState> temp=new HashMap<Integer,SpouseQuestionState>();
        for(SpouseQuestionState state:getAllState()){
            temp.put(state.hashCode(), state);
        }
        return temp;
    }
    /*
     * （非 Javadoc）
     * 
     * @see com.lille.mathModel.riverCrossing.state.State#getAllLowfullState()
     */
    @Override
    public ArrayList<SpouseQuestionState> getAllLowfulState(){
        return getAllState();
    }
    public static ArrayList<SpouseQuestionState> getAllState() {
        // TODO 自动生成的方法存根
        LinkedList<SpouseQuestionState> temp = new LinkedList<SpouseQuestionState>();
        Set<Boolean> set = new HashSet<Boolean>();
        set.add(true);
        set.add(false);
        for (boolean t0 : set)
            for (boolean t1 : set)
                for (boolean t2 : set)
                    for (boolean t3 : set)
                        for (boolean t4 : set)
                            for (boolean t5 : set)
                                for (boolean t6 : set) {
                                    SpouseQuestionState statetemp = new SpouseQuestionState(t0, t1, t2, t3, t4, t5, t6);
                                    if (statetemp.isLowful()) {
                                        temp.add(statetemp);
                                    }
                                }

        return new ArrayList<SpouseQuestionState>(temp);
    }

    /*
     * （非 Javadoc）
     * 
     * @see com.lille.mathModel.riverCrossing.state.State#getFirstState()
     */
    @Override
    public State getFirstState() {
        // TODO 自动生成的方法存根
        return FIRST_STATE;
    }

    /*
     * （非 Javadoc）
     * 
     * @see com.lille.mathModel.riverCrossing.state.State#getLastState()
     */
    @Override
    public State getLastState() {
        // TODO 自动生成的方法存根
        return LAST_STATE;
    }

    /**
     * 判断该状态是否是合法的
     * 
     * @return true为合法，false为不合法
     */
    public boolean isLowful() {
        if (man[0] == man[1] && man[1] == man[2])
            return true;// 所有丈夫都在同一侧时一定是合法的
        for (int i = 0; i < 3; i++)
            if (man[i] != woman[i])
                return false;// 任意丈夫与妻子不在同一侧时一定是不合法的
        return true;// 所有妻子都和丈夫在同一侧，所以是合法的
    }
    public int hashCode(){
        if(hash==0){
            for(int ti=0;ti<3;ti++)
                for(int tj=0;tj<ti;tj++)
            {
            int hash1=ship?1:0;
            for(int x=0;x<3;x++){
                int i=x==ti?tj:x==tj?ti:x;
                hash1=hash1<<1;
                hash1+=man[i]?1:0;
                hash1=hash1<<1;
                hash1+=woman[i]?1:0;
            }
            hash1+=128;
            hash=hash1>hash?hash1:hash;
            }
        }
        return hash;
    }
    public boolean equals(SpouseQuestionState object){
        if(this==object)return true;
        if(object==null)return false;
        if(object.getClass()!=this.getClass())return false;
        return this.hashCode()==object.hashCode();
    }
    /*
    public boolean equals(SpouseQuestionState object){
        if(this==object)return true;
        if(object==null)return false;
        if(object.getClass()!=this.getClass())return false;
        for(int i=0;i<3;i++){
            for(int j=0;j<i;j++){
                hash=object.ship?1:0;
                for(int x=0;x<3;x++){
                    int temp=x==i?j:x==j?i:x;
                    hash=hash<<1;
                    hash+=object.man[x]?1:0;
                    hash=hash<<1;
                    hash+=object.woman[x]?1:0;
                }
                hash+=128;
                if(hashCode()==128)return true;
            }
        }
        return this.hashCode()==object.hashCode();
    }*/
    SpouseQuestionState() {

    }
    SpouseQuestionState(boolean ship, boolean man0, boolean man1, boolean man2, boolean woman0, boolean woman1,
            boolean woman2) {
        this.ship = ship;
        this.man = new boolean[] { man0, man1, man2 };
        this.woman = new boolean[] { woman0, woman1, woman2 };
    }
    /**
     * 初态下所有元素都在此岸
     */
    private static final SpouseQuestionState FIRST_STATE=ALL_LOWFUL_STATE.get(255);
    /**
     * 终态下所有元素都在彼岸
     */
    private static final SpouseQuestionState LAST_STATE=ALL_LOWFUL_STATE.get(128);
    public boolean ship;
    public boolean man[] = new boolean[3];
    public boolean woman[] = new boolean[3];
    private int hash;
}

package com.lille.mathModel.riverCrossing.stateTransitionImpl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

import com.lille.mathModel.riverCrossing.state.State;
import com.lille.mathModel.riverCrossing.stateImpl.SpouseQuestionState;
import com.lille.mathModel.riverCrossing.stateTransition.StateTransition;

public class SpouseQuestionStateTransition implements StateTransition {

    @Override
    public ArrayList<StateTransition> getAllLowfulStateTranssition(ArrayList<State> stateList) {
        // TODO 自动生成的方法存根

        return null;
    }

    @Override
    public Set<SpouseQuestionStateTransition> getAllLowfulStateTranssitionFrom(State state) {
        // TODO 自动生成的方法存根
        HashSet<SpouseQuestionStateTransition> temp = FROM_TABLE.get(state);
        if (temp == null) {
            temp = new HashSet<SpouseQuestionStateTransition>();
            FROM_TABLE.put(state, temp);
            SearchAboutStart((SpouseQuestionState) state, temp);
        }
        return FROM_TABLE.get(state);
    }

    @Override
    public Set<SpouseQuestionStateTransition> getAllLowfulStateTranssitionTo(State state) {
        // TODO 自动生成的方法存根
        return null;
    }

    private final HashMap<State, HashSet<SpouseQuestionStateTransition>> FROM_TABLE = new HashMap<State, HashSet<SpouseQuestionStateTransition>>();
    private final HashMap<State, HashSet<SpouseQuestionStateTransition>> TO_TABLE = new HashMap<State, HashSet<SpouseQuestionStateTransition>>();
    private final SpouseQuestionState start;
    private final SpouseQuestionState end;

    public SpouseQuestionState getStart() {
        return start;
    }

    public SpouseQuestionState getEnd() {
        return end;
    }

    public SpouseQuestionStateTransition() {
        start = null;
        end = null;
    }

    public SpouseQuestionStateTransition(SpouseQuestionState start, SpouseQuestionState end) {
        this.start = start;
        this.end = end;
    }

    /**
     * 判断两状态之间的迁移是否合法
     * 
     * @param state1
     * @param state2
     * @return 合法则返回true
     */
    private boolean isLowful(SpouseQuestionState state1, SpouseQuestionState state2) {
        if (state1 == null || state2 == null)
            return false;
        //System.out.println(Integer.toString(state1.hashCode(),2)+"比较"+Integer.toString(state2.hashCode(),2));
        if (state1.ship == state2.ship)
            return false;
        int count = 0;
        for (int i = 0; i < 3; i++) {
            if (state1.man[i] == state2.man[i])
                continue;// 两个状态中某个人位置没有变动
            if (state1.man[i] == state1.ship && state2.man[i] == state2.ship) {
                count++;
                continue;
            }
            // 一个人随船到了另一侧
            return false;// 其它情况
        }
        for (int i = 0; i < 3; i++) {
            if (state1.woman[i] == state2.woman[i])
                continue;// 两个状态中某个人位置没有变动
            if (state1.woman[i] == state1.ship && state2.woman[i] == state2.ship) {
                count++;
                continue;
            }
            // 一个人随船到了另一侧
            return false;// 其它情况
        }
        if (count == 1 || count == 2)
            return true;
        return true;// 超过两人乘船或无人驾驶

    }

    /**
     * 取得指定起点的所有合法状态迁移，并将其储存在set中
     * 
     * @param state
     * @param set
     * @return 若set不为空，返回true
     */
    private boolean SearchAboutStart(SpouseQuestionState state, HashSet<SpouseQuestionStateTransition> set) {

        for (int i = 0; i < 6; i++)
            for (int j = 0; j <=i; j++) {
                int key = 0;
                if (i != j)
                    key = (1 << i) + (1 << j) + (1 << 6);
                else
                    key = (1 << i) + (1 << 6);
                SpouseQuestionState temp = SpouseQuestionState.ALL_LOWFUL_STATE.get(key^state.hashCode());
                if (isLowful(state, temp)){
                    set.add(new SpouseQuestionStateTransition(state, temp));}
            }
        return !set.isEmpty();
    }

    /**
     * 
     */
    public String toString() {
        return Integer.toString(start.hashCode(), 2) + "到" + Integer.toString(end.hashCode(), 2);

    }

    private int hash;

    public int hashCode() {
        if (hash == 0) {
            hash = start.hashCode();
            hash = hash*128 + end.hashCode();
        }
        return hash;
    }

    public boolean equals(SpouseQuestionStateTransition x) {
        if (x == null )
            return false;
        return this.hashCode()==x.hashCode();
        
    }
}

package com.lille.mathModel.riverCrossing.state;

import java.util.ArrayList;

/**
 * 
 * @author Lille qliujinming@qq.com
 * @time 2018-3-18
 */
public interface State {
    /**
     * 取得所有合法状态
     * 
     * @return
     */
    public ArrayList<? extends State> getAllLowfulState();

    /**
     * 取得初态
     * 
     * @return
     */
    public State getFirstState();

    /**
     * 取得终态
     * 
     * @return
     */
    public State getLastState();
}

package com.lille.mathModel.riverCrossing.stateTransition;

import java.util.ArrayList;
import java.util.Set;

import com.lille.mathModel.riverCrossing.state.State;
import com.lille.mathModel.riverCrossing.stateTransitionImpl.SpouseQuestionStateTransition;

public interface StateTransition {
    /**
     * 获取该状态迁移的初始状态
     * @return
     */
    public State getStart();
    /**
     * 该状态迁移的目的地
     * @return
     */
    public State getEnd();
    /**
     * 获得所有合法的状态迁移
     * 
     * @param stateList
     *            所有的合法状态
     * @return
     */
    public ArrayList<StateTransition> getAllLowfulStateTranssition(ArrayList<State> stateList);

    /**
     * 获得以state为起点的所有合法状态迁移
     * 
     * @param state
     * @return
     */
    public Set<SpouseQuestionStateTransition> getAllLowfulStateTranssitionFrom(State state);

    /**
     * 获得所有以state为终点的所有合法状态迁移
     * 
     * @param state
     * @return
     */
    public Set<SpouseQuestionStateTransition> getAllLowfulStateTranssitionTo(State state);
}

package com.lille.test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lille.mathModel.riverCrossing.state.State;
import com.lille.mathModel.riverCrossing.stateTransition.StateTransition;

public class Test01 {
    @Test
    public void Test1() {
        String xml = "applicationContext.xml";
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext(xml);
        State state = (State) context.getBean("State");
        StateTransition stateTransition = (StateTransition) context.getBean("StateTransition");
        hashSet.add(state.getFirstState());
        // Digui(state, stateTransition);
        LinkedList<State> last = new LinkedList<State>();
        Digui2(state.getFirstState(), last, state, stateTransition);
    }

    Set<State> hashSet = new HashSet<State>();

    private void Digui2(State start, LinkedList<State> last, State state, StateTransition stateTransition) {
        if (start.equals(state.getLastState())) {
            // System.out.println("\t抵达终点");
            if (last.size() <= 20) {
                for (State sta : last) {
                    System.out.println(Integer.toString(sta.hashCode(), 2));
                }
                System.out.println("抵达终点,耗时"+(last.size()+1));
            }
            last.pollLast();
            return;
        }
        Set<StateTransition> temp = new HashSet<>(stateTransition.getAllLowfulStateTranssitionFrom(start));
        // if(temp==null){
        // System.out.println("\t此路不通");
        // return;
        // }
        Iterator<StateTransition> iterator = temp.iterator();
        while (iterator.hasNext()) {
            StateTransition sta = iterator.next();
            if (last.contains(sta.getEnd())) {
                iterator.remove();
            }
        }
        // temp.removeAll(last);
        if (temp.isEmpty()) {
            // System.out.println("\t此路不通");
            last.pollLast();
            return;
        }
        for (StateTransition x : temp) {
            last.add(start);
            // System.out.print(x.toString()+"\t");
            Digui2(x.getEnd(), last, state, stateTransition);
        }
        last.pollLast();
        return;
    }

    private void Digui(State state, StateTransition stateTransition) {
        boolean flag = false;
        do {
            flag = false;
            Set<State> hashSet2 = new HashSet<State>();
            for (State temp : hashSet) {
                for (StateTransition trtemp : stateTransition.getAllLowfulStateTranssitionFrom(temp)) {
                    if (!hashSet.contains(trtemp.getEnd())) {
                        hashSet2.add(trtemp.getEnd());
                        System.out.println(trtemp.toString());
                    }
                }
            }
            if (hashSet.addAll(hashSet2))
                flag = true;
        } while (flag);
    }

}

以下为最终结果：

11111111
10111010
11111110
10101010
11111010
10110000
11111100
10010100
11010101
10010000
11110000
抵达终点,耗时12
11111111
10111010
11111110
10101010
11111010
10110000
11111100
10010100
11010101
10010000
11010100
抵达终点,耗时12
11111111
10111100
11111110
10101010
11111010
10110000
11111100
10010100
11010101
10010000
11110000
抵达终点,耗时12
11111111
10111100
11111110
10101010
11111010
10110000
11111100
10010100
11010101
10010000
11010100
抵达终点,耗时12

每个字节表示一个状态，首位始终为1，不然会参差不齐的，剩下七位分别是船、男A、女A、男B、女B、男C、女C，1表示此岸，0表示彼岸

为什么要用Spring呢，因为刚学想练练手。

PS:用java来做算法题真是让人头疼