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

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。
思路
先将作业按照ddl进行降序排序，为了使在一个时间段完成A作业对其他作业完成情况影响最小，选择从时间段倒叙安排作业。
拿第三组样例来说，其作业<ddl,deduct>情况如下：

w1<1,3>
w2<4,2>
w3<6,1>
w4<4,7>
w5<2,6>
w6<4,5>
w7<3,4>
按照ddl排序后：
w3,w2,w4,w6,w7,w5,w1

倒叙考虑作业安排情况：

	1	2	3	4	5	6	7
0	-	-	-	-	-	-	x
1	-	-	-	-	-	w3√	x
2	-	-	-	-	x	w3√	x
3	-	-	-	可供选择的有：w2,w4,w6 选择扣分最多的w4	x	w3√	x
4	-	-	可选择：w2,w6,w7 因此选择w6	w4√	x	w3√	x
5	-	可选择：w2,w7,w5,选择w5	w6√	w4√	x	w3√	x
6	可选择：w2,w7,w1,选择w7	w5√	w6√	w4√	x	w3√	x

选择完成后，还剩余w2，w1未被选择，总扣分为3+2=5
因此按照这个思路，倒叙找出在该时间点可以完成的作业，选择完成扣分最多的那个作业，依次进行，直至每个可以完成作业的时间点都被安排了作业。

代码

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

struct DDL
{
	int ddl;
	int deduct;

	DDL()
	{
		ddl = 0;
		deduct = 0;
	}

	DDL& operator=(const DDL& rv)
	{
		ddl = rv.ddl;
		deduct = rv.deduct;
		return *this;
	}
};

bool cmp1(DDL& a, DDL& b)
{
	return a.ddl > b.ddl;
}

bool cmp2(DDL& a, DDL& b)
{
	return a.deduct < b.deduct;
}

int N;
DDL* a;


void work()
{
	DDL *temp = new DDL[N];
	int j = 0;
	int k = 0;
	for (int i = N; i > 0; i--)
	{
		for (; k < N; k++)
		{
			if (a[k].ddl >= i)//选出在该天可以完成的作业的情况
			{
				temp[j] = a[k];
				j++;
			}
			else
			{
				break;
			}
		}

		if (j > 0)//temp中有数据
		{
			sort(temp, temp + j, cmp2);//按照扣分进行升序排序
			/*for (int t = 0; t < j; t++)
			{
				cout << "<" << temp[t].ddl << ", " << temp[t].deduct << ">" << endl;
			}
			cout << endl;*/
			j--;//选出扣分最多的
		}
		
	}

	int sum = 0;
	for (int i = 0; i < j; i++)
	{
		sum += temp[i].deduct;
	}
	cout << sum << endl;

}


int main()
{
	int T;
	cin >> T;
	for (int i = 0; i < T; i++)
	{
		cin >> N;
		a = new DDL[N];
		for (int j = 0; j < N; j++)
		{
			cin >> a[j].ddl;
		}
		for (int j = 0; j < N; j++)
		{
			cin >> a[j].deduct;
		}
		sort(a, a + N, cmp1);//按照ddl降序排序
		work();
	}
}

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).
思路
将A和B两个数列进行枚举，得到的两个数的和放入一维数组sum中，对该数组进行升序排序，在对C和D两个数列进行枚举，每得到一个两个数的和，就去sum数组中计算该和的相反数出现的次数。
采用二分的方法进行查找，先找到该相反数在数组中第一次出现的位置，再找到该相反数在数组中最后一次出现的位置，两个位置进行相减运算，即可得到该相反数在数组中出现的次数。

我在刚开始的时候采用的时map来寻找计算相反数出现的次数，但此过程过于浪费时间，因此选择了二分。值得注意的是进行二分查找时，左右模拟指针的移动位置十分重要，我中间几次失误均是因为移动左右模拟指针时出现错误，以致寻找位置出错。

代码

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

/*B-四个数列*/

int n;
int* A, * B, * C, * D;

bool cmp(const int& a,const int& b)
{
	return a < b;
}





//找到>=x的第一个位置
int findOne(int& x,int *sum)
{
	int left = 0, right = n * n;
	while (left < right)
	{
		int mid = (left + right) >> 1;
		if (sum[mid] >= x)
		{
			right = mid;
		}
		else
		{
			left = mid + 1;
		}
	}
    
	if (sum[left] != x)
	{
		return -1;
	}
	else
	{
		return left;
	}
}

//找到x的最后一个位置
int findEnd(int& x, int* sum)
{
	int left = 0, right = n * n;
	while (left < right)
	{
		int mid = (right + left) >> 1;
		if (sum[mid] > x)
		{
			right = mid;
		}
		else
		{
			left = mid + 1;
		}
	}
	return left;
}






void work()
{
	int* sum = new int[n * n];
	int k = 0;
	int count = 0;

	//枚举A和B
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			int temp = A[i] + B[j];
			sum[k] = temp;
			k++;
		}
	}
	sort(sum, sum + k, cmp);


	//枚举C和D
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			int temp = 0 - (C[i] + D[j]);
			int flag1 = findOne(temp, sum);
			if (flag1 == -1)
			{
				continue;
			}
			else
			{
				int flag2 = findEnd(temp, sum);
				count = count + (flag2 - flag1);
			}
		}
	}

	cout << count << endl;

}

int main()
{
	cin >> n;
	A = new int[n];
	B = new int[n];
	C = new int[n];
	D = new int[n];
	for (int i = 0; i < n; i++)
	{
		cin >> A[i] >> B[i] >> C[i] >> D[i];
	}
	work();
}

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

思路
将给定的数列cat进行升序排序，此时可以去除绝对值，对于abs(cat[i]-cat[j])的最大值就是cat[n-1]-cat[0],而最小值就是0。

由于知道了cat数列中元素的个数，因此也就能够知道新数组ans的元素个数，进而可以得到新数组中元素的中位数所在的位置midAddress。

用二分的方式枚举P，来计算cat[j]<=cat[i]+P满足条件的cat[j]的个数。
对于P，如果P从小到大排的名次比中位数小，P比中位数小；同理，如果P从小到大排的名次比中位数大，P比中位数大；只有当如果P从小到大排的名次与中位数相同时，P就是中位数。

计算cat[j]的个数时也可以采用二分的方式，可以大大减少时间。

代码

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


int N;
int cat[110000];
int P;

int find_count(int x)
{//搜索小于x的值的个数
	int left = 0, right = N - 1, ans = N;
	while (left <= right)
	{
		int mid = (left + right) >> 1;

		if (cat[mid] >= x)
		{
			ans = mid;
			right = mid - 1;
		}
		else
		{
			left = mid + 1;
		}
	}

	return (N - ans);
}



void median()
{
	int left = 0, right = cat[N - 1] - cat[0];
	int midAddress = (N * (N - 1) / 2 - 1) / 2;

	while (left < right)
	{
		P = (left + right) >> 1;

		int countJ = 0;

		for (int i = 0; i < N; i++)
		{
			countJ += find_count(cat[i] + P);

		}

		if (countJ >= (N * (N - 1) / 2 - midAddress))
		{
			left = P + 1;
		}
		else
		{
			right = P;
		}

	}
	cout << left-1 << endl;

}

int main()
{
	while (scanf("%d", &N) != EOF)
	{
		for (int i = 0; i < N; i++)
		{
			scanf("%d", &cat[i]);
		}

		sort(cat, cat + N);
		median();
	}
}