初级->基本算法->模拟 poj 2632 Crashing Robots

最新推荐文章于 2021-10-17 22:14:16 发布
原创 最新推荐文章于 2021-10-17 22:14:16 发布 · 600 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文概述了AI音视频处理领域的关键技术，包括视频分割、语义识别、自动驾驶、AR、SLAM等，并探讨了其在实际应用中的作用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Crashing Robots

Time Limit: 1000MSMemory Limit: 65536K
Total Submissions: 5708Accepted: 2492

Description

In a modernized warehouse, robots are used to fetch the goods. Careful planning is needed to ensure that the robots reach their destinations without crashing into each other. Of course, all warehouses are rectangular, and all robots occupy a circular floor space with a diameter of 1 meter. Assume there are N robots, numbered from 1 through N. You will get to know the position and orientation of each robot, and all the instructions, which are carefully (and mindlessly) followed by the robots. Instructions are processed in the order they come. No two robots move simultaneously; a robot always completes its move before the next one starts moving.
A robot crashes with a wall if it attempts to move outside the area of the warehouse, and two robots crash with each other if they ever try to occupy the same spot.

Input

The first line of input is K, the number of test cases. Each test case starts with one line consisting of two integers, 1 <= A, B <= 100, giving the size of the warehouse in meters. A is the length in the EW-direction, and B in the NS-direction.
The second line contains two integers, 1 <= N, M <= 100, denoting the numbers of robots and instructions respectively.
Then follow N lines with two integers, 1 <= Xi <= A, 1 <= Yi <= B and one letter (N, S, E or W), giving the starting position and direction of each robot, in order from 1 through N. No two robots start at the same position.

Figure 1: The starting positions of the robots in the sample warehouse

Finally there are M lines, giving the instructions in sequential order.
An instruction has the following format:
< robot #> < action> < repeat>
Where is one of
  • L: turn left 90 degrees,
  • R: turn right 90 degrees, or
  • F: move forward one meter,

and 1 <= < repeat> <= 100 is the number of times the robot should perform this single move.

Output

Output one line for each test case:
  • Robot i crashes into the wall, if robot i crashes into a wall. (A robot crashes into a wall if Xi = 0, Xi = A + 1, Yi = 0 or Yi = B + 1.)
  • Robot i crashes into robot j, if robots i and j crash, and i is the moving robot.
  • OK, if no crashing occurs.

Only the first crash is to be reported.

Sample Input

4
5 4
2 2
1 1 E
5 4 W
1 F 7
2 F 7
5 4
2 4
1 1 E
5 4 W
1 F 3
2 F 1
1 L 1
1 F 3
5 4
2 2
1 1 E
5 4 W
1 L 96
1 F 2
5 4
2 3
1 1 E
5 4 W
1 F 4
1 L 1
1 F 20

Sample Output

Robot 1 crashes into the wall
Robot 1 crashes into robot 2
OK
Robot 1 crashes into robot 2
 
 
题意：某个仓库很高科技 用机器人搬东西，告诉你机器人的个数 仓库的大小 给你一些让机器人转向或者移动的命令 让你判断机器人在执行这些命令的时候 会不会相撞或者撞墙。
 
 
//第一次的代码，改了无数次。麻烦死。没有经验啊。

