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=60;
const int M=20;
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][2];  //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=0;
    for(int r=1; r<=k[p]; r++)
    {
        if( siz>=req[p][r][0] )    t=req[p][r][1];
        else break;
    }
    return t;
}
int last[N][M];

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


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


bool DFS(int x)
{
    S[x]=true;
    for(int j=0; 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==0)
        {
            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, 0, sizeof(girl));
    memset(Ly, 0, sizeof(Ly));  //数量比较大
    for(int i=1; i<=n; i++)
    {
        Lx[i]=-INF;
        for(int j=0; j<vect[i].size(); j++) //n*m个位置要匹配
        {
            node &e=edge[vect[i][j]];
            Lx[i]=max(Lx[i], e.w ); //取最大的一条边
        }
    }

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

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

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

            //更新T
            for(int j=1; 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][3];
vector<pii> region[M];
void print(int Case)
{
    memset(program, 0 , sizeof(program));
    for(int i=0; i<=m; i++) region[i].clear();

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

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

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

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

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

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

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

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


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