杭电-PID1181-变形课

杭电-PID1181-变形课

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

Sample Output

Yes.

Hint

Harry 可以念这个咒语:"big-got-them".

解题思路：

其实我们可以将每个字母想成一个一个的顶点，输入的的数据可以得出边，也就是顶点与顶点之间的关系。

注意这里是有向图（边有方向）。

实际就是告诉你很多边，然后求一个点能不能到达另外一个点。

可以使用DFS或者BFS。

DFS：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int mark[26];
int map[26][26];
int endPoint = 'm' - 'a';

int dfs(int curPoint)
{
    if (curPoint == endPoint)
    {
        return 1;
    }

    int i;
    for (i = 0; i < 26; i++)
    {
        if (map[curPoint][i] == 1 && mark[i] == 0)
        {
            mark[i] = 1;
            int result = dfs(i);
            if (result == 1)
            {
                return 1;
            }
            mark[i] = 0;
        }
    }
    return 0;
}

int main()
{
    char s[1001];

    while (scanf("%s", s) != EOF)
    {
        memset(mark, 0, sizeof(mark));
        memset(map, 0, sizeof(map));

        while (s[0] != '0')
        {
            int len = strlen(s);
            map[s[0] - 97][s[len - 1] - 97] = 1;
            scanf("%s", s);
        }

        int result = dfs('b' - 'a');
        if (result)
        {
            printf("Yes.\n");
        }
        else
        {
            printf("No.\n");
        }
    }
    return 0;
}

BFS：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{

    int mark[26];
    int queue[26];
    int map[26][26];
    char s[1000];

    int endPoint = 'm' - 'a';

    while (scanf("%s", s) != EOF)
    {
        memset(mark, 0, sizeof(mark));
        memset(queue, 0, sizeof(queue));
        memset(map, 0, sizeof(map));

        while (s[0] != '0')
        {
            int x = s[0] - 'a';
            int y = s[strlen(s) - 1] - 'a';
            map[x][y] = 1;
            scanf("%s", s);
        }

        queue[0] = 'b' - 'a';
        int head = 0;;
        int tail = 1;

        int flag = 0;
        while (head < tail)
        {
            int curPoint = queue[head];
            if (curPoint == endPoint)
            {
                flag = 1;
                break;
            }

            int i;
            for (i = 0; i < 26; i++)
            {
                if (map[curPoint][i] == 1 && mark[i] == 0)
                {
                    queue[tail] = i;
                    mark[i] = 1;
                    tail++;
                }
            }
            head++;
        }

        if (flag == 1)
        {
            printf("Yes.\n");
        }
        else
        {
            printf("No.\n");
        }
    }

    return 0;
}

可以使用Floyd算法。

Floyd算法是求多源最短路径的算法。

我们的问题可以转化为：

使用Floyd求出每两个点之间的最短距离，看看这个最短距离是不是可达的（即与我们初始化的infinity进行比较）。

Floyd：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    int map[26][26];
    char s[1001];

    int infinity = 99999999;
    int endPoint = 'm' - 'a';

    while (scanf("%s", s) != EOF)
    {
        int i, j, k;
        for (i = 0; i < 26; i++)
        {
            for (j = 0; j < 26; j++)
            {
                map[i][j] = infinity;
            }
        }

        while (s[0] != '0')
        {
            int x = s[0] - 'a';
            int y = s[strlen(s) - 1] - 'a';
            map[x][y] = 1;
            scanf("%s", s);
        }

        for (k = 0; k < 26; k++)
        {
            for (i = 0; i < 26; i++)
            {
                for (j = 0; j < 26; j++)
                {
                    if (map[i][k] < infinity && map[k][j] < infinity && map[i][j] > map[i][k] + map[k][j])
                    {
                        map[i][j] = map[i][k] + map[k][j];
                    }
                }
            }
        }

        if (map['b' - 'a']['m' - 'a'] < infinity)
        {
            printf("Yes.\n");
        }
        else
        {
            printf("No.\n");
        }
    }
    return 0;
}