【LGR-176-Div.2】[yLCPC2024] 洛谷 3 月月赛 I（A~C and G＜oeis＞）

已于 2024-03-10 12:39:49 修改
阅读量985 收藏 14
点赞数 16
分类专栏： 洛谷 文章标签： c++ 思维 算法 数据结构 洛谷 div2
于 2024-03-10 01:04:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17807067/article/details/136588270
版权

[yLCPC2024] A. dx 分计算

前缀和提前处理一下区间和，做到O（1）访问就可以过。

#include <bits/stdc++.h>
//#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;

void solve(){
    string s;
    cin>>s;

    int a[s.length()+1];
    a[0]=0;
    per(i,0,s.length()-1){
        if(s[i]=='P')a[i+1]=3;
        else if(s[i]=='p')a[i+1]=2;
        else if(s[i]=='G')a[i+1]=1;
        else a[i+1]=0;
        if(i>=1)a[i+1]+=a[i];
    }

    int q;
    cin>>q;
    per(i,1,q){
        int l,r;
        cin>>l>>r;
        cout<<a[r]-a[l-1]<<endl;
    }
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

[yLCPC2024] B. 找机厅

可以走四个方向，从左上角到右下角，问最少步数，和输出任意一条最短路径。

第一次BFS，把到每个点的步数都求一下，即下一个点.step=前一个点.step+1

如果终点有最短步数，那么有解，再根据最短步数BFS一次，四个方向的下一步必须步数比当前刚好大1，再走，顺便输出方向即可。

#include <bits/stdc++.h>
//#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;

void solve(){
    int n,m;
    cin>>n>>m;

    int a[n+1][m+1],step[n+1][m+1];
    string s[n+1];
    per(i,1,n)cin>>s[i];

    per(i,1,n){
        per(j,0,m-1){
            if(s[i][j]=='0')
                a[i][j+1]=0;
            else a[i][j+1]=1;
        }
    }

    per(i,1,n){
        per(j,1,m){
            step[i][j]=INT_MAX;
        }
    }

    bool vis[n+1][m+1];
    per(i,1,n){
        per(j,1,m){
            vis[i][j]=false;
        }
    }

    struct Node{
        int x,y,val;
    };

    queue<Node>q;//终点开始BFS（起点应该一样的）
    q.push({n,m,1});

    auto inSec=[&](Node x){
        return x.x>=1 and x.x<=n and x.y>=1 and x.y<=m;
    };

    int dx[4]={0,0,1,-1};
    int dy[4]={1,-1,0,0};
    char dc[4]={'R','L','D','U'};
    map<pair<int,int>,char>d;
    per(i,0,3){
        d[{dx[i],dy[i]}]=dc[i];
    }

    while(q.size()){
        Node now=q.front();
        q.pop();
        if(vis[now.x][now.y])continue;
        vis[now.x][now.y]=true;
        step[now.x][now.y]=min(step[now.x][now.y],now.val);

        //四个方向
        per(i,0,3){
            Node next={now.x+dx[i],now.y+dy[i],now.val+1};
            //是否越界
            if(!inSec(next))continue;
            //是否可走
            if(a[next.x][next.y]==a[now.x][now.y])continue;
            q.push(next);
        }
    }

//    per(i,1,n){
//        per(j,1,m){
//            cout<<step[i][j]<<" ";
//        }cout<<endl;
//    }

    if(vis[1][1]){
        cout<<step[1][1]-1<<endl;

        Node now={1,1};
        Node END={n,m};
        while(true){
            if(now.x==END.x and now.y==END.y)break;

            per(i,0,3){
                Node next={now.x+dx[i],now.y+dy[i]};
                if(!inSec(next))continue;
                if(step[next.x][next.y]==step[now.x][now.y]-1){
                    cout<<d[{dx[i],dy[i]}];
                    now=next;
                    break;
                }
            }
        }
        cout<<endl;
    }else cout<<-1<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

[yLCPC2024] C. 舞萌基本练习

via z01prime.某某最大值里面的最小值，分成几段是否可行，没有思路的话就要考虑是二分答案了。

直接从二分不优美度入手，如果大优美度可以，那就往小的接着试。

线段树系数太大了过不了这道题，只能过第一个测试点。（要用树状数组）

每次加入一个数，访问比当前大的数已经存在了几个（即逆序对），根据这个去写check函数，分出组，如果组<=k 即合理，显然组越多 不优美度才有可能更小，让组更贴近k即为答案。

维护的时候记得离散化。

再加上不优美度最大极限可以达到1e10左右，所以这道题r至少要1e11才保险，也就是开long long。线段树基本上就似了。

比如下面这个线段树TLE（应该能过，动态修改就行，暂时没调对）

#include <bits/stdc++.h>
//#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;

void solve(){
    int n,k;
    cin>>n>>k;

    int a[n+1];
    per(i,1,n)cin>>a[i];

    struct{
        int val;
    }seg[n<<2];

    auto init=[&](){
        per(i,1,(n<<2)-1){
            seg[i].val=0;
        }
        return;
    };

    auto lc=[&](int i){
        return i<<1;
    };
    auto rc=[&](int i){
        return i<<1|1;
    };

    auto update=[&](int i){
        seg[i].val=seg[lc(i)].val+seg[rc(i)].val;
    };

    function<void(int l,int r,int i,int x)>insert=[&](int l,int r,int i,int x){
        if(l==r){
            if(l==x)seg[i].val=1;
            return;
        }
        int mid=(l+r)>>1;
        if(x<=mid)insert(l,mid,lc(i),x);
        if(x>mid)insert(mid+1,r,rc(i),x);
        update(i);
    };

    function<int(int l,int r,int i,int x,int y)>query=[&](int l,int r,int i,int x,int y){
        int ans=0;
        if(l>=x and r<=y)return seg[i].val;
        int mid=(l+r)>>1;
        if(x<=mid)ans+=query(l,mid,lc(i),x,y);
        if(y>mid)ans+=query(mid+1,r,rc(i),x,y);
        return ans;
    };

    function<void(int l,int r,int i,int x)>del=[&](int l,int r,int i,int x){
        if(l==r){
            if(l==x)seg[i].val=0;
            return;
        }
        int mid=(l+r)>>1;
        if(x<=mid)del(l,mid,lc(i),x);
        if(x>mid)del(mid+1,r,rc(i),x);
        update(i);
    };

    int b[n+1];
    per(i,1,n)b[i]=a[i];
    sort(b+1,b+1+n);

    //离散化
    map<int,int>f;//原数值,对应离散化
    per(i,1,n)f[b[i]]=i;

    init();

    auto check=[&](int x){
        int cnt=0,res=0,nxd=0;

        per(i,1,n){//划分
            res++;
            if(res==1){
                insert(1,n,1,f[a[i]]);
            }else{
                int add=query(1,n,1,f[a[i]]+1,n);
                if(nxd+add>x){
                    cnt++;
                    per(j,i-res,i-1){
                        del(1,n,1,f[a[j]]);
                    }
                    nxd=0;
                    res=0;
                }else{
                    nxd+=add;
                    insert(1,n,1,f[a[i]]);
                }
            }
        }
        per(i,n-res+1,n){
            del(1,n,1,f[a[i]]);
        }

        return cnt+1;
    };

    int l=0,r=INT_MAX;
    while(l<r){
        int mid=(l+r)>>1;
        int cnt=check(mid);
        if(cnt<=k){// mid越大  cnt越少
            r=mid;//合理的时候 cnt越多越好
        }else{
            l=mid+1;
        }
    }
    cout<<r<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

所以我们只需要稍加（全部）修改，把线段树的内容改成树状数组的内容。

#include <bits/stdc++.h>
#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;
const int N=1e5+5;

int a[N],n,k,c[N],b[N];
unordered_map<int,int>f;//原数值,对应离散化

void solve(){
    cin>>n>>k;
    per(i,1,n)cin>>a[i];

    per(i,1,n)b[i]=a[i];
    sort(b+1,b+1+n);

    //离散化
    f.clear();
    per(i,1,n)f[b[i]]=i;

    auto lowbit=[&](int x){
        return x&-x;
    };

    auto insert=[&](int x){
        while(x<=n){
            c[x]++;
            x+=lowbit(x);
        }
    };

    auto del=[&](int x){
        while(x<=n){
            c[x]--;
            x+=lowbit(x);
        }
    };

    auto sum=[&](int i){
        int res=0;
        while(i>=1){
            res+=c[i];
            i-=lowbit(i);
        }
        return res;
    };

    auto check=[&](int x){
        int cnt=0,res=0,nxd=0;

        per(i,1,n){//划分
            res++;
            if(res==1){
                insert(f[a[i]]);
            }else{
                int add=sum(n)-sum(f[a[i]]);
                if(nxd+add>x){
                    cnt++;
                    per(j,i-res+1,i-1){
                        del(f[a[j]]);
                    }
                    i--;
                    nxd=0;
                    res=0;
                }else{
                    nxd+=add;
                    insert(f[a[i]]);
                }
            }
        }
        per(i,n-res+1,n){
            del(f[a[i]]);
        }

        return cnt+1;
    };

    int l=0,r=1e11;
    while(l<r){
        int mid=(l+r)>>1;
        int cnt=check(mid);
        if(cnt<=k){// mid越大  cnt越少
            r=mid;//合理的时候 cnt越多越好
        }else{
            l=mid+1;
        }
    }
    cout<<r<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

即可AC。

离散化的时候使用unordered_map，插入和查询的复杂度都是O（1），当然，如果出题人对着STL的散列表的内部哈希值出数据，能把复杂度卡到O（n），当然这道题没这么毒瘤，用散列表即可AC（map过不了的，查询插入复杂度都是logn）当然就算出题人不卡散列表离散化，也有可能会超时。

763ms为散列表，178ms就是正常的离散化。

但是如果你很担心的话，就使用正常版本的。

首先复制一份你要离散化的数组，如c[i]=a[i]。

对c 先升序排序，然后去重（unique，返回值是压缩后的末尾迭代器，即新end）。

遍历 a 数组，在 c 数组中 lower_bound 自身值（即二分定位）在 c 中的排名。

总复杂度为nlogn，显然查询为稳定的O（1）

#include <bits/stdc++.h>
#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;
const int N=1e5+5;

int a[N],n,k,c[N],b[N];

void solve(){
    cin>>n>>k;
    per(i,1,n)cin>>a[i];

    per(i,1,n)b[i]=a[i];
    sort(b+1,b+1+n);
    int p=unique(b+1,b+1+n)-b;
    //离散化
    per(i,1,n)a[i]= lower_bound(b+1,b+1+p,a[i])-b+1;

    auto lowbit=[&](int x){
        return x&-x;
    };

    auto insert=[&](int x){
        while(x<=n){
            c[x]++;
            x+=lowbit(x);
        }
    };

    auto del=[&](int x){
        while(x<=n){
            c[x]--;
            x+=lowbit(x);
        }
    };

    auto sum=[&](int i){
        int res=0;
        while(i>=1){
            res+=c[i];
            i-=lowbit(i);
        }
        return res;
    };

    auto check=[&](int x){
        int cnt=0,res=0,nxd=0;

        per(i,1,n){//划分
            res++;
            if(res==1){
                insert(a[i]);
            }else{
                int add=sum(n)-sum(a[i]);
                if(nxd+add>x){
                    cnt++;
                    per(j,i-res+1,i-1){
                        del(a[j]);
                    }
                    i--;
                    nxd=0;
                    res=0;
                }else{
                    nxd+=add;
                    insert(a[i]);
                }
            }
        }
        per(i,n-res+1,n){
            del(a[i]);
        }

        return cnt+1;
    };

    int l=0,r=1e11;
    while(l<r){
        int mid=(l+r)>>1;
        int cnt=check(mid);
        if(cnt<=k){// mid越大  cnt越少
            r=mid;//合理的时候 cnt越多越好
        }else{
            l=mid+1;
        }
    }
    cout<<r<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

最后实测线段树打上所有178ms里面的优化，照样过不了第一个点，会TLE。（系数太大了）

[yLCPC2024] G. 系ぎて

直接上暴力！

void solve(){
    int n;
    cin>>n;

    auto cul=[&](int x){
        int res=0;
        per(i,1,x){
            per(j,1,x){
                per(k,1,x){
                    if(i*j*k==x)
                        res++;
                }
            }
        }
        return res;
    };

    int ans=0;
    per(i,1,n){
        ans+=cul(i);
    }
    cout<<ans<<endl;
}

100算的就有点慢了，显然i*j*k==x可以变成，x%(i*j)==0优化掉一个循环

void solve(){
    int n;
    cin>>n;

    auto cul=[&](int x){
        int res=0;
        per(i,1,x){
            per(j,1,x){
                if(x%(i*j)==0)res++;
            }
        }
        return res;
    };

    int ans=0;
    per(i,1,n){
        ans+=cul(i);
    }
    cout<<ans<<endl;
}

但是这样1e5的数据都跑不出来，1e10更是天方夜谭（，哪怕遍历每个数就得出res，也要遍历到1e10，差不多可以得出结论这是一道数学题，或许有可能是一个有规律的数列。

直接把前10个答案放到oeis网站上让网站帮忙找规律（

拉到下面有一个Python版本的代码

然后让Chat8帮忙改成C++代码，然后提交，AC..

#include <bits/stdc++.h>
#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;

int ans(int n){
    int m = cbrt(n);
    int sum = 0;

    for (int i = 1; i <= m; ++i) {
        int r = n / i;
        int s = sqrt(r);

        int term1 = -s * s;

        int term2 = 0;
        for (int k = 1; k <= s; ++k) {
            term2 += r / k;
        }
        term2 *= 2;
        
        int term3 = 0;
        for (int j = 1; j <= m; ++j) {
            term3 += n / (i * j);
        }

        sum += term1 + term2 - term3;
    }

    return m * m * m + 3 * sum;
}

void solve(){
    int n;
    cin>>n;

    cout<<ans(n)<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    while(t--)solve();
    return 0;
}

正解移步P10239 [yLCPC2024] G. 系ぎて - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

邪∩写法仅供参考。

zzc大魔王
关注
专栏目录
【LGR-118】洛谷 8 月月赛 Ⅲ Div.2 and 洛谷 8 月月赛 II div.2总结 and 洛谷 8 月月赛 I 总结
m0_55341679的博客
10-16 500
月赛总结
【LGR-070】洛谷 3 月月赛 I & EE Round 1 Div.2
chenboshuai的博客
03-24 489
【LGR-070】洛谷 3 月月赛 I & EE Round 1 Div.2 A 苏联人 入门 题目描述 你在打EE Round 1， 发现第一题非常无聊， 于是你不打了， 去下国际象棋了。 结果你发现， 由于某种神秘力量的影响， 你的棋子只剩下若干黑色的战车， 若干黑色的主教， 和一只白色的国王了。 由于你很无聊， 所以你把一些棋子放在了8×88 \times 88×8的棋...
【OJ比赛日历】快周末了，不来一场比赛吗？ #03.09-03.15 #13场
CompHub的博客
03-08 1010
实时聚合多平台的(Kaggle、天池…)和(Leetcode、牛客…）比赛。本账号会推送最新的比赛消息，欢迎关注！以下信息仅供参考，以比赛官网为准。
【LGR-174-Div.2】洛谷 2 月月赛 II & FanOI Round 1 题解
Chat_lsm2024的博客
02-23 537
容易发现，如果把ai​从小到大排序，那么ai​−ai1​≤0，否则一定有一项0，因此我们从小到大排序，求相邻两项差的最大值即可。
A. dx 分计算
2301_80065123的博客
04-15 965
你说的对，但舞萌 DX 是一款由 SEGA 开发，华立科技代理，形似洗衣机的街机音乐游戏。只要看准时机拍到所有的音符就好啦！
【LGR-196-Div.4】洛谷入门赛 #26(A~H)
weixin_73332175的博客
08-18 271
入门赛题目比较简单，直接贴代码~~
【LGR-190-Div.2】洛谷 6 月月赛 II & Windy OI Round 7
Water_Sunzhipeng的博客
07-03 387
其中从 𝑥𝑖xi​ 移动到 𝑦𝑖yi​ 的过程重复至少 𝑘𝑖ki​ 次。，其中第 𝑖i 项任务需要连续的 𝑎𝑖ai​ 天来完成。也就是说，假设她在第 𝑥x 天开始该任务，那么她会在第 𝑥+𝑎𝑖−1 天结束后完成该任务，她需要保证这些天里她都是空闲的。莲子有 𝑚m 个需要满足的条件，第 𝑖i 个条件形如“小球需要从点 𝑥𝑖xi​ 移动到点 𝑦𝑖yi​ 至少 𝑘𝑖ki​ 次”，莲子有 𝑚 个需要满足的条件，第 𝑖 个条件形如“小球需要从点 𝑥𝑖移动到点 𝑦𝑖 至少一次”，第三行 𝑚 个正整数描述序列 𝑏。
【LGR-182-Div.4】洛谷入门赛 #22 题解
2302_79422829的博客
04-21 640
【代码】【LGR-182-Div.4】洛谷入门赛 #22 题解。
【LGR-196-Div.4】洛谷入门赛 #26 题A - H 详细题解--优化思路简洁代码(C++,Python语言描述)
2401_83669813的博客
08-19 1221
本文为【LGR-196-Div.4】洛谷入门赛 #26所有题目的详细题解，包括两种代码(Python,C++)解释
【LGR-179-Div.2】复旦勰码 3 月月赛 II & ZHYOI Round 4（A~B）
qq_17807067的博客
03-17 504
【LGR-179-Div.2】复旦勰码 3 月月赛 II & ZHYOI Round 4（A~B）
【LGR-108】洛谷 5 月月赛 I & JROI R4 Div.2 P8319 『JROI-4』分数
fqyzOIer
05-02 524
题目背景 万人血书KHIN完成女装 flag(1/10000)\to→万人血书KHIN完成女装 flag(2/10000)(1/5000)\to→万人血书KHIN完成女装 flag(2/5000)(1/2500)\to→万人血书KHIN完成女装 flag(2/2500)(1/1250)\to→万人血书KHIN完成女装 flag(2/1250)(1/625)\cdots⋯以此类推，在可以约分的情况下，“万人血书”很快就能完成。 题目描述 “x 人血书”的过程可以...
洛谷 2 月月赛 I & 『MdOI R4』 (Div2) A ~ D 四题全，也许会有六题，超高质量题解 （Div.1E、F下辈子一定补）【每日亿题2 / 9】
繁凡さん的博客
02-09 1785
洛谷 2 月月赛 I & 『MdOI R4』 (Div2) A ~ D 四题全，也许会有六题，超高质量题解 （Div.1E、F下辈子一定补）【每日亿题2 / 9】
题解 【LGR-087】洛谷 7 月月赛 Div.2
im_zyINF的博客
08-20 421
qwq
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1102
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 642
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 407
【代码】求n的阶乘的相反数（c语言）
简易STL实现 | Set 的实现
AsherGu的博客
09-26 442
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
【C++】stack和queue的使用及注意事项
最新发布
wangnaisheng的专栏
09-28 641
【C++】stack和queue的使用及注意事项
对Sentinel-2A多光谱遥感影像反射率进行1/R、lgR、Ra、FDR、SDR及FDLR变换
10-25
2. lgR变换：将反射率的对数作为新的像元值，可以增强低反射率区域的对比度，适用于水体等低反射率区域。 3. Ra变换：将反射率的平方根作为新的像元值，可以增强中等反射率区域的对比度，适用于城市等中等反射率区域...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值