2023湖南省赛游记/题解

最新推荐文章于 2024-07-19 22:36:19 发布
最新推荐文章于 2024-07-19 22:36:19 发布
阅读量1.5k 收藏 1
点赞数 3
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41418557/article/details/133499869
版权

省赛拖了大哥们的后腿，感觉随便补个正常一队水平的人，我们一队肯定能AK。只能说自己真的菜，全程帮不上什么忙，还负贡献，真的想笑

B
暴力sg

#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
constexpr int N=1e6;
int sg[N+5];
int vis[N+5];
void getsg(){
    for (int i=1;i<=N;i++){
        // vis[sg[i-1]]=i;
        int res=sqrt(1.0*i);
        if (i==res*res){
            for (int k=1;k<=res;k++){
                vis[sg[i-(i-res*res+k*res)]]=i;
            }
        }else{
            for (int k=0;k<=res;k++){
                vis[sg[i-(i-res*res+k*res)]]=i;
            }
        }
        while (vis[sg[i]]==i){
            sg[i]++;
        }
    }
}
void yrzr(){
    getsg();
    int n;
    std::cin>>n;
    int sum=0;
    for (int i=1;i<=n;i++){
        int x;
        std::cin>>x;
        sum^=sg[x];
    }
    if (sum){
        std::cout<<"First\n";
    }else{
        std::cout<<"Second\n";
    }
}

D
大哥赛后说是HN省选dp原题（见状压dp P3188 [HNOI2007] 梦幻岛宝珠），然后这个题比那个题范围还要大，看完题解发现是贪心题，但是还是按位分组的思想去解决问题
首先对于一个目标物品来说，它的需求可以表示为几个二进制位的组合，然后我们分解每一个目标物品到位上，然后将其按位合并，最后可以表示为一个二进制串（用数组表示）
然后对于每一件物品，重量小的物品可以合并成大物品，但大物品不能拆解成小物品，所以我们按位从小到大枚举目标物品数组，贪心地用小物品去满足当前位的数量，然后将剩下的物品贪心地两两合并成下一位的物品。

简要的说就是：目标物品总体可以表示为一个数组，然后拥有的物品贪心从小到大去填补目标重量

#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
constexpr int inf=1e9;
std::priority_queue<int,std::vector<int>,std::greater<int>> q[5105];
void yrzr(){
    int n;
    std::cin>>n;
    for (int i=1;i<=n;i++){
        int x,y;
        std::cin>>x>>y;
        q[x].push(y);
    }
    
    int m;
    std::cin>>m;
    std::vector<int> sum(5105);
    while (m--){
        int t,h;
        std::cin>>t>>h;
        while (h){
            if (h&1) sum[t]++;
            h>>=1;
            t++;
        }
    }
    for (int i=0;i<=5100;i++){
        if (sum[i]>=2){
            int temp=sum[i],p=i;
            sum[i]=0;
            while (temp){
                if (temp&1) sum[p]++;
                temp>>=1;
                p++;
            }
        }
    }

    int ans=0;
    for (int i=0;i<=5100;i++){
        if (q[i].size()<sum[i]){
            std::cout<<"-1\n";
            return;
        }

        for (int j=1;j<=sum[i];j++){
            ans+=q[i].top();
            q[i].pop();
        }
        while (q[i].size()>=2){
            int temp=q[i].top();
            q[i].pop();
            temp+=q[i].top();
            q[i].pop();
            q[i+1].push(temp);
        }
    }
    std::cout<<ans;
}

F
图论题，首先Floyed求出一个字母变成另一个字母的最小花费，然后对于两个不同的字母，暴力预处理出他们变成同样字母的最小花费。最后A串不动，枚举B串位置，求最小即可

可能有重边，输入时 d i s dis dis取最小

