牛客练习赛16题解（待补完）_给定n个数,从中选出三个数,使得最大的那个减最小的那个的值小于等于d,问有多-优快云博客

本文解析了NOOC竞赛中的六道算法题目，包括最大/最小字典序、树高度调整、坐标排序、位运算组合、三数之差限制及特殊序列计数等问题，提供了多种解题思路和技术实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

链接 https://www.nowcoder.com/acm/contest/84#question

无solution为待补

A

经典题目

求一个序列的最大/最小字典序

决策方法：从左往右扫描，遇到一个新的字符后，依次和当前选好的序列比较，比它大的（小的），就换掉它，最后剩下的即为答案

栈实现

时间复杂度 $O(n)$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int debug_num=0;
#define debug cout<<"debug "<<++debug_num<<" :"

const int maxn=1e5+10;

char s[maxn];

stack<char> sta;

int main()
{
    //freopen("in.txt","r",stdin);
    cin>>s;
    //cout<<s<<endl;
    int len=strlen(s);
    sta.push(s[0]);
    for(int i=1;i<len;++i){
        while(!sta.empty()&& s[i]>sta.top()){
            sta.pop();
        }
        sta.push(s[i]);
    }
    string ans="";
    while(!sta.empty()){
        //cout<<sta.top()<<endl;
        ans+=sta.top();

        sta.pop();
    }
    reverse(ans.begin(),ans.end());
    cout<<ans<<endl;
    return 0;
}

B

思维题

任意选择一颗树作为标准，那其他树最后的高度是具体确定的

将每颗树现在的高度和标准高度做差值（可能为负，加shift偏移量）

同一差值数量最多的，就不改这些树的高度（即以他们为标准）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int debug_num=0;
#define debug cout<<"debug "<<++debug_num<<" :"

const int maxn=1e5+10;

int a[maxn];
int aa[maxn];//标准函数
int b[maxn];//估价函数
int c[2*maxn];
int n;


int main()
{
    //freopen("in.txt","r",stdin);
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=1;i<=n;++i){
        cin>>a[i];
        if(i==1) {
            aa[i]=a[i];
            continue;
        }
        if(i<=n/2){
            aa[i]=aa[i-1]+1;
        }
    }
    if(n%2==0){
        aa[n/2+1]=aa[n/2];
        for(int i=n/2+2;i<=n;++i){
            aa[i]=aa[i-1]-1;
        }
    }
    else{
        aa[n/2+1]=aa[n/2]+1;
        for(int i=n/2+2;i<=n;++i){
            aa[i]=aa[i-1]-1;
        }
    }
    //for(int i=1;i<=n;++i) cout<<aa[i]<<' ';
    const int shift=1e5;
    for(int i=1;i<=n;++i){
        c[a[i]-aa[i]+shift]++;
    }
//    for(int i=1;i<2*maxn;++i){
//        cout<<c[i]<<' ';
//    }
    sort(c,c+2*maxn);
    cout<<n-c[2*maxn-1]<<endl;
    return 0;
}

C

方法1（思路不是很优秀）

四种排序方法

再利用set去重

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int debug_num=0;
#define debug cout<<"debug "<<++debug_num<<" :"

struct node1{
    node1(int x,int y):x(x),y(y){}
    int x,y;
    bool operator == (const node1 &s) const{
        return x==s.x;
    }
    bool operator < (const node1 &s) const{
        return x<s.x;
    }
};

struct node2{
    node2(int x,int y):x(x),y(y){}
    int x,y;
    bool operator == (const node2 &s) const{
        return y==s.y;
    }
    bool operator < (const node2 &s) const{
        return y<s.y;
    }
};

struct node{
    int x,y;
}no[200];

multiset<node1> s1;
multiset<node2> s2;

bool cmp1(node a,node b){
    if(a.x==b.x){
        return a.y<b.y;
    }
    return a.x<b.x;
}

bool cmp2(node a,node b){
    if(a.y==b.y){
        return a.x<b.x;
    }
    return a.y<b.y;
}

bool cmp3(node a,node b){
    if(a.x==b.x){
        return a.y<b.y;
    }
    return a.x>b.x;
}

bool cmp4(node a,node b){
    if(a.y==b.y){
        return a.x<b.x;
    }
    return a.y>b.y;
}

int n;

