HDU - 2732 Leapin' Lizards(ISAP Dinic EK)

最新推荐文章于 2019-07-30 00:00:43 发布
最新推荐文章于 2019-07-30 00:00:43 发布
阅读量921 收藏
点赞数
分类专栏： ACM-图论-网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L123012013048/article/details/47217179
版权

题目大意：给出两张地图，第一张地图代表的是每根柱子的高度，第二张地图代表的是每只蜥蜴所在的位置
每根柱子只能站一只蜥蜴，蜥蜴离开该柱子时，柱子的高度会下降一个单元，当柱子的高度为0时，该柱子将不可用
现在给出每只蜥蜴能跳跃的距离，问最少有多少只蜥蜴逃不出来

解题思路：将柱子拆成2个点，权值为柱子的高度
将每只蜥蜴所在的位置和超级源点连接，权值为1
将能通到外界的柱子连接到超级汇点，权值为INF
如果柱子间的距离满足蜥蜴跳跃的距离，连接起来，权值为INF
这样图就完成了

ISAP：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define N 2010
#define INF 0x3f3f3f3f

struct Edge {
    int from, to, cap, flow;
    Edge() {}
    Edge(int from, int to, int cap, int flow): from(from), to(to), cap(cap), flow(flow) {}
};

struct ISAP {
    int p[N], num[N], cur[N], d[N];
    int t, s, n, m;
    bool vis[N];

    vector<int> G[N];
    vector<Edge> edges;

    void init(int n, int m) {
        this->n = n; this->m = m;
        for (int i = 0; i <= n; i++) {
            G[i].clear();
            d[i] = INF;
        }
        edges.clear();
    }

    void AddEdge(int from, int to, int cap) {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        int m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }

    bool BFS() {
        memset(vis, 0, sizeof(vis));

        queue<int> Q;
        d[t] = 0;
        vis[t] = 1;
        Q.push(t);

        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();

            for (int i = 0; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i] ^ 1];
                if (!vis[e.from] && e.cap > e.flow) {
                    vis[e.from] = true;
                    d[e.from] = d[u] + 1;
                    Q.push(e.from);
                }
            }
        }
        return vis[s];
    }

    int Augment() {
        int u = t, flow = INF;
        while (u != s) {
            Edge &e = edges[p[u]];
            flow = min(flow, e.cap - e.flow);
            u = edges[p[u]].from;
        }

        u = t;
        while (u != s) {
            edges[p[u]].flow += flow;
            edges[p[u] ^ 1].flow -= flow;
            u = edges[p[u]].from;
        }
        return flow;
    }

    int Maxflow(int s, int t) {
        this->s = s; this->t = t;
        int flow = 0;
        BFS();
        if (d[s] > n)
            return 0;

        memset(num, 0, sizeof(num));
        memset(cur, 0, sizeof(cur));
        for (int i = 0; i < n; i++)
            if (d[i] < INF)
                num[d[i]]++;
        int u = s;

        while (d[s] <= n) {
            if (u == t) {
                flow += Augment();
                u = s;
            }
            bool ok = false;
            for (int i = cur[u]; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i]];
                if (e.cap > e.flow && d[u] == d[e.to] + 1) {
                    ok = true;
                    p[e.to] = G[u][i]; 
                    cur[u] = i;
                    u = e.to;
                    break;
                }
            }

            if (!ok) {
                int Min = n;
                for (int i = 0; i < G[u].size(); i++) {
                    Edge &e = edges[G[u][i]];
                    if (e.cap > e.flow)
                        Min = min(Min, d[e.to]);
                }
                if (--num[d[u]] == 0)
                    break;
                num[d[u] = Min + 1]++;
                cur[u] = 0;
                if (u != s)
                    u = edges[p[u]].from;
            }
        }
        return flow;
    }
};

ISAP isap;
#define M 110
#define ABS(x) ((x) > 0 ? x : (-(x)))
#include <cstring>
char map1[25][M], map2[25][M];
int n, d, m, cas = 1;

