Codeforces Round #355 (Div. 2) D. Vanya and Treasure

题目大意： 给你一个n × m 的图，有p种宝箱， 每个点上有一个种类为a[ i ][ j ]的宝箱，a[ i ][ j ] 的宝箱里有 a[ i ][ j ] + 1的钥匙，第一种宝箱是没有锁的，

第p类宝箱只有一个且里面由宝藏，你现在在（1 ，1）问你最少需要多少步才能拿到宝藏。 （n, m <= 300）

思路：这题真的好恶心啊。。。  我们考虑p类宝箱只能从p - 1类转移过来， 这样我们就能从第一类宝箱开始往后递推， 但是最坏的情况， p 类 和p - 1类，都有45000

个点， 那么复杂度就会很大。。。  所以我们要分类讨论， 对于 (p.size()) * (p + 1. size()) > n * m 的点我们在图上进行暴力转移，复杂度微n × m， 否则我们直接暴力

转移。。。

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define pii pair<int,int>
#define piii pair<int, pair<int,int>>
using namespace std;

const int N=300+1;
const int M=1e4+7;
const int inf=0x3f3f3f3f;
const LL INF=0x3f3f3f3f3f3f3f3f;
const int mod=1e9 + 7;

vector<pair<int, pii>> vec[N * N];
int n, m, p, idx, a[N][N], S, T, f[N * N], hs[N][N], vis[N][N];
bool flag[N][N];
int dx[] = {1, -1, 0, 0}, dy[] = {0 ,0 , 1, -1};

int dis(pii &a, pii &b) {
    return abs(a.fi - b.fi) + abs(a.se - b.se);
}

bool check(int x, int y) {
    if(x < 1 || x > n) return false;
    if(y < 1 || y > m) return false;
    return true;
}

void bfs(int p) {
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            flag[i][j] = false;
            vis[i][j] = inf;
        }
    }
    queue<piii> Q;
    for(auto u : vec[p]) {
        Q.push(mk(f[u.fi], u.se));
        vis[u.se.fi][u.se.se] = f[u.fi];
    }

    while(!Q.empty()) {
        piii u = Q.front(); Q.pop();
        for(int i = 0; i < 4; i++) {
            piii nx = mk(vis[u.se.fi][u.se.se] + 1, mk(u.se.fi + dx[i], u.se.se + dy[i]));
            if(check(nx.se.fi, nx.se.se)) {
                if(vis[nx.se.fi][nx.se.se] > nx.fi)
                {
                    vis[nx.se.fi][nx.se.se] = nx.fi;
                    if(!flag[nx.se.fi][nx.se.se]) {
                        flag[nx.se.fi][nx.se.se] = true;
                        Q.push(nx);
                    }
                }
            }
        }
        flag[u.se.fi][u.se.se] = false;
    }

    for(auto u : vec[p + 1]) {
        f[u.fi] = vis[u.se.fi][u.se.se];
    }
}

int main() {
    memset(f, inf, sizeof(f));

    scanf("%d%d%d", &n, &m, &p);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            scanf("%d", &a[i][j]);

    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            vec[a[i][j]].push_back(mk(++idx, mk(i, j)));
            hs[i][j] = idx;
            if(a[i][j] == p) {
                S = 0;
                T = idx;
            }
        }
    }
    f[0] = 0;
    vec[0].push_back(mk(0, mk(1, 1)));
    for(int i = 1; i <= p; i++) {
        if(vec[i - 1].size() * vec[i].size() <= n * m) {
            for(auto u : vec[i - 1]) {
                for(auto v : vec[i]) {
                    f[v.fi] = min(f[v.fi], f[u.fi] + dis(u.se, v.se));
                }
            }
        } else {
            bfs(i - 1);
        }
    }
    printf("%d
", f[T]);
    return 0;
}
/*
*/