URAL-1101. Robot in the Field

最新推荐文章于 2024-10-01 18:52:56 发布
最新推荐文章于 2024-10-01 18:52:56 发布
阅读量364 收藏
点赞数
分类专栏： 动态规划 栈 URAL 文章标签： URAL 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/EverydayIsLife/article/details/77887619
版权

1、知识点：动态规划
2、思路：此题最大的难点恐怕还是表达式处理，我用的是栈，代码比较长，但注释比较详细。

/*
*/

#include <stdio.h>
#include <string.h>
#include <string>
#include <stack>
using namespace std;
#define MAXN 100+10                     //N,M,K最大值 
#define MAXEXPRELEN 250+10

struct Point{                           //点 
    int x;
    int y;
    int dir;                            //标记到当前点的方向 
};
Point fork_point[MAXN];                 //分叉点 
Point cur_poi;                          //当前点 

struct Invert{                          //定义转换点
    int a;
    int b;
    char c[5];
};
Invert inv[MAXN];                       //转换点                        
char sent[MAXEXPRELEN];                 //表达式 
int reg_arr[26+5];                      //寄存器数组 
int N,                                  //field
    M,                                  //fork 
    K;                                  //register-invert-point

int get_val(const char *formu);         //计算表达式的值 
int get_pri(string str);                //获取优先级 
bool is_fork();                         //判断当前点是否分叉 
void next_posi(int res, Point &poi);    //根据当前点计算下一个位置
bool is_out(Point poi);                 //检查新点是否出界 
bool is_invert(int &reg);               //检查当前点是否转换点,若是可得寄存器编号 
int main()
{
    memset(reg_arr, 0, sizeof(reg_arr));
    gets(sent);
    scanf("%d%d%d", &N, &M, &K);
    for(int i=0; i<M; i++)
        scanf("%d%d", &(fork_point[i].x), &(fork_point[i].y));

    for(int j=0; j<K; j++)
        scanf("%d%d%s", &(inv[j].a), &(inv[j].b), &(inv[j].c));

    cur_poi.x = 1;
    cur_poi.y = 0;
    cur_poi.dir = 1;                        //(0,0)->(1,0):右
    printf("%d %d\n", 0, 0);
    printf("%d %d\n", 1, 0);
    Point new_poi;
    int inv_reg;                            //转换的寄存器编号 
    for(;;){
        int res = -1;                       //默认直走 
        if(is_fork())                       //如果站在分叉点 
            res = get_val(sent);            //左，右？ 

        if(is_invert(inv_reg))              //如果站在转换点 
            reg_arr[inv_reg] = 1 - reg_arr[inv_reg];

        next_posi(res, new_poi);            //计算下一个点 
        bool ch = is_out(new_poi);          //检查新点是否出界 
        if(!ch){
            printf("%d %d\n", new_poi.x, new_poi.y);
            cur_poi.x = new_poi.x;
            cur_poi.y = new_poi.y;
            cur_poi.dir = new_poi.dir;
        }
        else
            break;
    }

    return 0;
}

