newwy
奋斗在IT路上的小蜗牛。一步一步往上爬,爬到小牛,在到大牛,然后是神牛,然后是犇,然后就可以离开IT行业,回归大自然了。 远离IT,珍爱生命!!! 记录学习的点滴。

一些杭电上的题目,给出代码,我具体理解的也不是很好。没有理解,就是不行啊,现在都有点忘了。

Tempter of the Bone

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 19092    Accepted Submission(s): 5331

Problem Description

The doggie found a bone in an ancient maze, which fascinated him a lot. However, when he picked it up, the maze began to shake, and the doggie could feel the ground sinking. He realized that the bone was a trap, and he tried desperately to get out of this maze.
The maze was a rectangle with sizes N by M. There was a door in the maze. At the beginning, the door was closed and it would open at the T-th second for a short period of time (less than 1 second). Therefore the doggie had to arrive at the door on exactly the T-th second. In every second, he could move one block to one of the upper, lower, left and right neighboring blocks. Once he entered a block, the ground of this block would start to sink and disappear in the next second. He could not stay at one block for more than one second, nor could he move into a visited block. Can the poor doggie survive? Please help him.

Input

The input consists of multiple test cases. The first line of each test case contains three integers N, M, and T (1 < N, M < 7; 0 < T < 50), which denote the sizes of the maze and the time at which the door will open, respectively. The next N lines give the maze layout, with each line containing M characters. A character is one of the following:
'X': a block of wall, which the doggie cannot enter;
'S': the start point of the doggie;
'D': the Door; or
'.': an empty block.
The input is terminated with three 0's. This test case is not to be processed.

Output

For each test case, print in one line "YES" if the doggie can survive, or "NO" otherwise.

Sample Input

4 4 5

S.X.

..X.

..XD

....

3 4 5

S.X.

..X.

...D

0 0 0

Sample Output

NO

YES

 

#include <iostream>

using namespace std;

#include <stdio.h>

#include <math.h>

#include <string.h>

#define N 10

int dir[4][2] = {0,-1,1,0,0,1,-1,0};//define up,right,down,left index

int escape,di,dj,T,m,n;//escape 是否逃脱,di,dj为目的地址坐标,T为恰好到达的时间,m,n为地图大小

char map[N][N];

 

void dfs(int si,int sj,int t)//t 记录现在已经走了几步

{

    int i;

    if(si == di && sj == dj && t == T)//成功到达目的地,并且时间相等,成功逃脱

    {

        escape = 1;

        return;

    }

    if(si < 0 || si >= m || sj < 0 || sj >= n)//越界中断

        return;

    if(T-t <(abs(si-di)+abs(sj-dj)))//如果剩下要走的步 少于当前能够到达的最少步 则逃脱失败

        return;

    if(( T - t - abs(si - di) - abs(sj - dj) ) % 2 != 0)//奇偶剪枝 如果剩下要走的步 多于当前能够到达的最少步

                                                        //求差,如果不是为偶数,则无法准确到达,即逃脱失败

        return;

    for(i = 0 ; i < 4; i++)//各个方向搜索开始

    {

        if(si + dir[i][0] >= 0 && si + dir[i][0] < m && sj + dir[i][1] >= 0 && sj + dir[i][1] < n )

        {//保证每个搜索的点,都在map中

            if(map[si + dir[i][0]][sj+dir[i][1]] != 'X' )

            {

                map[si + dir[i][0]][sj+dir[i][1]] = 'X';//将访问过的标记已访问

                dfs(si+dir[i][0],sj+dir[i][1],t+1);//从这一点开始,继续深度优先搜索

                if(escape) return;//如果逃脱则返回

                map[si+dir[i][0]][sj+dir[i][1]] = '.';//回溯,赋值初始值   

            }

        }

    }

    return ;

}

int main()

