POJ3422:Kaka's Matrix Travels——题解

http://poj.org/problem?id=3422

题目大意:

从左上角走到右下角,中途取数(数>=0),然后该点的数变为0,求走k的总价值和最大值。

——————————————————————————————

最大值?但是我们只会最小费用流啊……

但是数是>=0的啊,所以……

我们拆点,中间连一条容量为1费用为当前值负值的边,再连一条容量为k-1费用0的边。

这样就一定会先走前一条边啦!

然后向下向右连一条容量为k费用0的边。

源点到左上角连一条容量为k-1费用0的边。

右下角到汇点连一条容量为k-1费用0的边。

#include<cstdio>
#include<iostream>
#include<queue>
#include<cstring>
#include<algorithm>
#include<cctype>
using namespace std;
typedef long long ll;
const int INF=1e9;
const int N=50*50*2+10;
inline int read(){
    int X=0,w=0;char ch=0;#include<cstdio>#include<iostream>#include<queue>#include<cstring>#include<algorithm>#include<cctype>using namespace std;typedef long long ll;const int INF=1e9;const int N=50*50*2+10;inline int read(){    int X=0,w=0;char ch=0;    while(!isdigit(ch)){w|=ch==‘-‘;ch=getchar();}    while(isdigit(ch))X=(X<<3)+(X<<1)+(ch^48),ch=getchar();    return w?-X:X;}struct node{    int nxt;    int to;    int w;    int b;}edge[N*N*2];int head[N],cnt=-1;void add(int u,int v,int w,int b){    cnt++;    edge[cnt].to=v;    edge[cnt].w=w;    edge[cnt].b=b;    edge[cnt].nxt=head[u];    head[u]=cnt;    return;}int dis[N];bool vis[N];inline bool spfa(int s,int t,int n){    deque<int>q;    memset(vis,0,sizeof(vis));    for(int i=1;i<=n;i++)dis[i]=INF;    dis[t]=0;q.push_back(t);vis[t]=1;    while(!q.empty()){    int u=q.front();    q.pop_front();vis[u]=0;    for(int i=head[u];i!=-1;i=edge[i].nxt){        int v=edge[i].to;        int b=edge[i].b;        if(edge[i^1].w&&dis[v]>dis[u]-b){        dis[v]=dis[u]-b;        if(!vis[v]){            vis[v]=1;            if(!q.empty()&&dis[v]<dis[q.front()]){            q.push_front(v);            }else{            q.push_back(v);            }        }        }    }    }    return dis[s]<INF;}int ans=0;int dfs(int u,int flow,int m){    if(u==m){    vis[m]=1;    return flow;    }    int res=0,delta;    vis[u]=1;    for(int e=head[u];e!=-1;e=edge[e].nxt){        int v=edge[e].to;    int b=edge[e].b;        if(!vis[v]&&edge[e].w&&dis[u]-b==dis[v]){            delta=dfs(v,min(edge[e].w,flow-res),m);            if(delta){                edge[e].w-=delta;                edge[e^1].w+=delta;                res+=delta;        ans+=delta*b;                if(res==flow)break;            }        }    }    return res;}inline int costflow(int S,int T,int n){    while(spfa(S,T,n)){    do{        memset(vis,0,sizeof(vis));        dfs(S,INF,T);    }while(vis[T]);    }    return ans;}int main(){    memset(head,-1,sizeof(head));    int n=read();    int k=read();    int S=2*n*n+1,T=S+1;    for(int i=1;i<=n;i++){    for(int j=1;j<=n;j++){        int a=read();        int pos=(i-1)*n+j;        add(pos,pos+n*n,1,-a);        add(pos+n*n,pos,0,a);        add(pos,pos+n*n,k-1,0);        add(pos+n*n,pos,0,0);        pos+=n*n;        if(i+1<=n){        int ppos=i*n+j;        add(pos,ppos,k,0);        add(ppos,pos,0,0);        }        if(j+1<=n){        int ppos=(i-1)*n+j+1;        add(pos,ppos,k,0);        add(ppos,pos,0,0);        }    }    }    add(S,1,k,0);    add(1,S,0,0);    add(2*n*n,T,k,0);    add(T,2*n*n,0,0);    printf("%d\n",-costflow(S,T,T));    return 0;}

    while(!isdigit(ch)){w|=ch==‘-‘;ch=getchar();}
    while(isdigit(ch))X=(X<<3)+(X<<1)+(ch^48),ch=getchar();
    return w?-X:X;
}
struct node{
    int nxt;
    int to;
    int w;
    int b;
}edge[N*N*2];
int head[N],cnt=-1;
void add(int u,int v,int w,int b){
    cnt++;
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].b=b;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
    return;
}
int dis[N];
bool vis[N];
inline bool spfa(int s,int t,int n){
    deque<int>q;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)dis[i]=INF;
    dis[t]=0;q.push_back(t);vis[t]=1;
    while(!q.empty()){
    int u=q.front();
    q.pop_front();vis[u]=0;
    for(int i=head[u];i!=-1;i=edge[i].nxt){
        int v=edge[i].to;
        int b=edge[i].b;
        if(edge[i^1].w&&dis[v]>dis[u]-b){
        dis[v]=dis[u]-b;
        if(!vis[v]){
            vis[v]=1;
            if(!q.empty()&&dis[v]<dis[q.front()]){
            q.push_front(v);
            }else{
            q.push_back(v);
            }
        }
        }
    }
    }
    return dis[s]<INF;
}
int ans=0;
int dfs(int u,int flow,int m){
    if(u==m){
    vis[m]=1;
    return flow;
    }
    int res=0,delta;
    vis[u]=1;
    for(int e=head[u];e!=-1;e=edge[e].nxt){
        int v=edge[e].to;
    int b=edge[e].b;
        if(!vis[v]&&edge[e].w&&dis[u]-b==dis[v]){
            delta=dfs(v,min(edge[e].w,flow-res),m);
            if(delta){
                edge[e].w-=delta;
                edge[e^1].w+=delta;
                res+=delta;
        ans+=delta*b;
                if(res==flow)break;
            }
        }
    }
    return res;
}
inline int costflow(int S,int T,int n){
    while(spfa(S,T,n)){
    do{
        memset(vis,0,sizeof(vis));
        dfs(S,INF,T);
    }while(vis[T]);
    }
    return ans;
}
int main(){
    memset(head,-1,sizeof(head));
    int n=read();
    int k=read();
    int S=2*n*n+1,T=S+1;
    for(int i=1;i<=n;i++){
    for(int j=1;j<=n;j++){
        int a=read();
        int pos=(i-1)*n+j;
        add(pos,pos+n*n,1,-a);
        add(pos+n*n,pos,0,a);
        add(pos,pos+n*n,k-1,0);
        add(pos+n*n,pos,0,0);
        pos+=n*n;
        if(i+1<=n){
        int ppos=i*n+j;
        add(pos,ppos,k,0);
        add(ppos,pos,0,0);
        }
        if(j+1<=n){
        int ppos=(i-1)*n+j+1;
        add(pos,ppos,k,0);
        add(ppos,pos,0,0);
        }
    }
    }
    add(S,1,k,0);
    add(1,S,0,0);
    add(2*n*n,T,k,0);
    add(T,2*n*n,0,0);
    printf("%d\n",-costflow(S,T,T));
    return 0;
}