int get_val(const char *formu)
{
    string expre = formu; 
    expre += "#";
    int len = expre.length();
    stack<string> sym;
    stack<string> oper;
    string str="";              //临时字符串 
    string top_str="";          //栈顶运算符
    string top_oper="";         //栈顶操作数 
    int str_len=0;
    sym.push("#");
    for(int i=0; i<len; i++){
        str += expre[i];
        str_len++;
        if(str == " "){                             //如果是空格 
            str = ""; 
            str_len = 0;
            continue;
        }
        if(isalpha(str[0])){
            int j;
            for(j=i+1; j<len; j++)
                if(isalpha(expre[j])){
                    str += expre[j];
                    str_len++;
                }
                else
                    break;
            i = j-1;                                //其它字符，i移至最后一个有效字符 
        }

        if( str=="TRUE" || str=="FALSE" || 
            (isalpha(str[0]) && str_len == 1))      //寄存器或真值 
            oper.push(str);
        else{                                       //操作符 或 括号 
            if(get_pri(str) > get_pri(sym.top()) ||
                (sym.top()=="("&&str!=")") || str=="NOT")//>栈顶优先级 或 栈顶是左括号 或 "NOT"（NOT是右结合） 
                sym.push(str);
            else if(sym.top()=="(" && str==")")
                sym.pop();
            else{                                   //<栈顶优先级 或 右括号 或 "#" 
                while(sym.top()!="#" && get_pri(str)<=get_pri(sym.top()) && sym.top()!="("){
                    bool res = 0;                   //临时结果
                    string res_str = "";            //临时结果的字符串形式（TRUE,FALSE） 
                    top_str = sym.top();            //弹出栈顶运算符 
                    sym.pop();
                    top_oper = oper.top();          //弹出第一个操作数 
                    oper.pop();
                    if(top_str == "NOT"){           //单操作数 （只有NOT一个） 
                        if(top_oper == "TRUE")
                            res = 0;
                        else if(top_oper == "FALSE")
                            res = 1;
                        else
                            res = 1 - reg_arr[top_oper[0] - 'A'];
                    }
                    else{                           //双操作数 
                        string sec_oper = oper.top();       //第二个操作数 
                        oper.pop();
                        if(top_str == "AND"){               //AND
                            if(top_oper == "TRUE"){
                                if(sec_oper == "TRUE")
                                    res = 1;
                                else if(sec_oper == "FALSE")
                                    res = 0;
                                else
                                    res = reg_arr[sec_oper[0] - 'A'];
                            }
                            else if(top_oper == "FALSE")
                                res = 0;
                            else{                           //第一个操作数是寄存器 
                                if(!reg_arr[top_oper[0] - 'A'])
                                    res = 0;
                                else{
                                    if(sec_oper == "TRUE")
                                        res = 1;
                                    else if(sec_oper == "FALSE")
                                        res = 0;
                                    else
                                        res = reg_arr[sec_oper[0] - 'A'];
                                }
                            } 
                        }
                        else{                               //OR
                            if(top_oper == "TRUE")
                                res = 1;
                            else if(top_oper == "FALSE"){
                                if(sec_oper == "TRUE")
                                    res = 1;
                                else if(sec_oper == "FALSE")
                                    res = 0;
                                else
                                    res = reg_arr[sec_oper[0] - 'A'];
                            }
                            else{                           //第一个操作数是寄存器 
                                if(reg_arr[top_oper[0] - 'A'])
                                    res = 1;
                                else{                       //第一个操作数为0 
                                    if(sec_oper == "TRUE")
                                        res = 1;
                                    else if(sec_oper == "FALSE")
                                        res = 0;
                                    else
                                        res = reg_arr[sec_oper[0] - 'A']; 
                                }
                            }
                        }
                    }

                    if(res == 1)
                        res_str = "TRUE";           //运算结果转换为字符串压栈 
                    else
                        res_str = "FALSE";
                    oper.push(res_str);
                    if(str==")" && sym.top()=="("){ //遇到左括号退出循环 
                        sym.pop();
                        break;
                    }
                }

                if(str != ")") 
                    sym.push(str);                  //str入栈 
            }
        }
        str = "";
        str_len = 0;
    }
    if(!oper.empty()){
        string lst = oper.top();
        if(lst == "TRUE")
            return 1;
        else if(lst == "FALSE")
            return 0;
        else
            return reg_arr[lst[0] - 'A'];   
    }
    else{
        printf("oper stack is empty!");
        return false;
    }
}

int get_pri(string str)
{
    int num = 6;
    string prim[num] = {"#", ")", "OR", "AND", "NOT", "("};
    for(int i=0; i<num; i++)
        if(prim[i] == str)
            return i;

    return -1;
}

bool is_fork()                  //判断当前点是否分叉 
{
    for(int i=0; i<M; i++)
        if(cur_poi.x == fork_point[i].x && cur_poi.y == fork_point[i].y)
            return true;

    return false; 
} 

