In the morning, service engineers in a telecom company receive a list of jobs which they must serve today. They install telephones, internet, ipTVs, etc and repair troubles with established facilities. A client requires a deadline when the requested job must be completed. But the engineers may not complete some jobs within their deadlines because of job overload. For each job, we consider, as a penalty of the engineer, the difference between the deadline and the completion time. It measures how long the job proceeds after its deadline. The problem is to find a schedule minimizing the sum of the penalties of the jobs with the two largest penalties.

A service engineer gets a list of jobs J_i with a serving time s_i and a deadline d_i. A job J_i needs time s_i, and if it is completed at time C_i, then the penalty of J_i is defined to be max{0, C_i - d_i}. For convenience, we assume that the time t when a job can be served is 0t <  and s_i and d_i are given positive integers such that 0 < s_id_i. The goal is to find a schedule of jobs minimizing the sum of the penalties of the jobs with the two largest penalties.

For example, there are six jobs J_i with the pair (s_i, d_i) of the serving time s_i and the deadline d_i, i = 1,..., 6, where (s₁, d₁) = (1, 7), (s₂, d₂) = (4, 7), (s₃, d₃) = (2, 4), (s₄, d₄) = (2, 15), (s₅, d₅) = (3, 5), (s₆, d₆) = (3, 8). Then Figure 1 represents a schedule which minimizes the sum of the penalties of the jobs with the two largest penalties. The sum of the two largest penalties of an optimal schedule is that of the penalties of J₂ and J₆, namely 6 and 1, respectively, which is equal to 7 in this example.

Input 

Your program is to read from standard input. The input consists of T test cases. The number of test cases Tis given on the first line of the input. The first line of each test case contains an integer n ( 1n500), the number of the given jobs. In the next n lines of each test case, the i-th line contains two integer numbers s_i and d_i, representing the serving time and the deadline of the job J_i, respectively, where1s_id_i10, 000.

Output 

Your program is to write to standard output. Print exactly one line for each test case. The line contains the sum of the penalties of the jobs with the two largest penalties.

The following shows sample input and ouput for three test cases.

Sample Input 

3
6
1 7
4 7
2 4
2 15
3 5
3 8
7
2 17
2 11
3 4
3 20
1 20
4 7
5 14
10
2 5
2 9
5 10
3 11
3 4
4 21
1 7
2 9
2 11
2 23

Sample Output 

7
0
14

题意：给定一些任务，有完成需要时间，和完成期限，不能同时做两个任务，任务超过期限会罚钱，罚钱数为超过时间，求一个做任务的顺序，使得最大和第二大罚钱数之和最小，输出这个最小值。

思路：贪心，按期限从小到大排序，这样的话去完成，最大的罚钱是最小的。但是这并不一定是答案，因为还有第二小的，这时就需要从第一个任务到最大罚钱任务，把每个任务都放到最大罚钱的任务后面计算一次，保留最小值。因为如果一个任务后移，那么第一大和第二大的任务的时间将同时减少，这样就会演变为最大罚钱增大，第二大罚钱减少，相加的话比较和之前的答案谁更小。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
using namespace std;

const int N = 505;
int t, n, pos, time, m1, m2;
struct Work {
	int s, d;
} w[N];

bool cmp(Work a, Work b) {
	return a.d < b.d;
}

void init() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
		scanf("%d%d", &w[i].s, &w[i].d);
}

int cal(int i) {
	time = m1 = m2 = 0;
	for (int j = 0; j <= pos; j++) {
		if (i == j) continue;
		time +=w[j].s;
		int f = max(time - w[j].d, 0);
		if (m1 < f) {
			m2 = m1;
			m1 = f;
		}
		else if (m2 < f)
			m2 = f;
	}
	time += w[i].s;
	int f = max(time - w[i].d, 0);
		if (m1 < f) {
			m2 = m1;
			m1 = f;
		}
		else if (m2 < f)
			m2 = f;
	return m1 + m2;
}

int solve() {
	int ans; time = pos = m1 = m2 = 0;
	sort(w, w + n, cmp);
	for (int i = 0; i < n; i++) {
		time += w[i].s;
		int f = max(time - w[i].d, 0);
		if (m1 < f) {
			m2 = m1;
			m1 = f;
			pos = i;
		}
		else if (m2 < f) {
			m2 = f;
			pos = i;
		}
	}
	ans = m1 + m2;
	for (int j = 0; j < pos; j++)
		ans = min(cal(j), ans);
	return ans;
}

int main() {
	scanf("%d", &t);
	while (t--) {
		init();
		printf("%d\n", solve());
	}
	return 0;
}

UVA 1467 - Installations（贪心）