HDU 2686 Matrix||HDU 3376 Matrix Again （拆点费用流）

最新推荐文章于 2020-09-09 17:12:26 发布

原创最新推荐文章于 2020-09-09 17:12:26 发布 · 445 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#最小费用最大流

模板同时被 2 个专栏收录

65 篇文章

订阅专栏

网络流

23 篇文章

订阅专栏

本文介绍了一种解决特定路径问题的方法，即在一个从左上角到右下角再返回的网格中寻找最大点权路径。通过使用拆点技巧与改进的SPFA算法，确保每个点仅被访问一次的同时最大化路径的总权重。

大意：从（0.0）到（n-1,n-1）然后再返回起点，并且每个点只能走一次（从左上到右下走每次只能选右下方的路来走，同理右下到左上选走上的点来走），求最大点权值。

思路：针对这一个来回的过程，发现起终两个点走两次，所以流量为2，每点走一次所以可以拆点i'点连接j点这样的话可以保证返回的时候拆的点之间的流量为0，因此不能通过。最后设置一个源点，一个会点，流量也为2即可。（注意：1、数组 2、SPFA返回值得时候，用if语句判断 - -！）

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<set>
#include<queue>
#define inf 0x3f3f3f3f
#define LL __int64
using namespace std;
const int N = 10000;
int sum,head[N],cost,flow;
struct node{
    int to,c,w,next;
}q[N*500];
int mp[N/100][N/100],cur[N],f[N],dis[N];
int st,ed;
bool vis[N];
void Add(int u,int v,int cap,int cost){
    q[sum].to=v;
    q[sum].w=cap;
    q[sum].c=cost;
    q[sum].next=head[u];
    head[u]=sum++;

    q[sum].to=u;
    q[sum].w=0;
    q[sum].c=-cost;
    q[sum].next=head[v];
    head[v]=sum++;

}

int SPFA(){
    memset(vis,false,sizeof(vis));
    memset(dis,inf,sizeof(dis));
    queue<int>Q;
    while(!Q.empty())
        Q.pop();

    Q.push(st);
    cur[st] = -1;
    f[st] = inf;
    dis[st] = 0;
    while(!Q.empty()){
        int u = Q.front();
        Q.pop();
        vis[u] = false;
        for(int i = head[u];~i;i=q[i].next ){
            int v = q[i].to;
            if(dis[v] > dis[u] + q[i].c&&q[i].w ){
                dis[v]  = dis[u] + q[i].c;
                cur[v] = i;
                f[v] = min(f[u],q[i].w);
                if(!vis[v]){
                    vis[v] = true;
                    Q.push(v);
                }
            }
        }
    }

    if(dis[ed] == inf)
        return 0;
    flow += f[ed];
    cost += f[ed]*dis[ed];
    for(int i = cur[ed];~i;i = cur[q[i^1].to ]){
        q[i].w -= f[ed];
        q[i^1].w += f[ed];
    }
    return 1;
}

int main(){
    int n,m,i,j,k;
    while(~scanf("%d",&n)){
        cost = flow = 0;
        sum = 0;
        memset(head,-1,sizeof(head));
        for(i = 0;i < n;++ i){
            for(j = 0;j < n;++ j){
                scanf("%d",&mp[i][j]);
                if( (i==0&&j==0)||(i==n-1&&j==n-1) )
                    Add(i*n+j,i*n+j+n*n,2,-mp[i][j]);
                else
                    Add(i*n+j,i*n+j+n*n,1,-mp[i][j]);
                if(i+1 <= n-1)
                    Add(i*n+j+n*n,(i+1)*n+j,1,0);
                if(j+1 <= n-1)
                    Add(i*n+j+n*n,i*n+j+1,1,0);
            }
        }
        st = 2*n*n;
        ed = 2*n*n+1;
        Add(st,0,2,0);
        Add(2*n*n-1,ed,2,0);

        while(SPFA());
        printf("%d\n",-cost-mp[0][0]-mp[n-1][n-1]);
    }
    return 0;
}