POJ - 2175 Evacuation Plan (最小费用流消圈)

题意:有N栋楼,每栋楼有\(val_i\)个人要避难,现在有M个避难所,每个避难所的容量为\(cap_i\),每个人从楼i到避难所j的话费是两者的曼哈顿距离.现在给出解决方案,问这个解决方案是否是花费最小的,若不是,则给出比这个更优的解.

分析:若只是要我们求一个最优解的话就用费用流做.现在要求判断是否最优,那么就是当前这张图中是否最短路还能被更新.

首先需要根据给定的解决方案重现这个状态下的残余网,其实只需要加入必要的弧即可:对与任意的楼与避难所(i,j),建边,费用为其距离;若i->j有流量,则反向弧也需要加入,费用为-|距离|.

对于源点s和汇点t.其实没必要加入源点出发的边,只考虑到达t的边.这部分的弧显然费用不用考虑,为0即可.因为汇点是与避难所相连,统计每个避难所的入流,若入流不为0,需要加入反向弧,若已经满流,则说明已经不可增广,则不用加入该弧.

最后从汇点出发跑一遍spfa,若存在负环,则只要在任意一个负环中走一遍即可减少费用.在spfa的过程中记录每个点的前驱,这样绕着环走一遍,注意判断边(i,j)的意义,可能是楼i到避难所j多去一个人,也可能是避难所j往i回退一个人.

#include<iostream>
#include<cstring>
#include<stdio.h>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
const int MAXN = 1005;
const int MAXM = 100000;
const int INF = 0x3f3f3f3f;
struct Edge{
    int to, next, cap, flow, cost;
} edge[MAXM];
int head[MAXN], tot;
int pre[MAXN], dis[MAXN];
bool vis[MAXN];
int cnt[MAXN];
int N;
void init(int n)
{
    N = n;
    tot = 0;
    memset(head, -1, sizeof(head));
}

void AddEdge(int u, int v,int cost)
{
    edge[tot] = (Edge){v,head[u],0,0,cost};
    head[u] = tot++;
    //edge[tot] = (Edge){u,head[v],0,0,-cost};
    //head[v] = tot++;
}

int spfa(int s){
    queue<int> q;
    for (int i = 0; i < N; i++){
        dis[i] = INF;
        vis[i] = false;
        pre[i] = -1;
        cnt[i] = 0;
    }
    dis[s] = 0;
    vis[s] = true;
    q.push(s);
    while (!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = false;
        for (int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if (dis[v] > dis[u] + edge[i].cost){
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = u;                             //记录前驱
                if (!vis[v]){
                    vis[v] = true;
                    q.push(v);
                    if(++cnt[v]>N) return v;            //有负环,能减小花费
                }
            }
        }
    }
    return -1;
}

struct Point{
    int x,y,val;
}p[MAXN],vz[MAXN];

int dist(const Point &a, const Point &b){
    return abs(a.x-b.x) + abs(a.y-b.y) ;
}

int G[105][105];
int num[105];

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
        freopen("out.txt","w",stdout);
    #endif
    int N,M;
    while(scanf("%d %d",&N, &M)==2){
        init(N+M+2);
        int s=0,t=N+M+1;
        for(int i=1;i<=N;++i){
            scanf("%d %d %d",&p[i].x, &p[i].y, &p[i].val);
        }
        for(int i=1;i<=M;++i){
            scanf("%d %d %d",&vz[i].x,&vz[i].y, &vz[i].val);
        }
        memset(num,0,sizeof(num));
        for(int i=1;i<=N;++i){
            for(int j=1;j<=M;++j){
                scanf("%d",&G[i][j]);
                int d = dist(p[i],vz[j]);
                AddEdge(i,j+N,d);
                num[j] += G[i][j];
                if(G[i][j]) AddEdge(j+N,i,-d);          //有流量说明有反向边
            }
        }
        for(int i=1;i<=M;++i){              //此处s表示实际网络里的汇点
            if(num[i]){                     //有流量则有反向边
                AddEdge(s,i+N,0);
                if(num[i]<vz[i].val){       //没漫流说明还有继续推进的空间
                    AddEdge(i+N,s,0);
                }
            }
        }
        int u = spfa(s);
        if(u==-1){
            printf("OPTIMAL\n");
        }
        else{
            printf("SUBOPTIMAL\n");
            memset(vis,0,sizeof(vis));
            int v = u;
            while(!vis[pre[v]]){
                vis[v] = 1;
                v = pre[v];
            }
            int cur = v;
            do{
                int fa = pre[cur];
                if(fa<=N && cur>N)
                    G[fa][cur-N]++;         //走这条边代表楼i->避难所j多一个人能更优
                else if(fa>N && cur<=N)
                    G[cur][fa-N]--;         //同理
                cur = fa;
            }while(cur!=v);
            for(int i=1;i<=N;++i){
                for(int j=1;j<=M;++j){
                    printf("%d%c",G[i][j],j==M?‘\n‘:‘ ‘);
                }
            }
        }
    }
    return 0;
}