#include<stdio.h>
#include<string.h>
struct node
{
    int x,y;
    char direction;
}robotn[101];
struct nodeins
{
    int num;
    char action;
    int repeat;
}robotm[101];
int main()
{
    int K,A,B,N,M;
    int i,j,yushu,just,mx,flag;
    scanf("%d",&K);
    while(K--)
    {
        scanf("%d%d",&A,&B);
        scanf("%d%d",&N,&M);
        for(i=1;i<=N;i++)
        scanf("%d%d%*c%c",&robotn[i].x,&robotn[i].y,&robotn[i].direction);
        for(i=1;i<=M;i++)
        scanf("%d%*c%c%d",&robotm[i].num,&robotm[i].action,&robotm[i].repeat);
        for(i=1;i<=M;i++)
        {
            if(robotm[i].action=='F')
            {
                if(robotn[robotm[i].num].direction=='N')
                {
                    just=robotn[robotm[i].num].y;
                    robotn[robotm[i].num].y+=robotm[i].repeat;
                    if(robotn[robotm[i].num].y>B)
                    {
                         mx=101;
                          for(j=1;j<=N;j++)
                          {
                            if(robotn[j].x==robotn[robotm[i].num].x&&robotn[j].y>just&&robotn[j].y<=B)
                            {
                                if(mx>robotn[j].y) {mx=robotn[j].y;flag=j;}
                            }
                          }
                          if(mx!=101){printf("Robot %d crashes into robot %d\n",robotm[i].num,flag);break;}

                        if(j>N)
                        {printf("Robot %d crashes into the wall\n",robotm[i].num);
                        break;}
                    }
                    else
                    {
                        mx=101;
                    for(j=1;j<=N;j++)
                    {
                        if(robotm[i].num!=j&&robotn[j].x==robotn[robotm[i].num].x&&
                           robotn[j].y>just&&robotn[j].y<=robotn[robotm[i].num].y)
                        {
                            if(mx>robotn[j].y){mx=robotn[j].y;flag=j;}
                        }
                    }
                    if(mx!=101){printf("Robot %d crashes into robot %d\n",robotm[i].num,flag);break;}

                    }
                }
                else if(robotn[robotm[i].num].direction=='E')
                {
                    just=robotn[robotm[i].num].x;
                    robotn[robotm[i].num].x+=robotm[i].repeat;
                    if(robotn[robotm[i].num].x>A)
                    {
                        mx=101;
                            for(j=1;j<=N;j++)
                          {
                            if(robotn[j].y==robotn[robotm[i].num].y&&robotn[j].x>just&&robotn[j].x<=A)
                            {
                                if(mx>robotn[j].x){mx=robotn[j].x;flag=j;}
                            }
                          }
                          if(mx!=101){printf("Robot %d crashes into robot %d\n",robotm[i].num,flag);break;}

                        if(j>N)
                        {printf("Robot %d crashes into the wall\n",robotm[i].num);
                        break;}
                    }
                    else
                    {
                        mx=101;
                        for(j=1;j<=N;j++)
                        {
                           if(robotm[i].num!=j&&robotn[j].x>just&&robotn[j].x<=robotn[robotm[i].num].x&&
                           robotn[j].y==robotn[robotm[i].num].y)
                           {
                               if(mx>robotn[j].x){mx=robotn[j].x;flag=j;}
                           }
                        }
                        if(mx!=101){printf("Robot %d crashes into robot %d\n",robotm[i].num,flag);break;}

                    }
                }
                else if(robotn[robotm[i].num].direction=='S')
                {
                    just=robotn[robotm[i].num].y;
                    robotn[robotm[i].num].y-=robotm[i].repeat;
                    if(robotn[robotm[i].num].y<=0)
                    {
                        mx=0;
                            for(j=1;j<=N;j++)
                          {
                            if(robotn[j].x==robotn[robotm[i].num].x&&robotn[j].y>=robotn[robotm[i].num].y&&robotn[j].y<just)
                            {
                                if(mx<robotn[j].y){mx=robotn[j].y;flag=j;}
                            }

                          }
                          if(mx!=0){printf("Robot %d crashes into robot %d\n",robotm[i].num,flag);break;}

                        if(j>N)
                        {printf("Robot %d crashes into the wall\n",robotm[i].num);
                        break;}
                    }
                    else
                    {
                        mx=0;
                      for(j=1;j<=N;j++)
                      {
                        if(robotm[i].num!=j&&robotn[j].x==robotn[robotm[i].num].x&&
                           robotn[j].y>=robotn[robotm[i].num].y&&robotn[j].y<just)
                        {
                            if(mx<robotn[j].y){mx=robotn[j].y;flag=j;}
                        }

                      }
                      if(mx!=0){printf("Robot %d crashes into robot %d\n",robotm[i].num,flag);break;}

                    }
                }
                else
                {
                    just=robotn[robotm[i].num].x;
                    robotn[robotm[i].num].x-=robotm[i].repeat;
                    if(robotn[robotm[i].num].x<=0)
                    {
                        mx=0;
                            for(j=1;j<=N;j++)
                          {
                            if(robotn[j].y==robotn[robotm[i].num].y&&robotn[j].x>=robotn[robotm[i].num].x&&robotn[j].x<just)
                            {
                                if(mx<robotn[j].x){mx=robotn[j].x;flag=j;}
                            }

                          }
                          if(mx!=0) {printf("Robot %d crashes into robot %d\n",robotm[i].num,flag);break;}

                         if(j>N)
                        {printf("Robot %d crashes into the wall\n",robotm[i].num);
                        break;}
                    }
                    else
                    {
                        mx=0;
                      for(j=1;j<=N;j++)
                      {
                        if(robotm[i].num!=j&&robotn[j].x>=robotn[robotm[i].num].x&&robotn[j].x<just&&
                           robotn[j].y==robotn[robotm[i].num].y)
                        {
                            if(mx<robotn[j].x){mx=robotn[j].x;flag=j;}
                        }

                      }
                      if(mx!=0){printf("Robot %d crashes into robot %d\n",robotm[i].num,flag);break;}
                    }
                }
            }
            else if(robotm[i].action=='L')
            {
                yushu=robotm[i].repeat%4;
                if(yushu==1)
                {
                    if(robotn[robotm[i].num].direction=='N')
                    robotn[robotm[i].num].direction='W';
                    else if(robotn[robotm[i].num].direction=='E')
                    robotn[robotm[i].num].direction='N';
                    else if(robotn[robotm[i].num].direction=='S')
                    robotn[robotm[i].num].direction='E';
                    else robotn[robotm[i].num].direction='S';
                }
                else if(yushu==2)
                {
                    if(robotn[robotm[i].num].direction=='N')
                    robotn[robotm[i].num].direction='S';
                    else if(robotn[robotm[i].num].direction=='E')
                    robotn[robotm[i].num].direction='W';
                    else if(robotn[robotm[i].num].direction=='S')
                    robotn[robotm[i].num].direction='N';
                    else robotn[robotm[i].num].direction='E';
                }
                else if(yushu==3)
                {
                    if(robotn[robotm[i].num].direction=='N')
                    robotn[robotm[i].num].direction='E';
                    else if(robotn[robotm[i].num].direction=='E')
                    robotn[robotm[i].num].direction='S';
                    else if(robotn[robotm[i].num].direction=='S')
                    robotn[robotm[i].num].direction='W';
                    else robotn[robotm[i].num].direction='N';
                }
            }
            else
            {
                yushu=robotm[i].repeat%4;
                if(yushu==1)
                {
                    if(robotn[robotm[i].num].direction=='N')
                    robotn[robotm[i].num].direction='E';
                    else if(robotn[robotm[i].num].direction=='E')
                    robotn[robotm[i].num].direction='S';
                    else if(robotn[robotm[i].num].direction=='S')
                    robotn[robotm[i].num].direction='W';
                    else robotn[robotm[i].num].direction='N';
                }
                else if(yushu==2)
                {
                    if(robotn[robotm[i].num].direction=='N')
                    robotn[robotm[i].num].direction='S';
                    else if(robotn[robotm[i].num].direction=='E')
                    robotn[robotm[i].num].direction='W';
                    else if(robotn[robotm[i].num].direction=='S')
                    robotn[robotm[i].num].direction='N';
                    else robotn[robotm[i].num].direction='E';
                }
                else if(yushu==3)
                {
                    if(robotn[robotm[i].num].direction=='N')
                    robotn[robotm[i].num].direction='W';
                    else if(robotn[robotm[i].num].direction=='E')
                    robotn[robotm[i].num].direction='N';
                    else if(robotn[robotm[i].num].direction=='S')
                    robotn[robotm[i].num].direction='E';
                    else robotn[robotm[i].num].direction='S';
                }
            }
        }
        if(i>M) printf("OK\n");
    }
    return 0;
}

 

 

 

