2021暑假集训 Day 3

A

Decription:

有n个信号，第i个信号强度为bi。
总体强度为各操作信号的强度之和。
为保证信号强度需要删除某些信号。
有m个操作人员，第i个人只会删除编号在L[i]和R[i]之间的信号，每删除一个信号，花费C[i]格能量。飞船一共有 k格能量，
问在队友删除完信号后，总体强度最大是多少。

Input

第一行给出2个正整数n,m,k
第二行给出n个信号的强度bi
接下来m行，每行用L,R,C来描述一个操作人员

Output

总体最大强度

Sample Input：

5 5 10
10 -2 -5 7 -10
1 1 5
2 4 10
4 4 12
3 4 10
1 5 15

Sample Output：

5

Data Constraint

30%: $n,m\le 10$
100%: $1\le n,m\le 10^5;1\le k\le 500;1\le C[i]\le 500;1\le L[i]\le R[i]\le n;-10^9\le b[i]\le 10^9$

Hint

样例解释：花费10的代价除掉a[3],答案即为10+7-10-2=5

关于题1，我优化出来的一个变量写错了，但是O($n^2$)居然能过？？？区间数据给的太水了吧，我优化了一下使得赋值后的区间只走一遍，白优化了？？思路简单，就一个01背包。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 100000
#define M 500
using namespace std;
int n,m,k,a[N+1],vis[N+1],v[N+1],cnt,ans,dp[M+1],ans1; 
struct node{int l,r,val;}p[N+1],t[N+1];
bool cmp(node a,node b){return a.val<b.val;}
int main()
{
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]),ans+=a[i],a[i]=-a[i];
	for(int i=1;i<=m;i++) 
	{
		scanf("%d%d%d",&p[i].l,&p[i].r,&p[i].val);
		if(p[i].l>p[i].r) swap(p[i].l,p[i].r);
	}
    sort(p+1,p+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
    	if(cnt==n) break;
    	int j=p[i].l;
      	while(j<=p[i].r)
      		{
      		  if(!vis[j]) cnt++,v[j]=p[i].val,vis[j]=i;
      		  else j=p[vis[j]].r;
			  j++;	
			}
	}
	for(int i=1;i<=n;i++)
	{
		if(a[i]<=0||!vis[i]) continue;
		for(int j=k;j>=v[i];j--) dp[j]=max(dp[j-v[i]]+a[i],dp[j]),ans1=max(ans1,dp[j]);
	}
	printf("%d",ans+ans1);
	return 0;
} 

B

Decription:

一个序列S，如果S是回文的且分别是两个或多个已知序列的子序列，且是所有符合此条件序列中最长的，则 S 称为已知序列的最长公共回文子序列。
给一个长度为n的字符串a和一个长度为m的字符串b，求a和b的最长公共回文子序列的长度。

Input

第一行包含一个字符串，表示字符串a
第二行包含一个字符串，表示字符串b

Output

一行，包含一个整数，表示a和b的最长公共回文子序列的长度。

Sample Input：

aaaba
aabba

Sample Output：

3

Data Constraint

对于50%的数据，满足1≤n≤100。
对于100%的数据，满足1≤n≤100000，1≤m≤20，字符串只包含小写字母。

Hint

最长公共回文子序列是aaa，长度为3。最长公共子序列是aaba，但它不是回文的。

思路：
这个就暴力枚举B串的所有回文子串，然后一个一个放到A串暴力匹配，不会爆，因为B串长度太短了。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 200000
#define M 30
using namespace std;
int aa[N+1],bb[M+1],t[M+1],pp,lena,lenb,ans=1;
char a[N+1],b[M+1];
void dfs(int k,int len)
{
	if(k==lenb)
	{
		int q=1,p=len;
		bool flag=0;
		while(q<=p)
		{
			if(t[q]!=t[p]) 
			{
				flag=1;
				break;
			}
			q++,p--;
		}
		if(!flag) 
		{
			pp=1;
			for(int i=0;i<lena;i++)
			{
				if(t[pp]==aa[i]) pp++;
				if(pp>len)
				{
					ans=max(ans,len);
					break;
				}
			}
		}
		return;
	}
	t[len+1]=bb[k];
	dfs(k+1,len+1);
	dfs(k+1,len);
}
int main()
{
	cin>>a>>b;
	lena=strlen(a),lenb=strlen(b);
    for(int i=0;i<lena;i++) aa[i]=a[i]-'a';
    for(int i=0;i<lenb;i++) bb[i]=b[i]-'a';
    dfs(0,0);
	printf("%d",ans);
	return 0;
} 

