线性复杂度优化 / 离散化

1.连续自然数和

传送门

1.数论推公式做法：

思路：
假设连续子段为[L,R],则这段的和为(L+R)(R-L+1)/2=M,（等差数列求和公式）
(L+R)(R-L+1)=2M;
设x=L+R,y=R-L+1,联立得
L=(x-y+1)/2,R=(x+y-1)/2;
（1）L，R要是整数，则x,y必须一奇一偶；
（2）L!=R ，则x!=1.
所以x从sqrt(2M)枚举到2,如果满足y为整数且为一奇一偶，则输出L,R

代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

void solve(){
	int m;
	cin>>m;
	for(int i=sqrt(2*m);i>1;i--){
		if(2*m%i==0&&(i+2*m/i)%2){//前面保证j为整数，后面保证为一奇一偶 
			int j=2*m/i;
			cout<<(j-i+1)/2<<" "<<(i+j-1)/2<<endl;//输出L,R 
		}
	}
}

int main(){
	int t;
    t=1; 
	while(t--){
		solve();
	}
	return 0;
}

2.暴力解法：
直接从1-n/2枚举i,再从i到n枚举j,如果sum>=n,跳出循环。
如果sum==n 输出

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,sum;

void solve(){
	cin>>n;
	int j;
	for(int i=1;i<=n/2;i++){
		sum=0;
		for(j=i;j<n;j++){
			sum+=j;
			if(sum>=n) break;
		}
		if(sum==n) cout<<i<<" "<<j<<endl;
		 
	}
	return;
}

int main(){
	int t;
    t=1;
	while(t--){
		solve();
	}
	return 0;
}

(3)尺取法（双指针）

因为是连续自然数，所以至少2个数，即i=1,j=2,sum=3开始；
从i=1,j=2开始到i=n/2枚举，如果sum==n,输出i,j;
如果sum<n，表明小了，j++,sum+=j;
如果sum>n,表明大了，sum-=i,i++;

代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,sum;

void solve(){
	cin>>n;
	ll sum=3;
	for(int i=1,j=2;i<=n/2;){
		if(sum==n){
			cout<<i<<" "<<j<<endl;
			sum-=i;
			i++;
		}
		else if(sum<n){
			j++;
			sum+=j;
		}
		else {
			sum-=i;
			i++;
		}
	}
}

int main(){
	int t;
    t=1;
	while(t--){
		solve();
	}
	return 0;
}

2.扫描

传送门

1.滑动窗口单调队列求最大值

维护一个单调队列，其队首为最大值。

代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e6+10;
ll n,k,maxn,a[N],q[N];

void solve(){
	cin>>n>>k;
	for(int i=1;i<=n;i++) cin>>a[i];
	int head=1,tail=0;
	//维护一个单调队列，队首为最大值 
	for(int i=1;i<=n;i++){
		while(head<=tail&&q[head]+k<=i) head++;//过时了 
		while(head<=tail&&a[q[tail]]<=a[i]) tail--;//队尾比新来的小，出队 
		q[++tail]=i;//将新来的入队 
		if(i>=k) cout<<a[q[head]]<<endl;//枚举的是位置 
	}
}

int main(){
	int t;
	t=1;
	while(t--){
		solve();
	}
	return 0;
}

3.

RMQ
滚动数组

4.Diamond Collector S

传送门

思路：
要求最多一共可以放多少颗钻石在这两个陈列架上，
等价于先对数组排序，在数列中找两端长度和最大的不重叠的区间，并且这两个区间的最大值和最小值的差不大于k。

步骤：
先对数组元素排序，考虑每个点，算出它左边区间最长可以取到多少，右边区间最长可以取到多少 。最后取每个点的l[i]+r[i+1]的最大值。

易错点：
1.记得对数组排序
2.记得初始化l[1]和r[n]为1
3.防止区间重叠

代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 50010;
int n,k,a[N],l[N],r[N],now,ans;
//l[N]表示从左边开始的最长连续数列，r[N]表示从右边开始的最长连续数列 

void solve(){
    scanf("%d%d",&n,&k); 
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	sort(a+1,a+n+1);//排序 
	l[1]=r[n]=1;//两边的初始都为1，因为最开始无论是从左边还是右边都是只有一个数 
	//防重叠！！！ 
	//从左往右依次考虑每个点 
	for(int i=2,now=1;i<=n;i++){
		while(a[i]-a[now]>k) now++;
		l[i]=max(l[i-1],i-now+1);
	}
	//从右往左依次考虑每个点 
	for(int i=n-1,now=n;i;i--){
		while(a[now]-a[i]>k) now--;
		r[i]=max(r[i+1],now-i+1);
	}
	for(int i=1;i<n;i++){
		ans=max(ans,l[i]+r[i+1]);
	}
	printf("%d\n",ans);
}