原文地址:https://www.cnblogs.com/xiuwenli/p/9688785.html

时间: 2024-10-11 23:15:16

POJ - 2175 Evacuation Plan (最小费用流消圈)的相关文章

POJ 2175 Evacuation Plan 费用流 负圈定理

题目给了一个满足最大流的残量网络,判断是否费用最小. 如果残量网络中存在费用负圈,那么不是最优,在这个圈上增广,增广1的流量就行了. 1.SPFA中某个点入队超过n次,说明存在负环,但是这个点不一定在负环上. 2.这个负环可能包括汇点t,所以构建残量网络的时候也要考虑防空洞到t上的容量. //#pragma comment(linker, "/STACK:1024000000,1024000000") #include<cstdio> #include<cstring

POJ 2175 Evacuation Plan (费用流,负环,消圈法,SPFA)

http://poj.org/problem?id=2175 Evacuation Plan Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 3256   Accepted: 855   Special Judge Description The City has a number of municipal buildings and a number of fallout shelters that were build

POJ 2175 Evacuation Plan 费用流消圈

题目大意:给出一个费用流的模型和已经流过的一些边,问是否存在比这个解更优的解. 思路:直接用原图做一次费用流求最优解会T掉.先介绍费用流消圈定理:如果当前费用流的残量网络中存在负圈,那么当前流不是最优的解. 其实很好理解,结合原图和流过流量之后的反边,若出现了负圈,那么就可以沿着这个负圈增广,而且费用更小. 不过为了解决这个题我们并不需要建立完整的网络流,只需要建立残量网络之后SPFA看是否能找到负环即可. 具体建立方法: 如果一个避难地点有值,那么T向这个避难地点连边,费用0 若当前避难地点没

POJ 2175 Evacuation Plan

Evacuation Plan Time Limit: 1000ms Memory Limit: 65536KB This problem will be judged on PKU. Original ID: 217564-bit integer IO format: %lld      Java class name: Main The City has a number of municipal buildings and a number of fallout shelters that

POJ.2175.Evacuation Plan(消圈)

POJ \(Description\) \(n\)个建筑物,每个建筑物里有\(a_i\)个人:\(m\)个避难所,每个避难所可以容纳\(b_i\)个人. 给出每个建筑物及避难所的坐标,任意两点间的距离为它们的曼哈顿距离\(+1\). 现在给出一个分配方案(\(g[i][j]\)表示第\(i\)个建筑物去第\(j\)个避难所的人数),问是否存在所有人移动的距离之和比当前更小的方案.如果存在,输出任意一组更小的方案. \(n,m\leq100\) \(Solution\) 直接跑费用流会T,但是也没

解题报告 之 POJ2175 Evacuation Plan

解题报告 之 POJ2175 Evacuation Plan Description The City has a number of municipal buildings and a number of fallout shelters that were build specially to hide municipal workers in case of a nuclear war. Each fallout shelter has a limited capacity in term

ZOJ 1553 Evacuation Plan

最小费用最大流..... 建图: 源点 到 每栋楼  连容量为B,花费为0 的边 每个避难所 到 汇点  连容量为C,花费为0 的边 楼 到 避难所 连容量INF,花费 曼哈顿距离+1 的边 跑费用流后比较.... POJ 2175时限只有一秒.....会超时 Evacuation Plan Time Limit: 10000MS   Memory Limit: 32768KB   64bit IO Format: %lld & %llu [Submit]   [Go Back]   [Stat

[ACM] POJ 2947 Widget Factory (高斯消元)

Widget Factory Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 4436   Accepted: 1502 Description The widget factory produces several different kinds of widgets. Each widget is carefully built by a skilled widgeteer. The time required to

Codeforces Gym 100002 E &quot;Evacuation Plan&quot; 费用流

"Evacuation Plan" Time Limit: 1 Sec Memory Limit: 256 MB 题目连接 http://codeforces.com/gym/100002 Description The City has a number of municipal buildings and a number of fallout shelters that were build specially to hide municipal workers in case