//第二次的代码。对左转，右转简单的处理，一句话就行。把四个方向按0-3编号。
//可惜还是不能把代码量缩小，水平还是太低。
#include<stdio.h>
#include<string.h>
struct node
{
    int x,y;
    int direction;
}robotn[101];
struct nodeins
{
    int num;
    char action;
    int repeat;
}robotm[101];
int main()
{
    int K,A,B,N,M;
    int i,j,just,mx,flag;
    char dir;
    scanf("%d",&K);
    while(K--)
    {
        scanf("%d%d",&A,&B);
        scanf("%d%d",&N,&M);
        for(i=1;i<=N;i++)
        {
            scanf("%d%d%*c%c",&robotn[i].x,&robotn[i].y,&dir);
            switch(dir)
            {
                case 'N':robotn[i].direction=0;break;
                case 'E':robotn[i].direction=1;break;
                case 'S':robotn[i].direction=2;break;
                case 'W':robotn[i].direction=3;break;
            }
        }
        for(i=1;i<=M;i++)
        scanf("%d%*c%c%d",&robotm[i].num,&robotm[i].action,&robotm[i].repeat);
        for(i=1;i<=M;i++)
        {
            if(robotm[i].action=='F')
            {
                if(robotn[robotm[i].num].direction==0)
                {
                    just=robotn[robotm[i].num].y;
                    robotn[robotm[i].num].y+=robotm[i].repeat;
                    if(robotn[robotm[i].num].y>B)
                    {
                         mx=101;
                          for(j=1;j<=N;j++)
                          {
                            if(robotn[j].x==robotn[robotm[i].num].x&&robotn[j].y>just&&robotn[j].y<=B)
                            {
                                if(mx>robotn[j].y) {mx=robotn[j].y;flag=j;}
                            }
                          }
                          if(mx!=101){printf("Robot %d crashes into robot %d",robotm[i].num,flag);break;}

                        if(j>N)
                        {printf("Robot %d crashes into the wall",robotm[i].num);
                        break;}
                    }
                    else
                    {
                        mx=101;
                    for(j=1;j<=N;j++)
                    {
                        if(robotm[i].num!=j&&robotn[j].x==robotn[robotm[i].num].x&&
                           robotn[j].y>just&&robotn[j].y<=robotn[robotm[i].num].y)
                        {
                            if(mx>robotn[j].y){mx=robotn[j].y;flag=j;}
                        }
                    }
                    if(mx!=101){printf("Robot %d crashes into robot %d",robotm[i].num,flag);break;}

                    }
                }
                else if(robotn[robotm[i].num].direction==1)
                {
                    just=robotn[robotm[i].num].x;
                    robotn[robotm[i].num].x+=robotm[i].repeat;
                    if(robotn[robotm[i].num].x>A)
                    {
                        mx=101;
                            for(j=1;j<=N;j++)
                          {
                            if(robotn[j].y==robotn[robotm[i].num].y&&robotn[j].x>just&&robotn[j].x<=A)
                            {
                                if(mx>robotn[j].x){mx=robotn[j].x;flag=j;}
                            }
                          }
                          if(mx!=101){printf("Robot %d crashes into robot %d",robotm[i].num,flag);break;}

                        if(j>N)
                        {printf("Robot %d crashes into the wall",robotm[i].num);
                        break;}
                    }
                    else
                    {
                        mx=101;
                        for(j=1;j<=N;j++)
                        {
                           if(robotm[i].num!=j&&robotn[j].x>just&&robotn[j].x<=robotn[robotm[i].num].x&&
                           robotn[j].y==robotn[robotm[i].num].y)
                           {
                               if(mx>robotn[j].x){mx=robotn[j].x;flag=j;}
                           }
                        }
                        if(mx!=101){printf("Robot %d crashes into robot %d",robotm[i].num,flag);break;}

                    }
                }
                else if(robotn[robotm[i].num].direction==2)
                {
                    just=robotn[robotm[i].num].y;
                    robotn[robotm[i].num].y-=robotm[i].repeat;
                    if(robotn[robotm[i].num].y<=0)
                    {
                        mx=0;
                            for(j=1;j<=N;j++)
                          {
                            if(robotn[j].x==robotn[robotm[i].num].x&&robotn[j].y>=1&&robotn[j].y<just)
                            {
                                if(mx<robotn[j].y){mx=robotn[j].y;flag=j;}
                            }

                          }
                          if(mx!=0){printf("Robot %d crashes into robot %d",robotm[i].num,flag);break;}

                        if(j>N)
                        {printf("Robot %d crashes into the wall",robotm[i].num);
                        break;}
                    }
                    else
                    {
                        mx=0;
                      for(j=1;j<=N;j++)
                      {
                        if(robotm[i].num!=j&&robotn[j].x==robotn[robotm[i].num].x&&
                           robotn[j].y>=robotn[robotm[i].num].y&&robotn[j].y<just)
                        {
                            if(mx<robotn[j].y){mx=robotn[j].y;flag=j;}
                        }

                      }
                      if(mx!=0){printf("Robot %d crashes into robot %d",robotm[i].num,flag);break;}
                    }
                }
                else
                {
                    just=robotn[robotm[i].num].x;
                    robotn[robotm[i].num].x-=robotm[i].repeat;
                    if(robotn[robotm[i].num].x<=0)
                    {
                        mx=0;
                            for(j=1;j<=N;j++)
                          {
                            if(robotn[j].y==robotn[robotm[i].num].y&&robotn[j].x>=1&&robotn[j].x<just)
                            {
                                if(mx<robotn[j].x){mx=robotn[j].x;flag=j;}
                            }

                          }
                          if(mx!=0) {printf("Robot %d crashes into robot %d",robotm[i].num,flag);break;}

                         if(j>N)
                        {printf("Robot %d crashes into the wall",robotm[i].num);
                        break;}
                    }
                    else
                    {
                        mx=0;
                      for(j=1;j<=N;j++)
                      {
                        if(robotm[i].num!=j&&robotn[j].x>=robotn[robotm[i].num].x&&robotn[j].x<just&&
                           robotn[j].y==robotn[robotm[i].num].y)
                        {
                            if(mx<robotn[j].x){mx=robotn[j].x;flag=j;}
                        }

                      }
                      if(mx!=0){printf("Robot %d crashes into robot %d",robotm[i].num,flag);break;}
                    }
                }
            }
            else if(robotm[i].action=='L')
            robotn[robotm[i].num].direction=(robotn[robotm[i].num].direction-robotm[i].repeat%4+4)%4;
            else if(robotm[i].action=='R')
            robotn[robotm[i].num].direction=(robotn[robotm[i].num].direction+robotm[i].repeat%4)%4;
        }
        if(i>M) printf("OK");
        if(K) printf("\n");
    }
    return 0;
}


 


                

        

    

    
  



    



                



	

		

			

				
					
