POJ -- 3469 Dual Core CPU (最大流,最小割)

原创 2015年07月10日 16:41:09

题目大意:

双核计算机A,B,有n个模块,每个模块都要再CPU中运行,并且知道了每个模块在每个CPU上的运行时间,如果它们运行在同一个cpu,就可以忽略共享数据的花费,否则需要额外的费用,求完成所有任务的最小花费;

思路分析:

①:最大流量=最小割容量

②:建图:让两个CPU分别为图的源点s和汇点t,已知每个模块与两个CPU的运行时间Ai,Bi,则对于每个模块,从s连向一条容量为Ai的边到这个模块,在从这个模块连一条容量为Bi的边到t;对于在不同模块运行的模块需要额外的花费w,则在这两个模块之间连一条容量为w的双向边。

代码实现:

SAP:3172ms

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
using namespace std;
const int N=20010;
const int M=200010;
const int INF=0x3f3f3f3f;
int n,m,top,s,t,head[N],dis[N],pre[N],gap[N],cur[N],low[N];

struct Edge{
    int to,next,flow;
}edge[N*4+M*4];

void Addedge(int from,int to,int val){
    edge[top].to=to,edge[top].next=head[from],edge[top].flow=val,head[from]=top++;
    edge[top].to=from,edge[top].next=head[to],edge[top].flow=0,head[to]=top++;
}

void Bfs(){
    queue<int> q;
    memset(gap,0,sizeof(gap));
    memset(dis,-1,sizeof(dis));
    gap[0]=1,dis[t]=0;
    q.push(t);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=head[u];i+1;i=edge[i].next){
            if(dis[edge[i].to]==-1){
                dis[edge[i].to]=dis[u]+1;
                gap[dis[edge[i].to]]++;
                q.push(edge[i].to);
            }
        }
    }
}

int Sap(){
    Bfs();
    memset(pre,-1,sizeof(pre));
    for(int i=0;i<=n+1;++i) cur[i]=head[i];
    int u=s,i,cur_flow,max_flow=0,neck,tmp;
    while(dis[s]<n+1){
        if(u==t){
            cur_flow=INF;
            for(int i=s;i!=t;i=edge[cur[i]].to){
                if(cur_flow>edge[cur[i]].flow){
                    neck=i;
                    cur_flow=edge[cur[i]].flow;
                }
            }
            for(int i=s;i!=t;i=edge[cur[i]].to){
                tmp=cur[i];
                edge[tmp].flow-=cur_flow;
                edge[tmp^1].flow+=cur_flow;
            }
            max_flow+=cur_flow;
            u=neck;
        }
        int i;
        for(i=cur[u];i!=-1;i=edge[i].next)
            if(edge[i].flow&&dis[u]==dis[edge[i].to]+1) break;
        if(i!=-1){
            cur[u]=i;
            pre[edge[i].to]=u;
            u=edge[i].to;
        }else{
            if(--gap[dis[u]]==0) break;
            cur[u]=head[u];
            int mindis=n;
            for(i=head[u];i!=-1;i=edge[i].next){
                if(edge[i].flow&&mindis>dis[edge[i].to])
                    mindis=dis[edge[i].to];
            }
            dis[u]=mindis+1;
            gap[dis[u]]++;
            if(u!=s) u=pre[u];
        }
    }
    return max_flow;
}

int main(){
    while(~scanf("%d%d",&n,&m)){
        s=0,t=n+1;
        int v1,v2,x,y;
        memset(head,-1,sizeof(head));
        top=0;
        for(int i=1;i<=n;++i){
            scanf("%d%d",&v1,&v2);
            Addedge(s,i,v1);
            Addedge(i,t,v2);
        }
        for(int i=0;i<m;++i){
            scanf("%d%d%d",&x,&y,&v1);
            Addedge(x,y,v1);
            Addedge(y,x,v1);
        }
        int res=Sap();
        printf("%d\n",res);
    }
}
DINIC:6219ms

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#define Min(a,b) ((a)<(b)?(a):(b))
using namespace std;
const int N=20010;
const int M=200010;
const int INF=0x3f3f3f3f;
int n,m,top,s,t,head[N],dis[N];

struct Edge{
    int to,next,flow;
}edge[N*4+M*4];

void Addedge(int from,int to,int val){
    edge[top].to=to,edge[top].next=head[from],edge[top].flow=val,head[from]=top++;
    edge[top].to=from,edge[top].next=head[to],edge[top].flow=0,head[to]=top++;
}

