【Week4 作业】A - DDL 的恐惧、B - 四个数列、C - TT 的神秘礼物

A - DDL 的恐惧

题意：

ZJM 有 n 个作业，每个作业都有自己的 DDL，如果 ZJM 没有在 DDL 前做完这个作业，那么老师会扣掉这个作业的全部平时分。
所以 ZJM 想知道如何安排做作业的顺序，才能尽可能少扣一点分。
请你帮帮他吧！

Input

输入包含T个测试用例。输入的第一行是单个整数T，为测试用例的数量。
每个测试用例以一个正整数N开头(1<=N<=1000)，表示作业的数量。
然后两行。第一行包含N个整数，表示DDL，下一行包含N个整数，表示扣的分。

Output

对于每个测试用例，您应该输出最小的总降低分数，每个测试用例一行。

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

Hint

上方有三组样例。
对于第一组样例，有三个作业它们的DDL均为第三天，ZJM每天做一个正好在DDL前全部做完，所以没有扣分，输出0。
对于第二组样例，有三个作业，它们的DDL分别为第一天，第三天、第一天。ZJM在第一天做了第一个作业，第二天做了第二个作业，共扣了3分，输出3。

思路做法：

贪心法，由于题目中完成每项作业的时间是相同的，都是一天，因此我们只需要考虑其价值也就是分数。
维护一个布尔数组b，从一堆DDL中挑选一个价值最大的作业，根据其DDL放入b中，若b[DDL]已经为true，说明有一个价值更大的且其DDL大于等于当前作业的DDL的作业被放了进来（当前作业不能取而代之），当前作业继续往前寻找（不能往后，可能会超DDL），若找到空位，就更新b，代表这一天有一个作业了；若找到头也没有空余的一天，说明这个作业在我们的贪心算法中不能被完成，就把他的扣分加到ans中，全部便历一遍，ans值即为答案。

总结:

算法看起来很简单，但算法复杂度并没有被优化的很好，面对超大数据需要额外的优化。

代码:

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

const int N = 1010;
bool b[N];
struct DDL{
	int d,p;  //日期 分数 
	bool operator<(const DDL& ddl){
		if(p!=ddl.p) return p>ddl.p;
		return d<ddl.d;
	}
}a[N];

int main(){
	int t; cin>>t;
	while(t--){
		int n, ans = 0; cin>>n;
		memset(b, 0, sizeof(b));
		for(int i = 0; i < n; ++i) cin>>a[i].d;
		for(int i = 0; i < n; ++i) cin>>a[i].p;
		sort(a, a+n);
		for(int i = 0; i < n; ++i){
			int day = a[i].d;
			bool done = 0;
			while(day > 0){  //0不算 
				if(!b[day]){  //放进这一天 
					b[day] = 1;
					done = 1;
					break;
				}
				day--;
			}
			if(!done) ans += a[i].p;  //没有完成 
		}
		cout<<ans<<endl;
	}
	return 0;
} 

B - 四个数列

题意：

ZJM 有四个数列 A,B,C,D，每个数列都有 n 个数字。ZJM 从每个数列中各取出一个数，他想知道有多少种方案使得 4 个数的和为 0。
当一个数列中有多个相同的数字的时候，把它们当做不同的数对待。
请你帮帮他吧！

Input

第一行：n（代表数列中数字的个数） （1≤n≤4000）
接下来的 n 行中，第 i 行有四个数字，分别表示数列 A,B,C,D 中的第 i 个数字（数字不超过 2 的 28 次方）

Output

输出不同组合的个数。

Sample Input

6
-45 22 42 -16
-41 -27 56 30
-36 53 -37 77
-36 30 -75 -46
26 -38 -10 62
-32 -54 -6 45

Sample Output

5

Hint

样例解释: (-45, -27, 42, 30), (26, 30, -10, -46), (-32, 22, 56, -46),(-32, 30, -75, 77), (-32, -54, 56, 30).

思路做法：

直接4层循环复杂度太高，将4层循环拆为两个2层循环。
由于当一个数列中有多个相同的数字的时候，把它们当做不同的数对待，可以将前2个数组组合成1个数组，后2个数组组合成1个数组，对于后1个数组中的每一个元素，在前1个数组中找其相反数的个数，全部相加即为答案。
为进一步降低复杂度，将寻找个数问题转化为寻找相反数在数组中第一次和最后一次出现的位置（前后位置作差），用find_index函数二分查找实现，若函数返回不为-1（-1代表数没找到），就将ans更新。全部便历一遍后，ans就是答案。

总结:

对于一个问题。可以先想方设法实现，再进一步寻找优化的方法。

代码:

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 4010;
int a[N], b[N], c[N], d[N];
int ab[N*N];