初级->图算法->最短路 poj 1125 Stockbroker Grapevine

				
			

			

				

					Cyibing的专栏
				

				

					11-30
					
					872
					
				

			

		

		

			
				
Stockbroker Grapevine




Time Limit: 1000MS

Memory Limit: 10000K


Total Submissions: 21767

Accepted: 11857




Description
Stockbrokers are known to overreact to rumours. You hav

			
		

	



                

            
              



	

		

			

				
					
迷宫问题，求最短路径长度、最短路径条数、所有最短路径，DFS+BFS+栈+队列

				
			

			

				

					Cyibing的专栏
				

				

					10-03
					
					5635
					
				

			

		

		

			
				
迷宫问题，求最短路径长度、最短路径条数、所有最短路径，DFS+BFS+栈+队列

			
		

	



              


  
              

                


	

		

			

				
					
POJ2632-Crashing Robots

				
			

			

				

					07-29
				

			

		

		

			
				
北大POJ2632-Crashing Robots
解题报告+AC代码

			
		

	





	

		

			

				
					
Crashing Robots  POJ2632

				
			

			

				

					天堂人间
				

				

					09-27
					
					3054
					
				

			

		

		

			
				
Crashing Robots




Time Limit: 1000MS
 
Memory Limit: 65536K


Total Submissions: 4556
 
