HDU 3376 Matrix Again（最大费用最大流）HDU2686加强题

Matrix Again

Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 102400/102400 K (Java/Others)
Total Submission(s): 3206    Accepted Submission(s): 937

Problem Description

Starvae very like play a number game in the n*n Matrix. A positive integer number is put in each area of the Matrix.
Every time starvae should to do is that choose a detour which from the top left point to the bottom right point and than back to the top left point with the maximal values of sum integers that area of Matrix starvae choose. But from the top to the bottom can only choose right and down, from the bottom to the top can only choose left and up. And starvae can not pass the same area of the Matrix except the start and end..
Do you know why call this problem as “Matrix Again”? AS it is like the problem 2686 of HDU.

 

Input

The input contains multiple test cases.
Each case first line given the integer n (2<=n<=600)
Then n lines, each line include n positive integers. (<100)

 

Output

For each test case output the maximal values starvae can get.

 

Sample Input

  
  

   
   2
10 3
5 10
3
10 3 3
2 5 3
6 7 10
5
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
5 6 7 8 9
  
  

 

Sample Output

  
  

   
   28
46
80
  
  

 

Author

Starvae

 

Source

HDOJ Monthly Contest – 2010.04.04

 

题意：给一个n*n的距阵，每个点都有一个值。问从(0,0)到(n-1, n-1)点（只能从左到右 或 从上到下）再回到(0,0)点（只能从右到左 或 下到上）经过的点的值总和最大是多少？每个点只能走一次。

解题：其实就是找两条从(0,0)到(n-1,n-1)总和最大的路.拆点法。每个边容量为1，费用：对于点的本身，边权为点权，非点的边权值为0。一定要用数组模拟队列。不然会TLE。

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int MAXN = 720010;
const int MAXM = 3501000;
const int INF = 1<<30;
struct EDG{
    int to,next,cap,flow;
    int cost;  //单价
}edg[MAXM];
int head[MAXN],eid;
int pre[MAXN], cost[MAXN] ; //点0~(n-1)

void init(){
    eid=0;
    memset(head,-1,sizeof(head));
}
void addEdg(int u,int v,int cap,int cst){
    edg[eid].to=v; edg[eid].next=head[u]; edg[eid].cost = cst;
    edg[eid].cap=cap; edg[eid].flow=0; head[u]=eid++;

    edg[eid].to=u; edg[eid].next=head[v]; edg[eid].cost = -cst;
    edg[eid].cap=0; edg[eid].flow=0; head[v]=eid++;
}

bool inq[MAXN];
int q[MAXN];
bool spfa(int sNode,int eNode , int n){
    int l=0,r=0;
    for(int i=0; i<n; i++){
        inq[i]=false; cost[i]= -1;
    }
    cost[sNode]=0; inq[sNode]=1; pre[sNode]=-1;
    q[r++]=sNode;
    while(l!=r){
        int u=q[l++]; //数组模拟
        if(l==MAXN)l=0;
        inq[u]=0;
        for(int i=head[u]; i!=-1; i=edg[i].next){
            int v=edg[i].to;
            if(edg[i].cap-edg[i].flow>0 && cost[v]<cost[u]+edg[i].cost){ //在满足可增流的情况下，最小花费
                cost[v] = cost[u]+edg[i].cost;
                pre[v]=i;   //记录路径上的边
                if(!inq[v]){
                    if(r==MAXN)r=0;
                    q[r++]=v; inq[v]=1;
                }
            }
        }
    }
    return cost[eNode]!=-1;    //判断有没有增广路
}
//反回的是最大流，最小花费为minCost
int minCost_maxFlow(int sNode,int eNode ,int& minCost , int n){
    int ans=0;
    while(spfa(sNode,eNode , n)){

        for(int i=pre[eNode]; i!=-1; i=pre[edg[i^1].to]){
            edg[i].flow+=1; edg[i^1].flow-=1;
            minCost+=edg[i].cost;
        }
        ans++;
        if(ans==2)break;
    }
    return ans;
}
inline void scanf(int &ans){
    char ch;
    while(ch=getchar()){
        if(ch>='0'&&ch<='9')
            break;
    }
    ans = ch-'0';
    while(ch=getchar()){
        if(ch<'0' || ch>'9')
            break;
        ans = ans*10+ch-'0';
    }
}
int mapt[605][605];
int main(){
    int n;
    while(scanf("%d",&n)>0){
        init();
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
            scanf(mapt[i][j]);
        int s = 0 , t = n*n-1;

        for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
        if(i||j){
            addEdg(i*n+j , i*n+j+n*n , 1 , mapt[i][j]);
            if(j+1<n) addEdg(i*n+j+n*n, i*n+j+1 , 1 , 0 );
            if(i+1<n) addEdg(i*n+j+n*n, (i+1)*n+j , 1 , 0);
        }
        else{
            addEdg(s , 1 , 1,0) , addEdg(s , n , 1 , 0);
        }
        int maxCost=mapt[0][0];
        if(n>1) maxCost+=mapt[n-1][n-1];
        minCost_maxFlow(s , t , maxCost , n*n*2);
        printf("%d\n",maxCost);
    }
}