Annual Congress of MUD（最大流）

Annual Congress of MUD

时间限制: 1 Sec  内存限制: 128 MB
提交: 80  解决: 10
[提交] [状态] [讨论版] [命题人:admin]

题目描述

Multiuser dungeon games, also called MUD games, are real-time virtual-world multiplayer games that are usually played online with text-based commands. The players do not meet normally, but every year, there is the Annual Congress of MUD (ACM) where MUD lovers all around the world could meet in person.
ACM is so popular that the event each year spans around 20 days. Each day, there will be a special gathering for MUD game designers to introduce their new games to the others. 
Each player will usually spend a few days on the ACM site, and in-between will be invited in exactly one day to join this special gathering.
This year, ACM is held at your city, and your boss is an organiser, and he wants to find a best way to assign the players to these special gatherings (one player to one special gathering within his or her duration of stay), so that the maximum number of players among all gatherings is minimized.
Your boss is an extremely impatient guy. He wants to have a system that can tell the maximum number of players among all gatherings, in any best assignment, after each player enters his or her duration of stay. Your task is to help your boss develop such a system.

输入

An instance of the problem consists of N + 1 lines. The first line specifies the integers N and D, seperated by a space. In the ith line of the following N lines, it contains two integers xi and yi , separated by a space. Note that the test data file may contain more than one instance. The last instance is followed by a line containing a single 0.

输出

For each instance, an integer i is marked if and only if the maximum number of players in the best assignment increases after the duration of stay [xi , yi ] of the ith player is keyed in. By default, 1 is always marked. The output of the corresponding instance is the list of all marked integers in ascending order, separated by a space between successive integers, followed by a newline character.

样例输入

3 3
1 1
1 1
1 1
3 3
1 2
2 3
1 1
3 3
1 2
1 2
1 2
0

样例输出

1 2 3
1
1 3

思路：将每个区间看作一个点，在源点s与输入的区间之间连一条流量为一的边，如果该区间已经存在，则将对应边的流量加一；
在每一个区间与区间内每一个点之间建一条流量为无穷的边；
在所有1~D的点与汇点t之间建一条流量为max的边，max为当前的the maximum number of players among all gatherings；
当然max起始为0.

 #include <bits/stdc++.h>
 using namespace std;
 const int MAXN=;
 const int INF=1e9+;
 struct Max_flow
 {
     struct
     {
         int v,cap,next;
     } e[MAXN*MAXN];
     int cnt_edge,cur_clk,head[MAXN];
     void init(int cnt)
     {
         cnt_edge=;
         memset(head,0xff,sizeof(int)*cnt);
     }
     int add_edge_(int u,int v,int cap)
     {
         e[cnt_edge]={v,cap,head[u]};
         head[u]=cnt_edge;
         return cnt_edge++;
     }
     int add_edge(int u,int v,int cap)
     {
         int res=add_edge_(u,v,cap);
         add_edge_(v,u,);
         return res;
     }
     int clk[MAXN],pre[MAXN];
     queue<int> que;
     bool bfs(int s,int t)
     {
         while(!que.empty()) que.pop();
         cur_clk++;
         clk[s]=cur_clk;
         que.push(s);
         while(!que.empty())
         {
             int u=que.front();
             que.pop();
             for(int i=head[u]; i!=-; i=e[i].next)
             {
                 if(e[i].cap>)
                 {
                     int v=e[i].v;
                     if(clk[v]!=cur_clk)
                     {
                         pre[v]=i;
                         clk[v]=cur_clk;
                         if(v==t) return true;
                         que.push(v);
                     }
                 }
             }
         }
         return false;
     }
     int max_flow(int s,int t)
     {
         int flow=;
         while(bfs(s,t))
         {
             int min_cap=INF;
             for(int u=t;u!=s;u=e[pre[u]^].v)
             {
                 if(min_cap>e[pre[u]].cap) min_cap=e[pre[u]].cap;
             }
             for(int u=t; u!=s; u=e[pre[u]^].v)
             {
                 e[pre[u]].cap-=min_cap;
                 e[pre[u]^].cap+=min_cap;
             }
             flow+=min_cap;
         }
         return flow;
     }
 } G;
 int vis[][],idx[][],edg_t[],s_edg[MAXN];
 int n,d,now,m,s,t,flow;
 bool flag;
 int main()
 {
     while(scanf("%d",&n)!=EOF && n)
     {
         now++,m=,flow=,flag=false;
         scanf("%d",&d);
         for(int i=;i<d;i++)
         {
             for(int j=i;j<d;j++)
             {
                 idx[i][j]=m++;
             }
         }
         G.init(m+d+);
         s=m+d,t=m+d+;
         for(int i=;i<d;i++) edg_t[i]=G.add_edge(m+i,t,);
         for(int i=;i<n;i++)
         {
             int x,y;
             scanf("%d %d",&x,&y);
             x--,y--;
             int v=idx[x][y];
             if(vis[x][y]!=now)
             {
                 vis[x][y]=now;
                 for(int i=x;i<=y;i++) G.add_edge(v,m+i,INF);
                 s_edg[v]=G.add_edge(s,v,);
             }
             else
             {
                 G.e[s_edg[v]].cap++;
             }
             flow+=G.max_flow(s,t);
             //cout<<"ni"<<"->"<<flow<<endl;
             if(flow!=i+)
             {
                 if(flag) printf(" ");
                 else flag=true;
                 printf("%d",i+);
                 for(int i=;i<d;i++) G.e[edg_t[i]].cap++;
             }
         }
         puts("");
     }
     return ;
 }