「程序设计思维与实践」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。

题解

• easy 版
  • 使用贪心策略：1.尽量选价值高的任务；2.安排任务时尽量安排的靠后。于是对于n^2的做法，我们先按照大小顺序给任务排序，然后从大到小依次取出任务，对于该任务可以安排的时间，从ddl开始往前遍历，如果可以安排，那就放在这个地方，保证合法的情况下最晚。
• hard 版
  • 贪心策略：不再根据任务找时间，而是根据时间找合适的最有价值的任务。对于nlogn的做法，我们从最后一个时间开始一次往前遍历，对于遍历到时间t，将所有满足ddl=t的任务按照价值排序加到优先队列中，维护一个最大值，这样每次取出价值最大的放到当前时间t，直到最后时间遍历完成。

代码 easy版

#include 
#include 
#include 
#include 
using namespace std;

const int MAXN = 1010;
struct DDL {
	int d;
	int a;
}ddls[MAXN];

bool myday[MAXN];

bool cmp(const DDL x, const DDL y) {
	if(x.a != y.a) return x.a < y.a;
	return x.d < y.d;
}

int main() {
	int T;
	cin >> T;
	while (T --) {
		int N;
		cin >> N;
		for(int i = 0; i <= N; ++i) ddls[i].a = ddls[i].d = 0;
		memset(myday, 0, sizeof(myday));
		for (int i = 1; i <= N; ++i) {
			scanf("%d", &ddls[i].d);
		}
		for (int i = 1; i <= N; ++i) {
			scanf("%d", &ddls[i].a);
			ddls[0].a += ddls[i].a;
		}
		sort(ddls+1,ddls+N+1,cmp);
		int sum = 0;
		for (int i = N; i >= 1; i--) {
			for (int j = ddls[i].d; j >= 1; j--) {
				if (!myday[j]) {
					myday[j] = true;
					sum += ddls[i].a;
					break;
				}
			}
		}
		cout << ddls[0].a-sum << endl;

	}
	return 0;
}

代码 hard版

#include 
#include 
#include 
#include 
#include 
using namespace std;

const int MAXN = 1010;
struct DDL {
	int d;
	int a;
}ddls[MAXN];

bool cmp(const DDL x, const DDL y) {
	return x.d > y.d;
}

priority_queue<int> q;

