皮卡丘的敌人是？SDUT

皮卡丘的敌人是？
Time Limit: 1000 ms Memory Limit: 65536 KiB

Problem Description

大家知道皮卡丘的敌人是谁吗？他们是火箭队三人组。“为了防止世界被破坏，为了守护世界的和平，贯彻爱与真实的邪恶，可爱又迷人的反派角色。”火箭队整天妄想着从小智手中抓到皮卡丘并献给他们的boss。这一天，火箭队又给小智一行人设下了陷阱，想要从手里夺走皮卡丘，而小智当然不知道火箭队的阴谋。机智的你发现了火箭队的阴谋，通过卫星知道了火箭队埋下陷阱的位置，现在请你告诉小智，距离小智最近的陷阱有多远。陷阱与小智的距离=两点的横坐标之差+两点的纵坐标之差。

Input
输入数据有多组，到EOF结束。

每组数据先输入两个整数n，m（2<=n,m<=20）,代表卫星地图的大小。

接下来输入n行，每行m个整数Aij，其中Aij=1时代表小智的位置，Aij=2时代表陷阱的位置，其他位置Aij=0。数据保证至少有一处陷阱。

Output
每组数据输出一个整数d，代表小智与距离小智最近的陷阱的距离。

Sample Input
2 2
0 2
2 1
2 3
1 0 0
0 0 2
4 3
0 0 2
2 0 0
0 0 0
0 0 1
Sample Output
1
3
3
Hint
Source
【2017级《程序设计基础(B)I》期末上机考试】玄黄

#include <stdio.h>
#include <string.h>
#include <math.h>
int main()
{
    int n,m,i,j;
    int a[20][20];
    int b[20];
    int k;
    while(~scanf("%d %d",&n,&m))
    {
        int q,c,d,e,t,x,k=0;
        int flag1=0,flag2=0;
        for(i=0; i<n; i++)
        {
            for(j=0; j<m; j++)
            {
                scanf("%d",&a[i][j]);
            }
        }
        for(i=0; i<n; i++)
        {
            for(j=0; j<m; j++)
            {
                if(a[i][j]==1)
                {
                    q=i;
                    c=j;
                    flag1=1;
                }

            }
        }
        for(i=0;i<n;i++)
        {
         for(j=0;j<m;j++)
            {
                if(a[i][j]==2)
                    {
                        d=i;
                        e=j;
                        flag2=1;
                    }


                if(flag1&&flag2)
                {
                    x=fabs(q-d)+fabs(c-e);
                    b[k++]=x;
                }
            }
        }
        for(i=0; i<k-1; i++)
        {
            for(j=0; j<k-1-i; j++)
            {
                if(b[j]>b[j+1])
                {
                    t=b[j];
                    b[j]=b[j+1];
                    b[j+1]=t;
                }
            }
        }
        printf("%d\n",b[0]);
    }
    return 0;
}

由题意可知，小智的位置只有一个，但是陷阱至少有一个，所以需要一个for循环去寻找小智的位置，另一个去寻找陷阱的位置，然后再进行比较，把比较的数放在一个新的数组中，通过冒泡排序，找出最小值。