Accepted: 1991





Description

			
		

	



		

			
		



	

		

			

				
					
模拟 --- Crashing Robots

				
			

			

				

					weixin_34259159的博客
				

				

					05-22
					
					137
					
				

			

		

		

			
				
Crashing Robots




Time Limit: 1000MS

Memory Limit: 65536K


Total Submissions: 7394

Accepted: 3242




Description
In a modernized warehouse, robots are used to fetch the goods...

			
		

	





	

		

			

				
					
Crashing Robots

				
			

			

				

					pokerfacecyf的博客
				

				

					09-28
					
					204
					
				

			

		

		

			
				
Crashing Robots
题目描述
模拟的做题思路：
模拟题目的解题方法就是根据题目的叙述，模拟题目中所述的过程，难点基本在于对于题意的理解、数据结构的组织、部分过程的优化。
思路
该题是典型的模拟题。只需要依照题目中所说的过程进行模拟即可。但是有一些小方法值得注意。在对于方向进行表示时，对于面朝方向dir，我们用0,1,2,3对应“NESW”（顺序不能乱），对于转向或直走操作用0,1,2表示“FLR”（顺序不能乱）。然后对于左转操作，我们只需要dir = (dir + 3) % 4;就可以得到正确的

			
		

	





	

		

			

				
					