#include <bits/stdc++.h>
#define int long long
#define ull unsigned long long
constexpr int inf=1e16;
void yrzr(){
    int n,m;
    std::cin>>n>>m;
    std::vector<int> a(n),b(n);
    for (int i=0;i<n;i++){
        std::cin>>a[i];
    }
    for (int i=0;i<n;i++){
        std::cin>>b[i];
    }

    std::vector<std::vector<int>> dis(405,std::vector<int>(405,inf)),c(405,std::vector<int>(405,inf));
    for (int i=1;i<=m;i++){
        int x,y,z;
        std::cin>>x>>y>>z;
        dis[x][y]=std::min(dis[x][y],z);
    }

    for (int i=1;i<=400;i++){
        dis[i][i]=c[i][i]=0;
    }

    for (int k=1;k<=400;k++){
        for (int i=1;i<=400;i++){
            for (int j=1;j<=400;j++){
                dis[i][j]=std::min(dis[i][j],dis[i][k]+dis[k][j]);
            }
        }
    }


    for (int i=1;i<=400;i++){
        for (int j=1;j<=400;j++){
            for (int k=1;k<=400;k++){
                c[i][j]=std::min(c[i][j],dis[i][k]+dis[j][k]);
            }
        }
    }

    int ans=inf;
    for (int i=0;i<n;i++){
        int sum=0;
        bool ok=1;
        for (int j=0;j<n;j++){
            if (c[a[j]][b[(j+i)%n]]==inf){
                ok=0;
                break;
            }else{
                sum+=c[a[j]][b[(j+i)%n]];
            }
        }
        if (ok){
            ans=std::min(ans,sum);
        }
    }
    if (ans==inf){
        std::cout<<"-1\n";
    }else{
        std::cout<<ans<<"\n";
    }
}

I
数位dp，不知道省赛脑子犯了什么抽，受前几天一道数位dp，直接把状态数组压入map暴力记忆化的影响，想当然的觉得这题也是这么做，大哥直接提出时间复杂度是不够的。后面大哥们说是数位dp加个容斥。

补题的时候也一直在想数位dp+容斥，发现自己容斥不出来（容斥见识的得太少了），看了题解后发现只要一个数位dp就可以了

突然发现这题的思想其实跟前几天做的数位dp是一样的，甚至状态更简单，我们最重要的状态其实就只有当前位第几位，然后还要知道现在有多少个不同的数，这就足够了。因为对于这10个数字来说，后面的数字它只有两种身份，之前选了/没选，所以当前位相同，之前不同的数字个数相同，剩下的方案数就相同，就可以用记忆化。（赛时真的蠢傻了，这种套路思想学数位dp的时候见过很多了）

#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
constexpr ll mod=1e9+7;
ll f[200005][12][2][2];
int now[12];
void yrzr(){
    int n;
    std::cin>>n;
    std::vector<int> a(n+1),b(n+1);
    for (int i=1;i<=n;i++){
        char ch;
        std::cin>>ch;
        a[i]=ch-'0';
    }
    for (int i=1;i<=n;i++){
        char ch;
        std::cin>>ch;
        b[i]=ch-'0';
    }
    reverse(a.begin()+1,a.end());
    reverse(b.begin()+1,b.end());

    int A;
    std::cin>>A;
    std::function<ll(int,int,int,int)> dfs=[&](int len,int sum,int dif1,int dif2){
        if (len==0){
            return 1LL*(sum==A);
        }
        if (sum>A){
            return 0LL;
        }
        if (dif1&&dif2&&f[len][sum][dif1][dif2]){
            return f[len][sum][dif1][dif2];
        }

        int x=(dif1?0:a[len]),y=(dif2?9:b[len]);
        ll res=0;
        for (int i=x;i<=y;i++){
            if (now[i]){
                now[i]++;
                res=(res+dfs(len-1,sum,dif1|(a[len]!=i),dif2|(b[len]!=i)))%mod;
                now[i]--;
            }else{
                now[i]++;
                res=(res+dfs(len-1,sum+1,dif1|(a[len]!=i),dif2|(b[len]!=i)))%mod;
                now[i]--;
            }
        }
        if (dif1&&dif2) f[len][sum][dif1][dif2]=res;
        return res;
    };
    std::cout<<dfs(n,0,0,0);

}

