AOJ 0558

题意：在 H * W 的地图里有 N 个工厂，每个工厂分别生产硬度为1-N 的奶酪，有一只老鼠准备把所有奶酪都吃完。老鼠的初始体力值为1，每吃一个奶酪体力值加 1。已知老鼠不能吃硬度大于当前体力值的奶酪，老鼠只能向上下左右四个方向走，求吃完所有奶酪老鼠需要经过的最小步数。

分析：简单迷宫问题。不同的是，老鼠需要按1-N 的顺序把奶酪吃完。用广度优先搜索很容易求出起点到终点的最小步数。初始时，求起点到硬度值为 1 的奶酪的最小步数；接着将起点重置为此位置，继续求此位置到达硬度值为 2 的奶酪；如此类推。因此这里只需做N 次广度优先搜索，并累计其值即可。

C++代码：

#include <cstdio>
#include <iostream>
#include <queue>
#include <algorithm>

using namespace std;

typedef pair<int, int> P;     //first := x, second := y

const int INF = 100000000;
const int MAX_H = 1000;
const int MAX_W = 1000;
const int MAX_N = 9;

int H, W, N;
char maze[MAX_H][MAX_W + 1];

int sx, sy;     //start
int d[MAX_H][MAX_W];     //steps

const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};

int bfs(char c){
    //init
    for(int i = 0; i < H; i ++){
        fill(d[i], d[i] + W, INF);
    }
    d[sx][sy] = 0;
    queue<P> que;
    que.push(P(sx, sy));

    while(!que.empty()){
        P p = que.front();
        que.pop();
        //arrive
        if(maze[p.first][p.second] == c){
        //reset
        sx = p.first;
        sy = p.second;
        break;
        }

        for(int i = 0; i < 4; i ++){
            int nx = p.first + dx[i], ny = p.second + dy[i];

            if(0 <= nx && nx < H && 0 <= ny && ny < W && maze[nx][ny] != 'X' && d[nx][ny] == INF){
                que.push(P(nx, ny));
                d[nx][ny] = d[p.first][p.second] + 1;
            }
        }
    }
    return d[sx][sy];
}

void solve(){
    //start
    for(int i = 0; i < H; i ++){
        for(int j = 0; j < W; j ++){
            if(maze[i][j] == 'S'){
                sx = i;
                sy = j;
                break;
            }
        }
    }
    //bfs for 1-N
    int ans = 0;
    for(int i = 1; i <= N; i ++){
        ans += bfs('0' + i);
    }
    printf("%d\n", ans);
}

int main(int argc, char const *argv[]){

    scanf("%d %d %d", &H, &W, &N);
    for(int i = 0; i < H; i ++){
        scanf("%s", maze[i]);
    }
    solve();

    return 0;
}