{

    int i,j,si,sj,t,num;

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

    {

        getchar();

        if(m == 0 && n == 0 && T == 0)

            break;

        num = 0;

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

        {

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

            {

                scanf("%c",&map[i][j]);

                if(map[i][j] == 'S')

                    si = i,sj = j;

                else if(map[i][j] == 'D')

                    di = i,dj = j;

                else if(map[i][j] == 'X')

                    num++;

            }

            getchar();

        }

        if(m*n - num < T)//路径剪枝,如果能走的路小于时间T,则无法到达

        {

            puts("NO");

            continue;

        }

        escape = 0;

        map[si][sj] = 'X';

        dfs(si,sj,0);

        puts(escape ? "YES" : "NO" );

       

    }

}

Oil Deposits

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 2474    Accepted Submission(s): 1390

Problem Description

The GeoSurvComp geologic survey company is responsible for detecting underground oil deposits. GeoSurvComp works with one large rectangular region of land at a time, and creates a grid that divides the land into numerous square plots. It then analyzes each plot separately, using sensing equipment to determine whether or not the plot contains oil. A plot containing oil is called a pocket. If two pockets are adjacent, then they are part of the same oil deposit. Oil deposits can be quite large and may contain numerous pockets. Your job is to determine how many different oil deposits are contained in a grid.

 

 

Input

The input file contains one or more grids. Each grid begins with a line containing m and n, the number of rows and columns in the grid, separated by a single space. If m = 0 it signals the end of the input; otherwise 1 <= m <= 100 and 1 <= n <= 100. Following this are m lines of n characters each (not counting the end-of-line characters). Each character corresponds to one plot, and is either `*', representing the absence of oil, or `@', representing an oil pocket.

 

 

Output

For each grid, output the number of distinct oil deposits. Two different pockets are part of the same oil deposit if they are adjacent horizontally, vertically, or diagonally. An oil deposit will not contain more than 100 pockets.

 

 

Sample Input

1 1

*

3 5

*@*@*

**@**

*@*@*

1 8

@@****@*

5 5

****@

*@@*@

*@**@

@@@*@

@@**@

0 0

 

 

Sample Output

0

1

2

2

#include <iostream>

using namespace std;

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

char map[110][110];

int m,n;

void dfs(int a,int b)

{

    int i;

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

    {

        if(a+dir[i][0] >= 0 && a+dir[i][0] < m && b+dir[i][1] >= 0 && b+dir[i][1] < n)

        {

            if(map[a+dir[i][0]][b+dir[i][1]] == '@')

            {

                map[a+dir[i][0]][b+dir[i][1]] = '*';

                dfs(a+dir[i][0],b+dir[i][1]);

            }

        }

    }

}

int main()

{

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

    {

        int i,j;

        int cnt = 0;

        if(m == 0 || n == 0)

            break;

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

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

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

        {

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

            {

                if(map[i][j] == '@')

                {

                    map[i][j] = '*';

                    dfs(i,j);

                    cnt++;

                }

            }

        }

        printf("%d\n",cnt);       

    }

}

Prime Ring Problem

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 7023    Accepted Submission(s): 3144

Problem Description

A ring is compose of n circles as shown in diagram. Put natural number 1, 2, ..., n into each circle separately, and the sum of numbers in two adjacent circles should be a prime.

Note: the number of first circle should always be 1.

 

 

Input

n (0 < n < 20).

 

 

Output

The output format is shown as sample below. Each row represents a series of circle numbers in the ring beginning from 1 clockwisely and anticlockwisely. The order of numbers must satisfy the above requirements. Print solutions in lexicographical order.

You are to write a program that completes above process.

Print a blank line after each case.

 

 

Sample Input

6

8

 

 

Sample Output

Case 1:

1 4 3 2 5 6

1 6 5 2 3 4

 

Case 2:

1 2 3 8 5 6 7 4

1 2 5 8 3 4 7 6

1 4 7 6 5 8 3 2

1 6 7 4 3 8 5 2

 

#include <iostream>

using namespace std;

int prim[40];

