顶一下。
晚些时候贴个代码吧，没有代码估计都么有人愿意看这个问题。

有M个机器，其中，所述第i个机器有次芯（ⅰ从1开始）。在每台机器上，芯结构中的一行。 
有以下类型的服务q查询： 
    1，问对k内核。我们必须找到与第一台机器（ 
至少指数），使得它有K个连续的无芯并为它们分配 
给客户。如果有一个解决方案，返回结果（M，C），其中m 
被机器和c的索引是第一核心的分配索引 
在机器上。否则，返回（-1，-1）。一旦内核被分配 
它们不能被使用，直至它们被释放。 
     2，释放的核 
分配的所述第一类型的一个查询中。我们保证 
所述第一类型的第a个查询存在与每个查询被释放至多 
一次。如果相应的查询没有一个解决方案，你应该只 
忽视它。 
[输入参数] 
第一行给出了一个整数T，测试用例的数量。 
为 
每个测试例中，第一行给出了M和Q，则M线跟随，每 
其中包含一个数字，指示次为第i行。对于 
接下来的Q行，他们每个人给出的查询。 
     1，A K。对应于查询的第一类型，k是请求的核心数。 
     2，F A。对应于第二类型的查询，一个指示第一类型的一个查询。 
所有的数字都是整数。 
[输出规格] 
为 
每个测试案例，第一输出线在此格式“案例＃我：”（不 
引号），其中i是案件编号，从1开始，之后， 
输出结果为1型的每个查询，无论是“MC”（不带引号），如果 
有解决的查询，或“-1 -1”（不带引号），如果没有 
解决方案找到。 
[限制] 
1<= T<=20 
1<= M<=100000 
1 <=次<=128 
1<= Q<=百万 
1<= K<=128 
1<= A <= Q 
类型1的查询的数量是相同的类型2。

引用 2 楼 zhao4zhong1 的回复:

有M个机器，其中，所述第i个机器有次芯（ⅰ从1开始）。在每台机器上，芯结构中的一行。 
有以下类型的服务q查询： 
    1，问对k内核。我们必须找到与第一台机器（ 
至少指数），使得它有K个连续的无芯并为它们分配 
给客户。如果有一个解决方案，返回结果（M，C），其中m 
被机器和c的索引是第一核心的分配索引 
在机器上。否则，返回（-1，-1）。一旦内核被分配 
它们不能被使用，直至它们被释放。 
     2，释放的核 
分配的所述第一类型的一个查询中。我们保证 
所述第一类型的第a个查询存在与每个查询被释放至多 
一次。如果相应的查询没有一个解决方案，你应该只 
忽视它。 
[输入参数] 
第一行给出了一个整数T，测试用例的数量。 
为 
每个测试例中，第一行给出了M和Q，则M线跟随，每 
其中包含一个数字，指示次为第i行。对于 
接下来的Q行，他们每个人给出的查询。 
     1，A K。对应于查询的第一类型，k是请求的核心数。 
     2，F A。对应于第二类型的查询，一个指示第一类型的一个查询。 
所有的数字都是整数。 
[输出规格] 
为 
每个测试案例，第一输出线在此格式“案例＃我：”（不 
引号），其中i是案件编号，从1开始，之后， 
输出结果为1型的每个查询，无论是“MC”（不带引号），如果 
有解决的查询，或“-1 -1”（不带引号），如果没有 
解决方案找到。 
[限制] 
1<= T<=20 
1<= M<=100000 
1 <=次<=128 
1<= Q<=百万 
1<= K<=128 
1<= A <= Q 
类型1的查询的数量是相同的类型2。

你这个机器翻译的？
晚点我给一个翻译吧。

欢迎楼主做一个有益于码农的村官。

 There are M machines, in which the i-th machine has Ci cores (i starts from 1). On each machine, cores are structured in a line.

有M台机器，第i台机器拥有的核数量为Ci（至少为1），每台机器的cores连续并排。

There are Q queries of the following types to serve:

    1. Ask for k cores. We have to find the first machine (with theleast index) such that it has k free continuous cores and allocate themto customer. If there is a solution, return the result (m, c), in which m is the index of machine and c is the index of the first core allocated on the machine. Otherwise, return (-1,-1). Once the cores are allocated,they cannot be used until they are freed. 
2. Free the cores
allocated in the a-th query of the first type. We guarantee that the a-th query of the first type exists and each query is freed at most once. If the corresponding query didn't have a solution, you should just ignore it. 

