人狼羊菜过河问题

最新推荐文章于 2023-03-16 13:12:38 发布
最新推荐文章于 2023-03-16 13:12:38 发布
阅读量4.3k 收藏 24
点赞数 5
分类专栏： algurithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42683011/article/details/109827951
版权

人狼羊菜过河问题:

PTA原题:

image-20201119222220215

输入:

MWGC -> ....
.... <- MWGC

输出:

MWGC -> ....
.W.C <- M.G.
MW.C -> ..G.
...C <- MWG.
M.GC -> .W..
..G. <- MW.C
M.G. -> .W.C
.... <- MWGC

MWGC -> ....
.W.C <- M.G.
MW.C -> ..G.
.W.. <- M.GC
MWG. -> ...C
..G. <- MW.C
M.G. -> .W.C
.... <- MWGC

输入:

.W.. <- M.GC
M.GC -> .W..

输出:

.W.. <- M.GC
MWG. -> ...C
..G. <- MW.C
M.GC -> .W..

.W.. <- M.GC
MW.C -> ..G.
...C <- MWG.
M.GC -> .W..

分析

这题本质上还是用 DFS+剪枝 暴力搜索所有状态, 以找到满足条件的解

这题我写了将近5个小时😂, 个人认为主要的难点和Debug点是在状态变化上, 本题中状态总共有8种:

	/*
	 * 农夫单独过河
	 * 农夫带狼过河；
	 * 农夫带羊过河；
	 * 农夫带菜过河;
	 * 农夫单独返回；
	 * 农夫带狼返回；
	 * 农夫带羊返回；
	 * 农夫带菜返回；
	*/

所以需要开一个八叉树进行DFS搜索, 其中需要对无效状态和重复状态进行剪枝, 并在状态符合最终结果的时候打印返回

首先是状态的转换, 用bool[8]储存当前状态:

//输入并转化状态:
char temp[MAX]={0};
for(int i=0;i<4;++i){
    scanf("%c",&temp[i]);
    temp[i]=='.'?startState[i]=false:startState[i]=true;
}
scanf("%*4c");
for(int i=4;i<8;++i){
    scanf("%c",&temp[i]);
    temp[i]=='.'?startState[i]=false:startState[i]=true;
}
getchar();

for(int i=0;i<4;++i){
    scanf("%c",&temp[i]);
    temp[i]=='.'?endState[i]=false:endState[i]=true;
}
scanf("%*4c");
for(int i=4;i<8;++i){
    scanf("%c",&temp[i]);
    temp[i]=='.'?endState[i]=false:endState[i]=true;
}
getchar();

而后是八种状态的变换, 这里使用了Lambda表达式进行, 以便于在DFS时使用变量控制

当能够改变状态时返回true, 不能时返回false, 以便于DFS中进行判断

//定义8种状态:
/*
	 * 农夫单独过河
	 * 农夫带狼过河；
	 * 农夫带羊过河；
	 * 农夫带菜过河;
	 * 农夫单独返回；
	 * 农夫带狼返回；
	 * 农夫带羊返回；
	 * 农夫带菜返回；
	*/
