POJ2175：Evacuation Plan（消负圈）

Evacuation Plan

Time Limit: 1000MSMemory Limit: 65536KTotal

Submissions: 5665Accepted: 1481Special Judge

题目链接：http://poj.org/problem?id=2175

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 terms of a number of people it can accommodate, and there's almost no excess capacity in The City's fallout shelters. Ideally, all workers from a given municipal building shall run to the nearest fallout shelter. However, this will lead to overcrowding of some fallout shelters, while others will be half-empty at the same time.

To address this problem, The City Council has developed a special evacuation plan. Instead of assigning every worker to a fallout shelter individually (which will be a huge amount of information to keep), they allocated fallout shelters to municipal buildings, listing the number of workers from every building that shall use a given fallout shelter, and left the task of individual assignments to the buildings' management. The plan takes into account a number of workers in every building - all of them are assigned to fallout shelters, and a limited capacity of each fallout shelter - every fallout shelter is assigned to no more workers then it can accommodate, though some fallout shelters may be not used completely.

The City Council claims that their evacuation plan is optimal, in the sense that it minimizes the total time to reach fallout shelters for all workers in The City, which is the sum for all workers of the time to go from the worker's municipal building to the fallout shelter assigned to this worker.

The City Mayor, well known for his constant confrontation with The City Council, does not buy their claim and hires you as an independent consultant to verify the evacuation plan. Your task is to either ensure that the evacuation plan is indeed optimal, or to prove otherwise by presenting another evacuation plan with the smaller total time to reach fallout shelters, thus clearly exposing The City Council's incompetence.

During initial requirements gathering phase of your project, you have found that The City is represented by a rectangular grid. The location of municipal buildings and fallout shelters is specified by two integer numbers and the time to go between municipal building at the location (Xi, Yi) and the fallout shelter at the location (Pj, Qj) is D_i,j = |Xi - Pj| + |Yi - Qj| + 1 minutes.

Input:

The input consists of The City description and the evacuation plan description. The first line of the input file consists of two numbers N and M separated by a space. N (1 ≤ N ≤ 100) is a number of municipal buildings in The City (all municipal buildings are numbered from 1 to N). M (1 ≤ M ≤ 100) is a number of fallout shelters in The City (all fallout shelters are numbered from 1 to M).

The following N lines describe municipal buildings. Each line contains there integer numbers Xi, Yi, and Bi separated by spaces, where Xi, Yi (-1000 ≤ Xi, Yi ≤ 1000) are the coordinates of the building, and Bi (1 ≤ Bi ≤ 1000) is the number of workers in this building.

The description of municipal buildings is followed by M lines that describe fallout shelters. Each line contains three integer numbers Pj, Qj, and Cj separated by spaces, where Pi, Qi (-1000 ≤ Pj, Qj ≤ 1000) are the coordinates of the fallout shelter, and Cj (1 ≤ Cj ≤ 1000) is the capacity of this shelter.

The description of The City Council's evacuation plan follows on the next N lines. Each line represents an evacuation plan for a single building (in the order they are given in The City description). The evacuation plan of ith municipal building consists of M integer numbers E_i,j separated by spaces. E_i,j (0 ≤ E_i,j ≤ 1000) is a number of workers that shall evacuate from the i^th municipal building to the j^th fallout shelter.

The plan in the input file is guaranteed to be valid. Namely, it calls for an evacuation of the exact number of workers that are actually working in any given municipal building according to The City description and does not exceed the capacity of any given fallout shelter.

Output:

If The City Council's plan is optimal, then write to the output the single word OPTIMAL. Otherwise, write the word SUBOPTIMAL on the first line, followed by N lines that describe your plan in the same format as in the input file. Your plan need not be optimal itself, but must be valid and better than The City Council's one.

Sample Input:

3 4
-3 3 5
-2 -2 6
2 2 5
-1 1 3
1 1 4
-2 -2 7
0 -1 3
3 1 1 0
0 0 6 0
0 3 0 2

Sample Output:

SUBOPTIMAL
3 0 1 1
0 0 6 0
0 4 0 1

题意：

给出n个房间，m个目的地，每个房间有一定数量的人，每个目的地也只能装一定数量的人。

现在给出政府大的迁移计划，把n个房间里面的人都迁到m个目的地上面去（通过一个n*m的矩阵给出迁移方案），当然两点建的迁移费用为曼哈顿距离加一。

问现在的迁移计划是否合理，如果不是，请输出一个更合理的方案(special judge)。

题解：

这题可以用最大流最小费用流来做，但是由于边比较多，会T掉。

做这个题需要知道：当前流量下的最小费用<=>当前无负费用圈。

