HDU-1789-Doing Homework again



Doing Homework again

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 6716    Accepted Submission(s): 4011

Problem Description

Ignatius has just come back school from the 30th ACM/ICPC. Now he has a lot of homework to do. Every teacher gives him a deadline of handing in the homework. If Ignatius hands in the homework after the deadline, the teacher will reduce his score of the final test. And now we assume that doing everyone homework always takes one day. So Ignatius wants you to help him to arrange the order of doing homework to minimize the reduced score.

 

Input

The input contains several test cases. The first line of the input is a single integer T that is the number of test cases. T test cases follow.
Each test case start with a positive integer N(1<=N<=1000) which indicate the number of homework.. Then 2 lines follow. The first line contains N integers that indicate the deadlines of the subjects, and the next line contains N integers that indicate the reduced scores.

 

Output

For each test case, you should output the smallest total reduced score, one line per test case.

 

Sample Input

  
  

   
   3
3
3 3 3
10 5 1
3
1 3 1
6 2 3
7
1 4 6 4 2 4 3
3 2 1 7 6 5 4
  
  

 

Sample Output

  
  

   
   0
3
5
  
  

 

Author

lcy

 

Source

2007省赛集训队练习赛（10）_以此感谢DOOMIII

排序、DP动态规划。按损失时间从大到小排序，从最大开始安排计划，再向前尽量安插次小的任务，最后可以最大化减少损失。

怎么证明这样是最优的方法暂时没想清楚，纯粹是因为见到别人这么做了，很像是贪心的思路，但是还不知道贪心准则是怎么确立的。

建议再去看看经典01背包问题。

代码注释绝对详细啊！！！

#include <iostream>
#include <algorithm>

using namespace std;

struct st
{
	int t;      //最后期限
	int p;      //减少分数
};

bool cmp(st a, st b)       //传参指针类型，sort中前两项p的类型
{
	if (a.p > b.p)
	{
		return true;       //按照减少分数的降序排列
	}
	if (a.p == b.p)        //对于减少的分数相同的项
	{
		if (a.t < b.t)
		{
			return true;   //按照最后期限的升序排列
		}
	}
	return false;          //配合上面的return，其实感觉函数可以用return的值进行简化
}

int main()
{
	int T;
	bool f[1024]; //用来标记是否该天已被占用
	st p[1024];

	cin >> T;     //测试组数，服从题上面给的符号

	while(T--)    //排序、DP — — 经典01背包似的思路
	{
		int n;

		cin >> n;

		for(int i = 0; i < n; i++)   //第一轮输入，最后期限
		{
			cin >> p[i].t;
		}
		for(int i = 0;i < n;i++)     //第二轮输入，减少分数
		{
			cin >> p[i].p;
		}

		for (int i = 0; i < 1024; i++)
		{
			f[i] = false;            //清空记录为false，最多1000组
		}

		sort(p, p + n, cmp);         //排序，详见子函数

		int r = 0;                   //r为总减少分数，清为0

		for(int i = 0; i < n; i++)
		{
			int j;
			for(j = p[i].t; j > 0; j--) //第i项任务的最后期限赋给j
			{                           //期限大于0，否则还会对f(0)进行错误判断
				if (!f[j])              //这一天在最后期限之前且没被占用，标记为ture
				{
					f[j] = true;        //本任务是必须要完成的了，占用一天的时间
					break;              //跳出对本次任务判断
				}                       //之前某次任务将f(1)标记为了ture
				if (j == 1)             //在某一个必须要完成的任务的最后期限之前
				{                       //循环向前找时间，找不到未被占用时间来完成该次任务
					r = r + p[i].p;     //累加减少的总分数
				}
			}
        }
		cout << r << endl;              //占用一行输出
	}
	return 0;
}