state[0]=[](void)->bool{
    if(!nowState[0]){
        return false;
    }else if((nowState[1] && nowState[2]) ||
             (nowState[2] && nowState[3])){
        return false;
    }else{
        nowState[0]=false;
        nowState[4]=true;
        return true;
    }

};
state[1]=[](void)->bool{
    if((!nowState[0]) || (!nowState[1])){
        return false;
    }else if(nowState[2] && nowState[3]){
        return false;
    }else{
        nowState[0]=false;
        nowState[4]=true;
        nowState[1]=false;
        nowState[5]=true;
        return true;
    }
};
state[2]=[](void)->bool{
    if((!nowState[0]) || (!nowState[2])){
        return false;
    }else{
        nowState[0]=false;
        nowState[4]=true;
        nowState[2]=false;
        nowState[6]=true;
        return true;
    }

};
state[3]=[](void)->bool{
    if((!nowState[0]) || (!nowState[3])){
        return false;
    }else if(nowState[1] && nowState[2]){
        return false;
    }else{
        nowState[0]=false;
        nowState[4]=true;
        nowState[3]=false;
        nowState[7]=true;
        return true;
    }
};
//--------------------------------
state[4]=[](void)->bool{
    if(!nowState[4]){
        return false;
    }else if((nowState[5] && nowState[6]) ||
             (nowState[6 && nowState[7]])){
        return false;
    }else{
        nowState[4]=false;
        nowState[0]=true;
        return true;
    }

};
state[5]=[](void)->bool{
    if((!nowState[4]) || (!nowState[5])){
        return false;
    }else if(nowState[6] && nowState[7]){
        return false;
    }else{
        nowState[4]=false;
        nowState[0]=true;
        nowState[5]=false;
        nowState[1]=true;
        return true;
    }

};
state[6]=[](void)->bool{
    if((!nowState[4]) || (!nowState[6])){
        return false;
    }else {
        nowState[4]=false;
        nowState[0]=true;
        nowState[6]=false;
        nowState[2]=true;
        return true;
    }

};
state[7]=[](void)->bool{
    if((!nowState[4]) || (!nowState[7])){
        return false;
    }else if(nowState[5] && nowState[6]){
        return false;
    }else{
        nowState[4]=false;
        nowState[0]=true;
        nowState[7]=false;
        nowState[3]=true;
        return true;
    }
};

判定状态是否重复这里使用了set

当有重复元素插入时, insert会返回一个false, 此时在DFS中进行剪枝:

bool isRepeat(bool s[]){
	auto re=stateList.insert (stateToInt (s));
	if(!re.second){
		return true;
	}else{
		return false;
	}
}

最后是DFS暴力搜索

这里debug了很久, 主要是忘了在return之后对当前状态进行回退, 导致set中状态没有清干净, 忽略了部分情况

void dfs(int stateNum){
	for(int i=0;i<8;++i){
		nowState[i]=stateTrace[tracePtr-1][i];
	}
	//改变状态, 如果状态非法, 则返回
	if(!state[stateNum]()){
		return ;
	}else if(!isRepeat(nowState)){
		pushState (nowState);
//		printState ();
	}else {
		//如果状态重复, 则返回
		return ;
	}
	//如果状态相等, 则打印返回
	if(stateEqual (nowState, endState)){
		if(ansCount!=0){
			printf("\n");
		}
		printState ();
		++ansCount;
		popState ();
		stateList.erase (stateToInt (nowState));
		return ;
	}
	//递归
	for(int i=0;i<8;++i){
		if(tracePtr==3 && i==3){
//			printf("breakP\n");
		}
		dfs(i);
	}
	for(int i=0;i<8;++i){
		nowState[i]=stateTrace[tracePtr-1][i];
	}
	popState ();
	stateList.erase (stateToInt (nowState));
	return ;
}

源码:

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<bits/stdc++.h>
#include <queue>
#include <vector>
#include <utility>

using namespace std;

#define INF 0x3f3f3f3f
#define ll long long
#define ull unsigned long long


const int MAX=20+5;

bool (*state[8])(void);

//MWGC
bool nowState[8];
bool startState[8];
bool endState[8];
set<int> stateList;
int ansCount=0;

bool stateEqual(bool b1[], bool b2[]){
	bool flag=true;
	for(int i=0;i<8;++i){
		if(b1[i]!= b2[i]){
			flag=false;
			break;
		}
	}
	return flag;
}

int stateToInt(bool s[]){
	int stateInt=0;
	for(int i=0;i<8;++i){
		if(s[i]){
			stateInt+=pow(2,7-i);
		}
	}
	return stateInt;
}

bool isRepeat(bool s[]){
	auto re=stateList.insert (stateToInt (s));
	if(!re.second){
		return true;
	}else{
		return false;
	}
}



int tracePtr=0;
//最后一位为stateNum
bool stateTrace[MAX][9]={0};
char stateFlag[]={"MWGCMWGC"};

void pushState(bool b[]){
	for(int i=0;i<8;++i){
		stateTrace[tracePtr][i]=b[i];
	}
	++tracePtr;
	return ;
}