void init() {
    scanf("%d%d", &n, &d);
    for (int i = 0; i < n; i++)
        scanf("%s", map1[i]);
    for (int i = 0; i < n; i++)
        scanf("%s", map2[i]);

    m = strlen(map1[0]);
    int s = n * m * 2, t = s + 1;
    isap.init(t, 0);

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) 
            if (map1[i][j] - '0') {
                isap.AddEdge(i * m + j, n * m + i * m + j, map1[i][j] - '0');
            }

    int cnt = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (map2[i][j] == 'L') {
                isap.AddEdge(s, i * m + j, 1);
                cnt++;
            }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) {
            if (i < d || j < d || j >= m - d || i >= n - d) {
                isap.AddEdge(i * m + j + n * m, t, INF);
            }
        }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            for (int k = 0; k < n; k++)
                for (int l = 0; l < m; l++)
                    if (!(i == k && l == m) && d >= ABS(i - k) + ABS(j - l))
                        isap.AddEdge(i * m + j + n * m, k * m + l, INF);
    int ans = isap.Maxflow(s, t);

    printf("Case #%d: ", cas++);
    if (ans == cnt) 
        printf("no lizard was left behind.\n");
    else if(ans + 1 == cnt)
        printf("1 lizard was left behind.\n");
    else 
        printf("%d lizards were left behind.\n", cnt - ans);
}

int main() {
    int test;
    scanf("%d", &test);
    while (test--) {
        init();

    }
    return 0;
}

EK

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <vector>
using namespace std;
#define N 1010
#define INF 0x3f3f3f3f


struct Edge{
    int from, to, cap, flow;
    Edge() {}
    Edge(int from, int to, int cap, int flow): from(from), to(to), cap(cap), flow(flow){}
};

struct EK{
    vector<int> G[N];
    vector<Edge> edges;
    int s, t, n, m, p[N];
    bool vis[N];

    void init(int n, int m) {
        this->n = n; this->m = m;
        for (int i = 0; i <= n; i++)
            G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int cap) {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        int m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }

    bool BFS() {
        queue<int> q;
        memset(vis, 0, sizeof(vis));
        vis[s] = 1;
        q.push(s);

        while (!q.empty()) {
            int u = q.front();
            q.pop();

            for (int i = 0; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i]];
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = true;
                    p[e.to] = G[u][i];
                    if (e.to == t)
                        return true;
                    q.push(e.to);
                }
            }
        }
        return false;
    }

    int Augment() {
        int flow = INF, u = t;
        while (u != s) {
            Edge &e = edges[p[u]];
            flow = min(flow, e.cap - e.flow);
            u = e.from;
        }

        u = t;
        while (u != s) {
            edges[p[u]].flow += flow;
            edges[p[u] ^ 1].flow -= flow;
            u = edges[p[u]].from;
        }
        return flow;
    }

    int Maxflow(int s, int t) {
        this->s = s; this->t = t;
        int flow = 0;

        while (BFS()) {
            flow += Augment();
        }
        return flow;
    }
};

EK ek;



#define M 110
#define ABS(x) ((x) > 0 ? x : (-(x)))
#include <cstring>
char map1[25][M], map2[25][M];
int n, d, m, cas = 1;

void init() {
    scanf("%d%d", &n, &d);
    for (int i = 0; i < n; i++)
        scanf("%s", map1[i]);
    for (int i = 0; i < n; i++)
        scanf("%s", map2[i]);

    m = strlen(map1[0]);
    int s = n * m * 2, t = s + 1;
    ek.init(t, 0);

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) 
            if (map1[i][j] - '0') {
                ek.AddEdge(i * m + j, n * m + i * m + j, map1[i][j] - '0');
            }

    int cnt = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (map2[i][j] == 'L') {
                ek.AddEdge(s, i * m + j, 1);
                cnt++;
            }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) {
            if (i < d || j < d || j >= m - d || i >= n - d) {
                ek.AddEdge(i * m + j + n * m, t, INF);
            }
        }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            for (int k = 0; k < n; k++)
                for (int l = 0; l < m; l++)
                    if (!(i == k && l == m) && d >= ABS(i - k) + ABS(j - l))
                        ek.AddEdge(i * m + j + n * m, k * m + l, INF);
    int ans = ek.Maxflow(s, t);

    printf("Case #%d: ", cas++);
    if (ans == cnt) 
        printf("no lizard was left behind.\n");
    else if(ans + 1 == cnt)
        printf("1 lizard was left behind.\n");
    else 
        printf("%d lizards were left behind.\n", cnt - ans);
}

