Wooden Sticks

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 23191 Accepted Submission(s): 9411

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

Solution

//贪心问题，先处理最长最重的木头以便一台机器可以处理尽可能多的木头，

Code

/**
 * date:2017.11.15
 * author:孟小德
 * function:杭电acm1051
 *
 */
 
 
 
import java.util.*;
 
public class acm1051
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
 
        int num = input.nextInt();
        int[] result = new int[num];
        for (int j=0;j<num;j++)
        {
            int wood_num = input.nextInt();
            wood[] array = new wood[wood_num];
            for (int i=0;i<wood_num;i++)
            {
                int len = input.nextInt();
                int weight = input.nextInt();
                array[i] = new wood(len,weight);
            }
 
            sort(array);
            int use_num = 0;
            result[j] = 0;
            wood temp = new wood();
            while (use_num < wood_num)
            {
                for (int i=0;i<wood_num;i++)
                {   //寻找未处理木头中最长最重的一根
                    if(array[i].use == false)
                    {
                        temp = array[i];
 
                        break;
                    }
                }
 
                for (int i=0;i<wood_num;i++)
                {// 寻找可以被同时处理的木头
                    if (array[i].use == false && array[i].len <= temp.len &&
                    array[i].weight <= temp.weight)
                    {
                        array[i].use = true;
                        use_num++;
                        temp = array[i];
                    }
                }
 
                result[j]++;
            }
 
        }
 
        for (int i=0;i<result.length;i++)
        {
            System.out.println(result[i]);
 
        }
    }
 
    //按长度排序，长度相同则按重量排序
    public static void sort(wood[] array)
    {
        boolean flag = true;
        wood temp = new wood();
        for (int i = 0;i<array.length && flag;i++)
        {
            flag = false;
            for (int j = 0;j<array.length-i-1;j++)
            {
                if (array[j].len < array[j+1].len)
                {
                    temp.len = array[j].len;
                    temp.weight = array[j].weight;
 
                    array[j].len = array[j+1].len;
                    array[j].weight = array[j+1].weight;
 
                    array[j+1].len = temp.len;
                    array[j+1].weight = temp.weight;
                    flag = true;
                }
                else if (array[j].len == array[j+1].len)
                {
                    if (array[j].weight < array[j+1].weight)
                    {
                        temp.len = array[j].len;
                        temp.weight = array[j].weight;
 
                        array[j].len = array[j+1].len;
                        array[j].weight = array[j+1].weight;
 
                        array[j+1].len = temp.len;
                        array[j+1].weight = temp.weight;
                        flag = true;
                    }
                }
            }
        }
    }
 
}
 
class wood
{
    public int len;
    public int weight;
    public boolean use = false;
 
    public wood()
    {
 
    }
 
    public wood(int len,int weight)
    {
        this.len = len;
        this.weight = weight;
    }
}