POJ3422:Kaka's Matrix Travels——题解

时间: 2024-09-30 15:07:41

POJ3422:Kaka's Matrix Travels——题解的相关文章

POJ3422 Kaka&#39;s Matrix Travels 【最大费用最大流】

Kaka's Matrix Travels Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 8006   Accepted: 3204 Description On an N × N chessboard with a non-negative number in each grid, Kaka starts his matrix travels with SUM = 0. For each travel, Kaka mo

POJ3422 Kaka&#39;s Matrix Travels[费用流]

Kaka's Matrix Travels Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 9522   Accepted: 3875 Description On an N × N chessboard with a non-negative number in each grid, Kaka starts his matrix travels with SUM = 0. For each travel, Kaka mo

POJ3422 Kaka&#39;s Matrix Travels(最大费用最大流 + 拆点)

题目链接:http://poj.org/problem?id=3422 题意:有一个n*n的矩阵,格子中的元素是费用,KaKa从左上角开始出发要到达右下角,但是他只能向下走或者向右走,且走过的格子赋值为0,可以走K次,问K次后KaKa能获得的最大费用是多少? 思路:首先解释一下为什么要拆点?    因为要获得最大费用,所以假设当前步选择先下走,最终得到的结果可能不是最大值,但根据题意却把走过的格子赋为0了,这就影响了最终结果.所以进行拆点,把每个点拆成两个点,入度点和出度点,本点的入度点连接着本