Crashing Robots（好麻烦啊~）

				
			

			

				

					Domacles
				

				

					05-07
					
					1030
					
				

			

		

		

			
				
Crashing Robots




Time Limit: 1000MS
 
Memory Limit: 65536K


 
 
 




Description

In a modernized warehouse, robots are used to fetch the goods. Careful planning is needed to e

			
		

	





	

		

			

				
					
Crashing Robots POJ - 2632

				
			

			

				

					lovelyfather的博客
				

				

					10-17
					
					94
					
				

			

		

		

			
				
Crashing Robots POJ - 2632
题目链接：https://vjudge.net/problem/POJ-2632
题意：
xxx     is     from[1,a]from  [1,a]from[1,a]
yyy     is     from[1,b]from  [1,b]from[1,b]
在XoY上有nnn个机器人，从1到n编号，对于这些机器人有mmm个指令。指令格式如下：
robot#id   type  times
robot#id对应机器人id
type是指令类型，有

			
		

	





	

		

			

				
					
POJ2632-Crashing Robots(模拟)

				
			

			

				

					a774468183的专栏
				

				

					08-31
					
					112
					
				

			

		

		

			
				
题目详情点此查看 
花了近一个小时，总算是AC了， 
其实这题比较简单，没啥算法，题目详情点击链接； 
主要由以下事项： 
    1.我用的是二维数组，然后其（0， 0）点的位置与直角坐标系的远点位置恰好相反，因此处理数据时要特别注意。 
    2.最后提交时还出现了了WA, 然后一检查，我的天呐，我尽然把OK写成了小写的。。。。。。。
code：

//****...

			
		

	





	

		

			

				
					
poj-2632-- Crashing Robots -- 模拟法

				
			

			

				

					命运在指间
				

				

					07-30
					
					1273
					
				

			

		

		

			
				
Description

In a modernized warehouse, robots are used to fetch the goods. Careful planning is needed to ensure that the robots reach their destinations without crashing into each other. Of course,

			
		

	





	

		

			

				
					
POJ2632-Crashing Robots解题分析与AC代码

				
			

			

				

					
				

			

		

		

			
				
北大POJ2632-Crashing Robots是一道经典的编程题，常作为算法和编程能力的测试题出现在各大在线编程平台和算法竞赛中，如北京大学的在线评测系统（PKU Judge Online，简称POJ）。该题目要求参与者利用算法逻辑，编写...

			
		

	





	

		

			

				
					
