poj3422 最小费用流

一遍的话秩序要dp就好，但是这里要删去点。此题可以转化为最小费用流。开始我想了半天纠结怎么处理到过一次后值变0，看了书之后发现拆点解决了这个问题。

对于点t，拆为t-->t'，容量为1，费用为负的矩阵的值，那就解决了只能一次。如果2个点连通，s-->t,就相连,s-->t,s-->t',t'->s',t'->s，容量为无穷，费用0。

然后费用流，得到的值取负即可。

#include<stdio.h>
#include<string.h>
#include<queue>
#define INF 99999999
using namespace std;
const int maxn = ;
struct mp
{
    int v;
    int cnt;
} map[][];
struct node
{
    int to;
    int v;
    int cost;
    int flag;
    int next;
} edge[maxn*maxn/];
int pre[maxn],fpre[maxn],index,head[maxn],dis[maxn],n,k,N;
int ok(int x1,int y1,int x2,int y2)
{
    if(x1>=n||y1>=n||x2>=n||y2>=n)
        return ;
    return ;
}
void add(int x,int y,int v,int cost)
{
    edge[index].to=y;
    edge[index].v=v;
    edge[index].cost=cost;
    edge[index].flag=index+;
    edge[index].next=head[x];
    head[x]=index++;
    edge[index].to=x;
    edge[index].v=;
    edge[index].cost=-cost;
    edge[index].flag=index-;
    edge[index].next=head[y];
    head[y]=index++;

}
int spfa(int S,int T)
{
    int vis[maxn],i;
    queue<int>q;
    memset(vis,,sizeof(vis));
    memset(pre,-,sizeof(pre));
    for(i=; i<=T; i++)
        dis[i]=INF;
    dis[S]=;
    vis[S]=;
    pre[S]=;
    q.push(S);
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        vis[t]=;
        for(i=head[t]; i!=-; i=edge[i].next)
        {
            if(edge[i].v&&dis[edge[i].to]>dis[t]+edge[i].cost)
            {
                dis[edge[i].to]=dis[t]+edge[i].cost;
                if(!vis[edge[i].to])
                {
                    vis[edge[i].to]=;
                    q.push(edge[i].to);
                }
                pre[edge[i].to]=t;
                fpre[edge[i].to]=i;
            }
        }
    }
    //printf("1\n");
    if(dis[T]>=INF)return ;
    return ;
}
void MCMF(int S,int T)
{
    int i;
    int ans=;
    while(spfa(S,T))
    {
        int minflow=INF;
        for(i=T; i!=; i=pre[i])
        {
            if(minflow>edge[fpre[i]].v)
                minflow=edge[fpre[i]].v;
        }
        ans+=dis[T]*minflow;
        for(i=T; i!=; i=pre[i])
        {
            edge[fpre[i]].v-=minflow;
            edge[edge[fpre[i]].flag].v+=minflow;
        }
    }
    printf("%d\n",-ans);
}
int main()
{
    int i,j;
    while(~scanf("%d%d",&n,&k))
    {
        N=n*n;
        index=;
        memset(head,-,sizeof(head));
        int cnt=;
        for(i=; i<n; i++)
            for(j=; j<n; j++)
            {
                map[i][j].cnt=++cnt;
                scanf("%d",&map[i][j].v);
            }
        for(i=; i<n; i++)
        {
            for(j=; j<n; j++)
            {
                add(map[i][j].cnt,map[i][j].cnt+N,,-map[i][j].v);
                if(ok(i,j,i,j+))
                {
                    add(map[i][j].cnt,map[i][j+].cnt,INF,);
                    add(map[i][j].cnt,map[i][j+].cnt+N,INF,);
                    add(map[i][j].cnt+N,map[i][j+].cnt,INF,);
                    add(map[i][j].cnt+N,map[i][j+].cnt+N,INF,);
                }
                if(ok(i,j,i+,j))
                {
                    add(map[i][j].cnt,map[i+][j].cnt,INF,);
                    add(map[i][j].cnt,map[i+][j].cnt+N,INF,);
                    add(map[i][j].cnt+N,map[i+][j].cnt,INF,);
                    add(map[i][j].cnt+N,map[i+][j].cnt+N,INF,);
                }
            }
        }
        add(,,k,);
        add(map[n-][n-].cnt,*N,k,);
        int S=,T=n*n*;
        MCMF(S,T);
    }
}