（Java实现） 零件分组

零件分组（Stick）-动态规划-中高级

Case Time Limit:1000MS

Time Limit: 3000MS Memory Limit: 65536K

Total Submissions: 62 Accepted: 21

Description

某工厂生产一批棍状零件，每个零件都有一定的长度（Li）和重量（Wi）。现在为了加工需要，要将它们分成若干组，使每一组的零件都能排成一个长度和重量都不下降

Input

第一行为一个整数N（N<=1000），表示零件的个数。第二行有N对正整数，每对正整数表示这些零件的长度和重量，长度和重量均不超过10000。

Output

仅一行，即最少分成的组数。

Sample Input

5 8 4 3 8 2 3 9 7 3 5

Sample Output

2

思路：

刚开始看到这题的时候感觉和导弹拦截那道题的第二问很像。

但是这道题和导弹那道题的差距是，导弹那道题的导弹顺序是固定的，所以我们分组的时候也只能从前到后进行分组。

但是这里我们可以对他们的顺序进行改变后再进行分组。

所以首先我先对零件的长度进行从小到大的排序，因为我们要求的是一个LIS，这是第一个约束条件，然后我们就像导弹的第二问那样，进行分组。分组的时候要注意当有多种情况成立时，我们要选择那个w较大的那个，因为我们尽可能的要让w小的去匹配小的嘛。然后就能够求出需要几组了。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class lingjianfenzu {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), b, c, d = 0;
		int[] l = new int[n + 1];
		boolean[] lb = new boolean[n + 1];
		int[] len = new int[n + 1];
		int[] w = new int[n + 1];
		int[] we = new int[n + 1];
		for (int i = 1; i < w.length; i++) {
			l[i] = sc.nextInt();
			len[i] = l[i];
			w[i] = sc.nextInt();
			// map.put(b, c);
		}
		// int a=1;
		// for (int i :map.keySet()) {
		// l[a]=i;
		// w[a]=map.get(i);
		// a++;
		// }
		Arrays.sort(len);
		for (int i = 1; i < w.length; i++) {
			we[i] = Integer.MAX_VALUE;
			for (int j = 1; j < w.length; j++) {
				if (len[i] == l[j] && !lb[j]) {
					if (w[j] < we[i]) {
						we[i] = w[j];
						d = j;
					}
				}
			}
			lb[d] = true;
		}
		list.add(we[1]);
		for (int i = 2; i < w.length; i++) {
			int temp = 0;
			for (int j = 0; j < list.size(); j++) {
				if (list.get(j) <= we[i]) {
					Collections.replaceAll(list, list.get(j), we[i]);
					temp = 1;
					break;
				}
			}
			if (temp == 0) {
				list.add(we[i]);
			}
		}
		System.out.println(list.size());
	}

}