北大POJ初级-基本算法

				
			

			

				

					07-30
				

			

		

		

			
				
【北大POJ初级-基本算法】是一系列针对北京大学在线编程平台POJ的初级算法题目解题报告和通过（AC）代码的集合。这个资源对于学习算法基础和提升编程能力非常有帮助，尤其适合初学者。POJ是许多计算机科学与技术专业...

			
		

	





	

		

			

				
					
java-poj:JAVE 上的最终项目 -> 解析来自 pl.kingofsat.net、HOTBIRD 卫星的频道列表并将压缩信息保存在 SQLlite 数据库中

				
			

			

				

					05-31
				

			

		

		

			
				
在文件处理方面，考虑到项目名为"java-poj-master"，可能包含了项目的源代码和资源文件。开发者可能将下载的频道列表文件临时存储在本地，然后读取这个文件进行解析。Java的`FileInputStream`和`BufferedReader`等类...

			
		

	





	

		

			

				
					
sdutoj 1269 走迷宫

				
			

			

				

					Cyibing的专栏
				

				

					10-04
					
					2792
					
				

			

		

		

			
				
迷宫问题，求出所有的路径。
sdutoj 1269 走迷宫

			
		

	





	

		

			

				
					
Java Scanner nextInt() 离奇的bug

				
			

			

				

					Cyibing的专栏
				

				

					09-10
					
					2586
					
				

			

		

		

			
				
import java.io.File;
import java.util.Scanner;


public class Main {
	public static void main(String[] args) {
		Scanner cin = null;
		try {
			cin = new Scanner(new File("sum.in"));
			int a

			
		

	





	

		

			

				
					
UVA  10267 - Graphical Editor

				
			

			

				

					Cyibing的专栏
				

				

					09-29
					
					2039
					
				

			

		

		

			
				
UVA  10267 - Graphical Editor
【题意】
* 根据命令符号操作就行了。
* I M N 建立一个M列N行的图
* C 清空所有的颜色，用0表示
* L X Y C 在点（X,Y）处涂上颜色C
* V X Y1 Y2 C 在X列上的区间Y1-Y2涂上颜色C
* H Y X1 X2 C 在Y行上的区间X1-X2涂上颜色C
* K X1 Y1 X2 Y2 C 把左上角（X1，Y1）到右下角（X2，Y2）所组成的矩形涂上颜色C
* F X Y C 把点（X,Y）的上下左右四个方向上的点涂

			
		

	





	

		

			

				
					
UVA  10189 - Minesweeper（扫雷）

				
			

			

				

					Cyibing的专栏
				

				

					09-29
					
					1781
					
				

			

		

		

			
				
UVA  10189 - Minesweeper（扫雷）
题意：一个n行m列的大框（一共n×m个方格），“*”代表雷，“.”代表没有雷；
输出每个方格的周围有多少个雷。每个方格的周围最多有八个方格。

			
		

	





	

		

			

				
					
sdutoj 1157 小鼠迷宫问题

				
			

			

				

					Cyibing的专栏
				

				

					10-03
					
					1546
					
				

			

		

		

			
				
【题目描述】
小鼠a与小鼠b身处一个m×n的迷宫中，如图所示。每一个方格表示迷宫中的一个房间。这m×n个房间中有一些房间是封闭的，不允许任何人进入。在迷宫中任何位置均可沿上，下，左，右4个方向进入未封闭的房间。小鼠a位于迷宫的(p，q)方格中，它必须找出一条通向小鼠b所在的(r，s)方格的路。请帮助小鼠a找出所有通向小鼠b的最短道路。

BFS+DFS+奇偶剪枝

			
		

	





	

		

			

				
					
sdutoj 1129 电路稳定性

				
			

			

				

					Cyibing的专栏
				

				

					10-02
					
					1396
					
				

			

		

		

			
				
sdutoj 1129 电路稳定性
转成中缀表达式，再转成后缀表达式，再求值

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值