传教士与野人问题

传教士与野人问题:三个传教士,三个野人,一条船,船最多搭载两个人,传教士和野人都能划船,如何用求解这个问题?

根据<人工智能>的搜索算法,定义目标函数,初始状态,计算出状态空间,然后进行搜索,由于路径耗散是常量,省略了路径耗散函数

这个问题的推广:nn野人问题,在n>3时是无解的

#ifndef te_acrossRiver_MOC_H20132417
#define te_acrossRiver_MOC_H20132417

#include "te_common.h"

class AcrossRiver:public Singaleton<AcrossRiver>
{

class StateNode
{
public:
int goodManLeft;
int badManLeft;

int goodManRight;
int badManRight;

bool boatAtLeft;

StateNode* clone()
{
StateNode* p1=new StateNode();
p1->goodManLeft=goodManLeft;
p1->goodManRight=goodManRight;
p1->badManLeft=badManLeft;
p1->badManRight=badManRight;

return p1;
}
bool isSameState(StateNode* p1)
{
return p1->goodManRight==goodManRight&&p1->goodManLeft==goodManLeft&&p1->badManLeft==badManLeft&&p1->badManRight==badManRight
&&p1->boatAtLeft==boatAtLeft;
}
//后继状态
vector<StateNode*> linkNodes;
};

bool targetTest(StateNode* p)
{
return p->goodManLeft==0&&p->badManLeft==0;
}

//node是否合法
bool nodeTest(StateNode* p,vector<StateNode*>* states)
{
auto it1=find_if(states->begin(),states->end(),[&](StateNode* p1){
return p->isSameState(p1);
});

bool b1=it1==states->end();
bool bleft=(p->goodManLeft==0)||(p->goodManLeft>=p->badManLeft);
bool bright=(p->goodManRight==0)||(p->goodManRight>=p->badManRight);

bool b3=p->goodManLeft>=0&&p->goodManRight>=0&&p->badManLeft>=0&&p->badManRight>=0;

return b1&&bleft&&bright&&b3;
}

void genStatesColection(StateNode* initial,vector<StateNode*>* states)
{

if(targetTest(initial))
{
return;
}else
{

auto perNodeFunc=[&](StateNode* v){
if(nodeTest(v,states))
{
CCLOG("add state %d %d %d %d",v->goodManLeft,v->badManLeft,v->goodManRight,v->badManRight);
initial->linkNodes.push_back(v);

}else
{
delete v;
}
};

if(initial->boatAtLeft)
{
//右移一个goodman
{
StateNode* n1=initial->clone();
n1->boatAtLeft=false;
n1->goodManLeft--;
n1->goodManRight++;
perNodeFunc(n1);
}
//右移一个badman
{
StateNode* n1=initial->clone();
n1->boatAtLeft=false;
n1->badManLeft--;
n1->badManRight++;
perNodeFunc(n1);

}
//右移两个good
{
StateNode* n1=initial->clone();
n1->boatAtLeft=false;
n1->goodManLeft-=2;
n1->goodManRight+=2;
perNodeFunc(n1);
}
//右移两个bad
{
StateNode* n1=initial->clone();
n1->boatAtLeft=false;
n1->badManLeft-=2;
n1->badManRight+=2;
perNodeFunc(n1);

}
//混合右移
{
StateNode* n1=initial->clone();
n1->boatAtLeft=false;
n1->goodManLeft--;
n1->goodManRight++;
n1->badManLeft--;
n1->badManRight++;
perNodeFunc(n1);
}
}else
{
//左移一个goodman
{
StateNode* n1=initial->clone();
n1->boatAtLeft=true;
n1->goodManLeft++;
n1->goodManRight--;
perNodeFunc(n1);
}
//左移一个badman
{
StateNode* n1=initial->clone();
n1->boatAtLeft=true;
n1->badManLeft++;
n1->badManRight--;
perNodeFunc(n1);

}

//左移两个good
{
StateNode* n1=initial->clone();
n1->boatAtLeft=true;
n1->goodManLeft+=2;
n1->goodManRight-=2;
perNodeFunc(n1);
}
//左移两个bad
{
StateNode* n1=initial->clone();
n1->boatAtLeft=true;
n1->badManLeft+=2;
n1->badManRight-=2;
perNodeFunc(n1);

}

//混合左移
{
StateNode* n1=initial->clone();
n1->boatAtLeft=true;
n1->goodManLeft++;
n1->goodManRight--;
n1->badManLeft++;
n1->badManRight--;
perNodeFunc(n1);
}
}

states->push_back(initial);
for_each(initial->linkNodes.begin(),initial->linkNodes.end(),[&](StateNode* n1){

genStatesColection(n1,states);

});

}
}

bool containState(vector<StateNode*>* nodes,StateNode* node)
{
auto it1=find_if(nodes->begin(),nodes->end(),[&](StateNode* p1){
return p1->isSameState(node);
});

return it1!=nodes->end();

}
bool DFSSearch(vector<StateNode*>* path)
{
StateNode* curNode=path->back();

for (int i=0;i<curNode->linkNodes.size();i++)
{
StateNode*  subNode=curNode->linkNodes[i];
path->push_back(subNode);
if(targetTest(subNode))
{

return true;
}else
{
bool b1=DFSSearch(path);
if(b1)
return true;
}
path->pop_back();

}

return false;

}

public:
void run(int m,int n)
{

StateNode* node1=new StateNode();
node1->goodManLeft=m;
node1->badManLeft=n;
node1->badManRight=0;
node1->goodManRight=0;
node1->boatAtLeft=true;

vector<StateNode*>*  nodes=new vector<StateNode*>();

genStatesColection(node1,nodes);

vector<StateNode*> path;
path.push_back(node1);
bool b=DFSSearch(&path);

for_each(path.begin(),path.end(),[&](StateNode* p1){
CCLOG("%d %d     %d %d   %d",p1->goodManLeft,p1->badManLeft,p1->goodManRight,p1->badManRight,p1->boatAtLeft);
});

CCLOG("state space %d",nodes->size());

}
protected:

};

#endif