UVALive 2238 Fixed Partition Memory Management（二分完美匹配）

题意：计算机中有一些固定大小的内存，内存越大，处理速度越快。对于一个程序，加入不同的内存空间，处理所需时间不同。现给出m个内存空间，n个程序，对于每个程序程序，有k组数据(s,t)，分别表示当程序 i 在某个内存环境s下对应的运行时间t。当有一个内存空间为si，一个程序的2组数据a,b，满足as<=si<bs，那么这个程序放到该内存中的运行时间是at（取下界）。已知不同的内存空间可以同时运行，同一个内存空间的程序在某一时刻只能有一个在运行。又知道一个程序从提交给计算机到运行结束这段时间为“运行时间”（所有程序在0时刻同时提交）。求出最小平均“运行时间”=总“运行时间”/n个程序，并给出每个程序在哪个内存区内运行（内存区编号1~m），以及该程序在内存区内是从何时开始运行，何时结束的。（保证不会出现程序的最小需求内存>最大内存空间）

分析：

　　很复杂的题意，直观感觉就是所求的量很多，而且并非直接求最小值，是要具体的把方案求解出来。想到这里应该能确定用图论解决。进一步的，要用什么来处理，排除法也能想到匹配（其实我在刷图论专题= =）。

　　确定了算法，就明确了方向，一侧必然是n个程序。那么另一侧应该是什么呢？我们求的是平均“运行时间”，那么可行顶标Lx、Ly之和就应该是最小的总“运行时间”。我们先考虑总运行时间应该怎么算呢？假设一个内存空间 i 按顺序运行3个程序a、b、c，那么这个程序总的运行时间Ti=at+(at+bt)+(at+bt+ct)=3*at+2*bt+1*ct

　　（至此应该都能想到，接下来根据这个式子建模）。

　　我们发现，a程序虽然是第一个完成，但它受这个内存中程序的数量以及运行次序的影响，实际贡献了3*at的时间。当我们拿到一个程序a，并放入某个内存 i 中。首先根据程序的 k 组数据可以确定at的大小。如果假定这个内存中有x个程序，a程序排在第y个，于是构造一个点(i,x,y)，那么我们就可以确定边权为(x-y+1)*at。

　　如此构造有何不妥之处呢？

　　做最佳二分完美匹配，每个程序都对应于一个点(i,x,y)，得到最小值。会不会不合常理呢？会的...因为是在交错树上沿等边增广，这里每次调整后，都必然出现许多等边（(x-y+1)的大小同时受x和y影响），虽然调整交错树可能会出现多条等边，但那是巧合（数据相等），而非必然。这种必然导致的就是出现了大量的符合最小值的方案，一个任务，可以匹配点(i,x,y)，也可以匹配点(i,(x+1),(y+1))，反正都在内存 i 内，at为定值。而这种任意分配是不合理的，因为最后无法确定顺序：一个内存中，若有x个程序，它的(i,x,1)可能都已经匹配，但是本该与(i,x,2)(i,x,3)匹配的点却与(i,(x-1),1)(i,(x-1),2)匹配。

　　建模失败了，那么有什么可取之处？该如何改进呢？

　　先找问题：1、点的构造决定了边权(x-y+1)*at，x、y同时影响是等边过多；2、时间复杂度高：一侧有S=n个点，一侧有T=m*n*n=mn2个点，所以总复杂度S*T*(S+T)=m2n5=10的10次方 = =

　　重新建点，将x,y两个变量简化为一个变量，观察式子Ti=3*at+2*bt+ct，从后往前逐次+1；又边权(x-y+1)*at 中，(x-y+1)本身就表示的是系数，也可以理解为倒数第几个。于是，新的构点取(i,p)：在第 i 个内存中以倒数第p个的身份出现，边权就是p*at。

　　同样做最佳完美匹配。已知一种完美匹配是任意的，不仅不一定是最佳，而且不一定不合理。但是最佳二分完美匹配，一定是合理的。因为(i,p)与权值p*at相互唯一对应，杜绝了之前多条等边的情况。又有，若在内存 i 中有3个程序a,b,c，分别对应( i,1)( i,2)( i,4)，必然不是最佳，c对应于( i,3)有“更佳”的权值3*ct。再考虑复杂度，S=n，T=m*n,总复杂度S*T*(S+T)=m2n3=10的7次方，可以接受。

注意：

1、S,T两侧的数组因为点数的不同，要分开处理。

2、关于n个程序与m*n个点( i,p),究竟放那一侧，我选择n个程序在S侧。其实若放T侧，貌似可以直接顺序找到每个程序对应的点( i,p)，但还要处理每个程序在内存中的具体时间，复杂度上是相同的。

3、我这样处理其实也存在弊端，这是另一种（n个点在T侧）所能避免的，真亏我能想出来。