int main() {
    int test;
    scanf("%d", &test);
    while (test--) {
        init();

    }
    return 0;
}

Dinic

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define N 1010
#define INF 0x3f3f3f3f

struct Edge{
    int from, to, cap, flow;
    Edge() {}
    Edge(int from, int to, int cap, int flow) : from(from), to(to), cap(cap), flow(flow) {}
};

struct Dinic{
    int n, m, s, t;
    vector<Edge> edges;
    vector<int> G[N];
    bool vis[N];
    int d[N], cur[N];

    void init(int n, int m) {
        this->n = n; this->m = m;
        for (int i = 0; i <= n; i++) {
            G[i].clear();
        }
        edges.clear();
    }

    void AddEdge(int from, int to, int cap) {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        int m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    } 

    bool BFS() {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;

        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();
            for (int i = 0; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i]];
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = true;
                    d[e.to] = d[u] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x, int a) {
        if (x == t || a == 0)
            return a;

        int flow = 0, f;
        for (int i = cur[x]; i < G[x].size(); i++) {
            Edge &e = edges[G[x][i]];
            if (d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
                e.flow += f;
                edges[G[x][i] ^ 1].flow -= f;
                flow += f;
                a -= f;
                if (a == 0)
                    break;
            }
        }
        return flow;
    }

    int Maxflow(int s, int t) {
        this->s = s; this->t = t;
        int flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }
};

Dinic dinic;


#define M 110
#define ABS(x) ((x) > 0 ? x : (-(x)))
#include <cstring>
char map1[25][M], map2[25][M];
int n, d, m, cas = 1;

void init() {
    scanf("%d%d", &n, &d);
    for (int i = 0; i < n; i++)
        scanf("%s", map1[i]);
    for (int i = 0; i < n; i++)
        scanf("%s", map2[i]);

    m = strlen(map1[0]);
    int s = n * m * 2, t = s + 1;
    dinic.init(t, 0);

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) 
            if (map1[i][j] - '0') {
                dinic.AddEdge(i * m + j, n * m + i * m + j, map1[i][j] - '0');
            }

    int cnt = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (map2[i][j] == 'L') {
                dinic.AddEdge(s, i * m + j, 1);
                cnt++;
            }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) {
            if (i < d || j < d || j >= m - d || i >= n - d) {
                dinic.AddEdge(i * m + j + n * m, t, INF);
            }
        }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            for (int k = 0; k < n; k++)
                for (int l = 0; l < m; l++)
                    if (!(i == k && l == m) && d >= ABS(i - k) + ABS(j - l))
                        dinic.AddEdge(i * m + j + n * m, k * m + l, INF);
    int ans = dinic.Maxflow(s, t);

    printf("Case #%d: ", cas++);
    if (ans == cnt) 
        printf("no lizard was left behind.\n");
    else if(ans + 1 == cnt)
        printf("1 lizard was left behind.\n");
    else 
        printf("%d lizards were left behind.\n", cnt - ans);
}