int find_index(int num, int len, bool last){
//找num在ab[0,len)数组中第一次或最后一次last出现的位置 
	int l = 0, r = len-1, ans = -1;  //找不到返回-1 
	while(l <= r){
		int mid = (l + r) >> 1;
		if(ab[mid] == num){
			ans = mid;
			if(!last) r = mid - 1;
			else l = mid + 1;
		}
		else if(ab[mid] < num) l = mid + 1;
		else r = mid - 1;
	}
	return ans;
}

int main(){
	int n, ans = 0; cin>>n;
	for(int i = 0; i < n; ++i)
		cin>>a[i]>>b[i]>>c[i]>>d[i];
		
	for(int i = 0; i < n; ++i)
		for(int j = 0; j < n; ++j)
			ab[i*n+j] = a[i] + b[j];
			
	sort(ab, ab+n*n);
	
	for(int i = 0; i < n; ++i){
		for(int j = 0; j < n; ++j){
			int last = find_index(-(c[i]+d[j]), n*n, 1);
			if(last != -1) ans += last-find_index(-(c[i]+d[j]), n*n, 0)+1;
		}
	}
	cout<<ans<<endl;
	return 0;
}

C - TT 的神秘礼物

题意：

TT 是一位重度爱猫人士，每日沉溺于 B 站上的猫咪频道。
有一天，TT 的好友 ZJM 决定交给 TT 一个难题，如果 TT 能够解决这个难题，ZJM 就会买一只可爱猫咪送给 TT。
任务内容是，给定一个 N 个数的数组 cat[i]，并用这个数组生成一个新数组 ans[i]。新数组定义为对于任意的 i, j 且 i != j，均有 ans[] = abs(cat[i] - cat[j])，1 <= i < j <= N。试求出这个新数组的中位数，中位数即为排序之后 (len+1)/2 位置对应的数字，’/’ 为下取整。
TT 非常想得到那只可爱的猫咪，你能帮帮他吗？

Input

多组输入，每次输入一个 N，表示有 N 个数，之后输入一个长度为 N 的序列 cat， cat[i] <= 1e9 , 3 <= n <= 1e5

Output

输出新数组 ans 的中位数

Sample Input

4
1 3 2 4
3
1 10 2

Sample Output

1
8

思路做法：

若是按照最容易想到的方法，将ans[]求出来，其中位数自然可求，但这样做的复杂度太高，采用中位数与名次的关系将其优化。
具体做法是，先求出ans[]中元素可能取值的界限，最小为0，最大为cat[]数组中差值最大的数（最大-最小），由于名次与中位数的关系，可以在这样的范围里二分求中位数。
为了求任一数P的名次，要计算| cat[j] - cat[i] | <= P的个数，将cat排序以去掉绝对值运算，这样P的上限也可通过cat[n-1] - cat[0]得出。接下来，计算P的名次便转化为对任意i (0 <= i < n-1)，求cat[j] <= P + cat[i] 的个数和。依然可以通过二分求这样的cat[j]第一次和最后一次出现的位置（cat已被排序，可以二分）来计算符合条件的cat[j]的个数。
最后，通过个数和（即P的名次）与中位数的名次比较更新P值。我们想要的P是其名次不小于中位数名次的第一次出现的那个P值，因为在它之前的P名次都低，而它和它后面的P的名次都大于等于中位数名次，第一个不小于中位数名次的P自然便是中位数。

总结:

思路很明确，二分也不难写，之所以过不了，是因为在编写代码过程中，忘记组合数怎么计算了，网上查到是m!/((m-n)!n!)，于是自己编写了一个，但是RE了。后来知道其实很简单，n(n-1)/2就可以算出来，于是得到结果但是超时，将cin改为scanf才AC

代码:

#include <stdio.h>
#include <algorithm>
using namespace std;
const int N = 100050;
int cat[N], n;

int find_index(int start, int P){
	int l = start+1, r = n-1, ans = -1;
	while(l <= r){
		int mid = (l + r) >> 1;
		if(cat[mid] <= cat[start]+P){
			ans = mid;
			l = mid + 1;
		}
		else r = mid - 1;
	}
	return ans;
} 

int G(int P){
	int ans = 0;
	for(int i = 0; i < n-1; ++i){
		int num = find_index(i, P);
		if(num != -1) ans += (num-i);
	}
	return ans;  //返回名次 
}

int main(){
	while(~scanf("%d", &n)){
		for(int i = 0; i < n; ++i) scanf("%d", &cat[i]);
		sort(cat, cat+n);
		int ans = -1, l = 0, r = cat[n-1]-cat[0], num = n*(n-1)/2;
		while(l <= r){
			int mid = (l + r) >> 1;
//			cout<<"l="<<l<<" r="<<r<<" mid="<<mid<<" G="<<G(mid)<<endl;
			if(G(mid)<(num+1)/2) l = mid + 1;
			else{
				ans = mid;
				r = mid - 1;
			}
		}
		printf("%d\n", ans);
	}
	return 0;
}