UVALive

Problem  UVALive - 3661 - Animal Run

Time Limit: 6000 mSec

Problem Description

Input

Output

Sample Input

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 0 0

Sample Output

Case 1: Minimum = 14

题解：一看就是最大流最小割，但是常规网络流的算法显然太慢了，这时候就引出了平面图最小割的概念，orz.

详见：https://wenku.baidu.com/view/a10e0529bd64783e09122ba9.html

#include <bits/stdc++.h>

using namespace std;

#define REP(i, n) for (int i = 1; i <= (n); i++)
#define sqr(x) ((x) * (x))

const int maxn = 6000000 + 100;
const int maxm = 12000000 + 100;
const int maxs = 10;

typedef long long LL;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;

const LL unit = 1LL;
const int INF = 0x3f3f3f3f;
const LL Inf = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-14;
const double inf = 1e15;
const double pi = acos(-1.0);
const LL mod = 1000000007;
const int base = 10000;

struct Edge
{
    LL to, next, w;
    Edge(LL to = 0, LL next = 0, LL w = 0) : to(to), next(next), w(w) {}
} edge[maxm];

struct HeapNode
{
    LL u, dis;
    bool operator<(const HeapNode &a) const
    {
        return dis > a.dis;
    }
};

LL head[maxn], tot;
LL n, m, we[maxm];
LL num;
LL dist[maxn];
bool vis[maxn];

void init()
{
    memset(head, -1, sizeof(head));
    tot = 0;
}

void AddEdge(LL u, LL v, LL w, LL w2)
{
    edge[tot] = Edge(v, head[u], w);
    head[u] = tot++;
    edge[tot] = Edge(u, head[v], w2);
    head[v] = tot++;
}

inline LL get_row(LL x, LL y)
{
    return x * (m + m - 1) + y;
}

inline LL get_col(LL x, LL y)
{
    return x * (m + m - 1) + y + m - 1;
}

LL Dijkstra()
{
    priority_queue<HeapNode> que;
    memset(dist, INF, sizeof(dist));
    memset(vis, false, sizeof(vis));
    for (LL i = 0; i < n - 1; i++)
    {
        LL id = get_col(i, 0);
        dist[id] = we[id];
        que.push((HeapNode){id, dist[id]});
    }
    for (LL j = 0; j < m - 1; j++)
    {
        LL id = get_row(n - 1, j);
        dist[id] = we[id];
        que.push((HeapNode){id, dist[id]});
    }
    while (!que.empty())
    {
        HeapNode x = que.top();
        que.pop();
        if (vis[x.u])
            continue;
        LL u = x.u;
        vis[u] = true;
        for (LL i = head[u]; i != -1; i = edge[i].next)
        {
            LL v = edge[i].to;
            if (!vis[v] && dist[v] > dist[u] + edge[i].w)
            {
                dist[v] = dist[u] + edge[i].w;
                que.push((HeapNode){v, dist[v]});
            }
        }
    }

    LL ans = Inf;
    for (LL j = 0; j < m - 1; j++)
    {
        ans = min(ans, dist[get_row(0, j)]);
    }
    for (LL i = 0; i < n - 1; i++)
    {
        ans = min(ans, dist[get_col(i, m - 1)]);
    }

    return ans;
}

LL iCase;

int main()
{
    //ios::sync_with_stdio(false);
    //cin.tie(0);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    while (~scanf("%lld%lld", &n, &m) && (n || m))
    {
        init();
        for (LL i = 0; i < n; i++)
        {
            for (LL j = 0; j < m - 1; j++)
            {
                scanf("%lld", &we[get_row(i, j)]);
            }
        }
        for (LL i = 0; i < n - 1; i++)
        {
            for (LL j = 0; j < m; j++)
            {
                scanf("%lld", &we[get_col(i, j)]);
            }
        }
        num = n * (m - 1) + m * (n - 1);
        LL val;
        for (LL i = 0; i < n - 1; i++)
        {
            for (LL j = 0; j < m - 1; j++)
            {
                scanf("%lld", &val);
                int a = get_row(i, j), b = get_row(i + 1, j);
                int c = get_col(i, j), d = get_col(i, j + 1);
                AddEdge(num, a, we[a], val);
                AddEdge(num, b, we[b], val);
                AddEdge(num, c, we[c], val);
                AddEdge(num, d, we[d], val);
                AddEdge(d, a, we[a], we[d]);
                AddEdge(b, c, we[c], we[b]);
                num++;
            }
        }
        LL ans = Dijkstra();
        printf("Case %d: Minimum = %lld
", ++iCase, ans);
    }
    return 0;
}