机器人扫雷

机器人扫雷

问题描述
在一个 N× N的长方形网格区域，每个格点有一个有0个或一个地雷，地雷的重量用一个正整数表示（没有地雷也用0表示）。在区域的左上方有一个机器人扫雷车。该扫雷车需要开通一条从左上角S到向右下角T的路线，然后开辟另外一条路从T返回到左上角起点S。
规定：（1）扫雷车从起点S出发后，每一步只能向右或向下；
（2）扫雷车返回过程中，每一步只能向左或向上；
（3）除了起点S和终点T外，走过的格点是不能重复的。
扫雷开始时，sum=0，然后在路途中到达一个格点时记录扫到地雷的重量加入sum。现在要求计算，这样一个来回路径上地雷的最大重量和sum。
输入
有多组测试数据。
每组的第1行有1个整数N (1 ≤N ≤ 50) 。接着有N行，每行有N个非负整数，形成一个N× N矩阵，表示正方形网格区域。这些整数最大不超过1000。
输出
对每组测试数据，输出来回路径上扫到地雷的最大的重量和。.
输入样例
3
1 2 3
0 2 1
1 4 2
输出样例
15

网络流建图：最大费用最大流思想。

这题目和无向图中给定起点s，终点t,找到从起点到终点，终点回到起点，且每条边只有一次的经典最小费用最大流题目是一个思想。

总点数tot = n * n;
每个格子拆点，拆成入点x，出点x + tot，把点权拆分为边权，费用非点权取反，流量无穷。
新建超级源点s = 0，向起点1连费用为0，流量为2的边，
新建超级汇点t = 2 * tot + 1, 终点n * n + tot向汇点t连费用为0，流量为2的边，
每个格子点的出点tmp+tot，向自左边点入点tmp+1连费用为0，流量为1的边，向下边点入点tmp + n 连费用为0，流量为1的边。 让后跑最小费用最大流板子即可。

code：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 100;
const int INF = 0x3f3f3f3f;
const int MAXM = 2500000;
struct MinCostMaxFlow{
    int n,m,tot;
    struct Edge{
        int to,next,cap,flow,cost;
    }edge[MAXM];
    int head[maxn];
    int pre[maxn],dis[maxn];
    bool vis[maxn];
    void init(int N){
        tot = 0;
        this->n = N;
        memset(head,-1,sizeof(head));
    }
    void addedge(int u,int v,int cap,int cost){
        edge[tot] = (Edge){v,head[u],cap,0,cost}, head[u] = tot++;
        edge[tot] = (Edge){u,head[v],0,0,-cost},  head[v] = tot++;
    }
    bool spfa(int s,int t){
        for(int i=0;i<=(this->n);++i){
            dis[i] = INF,vis[i] = false,pre[i] = -1;
        }
        dis[s] = 0,vis[s] = true;
        queue<int>q;
        q.push(s);
        while(!q.empty()){
            int u = q.front(); q.pop();
            vis[u] = false;
            for(int i=head[u];~i;i=edge[i].next){
                int v = edge[i].to;
                if(edge[i].cap>edge[i].flow&&dis[v]>dis[u]+edge[i].cost){
                    dis[v] = dis[u] + edge[i].cost;
                    pre[v] = i;
                    if(!vis[v]){
                        vis[v] = true;
                        q.push(v);
                    }
                }
            }
        }
        return (pre[t]!=-1);
    }
    int mincostflow(int s,int t,long long &cost){
        int flow = 0;
        cost = 0;
        while(spfa(s,t)){
            int Min = INF;
            for(int i=pre[t];~i;i=pre[edge[i^1].to]){
                if(Min>(edge[i].cap-edge[i].flow)){
                    Min = edge[i].cap - edge[i].flow;
                }
            }
            for(int i=pre[t];~i;i=pre[edge[i^1].to]){
                edge[i].flow += Min;
                edge[i^1].flow -= Min;
                cost += (long long)edge[i].cost*(long long)Min;
            }
            flow += Min;
            //if(flow>=k) break;
        }
        return flow;
    }
}F;

int a[60][60];
int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                scanf("%d",&a[i][j]);
            }
        }
        int tot = n * n;
        F.init(2 * tot + 5);
        int s = 0, t = 2 * tot + 1;
        F.addedge(s,1,2,0);
        F.addedge(t - 1,t,2,0);
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                int tmp = (i - 1) * n + j;
                F.addedge(tmp, tmp + tot, INF, -a[i][j]);
                if(i < n) F.addedge(tmp + tot, tmp + n, 1, 0);
                if(j < n) F.addedge(tmp + tot, tmp + 1, 1, 0);
            }
        }
        long long cost;
        F.mincostflow(s,t,cost);
        printf("%d\n",-cost - a[1][1] - a[n][n]);
    }
    return 0;
}