[网络流24题] 20 深海机器人 (线性规划网络优化 ,最小费用最大流)

题目大意：

深海资源考察探险队的潜艇将到达深海的海底进行科学考察。潜艇内有多个深海机器人。潜艇到达深海海底后，深海机器人将离开潜艇向预定目标移动。深海机器人在移动中还必须沿途采集海底生物标本。沿途生物标本由最先遇到它的深海机器人完成采集。每条预定路径上的生物标本的价值是已知的，而且生物的标本只能采集一次。本题限定深海机器人只能从其出发的位置沿着向北或者向东方向移动，而且多个深海机器人可以在同一时间占据同一位置。

用一个PQ网格表示深海机器人的可移动位置。西南角的坐标为(0,0)，东北角的坐标为(Q,P)。

给定每个机器人的出发位置和目标位置，以及每条网格上生物标本的价值。计算深海机器人最优移动方案，使深海机器人到达目的地后，采集的生物标本总价值最高。

思路分析：

这道题的网格貌似给的是逆的，但实际就当成普通的网格来求就行。

把网格中的每个位置抽象成网格中一个节点，建立源点s和汇点t；

①：对于每个结点i，j为i东边或者南边相邻的一个节点，从节点i向节点j连一条容量为1，费用为该边价值的有向边。（保证每个生物标本只能被取一次）；

②：对于每个结点i，j为i东边或者南边相邻的一个节点，从节点i向节点j连一条容量为INF，费用为0的有向边。（保证多个深海机器人可以在同一时间占据同一位置）；

③：从s到每个出发点i连接一条容量为该点出发的机器人数量，费用为0的有向边。

④：从每个目标点i到t连接一条容量为可以到达该点的机器人数量，费用为0的有向边。

代码实现：

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
using namespace std;
const int N=266, M=2570, INF=0x3f3f3f3f;
int n, m, s, t, top, sum_cost;
int head[N], vis[N], dis[N], path[N], minflow[N], pre[N], cnt[20][20];

struct Edge{
    int to, next, flow, cost;
    Edge(int _to = 0, int _next = 0, int _flow = 0, int _cost = 0):to(_to), next(_next), flow(_flow), cost(_cost){}
}edge[M];

void Addedge(int from, int to, int flow, int cost){
    edge[top] = Edge(to, head[from], flow, cost);
    head[from] = top++;
    edge[top] = Edge(from, head[to], 0, -cost);
    head[to] = top++;
}

int Spfa(){
    queue<int> q;
    memset(dis, 0x3f, sizeof(dis));
    memset(minflow, 0x3f, sizeof(minflow));
    memset(path, -1, sizeof(path));
    memset(vis, 0, sizeof(vis));
    dis[s] = 0, q.push(s);
    while(!q.empty()){
        int u = q.front(); q.pop();
        vis[u] = 0;
        for(int i = head[u]; i + 1; i = edge[i].next){
            if(edge[i].flow && dis[edge[i].to] > dis[u] + edge[i].cost){
                dis[edge[i].to] = dis[u] + edge[i].cost;
                pre[edge[i].to] = u;
                path[edge[i].to] = i;
                minflow[edge[i].to] = Min(minflow[u], edge[i].flow);
                if(!vis[edge[i].to]){
                    vis[edge[i].to] = 1;
                    q.push(edge[i].to);
                }
            }
        }
    }
    if(dis[t] == INF) return 0;
    sum_cost += minflow[t] * dis[t];
    int u = t;
    while(u != s){
        edge[path[u]].flow -= minflow[t];
        edge[path[u]^1].flow += minflow[t];
        u = pre[u];
    }
    return 1;
}

int main(){
    freopen("shinkai.in", "r", stdin);
    freopen("shinkai.out", "w", stdout);
    int a, b;
    scanf("%d%d%d%d", &a, &b, &n, &m);
    memset(head, -1, sizeof(head));
    top = s = sum_cost = 0;
    int c = 0, k, x, y, val;
    t = (n+1)*(m+1) + 1;
    for(int i = 0; i <= n; ++i){
        for(int j = 0; j <= m; ++j) cnt[i][j] = ++c;
    }
    for(int i = 0; i <= n; ++i){
        for(int j = 0; j < m; ++j){
            scanf("%d", &val);
            Addedge(cnt[i][j], cnt[i][j+1], 1, -val);
            Addedge(cnt[i][j], cnt[i][j+1], INF, 0);
        }
    }
    for(int j = 0; j <= m; ++j){
        for(int i = 0; i < n; ++i){
            scanf("%d", &val);
            Addedge(cnt[i][j], cnt[i+1][j], 1, -val);
            Addedge(cnt[i][j], cnt[i+1][j], INF, 0);
        }
    }
    for(int i = 0; i < a; ++i){
        scanf("%d%d%d", &k, &x, &y);
        Addedge(s, cnt[x][y], k, 0);
    }
    for(int i = 0; i < b; ++i){
        scanf("%d%d%d", &k, &x, &y);
        Addedge(cnt[x][y], t, k, 0);
    }
    while(Spfa());
    printf("%d\n", -sum_cost);
    return 0;
}