int main()
{
    //freopen("in.txt","r",stdin);
    ios::sync_with_stdio(false);
    cin>>n;
    int x,y;
    for(int i=0;i<n;++i){
        cin>>x>>y;
        no[i].x=x;
        no[i].y=y;
    }
    int num;
    num=-1;
    sort(no,no+n,cmp1);
    for(int i=0;i<n;++i){
        x=no[i].x,y=no[i].y;
        if(s1.count(node1(x,y))){
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
        else if(s2.count(node2(x,y))){
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
        else{
            num++;
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
    }
    int ans=num;
    s1.clear();
    s2.clear();
    num=-1;
    sort(no,no+n,cmp2);
    for(int i=0;i<n;++i){
        x=no[i].x,y=no[i].y;
        if(s1.count(node1(x,y))){
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
        else if(s2.count(node2(x,y))){
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
        else{
            num++;
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
    }
    ans=min(num,ans);
    s1.clear();
    s2.clear();
    num=-1;
    sort(no,no+n,cmp3);
    for(int i=0;i<n;++i){
        x=no[i].x,y=no[i].y;
        if(s1.count(node1(x,y))){
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
        else if(s2.count(node2(x,y))){
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
        else{
            num++;
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
    }
    ans=min(num,ans);
    s1.clear();
    s2.clear();
    num=-1;
    sort(no,no+n,cmp4);
    for(int i=0;i<n;++i){
        x=no[i].x,y=no[i].y;
        if(s1.count(node1(x,y))){
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
        else if(s2.count(node2(x,y))){
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
        else{
            num++;
            s1.insert(node1(x,y));
            s2.insert(node2(x,y));
        }
    }
    ans=min(num,ans);
    cout<<ans<<endl;
    return 0;
}

方法二（很自然）

考虑连通块

有横坐标相同或纵坐标相同的点点就是在一个连通块内

连通块的数量减1即为ans

并查集维护连通块

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int debug_num=0;
#define debug cout<<"debug "<<++debug_num<<" :"

int n;

const int maxn=200;

int father[maxn];
bool vis[maxn];

void init()
{
    for(int i=1;i<=n;++i){
        father[i]=i;
    }
}

int Find(int x)
{
    return father[x] = father[x]==x?  x:  Find(father[x]) ;
}

void Merge(int x,int y)
{
    int fx=Find(x);
    int fy=Find(y);
    if(fx!=fy){
        father[fx]=fy;
    }
}

typedef pair<int,int> pa;

pa node[maxn];

int main()
{
    //freopen("in.txt","r",stdin);
    ios::sync_with_stdio(false);
    cin>>n;
    init();
    for(int i=1;i<=n;++i){
        cin>>node[i].first>>node[i].second;
    }
    for(int i=1;i<=n;++i){//这个过程可以用set实现nlogn,由于n较小，就直接n^2了
        for(int j=1;j<i;++j){
            if(node[i].first==node[j].first||node[i].second==node[j].second)
            {
                //debug<<"***"<<endl;
                //cout<<i<<"->"<<j<<endl;
                Merge(i,j);
            }
        }
    }
    for(int i=1;i<=n;++i){
        //cout<<father[i]<<" ";
        vis[Find(i)]=true;
        //cout<<father[i]<<endl;
    }
    int ans=-1;
    for(int i=1;i<=n;++i){
        if(vis[i]) ++ans;
    }
    cout<<ans<<endl;
    return 0;
}

D

E

枚举左端点，其有一些0，有一些1，那我只需要考虑是0的位置，因为1的位置后面怎么或都是1

而对这些0，最多就20个，当某个位置为1后，后面也一直为1了

所以对于一个固定的l，不同的或值对应的右边界的状态只有最多20个

只要找到这些右边界即可

如何找这些右边界呢？

先预处理出每个数每个位置下一个1出现在什么位置

那对于一个 $l$ 的一个状态，找当前所有0位对应的下一个1的位置，取最小值，即为最近的状态

枚举一遍l即可

用bool数组计数

时间复杂度 $O(n*20*20)$

第一个20为数字位数，第二个20为确定后，后面的状态数

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

const int maxn=1e5+10;

const int inf=0x3f3f3f3f;


int a[maxn];
int help[maxn][20];
int n;
//set<int> ans;
bool b[maxn*11];

void init()
{
    for(int loc=0;loc<20;++loc){
        int id=inf;//最近的1的位置
        for(int j=n-1;j>=0;--j){
            if((a[j]>>loc)&1){
                id=j;
            }
            help[j][loc]=id;
        }
    }
}

int main()
{
    //freopen("in.txt","r",stdin);
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=0;i<n;++i)  cin>>a[i];
    init();

//    for(int i=0;i<n;++i){
//        for(int j=19;j>=0;--j){
//            cout<<help[i][j]<<" ";
//        }
//        cout<<endl;
//    }
//    cout<<endl;

    for(int l=0;l<n;++l){
        int loc=l;
        int tp=a[l];
        //ans.insert(tp);
        b[tp]=true;
        while(1){
            int minn=n;
            //cout<<minn<<endl;
            for(int i=0;i<20;++i){
                //cout<<(tp>>i)<<endl;
                if(((tp>>i)&1)==0){
                    //cout<<i<<" ";
                    minn=min(minn,help[loc][i]);
                }
            }
            //assert(minn<n);
            if(minn>=n) break;
            tp=tp|a[minn];
            b[tp]=true;
            //cout<<tp<<endl;
            loc=minn;
            if(loc==n-1) break;
        }
    }
    //cout<<ans.size()<<endl;
    int num=0;
    for(int i=0;i<maxn*11;++i){
        if(b[i]) num++;
    }
    cout<<num<<endl;
    return 0;
}

F

给定n个数，从中选出三个数，使得最大的那个减最小的那个的值小于等于d，问有多少种选法。

给的数据是有序的，且去重的，不用考虑重复元素了

枚举左端点，二分右端点计数即可

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int debug_num=0;
#define debug cout<<"debug "<<++debug_num<<" :"

const int maxn=1e5+10;

ll a[maxn];

int main()
{
    //freopen("in.txt","r",stdin);
    int n;
    ll d;
    ios::sync_with_stdio(false);
    cin>>n>>d;
    for(int i=0;i<n;++i) cin>>a[i];
    ll num=0;
    for(int i=0;i<n;++i){
        int id=upper_bound(a+i,a+n,d+a[i])-a;
        ll cha = id-i-1;
        num+=cha*(cha-1)/2;
    }
    cout<<num<<endl;
    return 0;
}