UVALive 2238 Fixed Partition Memory Management 固定分区内存管理（KM算法，变形）

题意：目前有一部分可用内存，分为m个大小固定的区域。现有n个程序要执行，每个程序在不同大小的内存中运行所需的时间不同，要使运行完所有程序所耗时最少，问每个程序在哪块区域中从什么时间运行到什么时间，以及运行完所有程序的平均周转时间。

思路：各种记录有点麻烦！

　　m个区域看成m台内存大小为该区域大小的计算机，然后n个程序分别要选择在其中一台计算机中运行。由于运行有先后顺序，这也很影响平均周转时间，所以最极端时，其中某台计算机可能有n个程序要运行，那么每台计算机就得有n个位置供挑选。所以一共有n*m个位置啦，而只有n个程序，所以左边有n个点，右边有n*m个点，这样可以用KM算法求最佳匹配（必须最佳），而因为我们要使得周转时间少，所以建图时可以将边取相反数。

　　例如一台计算机：设有k个程序运行在该机，则其运行时间分别为t₁,t₂……t_k，则第i个程序结束时间Ti=t1+t2+……+ti （因为它得等前面的人运行完），则此机器上所有程序运行时间之和为sum=k*t₁ + (k-1)*t₂ + (k-2)*t₃ + …… + 1*t_k。对于倒数第p个执行的程序c来说，其对总运行时间的贡献为p*t_c（t_c该程序在该机器中所需的运行时间）。其他机器也是这样的。

　　那么可以建图了，如果程序c能在该机器x上运行，必定有一个运行时间t，而c可能排在任意一个位置，所以c应该有边连到机器x上的任意一个倒数为p的位置，权值为-t*p。这样子求KM的最佳匹配就行了。记得将点数少的放在左边的集合中。

　　输出才是个技术活！要特别注意的是大小的问题，n<=50，m<=10。

 #include <bits/stdc++.h>
 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
 #define pii pair<int,int>
 #define INF 0x7f7f7f7f
 #define LL long long
 using namespace std;
 const int N=;
 const int M=;
 vector<int> vect[N];
 struct node
 {
     int from, to, w;
     node(){};
     node(int from,int to,int w ):from(from),to(to),w(w){};
 }edge[N*M*M];

 struct node1
 {
     int region;         //第几个区域
     int countdown;      //倒数第几
     node1(){};
     node1(int re,int cd ):region(re),countdown(cd){};
 }pos[N*M] ;

 int edge_cnt, pos_cnt;
 int m, n;
 int msize[N];  //m块区域
 int k[N], req[N][M][];  //m个程序的要求

 void add_edge(int from,int to,int w)
 {
     edge[edge_cnt]=node(from, to, w);
     vect[from].push_back(edge_cnt++);
 }
 void add_pos(int r,int cd)
 {
     pos[pos_cnt]=node1(r,cd);
     pos_cnt++;
 }

 int Lx[N], Ly[N*M], slack[N*M];
 int girl[N*M], S[N], T[N*M];
 int get_time(int p,int siz)       //在reg区域找到能运行siz大小内存的时间
 {
     int t=;
     for(int r=; r<=k[p]; r++)
     {
         if( siz>=req[p][r][] )    t=req[p][r][];
         else break;
     }
     return t;
 }
 int last[N][M];

 void build()
 {
     //共n*m个位置.
     for(int j=; j<=m; j++) //对于每块区域
         for(int r=; r<=n; r++) //每个位置(倒数的)
             add_pos(j, r);

     for(int i=; i<=n; i++)     //每个程序
     {
         for(int j=; j<=m; j++) //每块区域
         {
             int t=get_time(i, msize[j] );
             if(!t)  continue;   //此程序不可在此区域运行。
             for(int r=; r<=n; r++) //每个位置
                 add_edge(i, (j-)*n+r, -t*r );
             last[i][j]=t;           //记录i程序在第j区域中的运行时间
         }
     }
 }

 bool DFS(int x)
 {
     S[x]=true;
     for(int j=; j<vect[x].size(); j++)
     {
         node &e=edge[vect[x][j]];
         if(T[e.to]) continue;

         int tmp=Lx[x] +Ly[e.to] -e.w;
         if(tmp==)
         {
             T[e.to]=true;
             if(!girl[e.to] || DFS( girl[e.to] ) )
             {
                 girl[e.to]=x;
                 return true;
             }
         }
         else if(slack[e.to]>tmp)    slack[e.to]=tmp;
     }
     return false;
 }

 void KM()    //用n个程序，匹配n*m个位置
 {
     //初始化
     memset(girl, , sizeof(girl));
     memset(Ly, , sizeof(Ly));  //数量比较大
     for(int i=; i<=n; i++)
     {
         Lx[i]=-INF;
         for(int j=; j<vect[i].size(); j++) //n*m个位置要匹配
         {
             node &e=edge[vect[i][j]];
             Lx[i]=max(Lx[i], e.w ); //取最大的一条边
         }
     }

     for(int i=; i<=n; i++)
     {
         for(int j=n*m; j>; j--) slack[j]=INF;
         while(true)
         {
             memset(T, , sizeof(T));
             memset(S, , sizeof(S));
             if(DFS(i))  break;

             //找最小slack
             int d=INF;
             for(int j=; j<pos_cnt; j++)
                 if(!T[j] && d>slack[j])
                     d=slack[j];

             //更新S
             for(int j=; j<=n; j++)
                 if(S[j])    Lx[j]-=d;

             //更新T
             for(int j=; j<pos_cnt; j++)
                 if(T[j])  Ly[j]+=d;
                 else      slack[j]-=d;
         }
     }
 }

 inline int cmp(pii a, pii b){return a.second>b.second;}
 int program[N][];
 vector<pii> region[M];
 void print(int Case)
 {
     memset(program,  , sizeof(program));
     for(int i=; i<=m; i++) region[i].clear();

     for(int i=; i<pos_cnt; i++)    //将匹配对的信息绑定在一起
         if(girl[i]!=)
             region[ pos[i].region ].push_back(make_pair( girl[i],  pos[i].countdown ));

     for(int i=; i<=m; i++)         //排个序，先执行的在前
         sort(region[i].begin(), region[i].end(), cmp);

     double sum=0.0;
     for(int i=; i<=m; i++) //计算执行的时间
     {
         int now=;
         for(int j=; j<region[i].size(); j++)
         {

             pii a=region[i][j];
             program[a.first][]=i;

             program[a.first][]=now;
             now+=last[a.first][i];       //所需要的时间呢？
             program[a.first][]=now;

             sum+=now;   //累加时间
         }
     }

     if(Case>)  printf("\n");
     printf("Case %d\n", Case);
     printf("Average turnaround time = %.2f\n", sum/n);
     for(int i=; i<=n; i++)
     {
         printf("Program %d runs in region %d from %d to %d\n", i, program[i][], program[i][], program[i][] );
     }
 }

 int main()
 {
     freopen("input.txt", "r", stdin);
     int Case=;
     while(scanf("%d%d",&m,&n), n+m)
     {
         edge_cnt=pos_cnt=;
         for(int i=; i<=n; i++) vect[i].clear();

         for(int i=; i<=m; i++)    scanf("%d", &msize[i]);   //m个区域的大小
         for(int i=; i<=n; i++) //程序i的内存要求，及时间。
         {
             scanf("%d", &k[i]);
             for(int j=; j<=k[i]; j++)
                 scanf("%d %d", &req[i][j][], &req[i][j][]);
         }
         build();    //建图
         KM();    //最佳匹配
         print(++Case);//输出
     }
     return ;
 }

AC代码