int res[25];

int mark[25];

int n;

void dfs(int t)

{

    if(t == n+1)

    {

        if(prim[1+res[t-1]])

        {

            printf("1");

            int i;

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

                printf(" %d",res[i]);

            printf("\n");

        }

        return;

    }

    int i;

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

    {

        if(!mark[i] && prim[res[t-1]+i])

        {

            mark[i] = 1;

            res[t] = i;

            dfs(t+1);

            mark[i] = 0;

        }

    }

}

int main()

{

    prim[3] = prim[5] = prim[7] = prim[11] = prim[13] = prim[17] = prim[19] = prim[23] = prim[29] = prim[31] = 1;

    memset(mark,0,sizeof(mark));

    int cnt = 0;

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

    {

        printf("Case %d:\n",++cnt);

        mark[1] = 1;

        res[1] = 1;

        dfs(2);

        printf("\n");

    }

}

Zipper

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 2179    Accepted Submission(s): 779

Problem Description

Given three strings, you are to determine whether the third string can be formed by combining the characters in the first two strings. The first two strings can be mixed arbitrarily, but each must stay in its original order.

For example, consider forming "tcraete" from "cat" and "tree":

String A: cat
String B: tree
String C: tcraete


As you can see, we can form the third string by alternating characters from the two strings. As a second example, consider forming "catrtee" from "cat" and "tree":

String A: cat
String B: tree
String C: catrtee


Finally, notice that it is impossible to form "cttaree" from "cat" and "tree".

 

 

Input

The first line of input contains a single positive integer from 1 through 1000. It represents the number of data sets to follow. The processing for each data set is identical. The data sets appear on the following lines, one data set per line.

For each data set, the line of input consists of three strings, separated by a single space. All strings are composed of upper and lower case letters only. The length of the third string is always the sum of the lengths of the first two strings. The first two strings will have lengths between 1 and 200 characters, inclusive.

 

 

Output

For each data set, print:

Data set n: yes

if the third string can be formed from the first two, or

Data set n: no

if it cannot. Of course n should be replaced by the data set number. See the sample output below for an example.

 

 

Sample Input

3

cat tree tcraete

cat tree catrtee

cat tree cttaree

 

 

Sample Output

Data set 1: yes

Data set 2: yes

Data set 3: no

《此题还有DP的做法》

#include <iostream>

#include <string.h>

using namespace std;

int n;

int flag;

int len1,len2,len3;

int marka[205],markb[205];

char a[205],b[205],c[410];

void dfs(int i,int j, int k)

{

    if(k == len3)

    {

        flag = 1;

        return;

    }

    if(marka[i] && markb[j] )

        return;

    if(i < len1 && a[i] == c[k]) {marka[i] = 1;dfs(i+1,j,k+1);}

    if(j < len2 && b[j] == c[k]) {markb[j] = 1;dfs(i,j+1,k+1);}

}

int main()

{

    scanf("%d",&n);

    int cnt = 0;

    while(n--)

    {

        printf("Data set %d: ",++cnt);

        int i;

        scanf("%s %s %s",a,b,c);

        len1 = strlen(a);

        len2 = strlen(b);

        len3 = strlen(c);

        memset(marka,0,sizeof(marka));

        memset(markb,0,sizeof(markb));

        flag = 0;

        dfs(0,0,0);

        puts(flag ? "yes":"no");

       

    }   

}

变形课

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others)
Total Submission(s): 3011    Accepted Submission(s): 1000

Problem Description

呃......变形课上Harry碰到了一点小麻烦,因为他并不像Hermione那样能够记住所有的咒语而随意的将一个棒球变成刺猬什么的,但是他发现了变形咒语的一个统一规律:如果咒语是以a开头b结尾的一个单词,那么它的作用就恰好是使A物体变成B物体.
Harry已经将他所会的所有咒语都列成了一个表,他想让你帮忙计算一下他是否能完成老师的作业,将一个B(ball)变成一个M(Mouse),你知道,如果他自己不能完成的话,他就只好向Hermione请教,并且被迫听一大堆好好学习的道理.

 

 

