Fireworks焦祺_第一周

星期日 :

花了一个下午的时间搞 昨天比赛的逃离迷宫问题

虽然做了不少的搜索题,但是这题原来还真不简单

不是一般的搜索方法,不是很适合我做....

17:34,还没有搞定,希望晚上可以拿下它.

//----------------------------------------

22:38分终于干掉了这题,记录一下

花了我10个小时

前后用了N种方法

证明自己还是太菜

其实也是这题很强

小看它了,把它当成一般的搜索

其实有时候搜索很需要变通

还有就是STL的队列虽然好用,但是占MEMERY

要不是用了STL,也不会在训练的赛的时候MLE浪费了很多时间!

 

题目:

HDOJ 1728 逃离迷宫 http://acm.hdu.edu.cn/showproblem.php?pid=1728

Problem Description

  给定一个m × n (m, n)的迷宫,迷宫中有两个位置,gloria想从迷宫的一个位置走到另外一个位置,当然迷宫中有些地方是空地,gloria可以穿越,有些地方是障碍,她必须绕行,从迷宫的一个位置,只能走到与它相邻的4个位置中,当然在行走过程中,gloria不能走到迷宫外面去。令人头痛的是,gloria是个没什么方向感的人,因此,她在行走过程中,不能转太多弯了,否则她会晕倒的。我们假定给定的两个位置都是空地,初始时,gloria所面向的方向未定,她可以选择4个方向的任何一个出发,而不算成一次转弯。gloria能从一个位置走到另外一个位置吗?

Input

  第1行为一个整数t (1 ≤ t ≤ 100),表示测试数据的个数,接下来为t组测试数据,每组测试数据中,
  第1行为两个整数m, n (1 ≤ m, n ≤ 100),分别表示迷宫的行数和列数,接下来m行,每行包括n个字符,其中字符'.'表示该位置为空地,字符'*'表示该位置为障碍,输入数据中只有这两种字符,每组测试数据的最后一行为5个整数k, x1, y1, x2, y2 (1 ≤ k ≤ 10, 1 ≤ x1, x2 ≤ n, 1 ≤ y1, y2 ≤ m),其中k表示gloria最多能转的弯数,(x1, y1), (x2, y2)表示两个位置,其中x1x2对应列,y1, y2对应行。

Output

  每组测试数据对应为一行,若gloria能从一个位置走到另外一个位置,输出“yes”,否则输出“no”

Sample Input

2

5 5

...**

*.**.

.....

.....

*....

1 1 1 1 3

5 5

...**

*.**.

.....

.....

*....

2 1 1 1 3

 

解题过程:

先是用了广度优先搜索的方法,但是当时用了STL的队列,于是MLE

后来讨论的时候发现可以用记录型深度搜索的方法

但是试过之后,发现一般的记录型深度搜索还是会TLE

于是再次用广搜,只不过用自己写的队列,还用了二维数组记录

但是考虑了很多问题排了很多BUG之后还是一直WA

主要是广搜对这题并非很好,会有重走或多算的可能.

花了一下午时间不断排除出错可能后未果,绝望了

网上看一下,发现最好对同一方向的一直搜索一下去的方法很好

这样做的最大好处是最小转弯优先” ,这样可以避免了一般广搜的很大不足

 

AC CODE:

 

#include <iostream>

using namespace std;

char g[102][102];     //记录图

int step[102][102];  //记录step

struct Node

{

         int x;

         int y;

         int dir;

         int last;

}state[10002];

//g[][]

int k,x1,x2,y1,y2;

int dir[][2]={{1,0},{0,1},{-1,0},{0,-1}};

bool bfs();

int n,m;

int main()

{

         int i,j,t;

         scanf("%d",&t);

         while (t--)

         {

                   scanf("%d %d",&m,&n);

                   //m,n

                   for (i=0;i<m;i++)

                   {

                            scanf("%s",g[i]);

                   }

                   scanf("%d %d %d %d %d",&k,&y1,&x1,&y2,&x2);

                   //反置xy, 使 x1x2对应行,y1, y2对应列。

                   x1--;y1--;y2--;x2--;

                   //-----------------------------------------

                   memset(step,-1,sizeof(step));

         //      step[x1][y1] = 0;

                   if (x1 == x2 && x2 == y2)

                   {

                            printf("yes/n");

                            continue;

                   }

                   if(bfs())

                   {

                            if (step[x2][y2] <= k)

                            {

                                     printf("yes/n");

                            }

                            else

                                     printf("no/n");

                   }

                   else

                   {

                            printf("no/n");

                   }

//              for (i=0;i<m;i++)

//              {

//                       for (j=0;j<n;j++)

//                       {

//                                 printf("%d ",step[i][j]);

//                       }

//                       printf("/n");

//              }

         }

         return 0;

}

 

bool bfs()