有Q次查询操作以如下两种类型执行：
1， Ask k个核，我们必须找到第一台（也就是序列最小的）拥有k个连续的可用核的机器，然后分配给客户。如果可行就返回（M，c）对，其中M为机器的索引，而c为这台机器里面这次请求到的第一个核的id；否则返回 (-1,-1)。一旦核被分配了，就不能再次分配（使用），直到被释放。

2、Free 核
释放之前第a次申请的核，我们保证上面的第a次申请操作是存在的，而且每次申请的核被一次释放。如果第a次申请么有成果，那么这次free应该被忽略。

引用 4 楼 zhao4zhong1 的回复:

欢迎楼主做一个有益于码农的村官。

你如何知道我做村官了？

引用 6 楼 ztz0223 的回复:

Quote: 引用 4 楼 zhao4zhong1 的回复:

欢迎楼主做一个有益于码农的村官。

你如何知道我做村官了？

（码）农民不都受村长（官）领导嘛。

仅供参考

//实现一个函数：求数轴上多个线段覆盖的区域对应的多个线段; 输入多个线段,求出被这些线段覆盖的所有区域(也用线段表示); 一条线段用两个值表示(x0,x1), 其中x1>x0;

//比如(1,3);(2,4);(5,6);结果为(1,4);(5,6);

//比如(1,3);(2,4);(5,6);(4,7);结果为(1,7);

#include <stdio.h>

#define MAXLINES 100

struct LINE {

    int x0;//左端

    int x1;//右端

} ls[MAXLINES];

int i,j,k,n,x0,x1,c;

void add() {

    if (0==n) {//加入第一对点

        ls[n].x0=x0;

        ls[n].x1=x1;

        n=1;

    } else {

        if (x1==ls[0].x0) {//右端＝第一条线段的左端

            ls[0].x0=x0;//第一条线段的左端修改为左端

            return;

        }

        if (x1<ls[0].x0) {//右端＜第一条线段的左端

            for (i=n-1;i>=0;i--) {//将所有线段往后移

                ls[i+1].x0=ls[i].x0;

                ls[i+1].x1=ls[i].x1;

            }

            ls[0].x0=x0;//新第一条线段为x0,x1

            ls[0].x1=x1;

            n++;

            return;

        }

        if (ls[n-1].x1<x0) {//左端＞最后那条线段的右端

            ls[n].x0=x0;//新最后那条线段

            ls[n].x1=x1;

            n++;

            return;

        }

        if (x0<=ls[0].x0 && ls[n-1].x1<=x1) {//左端≤第一条线段的左端且最后那条线段的右端≤右端

            ls[0].x0=x0;//只剩这一条线段

            ls[0].x1=x1;

            n=1;

            return;

        }

        for (i=0;i<n;i++) {//从左到右依次检查每条线段

            if (ls[i].x0<=x0 && x0<=ls[i].x1) {//第i条线段的左端≤左端≤第i条线段的右端

                for (j=i;j<n;j++) {//从第i条线段开始从左到右依次检查每条线段

                    if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端

                        ls[i].x1=ls[j].x1;//第i条线段的右端改为第j条线段的右端

                        for (k=1;k<=n-j-1;k++) {//将剩余线段往前移

                            ls[i+k].x0=ls[j+k].x0;

                            ls[i+k].x1=ls[j+k].x1;

                        }

                        n-=j-i;

                        return;

                    }

                    if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)

                        ls[i].x1=x1;//第i条线段的右端改为右端

                        for (k=1;k<=n-j-1;k++) {//将剩余线段往前移

                            ls[i+k].x0=ls[j+k].x0;

                            ls[i+k].x1=ls[j+k].x1;

                        }

                        n-=j-i;

                        return;

                    }

                }

            }

            if (ls[i].x1<x0 && (i==n-1 || x0<ls[i+1].x0)) {//第i条线段的右端＜左端＜第i+1条线段的左端(如果有)

                if (i!=n-1 && x1<ls[i+1].x0) {//右端＜第i+1条线段的左端(如果有)

                    for (k=n-1;k>=i+1;k--) {//将从第i+1条线段开始的所有线段往后移

                        ls[k+1].x0=ls[k].x0;

                        ls[k+1].x1=ls[k].x1;

                    }

                    ls[i+1].x0=x0;//新第i+1条线段为x0,x1

                    ls[i+1].x1=x1;

                    n++;

                    return;

                }

                for (j=i+1;j<n;j++) {//从第i+1条线段开始从左到右依次检查每条线段

                    if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端

                        ls[i+1].x0=x0;//第i+1条线段的左端改为左端

                        ls[i+1].x1=ls[j].x1;//第i+1条线段的右端改为第j条线段的右端

                        for (k=1;k<=n-j-1;k++) {//将剩余线段往前移

                            ls[i+1+k].x0=ls[j+k].x0;

                            ls[i+1+k].x1=ls[j+k].x1;

                        }

                        n-=j-i-1;

                        return;

                    }

                    if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)

                        ls[i+1].x0=x0;//第i+1条线段的左端改为左端

                        ls[i+1].x1=x1;//第i+1条线段的右端改为右端

                        for (k=1;k<n-j-1;k++) {//将剩余线段往前移

                            ls[i+k].x0=ls[j+k].x0;

                            ls[i+k].x1=ls[j+k].x1;

                        }

                        n-=j-i-1;

                        return;

                    }

                }

            }

            if (x0<ls[i].x0) {//左端＜第i条线段的左端

                for (j=i;j<n;j++) {//从第i条线段开始从左到右依次检查每条线段

                    if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端

                        ls[i].x0=x0;//第i条线段的左端改为左端

                        ls[i].x1=ls[j].x1;//第i条线段的右端改为第j条线段的右端

                        for (k=1;k<=n-j-1;k++) {//将剩余线段往前移

                            ls[i+k].x0=ls[j+k].x0;

                            ls[i+k].x1=ls[j+k].x1;

                        }

                        n-=j-i;

                        return;

                    }

                    if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)

                        ls[i].x0=x0;//第i条线段的左端改为左端

                        ls[i].x1=x1;//第i条线段的右端改为右端

                        for (k=1;k<=n-j-1;k++) {//将剩余线段往前移

                            ls[i+k].x0=ls[j+k].x0;

                            ls[i+k].x1=ls[j+k].x1;

                        }

                        n-=j-i;

                        return;

                    }

                }

            }

        }

    }

}