int main() {
	int T;
	cin >> T;
	while (T --) {
		int N;
		cin >> N;
		for(int i = 0; i <= N; ++i) ddls[i].a = ddls[i].d = 0;
		while(q.size()) q.pop();
		for (int i = 1; i <= N; ++i) {
			scanf("%d", &ddls[i].d);
			ddls[0].d = max(ddls[0].d,ddls[i].d);
		}
		for (int i = 1; i <= N; ++i) {
			scanf("%d", &ddls[i].a);
			ddls[0].a += ddls[i].a;
		}
		sort(ddls+1,ddls+N+1,cmp);
		int sum = 0, nowid = 1;
		for(int t = ddls[0].d; t >= 1; t--) {
			while (ddls[nowid].d == t && nowid <= N) {
				q.push(ddls[nowid].a);
				nowid++;
			}
			if (q.size()) {
				sum += q.top();
				q.pop();
			}
		}
		cout << ddls[0].a-sum << 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

题解

• 对于 a[i]+b[i]+c[i]+d[i] = 0，变换形式得到a[i]+b[i] = -(c[i]+d[i])，即其中两组数的和等于另外两组数的相反数，我们可以分别预处理出ab和cd的和，然后给ab组排序，这样在对于每一个cd[j]，我们都能在ab组中二分的查找符合条件的值的个数。时间复杂度为n^2logn.
• 在二分查找时，先找到符合条件的最左端和最右端，然后r-l+1便是个数。

代码

#include 
#include 
#include 
#include 
#include 
using namespace std;

const int MAXN = 4000+10;
int tot = 0;
int a[MAXN], b[MAXN], c[MAXN], d[MAXN];
int ab[MAXN*MAXN];
int cd[MAXN*MAXN];

int find_l(int x) {
	x = -x;
	int l = 1, r = tot; 
	int mid = (l+r)>>1;
	int res = -1;
	while (l <= r) {
		mid = (l+r)>>1;
		if (x == ab[mid]) {
			res = mid;
			r = mid-1;
		} else if (x < ab[mid]) {
			r = mid-1;
		} else if (x > ab[mid]) {
			l = mid+1;
		}
	}
	return res;
}

int find_r(int x) {
	x = -x;
	int l = 1, r = tot; 
	int mid = (l+r)>>1;
	int res = -1;
	while (l <= r) {
		mid = (l+r)>>1;
		if (x == ab[mid]) {
			res = mid;
			l = mid+1;
		} else if (x < ab[mid]) {
			r = mid-1;
		} else if (x > ab[mid]) {
			l = mid+1;
		}
	}
	return res;
}

int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d%d%d",&a[i],&b[i],&c[i],&d[i]);
	}
	for(int i = 1; i <= n; ++i) {
		for(int j = 1; j <= n; ++j) {
			ab[++tot] = a[i]+b[j];
			cd[tot] = c[i]+d[j];
		}
	}
	int ans = 0;
	sort(ab+1,ab+tot+1);
	for(int i = 1; i <= tot; ++i) {
		// cout << ab[i] << "      " << cd[i] << endl;
		int l = find_l(cd[i]);
		int r = find_r(cd[i]);
		// cout << l << " and " << r << endl;
		if(l == -1 || r == -1) continue;
		ans += r-l+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

题解

• 思路：先考虑暴力求解的复杂度，互相求差的绝对值，时间复杂度是 O(n)，会超时不可取。令两两相减生成的数组叫ans。我们观察中位数的特性，发现只要我们将原数组从小到大排序，然后按照顺序加减，我们就能得到对于某个数x来说ans数组里小于x的有多少个元素，而又因为ans数组有序，所以可以二分解决，复杂度可以为O(log(1e6)*n*logn)。
• 实现细节：先二分答案，下届为0，上届为1e6，因为最大的数才1e5肯定够用。然后对于每一个mid进行check：计算这个在ans数组里，找出严格小于 mid的的数字个数有k个，令m为我们ans数组中的中位数个数，如果k < m，即严格小于 mid 的的数字小于中位数应有的位数，表示mid刚好在中位数位置或者在中位数位置之前，偏小，那么返回1，在外层二分中令 左区间等于mid+1，朝右扩展。反之，朝左扩展。
• 二分边界问题：写的时候发现这个地方是自己知识的一个漏洞，之前写的时候非常麻烦的判断边界问题，这次参照了市面上的所有二分写法，最终选择如 https://www.zhihu.com/question/36132386 所示的二分问题写法：即l,r分别用来逼近答案和缩小区间。在这个题中，如果不满足条件，那么就l=mid+1缩小区间，满足的话r=mid来逼近。最终符合条件的是mid 或 r。特别注意的一点：这时计算mid的时候要l + (r-l+1)/2否则会因为mid一直==l，而又check==1所以死循环。
• 类似的二分还可以有另外一种写法：用l逼近区间，r来缩小区间，但是这时候注意是左闭右开的，就是那mid正常写就可了。然后结果l-1的原因：观察最后小区间的状态可以得知：当我们检查到mid，mid是中位数时，因为mid前面的严格小于的元素个数是小于mid所在的位置的，所以会执行l = mid+1，这一句话，所以最终的状态是 l-1 为最后我们检查合法的元素。
• 参考
  • https://www.zhihu.com/question/36132386
  • https://blog.csdn.net/OCEANtroye/article/details/82811432
  • https://blog.csdn.net/yefengzhichen/article/details/52372407?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

代码1

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

const int MAXN = 1e5+10;
int n, nums;
int cat[MAXN];
// 0 1 2 3 4 5 6 7 8 9
// 2 3 6 7 9 9 9 9 9 9
// // // / / / / // / /
// 1 2 3 4 5 6 7 8 9 10
// 2 3 6 7 9 9 9 9 9 9

bool check(int x) {
	// 目的：找到在cat数组里，两数之差小于x的个数，即找满足 a[j]-a[i] < x 的个数，个数多说明x过大，个数少说明x小
	// 也就是对于每一个i来说，要找到刚好满足条件的位置，j~n全是可以的。 a[j] < a[i]+x;
	// cout << " - - - - - - - - - x = " << x << endl;
	int sum = 0;
	for (int i = 0; i < n; ++i) {
		// cout << "t = " << cat[i]+x << endl;
		// cout << "juedui:" << lower_bound(cat+i+1, cat+n, cat[i]+x)-(cat) << ",posi = " << lower_bound(cat+i+1, cat+n, cat[i]+x)-(cat+i+1) << endl;
		int posi = lower_bound(cat+i+1, cat+n, cat[i]+x)-(cat+i+1); //在他前面的数的个数
		sum += posi;
		// cout << posi << ",";
	}
	// cout << endl;
	// cout << "sum = " << sum << endl; 
	return sum < nums;
}

int main() {
	while (cin >> n) {
	 	nums = n*(n-1)/2;
	 	nums = (nums+1)/2; // 中位数的位置
	 	// cout << "mid:" << nums << endl;
		memset(cat, 0, sizeof(cat));
		for (int i = 0; i < n; ++i) {
			scanf("%d", &cat[i]);
		}
		sort(cat,cat+n);	
		int l = 0, r = 1e6;
		int mid = l+r >> 1;
		int ans = 0;
		while (l < r) {
			mid = l + (r-l+1)/2;
			// cout << l << ", " << mid << ", " << r << endl;
			// cout << "now mid = " << mid << endl;
			// 严格小于的个数小于真正中位数的位置
			if (check(mid)) { // 如果这个数前面数字达不到中位数个数的情况// 前面如果有小于等于 nums 个数。这个数一定不行
				l = mid;
			} else {// 这个数字可能彳亍
				r = mid-1;
			}
		}
		// l-1的原因：观察最后小区间的状态可以得知：当我们检查到mid，mid是中位数时，因为mid前面的严格小于的元素个数是小于mid所在的位置的，
		// 所以会执行 l = mid+1，这一句话，所以最终的状态是 l-1 为最后我们检查合法的元素。
		printf("%d\n",l);
	} 

	return 0;
}

代码2

		while (l < r) {
			mid = l + (r-l)/2;
			// cout << l << ", " << r << "mid = " << mid << endl;
			// cout << "now mid = " << mid << endl;
			if (check(mid)) { // 如果这个数前面数字达不到中位数个数的情况// 前面如果有小于等于 nums 个数。这个数一定不行
				l = mid+1;
			} else {// 这个数字可能彳亍
				r = mid;
			}
		}
		printf("%d\n",l-1);