Wooden Sticks

Wooden Sticks

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) : 35   Accepted Submission(s) : 11

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

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

题意：
给出一组木棍的长l、重w，如果上一个木棍的l、w比下一个的要小的话，不需要额外时间，否则多加一分钟。
分析：
贪心算法，优先选择最长的，再从剩下的里面选择最长的。
先按l从小到大的顺序来排好（若相等，则用w），从第一个开始，往后找找到这组数一系列（即w、l都比下一个小）找到最后停止，计数+1，这是该组的最优，即贪心中的单步最优。
找完一组后，再从剩下的当中找，当找过所有的数之后，结束count即为所求的数。
代码：
#include<algorithm>
#include<stdio.h>
#include<string.h>
using namespace std;
struct sticks{
    int l;
    int w;
    int flag;
}s[5002];/*运用结构体使条理更清晰*/
int cmp(const void *a,const void *b){/*struct的二级排序，先按l排若相等，则按w排，注意大小关系*/
    struct sticks *c=(sticks*)a;
    struct sticks *d=(sticks*)b;
    if(c->l!=d->l)
        return c->l-d->l;
    else
        return c->w-d->w;
}
int main(){
    int T,n;
    int i,j,count,cl,cw;/*count是计数的，ccurrent是当前的，所以cl为当前
的长，同理cw*/
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        memset(s,0,sizeof(s));/*清零防干扰*/
        for(i=0;i<n;i++)
            scanf("%d%d",&s[i].l,&s[i].w);
        qsort(s,n,sizeof(s[0]),cmp);/*这里排序的数目是n，从小到大排*/
        count=1;/*第一根木棍上来肯定要花1*/
        s[0].flag=1;/*标记下是否被容纳过*/
        cl=s[0].l;/*记录当前的l*/
        cw=s[0].w;/*记录当前的w*/
        /*用循环去跟当前比较，如果都小的话，就是能被容纳，不需要多加时间*/
        for(i=1;i<n;i++){
            for(j=i;j<n;j++){
                if(s[j].flag!=1&&s[j].l>=cl&&s[j].w>=cw){
                    s[j].flag=1;
                    cl=s[j].l;
                    cw=s[j].w;
                }
            }
            j=1;
            while(s[j].flag==1)/*判断是否全被容纳过，若是，则完成*/
                j++;
            i=j;/*找到最前边的没有被标记过的一组数，即剩下中最小的一组数，再次找*/
            if(i==n)
                break;/*跳出*/
            count++;/*每找过一次，就说明一次可能，所以count计数是所求结果*/
            s[i].flag=1;
            cl=s[i].l;/*重新刷新下当前数*/
            cw=s[i].w;
        }
        printf("%d\n",count);

    }
    return 0;
}