hihoCoder #1092 Have Launch Together

Description

Everyday Littile Hi and Little Ho meet in the school cafeteria to have lunch together. The cafeteria is often so crowded that two adjacent seats are hard to find.

School cafeteria can be considered as a matrix of N*M blocks. Each block can be empty or occupied by people, obstructions and seats. Little Hi and Little Ho starts from the same block. They need to find two adjacent seats(two seats are adjacent if and only if their blocks share a common edge) without passing through occupied blocks. Further more, they want the total distance to the seats is minimal.

Little Hi and Little Ho can move in 4 directions (up, down, left, right) and they can not move outside the matrix.

Input

Input cantains a single testcase.

First line contains two integers N, M, the length and width of school cafeteria.

The next is a matrix consists of N lines, each line containing M characters. Each character describe a block: '.' for empty block, 'P' for people, '#' for obstructions, 'S' for seats and 'H' for Little Hi and Little Ho's starting position.

10 <= N, M <= 100

Output

Output the minimal distance they need to move to reach two adjacent seats. If no such adjacent seats output a line "Hi and Ho will not have lunch." without quotes.

 

Sample Input

10 10
##########
#...P##..#
#S#...#.P#
#S#..#...#
#...#.####
#.#...#.H#
##......##
#..P#..S.#
##.......#
##########

Sample Output

25

Solution:

最短路径算法的 简单应用。TALK IS CHEAP......

#include <iostream>
#include <cstdio>
#include <cstring>
#include <climits>
#include <cmath>
using namespace std;

char g[100][100];
int N, M;

int d[100][100];
bool spt[100][100];
int Hi,Hj;

int minDistance()
{
    int minm = INT_MAX, min_index;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            if(spt[i][j] == false && d[i][j] <= minm) 
                minm = d[i][j], min_index = i*N + j;
        }
    }

    return min_index;
}

void dijkstra()
{
    for (int i = 0; i < N; ++i) 
        for (int j = 0; j < M; ++j) {
            d[i][j] = INT_MAX, spt[i][j] = false;
        }

    d[Hi][Hj] = 0;
    int V = N*M;
    for (int k = 0; k < V-1; ++k) {
        int u = minDistance();

        spt[u/N][u%N] = true;

        for (int i = 0; i < N; ++i) 
            for (int j = 0; j < M; ++j) {
                if (!spt[i][j] && ((g[i][j] == '.') && abs(i-u/N) + abs(j-u%N) == 1)
                    && d[u/N][u%N] != INT_MAX && (d[u/N][u%N] + 1 < d[i][j]) ) {
                    d[i][j] = d[u/N][u%N] + 1;
                }
            }
    }
}


bool hasSeats()
{
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            if (g[i][j] == 'S') {
                if ((i+1 < N && g[i+1][j] == 'S')
                    || (j+1 < M && g[i][j+1] == 'S')
                    || (i-1 >= 0 && g[i-1][j] == 'S')
                    || (j-1 >= 0 && g[i][j-1] == 'S')) {
                    return true;
                }
            }
        }
    }

    return false;
}

int solve()
{
    int minm = INT_MAX;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            if (g[i][j] == 'S') {
                if ((i+1 < N && g[i+1][j] == 'S')) {
                    int d1 = INT_MAX;
                    if (i-1>=0) {
                        d1 = min(d1, d[i-1][j]);
                    }
                    if (j-1>=0) {
                        d1 = min(d1, d[i][j-1]);
                    }
                    if (j+1<M) {
                        d1 = min(d1, d[i][j+1]);
                    }

                    int d2 = INT_MAX;
                    if (j-1>=0) {
                        d2 = min(d2, d[i+1][j-1]);
                    }
                    if (j+1 < M) {
                        d2 = min(d2, d[i+1][j+1]);
                    }
                    if (i+2 < N) {
                        d2 = min(d2, d[i+2][j]);
                    }
                    if (d1 != INT_MAX && d2 != INT_MAX)
                        minm = min(d1+d2+2, minm);
                }
                if (j+1 < M && g[i][j+1] == 'S') {
                    int d1 = INT_MAX;
                    int d2 = INT_MAX;

                    if (i-1>=0) {
                        d1 = min(d1, d[i-1][j]);
                    }
                    if (j-1>=0) {
                        d1 = min(d1, d[i][j-1]);
                    }
                    if (i+1 < N) {
                        d1 = min(d1, d[i+1][j]);
                    }

                    if (i-1>=0) {
                        d2 = min(d2, d[i-1][j+1]);
                    }
                    if (j+2 < M) {
                        d2 = min(d2, d[i][j+2]);
                    }
                    if (i+1 < N) {
                        d2 = min(d2, d[i+1][j+1]);
                    }

                    if (d1 != INT_MAX && d2 != INT_MAX)
                        minm = min(d1+d2+2, minm);

                }
            }
        }
    }

    return minm;
}

int main()
{
    scanf("%d %d", &N, &M);
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            scanf(" %c", g[i] + j);
            if (g[i][j] == 'H') {
                Hi = i, Hj = j;
            }
        }
    }

    if (!hasSeats()) {
        cout << "Hi and Ho will not have lunch." << endl;
    }
    else {
        dijkstra();

        int dist = solve();
        if (dist == INT_MAX) {
            cout << "Hi and Ho will not have lunch." << endl;
        }
        else {
            cout << dist << endl;
        }
    }
}