void next_posi(int res, Point &poi)         //计算下一个位置 
{
    int dir = cur_poi.dir;                  //到当前点的方向 
    if(res == 1){                           //右拐 
        if(dir == 0){                       //原左 
            poi.x = cur_poi.x;
            poi.y = cur_poi.y+1;
            poi.dir = 2;
        }
        else if(dir == 1){                  //原右 
            poi.x = cur_poi.x;
            poi.y = cur_poi.y-1;
            poi.dir = 3;
        }
        else if(dir == 2){                  //原上 
            poi.x = cur_poi.x+1;
            poi.y = cur_poi.y; 
            poi.dir = 1;
        }
        else{                               //原下 
            poi.x = cur_poi.x-1;
            poi.y = cur_poi.y;
            poi.dir = 0;
        }
    }
    else if(res == 0){                      //左拐 
        if(dir == 0){
            poi.x = cur_poi.x;
            poi.y = cur_poi.y-1;
            poi.dir= 3;
        }
        else if(dir == 1){
            poi.x = cur_poi.x;
            poi.y = cur_poi.y+1;
            poi.dir = 2;
        }
        else if(dir == 2){
            poi.x = cur_poi.x-1;
            poi.y = cur_poi.y;
            poi.dir = 0;
        }
        else{
            poi.x = cur_poi.x+1;
            poi.y = cur_poi.y;
            poi.dir = 1;
        }
    }
    else{                                   //直走 
        if(dir == 0){
            poi.x = cur_poi.x-1;
            poi.y = cur_poi.y;
        }
        else if(dir == 1){
            poi.x = cur_poi.x+1;
            poi.y = cur_poi.y;
        }
        else if(dir == 2){
            poi.x = cur_poi.x;
            poi.y = cur_poi.y+1;
        }
        else{
            poi.x = cur_poi.x;
            poi.y = cur_poi.y-1;
        }
        poi.dir = dir;
    }
}

bool is_out(Point poi)                  //检查(x,y)是否出界 
{
    if(poi.x<-N || poi.x>N || poi.y<-N || poi.y>N)
        return true;
    else
        return false;
}

