BZOJ 1066

1066: [SCOI2007]蜥蜴

再此用来验证dinic板子

BZOJ 1066

/**************************************************************
    Problem: 1066
    User: Dream_Tonight
    Language: C++
    Result: Accepted
    Time:52 ms
    Memory:1912 kb
****************************************************************/
 
#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
#include <string>
#include <cstdio>
#include <cmath>
#include <stack>
#include <queue>
#include <list>
#include <map>
#include <set>
#include <iostream>
#include <cstdio>
 
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 6e6 + 7;
const int inf = 0x7fffffff;
int deep[1010], head[1010], cnt = 2, cur[1010];
int mp[31][31];
int r, c, d, num = 0,S,T;char s[31];
struct node {
    int to, value, next;
} edge[1010*50];
 
inline void add(int u, int v, int w) {
    edge[cnt].to = v;
    edge[cnt].value = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}
 
inline void addEdge(int u, int v, int w) {
    add(u, v, w);
    add(v, u, 0);
}
 
//分层图
bool bfs() {
    queue<int> q;
    memset(deep, 0, sizeof(deep));
    memcpy(cur, head, sizeof(head));
    deep[S] = 1;
    q.push(S);
    while (!q.empty()) {
        int x = q.front();
        if (x == T) break; //优化
        q.pop();
        for (int i = head[x]; i != -1; i = edge[i].next) {
            if (edge[i].value && !deep[edge[i].to]) {
                deep[edge[i].to] = deep[x] + 1;
                q.push(edge[i].to);
            }
        }
    }
    return deep[T];
}
 
//增广路
int dfs(int x, int limit) {
    if (x == T) return limit;
    int flow = 0;
    for (int i = cur[x]; i != -1; i = edge[i].next) {
        cur[x] = i; //当前弧优化
        if (deep[x] == deep[edge[i].to] - 1 && edge[i].value) {
            if (int f = dfs(edge[i].to, min(edge[i].value, limit))) {
                edge[i].value -= f;
                edge[i ^ 1].value += f;
                flow += f;
                limit -= f;
                if (!limit) break;
            }
        }
    }
    return flow;
}
 
int dinic() {
    int result = 0;
    while (bfs()) {
        while (int deep = dfs(S, inf)) {
            result += deep;
        }
    }
    return num-result;
}
 
int sqr(int x) {
    return x * x;
}
 
double dist(int x1, int y1, int x2, int y2) {
    return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
 
int pos(int x, int y, int add) {
    return (x - 1) * c + y + r * c * add;
}
 
bool can(int x, int y) {
    return x <= d || r - x < d || y <= d || c - y < d;
}
 
int main() {
    scanf("%d%d%d", &r, &c, &d);
    S = 0;
    T = 2 * r * c + 1;
    memset(head,-1, sizeof(head));
    for (int i = 1; i <= r; i++) {
        scanf("%s", s + 1);
        for (int j = 1; j <= c; j++) mp[i][j] = s[j] - '0';
    }
    for (int i = 1; i <= r; i++) {
        scanf("%s", s + 1);
        for (int j = 1; j <= c; j++) {
            if (s[j] == 'L') num++, addEdge(S, pos(i, j, 0), 1);
        }
    }
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            if (mp[i][j]) {
                addEdge(pos(i, j, 0), pos(i, j, 1), mp[i][j]);
            }
        }
    }
    for (int x1 = 1; x1 <= r; x1++) {
        for (int y1 = 1; y1 <= c; y1++) {
            if (!mp[x1][y1]) continue;
            for (int x2 = 1; x2 <= r; x2++) {
                for (int y2 = 1; y2 <= c; y2++) {
                    if (x1 == x2 && y1 == y2) continue;
                    if (mp[x2][y2] && dist(x1, y1, x2, y2) <= d) {
                        addEdge(pos(x1, y1, 1), pos(x2, y2, 0), inf);
                        addEdge(pos(x2, y2, 1), pos(x1, y1, 0), inf);
                    }
                }
            }
        }
    }
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            if (can(i, j)) {
                addEdge(pos(i, j, 1), T, inf);
            }
        }
    }
    printf("%d", dinic());
    return 0;
}