程序设计思维与实践 Week4 作业3道

本周作业3道，是贪心(第一题)+二分(第二、三题)的应用。

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.将 n 个 deadline 根据分数从大到小排序，依次遍历
  2.对于第 𝑖 个 deadline，根据 ti从后往前遍历，一旦找到空闲时段则安排为第 𝑖 个 deadline
  3.时间复杂度为 O (n^2)
• 解法（hard版）
  1.从后往前枚举每一天，给每一天安排任务
  2.枚举到第 x 天时，将所有 ti = 𝑥 的 deadline 加入最大堆中
  3.再从最大堆中选取一个价值最大的 deadline 安排在第 x 天
  4.复杂度为O (𝑛𝑙𝑜𝑔𝑛 )，利用数据结构进行优化

该题1<=N<=1000，可以接受O（n^2）的复杂度，可以用easy版的解法。

附：

之前便用到了memset，这次便查阅了详细的相关知识。之前用到的memset（dis，63， sizeof dis）是将所有的单元初始化为无穷大。

memset 函数是内存赋值函数，用来给某一块内存空间进行赋值的；包含在<string.h>头文件中,可以用它对一片内存空间逐字节进行初始化；原型为 ：
void *memset(void *s, int v, size_t n);
这里s可以是数组名，也可以是指向某一内在空间的指针；
v为要填充的值；
n为要填充的字节数；

参考：memset详解

C++

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

bool compare(const pair<int, int> &a, const pair<int, int> &b) {
	return a.second > b.second; //将 n 个 deadline 根据分数从大到小排序
}
pair<int, int> a[1010];
bool b[1010];
int main() {
	int t, n, max, ddl;
	bool flag;
	cin >> t;
	for (int i = 0; i < t; i++) {
		int sum = 0;
		cin >> n;
		for (int j = 0; j < n; j++) {
			cin >> a[j].first;
		}
		for (int k = 0; k < n; k++) {
			cin >> a[k].second;
		}
		sort(a, a + n, compare);
		memset(b,true,sizeof(b));//初始化，直接bool b[1010] = { true };也可
		for (int m = 0; m < n; m++) {
			ddl = a[m].first;
			flag = false;
			for (int x = ddl; x > 0; x--) {
				if (b[x])
				{
					b[x] = false;
					flag = true;//标记找到了位置
					break;//往前遍历找到位置后退出
				}
			}
			if (!flag)//如果往前没有找到空位，算作耽误时间的一部分
				sum += a[m].second;
		}
		cout << sum << endl;
	}
	system("pause");
	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).

分析

用map的find直接找到相反数，返回对应的value值相加，代码如下，但是超时了。（其中map中find函数复杂度为logn…如这个所说C++ STL中常见容器的时间复杂度）

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

int a[5000], b[5000], c[5000], d[5000];
map<int, int> result;
int main() {
	int n, sum, count = 0, sum1;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> a[i] >> b[i] >> c[i] >> d[i];
	}
	for (int j = 0; j < n; j++) {
		for (int k = 0; k < n; k++) {
			sum = a[j] + b[k];
			map<int, int>::iterator it;//迭代器
			it = result.find(sum);
			if (it != result.end())//找到了
				it->second++;
			else
				result.insert(pair<int, int>(sum, 1));
		}
	}
	for (int j = 0; j < n; j++) {
		for (int k = 0; k < n; k++) {
			sum1 = c[j] + d[k];
			map<int, int>::iterator it;
			it = result.find(-sum1);//找相反数
			if (it != result.end())
				count+=it->second;
		}
	}
	cout << count << endl;
	return 0;
}

总之，出题目的就是用课上所学的整数二分法来解决此问题。

整数二分

• 分治算法的基本思想是将一个规模为N的大问题分解为K个规模较小的问题（一般来说是2个），这些子问题相互独立并且与原问题的性质相同，求解的过程一致。然后分治算法就是合并子问题的解求得原问题的解。
• 二分法属于分治算法，普遍意义下的二分法为二分查找法。
• 在一个单调有序(递增或递减) 的区间[a1 ，an ] 中查找元素x，每次将区间分为左右长度相等的两部分，判断解在哪个区间中并调整区间上下界，不断重复直至找到相应的解。
• 时间复杂度 𝑂(𝑙𝑜𝑔𝑛)。
• 优于顺序查找 𝑂(𝑛)。
• 作用：

1. 查找元素（位置或值）
2. 求满足条件的最值（最大值/最小值）

本题如果用暴力枚举的话，为四重循环，时间复杂度𝑂(𝑛^2 )，在𝑛 ≤ 4000 会运行超时。

但是当𝑛 ≤ 4000时，𝑂(𝑛^2 )的时间复杂度可以接受，可以优化到AB,CD分别进行两重循环。枚举C和D的时候计算它的相反数在A和B中出现多少次！也就是计算一个数在有序数列中第一次和最后一次出现的位置！

C++

#include<iostream>
#include<algorithm>
using namespace std;
int sum[16000010], sum1[16000010];
int a[4010], b[4010], c[4010], d[4010];