J
分别枚举圆心在三个坐标轴，然后二分圆的半径，接下来考虑怎么check，对于一个点来说，我们去计算出它在球内时，圆心所在的区间,存下区间左右端点和权值（表示是左端点还是右端点），遍历一遍看是否有点满足题意即可

#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
constexpr int N=1e5+5;
int n;
ll x[N],y[N],z[N];
struct node{
    double pos;
    int val;
}a[N<<1];
bool check(double r){
    int cnt=0;
    for (int i=1;i<=n;i++){
        double res=r*r-y[i]*y[i]-z[i]*z[i];
        if (res<0) continue;
        res=sqrt(res);
        a[++cnt]={x[i]-res,1};
        a[++cnt]={x[i]+res,-1};
    }
    std::sort(a+1,a+1+cnt,[&](node i,node j){
        return i.pos<j.pos;
    });
    int sum=0;
    for (int i=1;i<=cnt;i++){
        sum+=a[i].val;
        if (sum>=n/2){
            return 1;
        }
    }

    cnt=0;
    for (int i=1;i<=n;i++){
        double res=r*r-x[i]*x[i]-z[i]*z[i];
        if (res<0) continue;
        res=sqrt(res);
        a[++cnt]={y[i]-res,1};
        a[++cnt]={y[i]+res,-1};
    }
    std::sort(a+1,a+1+cnt,[&](node i,node j){
        return i.pos<j.pos;
    });
    sum=0;
    for (int i=1;i<=cnt;i++){
        sum+=a[i].val;
        if (sum>=n/2){
            return 1;
        }
    }

    cnt=0;
    for (int i=1;i<=n;i++){
        double res=r*r-x[i]*x[i]-y[i]*y[i];
        if (res<0) continue;
        res=sqrt(res);
        a[++cnt]={z[i]-res,1};
        a[++cnt]={z[i]+res,-1};
    }
    std::sort(a+1,a+1+cnt,[&](node i,node j){
        return i.pos<j.pos;
    });
    sum=0;
    for (int i=1;i<=cnt;i++){
        sum+=a[i].val;
        if (sum>=n/2){
            return 1;
        }
    }

    return 0;
}
void yrzr(){
    std::cin>>n;
    for (int i=1;i<=n;i++){
        std::cin>>x[i]>>y[i]>>z[i];
    }

    double l=0,r=1e6;
    for (int i=0;i<=50;i++){
        double mid=(l+r)/2;
        if (check(mid)){
            r=mid;
        }else{
            l=mid;
        }
    }
    std::cout<<std::fixed<<std::setprecision(7)<<l;
}

K
补的时候相成状压了，然后状压+矩阵加速？？？，发现不会写
然后看了题解知道是容斥了，所以以后对于这种小数据除了状压也有可能是容斥

想到容斥就很好做了，每次直接暴力二进制枚举哪些城市不去，在转移的矩阵和答案矩阵上去掉那些转移点，然后dp矩阵加速即可

#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
constexpr ll mod=1e9+9;
constexpr int N=25;
struct Matrix{
    int lenn,lenm;
    ll a[N][N];
    Matrix() {memset(a,0,sizeof(a));}
 
    Matrix operator*(const Matrix &b)const{
        if (lenm==b.lenn){
            Matrix res;
            res.lenn=lenn;
            res.lenm=b.lenm;
            for (int i=1;i<=lenn;i++){
                for (int j=1;j<=b.lenm;j++){
                    for (int l=1;l<=lenm;l++){
                        res.a[i][j]=(res.a[i][j]+a[i][l]*b.a[l][j]%mod)%mod;
                    }
                }
            }
            return res;
        }
    }

    Matrix operator+(const Matrix &b)const{
        if (lenn==b.lenn&&lenm==b.lenm){
            Matrix res;
            res.lenn=lenn;
            res.lenm=lenm;
            for (int i=1;i<=lenn;i++){
                for (int j=1;j<=lenm;j++){
                    res.a[i][j]=a[i][j]+b.a[i][j];
                }
            }
            return res;
        }
    }

