csu 1510 Happy Robot（字符串DP，记忆化搜索）

最新推荐文章于 2024-10-13 22:12:51 发布
最新推荐文章于 2024-10-13 22:12:51 发布
阅读量633 收藏 1
点赞数
分类专栏： 动态规划 搜索 文章标签： ACM 搜索 dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/acm_cxq/article/details/52217627
版权

Happy RobotTime Limit: 1 Sec  Memory Limit: 128 MB
Submit: 182  Solved: 85
[Submit][Status][Web Board]

Description

Input

There will be at most 1000 test cases. Each case contains a command sequence with no more than 1000 characters.

Output

For each test case, print the case number, followed by minimal/maximal possible x (in this order), then the minimal/maximal possible y.

Sample Input

F?F
L??
LFFFRF

Sample Output

Case 1: 1 3 -1 1
Case 2: -1 1 0 2
Case 3: 1 1 3 3

题意：给一个字符串，包含有四种字符，F表示向前走，L表示在当前位置向左转，R表示在当前位置向右转，？表示执行上面三种任意一种都可以

机器人从(0,0)开始，输出x,y的最小值和最大值

思路：用记忆化搜索从后往前搜索，搜过的位置可以直接返回。DP里要保存在当前这个位置朝向某个方向极值

队友还提供了一种字符串DP的思路，其实也差不多。

关键在于此题不能在二维平面考虑，要在字符串上考虑才可以。

这里给出两个代码，记忆化搜索的方向是上下左右，字符串DP的方向是上右下左