int main() {
    int test;
    scanf("%d", &test);
    while (test--) {
        init();

    }
    return 0;
}
暗金色
关注
专栏目录
HDU 2732 Leapin' Lizards (最大流)
HHH_go_的博客
12-14 521
题目链接 题目大意：有一些蜥蜴在一些迷宫里，迷宫的行数为n列数没给，每个蜥蜴每次可以跳跃的最大距离为d，现在给出两个矩阵，第一个描述的是每个位置最多可以被走几次，第二个描述的是哪里有蜥蜴，问最少有几只蜥蜴无法走出迷宫。 分析建图： 这也是一个最大流问题，通过贪心的思想可以知道： 如果一个位置能够直接跳出迷宫，那么最优方案肯定是直接跳出，于是可以将这些点直接与汇点相连。 因
Leapin' Lizards 【HDU - 2732】【最大流】
既然弱小，就只顾变强就是了
04-15 204
题目链接 题意：就是给你这样的N*M的点（其中M还没有给出，但是M可以算得），然后先输出N、D，N行，D是每个青蛙能跳的距离（欧拉距离，以为是曼哈顿距离的我WA了两发…… QAQ），然后是第一张N*M的图，代表着的是每个点能被起跳的次数，从它起跳需要消耗一次，然后第二幅N*M的图代表的是是否有青蛙。 直接最大流就是了，但是这里的D可能会>3，其他人错的原因，我完全是被卡了欧拉距离...
HDU ~ 2732 ~ Leapin' Lizards（最大流，结点容量）
张松超的博客
11-20 232
题意 T组测试数据，每组测试数据输入n，d，表示有两个n行的矩阵，保证列数相等但是没有输入是多少列。 第一个矩阵，每个点有一根柱子，每个柱子的高度&amp;lt;10。 第二个矩阵，‘L’表示该点有一只蜥蜴，‘.’表示啥也没有。 由于作用力与反作用力的原因，柱子上每当有一只蜥蜴跳过柱子高度就会减少1，柱子高度为0时不能再有蜥蜴跳过。蜥蜴跳跃距离为d，行数之差+列数之差距离不超过d即可进行跳跃。 思路 ...
【HDU】 2732 Leapin' Lizards
S_Black的专栏
05-06 899
Leapin’ Lizards题目链接 Leapin’Lizards 题目大意 给你两个图，一个用0，1，2，3表示，一个用 L 或 . 表示。其中用L表示的图中，有L的位置表示有蜥蜴，没有L的位置表示没有蜥蜴。用数字表示的图中，数字表示当前位置柱子的高度，每次一个蜥蜴可以从一个柱子跳到距离d以内的另外一个柱子，每跳跃一次，当前柱子的高度就减一，问最后会有多少只蜥蜴被困在里面。 题解 首先，
HDU 2732 Leapin' Lizards(最大流)
code
08-31 2116
HDU 2732 Leapin' Lizards(最大流) http://acm.hdu.edu.cn/showproblem.php?pid=2732 题意:        给你一个网格,网格上的一些位置上有一只蜥蜴,所有蜥蜴的最大跳跃距离是d,如果一只蜥蜴能跳出网格边缘,那么它就安全了.且每个网格有一个最大跳出次数x,即最多有x只蜥蜴从这个网格跳出,这个网格就再也不能有蜥蜴进来了.问你最
HDU-2000-2099.rar_hdu
09-19
这个名为"HDU-2000-2099.rar_hdu"的压缩包包含了该平台从2000到2099共100道题目的源代码。这些题目涵盖了初级到高级的各种算法，对于学习和提升编程技能非常有帮助。 首先，我们来看看这些题目可能涉及到的基础知识...
HDU-2000-2099.zip_hdu2000
最新发布
09-23
【标题】"HDU-2000-2099.zip_hdu2000" 是一个包含杭电（Hangzhou Dianzi University）ACM竞赛题目解题报告的压缩包，覆盖了编号从2000到2099的题目。这个资源对于学习算法、提高编程技巧以及准备ACM/ICPC（国际大学...
HDU-GO-crx插件
04-02
HDU-GO是一款专为杭州电子科技大学（HDU）学生设计的Chrome浏览器插件，它极大地简化了学生的选课流程并提供了多项实用功能。这款插件以中文简体界面呈现，便于国内用户使用，尤其对杭电的学生来说，是他们日常学习...
HDU-EID-V2-核心板1
08-03
在本话题中，我们关注的是一个名为"HDU-EID-V2-核心板1"的特定设计，它涉及到STM32的核心组件、接口、电源管理和调试配置。 首先，核心板设计中提到了F103和F207两个型号的STM32芯片。F103和F207属于STM32的不同...
HDU-ACM_java.rar_hdu
09-22
【标题】"HDU-ACM_java.rar" 是一个针对杭州电子科技大学（HDU）ACM竞赛的资源压缩包，其中包含的是使用Java语言编写的算法解决方案。这个压缩包主要面向那些参与或准备参与ACM国际大学生程序设计竞赛（ICPC）的参赛...
HDU-2732 (Leapin' Lizards) 网络流
xdlove
08-20 1018
HDU-2732 (Leapin' Lizards) 网络流
HDU 2732 Leapin' Lizards（拆点法+最大流）
AC_Arthur的专栏
08-30 1339
该题是一道比较简单拆点+最大流的题目，因为每个柱子都有一定的寿命，很容易将其对应成流量，那么处理结点容量的一般方法当然是拆点法 。该题反而对边的容量没有要求，为保险起见可以设成无穷大。   该题的思路很好想，建议独立编写代码 。 推荐题目： 点击打开链接    结点法的一些见解 也可以看这里。 细节参见代码： #include using namespace std; typedef lon
HDU2732Leapin' Lizards(最大流+拆点)
Rain
03-02 639
HDU2732Leapin' Lizards(最大流+拆点) 题目传送门：http://acm.hdu.edu.cn/showproblem.php?pid=2732 题意:        给你一个网格,网格上的一些位置上有一只蜥蜴,所有蜥蜴的最大跳跃距离是d,如果一只蜥蜴能跳出网格边缘,那么它就安全了.且每个网格有一个最大跳出次数x,即最多有x只蜥蜴从这个网格跳出,这个网格就再也不能有蜥蜴进来了.问你最少有多少只蜥蜴跳不出网格.
hdu2732——建图最大流+拆点
mumei的博客
07-30 317
题目链接：https://cn.vjudge.net/problem/HDU-2732 Your platoon of wandering lizards has entered a strange room in the labyrinth you are exploring. As you are looking around for hidden treasures, one of the...
HDU2732 最大流..
NineFailure的博客
04-03 432
Your platoon of wandering lizards has entered a strange room in the labyrinth you are exploring. As you are looking around for hidden treasures, one of the rookies steps on an innocent-looking stone an
hdu2732最大流
终究我要华丽逆袭
08-26 1384
这道题目就是拆点，给出是每个点的容量限制，每个点如果可以escape就对汇点连条inf，每个点对可到的柱子连条inf，源点到有lizard的地方连条长为1的边，ans就是sum（lizard)-最大流#include #include int T,n,d,m,cnt,dis[1000],gap[1000],head[1000],s,t,sum,N; const int inf=10000000;
hdu 2732&&poj 2711 (最大流)
菜鸟起航的专栏
08-10 937
非常好的一道拆点题目，终于学会isap了，递归的，这几天要把非递归实现的敲出来，， 题意：给出蜥蜴可以跳的最大距离,从一根柱子跳向可以到达的任意柱子，每个柱子有高度，蜥蜴没跳一次柱子会下降1米，问有多少蜥蜴跳不出所给的图。 建图：源点与每个蜥蜴所在的柱子建边流量为1，应为柱子间可以互相达到的，所以每个柱子应该拆成两个点，每根柱子相当于一条边，流量为柱子的高度，没两个可以互相到达的柱子间建边（一
hdu2732 网络流经典建图
liujc_的专栏
04-18 1195
http://acm.hdu.edu.cn/showproblem.php?pid=2732 题目大意： 给了n和d，表示有n行的图，（列数没给），对于每一个人都可以最长跳d的距离，对于每一个柱子有一个限定条件，只能从这里跳出去多少次。给了两张图，一张表示柱子的限定条件，一张给了现在那些柱子上有人。问有几个人不能跳到图的外面。 思路： 最大流建图。将图的外面抽象为一个汇点t，对于图中本来就可
POJ 3680 Intervals(区间k覆盖问题)
静静地码
09-04 2056
题目大意：给出N个区间，每个区间都有相应的收益。限制是每个数最多被覆盖k次 问如何选择区间，才能使得受益最大解题思路：区间k覆盖问题，首先点和边很多，所以离散化 接着是源点连接第一个点，容量为k，费用为0(保证每个数最多被覆盖k次) 最后一个点连接汇点，容量为k，费用为0 剩下的是点之间的关系了 我们按从小到达排序，然后每个点之间连一条边，容量至少大于等于k(因为源点到第一个点已经限制了是
UVA - 11613 Acme Corporation(最小费用流)
静静地码
08-25 1888
题目大意：A公司生产一种元素，给出该元素在未来M个月中每个月的单位售价，最大生产量，生产成本，最大销售量和最大存储时间，和每月存储代价，问这家公司在M个月内所能赚大的最大利润解题思路：这题建图还是比较简单的。主要说一下怎么跑出答案吧。我用的是MCMF，建边的时候，费用我用的是相反数，所以得到最小费用后要去相反数 MCMF的时候，用一个数组纪录了到达汇点时所花费的最小价值，因为取的是相反数，所以当价
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值