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

思路

1. 最后扣分最少，即为：按时上交的作业都得到分值，最后得分最多，需要用到贪心。要考虑得分最高，我们需要优先考虑分值较高的作业，需要将所有作业按分值从大到小排序得到新序列。但又不能直接用分值作为安排任务的指标，因为存在ddl这一属性，所以我们需要考虑尽量在完成ddl的情况下得到最多的分数。
2. 刚才排好的序列从头开始，由每个任务对应的ddl所在日期开始从后往前找空余的天，因为一个任务只需要一天完成，则一旦遇到空余的天就把该任务安排在那。这样对其他任务完成的影响最小。
3. 具体做法：作业用结构体task存储，有ddl（截止日期）和分值value。用vector容器存储所有的作业。排序也直接用sort，排序方法cmp需要自定义按分值value从大到小排。设置一个flag布尔数组表示每个日期的空闲状态，在安排任务时直接对其进行判断则可知当天是否可以继续安排任务。在安排任务时，若能将该任务按时完成（即：在其ddl或以前的日期有空闲位置），则将该任务的value值加入扣分值中。
4. 另一种做法：从后往前枚举每一天，给每一天安排任务，在第x天时将所有ddl为x的任务加入最大堆中，再从最大堆中选取一个value最大的任务安排在此天。复杂度从O(n^2)变为O(nlogn)。

代码

#include <iostream>
#include <vector>
#include <algorithm> 
using namespace std;
int T,N;//测试用例的个数，每个例子中的任务个数 
int a,b,i,j,pos,del;

struct task{
	int ddl;
	int value;
	task()
	{
		ddl=0;
		value=0;
	}
};

bool cmp(task &x,task &y)
{
	return x.value>y.value;
}

vector<task> vt;

int main()
{
	T=0;
	N=0;
	scanf("%d",&T);//输入测试用例的个数 
	for(i=0;i<T;i++)
	{
		del=0;
		bool flag[1001]={false}; //初始所有日期都无任务安排 
		scanf("%d",&N);
		for(j=0;j<N;j++)
		{
			scanf("%d",&a);
			task x;
			x.ddl=a;
			vt.push_back(x);  
		}
		for(j=0;j<N;j++)
		{
			scanf("%d",&b);
			vt[j].value=b;
		}
		
		sort(vt.begin(), vt.end(),cmp);
		for(j=0;j<N;j++)
		{
			for(pos=vt[j].ddl ; pos>0 ; pos--)
			{
				if(!flag[pos])//如果有日期空闲 
				{
					flag[pos]=true;
					break;
				}
			
			}
			if(pos==0)
			{
				del+=vt[j].value;//如果该任务无法被安排，则被算扣分
			}
		
		}
		vt.clear();
		cout<<del<<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

样例解释

(-45, -27, 42, 30), 
(26, 30, -10, -46),
(-32, 22, 56, -46),
(-32, 30, -75, 77),
(-32, -54, 56, 30).

思路

1. 这道题如果直接暴力求解，枚举ABCD中的每个数，四重循环做加法，复杂度为O(n^4)，无法接受。
2. 可以减少枚举的次数，可以将四个数分成两部分考虑，枚举A和B，得到A+B(A中一个数加上B中的一个数)的所有可能的和，再枚举C+D，得到C+D的所有可能和。这样将枚举复杂度降到O(n^2)。再判定A+B与C+D的相反数是否相等，可以得到所有使A+B+C+D=0的解的个数。
3. 在判断A+B是否等于C+D的相反数时，可以将A+B作为基准，A+B的所有可能的数先排序，然后从C+D中依次取数，在A+B中寻找最后一个出现-(C+D)的位置和第一个出现-(C+D)的位置。也就是求一个数在有序数列中出现的最后一个位置-第一个位置+1。考虑二分，将寻找位置的复杂度从O(n)降低到O(logn)。

代码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int n,i,j,a,b,c,d,tmp,sum;
vector<int> va,vb,vc,vd,vab,vcd;


int findBegin(int x,vector<int> &vx,int num)
{//找到有序数列vx中x的第一个位置
 	int l=0,r=num-1,ans=-1;
 	while(l<=r)
 	{
 		int mid=(l+r) >>1;
 		if(vx[mid]==x)
 		{
 			ans=mid;
 			r=mid-1;
		}
		else if(vx[mid]>x)
				r=mid-1;
			 else
			 	l=mid+1;
		 
	}
	return ans;
} 
int findEnd(int x,vector<int> &vx,int num) 
{//找到有序数列vx中x的最后一个位置
	int l=0,r=num-1,ans=-2;
 	while(l<=r)
 	{
 		int mid=(l+r) >>1;
 		if(vx[mid]==x)
 		{
 			ans=mid;
 			l=mid+1;
		}
		else if(vx[mid]>x)
				r=mid-1;
			 else
			 	l=mid+1;
		 
	}
	return ans;

}
int main()
{
	sum=0;
	scanf("%d",&n);//数列中的数字个数
	for(i=0;i<n;i++)
	{
		scanf("%d %d %d %d",&a,&b,&c,&d);
		va.push_back(a); 
		vb.push_back(b); 
		vc.push_back(c); 
		vd.push_back(d); 
	} 
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			tmp=va[i]+vb[j];
			vab.push_back(tmp); 
		}
	}

	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			tmp=vc[i]+vd[j];
			vcd.push_back(tmp); 
		}
	}
	
	sort(vab.begin(),vab.end());
	j=vab.size();
	for(vector<int >::iterator it = vcd.begin() ; it!=vcd.end() ; ++it)
	{
		tmp=findEnd(-*it,vab,j)-findBegin(-*it,vab,j)+1;//a+b中有多少个c+d的相反数 
		if(tmp!=0)
			sum=sum+tmp;//若a+b中存在c+d的相反数，计入最终方案数 
	
	}
	printf("%d",sum);
	
	
	return 0;
}