代码1：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
#define N 1050
#define INF 99999999
struct Node
{
    int minx,maxx,miny,maxy;
} dp[N][4];
char a[N];
int vis[N][4];
int len;
int Min(int b,int c,int d)
{
    if(b>c) b=c;
    return b<d?b:d;
}
int Max(int b,int c,int d)
{
    if(b<c) b=c;
    return b>d?b:d;
}
Node dfs(int k,int f)
{
    if(vis[k][f]) return dp[k][f];
    vis[k][f]=1;
    dp[k][f].minx=dp[k][f].maxx=dp[k][f].miny=dp[k][f].maxy=0;
    if(k==len-1)
    {
        if(a[k]=='F')
        {
            if(f==0) dp[k][f].maxy=1,dp[k][f].miny=1;
            else if(f==1) dp[k][f].maxy=-1,dp[k][f].miny=-1;
            else if(f==2) dp[k][f].minx=-1,dp[k][f].maxx=-1;
            else dp[k][f].minx=1,dp[k][f].maxx=1;
        }
        else if(a[k]=='?')
        {
            if(f==0) dp[k][f].maxy=1;
            else if(f==1) dp[k][f].miny=-1;
            else if(f==2) dp[k][f].minx=-1;
            else dp[k][f].maxx=1;
        }
    }
    else
    {
        if(a[k]=='L')
        {
            if(f==0) dp[k][f]=dfs(k+1,2);
            else if(f==1) dp[k][f]=dfs(k+1,3);
            else if(f==2) dp[k][f]=dfs(k+1,1);
            else dp[k][f]=dfs(k+1,0);
        }
        else if(a[k]=='R')
        {
            if(f==0) dp[k][f]=dfs(k+1,3);
            else if(f==1) dp[k][f]=dfs(k+1,2);
            else if(f==2) dp[k][f]=dfs(k+1,0);
            else dp[k][f]=dfs(k+1,1);
        }
        else if(a[k]=='F')
        {
            if(f==0)
            {
                dp[k][f]=dfs(k+1,0);
                dp[k][f].maxy++;
                dp[k][f].miny++;
            }
            else if(f==1)
            {
                dp[k][f]=dfs(k+1,1);
                dp[k][f].miny--;
                dp[k][f].maxy--;
            }
            else if(f==2)
            {
                dp[k][f]=dfs(k+1,2);
                dp[k][f].minx--;
                dp[k][f].maxx--;
            }
            else
            {
                dp[k][f]=dfs(k+1,3);
                dp[k][f].maxx++;
                dp[k][f].minx++;
            }
        }
        else
        {
            Node b,c,d,e;
            if(f==0)
            {
                b=dfs(k+1,0);
                b.maxy++; b.miny++;
                c=dfs(k+1,2);
                d=dfs(k+1,3);
                dp[k][f].minx=Min(b.minx,c.minx,d.minx);
                dp[k][f].maxx=Max(b.maxx,c.maxx,d.maxx);
                dp[k][f].miny=Min(b.miny,c.miny,d.miny);
                dp[k][f].maxy=Max(b.maxy,c.maxy,d.maxy);
            }
            else if(f==1)
            {
                b=dfs(k+1,1);
                b.maxy--;  b.miny--;
                c=dfs(k+1,3);
                d=dfs(k+1,2);
                dp[k][f].minx=Min(b.minx,c.minx,d.minx);
                dp[k][f].maxx=Max(b.maxx,c.maxx,d.maxx);
                dp[k][f].miny=Min(b.miny,c.miny,d.miny);
                dp[k][f].maxy=Max(b.maxy,c.maxy,d.maxy);
            }
            else if(f==2)
            {
                b=dfs(k+1,2);
                b.maxx--; b.minx--;
                c=dfs(k+1,1);
                d=dfs(k+1,0);
                dp[k][f].minx=Min(b.minx,c.minx,d.minx);
                dp[k][f].maxx=Max(b.maxx,c.maxx,d.maxx);
                dp[k][f].miny=Min(b.miny,c.miny,d.miny);
                dp[k][f].maxy=Max(b.maxy,c.maxy,d.maxy);
            }
            else
            {
                b=dfs(k+1,3);
                b.maxx++; b.minx++;
                c=dfs(k+1,0);
                d=dfs(k+1,1);
                dp[k][f].minx=Min(b.minx,c.minx,d.minx);
                dp[k][f].maxx=Max(b.maxx,c.maxx,d.maxx);
                dp[k][f].miny=Min(b.miny,c.miny,d.miny);
                dp[k][f].maxy=Max(b.maxy,c.maxy,d.maxy);
            }
        }
    }
    return dp[k][f];
}
int main()
{
    int cas=1;
    while(~scanf("%s",a))
    {
        len=strlen(a);
        memset(vis,0,sizeof(vis));
        Node ans=dfs(0,3);
        printf("Case %d: %d %d %d %d\n",cas++,ans.minx,ans.maxx,ans.miny,ans.maxy);
    }
    return 0;
}

代码2:

#include<iostream>
#include<cstdio>
#include<cstring>
#define max(a,b) (a) > (b) ? (a) : (b)
#define min(a,b) (a) < (b) ? (a) : (b)
using namespace std;

const int maxn = 1005;
const int inf = 0x3f3f3f3f;
int dp[maxn][4],n;
char str[maxn];

int MAX(int a,int b,int c,int d)
{
	return max(a,max(b,max(c,d)));
}

int MIN(int a,int b,int c,int d)
{
	return min(a,min(b,min(c,d)));
}

