[HNOI 2007] 紧急疏散

[题目链接]

https://www.lydsy.com/JudgeOnline/problem.php?id=1189

[算法]

首先 ， 答案具有单调性 ， 不妨二分答案” 第mid秒是否可以完成疏散 ”

检验时 ， 首先通过广度优先搜索BFS求出每扇门到每个空地的距离

然后建图 ， 判断最大流是否等于空地的数量

详见代码

时间复杂度： O(dinic(N ^ 3 , N ^ 3) log N ^ 2)

[代码]

#include<bits/stdc++.h>
using namespace std;
#define MAXN 16100
#define MAXD 25
const int inf = 2e9;
const int dx[] = { ,  , - , };
const int dy[] = {- ,  ,  , };

struct edge
{
        int to , w , nxt;
} e[MAXN << ];

int tot , cntk , cntd , S , T , n , m;
int head[MAXN] , depth[MAXN];
int point[MAXD][MAXD];
int dist[MAXN][MAXD][MAXD];
char mp[MAXD][MAXD];
pair<int , int> a[MAXN * MAXD];

template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }
template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }
template <typename T> inline void read(T &x)
{
    T f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
    x *= f;
}
inline void addedge(int u , int v , int w)
{
        ++tot;
        e[tot] = (edge){v , w , head[u]};
        head[u] = tot;
        ++tot;
        e[tot] = (edge){u ,  , head[v]};
        head[v] = tot;
}
inline bool valid(int x , int y)
{
        return x >=  && x <= n && y >=  && y <= m;
}
inline void do_bfs(int s)
{
        queue< pair<int , int> > q;
        q.push(make_pair(a[s].first , a[s].second));
        memset(dist[s] , 0x3f , sizeof(dist[s]));
        dist[s][a[s].first][a[s].second] = ;
        while (!q.empty())
        {
                pair<int , int> cur = q.front();
                q.pop();
                for (int i = ; i < ; i++)
                {
                        int nx = cur.first + dx[i] , ny = cur.second + dy[i];
                        if (valid(nx , ny) && mp[nx][ny] == '.')
                        {
                                if (dist[s][cur.first][cur.second] +  < dist[s][nx][ny])
                                {
                                        dist[s][nx][ny] = dist[s][cur.first][cur.second] + ;
                                        q.push(make_pair(nx , ny));
                                }
                        }
                }
        }
}
inline bool bfs()
{
        int l , r;
        static int q[MAXN];
        q[l = r = ] = S;
        memset(depth ,  ,sizeof(depth));
        depth[S] = ;
        while (l <= r)
        {
                int cur = q[l++];
                for (int i = head[cur]; i; i = e[i].nxt)
                {
                        int v = e[i].to , w = e[i].w;
                        if (w >  && !depth[v])
                        {
                                depth[v] = depth[cur] + ;
                                q[++r] = v;
                                if (v == T) return true;
                        }
                }
        }
        return false;
}
inline int dinic(int u , int flow)
{
        int rest = flow , ret = ;
        if (u == T) return flow;
        for (int i = head[u]; i && rest; i = e[i].nxt)
        {
                int v = e[i].to , w = e[i].w;
                if (depth[v] == depth[u] +  && w)
                {
                        int k = dinic(v , min(rest , w));
                        if (!k) depth[v] = ;
                        e[i].w -= k;
                        e[i ^ ].w += k;
                        rest -= k;
                }
        }
        return flow - rest;
}
inline bool check(int mid)
{
        S = cntk + cntd * mid + cntd + ;
        T = S + ;
        tot = ;
        for (int i = ; i <= T; i++) head[i] = ;
        for (int i = ; i <= n; i++)
        {
                for (int j = ; j <= m; j++)
                {
                        if (mp[i][j] == '.')
                                addedge(S , point[i][j] , );
                }
        }
        for (int i = ; i <= cntd; i++)
        {
                for (int j = ; j <= n; j++)
                {
                        for (int k = ; k <= m; k++)
                        {
                                if (mp[j][k] == '.' && dist[i][j][k] <= mid)
                                        addedge(point[j][k] , cntk + (i - ) * mid + dist[i][j][k] , );
                        }
                }
        }
        for (int i = ; i <= cntd; i++)
        {
                for (int j = ; j <= mid; j++)
                {
                      addedge(cntk + (i - ) * mid + j , cntk + cntd * mid + i , mid - j + );
                }
        }
        for (int i = ; i <= cntd; i++) addedge(cntk + cntd * mid + i , T , mid);
        int ret = ;
        while (bfs())
        {
                while (int flow = dinic(S , inf)) ret += flow;
        }
        return ret == cntk;
}

int main()
{

        scanf("%d%d" , &n , &m);
        for (int i = ; i <= n; i++) scanf("%s" , mp[i] + );
        for (int i = ; i <= n; i++)
        {
                for (int j = ; j <= m; j++)
                {
                        if (mp[i][j] == '.')
                                point[i][j] = ++cntk;
                        if (mp[i][j] == 'D') a[++cntd] = make_pair(i , j);
                }
        }
        for (int i = ; i <= cntd; i++) do_bfs(i);
        int l =  , r = n * m , ans = -;
        while (l <= r)
        {
                int mid = (l + r) >> ;
                if (check(mid))
                {
                        ans = mid;
                        r = mid - ;
                }    else l = mid + ;
        }
        if (ans >= ) printf("%d\n" , ans);
        else printf("impossible\n");

        return ;

}