uvalive 3661 Animal Run

题意：

一群动物想从动物园逃离，从一个图的左上角出发，只有到达右下角才能彻底逃离。

动物园的管理者为了防止他们逃跑，安排了若干人在路上防守。

现在问最少需要花多少人能够封锁动物逃跑的路线。

思路：

简单画一画知道，就是找一个边的集合把整个图分成两个部分，且要求这些边的权值最小，这是著名的最小割问题（虽然我没有学过。

不过可以用最短路解决。

经过尝试可以知道，从下到上的连线，从左到右的连线，从左到上的连线以及从下到右的连线均可以到达目的，其它的就不行，比如从下到左。

所以，可以以每一条边作为一个点，把左边界的边和下边界的边作为起点，右边界和上边界作为终点，求出最短路即是答案。

接下来就是连边的问题，如果i和j之间连边，那么从i连向j，那么这条边的权值就是i边的权值（这时候是把边当作点的）；若是从j向i连边，那么就是j边的权值作为这条边的权值。

最后是哪些些边之间要连边的问题，处在同一个小三角形当中的边两两之间都要连边。

一开始以为只有对角线要和两条直角边连线，最后画图发现其实两条直角边互相连线也是必须的。

如图：（自己画的，很丑）

这题用到了超级源点的技巧，然后优先队列优化的Dijkstra。

最难的还是如何给边编号的问题，我所用的编号就是题目的输入顺序，水平边和竖直边以及对角线的编号之间存在着一定的关系，可以推导得出，只不过比较繁琐，所以代码略长。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

const int N = 5e6;
const int inf = 0x3f3f3f3f;

typedef pair<int,int> pii;

int d[N];
int w[N];

struct edge
{
    int to,cost;
    edge(){};
    edge(int a,int b)
    {
        to = a;
        cost = b;
    }
};

vector<edge> es;
vector<int> g[N];

void adde(int from,int to,int cost)
{
    es.push_back(edge(to,cost));
    g[from].push_back(es.size() - 1);
}

void init(int n)
{
    es.clear();
    
    for (int i = 0;i <= n;i++) g[i].clear();
    
    memset(d,inf,sizeof(d));
}

void dij(int n)
{
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    
    d[0] = 0;
    
    pq.push(pii(0,0));
    
    while (!pq.empty())
    {
        pii x = pq.top();pq.pop();
        
        int v = x.second;
        
        if (d[v] < x.first) continue;
        
        for (int i = 0;i < g[v].size();i++)
        {
            int id = g[v][i];
            
            edge e = es[id];
            
            if (d[e.to] > e.cost + d[v])
            {
                d[e.to] = d[v] + e.cost;
                pq.push(pii(d[e.to],e.to));
            }
        } 
    }
}

int main()
{
    int n,m;
    int kase = 0;
    
    while (scanf("%d%d",&n,&m) != EOF)
    {
        if (m == 0 && n == 0) break;
        
        int cnt = 0;
        
        //init(n,m);
        
        for (int i = 0;i < n;i++)
        {
            for (int j = 0;j < m - 1;j++)
            {
                int tmp;
                
                scanf("%d",&tmp);
                
                w[++cnt] = tmp;
            }
        }
        
        for (int i = 0;i < n - 1;i++)
        {
            for (int j = 0;j < m;j++)
            {
                int tmp;
                scanf("%d",&tmp);
                w[++cnt] = tmp;
            }
        }
        
        for (int i = 0;i < n - 1;i++)
        {
            for (int j = 0;j < m - 1;j++)
            {
                int tmp;
                scanf("%d",&tmp);
                w[++cnt] = tmp;
            }
        }
        
        int rs = 1,cs = n * (m - 1) + 1,ds = n * (m - 1) + m * (n - 1) + 1;
        
        //int sume = n * (m - 1) + m * (n - 1) + (m - 1) * (n - 1);
        
        init(cnt);
        
        for (int i = ds;i <= cnt;i++)
        {
            int num = (i - ds) / (m - 1);
            int curds = ds + (m - 1) * num;
            int curcs = cs + num * m;
            int currs = rs + num * (m - 1);
            int tmp = i - curds;
            int curc = curcs + tmp,curr = currs + tmp;
            
            adde(curc,i,w[curc]);
            adde(i,curc,w[i]);
            adde(i,curc + 1,w[i]);
            adde(curc+1,i,w[curc+1]);
            adde(i,curr,w[i]);
            adde(curr,i,w[curr]);
            adde(curr + m - 1,i,w[curr + m - 1]);
            adde(i,curr + m - 1,w[i]);
            adde(curc,curr+m-1,w[curc]);
            adde(curr + m - 1,curc,w[curr + m - 1]);
            adde(curr,curc + 1,w[curr]);
            adde(curc+1,curr,w[curc+1]);
        }
        
        for (int i = 0;i < n - 1;i++)
        {
            adde(0,cs + i * m,0);
        }
        
        for (int i = 0;i < m - 1;i++)
        {
            adde(0,(n - 1) * (m - 1) + 1 + i,0);
        }
        
        dij(cnt);
        
        int ans = inf;
        
        for (int i = 1;i <= m - 1;i++)
        {
            ans = min(ans,d[i] + w[i]);
        }
        
        for (int i = 1;i <= n - 1;i++)
        {
            int v = n * (m - 1) + m * i;
            ans = min(ans,d[v] + w[v]);
        }
        
        printf("Case %d: Minimum = %d\n",++kase,ans);
    }
    
    return 0;
}