int find1(int x,int index) {//返回第一次出现的下标
	int left = 0, right = index-1, ans = -1;
	while (left <= right) {
		int mid = (left + right) >> 1;
		if (sum[mid] >= x) {
			ans = mid;
			right = mid - 1;
		}
		else
			left = mid + 1;
	}
	if (sum[ans] != x)//未找到返回-1
		ans = -1;
	return ans;
}

int find2(int x, int index) {//返回最后一次出现的下标
	int left = 0, right = index - 1, ans = 0;
	while (left <= right) {
		int mid = (left + right) >> 1;
		if (sum[mid] == x) {
			ans = mid;
			left = mid + 1;
		}
		else if (sum[mid] > x)right = mid - 1;
		else
			left = mid + 1;
	}
	return ans;
}

int main() {
	int n, count = 0, index = 0;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> a[i] >> b[i] >> c[i] >> d[i];
	}
	for (int j = 0; j < n; j++) {
		for (int k = 0; k < n; k++) {
			sum[index] = a[j] + b[k];
			sum1[index] = c[j] + d[k];
			index++;
		}
	}
	sort(sum, sum + index);
	for (int i = 0; i < index; i++) {
		 int index1 = find1(-sum1[i],index);
		 if (index1 == -1) {}
		 else {
			 int index2 = find2(-sum1[i], index);
			 count += index2 - index1 + 1;//出现的次数
		 }
	}
	cout << count << 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

分析

暴力做法为枚举i，j将数列B计算出来，然后取它的中位数，时间复杂度和空间复杂度均为𝑂(𝑛^2)，无法接受。

换一个思路。
如果给定一个数P，如何判断它是不是中位数？
计算P在数列中的名次即可。
如果P从小到大排的名次比中位数小，说明什么？ P比中位数要小
如果P从小到大排的名次比中位数大，说明什么？ P比中位数要大
如果P从小到大排的名次等于中位数，说明什么？ P就是中位数
结论：满足单调性，可以二分P！

怎样计算P的名次？
如果将X从小到大排列可以去绝对值。
那么计算𝑋 j − 𝑋 i ≤ 𝑃的二元组对数即可。
移项可得𝑋 j ≤ 𝑋 i + 𝑃,𝑖 < 𝑗
枚举下标i然后计算满足条件的下标j的个数 也可以二分！


总之，方法为二分答案P，枚举+二分计算P的名次。
其复杂度为𝑂 (𝑙𝑜𝑔𝑋i) ∗ 𝑂(𝑛𝑙𝑜𝑔(𝑛)) = 𝑂(𝑛𝑙𝑜𝑔( 𝑛) 𝑙𝑜𝑔𝑋i).
二分答案还可以解决一类问题：最大值最小/最小值最大

在本题中，中位数即在新数列中位置最居中位置的数，其在新数列中应该在的位置为C（2，number）即 m = ((number - 1)*number / 2 + 1) / 2，即小于等于该中位数的数量应该为m，之后进行二分。新数组中每个数的取值范围为0~a[number - 1] - a[0]，（因为两个数的绝对值大于等于0，而排序后其差的最大值为a[number - 1] - a[0]），mid取其中二分的一个数，在for循环中进行a[i] - a[j] > mid的判断，得到i前<=mid的数量num，累加后的num为mid所在的位置，通过如果该位置恰好为m，则该mid值为中位数。

C

#include<cstdio>
#include<algorithm>
using namespace std;
int number, a[1000010];

int main()
{
	while (~scanf("%d",&number))
	{
		for (int i = 0; i < number; i++)
		{
			scanf("%d", &a[i]);
		}
		sort(a, a + number);//递增数列
		int l = 0, r = a[number - 1] - a[0], mid, num;//两两只差最小是1(因为i!=j)，最大是升序数组中的最大值减最小值
		int	m = ((number - 1)*number / 2 + 1) / 2;//m为新数列中应该在的中点位置，因为新数列总数为C(n,2)，其中+1是为了处理奇偶问题
		while (l < r)
		{//左右两个相等就跳出
			mid = (l + r) >> 1;
			int j = 0;//记录满足大于的数
			num = 0;//记录满足a[i] - a[j] <= mid的总数，即记录在mid左边的总数量
			for (int i = 1; i < number; i++)
			{
				while (a[i] - a[j] > mid)
					j++;//记录i前有多少对两两相减大于mid的
				num += i - j;//i前的总数减去大于的数，得到(<=mid的数量)值为mid的在新数列中的位置。从下标为0开始，i前面有i个数，j为大于mid的数量
			}
			if (num >= m)//位置与新数列的中点位置比较，大于则中点在左边，右端点移动
				r = mid;
			else 
				l = mid + 1;
		}
		printf("%d\n",l);
	}
}

这题特别绕，这里只用了一次二分，还可以用两次二分。这题一不小心思路就不清晰了，十分有难度，现在回想起步骤脑子还是嗡嗡疼！！！