HDU 2686

http://acm.split.hdu.edu.cn/showproblem.php?pid=2686

 

and

 

http://codevs.cn/problem/1169/

 

题意： 从矩阵左上角1，1，走到右下角n，n，每次只能向右或向下走，到达nn后，再走回1，1，往回走时，每次只能向左或者向上走，除了11和nn，其他点在去和回的路径中只能出现一次，问权值和最大的来回的路径是多少。

解法：找一条来回的路径，相当于从11到nn找两条点不重复的路径，使得两条的和最大。 相当于从源点 给11一个2的流量， nn给汇点一个n的流量， 跑最大流， 两个流经过的两条路就是要找的答案。 为了保证一个点只会被选择一次，考虑拆点。

把矩阵中的点xy，拆成两个点，一个称为in，一个称为out，所有指向这个点的边 连到in，所有从xy出发的边，从out点连出去， in-》out连流量为1，费用为- a【x】【y】，求最小费用最大流， 相反数就是最大权值和。其他的边就是往右和往下建边。

 

#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int M=1e2+10;
class MaxFlowMinCost { ///最小费用最大流O(~=V^3)
    typedef int typef;///流量的类型
    typedef int typec;///费用的类型
    static const int ME=1e6+10;///边的个数
    static const int MV=5e3+10;///点的个数
    queue<int> q;
    int n,cur[MV],pre[MV];
    bool used[MV],sign[MV];
    typef flow;
    typec cost,dist[MV];
    bool spfa(int s,int t) {
        for(int i=0; i<=n; i++) {
            used[i]=sign[i]=dist[i]=0;
        }
        used[s]=sign[s]=true;
        while(!q.empty()) q.pop();
        q.push(s);
        while(!q.empty()) {
//            - 24 -
            int u=q.front();
            q.pop();
            used[u]=false;
            for(int i=g.head[u]; ~i; i=g.e[i].next) {
                if(g.e[i].flow<1) continue;
                int v=g.e[i].v;
                typec c=g.e[i].cost;
                if(!sign[v]||dist[v]>dist[u]+c) {
                    dist[v]=dist[u]+c;
                    sign[v]=true;
                    pre[v]=u;
                    cur[v]=i;
                    if(used[v]) continue;
                    used[v]=true;
                    q.push(v);
                }
            }
        }
        return sign[t];
    }
    struct G {
        struct E {
            int v,next;
            typef flow;
            typec cost;
        } e[ME];
        int le,head[MV];
        void init(int n) {
            le=0;
            for(int i=0; i<=n; i++) head[i]=-1;
        }
        void add(int u,int v,typef flow,typec cost) {
            e[le].v=v;
            e[le].flow=flow;
            e[le].cost=cost;
            e[le].next=head[u];
            head[u]=le++;
        }
    } g;
public:
    void init(int tn) {
        n=tn;
        g.init(n);
    }
//    - 25 -
    void add(int u,int v,typef flow,typec cost) {
        g.add(u,v,flow,cost);
        g.add(v,u,0,-cost);
    }
    void solve(int s,int t) {
        flow=cost=0;
        while(spfa(s,t)) {
            int temp=t;
            typef now=inf;
            while(temp!=s) {
                now=min(now,g.e[cur[temp]].flow);
                temp=pre[temp];
            }
            flow+=now;
            temp=t;
            while(temp!=s) {
                int id=cur[temp];
                cost+=now*g.e[id].cost;
                g.e[id].flow-=now;
                g.e[id^1].flow+=now;
                temp=pre[temp];
            }
        }
    }
    typef getflow() {
        return flow;
    }
    typec getcost() {
        return cost;
    }
} gx;
int a[M][M];
int in[M][M];
int out[M][M];
int n,m;
int solve() {
    int id=0;
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            in[i][j]=id;
            id++;
        }
    }
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            out[i][j]=id;
            id++;
        }
    }
    int s=id;
    id++;
    int t=id;
    id++;
    gx.init(t);
    gx.add(s,in[0][0],2,0);
    gx.add(out[n-1][m-1],t,2,0);
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            int flow=1;
            if(i==0&&j==0) flow=2;
            if(i==n-1&&j==m-1) flow=2;
            gx.add(in[i][j],out[i][j],flow,-a[i][j]);
            if(i+1<n) {
                gx.add(out[i][j],in[i+1][j],1,0);
            }
            if(j+1<m) {
                gx.add(out[i][j],in[i][j+1],1,0);
            }
        }
    }
    gx.solve(s,t);
    return -gx.getcost();
}
int main() {
    while(~scanf("%d",&n)) {
        m=n;
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                scanf("%d",&a[i][j]);
            }
        }
        printf("%d\n",solve()-a[0][0]-a[n-1][n-1]);
    }
    return 0;
}

 

有另一种动态规划解法，网上称之为多线程dp。 

 

思想是，每一步让两条路同时向前走一格，状态dp【】【】【】【】记录了第一条路径终点在x1y1,第二条路径终点在x2y2这个状态的最大值，然后当两条路径走到同一个点，且这个点不是nm时，这种情况是不允许的，即可。因为两个路是同时走的，所以相撞的点只可能是终点，因为从11到某一个点xy需要的步数是定值（x-1）+（y-1）。转移有4个，因为每条路都有右下两种选法，两条路，所以有四种情况。

 

#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int inf=0x3f3f3f3f;
const int M=32;
int n,m;
int a[M][M];
int dp[M][M][M][M];
int dfs(int x1,int y1,int x2,int y2){
    int &d=dp[x1][y1][x2][y2];
    if(~d) return d;
    if(x1==x2&&y1==y2&&(x1!=n-1||y1!=m-1)&&(x1!=0||y1!=0)){
        d=-inf;
        return d;
    }
    d=0;
    if(x1>0&&x2>0){
        d=max(d,dfs(x1-1,y1,x2-1,y2));
    }
    if(x1>0&&y2>0){
        d=max(d,dfs(x1-1,y1,x2,y2-1));
    }
    if(y1>0&&x2>0){
        d=max(d,dfs(x1,y1-1,x2-1,y2));
    }
    if(y1>0&&y2>0){
        d=max(d,dfs(x1,y1-1,x2,y2-1));
    }
    d+=a[x1][y1]+a[x2][y2];
    return d;
}
int solve(){
    mt(dp,-1);
    return dfs(n-1,m-1,n-1,m-1);
}
int main() {
    while(~scanf("%d",&n)) {
        m=n;
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                scanf("%d",&a[i][j]);
            }
        }
        printf("%d\n",solve()-a[0][0]-a[n-1][m-1]);
    }
    return 0;
}

 

 

 

 

 

end