bzoj1189: [HNOI2007]紧急疏散evacuate

看到黄学长的做法觉得有点疑问

网上搜了下发现确实有问题

看到PoPoQQQ大爷的啦 http://blog.csdn.net/popoqqq/article/details/41594921

然后怎么办呢

得把每个出口拆成很多个时刻 每个时刻到t建边

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<iostream>

using namespace std;

void setIO(const string& s) {
    freopen((s + ".in").c_str(), "r", stdin);
    freopen((s + ".out").c_str(), "w", stdout);
}
template<typename Q> Q read(Q& x) {
    static char c, f;
    for(f = 0; c = getchar(), !isdigit(c); ) if(c == '-') f = 1;
    for(x = 0; isdigit(c); c = getchar()) x = x * 10 + c - '0';
    if(f) x = -x;
    return x;
}
template<typename Q> Q read() {
    static Q x; read(x); return x;
}

// ISAP
const int N = 40000 + 10, M = 500000 + 10, INF = ~0u >> 1;
const int R = 400;

struct Edge {
    int to, cap, adv;
    Edge *next;
    void init() {adv = cap;}
    Edge(int to = 0, int cap = 0, Edge *next = 0) : to(to), cap(cap), next(next) {}
}pool[M * 2], *pis = pool, *fir[N], *pre[N];

void AddEdge(int u, int v, int w) {
    fir[u] = new(pis++) Edge(v, w, fir[u]);
    fir[v] = new(pis++) Edge(u, 0, fir[v]);
}

Edge *inv(Edge *p) {
    return pool + ((p - pool) ^ 1);
}

namespace ISAP {
    int d[N], q[N], ql, qr;
    int n, s, t;
    int num[N];
    Edge *cur[N];
    
    void insert(int u, int dis) {
        if(d[u] == n) {
            d[u] = dis;
            q[qr++] = u;
        }
    }
    
    void BFS() {
        for(int u = 1; u <= n; u++) {
            d[u] = n;
        }
        insert(t, 0);
        while(ql ^ qr) {
            int u = q[ql++];
            for(Edge *p = fir[u]; p; p = p->next) if(inv(p)->adv){
                insert(p->to, d[u] + 1);
            }
        }
    }
    
    int Augment() {
        int a = INF;
        for(int u = t; u != s; u = inv(pre[u])->to) {
            a = min(a, pre[u]->adv);
        }
        for(int u = t; u != s; u = inv(pre[u])->to) {
            pre[u]->adv -= a;
            inv(pre[u])->adv += a;
        }
        return a;
    }
    
    int Maxflow() {
        memset(num, 0, sizeof num);
        BFS();
        for(int u = 1; u <= n; u++) {
            cur[u] = fir[u];
            num[d[u]]++;
        }
        for(int i = 1; i < d[s]; i++) {
            if(!num[i]) return 0;
        }
        int flow = 0;
        for(int u = s; d[s] < n; ) {
            if(u == t) {
                flow += Augment();
                u = s;
            }
            int ok = 0;
            for(Edge *&p = cur[u]; p; p = p->next) if(p->adv) {
                int v = p->to;
                if(d[v] + 1 == d[u]) {
                    pre[u = v] = p;
                    ok = 1;
                    break;
                }
            }
            if(!ok) {
                int &dis = d[u];
                if(!--num[dis]) break;
                dis = n;
                for(Edge *p = (cur[u] = fir[u]); p; p = p->next) if(p->adv) {
                    dis = min(dis, d[p->to] + 1);
                }
                num[dis]++;
                if(u != s) u = inv(pre[u])->to;
            }
        }
        return flow;
    }
    
    int main(int _n, int _s, int _t) {
        n = _n, s = _s, t = _t;
        return Maxflow();
    }
}

const int maxn = 20 + 5;

int n, m;
char g[maxn][maxn];

int encode(int x, int y) {
    return (x - 1) * m + y;
}

void discode(int s, int& x, int& y) {
    y = (s - 1) % m + 1;
    x = (s - y) / m + 1;
}

int mid;

int q[maxn * maxn], ql, qr;
int d[maxn][maxn];

void insert(int x, int y, int dis) {
    if(d[x][y] > dis) {
        d[x][y] = dis;
        if(g[x][y] != 'D') q[qr++] = encode(x, y);
    }
}

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

bool inmap(int x, int y) {
    return 0 < x && x <= n && 0 < y && y <= m;
}

int tot;
#include<vector>
vector<int> doors;
int ND[R][R];
Edge *rec[R][R];

void BFS(int sx, int sy) {//(2, 2) -> (n - 1, n - 1)
    memset(d, 0x3f, sizeof d);
    ql = qr = 0;
    insert(sx, sy, 0);
    while(ql ^ qr) {
        int s = q[ql++], x, y;
        discode(s, x, y);
        for(int k = 0; k < 4; k++) {
            int xx = x + dx[k], yy = y + dy[k];
            if(inmap(xx, yy) && g[xx][yy] != 'X') insert(xx, yy, d[x][y] + 1);
        }
    }
}

void build(int s, int& cnt) {
    for(int x0 = 2; x0 < n; x0++) {
        for(int y0 = 2; y0 < m; y0++) if(g[x0][y0] == '.') {
            ++cnt;
            BFS(x0, y0); int u = encode(x0, y0);
            AddEdge(s, u, 1);
            for(unsigned i = 0; i < doors.size(); i++) {
                int v = doors[i], x, y; discode(v, x, y);
                if(d[x][y] < R) AddEdge(u, ND[v][d[x][y]], 1);
            }
        }
    }
}

void rebuild(int mid) {
    for(Edge *p = pool; p != pis; (p++)->init());
    for(unsigned i = 0; i < doors.size(); i++) {
        int u = doors[i];
        for(int j = mid + 1; j < R; j++) rec[u][j]->adv = 0;
    }
}

void find_doors(int t) {
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j += m - 1) {
            if(g[i][j] == 'D') {
                doors.push_back(encode(i, j));
            }
        }
    }
    for(int j = 2; j < m; j++) {
        for(int i = 1; i <= n; i += n - 1) {
            if(g[i][j] == 'D') {
                doors.push_back(encode(i, j));
            }
        }
    }
    tot = n * m;
    for(unsigned i = 0; i < doors.size(); i++) {
        int u = doors[i];
        for(int j = 1; j < R; j++) {
            ND[u][j] = ++tot;
            AddEdge(tot, t, 1);
            rec[u][j] = pis - 2;
            if(j > 1) AddEdge(tot - 1, tot, INF);
        }
    }
}

int main() {
#ifdef DEBUG
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    
    read(n), read(m);
    for(int i = 1; i <= n; i++) {
        scanf("%s", g[i] + 1);
    }
    
    int s = 40000 + 1, t = 40000 + 2, cnt;
    
    find_doors(t);
    build(s, cnt = 0);
    int l = 0, r = R - 1, res = INF;
    while(l <= r) {
        int mid = (l + r) >> 1;
        rebuild(mid);
        int tmp = ISAP::main(t, s, t);
        if(tmp >= cnt) r = mid - 1, res = mid;
        else l = mid + 1;
    }
    if(res == INF) puts("impossible");
    else printf("%d
", res);
    
    return 0;
}