花了半个晚上写了一个深度优先求解人狼过河的程序

 

狼人过河问题：有三个人和三只狼要过河，河里有一只船同时能容纳最多两个生物
假设狼和人都会划船，但如果岸边（不包括船上）狼的数量比人多 ，狼就要吃人
问：怎么把三只狼和三个人安全运输到对岸

// mytest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <windows.h>
#include <iostream>
#include <string>
#include <set>
#include <map>
#include <vector>
using namespace std;

//打印结果相关函数
void printState(char state);
void printStates(const vector<char>& vecStates);
//根据当前状态，获取下一步可能的所有状态函数
void getNextStates(char currState, vector<char>& vecNextStates);

//检查状态是否符合要求的函数
#define RET_IF_NOT_OK(cnt) do { if(cnt < 0 || cnt > 3) return false; } while(0)
bool isStateOk(int leftPeopleCnt, int leftWolfCnt, int rightPeopleCnt, int rightWolfCnt)
{
    RET_IF_NOT_OK(leftPeopleCnt);
    RET_IF_NOT_OK(leftWolfCnt);
    RET_IF_NOT_OK(rightPeopleCnt);
    RET_IF_NOT_OK(rightWolfCnt);

    //岸边有人，且人的数量少于狼的数量
    if (leftPeopleCnt > 0 && leftPeopleCnt < leftWolfCnt) return false;
    if (rightPeopleCnt > 0 && rightPeopleCnt < rightWolfCnt) return false;

    return true;
}

//根据下一步船所在岸边和岸边狼/人数量生成下一步状态字节
//这个函数与getNextStates紧密结合 详细用法请参考该函数调用逻辑
char makeState(int leftPeopleCnt, int leftWolfCnt, bool bLeft)
{
    //用一个字节第一位（左数，下同 ）表示船在左边(0)还是在右边(1)
    //用第3、4代表人的数量，第7、8位代表狼的数量(00 ~ 11)
    //举例：0b00110011 表示左岸有三个人三只狼 船在左边
    //      0b10100001 表示左岸有三个人一只狼 船在右边
    char state = 0;
    

    //下一步船在左边
    if (bLeft)
    {
        //传进来的其实是下一步右边岸上人和狼的数量
        //需要推导出下一步左边岸上的人和儿狼的数量
        state = state | ((3 - leftPeopleCnt) << 4) | (3 - leftWolfCnt);
    }
    else
    {
        //下一步船要在右边了
        state = state | 0x80;
        state = state | (leftPeopleCnt << 4) | leftWolfCnt;
    }

    
    return state;
}

//根据当前状态，获取下一步可能的所有状态函数
void getNextStates(char state, vector<char>& vecNextStates)
{
    bool bLeft = (state & 0x80) == 0;
    int leftPepleCnt = (state & 0x30) >> 4, rihgtPeopleCnt = 3 - leftPepleCnt;
    int leftWolfCnt = (state & 0x03), rightWolfCnt = 3 - leftWolfCnt;
    if (!isStateOk(leftPepleCnt, leftWolfCnt, rihgtPeopleCnt, rightWolfCnt)) return;
    
    //定义指针指向当前船所在的岸边和对岸的人和狼数量
    //这样做的原因是左岸和右岸状态变化逻辑是一样的 可以减少逻辑重复的代码
    int *pShipPeopleCnt, *pNotShipPeopleCnt, *pShipWolfCnt, *pNotShipWolfCnt;

    if (bLeft)
    {
        pShipPeopleCnt = &leftPepleCnt;
        pShipWolfCnt = &leftWolfCnt;
        pNotShipPeopleCnt = &rihgtPeopleCnt;
        pNotShipWolfCnt = &rightWolfCnt;
    }
    else
    {
        pShipPeopleCnt = &rihgtPeopleCnt;
        pShipWolfCnt = &rightWolfCnt;
        pNotShipPeopleCnt = &leftPepleCnt;
        pNotShipWolfCnt = &leftWolfCnt;
    }

    //可能变化有五种，一个人/狼单独过河 两个人/狼过河 一只狼和一个人一起过河
    //根据人的思维，尽量先处理两个生物过河的状态，不行再处理单个生物过河的
    //两个人/狼过河
    if ( isStateOk(*pShipPeopleCnt - 2, *pShipWolfCnt, *pNotShipPeopleCnt + 2, *pNotShipWolfCnt) )
    {
        vecNextStates.push_back( makeState(*pShipPeopleCnt - 2, *pShipWolfCnt, !bLeft) );
    }

    if ( isStateOk(*pShipPeopleCnt, *pShipWolfCnt - 2, *pNotShipPeopleCnt, *pNotShipWolfCnt + 2) )
    {
        vecNextStates.push_back( makeState(*pShipPeopleCnt, *pShipWolfCnt - 2, !bLeft) );
    }

    //一只狼和一个人一起过河
    if ( isStateOk(*pShipPeopleCnt - 1, *pShipWolfCnt - 1, *pNotShipPeopleCnt + 1, *pNotShipWolfCnt + 1) )
    {
        vecNextStates.push_back( makeState(*pShipPeopleCnt - 1, *pShipWolfCnt - 1, !bLeft) );
    }

    //一个人/狼单独过河
    if ( isStateOk(*pShipPeopleCnt - 1, *pShipWolfCnt, *pNotShipPeopleCnt + 1, *pNotShipWolfCnt) )
    {
        vecNextStates.push_back( makeState(*pShipPeopleCnt - 1, *pShipWolfCnt, !bLeft) );
    }

    if ( isStateOk(*pShipPeopleCnt, *pShipWolfCnt - 1, *pNotShipPeopleCnt, *pNotShipWolfCnt + 1) )
    {
        vecNextStates.push_back( makeState(*pShipPeopleCnt, *pShipWolfCnt - 1, !bLeft) );
    }

    //如果要避免一些看起来比较愚蠢的走法，可以在这里加上对状态优先级排序的逻辑
}

