程序设计思维与实践 Week4： DDL 的恐惧、四个数列、TT 的神秘礼物

程序设计思维与实践 Week4： DDL 的恐惧、四个数列、TT 的神秘礼物

*写在前边：
1，以后数组尽可能都在静态区开；
2，输入用scanf比cin

A-DDL 的恐惧

描述：

ZJM 有 n 个作业，每个作业都有自己的 DDL，如果 ZJM 没有在 DDL 前做完这个作业，那么老师会扣掉这个作业的全部平时分。所以 ZJM 想知道如何安排做作业的顺序，才能尽可能少扣一点分。

输入：
输入包含T个测试用例。输入的第一行是单个整数T，为测试用例的数量。
每个测试用例以一个正整数N开头(1<=N<=1000)，表示作业的数量。
然后两行。第一行包含N个整数，表示DDL，下一行包含N个整数，表示扣的分。

输出：
对于每个测试用例，您应该输出最小的总降低分数，每个测试用例一行。

Example ：

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

Output：

0
3
5

思路：

用结构体保存每个task的ddl和罚分。重载“<”,ddl小的，罚分少的排在前边。
对于当前天i，ddl在i之后的任务都可以在这一天完成且不会对ddl在i之前的任务产生影响。考虑以下贪心策略：从最后一天开始，每天将ddl在该天之后的任务罚分加入优先队列，选出罚分最高的任务去完成它。最后用所有任务的总罚分减去完成任务的罚分即为最少罚分。

代码：

#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
struct DayFine{
	int day;
	int fine;
	DayFine(){};
	bool operator < (const DayFine a)const
	{
	    if(day == a.day)return fine<a.fine;
	    else return day<a.day;
	} 
};

int main()
{
	int T,n;
	cin>>T;
	priority_queue<int> q;//大根堆优先队列； 
	while(T--){
		cin>>n;
		int tf=0,gf=0;
		
	    DayFine* a=new DayFine[n+1];
		for(int i=1; i<=n; i++)
            scanf("%d",&a[i].day);	
		for(int i=1; i<=n; i++){
		    scanf("%d",&a[i].fine);
		    tf += a[i].fine;
		}
		sort(a+1,a+n+1);
		
		int dayindex=n+1;
		for(int i=n; i>=1; i--){//第i天； 
            while(dayindex--){
                if(dayindex==0)break;
				if(a[dayindex].day >= i && dayindex>=1){
                	q.push(a[dayindex].fine);
				    //cout<<dayindex<<' '<<a[dayindex].fine<<endl;
				}
		        else{
		            dayindex++;
		            break;
				}
			}
			if(!q.empty()){
				//cout<<q.top()<<" ";
				gf += q.top();
				q.pop();
			}
		}
		//cout<<tf<<endl;
		//cout<<tf<<' '<<gf<<endl;
		cout<<tf-gf<<endl;
		
		while(!q.empty())q.pop();
		delete []a;
	}
	
	return 0;
} 

---

B-四个数列

描述：

ZJM 有四个数列 A,B,C,D，每个数列都有 n 个数字。ZJM 从每个数列中各取出一个数，他想知道有多少种方案使得 4 个数的和为 0。 当一个数列中有多个相同的数字的时候，把它们当做不同的数对待。请你帮帮他吧！
第一行：n（代表数列中数字的个数） （1≤n≤4000）

输入：
接下来的 n 行中，第 i 行有四个数字，分别表示数列 A,B,C,D 中的第 i 个数字（数字 
不超过 2 的 28 次方）

输出：
输出不同组合的个数。

Example ：

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

Output：

5

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

思路：

最简单的方法 四次for循环枚举，但是（1≤n≤4000）O(n⁴)肯定TLE。

第二种思路：先算出AB的组合将其装入map中。对于CD的每一种组合sum在map中搜索 -sum对应的value值，map中元素个数为log(n²)。两个for循环，每次查map需要log(n²)，查询的所以第二部复杂度为O(n²logn²)。
看似可以，但是在第一步每次插入一个sum，map都要维护，map是利用类似红黑树实现，则n² 次插入维护复杂度为O(n² *nlogn²)，所以这种方法时间复杂度也超了。

用二分的方法：第一步将AB的组合和存入数组v，复杂度O(n²),第二部sort排序复杂度O(logn²)。第三部在计算CD组合和sum时在数组v中利用二分查找-sum第一次和最后一次出现的下标。下标差加一即为sum对答案的贡献。则此时复杂度为O(n²*2logn²)这里注意当最左边找不到就返回，无需再二分最右边。

