1021: 机器人走迷宫

题目描述

有一个愚蠢的机器人走进一个wh的迷宫,迷宫里有空地和陷阱。他想要访问迷宫的每个方格,但是它很笨,只会按照指令的方向走。当机器人不能走的时候,也就是下一步会遇到陷阱、迷宫边界或者访问过的格子,它会向右转90度(顺时针旋转90度,不能访问已经访问过的方格,且在原地只转一次,移动后可获得又一次旋转机会)。请问这个机器人最多可以经过多少个方格。
例如:
5 5
R
***





机器人可以经过25个格子,但是
2 3
**L


机器人只能经过3个格子。

输入

对于每组数据,第一行两个数w和h,表示迷宫的行和列(1<=w,h<=10)
接下来w行每行有h个字符用于描述这个迷宫。迷宫的‘.’表示空地,即为可以走的地方。‘*’表示陷阱,即为不能走的地方。迷宫中有一个英文字母,表示机器人的出发点,字母只有’U’,’D’,’L’,’R’四种。分别表示机器人的初始指令是向上,向下,向左,向右。

输出

对于每组数据,输出一个整数,即机器人一共经过多少个方格。

样例输入

2 3
U…
.*.
4 4
R…
..
.
.

样例输出

4
12

#include<bits/stdc++.h>
using namespace std;
char s[15][15];
int dir[][2]={-1,0,0,1,1,0,0,-1};///上右下左 
struct node{
	int x,y,sta;
}rear;
bool vis[15][15];
int main(){
	int w,h,sx,sy;
	while(scanf("%d%d",&w,&h)!=EOF){
		memset(vis,0,sizeof(vis));
		for(int i=0;i<w;i++){
		scanf("%s",s[i]);
		for(int j=0;j<h;j++){
			if(s[i][j]=='U'||s[i][j]=='D'||s[i][j]=='L'||s[i][j]=='R'){
				rear.x=i,rear.y=j;
				vis[i][j]=1;				
				if(s[i][j]=='U') rear.sta=0;
				if(s[i][j]=='R') rear.sta=1;
				if(s[i][j]=='D') rear.sta=2;
				if(s[i][j]=='L') rear.sta=3;	 	
			}
		}
	}
	int ans=1,flag=0; ///ans统计走过的步数 
	for(int i=rear.sta;i<4;){ ///第一个点给出前进的方向,初始值为rear.sta 
		while(1){  ///机器人一直往一个方向走 
			int xx=rear.x+dir[i][0];
			int yy=rear.y+dir[i][1];
			if(xx<0||xx>=w||yy<0||yy>=h||vis[xx][yy]||s[xx][yy]=='*'){
				flag++;
				break;
			}
			vis[xx][yy]=1;
			ans++;
			rear.x=xx;
			rear.y=yy;
			flag=0;
		}
		i=(i+1)%4;
		if(flag==2) break; ///当在一个位置停留两次时,循环结束 
	}
	printf("%d\n",ans);
	}
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
强化学习机器人走迷宫是一个经典的强化学习问题。在这个问题中,机器人需要在一个迷宫中找到出口。机器人可以采取不同的动作,例如向上、向下、向左或向右移动。机器人的目标是找到迷宫的出口,并且在此过程中最小化花费的步数。 为了实现这个问题,我们可以使用 Python 中的强化学习库,例如 OpenAI Gym 或者 PyTorch。我们需要定义一个 Robot 类,这个类将会实现机器人的移动和学习函数。在学习函数中,我们需要实现强化学习算法,例如 Q-learning 或者 Deep Q-Networks(DQN)算法。 在实现机器人走迷宫的过程中,我们需要使用迷宫类 Maze 来随机生成一个迷宫。我们可以使用基础搜索算法或者 DQN 算法来训练机器人。在基础搜索算法中,我们可以使用广度优先搜索(BFS)或深度优先搜索(DFS)算法来搜索迷宫。在 DQN 算法中,我们需要使用神经网络来估计每个动作的 Q 值,并且使用经验回放和目标网络来训练神经网络。 以下是一个基于 PyTorch 和 DQN 算法的机器人走迷宫的示例代码: ```python import os import random import numpy as np import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F from collections import deque from maze import Maze class DQNAgent: def __init__(self, state_size, action_size): self.state_size = state_size self.action_size = action_size self.memory = deque(maxlen=2000) self.gamma = 0.95 self.epsilon = 1.0 self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.learning_rate = 0.001 self.model = self._build_model() def _build_model(self): model = nn.Sequential( nn.Linear(self.state_size, 64), nn.ReLU(), nn.Linear(64, 64), nn.ReLU(), nn.Linear(64, self.action_size) ) optimizer = optim.Adam(model.parameters(), lr=self.learning_rate) model.compile(loss='mse', optimizer=optimizer) return model def remember(self, state, action, reward, next_state, done): self.memory.append((state, action, reward, next_state, done)) def act(self, state): if np.random.rand() <= self.epsilon: return random.randrange(self.action_size) else: return np.argmax(self.model.predict(state)) def replay(self, batch_size): minibatch = random.sample(self.memory, batch_size) for state, action, reward, next_state, done in minibatch: target = reward if not done: target = (reward + self.gamma * np.amax(self.model.predict(next_state)[0])) target_f = self.model.predict(state) target_f[0][action] = target self.model.fit(state, target_f, epochs=1, verbose=0) if self.epsilon > self.epsilon_min: self.epsilon *= self.epsilon_decay class Robot: def __init__(self, maze_size): self.maze = Maze(maze_size=maze_size) self.state_size = 2 self.action_size = 4 self.agent = DQNAgent(self.state_size, self.action_size) def run(self, episodes): for e in range(episodes): state = self.maze.reset() state = np.reshape(state, [1, self.state_size]) done = False i = 0 while not done: action = self.agent.act(state) next_state, reward, done = self.maze.step(action) next_state = np.reshape(next_state, [1, self.state_size]) self.agent.remember(state, action, reward, next_state, done) state = next_state i += 1 print("episode: {}/{}, steps: {}" .format(e, episodes, i)) if len(self.agent.memory) > 32: self.agent.replay(32) robot = Robot(maze_size=10) robot.run(episodes=1000) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值