hdu 3376 Matrix Again 最大费用流

Matrix Again

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

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
   
   

   
   
//最大费用流，在图上做spfa时求最长路径即可
//用挑战程序设计上的第一个模板+spfa即vector实现的邻接表 + spfa会超时，改成用数组实现的邻接表就没事了。。。
//建图时，因为每个点只能走一次，所以要拆点，容量为1，起点和终点要走两次，容量为2，然后各点之间容量为1，最后套模板就好了
//总结;图中点只走一次时，一定记得拆点且容量为1，边只能走一次则边容量为1
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
using namespace std;

const int N = 1010;
const int INF = 0x3f3f3f3f;
int mpa[N][N];
int n;

struct edge
{
    int from, to, cap, cost, nex;
}ss[N*N*3];

int preve[N*N];
int dist[N*N], head[N*N];
int cnt;
bool used[N*N];

void add_edge(int from, int to, int cap, int cost)
{
    ss[cnt].from = from, ss[cnt].to = to, ss[cnt].cap = cap, ss[cnt].cost = cost, ss[cnt].nex = head[from], head[from] = cnt++;
    ss[cnt].from = to, ss[cnt].to = from, ss[cnt].cap = 0, ss[cnt].cost = -cost, ss[cnt].nex = head[to], head[to] = cnt++;
}

int min_cost_flow(int s, int t, int f)
{
    int res = 0;
    while(f > 0)
    {
        memset(used, 0, sizeof used);
        memset(dist, -1, sizeof dist);
        memset(preve, -1, sizeof preve);
        queue <int> que;
        que.push(s);
        dist[s] = 0;
        used[s] = true;

        while(! que.empty())
        {
            int v = que.front(); que.pop();

            for(int i = head[v]; i != -1; i = ss[i].nex)
            {
                edge &e = ss[i];
                if(e.cap > 0 && dist[e.to] < dist[v] + e.cost)
                {
                    dist[e.to] = dist[v] + e.cost;
                    preve[e.to] = i;
                    if(! used[e.to])
                    {
                        que.push(e.to);
                        used[e.to] = true;
                    }
                }
            }
            used[v] = false;
        }

        if(dist[t] == -1) return 0;

        int d = f;
        for(int i = preve[t]; i != -1; i = preve[ss[i].from])
            d = min(d, ss[i].cap);

        f -= d;
        res += d * dist[t];
        for(int i = preve[t]; i != -1; i = preve[ss[i].from])
        {
            ss[i].cap -= d;
            ss[i^1].cap += d;
        }
    }

    return res;
}

int main()
{
    while(~ scanf("%d", &n))
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                scanf("%d", &mpa[i][j]);

        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
            {
                if((i == 0 && j == 0) || (i == n - 1 && j == n - 1))
                    add_edge(i * n + j, i * n + j + n * n, 2, 0);
                else
                    add_edge(i * n + j, i * n + j + n * n, 1, 0);

                if(i != n - 1) add_edge(i * n + j + n * n, (i+1) * n + j, 1, mpa[i+1][j]);
                if(j != n - 1) add_edge(i * n + j + n * n, i * n + j + 1, 1, mpa[i][j+1]);
            }
        printf("%d\n", min_cost_flow(0, n * n - 1 + n * n, 2) + mpa[0][0] - mpa[n-1][n-1]);
    }

    return 0;
}