void show() {

    for (i=0;i<n;i++) {

        printf("(%d,%d);",ls[i].x0,ls[i].x1);

    }

    printf("\n");

}

void main() {

    n=0;

    c=0;

    while (1) {

        printf("Input x0,x1(x0<x1;0,0 to exit):");

        fflush(stdout);

        rewind(stdin);

        if (2==scanf("%d,%d",&x0,&x1)) {

            if (0==x0&&0==x1) break;

            if (x1>x0) {

                c++;

                if (c>=MAXLINES) {

                    printf("Up to %d!\n",MAXLINES);

                    break;

                }

                add();

                show();

            }

        }

    }

}

这题的难点应该是如何排序，每次分配时最多需要访问128*10000个节点，所以遍历搜索不可取，必须排序。这里有3个关键字段：机器号（1-10000），内核号（1-128），连续空闲数量（1-128），而每次给出的搜索条件只有连续空闲数量（比如A 10 -- 分配连续10个core），必须找出匹配的最小机器号+最小内核号，这里的最大问题是如何排序，一般思考总是按搜索条件排序，比如用最大空闲数量+机器号+内核号这样的顺序排序，但是按题目要求这样排序并不能找到合适结果，因为比如你需要分配连续10个core，而满足条件的可能有第300号机器第7内核开始有10个core空闲，第5000机器第50内核开始有10个空闲，第156号机器第3内核开始有100个空闲，按题目要求，匹配的是（156，3）而不是排序之后得到的结果（300，7），而如果用机器号+空闲数+内核号排序，因为输入条件只有一个空闲数，所以还是必须遍历搜索。

引用 9 楼 Idle_ 的回复:

这题的难点应该是如何排序，每次分配时最多需要访问128*10000个节点，所以遍历搜索不可取，必须排序。这里有3个关键字段：机器号（1-10000），内核号（1-128），连续空闲数量（1-128），而每次给出的搜索条件只有连续空闲数量（比如A 10 -- 分配连续10个core），必须找出匹配的最小机器号+最小内核号，这里的最大问题是如何排序，一般思考总是按搜索条件排序，比如用最大空闲数量+机器号+内核号这样的顺序排序，但是按题目要求这样排序并不能找到合适结果，因为比如你需要分配连续10个core，而满足条件的可能有第300号机器第7内核开始有10个core空闲，第5000机器第50内核开始有10个空闲，第156号机器第3内核开始有100个空闲，按题目要求，匹配的是（156，3）而不是排序之后得到的结果（300，7），而如果用机器号+空闲数+内核号排序，因为输入条件只有一个空闲数，所以还是必须遍历搜索。

你说的对，复杂的地方就在这里。我反正怎么搞都没有成功，之前结果错误，然后修改了实现，就无法输出了。估计还是效率问题。
发出来我的垃圾代码，希望可以高手指点以下。