hdu 1065(贪心)

Wooden Sticks

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 20938		Accepted: 8872

Description

There is a pile of n wooden sticks. The length and weight of each stick are known in advance. The sticks are to be processed by a woodworking machine in one by one fashion. It needs some time, called setup time, for the machine to prepare processing a stick. The setup times are associated with cleaning operations and changing tools and shapes in the machine. The setup times of the woodworking machine are given as follows:
(a) The setup time for the first wooden stick is 1 minute.

(b) Right after processing a stick of length l and weight w ,
the machine will need no setup time for a stick of length l' and
weight w' if l <= l' and w <= w'. Otherwise, it will need 1
minute for setup.

You are to find the minimum setup time to process a given pile of n
wooden sticks. For example, if you have five sticks whose pairs of
length and weight are ( 9 , 4 ) , ( 2 , 5 ) , ( 1 , 2 ) , ( 5 , 3 ) ,
and ( 4 , 1 ) , then the minimum setup time should be 2 minutes since
there is a sequence of pairs ( 4 , 1 ) , ( 5 , 3 ) , ( 9 , 4 ) , ( 1
, 2 ) , ( 2 , 5 ) .

Input

The
input consists of T test cases. The number of test cases (T) is
given in the first line of the input file. Each test case consists of
two lines: The first line has an integer n , 1 <= n <=
5000 , that represents the number of wooden sticks in the test
case, and the second line contains 2n positive integers l1 , w1
, l2 , w2 ,..., ln , wn , each of magnitude at most 10000 ,
where li and wi are the length and weight of the i th wooden
stick, respectively. The 2n integers are delimited by one or more
spaces.

Output

The output should contain the minimum setup time in minutes, one per line.

Sample Input

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

Sample Output

2
1
3

Source

Taejon 2001

不知道为何要分到最长上升子序列..只有上升的感觉吧。。

题意：n根木棒，每根木棒都有个长度和重量两个属性，现在要处理这些木棒，当下一根木棒的重量和长度都不小于上一根木棒时，机器就继续工作，否则，机器就要一秒钟重置，

问全部处理完要多久.

题解：和矩形嵌套问题几乎一样，只是这里需要处理完所有木棒.先按长度排序，如果长度相同再按重量排序。利用贪心思想,每次找到可以延伸到的最远距离。然后把这条路上的点全部标记，然后从没标记的下一点开始找，一直找到可以延伸的最远距离。每次重新找+1就是了。

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<math.h>
#include <algorithm>
using namespace std;
const int N = ;

struct Wooden{
    int l,w;
}wd[N];
int cmp(Wooden a ,Wooden b){
    if(a.l!=b.l) return a.l<b.l;
    return a.w<b.w;
}
bool use[N];
int main()
{
    int tcase ;
     scanf("%d",&tcase);
     while(tcase--){
        memset(use,,sizeof(use));
        int n;
        scanf("%d",&n);
        int time = ;
        for(int i=;i<=n;i++) scanf("%d%d",&wd[i].l,&wd[i].w);
        sort(wd+,wd++n,cmp);
        for(int i=;i<=n;i++){
            if(!use[i]){
                ++time;
                int w = wd[i].w;
                for(int j=i+;j<=n;j++){
                    if(!use[j]&&wd[j].w>=w){
                        w = wd[j].w;
                        use[j]=;
                    }
                }
            }
        }
        printf("%d\n",time);
     }
    return ;
}