POJ1065/HDOJ1051 Wooden Sticks

                                                                                         Wooden Sticks

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 14809		Accepted: 6081

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

 

 

思路：有一堆棍子，棍子有长度（L）和重量（W）。机器处理第一根棍子花费1秒。如果后一根棍子的长度（L`)和重量（W`)都比前一根的大，则后一根棍子不需要花费时间（L`>=L&&W`>=W)。求怎样处理这一堆棍子，所花费的时间最少。

        本题可以运用贪心策略，首先按照L进行递增排序，如果L相等则按照W递增进行排序（当然也可以把W当做第一关键字，L当做第二关键字）。排序后，从前往后，找出每一根棍子的后继棍子（条件为后一根棍子的L和W都>=前一根的）。最后可以找出都少条这样的链即为所求。

注意：本题表面上看可以依据L*W的递增进行排序，但是，实际上是不行的。反例：(5,2) (4,3) (4,1) (1,3)。如果按照L,W排序为：（1,3），（4,1），（4,3），（5,2）。结果为2。如果按照面积排序为（1,3），（4,1），（5,2），（4,3）。结果为3。

  

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstdlib>
  4 #include <cmath>
  5 #include <cstring>
  6 #include <algorithm>
  7 #include <map>
  8 #define MAXINT 99999999
  9 
 10 #define MININT -1
 11 
 12 using namespace std;
 13 
 14 struct Node{
 15        int l;
 16        int w;
 17        }node[5000+4];
 18        
 19        
 20 int vis[5000+4];
 21 
 22 
 23        
 24 bool cmp(Node x,Node y)
 25 {if(x.l<y.l)
 26  return true;
 27  else if(x.l==y.l)
 28  {if(x.w<=y.w)
 29   return true;
 30  }
 31  return false;
 32 }
 33 
 34 
 35 
 36 
 37 int main()
 38 {
 39     int n;
 40     int m;
 41     int i,j,k;
 42     scanf("%d",&m);
 43     while(m--)
 44     {
 45               scanf("%d",&n);
 46               
 47               for(i=0;i<n;i++)
 48               {
 49                               scanf("%d%d",&node[i].l,&node[i].w);
 50               }
 51               
 52               sort(node,node+n,cmp);
 53               
 54               //for(i=0;i<n;i++)
 55              // cout<<node[i].l<<' '<<node[i].w<<endl;
 56               
 57               for(i=0;i<n;i++)
 58               {vis[i]=0;}
 59               
 60               
 61               int countn=0;
 62               
 63               
 64               for(i=0;i<n;i++)
 65               {
 66                               if(vis[i])
 67                               continue;
 68                               
 69                               vis[i]=1;
 70                               countn++;
 71                               int pre=i;
 72                               for(j=i+1;j<n;j++)
 73                               {
 74                                               
 75                                               
 76                                               
 77                                               
 78                                               if(vis[j]==0)
 79                                               {
 80                                                            if(node[j].w>=node[pre].w)
 81                                                            {vis[j]=1;pre=j;}
 82                                               }
 83                                               
 84                               }
 85               }
 86               
 87               cout<<countn<<endl;
 88     }
 89                                                            
 90                               
 91               
 92               
 93               
 94           
 95            
 96                             
 97     
 98     //system("PAUSE");
 99     
100     return 0;
101 }