void DP1()
{
	for(int i = 0; i < n; i++)
		for(int j = 0; j < 4; j++)
			dp[i][j] = inf;
	if(str[0] == 'F')
		dp[0][1] = 1;
	else if(str[0] == 'L')
		dp[0][0] = 0;
	else if(str[0] == 'R')
		dp[0][2] = 0;
	else 
	{
		dp[0][0] = 0;
		dp[0][1] = 1;
		dp[0][2] = 0;
	}
	for(int i = 1; i < n; i++)
		for(int j = 0; j < 4; j++) //上一个指令执行后的方向
		{
			if(str[i] == 'F') //前进	
			{
				if(j == 0) //向上
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else if(j == 1) //向右
					dp[i][j] = min(dp[i][j],dp[i-1][j] + 1);
				else if(j == 2) //向下
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else //向左
					dp[i][j] = min(dp[i][j],dp[i-1][j] - 1);
			}
			else if(str[i] == 'L')
			{
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
			else if(str[i] == 'R')
			{
				int d = (j + 1) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
			else
			{
				if(j == 0) //向上
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else if(j == 1) //向右
					dp[i][j] = min(dp[i][j],dp[i-1][j] + 1);
				else if(j == 2) //向下
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else //向左
					dp[i][j] = min(dp[i][j],dp[i-1][j] - 1);
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
				d = (j + 1) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
		}
}

void DP2()
{
	for(int i = 0; i < n; i++)
		for(int j = 0; j < 4; j++)
			dp[i][j] = -inf;
	if(str[0] == 'F')
		dp[0][1] = 1;
	else if(str[0] == 'L')
		dp[0][0] = 0;
	else if(str[0] == 'R')
		dp[0][2] = 0;
	else 
	{
		dp[0][0] = 0;
		dp[0][1] = 1;
		dp[0][2] = 0;
	}
	for(int i = 1; i < n; i++)
		for(int j = 0; j < 4; j++) //上一个指令执行后的方向
		{
			if(str[i] == 'F') //前进	
			{
				if(j == 0) //向上
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else if(j == 1) //向右
					dp[i][j] = max(dp[i][j],dp[i-1][j] + 1);
				else if(j == 2) //向下
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else //向左
					dp[i][j] = max(dp[i][j],dp[i-1][j] - 1);
			}
			else if(str[i] == 'L')
			{
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
			else if(str[i] == 'R')
			{
				int d = (j + 1) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
			else
			{
				if(j == 0) //向上
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else if(j == 1) //向右
					dp[i][j] = max(dp[i][j],dp[i-1][j] + 1);
				else if(j == 2) //向下
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else //向左
					dp[i][j] = max(dp[i][j],dp[i-1][j] - 1);
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
				d = (j + 1) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
		}
}

void DP3()
{
	for(int i = 0; i < n; i++)
		for(int j = 0; j < 4; j++)
			dp[i][j] = inf;
	if(str[0] == 'F')
		dp[0][1] = 0;
	else if(str[0] == 'L')
		dp[0][0] = 0;
	else if(str[0] == 'R')
		dp[0][2] = 0;
	else 
	{
		dp[0][0] = 0;
		dp[0][1] = 0;
		dp[0][2] = 0;
	}
	for(int i = 1; i < n; i++)
		for(int j = 0; j < 4; j++) //上一个指令执行后的方向
		{
			if(str[i] == 'F') //前进	
			{
				if(j == 0) //向上
					dp[i][j] = min(dp[i][j],dp[i-1][j] + 1);
				else if(j == 1) //向右
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else if(j == 2) //向下
					dp[i][j] = min(dp[i][j],dp[i-1][j] - 1);
				else //向左
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
			}
			else if(str[i] == 'L')
			{
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
			else if(str[i] == 'R')
			{
				int d = (j + 1) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
			else
			{
				if(j == 0) //向上
					dp[i][j] = min(dp[i][j],dp[i-1][j] + 1);
				else if(j == 1) //向右
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else if(j == 2) //向下
					dp[i][j] = min(dp[i][j],dp[i-1][j] - 1);
				else //向左
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
				d = (j + 1) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
		}
}

void DP4()
{
	for(int i = 0; i < n; i++)
		for(int j = 0; j < 4; j++)
			dp[i][j] = -inf;
	if(str[0] == 'F')
		dp[0][1] = 0;
	else if(str[0] == 'L')
		dp[0][0] = 0;
	else if(str[0] == 'R')
		dp[0][2] = 0;
	else 
	{
		dp[0][0] = 0;
		dp[0][1] = 0;
		dp[0][2] = 0;
	}
	for(int i = 1; i < n; i++)
		for(int j = 0; j < 4; j++) //上一个指令执行后的方向
		{
			if(str[i] == 'F') //前进	
			{
				if(j == 0) //向上
					dp[i][j] = max(dp[i][j],dp[i-1][j] + 1);
				else if(j == 1) //向右
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else if(j == 2) //向下
					dp[i][j] = max(dp[i][j],dp[i-1][j] - 1);
				else //向左
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
			}
			else if(str[i] == 'L')
			{
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
			else if(str[i] == 'R')
			{
				int d = (j + 1) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
			else
			{
				if(j == 0) //向上
					dp[i][j] = max(dp[i][j],dp[i-1][j] + 1);
				else if(j == 1) //向右
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else if(j == 2) //向下
					dp[i][j] = max(dp[i][j],dp[i-1][j] - 1);
				else //向左
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
				d = (j + 1) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
		}
}

int main()
{
	int cas = 1;
	while(scanf("%s",str)!=EOF)
	{
		n = strlen(str);
		DP1();
		printf("Case %d: %d ",cas++,MIN(dp[n-1][0],dp[n-1][1],dp[n-1][2],dp[n-1][3]));
		DP2();
		printf("%d ",MAX(dp[n-1][0],dp[n-1][1],dp[n-1][2],dp[n-1][3]));
		DP3();
		printf("%d ",MIN(dp[n-1][0],dp[n-1][1],dp[n-1][2],dp[n-1][3]));
		DP4();
		printf("%d\n",MAX(dp[n-1][0],dp[n-1][1],dp[n-1][2],dp[n-1][3]));
	}
	return 0;
}






pwn格式化字符串漏洞小结
PLpa的博客
11-30 2671
格式化字符串漏洞 0x00.前言 在pwn中，格式化字符串漏洞是一个非常基础的漏洞，他通常穿插在各种漏洞之中。比如，当程序开了PIE保护时，在栈溢出之前，我们先可以运用格式化字符串漏洞获取栈中的信息；通过格式化字符串漏洞的任意地址写，我们可以把栈帧劫持到堆地址上；我们甚至可以直接通过任意地址写，劫持got表，实现getshell…… 总而言之，格式化字符串漏洞虽然在目前市面上的软件中比较难以看到，...
NYOJ564 & CSU 1106 最优对称路径【记忆化搜索+最短路】
AC_Dreameng
08-18 1309
最优对称路径 时间限制：1000 ms  |  内存限制：65535 KB 难度：3 描述     给一个 n 行 n 列的网格，每个格子里有一个 1 到 9 的数字。你需要从左上角走到右下角，其中每一步只能往上、下、左、右四个方向之一走到相邻格子，不能斜着走，也不能走出网格，但可以重复经过一个格子。为了美观，你经过的路径还必须关于“左下-右上”这条对角线对称。下图是一
csu1510(规律)
远方传来风铃
08-26 423
题意：从（0，0）开始在坐标上移动，问x,y分别可以移动到的位置的最小值和最大值，有四种移动方式： F:在当前面对的方向移动一格，一共四个方向，自然是坐标轴的上下左右四个方向，这代表着每次只有x变化或者只有y变化 L:当前方向向左转90度，比如面对着x轴正方向转为y轴正方向 R:向右转90度 ?:这个代表着这个命令由你定，你可以执行上述三个命令中任何一个，当然为了得到极值选哪个命令就是这道
csu1510 Happy Robot 递推
旧时光
08-23 1206
题目链接： csu1510 解题思路： 要求解四个值x_min,x_max,y_min,y_max 首先考虑x_min如何得到：因为机器人最后有可以面向四个方向（E,W,N,S），我们可以用一个数组a[4]来存机器人面向4个方向时x的值 a[0]: x+，a[1]:x-，a[2]:y+,a[3],y-; 只要求出a[4]最后比较出最小值,即为x_mi
CSU 1510 Happy Robot DP
Houheshuai的专栏
05-02 444
Happy Robot Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 147  Solved: 68 [Submit][Status][Web Board] Description Input There will be at most 1000 test cases. Each case c
CSU 1510 Happy Robot(字符串上的dp)
hexianhao的博客
08-16 565
Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 182  Solved: 85 [Submit][Status][Web Board] Description Input There will be at most 1000 test cases. Each case contains a command sequ
湖南14年省赛 H - Happy Robot dp
转角的守望
08-24 723
A robot is moving from (0,0) according to a command sequence. Each character in the sequence is command: • L: turn left • R: turn right • F: go forward one step Interestingly, the command sequenc
字符编码，国际化编程、高级字符串
weixin_43698704的博客
01-30 226
一、字符编码： 文件的写入读出使用的编码必须统一否则会出现乱码。 new OutputStreamWriter(fos, charset); new InputStreamReader(fos, charset); 编码方式charset保持一致。 二、国际化编程 一般是使用java.util.ResourceBundle用于加载语言_国家语言包 java.util.Locale定...
字符串hash笔记
weixin_37964310的博客
04-25 455
（该笔记整理自远航休息栈：点击打开链接）字符串hash可以将字符串映射为整数类型，使得可以快速的匹配字符串首先选择一个适当的进制，要比字符串中字母对应的数字大（一般a-z对应1-26），且不要含有模数的质因子。//对于只有a-z的字符串，27，131，233等可以。选择一个模数（尽量是质数)自然溢出hash：将整数类型定义为unsigned long long，并且hash值&amp; 0x7ff...
芯海CSU32MX10系列DEMO程序_CSU32MX10_C++_troopseh6_芯海_DEMO_
10-03
1. **初始化代码**：DEMO程序通常会包含设备初始化过程，如设置时钟、配置GPIO、初始化内存和外设接口等，以确保MCU能正常运行。 2. **示例应用**：为了展示MCU的功能，DEMO可能包含一些简单的应用示例，如LED闪烁...
2014年湖南省第十届程序设计大赛 H Happy Robot
u012659423的专栏
10-30 1206
题意： 给你一串由L,R,F,?组成的字符串，L表示
python记忆化搜索——缓存@cache与@lru_cache
我的博客
09-05 8138
python缓存机制
记忆化搜索 （蒟蒻练习生）
cyyyyds857的博客
11-05 347
记忆化搜索是一种通过记录已经遍历过的状态的信息，从而避免对同一状态重复遍历的搜索实现方式。因为记忆化搜索确保了每个状态只访问一次，它也是一种常见的动态规划实现方式。
蓝桥 python笔记11——DFS深度优先搜索、回溯、剪枝、记忆化搜索
m0_62861576的博客
03-18 523
【代码】蓝桥 python笔记11——DFS深度优先搜索、回溯、剪枝、记忆化搜索。
记忆化搜索
m0_52711790的博客
10-28 1878
对于学计算机的同学来说，学习算法是一件非常重要的事情，废话不多讲，我们来讲讲“记忆化搜索问题”。
leetcode单词拆分python-动态规划和记忆化搜索
苏钟白的博客
03-17 896
动态规划与记忆化搜索
算法竞赛（Python）-AI的思维模式（搜索）
最新发布
总裁余（余登武）博客
10-13 1198
算法竞赛（Python）-AI的思维模式（搜索）
记忆化搜索（例）
weixin_34043301的博客
07-16 308
前言：记忆化搜索是在递归的基础上进行优化，这种方法综合了搜索和动态规划两方面的优点。 记忆化搜索的思想是：在搜索过程中，会有很多重复计算,如果我们能记录一些状态的答案，就可以减少重复搜索量。 实现方式 ①定义好一个数组，用来存储递归所求出来的值，以便接下来进行访问； ②在主程序里，memset一下，一般都是赋初值为-1，然后把这个数组的边界值设置好； ③在递归函数里，首先加一句：if （...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值