C——TT的神秘礼物（二分）

问题描述

有一天，TT 的好友 ZJM 决定交给 TT 一个难题，如果 TT 能够解决这个难题，ZJM 就会买一只可爱猫咪送给 TT。

任务内容是，给定一个 N 个数的数组 cat[i]，并用这个数组生成一个新数组 ans[i]。新数组定义为对于任意的 i, j 且 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

思路

1. 可以先想到最简单的做法，暴力处理，枚举i、j，将ans数组中的所有值算出来，再从中寻中位数。但复杂度为O(n^2)，对于 10 ^5个数来说不可接受。
2. 在一个有序数列中，一个数p是否为中位数，可以根据其名次是否等于中位数的名次来判定，p的名次小于中位数的名次则其小于中位数，等于则等于，大于则大于，名次具有单调性。根据所学，具有单调性的问题一般可二分。所以这道问题考虑二分。
3. 将cat数组从小到大排序，j>i，则新数组中的中位数数值的范围在0~（cat[N]-cat[1] ）(cat数组下标从1开始计)，中位数在新数组中的名次midpos直接可以得到为：((N*(N-1)/2)+1)/2，即：(新数组的个数+1)/2。满足cat[j]-cat[i]<=p的所有 i、j 数对个数即为p在新数组中的名次。即是说，枚举i，所有满足cat[j]<=cat[i]+p的 j 的个数。
4. 我们通过循环二分，初始二分的左、右边界为i+1、N，比较的是cat[j] 与 cat[i]+p的数值，根据判断变化的是下标号（即：位置），得到每个cat[i]对应在cat数组中的最后一个满足上述不等式的j的位置，用该位置减去i，为当前i对应的j的个数，循环所有i得到的j个数之和，即为我们求得一个数p的名次。将其跟midpos进行比较，就可以知道p在新数组中与中位数的相对位置。也是通过二分得到答案，开始二分的范围就是中位数数值的范围[0，cat[N]-cat[1] ]，这次比较的是名次，需要根据判断而变化的是最终数值。

总结

这道题一开始很难想到怎么二分，需要把一个问题分为两个部分考虑，名次和数值的对应不好想到。也很容易在二分时弄错需要比较的量以及范围。
相当于两层二分，可以用两个二分函数嵌套完成，过程更清晰一些。

代码

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

int cat[100010],N,midpos,result;


int find(int l1,int r1)
{
	int x,ans,jnum,jpos,mid1,mid2,l2,r2;
	while(l1<=r1)
	{
		mid1=(l1+r1)>>1;
		jnum=0;//满足cat[j]<=cat[i]+p的j个数 
		for(int i=1;i<=N;i++)
		{//枚举i，找到所有满足不等式的j
		//将所有满足条件j的个数加在一起就是它的名次 
			x=cat[i]+mid1;
			jpos=-1;
			l2=i+1;//因为j必须大于i 
			r2=N;
			while(l2<=r2)
			{//找到最后一个满足条件的j 
				mid2=(l2+r2)>>1;
				if(cat[mid2]<=x)
				{
					jpos=mid2;
					l2=mid2+1;
				}
				else r2=mid2-1;
			}
			if(jpos!=-1)//存在满足cat[j]<=cat[i]+p的j 
				jnum=jnum+jpos-i;	
		}
		if(jnum>=midpos)
		{
			ans=mid1;
			r1=mid1-1;
		}
		else
			l1=mid1+1;
	}

	return ans;
}

int main()
{
	while(scanf("%d",&N)!=EOF)
	{
		for(int i=1;i<=N;i++)
			scanf("%d",&cat[i]);
		sort(cat+1,cat+1+N);//将cat数组排序 
		midpos=((N*(N-1)>>1)+1)>>1;//新数组中的中位数位置
		result=find(0,cat[N]-cat[1]);
		printf("%d\n",result);	
	}
	return 0;
}