所以我们可以直接让其满流，来判断有无负圈就好了。如果有负圈，就在负圈上面进行相应的退流、加流操作就ok了。

还有需要注意的是，一个点被更新了大于n次，不能说明这个点就在负环中，如下图：

注意一下建图，比较直观的就是直接把最大流时边的状态建出来，类似于下面这样：

        for(int i=;i<=n;i++){
            for(int j=;j<=m;j++){
                int tmp;scanf("%d",&tmp);
                E[i][j]=tmp;
                sum[j]+=tmp;
                adde(i,j+n,INF-E[i][j],dis(i,j));
                adde(j+n,i,E[i][j],-dis(i,j));
            }
        }
        for(int i=;i<=n;i++) adde(,i,p1[i].w,),adde(i,,,);
        for(int i=;i<=m;i++){
            adde(i+n,n+m+,p2[i].w-sum[i],);
            adde(n+m+,i+n,sum[i],);
        }

但是还是可以直接去掉边的容量建图，因为我们跑spfa的时候实际上只需要知道边的费用，但在这种情况下需要知道哪些边应该存在，哪些边不容易存在，不然很容易WA。

另外源点应该连反向边的，但是这里我们其实不需要源点，我们为了跑spfa方便增添了一个正向连边的源点。

其余的边可以根据最后存在的边建出来。

我直接给出第二种建图方式的代码:

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#include <cmath>
#define INF 1e9
using namespace std;
typedef long long ll;
const int N = ;
int n,m,tot;
int E[N][N];
int head[N],vis[N],d[N],pa[N],cnt[N],sum[N];
struct Edge{
    int u,v,next,w;
}e[(N*N)<<];
struct Node{
    int x,y,w,c;
}p1[N],p2[N];
void adde(int u,int v,int w){
    e[tot].w=w;e[tot].v=v;e[tot].u=u;e[tot].next=head[u];head[u]=tot++;
}
int dis(int a,int b){
    return abs(p1[a].x-p2[b].x)+abs(p1[a].y-p2[b].y)+;
}
int spfa(){
    for(int i=;i<=n+m+;i++) d[i]=1e9;d[]=;
    queue<int> q;q.push();memset(vis,,sizeof(vis));vis[]=;
    memset(pa,-,sizeof(pa));
    memset(cnt,,sizeof(cnt));cnt[]++;
    while(!q.empty()){
        int u =q.front();q.pop();vis[u]=;
        for(int i=head[u];i!=-;i=e[i].next){
            int v=e[i].v;
            if(d[v]>d[u]+e[i].w){
                d[v]=d[u]+e[i].w;
                pa[v]=u;
                if(!vis[v]){
                    vis[v]=;
                    if(++cnt[v]>n+m+) return v;
                    q.push(v);
                }
            }
        }
    }
    return -;
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        memset(head,-,sizeof(head));tot=;
        memset(sum,,sizeof(sum));
        for(int i=;i<=n;i++)
            scanf("%d%d%d",&p1[i].x,&p1[i].y,&p1[i].w);
        for(int i=;i<=m;i++)
            scanf("%d%d%d",&p2[i].x,&p2[i].y,&p2[i].w);
        for(int i=;i<=n;i++){
            for(int j=;j<=m;j++){
                int tmp;scanf("%d",&tmp);
                E[i][j]=tmp;
                sum[j]+=tmp;
                adde(i,j+n,dis(i,j));
                if(E[i][j]) adde(j+n,i,-dis(i,j));
            }
        }
        for(int i=;i<=n;i++) adde(,i,);
        for(int i=;i<=m;i++){
            if(p2[i].w> && sum[i]==) adde(i+n,n+m+,);
            else if(sum[i]>&&p2[i].w>sum[i]) adde(n+m+,i+n,),adde(i+n,n+m+,);
            else if(p2[i].w==sum[i]) adde(n+m+,i+n,);
        }
        int s = spfa();
        if(s==-) cout<<"OPTIMAL";
        else{
            cout<<"SUBOPTIMAL"<<endl;
            memset(vis,,sizeof(vis));
            int tmp=s;
            while(true){       //找到在负环中的点，当前求出来的点不一定在负环中
                if(!vis[tmp]){
                    vis[tmp]=;tmp=pa[tmp];
                }else{
                    s=tmp;
                    break ;
                }
            }
            do{
                int u=pa[s];
                if(u<=n && s>n) E[u][s-n]++;
                if(u>n && s<=n) E[s][u-n]--;
                s=u;
            }while(s!=tmp);
            for(int i=;i<=n;i++){
                for(int j=;j<=m;j++){
                    cout<<E[i][j]<<" ";
                }
                cout<<endl;
            }
        }
    }
    return ;
}