poj3422 Kaka&#39;s Matrix Travels(最小费用最大流问题)

1 /* 2 poj3422 Kaka's Matrix Travels 3 不知道 k次 dp做为什么不对??? 4 看了大牛的代码,才知道还可以这样做! 5 开始没有理解将a 和 a‘ 之间建立怎样的两条边,导致程序一直陷入死循环,真心花了好长时间,快崩溃了.无语..... 6 题意:有个方阵,每个格子里都有一个非负数,从左上角走到右下角,每次走一步,只能往右或往下走,经过的数字拿走 7 每次都找可以拿到数字和最大的路径走,走k次,求最大和 8 9 这是 最大费用最大流 问题 每次spfa都

POj3422 Kaka&#39;s Matrix Travels 最小费用最大流 拆点

题目链接: poj3422 题意: 有一个N X N的矩阵, 矩阵的每一小格都有且仅有一个数字v,kaka每经过一个数字就会把它捡起来并将那个数字加到sum上去. 现在kaka能通过向下或向右走的方式从 (1,1)到(n,n)  K次,问kaka能取到的最大的sum是多少. 解题思路: 题目问题可以抽象为   求多次可走重复路的最长路的最大和问题 首先想到的就应该是最小费用最大流, 而题目要求的最大和值,那么应求就是最大费用最大流, 仅仅只需要将代码中的最小路算法改为最长路算法即可 题目的条件是

【poj3422】 Kaka&#39;s Matrix Travels

http://poj.org/problem?id=3422 (题目链接) 题意 N*N的方格,每个格子中有一个数,寻找从(1,1)走到(N,N)的K条路径,使得取到的数的和最大. Solution 同[codevs1277] 方格取数 代码 // poj3422 #include<algorithm> #include<iostream> #include<cstring> #include<cstdlib> #include<cstdio>

POJ 3422 Kaka&#39;s Matrix Travels(费用流)

POJ 3422 Kaka's Matrix Travels 题目链接 题意:一个矩阵,从左上角往右下角走k趟,每次走过数字就变成0,并且获得这个数字,要求走完之后,所获得数字之和最大 思路:有点类似区间k覆盖的建图方法,把点拆了,每个点有值的只能选一次,其他都是无值的,利用费用流,入点出点之间连一条容量1,有费用的边,和一条容量k - 1,费用0的边,然后其他就每个点和右边和下边2个点连边,然后跑费用流 代码: #include <cstdio> #include <cstring&g

POJ 3422 Kaka&#39;s Matrix Travels

K路最大费用最大流, 每个点的值只能取一次: 拆点,一个点的两个部分之间连 1 条费用mp容量一的边,连一条费用0容量很大的边 K次: 源点和汇点拆点,两个部分之间连K条边 Kaka's Matrix Travels Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 7985   Accepted: 3191 Description On an N × N chessboard with a non-negative num

POJ 3422 Kaka&#39;s Matrix Travels 【最小费用最大流】

题意: 卡卡有一个矩阵,从左上角走到右下角,卡卡每次只能向右或者向下.矩阵里边都是不超过1000的正整数,卡卡走过的元素会变成0,问卡卡可以走k次,问卡卡最多能积累多少和. 思路: 最小费用最大流的题目. 建图自己没想出来,看了大神的建边,把每个点分解成两个点,一个代表进入一个代表出去,然后每个进入和每个出去连边,容量是1价值是这个点的矩阵的数值.然后因为可以不进去,所以起点要和别的矩阵元素的起点建边,终点也要和别的矩阵矩阵元素的起点建边,最后跑下最小费用最大流. 这题最右下角的矩阵元素需要特殊