bool is_invert(int &reg)                //检查当前点是否转换点，若是，引用带回寄存器编号 
{
    for(int i=0; i<K; i++)
        if(cur_poi.x == inv[i].a && cur_poi.y == inv[i].b){
            reg = inv[i].c[0] - 'A';
            return true;
        }

    return false; 
}
bzoj AC倒序
weixin_30819085的博客
08-23 2万+
Search GO 说明：输入题号直接进入相应题目，如需搜索含数字的题目，请在关键词前加单引号 Problem ID Title Source AC Submit Y 1000 A+B Problem 10983 18765 Y 1036 [ZJOI2008]树的统计Count 5293 13132 Y 1588 [HNOI2002]营业额统计 5056 13607 100...
PART II THE URAL-ALTAIC HYPOTHESIS CHAPTER IV. THE URAL-ALTAIC HYPOTHESIS AND TUNGUS MATERIAL (1931年)
04-27
28. The Theoretical Background of the Ural-Altale Hypothesis The hypothesis of common origin of the Altaic languages,and even the Ural-Altaic languages,dates from the first half of the last century....
ural 1101(Robot in the Field )表达式求值
qq_36398723的博客
11-12 229
题目链接：点击打开链接 很水的模拟题，英语水平不行~~刚开始题目里面的invert没看懂，然后一直WA~~~OrzOrzOrzOrz 题目给定一个[-N-N]*[-N*N]的场地，题目中有一些拐弯点，根据boolean表达式的值判断向右转还是向左转~ 还有一些点，能使机器人的某个寄存器指令翻转（就是这里题意读错了,Orz），刚开始机器人的全部指令为空，第一次遇到某个指令时候对应的寄存器打开，
URAL 1100
weixin_30640769的博客
07-27 126
Problem Description Old contest software uses bubble sort for generating final standings. But now, there are too many teams and that software works too slow. You are asked to write a program, which...
URAL 做题记录 V2
站稳脚跟学做人！
08-12 4113
题号 标题 难度系数 算法 1100 Final Standings 50% 反复统计 1101 Robot in the field 30% 表达式求值 1102 Strange Dialog 60% 动态规划或语法图 1103 Pencils and Circl
字符串专项：Ural 1102
bly
06-28 707
这题刚开始不是MLE就是RE，后来发现用string就没问题，不知道是什么机理……本来是用回溯法做的，结果各种WA，上网搜了下，发现有说什么有限状态自动机，完全不懂……然后发现用模拟也可以做，从后向前判断，否则相当复杂。 #include #include #include using namespace std; string s; int main() { int n;
ACM算法专题
Tizzi的博客
01-06 1208
专题一 简单搜索 POJ 1321 棋盘问题 POJ 2251 Dungeon Master POJ 3278 Catch That Cow POJ 3279 Fliptile POJ 1426 Find The Multiple POJ 3126 Prime Path POJ 3087 Shuffle'm Up POJ 3414 Pots FZU 2150 Fire Game UVA 11624...
uva 工具网站 顶 顶！！！
Kizuki
07-27 3458
Online Judge System 源起 「Association for Computing Machinery (ACM) 」是一個致力於電腦科學教育的協會，出版大量專業期刊、文獻，舉辦重大的計算機科學會議，在資訊界舉足輕重、名聞遐邇。 ACM 每年度都會舉辦一次「The ACM-ICPC International Collegiate Programming Contest (A
Python库 | ural-0.28.0.tar.gz
04-18
资源分类：Python库 所属语言：Python 资源全名：ural-0.28.0.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
spssw-184.zip
05-13
and the National Geographic Society[5] as 4/5 of the landmass of Eurasia – with the western portion of the latter occupied by Europe – located to the east of the Suez Canal, east of the Ural ...
Ural-开源
04-27
文件列表中的"ural-0.3.4"可能表示Ural库的一个具体版本。版本号通常遵循语义化版本控制，意味着0.3.4可能代表一个稳定版，其中的"3"可能是主要功能的版本，"4"可能是对前一版本的次要更新或错误修复。 总的来说，...
URAL-PHA
10-24
URAL-PHA是一个与字体相关的主题。在这个压缩包中，我们看到只有一个文件名“2238”，这可能是某种特定字体的文件或者一个包含了多个字体文件的集合。在IT行业中，字体设计是用户界面和视觉传达的重要组成部分，尤其...
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 3224
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
优化A星算法：动态加权代价函数提升搜索效率，内切圆平滑非光滑转折，减少冗余路径与节点，大幅降低路径长度与提升平滑性 · 启发式搜索 高效版
05-31
内容概要：本文详细介绍了如何通过改进A星算法来优化路径搜索和路径平滑性。首先，提出了动态加权代价函数的概念，通过为不同的路径因素分配权重值，使算法能够更精确地评估节点代价，减少无关节点的搜索。其次，采用启发式搜索策略和剪枝算法去除冗余路径点和路段，降低了路径长度。最后，利用内切圆平滑技术优化路径的转折角，提高了路径的平滑性和连续性。实验结果显示，改进后的A星算法在复杂环境中显著提升了路径规划的效率和质量。 适合人群：从事路径规划、自动驾驶、机器人导航等领域研究的技术人员和研究人员。 使用场景及目标：适用于需要高效路径规划的应用场景，如无人驾驶车辆、无人机飞行路径规划、物流配送机器人等。目标是提高路径规划的效率，减少冗余路径，提升路径平滑性和连续性。 其他说明：文中提供了部分代码实现，帮助读者更好地理解和应用改进后的A星算法。未来的研究方向包括将更多人工智能技术融入路径规划，以实现更智能、高效的导航系统。
医疗保险领域_基于知识图谱与自然语言处理技术_包含疾病诊断编码医保报销政策药品目录医疗机构信息的_用于智能医保咨询费用预测政策解读和医疗资源推荐的综合性知识图谱系统_支持.zip
05-31
医疗保险领域_基于知识图谱与自然语言处理技术_包含疾病诊断编码医保报销政策药品目录医疗机构信息的_用于智能医保咨询费用预测政策解读和医疗资源推荐的综合性知识图谱系统_支持.zip
基于COMSOL平台的块石路基水热力耦合与冻胀变形模拟研究
05-31
内容概要：本文主要探讨了利用COMSOL Multiphysics软件对块石路基进行水热力耦合及冻胀变形的模拟研究。首先介绍了COMSOL软件的特点及其在岩石工程中的应用，随后详细阐述了水热力耦合分析的方法，即通过建立三维模型来模拟水分迁移、热量传递和应力变化之间的相互作用。接着讨论了冻胀变形的具体机制，特别是在寒冷地区，当温度低于冰点时，水分冻结引起的体积膨胀对块石路基的影响。最后，通过对模拟结果的分析，展示了水分迁移规律、温度场变化及应力分布情况，并提出了对未来研究方向的展望。 适合人群：从事工程地质学、土木工程及相关领域的研究人员和技术人员。 使用场景及目标：适用于需要理解和预测块石路基在复杂环境下（如寒区）的行为特性的工程项目。具体目标包括优化路基设计、提高施工质量、预防冻胀变形带来的潜在风险。 阅读建议：对于想要深入理解块石路基在寒区环境中性能表现的专业人士来说，本文提供了详细的理论背景和实用的技术指导。建议读者重点关注文中提到的建模步骤、关键参数选择以及最终得出的结论。
基于Newmark法求解两自由度体系振动反应分析
最新发布
05-31
在有限元课程中，有一个关于双自由度体系的算例，需要通过Newmark法来计算该体系的位移、速度和加速度，并使用Matlab进行编程实现。
【Java编程教育】焦玟尧七次作业汇总：涵盖数组、类与对象、异常处理、GUI编程及核心语法知识练习
05-31
内容概要：本文档汇总了焦玟尧同学完成的七次Java编程作业，涵盖数组、类和对象、异常处理、GUI编程、综合辨析以及类的定义复习等方面。通过具体的编程题目和代码示例，展示了对Java核心概念和技术的实际应用。作业一介绍了数组的基本操作，如输入学生成绩并计算总成绩和平均分；作业二探讨了类和对象的概念，包括类的定义、继承和对象创建；作业三和四则通过思维导图的形式梳理了异常处理和GUI编程的知识点；作业五结合GUI和I/O流，实现了一个带有图形界面的小程序；作业六深入解析了构造方法、多态、接口等高级特性；作业七复习了类的定义，包括矩形和球体类的具体实现。 适合人群：具备一定编程基础，正在学习或复习Java语言的初学者或初级开发者。 使用场景及目标：①帮助学生巩固Java基础知识，如数组、类、对象等；②通过实例加深对面向对象编程的理解，如继承、多态、接口等；③培养解决实际问题的能力，如处理异常、设计GUI界面、操作I/O流等；④强化对核心语法的理解，如构造方法、访问控制修饰符等。 阅读建议：读者应结合代码示例进行实践操作，理解每个知识点的具体应用场景。对于复杂概念，建议多次阅读并尝试修改代码，以加深理解和记忆。
英飞凌TC387 PMSM永磁同步电机FOC控制详解与实战Demo FOC控制 v4.0
05-31
内容概要：本文深入介绍了英飞凌TC387在永磁同步电机（PMSM）的Field Oriented Control (FOC) 控制中的应用。首先概述了TC387的特点及其广泛应用背景，然后详细解释了FOC控制的基本原理，包括d轴和q轴电流的分解与调控。接着，通过一个具体的demo展示了如何配置TC387并实现FOC控制的具体步骤，提供了简化的代码框架供参考。最后强调了FOC技术的重要性和未来发展趋势。 适合人群：电机控制系统工程师、嵌入式开发人员以及对高性能电机控制感兴趣的电子工程学生。 使用场景及目标：帮助读者掌握TC387在PMSM FOC控制中的具体实现方法，理解FOC的工作机制，能够独立完成类似项目的开发与调试。 其他说明：文中提供的代码片段仅为示意，实际项目中需根据具体情况调整优化。此外，建议配合官方提供的完整文档和工具链进行学习和实践。
URAL-PHA字体介绍与应用解析
标题和描述中都出现了“URAL-PHA”这个词汇，但并没有提供具体的描述信息，因此我们只能猜测这个词汇可能与字体设计、字体名称或者特定的字体文件相关。由于没有其他上下文信息，我们难以确定“URAL-PHA”是一个具体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值