最后，因为没有在静态区开数组，一直TLE卡了我十几次…

代码:

#include<iostream>
#include<queue>
#include<algorithm>
#include<map>
#include<vector>
#include<stdio.h>
using namespace std;
const int maxn=10000;
int a[maxn],b[maxn],c[maxn],d[maxn];
vector<int> v;

int find(int sum, int n )
{//logn 
   int l=0, r=n-1,ans1=-1,ans2=-1;
   
   while(l <= r){//找最右边
       int mid=(l+r)/2;	
   	   if(v[mid] == sum){
            ans1=mid;
            l=mid+1;
        }else if(v[mid] > sum){
            r=mid-1;
        }else{
            l=mid+1;
        }
   }
   if(ans1 == -1) return 0;
   else
   {
	   l=0;
	   r=n-1;
	   while(l <= r)
	   {//找最左边 
	        int mid=(l+r)/2;
	        if(sum <= v[mid]){
	            ans2=mid;
	            r=mid-1;
	        }else{
	            l=mid+1;
	        }
	       }
	   return ans1-ans2+1;
  }
}

int main()
{
	int n,sum,ans=0;
	cin>>n;
	for(int i=0; i<n; i++)
		cin>>a[i]>>b[i]>>c[i]>>d[i];
	
	for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
      	    v.push_back(a[i]+b[j]);
      	    
	sort(v.begin(),v.end());//排序 	
	
	for(int i=0; i<n; i++)
	{ 
	    for(int j=0; j<n; j++)
		{
	  	    sum=c[i]+d[j]; 
			//cout<<  find(sum,v,n*n)<<endl;
	        ans += find(-sum,n*n);
	    }
	} 
	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 非常想得到那只可爱的猫咪，你能帮帮他吗？

输入：
多组输入，每次输入一个 N，表示有 N 个数，之后输入一个长度为 N 的序列 cat， cat[i] <= 1e9 ,3 <= n <= 1e5
输出：
输出新数组 ans 的中位数

Example ：

Input：

4
1 3 2 4
3
1 10 2

Output：

1
8

思路：

第一种暴力算出B复杂度O(n²)TLE。

我们考虑先对X中元素升序。x[j]-x[i]=P (1<=i<j<=n)，P是B中的一个元素，其是由X中两个元素做差而来。我们计算所有满足x[j]-x[i]<=P的(i，j)数num，如果num==Mindex=(length+1)/2即P的位置就是中位数的位置，那么P就是中位数。

先对P在1到x[n]-x[1]之间二分，其跨度由排列组合计算为n(n-1)/2。由x[j] <= P + x[i]。对每一个i，计算第一个大于P+x[i]的x[j]的下标indexnum，其中STL的upper_bound()返回一段范围内第一个大于给定值的迭代器位置。因为x[n]有序为了避免重复计算我们还要减去i。
则复杂度为O(log(n(n-1)/2)nlogn)即O(n*(logn)²)。

输入最好用scanf("%d",&n)!=EOF和scanf("%d",&x[i])，亲测cin>>超时。

for(int i=1; i<=n; i++){//i下j的个数；计算mid的名次；
    //第一个大于的下标； 
	int indexnum= upper_bound(x+1,x+n+1,x[i]+mid)-(x+1);
	num += indexnum-i; //因为有序，要减去i  
}

代码：

#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
using namespace std;
const int maxn=1e5+10;
int x[maxn];
int main()
{
	int n,ans;
	while(scanf("%d",&n)!=EOF){
		for(int i=1; i<=n; i++)
		    scanf("%d",&x[i]);
		sort(x+1,x+n+1);
		
		int l=1,r=x[n]-x[1],ans=-1;
		int length=n*(n-1)/2;//数组B的长度； 
		int Mindex=(length+1)/2;//数组B中中位数对应下标； 
		int num;
		//对P的二分答案
		//xj-xi<=p;
		while(l<=r){
			num=0;
		    int mid=(r+l)/2; 
			for(int i=1; i<=n; i++){//i下j的个数；计算mid的名次；
				int indexnum= upper_bound(x+1,x+n+1,x[i]+mid)-(x+1);//第一个大于的下标； 
				num += indexnum-i; //因为有序，要减去i  
			}
			if(num >= Mindex){//名次大于中位数，往左找 
				ans=mid;
				r=mid-1;
			}
			else l=mid+1;//往右； 
		} 
	    cout<<ans<<endl; 
	}
	return 0;
}

二分答案是一类问题，有单调性查找的特点。