int main(){
	int t;
	t=1;
	while(t--){
		solve();
	}
	return 0;
}

5.Face The Right Way G

传送门

**题意：**有n头牛，最初面朝不同方位，现在需要将所有牛都朝前。每次只能操作k头牛，总共操作m次，输出k和m.

考察：差分

思路：
将面朝前记为1，面·朝后记为0.
从n到1枚举k,对于每个k，如果满足条件那么cnt++,且通过异或运算进行转换操作。如果操作完之后的cnt<ansm,更新ansm和ansk.
等价于将一个01串经过m次操作后变成全是1的串。

代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 0x3f3f3f3f
const int N = 5010;
int n,a[N],cf[N],ansm = INF,ansk;//cf:差分数组 
char ch;

void solve(){
    cin>>n;
    for(int i=1;i<=n;i++) {
    	cin>>ch;
    	if(ch=='F') a[i]=1;//朝前面，标记为1 
	}
    for(int k=1;k<=n;k++){//枚举k：即长度 
    	memset(cf,0,sizeof(cf));//每次差分数组都要清0 
    	int cnt=0,now=0,flag=1;//cnt记录操作次数，now记录每次操作结果 
    	for(int i=1;i<=n;i++){
    		now ^= cf[i];//最开始的now为0，异或：相同为0，所以当后面的a[i]和now都为0时，为0， 
    		if(now^a[i]==0){//如果朝后，需要进行操作 
    			if(i+k-1>n){//不满足条件 
    				flag=0;                                
    				break;
				}
				//满足条件 
				cnt++;
				//差分更新 
			    now ^= 1;
			    cf[i+k]^=1;
			}
			
		}
		if(flag){
			if(cnt<ansm){
				ansm=cnt;
				ansk=k;
			}
		}
	}
	
	cout<<ansk<<" "<<ansm<<endl;
}

int main(){
	int t;
	t=1;
	while(t--){
		solve();
	}
	return 0;
}

6.火烧赤壁

传送门

思路：分别用两个数组记录起点和终点，然后将这两个数组排序。
在范围内枚举，先加上这段范围的长度。如果不是最后一段且与下一段有重叠，那么减去重叠部分。

代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e4+10;
ll n,a[N],b[N],ans; 

void solve(){
    cin>>n;
    for(int i=1;i<=n;i++){
    	cin>>a[i]>>b[i];
	}
	//排序 
	sort(a+1,a+n+1);
	sort(b+1,b+n+1);
	for(int i=1;i<=n;i++){
		ans+=(b[i]-a[i]);//先加上这一段的长度 
		if(i<n){//如果不是最后一段 
			if(b[i]>a[i+1]){//如果这一段与下一段有重叠 
				ans-=(b[i]-a[i+1]);//减去重叠部分 
			}
		}
	}
	cout<<ans<<endl;
}

int main(){
	int t;
	t=1;
	while(t--){
		solve();
	}
	return 0;
}

7.My Cow Ate My Homework S

传送门

思路：
在ak+1-an中找到最小值，去掉这个最小值，求平均值，求平均值的最大值 。
先预处理mi数组为INF，后面再依次更新mi[i]。倒着扫一遍，得到最小值，并且求出后缀和，并求出平均值，更新平均值的最大值。
然后正着扫一遍，如果ave[i]==ma,输出i-1<<endl;

考察：预处理，后缀和，贪心

代码如下：

//思路：在ak+1-an中找到最小值，去掉这个最小值，求平均值，求平均值的最大值 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 0x3f3f3f3f
const int N = 1000010;
int n;
double a[N],sum[N],mi[N],ave[N],ma;

void solve(){
	cin>>n;
	for(int i=1;i<=n+1;i++) mi[i]=INF;//预处理数组mi的1-n+1为INF 
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=n;i>=2;i--){
		mi[i]=min(mi[i+1],a[i]);//找最小值 
		sum[i]=sum[i+1]+a[i];//前缀和 
		if(i!=n) ave[i]=(sum[i]-mi[i])/(double)(n-i);//如果不是最开始，求出平均值。本来应该是除以n-i+1,由于去掉最小值，所以除以n-i；这段的和就是sum[i]-mi[i] 
	    ma=max(ma,ave[i]);//找平均值的最大值 
	}
	for(int i=2;i<=n-1;i++){
		if(ma==ave[i]) cout<<i-1<<endl;//按升序输出平均值的最大值所对应的下标 
	}
}

int main(){
	int t;
	t=1;
	while(t--){
		solve();
	}
	return 0;
}

8.