{

         int head = 0;

         int tail = 1;

         state[head].x = x1;

         state[head].y = y1;

         int i;

         while (head != tail)

         {

                   for (i=0;i<4;i++)

                   {

                            int tx = state[head].x + dir[i][0];

                            int ty = state[head].y + dir[i][1];

                            while (g[tx][ty] == '.' && tx>=0 && tx<m && ty>=0 && ty<n)

                            {

                                     if (step[tx][ty] == -1)

                                     {

                                               state[tail].x = tx;

                                               state[tail].y = ty;

                                               tail++;

                                               step[tx][ty] = step[state[head].x][state[head].y] + 1;

                                             if(tx==x2 && ty==y2)

                    {

                         return 1;

                    }

                                     }

                                     tx += dir[i][0];

                                     ty += dir[i][1];

                            }

                   }

                   head++;

         }

         return 0;

}

 

参考网页:

http://hi.baidu.com/185015165/blog/item/247a4d135ad8d8856438db7c.html

 

 


 

星期一:

 

上一题在训练中没有解出来是我的错

而这道题是我在训练赛时又是重大的失误,所以在这里再做一遍

我只知道我只前看过这个题,当时还不会博弈,没有解出来

但是后来会了博弈之后并没有再找出这个题目

 

题目:

HDOJ 1730 Northcott Game http://acm.hdu.edu.cn/showproblem.php?pid=1730

Problem Description

  TomJerry正在玩一种Northcott游戏,可是Tom老是输,因此他怀疑这个游戏是不是有某种必胜策略,郁闷的Tom现在向你求救了,你能帮帮他么?
游戏规则是这样的:
  如图所示,游戏在一个nm列(1 ≤ n ≤ 10002 ≤ m ≤ 100)的棋盘上进行,每行有一个黑子(黑方)和一个白子(白方)。执黑的一方先行,每次玩家可以移动己方的任何一枚棋子到同一行的任何一个空格上,当然这过程中不许越过该行的敌方棋子。双方轮流移动,直到某一方无法行动为止,移动最后一步的玩家获胜。Tom总是先下(黑方)。图1是某个初始局面,图二是Tom移动一个棋子后的局面(第一行的黑子左移两步)。


1



2

Input

  输入数据有多组。每组数据第一行为两个整数nm,由空格分开。接下来有n行,每行两个数TiJi (1 ≤ Ti, Ji ≤ m)分别表示TomJerry在该行棋子所处的列数。
  注意:各组测试数据之间有不定数量的空行。你必须处理到文件末。

Output

对于每组测试数据输出一行你的结果。如果当前局面下Tom有必胜策略则输出“I WIN!”,否则输出“BAD LUCK!”

Sample Input

3 6

4 5

1 2

1 2

 

3 6

4 5

1 3

1 2

Sample Output

BAD LUCK!

I WIN!

 

解题过程:

这道题是博弈的经典

其实只要把它化解为取(N)石子问题的博弈就可以在十分钟之内解出来

把每行黑白棋位的差看成是一堆石子,这样就根本不用去分析下一步怎么走了

用取(N)石子博弈的XOR算法套上便可得解

 

AC CODE:

 

#include <iostream>

using namespace std;

int main()

{

         int i,j,k,t,n,m;

         int a,b;

         int d[1002];

         while (scanf("%d %d",&n,&m)!=EOF)

         {

                   int ans =0;

                   for (i=0;i<n;i++)

                   {

                            scanf("%d %d",&a,&b);

                            ans = (abs(a-b)-1)^ans ;

                   }

                   if (ans == 0)

                   {

                            printf("BAD LUCK!/n");

                   }

                   else

                   {

                            printf("I WIN!/n");

                   }

         }

         return 0;

}

 

 


星期四:

 

连续两天了,没有搞明白STONE GAME是怎么解的,很不爽

晚上决定到题库A点简单题…(题很水,于是就没有写解题过程了)

 

发现Volume 16 后面一系列的题题目很有意思

HDOJ 2567寻梦 http://acm.hdu.edu.cn/showproblem.php?pid=2567

字符串的简单处理

 

HDOJ 2566统计硬币 http://acm.hdu.edu.cn/showproblem.php?pid=2566

看似母函数,但暴力可解. 用暴力很爽.

 

HDOJ 2565放大的X  http://acm.hdu.edu.cn/showproblem.php?pid=2565

喜欢A这种图形题,不过这题很贱,不信你A看看.

 

HDOJ 2568前进 http://acm.hdu.edu.cn/showproblem.php?pid=2568

直接模拟AC

 

星期五:

 

HDOJ 2524 矩形A + B http://acm.hdu.edu.cn/showproblem.php?pid=2524

稍贴下代码,虽然题很水

         a[0] = 0;

         for (i=1;i<=100;i++)           //计算基数

                   a[i] = i + a[i-1];

         while (scanf("%d",&t)!=EOF)

         {

                   while (t--)

                   {

                            scanf("%d %d",&n,&m);

                            printf("%d/n",a[n]*a[m]);

                   }

         }

 

HDOJ 2564词组缩写 http://acm.hdu.edu.cn/showproblem.php?pid=2564

字符串的简单处理

 

PKU 2262 Goldbach's Conjecture

题目还不错,主要要会有筛法求素数,还有就是线性求素数.

还没有把代码改好,这里就先不贴了….

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值