HDU：1051 Wooden Sticks（贪心+动态规划DP||LIS？）

Wooden Sticks

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 18567 Accepted Submission(s): 7574



Problem 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 (4,9), (5,2), (2,1), (3,5), and (1,4), then the minimum setup time should be 2 minutes since there is
a sequence of pairs (1,4), (3,5), (4,9), (2,1), (5,2).

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 n 2 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

Asia 2001, Taejon (South Korea)

Recommend

We have carefully selected several similar problems for you: 1050 1045 1053 1789 1003

题目大意：给你n个棍子的长和重量，比如你加工了一根棍子，需要准备1分钟，若你加工完之后，再加工下一根棍子，如果新棍子的长和重量都大于等于上根棍子的长和重量，那么此时就不需要准备那1分钟了，问你如何安排能使得准备时间最少。

解题思路：我先将棍子的按长度升序排序，如果长度一样的话按重量升序排序，然后设置一个辅助数组记录加工过的且没有后继的棍子的长度和重量，每新加工一根棍子，就与辅助数组里面的棍子比较，如果符合不消耗时间的话（在已加工的没有后继的棍子中挑一根，新的作为它的后继）那么更新下辅助数组里的最新棍子作为新的没有后继的棍子，原来那根就有后继了，用新的来代替它；如果找不到的话那就不得不消耗一分钟了，然后将其加入辅助数组。

代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;
struct node
{
int chang,zhong;
}wood[5010];
node dp[5010];//记载没有后继的棍子
bool cmp(struct node a,struct node b)
{
if(a.chang==b.chang)
{
return a.zhong<b.zhong;
}
else
{
return a.chang<b.chang;
}
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d%d",&wood[i].chang,&wood[i].zhong);
}
sort(wood+1,wood+n+1,cmp);//排序
dp[1]=wood[1];//设置前键
int ans=1;//初始化答案，第一根棍子一定消耗1分钟啊
for(int i=2;i<=n;i++)
{
int flag=0;//标记能否找到符合不消耗一分钟的棍子
for(int j=1;j<=ans;j++)//扫描之前没有后继的棍子
{
if(dp[j].chang<=wood[i].chang&&dp[j].zhong<=wood[i].zhong)//找符合不消耗时间的棍子 ，由于之前已经排序了，所用辅助数组里面的也是有序的，不用担心
{
dp[j]=wood[i];//新棍子代替了原来的棍子，成了新的没后继的棍子
flag=1;
break;
}
}
if(flag==0)//找不到，就得花一分钟了，将其加入辅助数组
{
ans++;
dp[ans]=wood[i];
}
}
printf("%d\n",ans);
}
return 0;
}