//狼人过河问题：有三个人和三只狼要过河，河里有一只船同时能容纳最多两个生物
//假设狼和人都会划船，但如果岸边（不包括船上）狼的数量比人多 ，狼就要吃人
//问：怎么把三只狼和三个人安全运输到对岸
int dualLangRenOnce(char currState, vector<char>& vecStates, set<char> closeTab)
{
    //如果当前状态是目标状态，则退出递归
    if ((currState & 0x33) == 0) return 0;

    vector<char> vecNextState;
    //获取下个状态，即考虑怎么安排狼和人过河
    getNextStates(currState, vecNextState);
    for (size_t i = 0; i < vecNextState.size(); i++)
    {
        if ( closeTab.find(vecNextState[i]) == closeTab.end() )
        {
            closeTab.insert(vecNextState[i]);
            vecStates.push_back(vecNextState[i]);
            //如果打算找全部可能解 这里就不需要return了
            if (dualLangRenOnce(vecNextState[i], vecStates, closeTab) == 0) return 0;
            vecStates.pop_back();
        }
    }

    return 1;
}

void dualLangRen()
{
    //用一个字节第一位（左数，下同 ）表示船在左边还是在右边
    //用第3、4代表人的数量，第7、8位代表狼的数量(00 ~ 11)
    //举例：0b00110011 表示左岸有三个人三只狼 船在左边
    //      0b10100001 表示左岸有三个人一只狼 船在右边
    char state = 0x33;
    //vector记录状态变化过程
    vector<char> vecStates;
    //set记录已经历过的状态，以免重复尝试造成无尽递归
    set<char> closeTab;

    vecStates.push_back(state);
    closeTab.insert(state);
    if (dualLangRenOnce(state, vecStates, closeTab) == 0)
    {
        printStates(vecStates);
    }
    else
    {
        cout << "问题无解！" << endl;
    }

    return;
}

void printState(char state)
{
    bool bLeft = (state & 0x80) == 0;
    int leftPepleCnt = (state & 0x30) >> 4;
    int leftWolfCnt = (state & 0x03);

    printf("人%d 狼%d %s 人%d 狼%d", leftPepleCnt, leftWolfCnt, (bLeft ? "左": "右"), 3 -leftPepleCnt, 3 - leftWolfCnt);
}

void printStates(const vector<char>& vecStates)
{
    for(vector<char>::const_iterator it = vecStates.begin(); it != vecStates.end(); it++)
    {
        printState(*it);
        printf("
");
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    double start = GetTickCount();
    dualLangRen();
    
    //我自己机在win7 vs2008环境 debug模式是16毫秒 release不到1毫秒
    printf("总共耗时 %f 毫秒
", GetTickCount() - start);

    //挂屏
    system("pause");
    return 0;
}

运行结果：

这是最近第二次写了，复习一遍数据结构之后的作品

之前没有复习前写过另一版，逻辑比较混乱，有空再贴上来对比