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

最新推荐文章于 2024-05-08 09:26:56 发布

风zx

最新推荐文章于 2024-05-08 09:26:56 发布

阅读量399

点赞数

本文链接：https://blog.csdn.net/weixin_44343319/article/details/104999109

版权

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。

思路

看到题目，很朴素的想法就是尽可能将分值高的作业先完成，当然这也就是贪心准则了，下面详细的分析一下。
设a_j , …… , a_i-2 , a_i-1 , a_i , 是DDL序列中的一部分，设b_m，b_n 是DDL 为 a_i 的作业(b_m > b_n )，根据贪心准则，b_m 在a_i 或其之前完成，设b_m在a_u完成， b_n 在a_v完成(如果b_n可能完成的话)(u>v).
如果b_n无法完成，则DDL为a_i的作业仅有b_m在a_u完成，b_m是分数最高的作业，此时当然贪心的就是最优的。
如果b_n可以完成，那么交换b_m b_n 当然不会对结果有影响，而且可以交换为最优的作业序列（如果有DDL为a_i的未完成的作业比当前DDL为a_i的完成的作业的分数高，那么这一定不是最优的作业序列，可以把这两个交换得到比当前序列更优的序列），因此尽可能将分值高的作业先完成作为贪心准则是正确的。
针对每个ddl结构体都重新定义比较方式（分数由小到大，分数相同的按DDL由小到大），再使用sort进行排序，

struct ddl{
	int time,score;
	ddl(){time=0;score=0;}
	ddl(int t,int s){
		time=t;
		score=s;
	}
	bool operator < (ddl& d){
		if(score!=d.score)
			return score>d.score;
		return time>d.time;
	}
	void show(){
		cout<<"time:"<<time<<"  "<<"score:"<<score<<endl;
	}
	void clear(){
		time=0;score=0;
	}
};

对于第 𝑖 个 DDL，根据 𝑡_𝑖 从后往前遍历，一旦找到空闲时段则安排为第 𝑖 个 DDL

	for(int i=0;i<n;i++){
		for(int j=str[i].time;j>0;j--){
			if(!flag[j]){
				tempscore+=str[i].score;
				flag[j]=true;
				break;
			}
		}
	}

这样得到了完成的作业的分数，用总的分数减去完成分数就是扣除的分数

代码

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

struct ddl{
	int time,score;
	ddl(){time=0;score=0;}
	ddl(int t,int s){
		time=t;
		score=s;
	}
	bool operator < (ddl& d){
		if(score!=d.score)
			return score>d.score;
		return time>d.time;
	}
	void show(){
		cout<<"time:"<<time<<"  "<<"score:"<<score<<endl;
	}
	void clear(){
		time=0;score=0;
	}
};

const int number=1005;
ddl str[number];
bool flag[number];

int main(){
	int t;
	cin>>t;
	for(int k=0;k<t;k++){
		int n;
		int total=0,temp=0,tempscore=0;
		cin>>n;
		memset(flag,false,number*sizeof(bool));
		for(int i=0;i<n;i++)
			str[i].clear();
		for(int i=0;i<n;i++)
			cin>>str[i].time;
		for(int i=0;i<n;i++){
			cin>>temp;
			total+=temp;
			str[i].score=temp;
		}
		sort(str,str+n);
		
		for(int i=0;i<n;i++){
			for(int j=str[i].time;j>0;j--){
				if(!flag[j]){
					tempscore+=str[i].score;
					flag[j]=true;
					break;
				}
			}
		}
//		cout<<"total score:"<<total<<endl;
//		cout<<"de de fen:"<<tempscore<<endl;
//		cout<<"kou de fen:"<<total-tempscore<<endl;
//		for(int i=0;i<n;i++)
//			str[i].show();
		cout<<total-tempscore<<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

hint

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

思路

最朴素的想法当然是四重循环，复杂度太高。
a+b+c+d=0,一方面可以分别枚举a,b,c,d，另一方面，稍作变换，a+b = -(c+d),那么首先枚举a,b，二重循环，

	int index=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			ab[index++]=a[i]+b[j];
		}
	}
	sort(ab,ab+n*n);

再枚举c,d，二重循环，再找a+b中有几个c+d的相反数，如果对a+b进行排序再二分查找,复杂度为O(n²log(n)),复杂度降低了

	int total=0,result=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			total=c[i]+d[j];
			int first=find_first(-total,ab,n*n);//找到第一个-total的索引 
			int last=find_last(-total,ab,n*n);//找到最后一个-total 的索引 
//			cout<<"total:"<<total<<"  first:"<<first<<"  last:"<<last<<endl;
			if(first==-1 && last==-1)continue;
			else{
				result+=last-first+1;
			}
		}
	}

其中find_first,find_last分别寻找一个数再一个数组中的第一个出现的位置和最后一次出现的位置，使用二分查找

代码

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

const int number=4005;
int a[number];
int b[number];
int c[number];
int d[number];
int ab[number*number];

int find_first(int x,int* arr,int len){
	int l=0,r=len-1,ans=-1;
	while(l<=r){
		int mid=(l+r)>>1;
		if(arr[mid] == x){
			ans=mid;
			r=mid-1;
		}
		else if(arr[mid] > x)
			r=mid-1;
		else 
			l=mid+1;
	}
	return ans;
}

