1010: 机器人走迷宫

实现代码:

#include <iostream>
#include <stdio.h>
#include <string.h> 
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Status{
	int x,y;
	int t;
	int d; 
};

queue<Status> Q; 
bool mark[20][20] = {false};
char maze[20][20];

int getDr(char c){// 获得朝向 
	switch(c){
		case 'U':
			return 0;
		case 'R':
			return 1;
		case 'D':
			return 2;
		case 'L':
			return 3;		
	} 
} 

bool result(int x,int y){  // 判断当前位置是否是结果 
	if(mark[x-1][y]==true&&mark[x+1][y]==true&&mark[x][y-1]==true&&mark[x][y+1]==true){
		return true;
	}
	return false;
}

void getNextLocation(int *x,int* y,Status &s){
	if(s.d==0){
		*x = s.x-1;
		*y = s.y;
		return;
	}
	if(s.d==1){
		*x = s.x;
		*y = s.y+1;
		return;
	}
	if(s.d==2){
		*x = s.x+1;
		*y = s.y;
		return;
	}
	if(s.d==3){
		*x = s.x;
		*y = s.y-1;
		return;
	}
}

int BFS(int w,int h){
	while(!Q.empty()){
		Status cur = Q.front();
		Q.pop();
		if(result(cur.x,cur.y))return cur.t; // 在BFS中 要弄清楚目标状态是什么  如果是目标状态 返回结果
		 
		int nx;
		int ny;
		getNextLocation(&nx,&ny,cur);
		if(mark[nx][ny]==true||maze[nx][ny]=='*'){
			mark[nx][ny] = true;
			cur.d = (cur.d+1)%4; // 右转
			Q.push(cur);
			continue; 
		}else{
			mark[nx][ny] = true;
			cur.x = nx;
			cur.y = ny;
			cur.t = cur.t+1;
			Q.push(cur);
			continue;
		}
		
	}
	return 1;
}


int main(int argc, char** argv) {
	int w,h;
	while(scanf("%d%d",&w,&h)){
		// 清空上一次的数据 
		while (!Q.empty()) {
			Q.pop();
		}
		for (int i = 0; i < 20; i++) {
			for (int j = 0; j < 20; j++) {
				mark[i][j] = false;
				maze[i][j] = 0;
			}
		}
		
		// 进入这一次的输入 
		for(int i=1;i<=w;i++){
			scanf("%s",maze[i]+1);
		}
	
		mark[1][1] = true;
		for(int i=0;i<=w+1;i++){
			mark[i][0] = true;
			mark[i][h+1] = true;
		}
		for(int j=0;j<=h+1;j++){
			mark[0][j] = true;
			mark[w+1][j] = true;
		}
		
	
		Status temp;
		temp.x=temp.y=temp.t=1;
		temp.d = getDr(maze[1][1]);
		Q.push(temp);
		int ret = BFS(w,h);
		printf("%d\n",ret);
		//printf("%c",maze[1][1]); 
	}

	return 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、付费专栏及课程。

余额充值