　　固定内存 i ，查找p，从1找到第一个为0的点之前截止，这些点对应的 left[] 就是放在内存 i 中的程序编号。但可能n个程序都在同一个内存中，所以p的上界要定在(n+1)而不是n；这又引发了另一个问题：若n个程序都在最后一个内存中，所找到的(n+1)对应的点是第(m*n+1)个点，超出了既定的数据范围，若初始化右侧数据只是[1,m*n]的话，(m*n+1)这个点会访问到之前的数据。

 #include<cstdio>
 #include<cstring>
 #include<vector>
 #include<algorithm>
 #define clr(a,m) memset(a,m,sizeof(a))
 #define rep(i,a,b) for(int i=a;i<=b;i++)
 #define rrep(i,a,b) for(int i=a;i>=b;i--)
 using namespace std;

 const int MAXN=;
 const int MAXM=;
 const int INF =1e9;

 struct Point{
     int c,t;
     Point(){}
     Point(int _c,int _t):c(_c),t(_t){}
     bool operator < (const Point res)const {
         return c<res.c;
     }
 };

 struct Run{
     int num,l,r;
     Run(){}
     Run(int _num,int _l,int _r):num(_num),l(_l),r(_r){}
 }run[MAXN];
 int time[MAXM];

 int mem[MAXM],gap[MAXN][MAXN*MAXM];//数组忘记改大小了
 vector<Point>p[MAXN];

 int n,m,cnt;
 int Lx[MAXN],S[MAXN];
 int Ly[MAXN*MAXM],T[MAXN*MAXM],left[MAXN*MAXM],slack[MAXN*MAXM];

 void init()
 {
     rep(i,,n)
         p[i].clear();
 }

 void read()
 {
     init();
     rep(i,,m)
         scanf("%d",&mem[i]);
     rep(i,,n){
         int k,c,t;
         scanf("%d",&k);
         rep(j,,k){
             scanf("%d%d",&c,&t);
             p[i].push_back(Point(c,t));
         }
     }
     rep(i,,n){
         int sz=p[i].size();
         rep(j,,m){
             int tt;
             if(mem[j]<p[i][].c)
                 tt=INF;
             else{
                 int x=upper_bound(p[i].begin(),p[i].end(),Point(mem[j],))-p[i].begin();
                 tt=p[i][x-].t;
             }

             rep(p,,n){
                 if(tt==INF)gap[i][(j-)*n+p]=-INF;
                 else gap[i][(j-)*n+p]=-p*tt;
             }
         }
     }
 }

 bool match(int u)
 {
     S[u]=true;
     rep(v,,n*m)
         if(!T[v]){
             int tmp=Lx[u]+Ly[v]-gap[u][v];
             if(tmp==){
                 T[v]=true;
                 if(!left[v]||match(left[v])){
                     left[v]=u;
                     return true;
                 }
             }else slack[v]=min(slack[v],tmp);
         }
     return false;
 }

 void update()
 {
     int a=INF;
     rep(v,,n*m)//!!
         if(!T[v])
             if(a>slack[v]){
                 a=slack[v];
             }
     rep(i,,n)
         if(S[i])Lx[i]-=a;
     rep(i,,n*m)//!!
         if(T[i])Ly[i]+=a;

 }

 void KM()
 {
     rep(i,,n){
         Lx[i]=-INF;
         rep(j,,n*m)
             if(Lx[i]<gap[i][j]){
                 Lx[i]=gap[i][j];
             }
     }
     rep(i,,n*m+)
         left[i]=Ly[i]=;

     rep(i,,n){
         rep(j,,n*m)
             slack[j]=INF;
         while()
         {
             rep(j,,n)
                 S[j]=;
             rep(j,,n*m)
                 T[j]=;
             if(match(i))
                 break;
             else{
                 update();
             }
         }
     }
 }

 void print()
 {
     printf("Case %d\n",++cnt);

     int ans=;
     rep(i,,n)
         ans+=Lx[i];
     rep(i,,n*m)
         ans+=Ly[i];
     printf("Average turnaround time = %.2f\n",-ans*1.0/n);

     clr(time,);
     rep(i,,m){
         int sz;
         rep(p,,n+)//!会不会全都在同一个内存区？放在最后一个内存区，找到的+1会越界找到上一组数据
             if(left[(i-)*n+p]==){
                 sz=p-;
                 break;
             }
         rrep(p,sz,){
             int x=left[(i-)*n+p];
             run[x]=Run(i,time[i],time[i]-gap[x][(i-)*n+p]/p);
             time[i]-=gap[x][(i-)*n+p]/p;
         }
     }
     rep(i,,n)
         printf("Program %d runs in region %d from %d to %d\n",i,run[i].num,run[i].l,run[i].r);
 }

 int main()
 {
     cnt=;
     while(~scanf("%d%d",&m,&n))
     {
         if(!n&&!m)
             return ;
         if(cnt)puts("");
         read();
         KM();
         print();
     }
     return ;
 }
 /*
 2 4
 40 60
 1 35 4
 1 20 3
 1 40 10
 1 60 7
 2 2
 20 40
 2 20 100 40 2
 2 20 100 40 3
 */