    Matrix operator-(const Matrix &b)const{
        if (lenn==b.lenn&&lenm==b.lenm){
            Matrix res;
            res.lenn=lenn;
            res.lenm=lenm;
            for (int i=1;i<=lenn;i++){
                for (int j=1;j<=lenm;j++){
                    res.a[i][j]=a[i][j]-b.a[i][j];
                }
            }
            return res;
        }
    }

};
int s[10],n,m,k,d;
int a[25][25];
ll solve(int mask){
    Matrix e,f,ans;
    ans.lenn=1;
    ans.lenm=f.lenn=f.lenm=e.lenn=e.lenm=n;
    std::vector<int> vis(n+1);
    
    for (int i=1;i<=n;i++){
        for (int j=1;j<=n;j++){
            e.a[i][j]=a[i][j];
        }
        f.a[i][i]=1;
        ans.a[1][i]=1;
    }
    
    for (int i=1;i<=k;i++){
        if (mask&(1<<(i-1))){
            int x=s[i];
            for (int j=1;j<=n;j++){
                e.a[x][j]=e.a[j][x]=0;
            }
            vis[x]=1;
            ans.a[1][x]=0;
        }
    }

    int temp=d;
    while (temp){
        if (temp&1) f=f*e;
        e=e*e;
        temp>>=1;
    }
    ans=ans*f;
    ll sum=0;
    for (int i=1;i<=n;i++){
        if (vis[i]) continue;
        sum=(sum+ans.a[1][i])%mod;
    }
    return sum;
}
void yrzr(){
    std::cin>>n>>m>>k>>d;
    d--;
    for (int i=1;i<=k;i++){
        std::cin>>s[i];
    }
    for (int i=1;i<=m;i++){
        int x,y;
        std::cin>>x>>y;
        a[x][y]=a[y][x]=1;
    }
    ll ans=0;
    for (int i=0;i<(1<<k);i++){
        if (__builtin_popcount(i)&1){
            ans=(ans-solve(i)+mod)%mod;
        }else{
            ans=(ans+solve(i))%mod;
        }
    }
    std::cout<<ans;
}
_fairyland
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ICPC2023 西安区域赛 题解.pdf
11-09
ICPC2023 西安区域赛 题解 本文档提供了 ICPC2023 西安区域赛的题解，涵盖了五个题目：A - An Easy Geometry Problem、B - Counting Multisets、C - Counting Strings、D - Deep Intervals 和 E - Dominating Point...
蓝桥杯C++省赛真题题解
04-12
蓝桥杯c 蓝桥杯C++省赛真题题解是一本旨在帮助参赛者深入理解和掌握C++编程语言及其在解决实际问题中的应用的宝贵资料。通过题解，参赛者不仅可以学习到题目的正确解法，更能够从中掌握解题的思路和方法，提高自己的...
2023CCPC女生赛 女生专场题解 ABFGHKL（更新至7题）
weixin_61652616的博客
10-24 784
可知目标点必定在中点左侧，使 $ R = \frac{L+R}{2}$ ，再次询问。分别二分求解，设左边界为 $L = -1000 $ ，右边界为 $R = 1000 $ ，初始时固定。边暴力上跳到这个字符串的最大后缀处，导致了很多重复计算，如果数据够强，这种做法复杂度会被卡到。场上没有看出来能量是属于每个宝可梦的，而不是属于双方角色的，又喜提3发罚时，乐。场上读假题一次，判断非法错了若干次，到最后一小时才通过，令人感叹。中匹配，因此，需要构建AC自动机进行多模匹配。，再次询问，否则可能导致死循环。
2023湖南省第十九届大学生计算机程序设计竞赛 ---hard math
qq_74377549的博客
03-21 403
题目要求的区间是[L,R]，而 ans2-ans1 表示的是区间[L+1,R]，所以我们要再特判一下L,这样就满足题意了。题目中的f(x) 表示 数字x中非重复的位数，例如f(10112)=3 ，非重复的位数分别是 1，0，2共3个。注意到题给的L，R非常大，可能有200000位数！不懂数位dp的可以先去自行了解一下。[0,L] 满足题意的答案记为 ans1。[0,R] 满足题意的答案记为 ans2。所以我们要用2个数组去分别记录L，R。这样答案为 ans2-ans1。很明显这是一道数位dp题。
南京 ccpc邀请赛 一记【补】
qq_37206717的博客
08-30 422
5.5之前我们队我来安排   湖南和南京   果断选南京   然后就是车票酒店什么的预定   还是有点烦的  琐事什么的   但是比较激动   因为这是我大学参加的第一场竞赛（也是人生中信息学的第一场）   学长也推荐了一家酒店   然后就定那家了（后来发现定错了 空间好小 被队友鄙视了好久 手动/捂脸 ）   5.5 早上6点多就爬起来去赶动车了   发现598a原来要做这么久的 然后就是一
【游记】NOIP-2018翻车记
测试运算符
11-06 1639
凑省一人头的退役选手最后一场考试
2020CCPC网络赛题解.pdf
07-12
2020CCPC网络赛题解
2018ACM江苏省邀请赛题解+std
09-25
《2018 ACM江苏省邀请赛题解+std》是一份珍贵的资源，它记录了2018年在北京邮电大学 张恺晨（JSZKC）主持下的江苏省ACM邀请赛的比赛题目解析和标准答案。对于参与或研究ACM（国际大学生程序设计竞赛，International ...
2023蓝桥杯C++A组省赛真题
04-09
在2023年的第十四届蓝桥杯C++A组省赛中，参赛者需在4小时内完成若干道题目，包括结果填空和程序设计两大题型。结果填空题要求参赛者直接填写计算结果，而程序设计题则需要编写能够处理各种输入并产生正确输出的C++...
【18】输出字符菱形
2301_78786609的博客
07-19 184
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
m0_61862494的博客
07-19 96
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 159
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
树与二叉树
2201_76027754的博客
07-15 790
树和二叉树
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 119
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 128
完全二叉树的节点个数-递归
【算法】算法模板
qq_44765647的博客
07-19 148
LeetCode网站中学习算法的过程中使用到并总结的算法模板算法模板 数组算法模板，字符串算法模板，列表算法模板，数学算法模板，树算法模板，图算法模板，动态规划算法模板
力扣第十八题——四数之和
m0_74932528的博客
07-19 290
该代码通过排序、剪枝和双指针法，有效地解决了四数之和问题，时间复杂度从暴力解法的 O(n^4) 降低到 O(n^3)。
C语言习题~day32
TU^的博客
07-19 177
第一次循环，i 从 7 减 3 变为 4，j 加 1 变为 1；第二次循环，i 变为 1，j 变为 2；第三次循环，i 变为 253（7 减 3 溢出后变为 253），j 加 1 变为 3；第四次循环，i 变为 250，j 加 1 变为 4；第五次循环，i 变为 247，j 加 1 变为 5；依次类推，直到 i 变为 0 时，循环结束。从 7 开始每次减 3，7、4、1、253、250、247……输入：[9,6,4,2,3,5,7,0,1]无符号字符型的取值范围是 0 到 255。输入：[3,0,1]
湖南省省界线shp图层
12-25
湖南省省界线shp图层是用来展示湖南省与周边省份的界线和位置的地理信息系统数据图层。这个图层包含了湖南省与其相邻省份（包括广东、广西、贵州、江西和湖北）的边界线信息，以及省界线的地理坐标和属性数据。 这个shp图层可以用于地图制作、空间分析和地理信息系统应用中。通过这个图层，可以清晰地展示湖南省和其周边省份的地理位置和相对位置，方便进行地理信息的展示和分析。比如在地图制作中，可以直观地展示湖南省与周边省份的地理位置关系；在空间分析中，可以利用这个图层进行省界线的交叉分析和空间关系的研究；在地理信息系统应用中，可以用这个图层作为基础数据进行各种地理信息的查询和分析。 总之，湖南省省界线shp图层是一个重要的地理信息系统数据，可以为地图制作、空间分析和地理信息系统应用提供必要的地理信息。这对于地理研究、城市规划、资源管理等领域都具有重要的意义和应用价值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值