UESTCoj Grab a hole （二分+贪心）

Description

"One radish, one hole"

N rats migrate to a new habitat. There are exactly N holes which lie on a line one by one. The holes are numbered (starting from the leftmost one) from 1 to n. They don't want to share a hole with others, so every rat should grab a hole as its home. Each rat has an interested interval (we denote it as [s,t], in which s and t are the two ends) of holes from which it would choose one to grab. However, a plan that ensures any rats have a hole may not exist.

RectaFlex loves these rats very much. He wants to train these rats to expand their interested interval with K more holes. Note that the new expanded interested interval of each rat must still be continuous. If a rat interested in holes which belong to interval [s,t], it could extend the interval with K more hole. After training, the intervals this rat interest will be [s-a,t+b] (a+b<=k, 0<=a<=k, 0<=b<=k).

Because training these rats to expand their habitat's scope is very hard, RectaFlex wants to know the minimum K.

Input

There are multiple test cases. The first line of the input will be an integer T (T <= 20) indicating the number of test cases.

For each test case there is an integer N (1 <= N <= 500) in a single line, representing the number of holes (i.e. the number of rats). The holes are numbered from 1 to N. Then follows N lines, each contains two integers L_i and R_i (1 <= L_i <= R_i <= N), indicating the interest interval of the i^th rat (inclusive).

Output

For each test case, print "Case #t: " first, in which t is the number of the test case starting from 1. Then output the minimum K.

Sample Input

5
2
1 1
1 1
5
1 1
1 1
5 5
5 5
5 5
3
1 1
2 2
3 3
4
1 1
1 2
2 3
3 4
4
1 1
1 2
1 1
1 4

Sample Output

Case #1: 1
Case #2: 2
Case #3: 0
Case #4: 0
Case #5: 1

Hint

In the first case, expanding the intervals to be [1,2] guarantees each rat a hole.

Source

10th UESTC Programming Contest Final 

分析：首先二分答案。之后可以匹配，但是复杂度过高，会超时。正解是贪心。把
区间按左端点排序，扫描时取覆盖当前点的区间中右端点最大的，这个要用堆维
护。复杂度 O(N*log(N)^2)。数据规模较小，不用堆直接枚举也可以过，复杂度
O(N^2*logN)。

我的代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define maxn 510
using namespace std;
int n;
struct node
{
    int l,r;
};
node data[maxn];
bool cmp(node a,node b)
{
    if(a.l!=b.l)
    return a.l<b.l;
    else
    return a.l<b.l;
}
bool judge(int x)
{
    int i,j,k,tim=1;
    bool use[maxn];
    memset(use,0,sizeof(use));
    for(i=1;i<=n;i++)
    {
        k=0;
        for(j=1;j<=n;j++)
        {
            if(!use[j]&&(data[j].l-x)<=tim&&(data[j].r+x)>=tim)
            {
                if(k==0)k=j;
                else
                if(data[j].r<data[k].r)
                k=j;
            }
        }
        if(k==0)return 0;
           use[k]=1;
            tim++;
    }
    return 1;
}
int main()
{
   int t,i,j,k,m,cas=1;
   scanf("%d",&t);
   while(t--)
   {
       scanf("%d",&n);
       for(i=1;i<=n;i++)
       scanf("%d%d",&data[i].l,&data[i].r);
       sort(data+1,data+n+1,cmp);
       int l=0,r=n,mid;
       while(l<r)
       {
           mid=(l+r)/2;
           if(judge(mid))r=mid;
           else
           l=mid+1;
       }
       printf("Case #%d: %d\n",cas++,r);
   }
}