2021暑假集训 Day 2

回顾：就不知道今天为什么那么想尝试富文本编辑器了……

A

今天的第一题非常的无语呵，想了90min？而且差一个longlong就A了，别吧，心态炸裂。

Decription:

n个小球排成一列，第i个小球颜色为ai，
定义小球i与j的距离为|(i-j)*(ai-aj)|，
求所有小球间距离之和，
i与j 和 j与i 不必重复计算。

Input:

第一行一个n
第二行给出a1,a2,...,an-1,an

Output

按照题目要求作答

Sample Input

5
0 1 1 0 1

Sample Output

11

Data Constraint

30%: n<=10000
另外40%：n<=100000
100%：n<=1000000，0<=ai<=1

思路：

这道题的时间复杂度大概最多到O(nlogn),那我们就想一下关于二分或者倍增的吧，嗯，然后我就想到了类似于一个离散化的一个东东，首先我们分别将序列中一和零的下标存起来，然后遍历一遍原序列，当a[i]为一或零的时候那么这时候的贡献就是前面与当前不同值的数量减去前面的不同值的下标的和，然后我们可以用upper_bound二分查找离散化后的数量，那么查找n次就是O(nlogn)

代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#define N 1000000
#define ll long long
using namespace std;
ll n,one[N+1],ling[N+1],pos1[N+1],pos2[N+1],a[N+1],len1,len2,k,ans;
int main()
{
    scanf("%lld",&n);
    for(int i=1;i<=n;i++) 
    {
    	scanf("%lld",&a[i]);
    	if(a[i]) pos1[++len1]=one[len1]=i,one[len1]+=one[len1-1];
    	else pos2[++len2]=ling[len2]=i,ling[len2]+=ling[len2-1];
	}
    for(int i=1;i<=n;i++)
    {
    	if(!a[i])
    	{
    		k=upper_bound(pos1+1,pos1+len1+1,i)-pos1;
    		k--;
    		ans+=i*k-one[k];
		}
		else
		{
		    k=upper_bound(pos2+1,pos2+len2+1,i)-pos2;
    		k--;
    		ans+=i*k-ling[k];	
		}
	}
	printf("%lld",ans);
	return 0;
} 

B

Decription:

n个人，每个人都有一份情报
人之间都可以交流，交流有对应的费用，交流完后各自享有对方的情报
A与B交流，A与C交流，B与C也可以互相享有
派遣n个人中任意一人去执行任务都有对应的费用
要求：派遣人去执行任务，派遣的人需要包含所有的情报(不一定只派遣一个)，问最小花费

Input:

第一行一个正整数n
接下来的n行包含n个不超过10^6的非负整数。
在k行m列的数字第k人和第m人会面的花费，同样的，与m行k列的数字相等，k=m时数字为0。
接下来的一行包含N个正整数Ai（1≤Ai≤），分别为派遣1，2，…，N参加任务的花费。

Output

只有一行，为所需的最小总费用。

Sample Input

输入1：
3
0 6 9
6 0 4
9 4 0
7 7 7
输入2：
3
0 17 20
17 0 10
20 10 0
15 9 12
输入3：
5
0 3 12 15 11
3 0 14 3 20
12 14 0 11 7
15 3 11 0 15
11 20 7 15 0
5 10 10 10 10

Sample Output

输出1：
17
输出2：
34
输出3：
28

Data Constraint

30%：2<=n<=20
100%：2≤n≤1000

Hint:

样例1：将会在1和2，接着2和3间举行会面，然后送2参与任务。
样例2：将会在2和3间举行会面，然后送1和2参与任务。
样例3：将会在2和4，接着1和2，接着3和5间举行会面，然后送1和3（或1和5）参与任务。

思路：这道题是一道模板题，看出来就很简单了，那就是最小生成树，以最后派遣的为第n+1个点，求连接起来的最小生成树。