C

Decription:

有n个木桩依次排列，第i个木桩的高度为hi，其上的果冻数量为xi。
开始的时候可以选择站在任意一个木桩上，每次跳跃不限长度而且只能从左向右跳跃，但只能跳到高度与当前所站高度差绝对值小于等于m的柱子上。
问最多能拿到多少个果冻
最终不一定要落在最后一个木桩上

Input

第一行给出n,m
接下来n行给出每个柱子的高度以及上面的果冻数量

Output

最大获得果冻数量

Sample Input：

4 4
1 0
2 100
100 5
6 10

Sample Output：

110

Data Constraint

40%：1<=n,m<=20
100%:$1\le n\le 200000，1\le m\le 500，任意hi\in [1,1000000],xi\in [0,1000000]$

思路：
设$f_i$表示到了高度i能获得的最大果冻数每做到一个木桩，判断能否更新$f_{h_i}$即max{f[j]}+xi能否更优j为转移状态，即高度[hi-m,hi+m]其中能转移的最优状态设为f[k]，则f[hi] =max(f[hi],f[k]+$x_i$)这个状态可以用线段树在O(log2n)的时间内求出。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#define N 200000
using namespace std;

int n,m,h[N+1],w[N+1],top,tree[N<<2],res,ans;
void ins(int l,int r,int d,int x,int val)
{
	if(l==x&&r==x)
	{
		tree[d]=val;
		return;
	}
	int mid=(l+r)>>1;
	if(x>mid) ins(mid+1,r,d<<1|1,x,val);
	else ins(l,mid,d<<1,x,val);
	tree[d]=max(tree[d<<1|1],tree[d<<1]);
}
void query(int l,int r,int d,int xl,int xr)
{
	if(xl>r||xr<l) return;
	if(xl<=l&&r<=xr)
	{
		res=max(res,tree[d]);
		return;
	}
	int mid=(l+r)>>1;
	query(mid+1,r,d<<1|1,xl,xr),query(l,mid,d<<1,xl,xr);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d%d",&h[i],&w[i]),top=max(top,h[i]);
    for(int i=1;i<=n;i++) 
    {
    	query(1,top,1,max(h[i]-m,0),h[i]+m);
    	w[i]+=res,res=0;
    	ans=max(ans,w[i]);
    	ins(1,top,1,h[i],w[i]);
	}
	printf("%d",ans);
	return 0;
}

D

Decription:

定义：设f(x)为x的约数个数若对任意0<i<x都有f(i)<f(x)，
则称x为66数给出一个正整数n，求出不大于n的最大66数

Input

给出n

Output

对应最大66数

Sample Input：

1000

Sample Output：

840

Data Constraint

40%:1 $\le$ n $\le$ 10000
100%:1$\le$n$\le$ 200000000

思路：
设[1…N]中的一个数x，我们将x质因数分解，即x=$p_1^{c1}$ * $p_2^{c2}$*……pm^cm则我们发现它的约数个数可以被表示为($c_1$+1)（$c_2$+1)……($c_m$+1)因为要求约数个数最大，所以我们可以想到的就是，假如一个合法的数y能够被分成$p{1}^{c2}\ast p{2}^{c2}$且c2>c1，那么显然肯定存在一个$p_1^{c1}\ast p_2^{c2}$比y小且约数个数相同即满足c1≥c2≥……≥cm所以指数肯定是单调递减的，且x的质因子是连续的若干个最小的质数，因为x最大为2$10^9$我们可以发现2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 * 31 > 2 * $10^9$所以我们只需要对这10个质数的指数用dfs去确定即可。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define ll long long
using namespace std;
ll n,zs[12]={0,2,3,5,7,11,13,17,19,23,29,31},maxna,maxnb=1e11; //a放约数个数，b放值 
void dfs(int k,ll val,ll index)
{
	if(val>n) return;
	if(k>11) return; 
	if((index>maxna)||(maxnb>val&&index==maxna)) maxnb=val,maxna=index;
	for(int i=0;i<=32;i++)
		{
			val*=pow(zs[k],i);
			if(val>n) return;
			dfs(k+1,val,index*(i+1));
			val/=pow(zs[k],i);
		}
}
int main()
{
    scanf("%lld",&n);
    dfs(1,1,1);
    printf("%lld",maxnb);
	return 0;
}