int Bfs(){
    queue<int> q;
    memset(dis,-1,sizeof(dis));
    dis[s]=0;
    q.push(s);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        if(u==t) return 1;
        for(int i=head[u];i+1;i=edge[i].next){
            if(dis[edge[i].to]==-1&&edge[i].flow){
                dis[edge[i].to]=dis[u]+1;
                q.push(edge[i].to);
            }
        }
    }
    return 0;
}

int Dinic(int u,int sum){
    if(u==t) return sum;
    int max_flow=0;
    for(int i=head[u];i+1;i=edge[i].next){
        if(dis[edge[i].to]==dis[u]+1&&edge[i].flow){
            int a=Dinic(edge[i].to,Min(sum-max_flow,edge[i].flow));
            edge[i].flow-=a;
            edge[i^1].flow+=a;
            max_flow+=a;
            if(max_flow==sum) return max_flow;
        }
    }
    if(!max_flow) dis[u]=-1;
    return max_flow;
}

int main(){
    while(~scanf("%d%d",&n,&m)){
        s=0,t=n+1;
        int v1,v2,x,y;
        memset(head,-1,sizeof(head));
        top=0;
        for(int i=1;i<=n;++i){
            scanf("%d%d",&v1,&v2);
            Addedge(s,i,v1);
            Addedge(i,t,v2);
        }
        for(int i=0;i<m;++i){
            scanf("%d%d%d",&x,&y,&v1);
            Addedge(x,y,v1);
            Addedge(y,x,v1);
        }
        int res=0;
        while(Bfs()){
            res+=Dinic(s,INF);
        }
        printf("%d\n",res);
    }
}



版权声明:欢迎转载,转载请注明出处

【poj 3469 】 Dual Core CPU 【最大流+最小割建图】

Dual Core CPU Time Limit: 15000MS Memory Limit: 131072K Total Submissions: 20854 Accept...

poj 3469 Dual Core CPU (最小割->最大流)

这题不难,很容易建立最小割模型,然后就是最大流啦。顺便贴上我的SAP模板,此模板是我参考了网上众牛的模板写的,集各种优化于一身。#include #include #include #inclu...
  • ahfywff
  • ahfywff
  • 2012年02月06日 15:44
  • 453

poj 3469 Dual Core CPU 最大流-最小割

题目:http://poj.org/problem?id=3469 题意:有双核处理器,有n个任务,给出每个任务在分别在两个处理核心上工作的花费,然后有m行,每行给出两个任务,如果两个任务不在同一个处...

POJ 3469 Dual Core CPU (最大流最小割经典题)

Dual Core CPU Time Limit: 15000MS   Memory Limit: 131072K Total Submissions: 24781 ...

POJ 3469 Dual Core CPU(最大流最小割定理,Dinic)

题目链接:http://poj.org/problem?id=3469 题意: 计算机中有两个CPU,SWODNIW 包含了N 个模块,每个模块必须运行在某个CPU 中。每个模块在每个CPU 中运...

POJ 3469->Dual Core CPU(最大流最小割问题)

描述: Dual Core CPU Time Limit: 15000MS   Memory Limit: 131072K Total Submissions: 18147 ...

最大流-最小割定理&poj3469 Dual Core CPU

对于最大流问题中,经常会涉及到一个叫做最小割的部分,那么,首先先来看看最小割是什么。 在一个图G(V,E)中,通过去掉一些边的方式,使得节点u与节点v不连通,这就是节点u和节点v的一个割。 在G之...

POJ 3469-Dual Core CPU(Dinic 最大流/最小割算法)

Dual Core CPU Time Limit: 15000MS   Memory Limit: 131072K Total Submissions: 22932   Accepted:...
  • MIKASA3
  • MIKASA3
  • 2016年08月15日 19:35
  • 721

poj 3469 Dual Core CPU 最大流建图思想 dinic 弧优化很重要

http://poj.org/problem?id=3469题意:给你n个物品,放在集合a中会有一定的花费,放在集合B中也有一定的花费,其中还有m对物体当这m对物体放在同一个集合中不会产生额外的花费,...

(POJ3469)Dual Core CPU 网络流最小割,Dinic模板应用

Dual Core CPU Time Limit: 15000MS Memory Limit: 131072K Total Submissions: 22723 Accepte...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:POJ -- 3469 Dual Core CPU (最大流,最小割)
举报原因:
原因补充:

(最多只允许输入30个字)