HDU 4862 最小费用最大流+路径覆盖

点击打开链接

题意：给个n行m列的数列，一个人可以走k次，每次选择一个未走过的点，这个点继续走的话，可以往下走或往右走，当然他可以跳着走，也就是可以跳到下面或右面任意一个位置，但前提是这个点没有走过，初始能量为0，从a，b走到c，d消耗能量是|a-c|+|b-d|-1；问走K次能否将所有点走到，并且每个点只能走一次，，成功的话输出最后可以剩下的最多能量

思路：先要处理k次能否成功，想到了最小路径覆盖=定点数-最大匹配，那么最小路径覆盖的意义就是最小找几个顶点开始跑才可以使路径全被覆盖，也就是所有点被覆盖，刚刚好与此题相似，粘好最小路径覆盖模版，看下面，妹的，竟然是费用流，那这么写好像太麻烦了，想了想也不知道如何在费用流判断这个k路径覆盖，看了官方题解，感觉智商不够用啊，只要在二分图的X部分再加一个边，然后源点到这个点容量为k，费用为0，这个点到Y部所有点容量为1，费用为0；中间可以到达的点就连边，费用为得到的能量-消耗的能量，然后求完备匹配的最大权就行了，最大权的求法点这里

#include <queue>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1010;
typedef pair<int,int> P;
struct edge{
    int to,cap,cost,rev;
    edge();
    edge(int a,int b,int c,int d){to=a,cap=b,cost=c,rev=d;};
};
vector<edge>G[maxn];
int h[maxn],dis[maxn],prevv[maxn],preve[maxn];
void addedge(int st,int en,int cap,int cost){
    G[st].push_back(edge(en,cap,cost,G[en].size()));
    G[en].push_back(edge(st,0,-cost,G[st].size()-1));
}
int min_cost_flow(int st,int en,int f){
    int ans=0;
    memset(h,0,sizeof(h));
    while(f>0){
        priority_queue<P,vector<P>,greater<P> >que;
        memset(dis,inf,sizeof(dis));
        dis[st]=0;que.push(P(0,st));
        while(!que.empty()){
            P p=que.top();que.pop();
            int v=p.second;
            if(dis[v]<p.first) continue;
            for(unsigned int i=0;i<G[v].size();i++){
                edge &e=G[v][i];
                if(e.cap>0&&dis[e.to]>dis[v]+e.cost+h[v]-h[e.to]){
                    dis[e.to]=dis[v]+e.cost+h[v]-h[e.to];
                    prevv[e.to]=v;
                    preve[e.to]=i;
                    que.push(P(dis[e.to],e.to));
                }
            }
        }
        if(dis[en]==inf) return -1;
        for(int i=0;i<maxn;i++) h[i]+=dis[i];
        int d=f;
        for(int i=en;i!=st;i=prevv[i]){
            d=min(d,G[prevv[i]][preve[i]].cap);
        }
        f-=d;
        ans+=d*h[en];
        for(int i=en;i!=st;i=prevv[i]){
            edge &e=G[prevv[i]][preve[i]];
            e.cap-=d;
            G[i][e.rev].cap+=d;
        }
    }
    return ans;
}
char str[15][15];
int main(){
    int TTTT,n,m,k,ttt=1;
    scanf("%d",&TTTT);
    while(TTTT--){
        scanf("%d%d%d",&n,&m,&k);
        int S=0,T=2*n*m+1,T1=n*m*2+2;
        for(int i=1;i<=n;i++) scanf("%s",str[i]+1);
        for(int i=0;i<maxn;i++) G[i].clear();
        for(int i=1;i<=n*m;i++) addedge(S,i,1,0);addedge(S,T1,k,0);
        for(int i=n*m+1;i<=2*n*m;i++){
            addedge(i,T,1,0);
            addedge(T1,i,1,10000);
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                for(int l=j+1;l<=m;l++){
                    if(str[i][j]==str[i][l]){
                        int tmp=str[i][j]-'0'-(l-j-1);
                        int a=n*m+(i-1)*m+l;
                        addedge((i-1)*m+j,a,1,10000-tmp);
                    }else{
                        int tmp=l-j-1;
                        int a=n*m+(i-1)*m+l;
                        addedge((i-1)*m+j,a,1,10000+tmp);
                    }
                }
                for(int l=i+1;l<=n;l++){
                    if(str[i][j]==str[l][j]){
                        int tmp=str[i][j]-'0'-(l-i-1);
                        int a=n*m+(l-1)*m+j;
                        addedge((i-1)*m+j,a,1,10000-tmp);
                    }else{
                        int tmp=l-i-1;
                        int a=n*m+(l-1)*m+j;
                        addedge((i-1)*m+j,a,1,10000+tmp);
                    }
                }
            }
        }
        int ans=min_cost_flow(S,T,n*m);
        if(ans==-1) printf("Case %d : %d\n",ttt++,ans);
        else{
            ans-=(n*m*10000);
            printf("Case %d : %d\n",ttt++,-1*ans);
        }
    }
    return 0;
}