Input

测试数据有多组。每组有多行,每行一个单词,仅包括小写字母,是Harry所会的所有咒语.数字0表示一组输入结束.

 

 

Output

如果Harry可以完成他的作业,就输出"Yes.",否则就输出"No."(不要忽略了句号)

 

 

Sample Input

so

soon

river

goes

them

got

moon

begin

big

0

#include <iostream>

using namespace std;

typedef struct

{

    char begin,end;

    int flag;

}Model;

int n,flag;

Model test[10000];

void dfs(char c)

{

    if(flag == 1)

        return;

    if(c == 'm')

    {

        flag = 1;

        return;

    }

    int i;

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

    {

        if(test[i].begin == c && test[i].flag == 0)

        {

            test[i].flag = 1;

            dfs(test[i].end);

            test[i].flag = 0;

        }

    }   

}

int main()

{

    char s[20];

    while(scanf("%s",s) != EOF)

    {

        n = 1;

        while(strcmp(s,"0"))

        {

            test[n].begin = s[0];

            test[n].end = s[strlen(s)-1];

            test[n].flag = 0;

            n++;

            scanf("%s",s);

        }

        flag = 0;

        dfs('b');

        puts(flag ?"Yes.":"No.");

    }

}

Red and Black

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1759    Accepted Submission(s): 1165

Problem Description

There is a rectangular room, covered with square tiles. Each tile is colored either red or black. A man is standing on a black tile. From a tile, he can move to one of four adjacent tiles. But he can't move on red tiles, he can move only on black tiles.

Write a program to count the number of black tiles which he can reach by repeating the moves described above.

 

 

Input

The input consists of multiple data sets. A data set starts with a line containing two positive integers W and H; W and H are the numbers of tiles in the x- and y- directions, respectively. W and H are not more than 20.

There are H more lines in the data set, each of which includes W characters. Each character represents the color of a tile as follows.

'.' - a black tile
'#' - a red tile
'@' - a man on a black tile(appears exactly once in a data set)

 

 

Output

For each data set, your program should output a line which contains the number of tiles he can reach from the initial tile (including itself).

 

 

Sample Input

6 9

....#.

.....#

......

......

......

......

......

#@...#

.#..#.

11 9

.#.........

.#.#######.

.#.#.....#.

.#.#.###.#.

.#.#..@#.#.

.#.#####.#.

.#.......#.

.#########.

...........

11 6

..#..#..#..

..#..#..#..

..#..#..###

..#..#..#@.

..#..#..#..

..#..#..#..

7 7

..#.#..

..#.#..

###.###

...@...

###.###

..#.#..

..#.#..

0 0

 

 

Sample Output

45

59

6

13

 

#include <iostream>

using namespace std;

int m,n;

int si,sj;

char map[30][30];

int cnt;

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

int dfs(int a,int b)

{

    int i;

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

    {

        if(a+dir[i][0] >= 0 && a+dir[i][0] < n && b+dir[i][1] >= 0 && b+dir[i][1] < m)

        {

            if(map[a+dir[i][0]][b+dir[i][1]] == '.')

            {

                map[a+dir[i][0]][b+dir[i][1]] = '#';

                    ++cnt;

                dfs(a+dir[i][0],b+dir[i][1]);           

            }

        }

    }

    return cnt;

}

int main()

{

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

    {

        getchar();

        if(m+n == 0)

            break;

        int i,j;

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

        {

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

            {

                scanf("%c",&map[i][j]);

                if(map[i][j] == '@')

                    si = i, sj = j;

            }

            getchar();

        }

        cnt = 1;

        int ans = dfs(si,sj);

        printf("%d\n",ans);

    }

}

posted on 2010-12-01 16:02  newwy  阅读(855)  评论(0编辑  收藏  举报