不知道为什么没加快读会超时，其实说实话的时间复杂度妥妥的够啊……

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<queue>
#define N 1010
using namespace std;
int n,a,len,ans;
bool bo[N+1];
struct node
{
	int x,y,val;
}dis[N*N+1];
bool cmp(node a,node b)
{
	return a.val<b.val;
}
inline int qread()
{
   int s=0,w=1;
   char ch=getchar();
   while(ch<'0'||ch>'9'){if(ch=='-') w=-1;ch=getchar();}
   while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
   return s*w;
}
int main()
{

    n=qread();
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    {
    	a=qread();
    	if(i==j) continue;
    	dis[++len].x=i,dis[len].y=j,dis[len].val=a;
	}
    for(int i=1;i<=n;i++) 
    {
    	a=qread();
    	dis[++len].x=i,dis[len].y=n+1,dis[len].val=a;
	}
	sort(dis+1,dis+len+1,cmp);
	bo[1]=1;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=len;j++)
		{
			int xx=dis[j].x,yy=dis[j].y;
			if((bo[xx]&&!bo[yy])||(!bo[xx]&&bo[yy]))
			{
				bo[xx]=bo[yy]=1;
				ans+=dis[j].val;
				break;
			}
		}
	}
	printf("%d",ans);
	return 0;
} 

C

Decription:

给出一个长度为n的序列A描述一个长度为n的全排列，Ai表示前i-1个有多少个比第i个数大。
请求出这个全排列

Input:

第一行一个正整数n。
第二行给出序列A。

Output

对应的全排列

Sample Input

3
0 0 1

Sample Output

1 3 2

Data Constraint

30%:2<=n<=20
100%:2≤n≤1000

很显然？没有用Special Judge，暗示只有唯一解？好吧，其实没有什么多大关系，这只是我当时的想法而已。

那么我们怎么想到O()的解法，发现a[n]定下来以后，第n位一定是a[n] +1往前推第n-1位就是 数1到n中 删掉了第a[n]+1大的数后剩下的n-1个数中第a[n-1]+1大的数。那么我们用桶排去找，也可以用树状数组加上二分查找来优化此方法应该可以过10000的数据。

代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<queue>
#define N 8000
using namespace std;
int n,a[N+1],num[N+1];
bool bo[N+1];
int ser(int rank)
{
	int cnt=0,res;
	for(int i=1;i<=n;i++)
	{
		if(!bo[i]) cnt++;
		if(cnt==rank) 
		{
			bo[i]=1,res=i;
			break;
		}
	}
	return res;
}
int main()
{

    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=n;i>=1;i--)
    {
    	num[i]=ser(i-a[i]);
	}
	for(int i=1;i<=n;i++) printf("%d ",num[i]); 
	return 0;
} 

D

Decription:

依次给出n个人的性别，男或女，按输入顺序站成一排，问最长的一段男女人数相等的子序列长度

Input:

一行整数给出n
第二行给出序列a，ai=0表示男生，ai=1表示女生

Output

最大长度

Sample Input

9
0 1 0 0 0 1 1 0 0

Sample Output

6

Data Constraint

30%的数据，n<=100。
50%的数据，n<=1000。
100%的数据，n<=100000。

 这道题我们可以看到，需要发现一个非常隐蔽的性质，好吧，我也推了挺久才发现的，首先我们用一个数组来装到第i个人时男生和女生的数量差是多少，然后我们在遍历一次，对于第i个时的差，我们要找到相等的值最小的坐标，那么我们将i减去这个坐标内的值毫无疑问等于0，那么此区间的男和女的数量就相等，那么就与ans比较，最后得出答案，对于坐标，本人使用map来维护。

注意由于使用map，得比较本就为0时的长度。

代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<map>
#define N 100000
using namespace std;
int n,a[N+1],dp[N+1],ans;
map<int,int> p;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1;i<=n;i++)
    {
    	if(a[i]) dp[i]=dp[i-1]+1;
    	else dp[i]=dp[i-1]-1;
    	if(!p[dp[i]]) p[dp[i]]=i;
    	if(!dp[i]) ans=max(ans,i);
	}
	for(int i=1;i<=n;i++) if(p[dp[i]]!=i) ans=max(ans,i-p[dp[i]]);
	printf("%d",ans);
	return 0;
}