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=+;
 const int M=1e4+;
 const int inf=0x3f3f3f3f;
 const LL INF=0x3f3f3f3f3f3f3f3f;
 const int mod=1e9 + ;

 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[] = {, -, , }, dy[] = { , , , -};

 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 <  || x > n) return false;
     if(y <  || y > m) return false;
     return true;
 }

 void bfs(int p) {
     for(int i = ; i <= n; i++) {
         for(int j = ; 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 = ; i < ; i++) {
             piii nx = mk(vis[u.se.fi][u.se.se] + , 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 + ]) {
         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 = ; i <= n; i++)
         for(int j = ; j <= m; j++)
             scanf("%d", &a[i][j]);

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