hdu 2386 Matrix// 3376 Matrix Again (费用流)

   Matrix :

1. 题目大意是给定一个n*n的矩阵，yifenfei从起点(1, 1)这个位置一直取数到(n,n)， 
2. 每取完一个数，下一个只能取当前数右方或者下方的一个数， 
3. （注意两个数之间的距离应该是1，之前以为下方或者右方任何一个数都可以取）， 
4. 就这样取到(n,n)，然后再从(n,n)取回(1,1)，这次每取完一个数， 
5. 下一个只能取当前数左方或者右方的一个数，最后回到（1,1）， 
6. 每个数只能被取一次，求这样进行取数之后能取到的最大数 

 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cstdio>
using namespace std;
const int MAXN=610*610*2+2;
const int inf=1<<29;
int pre[MAXN];          
int dis[MAXN];          
int vis[MAXN];         
int path[MAXN];
int head[MAXN];
int NE,tot,ans,max_flow,map[666][666];
struct node
{
    int u,v,cap,cost,next;
} Edge[MAXN<<2];
void addEdge(int u,int v,int cap,int cost)
{
    Edge[NE].u=u;
    Edge[NE].v=v;
    Edge[NE].cap=cap;
    Edge[NE].cost=cost;
    Edge[NE].next=head[u];
    head[u]=NE++;
    Edge[NE].v=u;
    Edge[NE].u=v;
    Edge[NE].cap=0;
    Edge[NE].cost=-cost;
    Edge[NE].next=head[v];
    head[v]=NE++;
}
int SPFA(int s,int t)                   
    int i;
    for(i=s;i<=t;i++) dis[i]=inf;
    memset(vis,0,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    dis[s] = 0;
    queue<int>q;
    q.push(s);
    vis[s] =1;
 while(!q.empty())       
    {
        int u =q.front();
        q.pop();
         vis[u] =0;
        for(i=head[u]; i!=-1;i=Edge[i].next)
        {
            int v=Edge[i].v;
            if(Edge[i].cap >0&& dis[v]>dis[u]+Edge[i].cost)
            {
                dis[v] = dis[u] + Edge[i].cost;
                pre[v] = u;
                path[v]=i;
                if(!vis[v])
                {
                    vis[v] =1;
                    q.push(v);
                }
            }
        }
       
    }
    if(dis[t]==inf)
        return 0;
    return 1;
}
int MFMC(int s,int t)
{
    int i,u, sum = inf;
  while(SPFA(s,t))
  {
           
        
    for(u=t; u!=s; u=pre[u])  
    {  
        sum = min(sum,Edge[path[u]].cap);  
    }  
    max_flow+=sum;  
    for(u = t; u != s; u=pre[u])  
    {  
        Edge[path[u]].cap -= sum;  
        Edge[path[u]^1].cap += sum;  
         
    }  
      ans += sum*dis[t];     
   }
    return ans ;
}
int main()
{
    int i,j,n,s,t;
    while(scanf("%d",&n)!=EOF)
    {
        memset(head,-1,sizeof(head));
        NE=ans=max_flow=s=0;
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                scanf("%d",&map[i][j]);
            }
        }
        int k=n*n;
        t=2*k+1;
         for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                addEdge(j+(i-1)*n,k+j+(i-1)*n,1,-map[i][j]);
              if(j!=n) addEdge(k+j+(i-1)*n,j+1+(i-1)*n,inf,0);   //右边 
              if(i!=n) addEdge(k+j+(i-1)*n,i*n+j,inf,0);           //下边 
            }
        }
        addEdge(s,1,2,0);
        addEdge(1,k+1,1,0);          //（1,1）这个点要多建一条边，因为这个点选两次，所以这次费用为0， 
        addEdge(2*k,t,2,0);
        addEdge(k,2*k,1,0);         //同样 
         int ans = MFMC(s,t);
           printf("%d\n",-ans); 
    }
    return 0;
}

 

 

Matrix Again :  

    和上题一样，只不过数据 大了 ： 

 

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdlib>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cstring>
#include<stack>
#include<cmath>
#include<queue>
using namespace std;
#define CL(x,v); memset(x,v,sizeof(x));
#define INF 0x3f3f3f3f
#define LL long long
#define REP(i,r,n) for(int i=r;i<=n;i++)
#define RREP(i,n,r) for(int i=n;i>=r;i--)

int sumFlow;
const int MAXN = 720010;
const int MAXM = 1000010;
const int inf=1<<30 ;
struct Edge
{
    int u, v, cap, cost;
    int next;
}edge[MAXM<<2];
int NE;
int head[MAXN], dist[MAXN], pp[MAXN];
bool vis[MAXN];
void init()
{
    NE = 0;
    memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int cap, int cost)
{
    edge[NE].u = u; edge[NE].v = v; edge[NE].cap = cap; edge[NE].cost = cost;
    edge[NE].next = head[u]; head[u] = NE++;
    edge[NE].u = v; edge[NE].v = u; edge[NE].cap = 0; edge[NE].cost = -cost;
    edge[NE].next = head[v]; head[v] = NE++;
}
bool SPFA(int s, int t, int n)
{
    int i, u, v;
    queue <int> qu;
    memset(vis,false,sizeof(vis));
    memset(pp,-1,sizeof(pp));
    for(i = 0; i <= n; i++) dist[i] = INF;
    vis[s] = true; dist[s] = 0;
    qu.push(s);
    while(!qu.empty())
    {
        u = qu.front(); qu.pop(); vis[u] = false;
        for(i = head[u]; i != -1; i = edge[i].next)
        {
            v = edge[i].v;
            if(edge[i].cap && dist[v] > dist[u] + edge[i].cost)
            {
                dist[v] = dist[u] + edge[i].cost;
                pp[v] = i;
                if(!vis[v])
                {
                    qu.push(v);
                    vis[v] = true;
                }
            }
        }
    }
    if(dist[t] == INF) return false;
    return true;
}
int MCMF(int s, int t, int n) // minCostMaxFlow
{
    int flow = 0; // 总流量
    int i, minflow, mincost;
    mincost = 0;
    while(SPFA(s, t, n))
    {
        minflow = INF + 1;
        for(i = pp[t]; i != -1; i = pp[edge[i].u])
            if(edge[i].cap < minflow)
                minflow = edge[i].cap;
        flow += minflow;
        for(i = pp[t]; i != -1; i = pp[edge[i].u])
        {
            edge[i].cap -= minflow;
            edge[i^1].cap += minflow;
        }
        mincost += dist[t] * minflow;
    }
    sumFlow = flow; // 题目需要流量，用于判断
    return mincost;
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        //solver.init(n*n*2+5);
        init();
        int a;
        int k=n*n;
        int s=0;
        int t=2*k+1;       
        REP(i,1,n)
            REP(j,1,n){
                scanf("%d",&a);
                addedge(j+(i-1)*n,k+j+(i-1)*n,1,-a);  
              if(j!=n) addedge(k+j+(i-1)*n,j+1+(i-1)*n,inf,0);   //右边   
              if(i!=n) addedge(k+j+(i-1)*n,i*n+j,inf,0);           

            }
        addedge(s,1,2,0);  
        addedge(1,k+1,1,0);          //（1,1）这个点要多建一条边，因为这个点选两次，所以这次费用为0，   
        addedge(2*k,t,2,0);  
        addedge(k,2*k,1,0);   
        int ans=-MCMF(s,t,t);
        printf("%d\n",ans);
    }
    return 0;
}