int find_last(int x,int* arr,int len){
	int l=0,r=len-1,ans=-1;
	while(l<=r){
		int mid=(l+r)>>1;
		if(arr[mid] == x){
			ans=mid;
			l=mid+1;
		}
		else if(arr[mid] > x)
			r=mid-1;
		else 
			l=mid+1;
	}
	return ans;
}

int main(){
	int n;
	scanf("%d",&n);
	memset(a,0,number*sizeof(int));
	memset(b,0,number*sizeof(int));
	memset(b,0,number*sizeof(int));
	memset(d,0,number*sizeof(int));	
	memset(ab,0,2*number*sizeof(int));
	for(int i=0;i<n;i++){
		scanf("%d %d %d %d",a+i,b+i,c+i,d+i);
	}
	int index=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			ab[index++]=a[i]+b[j];
		}
	}
	sort(ab,ab+n*n);
//	for(int i=0;i<n*n;i++){
//		cout<<ab[i]<<ends;
//	}cout<<endl;
	int total=0,result=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			total=c[i]+d[j];
			int first=find_first(-total,ab,n*n);//找到第一个-total的索引 
			int last=find_last(-total,ab,n*n);//找到最后一个-total 的索引 
//			cout<<"total:"<<total<<"  first:"<<first<<"  last:"<<last<<endl;
			if(first==-1 && last==-1)continue;
			else{
				result+=last-first+1;
			}
		}
	}
	cout<<result;	
	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

sample output

1
8

思路：

求出abs数列的复杂度是O(n²)，根据给定的数据规模，超时
将cat数组升序排序后可以去掉ans数组中的绝对值，即ans[]=cat[j]-cat[i] (i<=i<j<=n)

这里用到了中位数的一个性质，给定一个数p,
如果p从小到大排序的名次比中位数小，则p比中位数小
如果p从小到大排序的名次比中位数大，则p比中位数大
如果p从小到大排序的名次的等于中位数，p就是中位数

问题转化为计算p在数组ans[]中的名次，
即计算cat[j] - cat[i] <= p 的(cat[j],cat[i])二元组对数
移项，cat[j] <= cat[i]+p
给定一个p,遍历cat数组，计算满足要求的cat[j]的总个数（二分查找），即二元组对数，即p的名次

int Rank(int p,int* arr,int len){
	int ans=0;	
	for(int i=0;i<n;i++){
		int temp=find_last(arr[i]+p,arr,len);//满足要求的cat[j]的个数（二分查找）
		if(temp!=-1) ans+=(temp-i);
	}
	return ans;	
}

此时的复杂度为O(nlog(n))
由于ans[]是有范围的，最小是0，最大是cat[n-1]-cat[0],ans[]数组一共有n(n-1)/2个数，因此可以在0 ~ cat[n-1]-cat[0] 内对p 进行二分，即二分答案

		int ans=-1,l=0,rcat[n-1]-cat[0];
		while(l<=r){
			int mid=(l+r)>>1;

			if(Rank(mid,cat,n) < (1+n*(n-1)/2)/2){
				l=mid+1;
			}
			else{
				ans=mid;
				r=mid-1;
			}
		}

代码：

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

const int number=100005;
int cat[number];
int n;

//找到<=x的最后一个位置 
int find_last(int x,int* arr,int len){
	int l=0,r=len-1,ans=-1;
	while(l<=r){
		int mid=(l+r)>>1;
		if(arr[mid] <= x){
			ans=mid;
			l=mid+1;
		}
		else
			r=mid-1;
	}
//	cout<<"ans:"<<ans<<endl;
	return ans;
}

int Rank(int p,int* arr,int len){
	int ans=0;	
	for(int i=0;i<n;i++){
		int temp=find_last(arr[i]+p,arr,len);
		if(temp!=-1) ans+=(temp-i);
	}
	return ans;	
}

int main(){
	
	while(scanf("%d",&n)!=EOF){
		memset(cat,0,number*sizeof(int));
		for(int i=0;i<n;i++){
			scanf("%d",cat+i);
		}
		
		sort(cat,cat+n);

		int max=cat[n-1]-cat[0];
		                                                                                                                                                                                                                                  
		//对max进行二分
		int ans=-1,l=0,r=max;
		while(l<=r){
			int mid=(l+r)>>1;

			if(Rank(mid,cat,n) < (1+n*(n-1)/2)/2){
				l=mid+1;
			}
			else{
				ans=mid;
				r=mid-1;
			}
		}
		printf("%d\n",ans);
		 
	}
}

风zx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
程序设计思维与实践 week4 作业

A-DDL的恐惧ZJM 有 n 个作业，每个作业都有自己的 DDL，如果 ZJM 没有在 DDL 前做完这个作业，那么老师会扣掉这个作业的全部平时分。所以 ZJM 想知道如何安排做作业的顺序，才能尽可能少扣一点分。请你帮帮他吧！input输入包含T个测试用例。输入的第一行是单个整数T，为测试用例的数量。每个测试用例以一个正整数N开头(1<=N<=1000)，表示作业的数量。...
复制链接

扫一扫