解法：对于位置(x1,y1)和位置(x1,y2)处的垃圾,如果满足x1<=x2&&y1<=y2(当然不可能出现两个相同的坐标),那么这两个位置处的垃圾只需要一个机器人就可以成功
            处理，则有Dilworth定理可知,将x坐标升序排序，相等时将y坐标升序排序(实际上题目就是按照这种形式输入),然后对y序列求解最长递减子序列数目即为所求。
            贪心算法可求。同1065。

源代码
 1#include<iostream>
 2#include<algorithm>
 3
 4using namespace std;
 5
 6const int MAXN = 580;
 7
 8struct Garbage
 9{
10    int r;
11    int c;
12    bool visited;
13};
14
15Garbage gar[MAXN];
16
17bool com(Garbage s1, Garbage s2)                //比较函数
18{
19    if(s1.r == s2.r)
20    {
21        return s1.c < s2.c;
22    }
23    else
24    {
25        return s1.r < s2.r;
26    }
27}
28
29int main()
30{
31    int minR;
32    Garbage cur;
33    bool allVisited;
34    int ind;                             //当前序列的第一元素数组下标
35    int n;
36
37    cin>>gar[0].r>>gar[0].c;
38    while(!(gar[0].r == -1 && gar[0].c == -1))
39    {
40        gar[0].visited = false;
41        n = 0;
42        while(!(gar[n].r == 0 && gar[n].c == 0))
43        {
44            ++n;
45            cin>>gar[n].r>>gar[n].c;
46            gar[n].visited = false;
47        }
48        ++n;
49
50        sort(gar,gar+n,com);             //排序
51
52        minR = 0;
53        ind = 0;
54        allVisited = false;
55        while(!allVisited)
56        {
57            allVisited = true;
58            for(;ind<n; ind++)           //新序列
59            {
60                if(!gar[ind].visited)
61                {
62                    cur = gar[ind];
63                    gar[ind].visited = true;
64                    allVisited = false;
65                    ++minR;
66                    break;
67                }
68            }
69            for(int j=ind+1; j<n; j++) 
70            {
71                if(!gar[j].visited && cur.r <= gar[j].r && cur.c <= gar[j].c)
72                {
73                    cur = gar[j];
74                    gar[j].visited = true;
75                }
76            }
77        }
78        cout<<minR<<endl;
79        cin>>gar[0].r>>gar[0].c;
80    }
81    return 0;
82}

思路：贪心算法。首先对棍子按长度从小到大排序，在长度相等的情况下再按重量由小到大对棍子排序。然后从第一跟棍子开始，依次考察后面的没被使用的棍子，如果该棍子没被使用过，
            且重量大于等于它的重量，长度大于等于它的长度，则将两跟棍子安排在一个序列中，并将加入序列的棍子置已使用标志。直到所有棍子都使用完，则序列数即为所需的最小准备时间。

源代码
 1#include<iostream>
 2#include<algorithm>
 3
 4using namespace std;
 5
 6const int MAXN = 5001;
 7
 8struct Stick
 9{
10    int l;
11    int w;
12    bool visited;
13};
14
15Stick sti[MAXN];
16
17bool com(Stick s1, Stick s2)                //棍子排序比较函数
18{
19    if(s1.l == s2.l)
20    {
21        return s1.w < s2.w;
22    }
23    else
24    {
25        return s1.l < s2.l;
26    }
27}
28
29int main()
30{
31    int T;
32    int n;
33    int minT;
34    Stick cur;
35    bool allVisited;
36    int ind;                             //当前序列的第一概棍子数组下标
37
38    cin>>T;
39    while(T--)
40    {
41        cin>>n;
42        for(int i=0; i<n; i++)
43        {
44            cin>>sti[i].l>>sti[i].w;
45            sti[i].visited = false;
46        }
47        sort(sti,sti+n,com);             //排序
48
49        minT = 0;
50        ind = 0;
51        allVisited = false;
52        while(!allVisited)
53        {
54            allVisited = true;
55            for(;ind<n; ind++)           //新序列的第一根棍子
56            {
57                if(!sti[ind].visited)
58                {
59                    cur = sti[ind];
60                    sti[ind].visited = true;
61                    allVisited = false;
62                    ++minT;
63                    break;
64                }
65            }
66            for(int j=ind+1; j<n; j++)    //序列中其他棍子
67            {
68                if(!sti[j].visited && cur.l <= sti[j].l && cur.w <= sti[j].w)
69                {
70                    cur = sti[j];
71                    sti[j].visited = true;
72                }
73            }
74        }
75        cout<<minT<<endl;
76    }
77    return 0;
78}
79