void popState(){
	--tracePtr;
}

void printState(){
	for(int i=0;i<tracePtr;++i){
		for(int j=0;j<4;++j){
			stateTrace[i][j]?printf("%c",stateFlag[j]):printf(".");
		}
		stateTrace[i][0]?printf(" -> "):printf(" <- ");
		for(int j=4;j<8;++j){
			stateTrace[i][j]?printf("%c",stateFlag[j]):printf(".");
		}
		putchar('\n');
	}
//	putchar('\n');
}

void dfs(int stateNum){
	for(int i=0;i<8;++i){
		nowState[i]=stateTrace[tracePtr-1][i];
	}
	//改变状态, 如果状态非法, 则返回
	if(!state[stateNum]()){
		return ;
	}else if(!isRepeat(nowState)){
		pushState (nowState);
//		printState ();
	}else {
		//如果状态重复, 则返回
		return ;
	}
	//如果状态相等, 则打印返回
	if(stateEqual (nowState, endState)){
		if(ansCount!=0)
			printf("\n");
		}
		printState ();
		++ansCount;
		popState ();
		stateList.erase (stateToInt (nowState));
		return ;
	}
	//递归
	for(int i=0;i<8;++i){
		if(tracePtr==3 && i==3){
//			printf("breakP\n");
		}
		dfs(i);
	}
    //状态回退
	for(int i=0;i<8;++i){
		nowState[i]=stateTrace[tracePtr-1][i];
	}
	popState ();
	stateList.erase (stateToInt (nowState));
	return ;
}
int main() {
	//定义8种状态:
	/*
	 * 农夫单独过河
	 * 农夫带狼过河；
	 * 农夫带羊过河；
	 * 农夫带菜过河;
	 * 农夫单独返回；
	 * 农夫带狼返回；
	 * 农夫带羊返回；
	 * 农夫带菜返回；
	*/
	state[0]=[](void)->bool{
		if(!nowState[0]){
			return false;
		}else if((nowState[1] && nowState[2]) ||
				 (nowState[2] && nowState[3])){
			return false;
		}else{
			nowState[0]=false;
			nowState[4]=true;
			return true;
		}

	};
	state[1]=[](void)->bool{
		if((!nowState[0]) || (!nowState[1])){
			return false;
		}else if(nowState[2] && nowState[3]){
			return false;
		}else{
			nowState[0]=false;
			nowState[4]=true;
			nowState[1]=false;
			nowState[5]=true;
			return true;
		}
	};
	state[2]=[](void)->bool{
		if((!nowState[0]) || (!nowState[2])){
			return false;
		}else{
			nowState[0]=false;
			nowState[4]=true;
			nowState[2]=false;
			nowState[6]=true;
			return true;
		}

	};
	state[3]=[](void)->bool{
		if((!nowState[0]) || (!nowState[3])){
			return false;
		}else if(nowState[1] && nowState[2]){
			return false;
		}else{
			nowState[0]=false;
			nowState[4]=true;
			nowState[3]=false;
			nowState[7]=true;
			return true;
		}
	};
	//--------------------------------
	state[4]=[](void)->bool{
		if(!nowState[4]){
			return false;
		}else if((nowState[5] && nowState[6]) ||
				 (nowState[6 && nowState[7]])){
			return false;
		}else{
			nowState[4]=false;
			nowState[0]=true;
			return true;
		}

	};
	state[5]=[](void)->bool{
		if((!nowState[4]) || (!nowState[5])){
			return false;
		}else if(nowState[6] && nowState[7]){
			return false;
		}else{
			nowState[4]=false;
			nowState[0]=true;
			nowState[5]=false;
			nowState[1]=true;
			return true;
		}

	};
	state[6]=[](void)->bool{
		if((!nowState[4]) || (!nowState[6])){
			return false;
		}else {
			nowState[4]=false;
			nowState[0]=true;
			nowState[6]=false;
			nowState[2]=true;
			return true;
		}

	};
	state[7]=[](void)->bool{
		if((!nowState[4]) || (!nowState[7])){
			return false;
		}else if(nowState[5] && nowState[6]){
			return false;
		}else{
			nowState[4]=false;
			nowState[0]=true;
			nowState[7]=false;
			nowState[3]=true;
			return true;
		}
	};


	//输入并转化状态:
	char temp[MAX]={0};
	for(int i=0;i<4;++i){
		scanf("%c",&temp[i]);
		temp[i]=='.'?startState[i]=false:startState[i]=true;
	}
	scanf("%*4c");
	for(int i=4;i<8;++i){
		scanf("%c",&temp[i]);
		temp[i]=='.'?startState[i]=false:startState[i]=true;
	}
	getchar();

	for(int i=0;i<4;++i){
		scanf("%c",&temp[i]);
		temp[i]=='.'?endState[i]=false:endState[i]=true;
	}
	scanf("%*4c");
	for(int i=4;i<8;++i){
		scanf("%c",&temp[i]);
		temp[i]=='.'?endState[i]=false:endState[i]=true;
	}
	getchar();

	//	for(int i=0;i<8;++i){
	//		printf("%d",startState[i]);
	//	}
	//	putchar('\n');
	//	for(int i=0;i<8;++i){
	//		printf("%d",endState[i]);
	//	}

	for(int i=0;i<8;++i){
		nowState[i]=startState[i];
	}
	pushState (nowState);
	isRepeat (nowState);

	for(int i=0;i<8;++i){
		dfs(i);
	}
//	cout<<stateToInt (nowState)<<endl;
//	cout<<stateToInt (endState)<<endl;
//	cout<<isRepeat (startState)<<endl;
//	cout<<isRepeat (endState)<<endl;
//	pushState (startState);
//	pushState (endState);
//	printState ();

	if(ansCount==0){
		printf("None\n");
	}

	return 0;
}
Janus_V
关注
  • 5
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
人狼羊菜过河程序JAVA
06-28
编译原理中人狼羊菜过河通过java语言实现的程序。
11.12PTA训练 人狼羊菜过河 搜索，位运算
TheSunspot的博客
11-14 1505
题意 人不在的时候狼吃羊，羊吃菜，用MWGC表示人狼羊草，箭头代表行进方向，输出所有由初始情况到最终情况的解决方案 思路 目前为止写得最头疼的搜索 因为一岸的状态确定了，另一岸也就唯一确定了，所以可以用五位二进制数表示当前状态。之后利用位运算的操作就可以进行搜索，用vector存储进行到当前状态的二进制数，得到结果后输出即可。为了防止重复访问，要开vis数组记录某个状态是否到过 代码 #include<cstdio> #include<iostream> #include<io
狼、羊、菜和农夫过河问题[超详细解析，CPP实现]
热门推荐
KongJHong的博客
06-02 4万+
农夫需要把狼、羊、菜和自己运到河对岸去（不知道为啥要运狼，别问我），只有农夫能够划船，而且船比较小，除农夫之外每次只能运一种东西，还有一个棘手的问题，就是如果没有农夫看着，羊会偷吃菜，狼会吃羊。请考虑一种方法，让农夫能够安全地安排这些东西和他自己过河。 算法设计思路 这是一个很简单的问题，在狼、羊和菜这个食物链上，关键是中间的羊，因为狼不吃菜，所以要安全过河，农夫的第一件事就是带羊走，拆开这个...
人狼羊菜过河问题(编程求得最优算法)
01-11
一个摆渡人F希望用一条小船把一只狼 W，一头羊 G 和一篮白菜 C 从一条河的左岸渡到右岸去，而船小只能容纳 F、W、G、C 中的两个，决不能在无人看守的情况下，留下狼和羊在一起，羊和白菜在一起，应怎样渡河才能将狼、羊、白菜都运过去?
基于深度优先搜索回溯法的人狼羊菜过河模型
CK的博客
12-15 4219
本文介绍了一种合理规划农夫携带狼、羊、菜安全过河问题。对问题合理分析，将人、狼、羊、菜四者的某时刻状态量化为一向量，基于此结构建立安全位置状态集合，与安全运输状态集合，存储运输过程中可能的位置状态与运输状态。以初始状态向量为起点，采用回溯法，深度优先遍历所有可行路径，将符合题目条件并未重复的可行路径添入历史路径集合中，并记录此时的位置状态。递归至搜索到终止状态集合，输出所有历史位置状态集合，即为一条可行方案。回溯弹出，即可搜寻到所有可行路径。并根据所搜寻到的可行路径输出最短路径。
java狼羊草过河_解决狼、羊、白菜过河问题的编程思路
weixin_31968223的博客
02-27 2263
前几天女朋友复习人工智能的考试，看见了一道经典的狼、羊、白菜过河问题，题目如下：一个人带着一只羊，一条狼和一个白菜想过河，假设他每次只能带一只羊，或者一条狼，或者一棵白菜过河，并限定人不在场时，狼和羊，或羊和白菜不能单独在一起，试求出他带一只羊，一条狼，一个白菜过河的方法。这样的题目小时候真的见过不少，虽然能够用笔头推导出来，但恰逢我最近在看算法之类的书，就想用这道题练练手，寻求其编程的解法。首先...
用python编写的一款小游戏，实现人狼羊菜过河
最新发布
05-17
总的来说，这款Python编写的"人狼羊菜过河"游戏是一个很好的教学示例，它结合了基础的编程概念和逻辑思维训练，对于学习Python编程和理解复杂问题解决策略的人来说具有很高的价值。同时，它也展示了Python在创建交互...
人狼羊菜渡河问题(含Matlab程序).doc
11-16
人狼羊菜渡河问题解决方案 人狼羊菜渡河问题是一种经典的计算机科学问题，它描述了一个人带着一条狼、一只羊、一筐白菜过河的过程，并且确保狼和羊、羊和白菜不能单独留在同岸，否则羊或白菜会被吃掉。该问题可以...
人狼羊问题
12-14
农夫需要把狼、羊、菜和自己运到河对岸去，只有农夫能够划船，而且船比较小，除农夫之外每次只能运一种东西，还有一个棘手问题，就是如果没有农夫看着，羊会偷吃菜，狼会吃羊。请考虑一种方法，让农夫能够安全地安排...
过河问题-狼羊人菜
wenkun_wang
04-09 6723
/* *功能：解决狼羊人过河问题 *作者：王文堃 *作者邮箱：wenkun_wang@163.com *创建时间：2016/4/5 *//* 问题描述：有一个人带着一匹狼、一头羊和白菜要过河 已知人每次过河只能带一样东西，狼和羊不能单独在一起 羊和菜不能单独在一起，求人过河的方案有几种？问题抽象：分别用m、w、g、c来表示人(men)、狼(wolf)、羊(goat)、菜(cabbage)问题的解决步
人、狼、羊、菜 过河问题
06-06
一个人带着一匹狼、一只羊和一筐白菜要自己划船从河的北岸过河到南岸。人不在时，狼会吃羊，羊会吃白菜。只有人会划船并且每次只能带一个对象过河。此程序解决如何过河
人羊菜以及狼的故事 .
weixin_34161064的博客
02-02 103
第一个问题：帮助男人用船把狼、羊、和一箱菜运送到河对面，船一次只能运一样，而且有苛刻的附加条件：当男人不在时，狼会吃羊，羊也会吃卷心菜。移动鼠标，开始解题吧 这个有游戏地址 ：http://www.chinaren.com/20050330/n224934721.shtml 没玩过的最好玩过再看我的代码，不懂的可以问我，写的比较乱。。。 一个有两个类，这个是主要的...
车羊问题c语言编程,C语言-人狼羊菜问题-最容易看懂的解决方法及代码
weixin_39638048的博客
05-18 266
题目描述：农夫需要把狼、羊、菜和自己运到河对岸去，只有农夫能够划船，而且船比较小，除农夫之外每次只能运一种东西，还有一个棘手问题，就是如果没有农夫看着，羊会偷吃菜，狼会吃羊。请考虑一种方法，让农夫能够安全地安排这些东西和他自己过河。想这个问题一连想了好几天，本人没有系统的学过算法，有些概念也不是很清楚，只因解决问题为目标。尝试过图论解决，但用floyed算法只能算出最短路径值，如何输出过程，一直没...
华为OD机试真题- 狼羊过河【2023Q2】【JAVA、Python、C++】
面试高手的博客
03-16 1620
一农夫带着m只羊，n只狼过河，农夫有一条可载x只狼/羊的船；农夫在时或者羊的数量大于狼时，狼不会攻击羊；农夫在不损失羊的情况下，运输几次可以完成运输？m 为羊的数量、n为狼的数量、x为可载狼和羊的数量。输入参数为 m, n , x;如果无法完成运输返回0；第三次：2只羊，1只狼。
人狼羊菜过河
BIG_kiss的博客
12-24 1612
一个人要将一匹狼、一只羊、一筐菜运到河对岸，但是他的船太小了，一次只能带一样过河。当他不在时，狼要吃羊、羊要吃菜。他怎样才能安全地将狼、羊、菜都运过河呢？ 请编写程序，找出过河的全部方案。 用 4 个字母分别表示人、狼、羊、菜的状态： 用 M 表示人在，用 . 表示人不在 用 W 表示狼在，用 . 表示狼不在 用 G 表示羊在，用 . 表示羊不在 用 C 表示菜在，用 . 表示菜不在 用 -> 表示船将从左岸去右岸，用 <- 表示船将从右岸去左岸。 举例说明： 若人狼羊菜全在左岸，则状态表示为
算法系列之十四：狼、羊、菜和农夫过河问题
java开发指南博客 【转载】
05-13 3254
题目描述：农夫需要把狼、羊、菜和自己运到河对岸去，只有农夫能够划船，而且船比较小，除农夫之外每次只能运一种东西，还有一个棘手问题，就是如果没有农夫看着，羊会偷吃菜，狼会吃羊。请考虑一种方法，让农夫能够安全地安排这些东西和他自己过河。 这个题目考察人的快速逻辑运算和短期记忆力。分析一下，在狼－》羊－》菜这个食物链条中，“羊”处在关键位置，解决问题的指导思想就是将“羊”与“狼”和“菜”始终处于隔离...
华为OD机试 - 羊、狼、农夫过河
01-12 655
华为OD机试 - 羊、狼、农夫过河
人、狼、羊、白菜过河问题（广度搜索）
qq_42577508的博客
10-19 3558
人、狼、羊、白菜过河问题（广度搜索） 大家好，我是小白莲，今天小白莲给大家分享的是广度搜索的应用之人、狼、羊、白菜过河问题，相信大家在小时候都听过这个有趣的思考题，没听过也没关系，大概是这样的： 初始状态：人、狼、羊、白菜都在左岸 目的：人、狼、羊、白菜都安全到达右岸 限制条件： 1.若人不在时，在同一岸，狼会吃羊，羊会吃白菜 2.每次过河人最多只能带一种生物（可以人独自过河）（当然狼、羊、白菜是...
请帮我修改一下人狼羊菜过河问题的代码
02-25
很高兴为您服务，我尽力给您修改一下人狼羊菜过河问题的代码。请根据您的需求，修改以下代码：// 人狼羊菜过河问题 int main() { // 定义变量 int farmer = 0; int wolf = 0; int goat = 0; int cabbage = 0; while (farmer != 1 || wolf != 1 || goat != 1 || cabbage != 1) { // 过河前 printf("Farmer: %d, Wolf: %d, Goat: %d, Cabbage: %d\n", farmer, wolf, goat, cabbage); int choice; printf("请输入您要搭乘的物品编号：\n"); scanf("%d", &choice); // 过河后 switch (choice) { case 0: farmer = 1 - farmer; break; case 1: wolf = 1 - wolf; break; case 2: goat = 1 - goat; break; case 3: cabbage = 1 - cabbage; break; } if ((wolf == goat && farmer == 0) || (goat == cabbage && farmer == 0)) { printf("无法完成！过河失败！\n"); break; } } if (farmer == 1 && wolf == 1 && goat == 1 && cabbage == 1) { printf("过河成功！\n"); } return 0; }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值