Bzoj 1001

最新推荐文章于 2020-04-27 20:45:05 发布

原创最新推荐文章于 2020-04-27 20:45:05 发布 · 461 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#bzoj

bzoj 专栏收录该内容

3 篇文章

订阅专栏

这里写图片描述
现在小朋友们最喜欢的”喜羊羊与灰太狼”,话说灰太狼抓羊不到，但抓兔子还是比较在行的，而且现在的兔子还比较笨，它们只有两个窝，现在你做为狼王，面对下面这样一个网格的地形：

左上角点为(1,1),右下角点为(N,M)(上图中N=4,M=5).有以下三种类型的道路 1:(x,y)<==>(x+1,y) 2:(x,y)<==>(x,y+1) 3:(x,y)<==>(x+1,y+1) 道路上的权值表示这条路上最多能够通过的兔子数，道路是无向的. 左上角和右下角为兔子的两个窝，开始时所有的兔子都聚集在左上角(1,1)的窝里，现在它们要跑到右下解(N,M)的窝中去，狼王开始伏击这些兔子.当然为了保险起见，如果一条道路上最多通过的兔子数为K，狼王需要安排同样数量的K只狼，才能完全封锁这条道路，你需要帮助狼王安排一个伏击方案，使得在将兔子一网打尽的前提下，参与的狼的数量要最小。因为狼还要去找喜羊羊麻烦.
输入

第一行为N,M.表示网格的大小，N,M均小于等于1000.接下来分三部分第一部分共N行，每行M-1个数，表示横向道路的权值. 第二部分共N-1行，每行M个数，表示纵向道路的权值. 第三部分共N-1行，每行M-1个数，表示斜向道路的权值. 输入文件保证不超过10M
输出

输出一个整数，表示参与伏击的狼的最小数量.
样例输入

3 4
5 6 4
4 3 1
7 5 3
5 6 7 8
8 7 6 5
5 5 5
6 6 6
样例输出

分析：这道题显然就是一个最小割问题，然后根据烂大街的最大流最小割定理，然后我们就可以转化成dinic或者是isap之类的算法乱搞但显然在数据规模较大的时候会被卡掉，这时候就需要我们进行思维上的转换了，转化的详细方式可以详见周冬的论文（相关我会链接附在文章后）这里就不在赘述。
好吧···我还是说说吧·····：首先我们将整个平面图划分的区域新建成点，考虑这样的一条边e(a, b)，表示连接a、b且权值为w的边，这条边将平面分为两部分A、B，那么在新的图中建立一条无向边E(A, B)，边权同样为w（如图1）。按照这种方法建图，我们得到了一个新的图。

这里写图片描述

在得到一个新图后， 在不破坏新图的前提下从源点到汇点连一条虚边， 这条虚边又构造出一个新的平面， 记这个平面为s， 无限大的平面为t， 那么s到t的一条路径即为原图的一个割。 这一点很好证明， 就像一刀切了下去， 原图变成了二分图。

这里写图片描述
然后到了这一步就可以发现从源点到汇点的每一条路径都可以将原图分为两个部分，也就是题目要求，所以现在我们只需要找到一条从源点道汇点的一条最短路径就可以了。。。对于这道题我是用堆优dij搞过的，spfa应该也行···· 其他的乱搞方法我就不清楚了··。这种转化考到的几率应该还是蛮大的，希望大家都要学会。
下面附一下我的代码（自带n倍常数，还望谅解·····）

    #include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#include <cstdlib>
#define N 2000000 + 100
#define M 6000000 + 100
#define INF 1000000000

using namespace std;

struct edge
{
    int to, w, next;
}e[M];
struct node
{
    int now, dist;
    node() { }
    node(int x, int y)
    {
        now = x;
        dist = y;
    }
    bool operator < (const node x) const
    {
        return dist > x.dist;
    }
};
int n, m, num, sum, p[N], d[N], flag[N];
void read(int &x)
{
    x = 0;
    char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9')
    {
        x = 10*x + c - '0';
        c = getchar();
    }
}
void add(int x, int y, int z)
{
    e[++num].to = y;
    e[num].w = z;
    e[num].next = p[x];
    p[x] = num;
}
void init()
{
    int x, y, z, l, r, po;
    read(n), read(m);
    if (n == 1 || m == 1)
    {
        if (n > m) swap(n, m);
        int ans = INF;
        for (int i = 1; i < m; ++i)
        {
            read(x);
            if (x < ans) ans = x;
        }
        printf("%d\n", ans);
        exit(0);
    }
    l = n - 1, r = m - 1;
    sum = 2 * l * r;
    for (int i = 1; i <= n; ++i)
    for (int j = 1; j < m; ++j)
    {
        read(z);
        po = (i-1)*r + j;
        y = po << 1;
        x = y - 2*r - 1;
        if (i == 1) x = 0;
        else if (i == n) y = sum + 1;
        add(x, y, z);
        add(y, x, z);
    }
    for (int i = 1; i < n; ++i)
    for (int j = 1; j <= m; ++j)
    {
        read(z);
        po = (i-1)*r + j - 1;
        x = po << 1;
        y = x | 1;
        if (j == 1) x = sum + 1;
        else if (j == m) y = 0;
        add(x, y, z);
        add(y, x, z);
    }
    for (int i = 1; i < n; ++i)
    for (int j = 1; j < m; ++j)
    {
        read(z);
        po = (i-1)*r + j;
        y = po << 1;
        x = y - 1;
        add(x, y, z);
        add(y, x, z);
    }
}
void dij_heap()
{
    priority_queue<node>q;
    for (int i = 1; i <= sum; ++i)
    d[i] = INF;
    d[sum+1] = INF;
    q.push(node(0, 0));
    while(!q.empty())
    {
        int x = q.top().now;
        q.pop();
        if (flag[x]) continue;
        for (int i = p[x]; i; i = e[i].next)
        {
            int k = e[i].to;
            if (d[k] > d[x] + e[i].w)
            {
                d[k] = d[x] + e[i].w;
                q.push(node(k, d[k]));
            }
        }
    }
}
void deal()
{
    dij_heap();
    printf("%d\n", d[sum+1]);
}
int main()
{
    init();
    deal();
    return 0;
}