蓝桥杯备战刷题two（自用）

1.杨辉三角形 

#include<iostream>
using namespace std;
#define ll long long
const int N=2e5+10;
int a[N];
//1 0 0 0 0 0 0
//1 1 0 0 0 0 0
//1 2 1 0 0 0 0
//1 3 3 1 0 0 0
//1 4 6 4 1 0 0
//1 5 10 10 5 1
//前缀和思想
//第一列全为1,第二列为从0开始递增1的序列,
//可以发现当前列为前面一列的前缀和序列
//N最大是1e9,第三列计算n*(n+1)/2>1e9得到n>44721
//又第三列前面有两个0,即最小需要44721+2=44723行
//当第三列的值已经大于1e9时,不需要再计算后面的数,
//直接根据第二列规律,找第二列中n的位置即可。
//由于第二列是从0开始的,此时可以确定n是在第n+1行,
//又因为是第二列，所以n的是数列中第n∗(n+1)/2+2个。
int main()
{
   int n;
   cin>>n;
   a[0]=1;
   int k=1;
   if(n==1)cout<<1<<endl;
   else
   {
    for(int i=1;i<44725;i++)//枚举行
    {
        for(int j=i;j>=1;j--)//从后往前（前缀和）
        {
            a[j]+=a[j-1];
            if(a[j]==n){
                cout<<k+i-j+1<<endl;
                return 0;
            }
        }
        k+=(i+1);
    }
    cout<<(1+n)*n/2+2<<endl;
   }
    return 0;
}

2.迷宫

#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
#define pii pair<int,int>
#define x first
#define y second
string ss[31]={
"                                                   ",
" 01010101001011001001010110010110100100001000101010",
" 00001000100000101010010000100000001001100110100101",
" 01111011010010001000001101001011100011000000010000",
" 01000000001010100011010000101000001010101011001011",
" 00011111000000101000010010100010100000101100000000",
" 11001000110101000010101100011010011010101011110111",
" 00011011010101001001001010000001000101001110000000",
" 10100000101000100110101010111110011000010000111010",
" 00111000001010100001100010000001000101001100001001",
" 11000110100001110010001001010101010101010001101000",
" 00010000100100000101001010101110100010101010000101",
" 11100100101001001000010000010101010100100100010100",
" 00000010000000101011001111010001100000101010100011",
" 10101010011100001000011000010110011110110100001000",
" 10101010100001101010100101000010100000111011101001",
" 10000000101100010000101100101101001011100000000100",
" 10101001000000010100100001000100000100011110101001",
" 00101001010101101001010100011010101101110000110101",
" 11001010000100001100000010100101000001000111000010",
" 00001000110000110101101000000100101001001000011101",
" 10100101000101000000001110110010110101101010100001",
" 00101000010000110101010000100010001001000100010101",
" 10100001000110010001000010101001010101011111010010",
" 00000100101000000110010100101001000001000000000010",
" 11010000001001110111001001000011101001011011101000",
" 00000110100010001000100000001000011101000000110011",
" 10101000101000100010001111100010101001010000001000",
" 10000010100101001010110000000100101010001011101000",
" 00111100001000010000000110111000000001000000001011",
" 10000001100111010111010001000110111010101101111000"
  };
struct Ch{
    char ch;
    pii per;
};
Ch mp[40][60];
bool vis[40][60];
int fx[] = {1,0,0,-1};
int fy[] = {0,-1,1,0};
void bfs(int x,int y)
{
    queue<pii> q;
    q.push({x,y});
    vis[x][y] = true;
    while(!q.empty())
    {
        pii temp = q.front();
        for(int i = 0;i < 4;i++)
        {
            pii t ={temp.x + fx[i],temp.y + fy[i]};
            if(mp[t.x][t.y].ch == '0' && vis[t.x][t.y] == false)
            {
                mp[t.x][t.y].per = temp;
                vis[t.x][t.y] = true;
                q.push(t);
            }
        }
        q.pop();
    }
}
int main()
{
  string s;
    for(int i = 1;i <= 30;i++)
    {
        for(int j = 1;j <= 50;j++)
        {
            mp[i][j].ch = ss[i][j];
        }
    }
    bfs(1,1);
    pii t = {30,50};
    while(t.x != 1 || t.y != 1)
    {
        int x = t.x - mp[t.x][t.y].per.x;
        int y = t.y - mp[t.x][t.y].per.y;
        int flag;
        for(int i = 0;i < 4;i++)
        {
            if(x == fx[i] && y == fy[i])
            {
                flag = i;
                break;
            }
        }
        switch(flag)
        {
        case 0:
            s += 'D';
            break;
        case 1:
            s += 'L';
            break;
        case 2:
            s += 'R';
            break;
        case 3:
            s += 'U';
            break;
        }
        t = mp[t.x][t.y].per;
    }
    for(int i = s.size() - 1;i >= 0;i--)
    {
        cout << s[i];
    }
    return 0;
}
//Ch记录这个结点的值和前驱结点的坐标,以便记录路径
//字典序最小的方向数组 - DLRU - 最优性剪枝
//求最短路使用BFS
//从终点开始遍历每个结点的前驱结点，直到起点结束，当两个坐标都为1的时候，循环结束
//当前结点减去前驱结点得到的值对应的就是前驱节点移动的方向
//使用switch来进行方向判断，加入答案，最后答案要进行逆序输出

 3.潜伏者

#include <iostream>
#include <map>
using namespace std;
int check[26];
int notwell[26];
int main()
{
  string secret;
  string origin;
  string need;
  cin>>secret>>origin>>need;
  map<char,int>ohp;
  map<char,int>shp;
  bool ok=1;
  for(int i=0;i<origin.size();i++)
  {
    check[origin[i]-'A']=1;
    if(!ohp[origin[i]])ohp[origin[i]]=secret[i],shp[secret[i]]=origin[i];
    else 
    {
      if(ohp[origin[i]]!=secret[i])
      notwell[origin[i]-'A']=1;
    }
  }
  for(int i=0;i<26;i++)
  {
    if(check[i]==0)
    {
      ok=0;
      break;
    }
  }
  string ans;
  for(int i=0;i<need.size();i++)
  {
    if(!shp[need[i]]||notwell[need[i]-'A'])
    {
      ok=0;
      break;
    }
    else ans+=(char)shp[need[i]];
  }
  if(!ok)cout<<"Failed"<<endl;
  else cout<<ans<<endl;
  return 0;
}

 4.灭鼠先锋

#include <iostream>
using namespace std;
//下第二行
//0000
//第一个人：XX00      X000
//第二个人：XXX0      XXX0
//第一个人：XXXX(输)  XXXX
//无论第一个人下一个还是两个，第二个人都会让它输
//即谁下满第一行，谁就赢
//换言之，谁开始下第二行，谁就输
int main()
{
  cout<<"LLLV"<<endl;
  return 0;
}

5.求和

#include <iostream>
using namespace std;
const int N=2e5+5;
#define ll long long
int n;
int a[N];
//a1 a2 a3 a4 a5 .. an
//a1*(a2+a3+...+an)+a2*(a3+a4+...+an)+a3*(a4+a5+...an)+an-1*an
//后缀和
ll suf[N];
int main()
{
  cin>>n;
  for(int i=1;i<=n;i++)
  {
    cin>>a[i];
    suf[i]=a[i];
  }
  for(int i=n-1;i>=1;i--)
  {
    suf[i]+=suf[i+1];
  }
  ll ans=0;
  for(int i=1;i<=n-1;i++)
  {
    ans+=(a[i]*suf[i+1]);
  }
  cout<<ans<<endl;
  return 0;
}

 6.爬树的甲壳虫

 

#include <iostream>
using namespace std;
#define ll long long
const int p=998244353; 
const int N=1e5+10;
ll E[N];
ll qmi(int a,int k,int p)//a^k%p
{
  ll res=1;
  while(k)
  {
    if(k&1)res=(ll)res*a%p;
    k>>=1;
    a=(ll)a*a%p;
  }
  return res;
}
//E[n]=E[n-1]+(1-P[n])*1+P[n]*(E[n]+1);
//E[n]=(E[n-1]+1)/(1-P[n])
//对到每层高度的期望，使用对前面的进行累加，以保证可以到达第n层了
//以第n层为例，在第n-1层有（1-P[n]）的概率成功再乘以时间1s则为成功期望时间
//在第n-1层有P[n]的概率失败则P[n]*(E[n]+1)即失败概率乘以从头再爬到n和掉下去的1s则为失败期望时间
int main()
{
  int n;
  cin>>n;
  for(int i=1;i<=n;i++)
  {
    int x,y;
    cin>>x>>y;
    E[i]=((E[i-1]+1)%p*(y%p))%p;
		E[i]*=qmi(y-x,p-2,p);	
		E[i]%=p;
  }
  cout<<E[n]<<endl;
  return 0;
}

 7.数的拆分

 

#include <iostream>
#include <cmath>
using namespace std;
#define ll long long
//如果能拆一定有以下的方式构造
//设p1和p2为素数或者其中一个为1
//n = p1^n1 * p2^n2
//n1和n2肯定可以被分解为=2+X或者=3+X
//即先判断此数是不是平方数或者立方数
//如果都不是则接着找质因子,若出现质因子的指数只有1,则肯定不行
//a最大是1e18,质因子找到4000即可
bool flag;
bool cubic(ll n)
{
    ll x = pow(n, 1.0 / 3);
    while (x * x * x <= n)//一定要使用while
    {
        if (x * x * x == n)return true;
        ++x;
    }
    return false;
}
bool square(ll n)
{
    ll x = sqrt(n);
    while (x * x <= n)//一定要使用while
    {
        if (x * x == n)return true;
        ++x;
    }
    return false;
}
int prime[2000];
int idx;
void Prime()
{
    int st[4005] = { 0 };
    for (int i = 2; i <= 4000; ++i)
        if (!st[i])
            for (int j = 2 * i; j <= 4000; j += i)
                st[j] = 1;
    for (int i = 2; i <= 4000; ++i)
        if (!st[i])
            prime[idx++] = i;
    
}
ll num[100050];
int t;
int main()
{
    Prime();
    scanf("%d", &t);
    for (int i = 0; i < t; ++i)scanf("%lld", num + i);
    for (int i = 0; i < t; ++i)
    {
        ll x = num[i];
        if (cubic(x) ||square(x))
        {
            printf("yes\n");
            continue;
        }
        flag = true;
        
        for (int j = 0; j < idx; ++j)
        {
            int s = 0;
            while (x % prime[j] == 0)
            {
                x /= prime[j];
                ++s;
            }
            if (s == 1)
            {
                flag = false;
                break;
            }
        }
        if (flag && (cubic(x) || square(x)))
            printf("yes\n");
        else
            printf("no\n");
    }
    return 0;
}

 

8.推导部分和

 

#include <iostream>
using namespace std;
#define ll long long
int n,m,q;
//并查集
int p[200000+10];
ll d[200000+10];
//以一个根结点为参照，l-1到根结点的距离为d[l-1] r到根结点的距离为d[r]
//根据前缀和原理 [l, r] 区间和为 d[r] - d[l - 1]
int find(int x)
{
  if(x!=p[x])
  {
    int t=p[x];
    p[x]=find(p[x]);
    d[x]+=d[t];
  }
  return p[x];
}
int main()
{
  scanf("%d %d %d",&n,&m,&q);
  //初始化并查集
  for(int i=1;i<=n;i++)p[i]=i;
  for(int i=1;i<=m;i++)
  {
    int l,r;
    ll s;
    scanf("%d %d %lld",&l,&r,&s);
    int pl=find(l-1),pr=find(r);
    p[pl]=pr;
    d[pl]=d[r]-d[l-1]-s;
  }
  for(int i=1;i<=q;i++)
  {
    int l,r;
    scanf("%d %d",&l,&r);
    int pl=find(l-1),pr=find(r);
    if(pl==pr)
    {
      printf("%lld\n",d[r]-d[l-1]);
    }
    else
    {
      printf("UNKNOWN\n");
    }
  }
  return 0;
}

 （参考代码来自lanqiao1533688980）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/423634.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

win安装卸载python3.13

win安装卸载python3.13

一、安装 访问python官网&#xff1a;https://www.python.org/ 点击“Downloads” 点击“Windows” 找到自己要下载的版本和位数&#xff0c;比如我这个是3.13版本、64位的安装包 下载好了之后&#xff0c;双击安装包 勾选“Add python.exe to PATH”&#xff1a;把python环…
阅读更多...
免费插件集-illustrator插件-Ai插件-雷达图-图表自动绘制

免费插件集-illustrator插件-Ai插件-雷达图-图表自动绘制

文章目录 1.介绍2.安装3.通过窗口>扩展>知了插件4.功能解释5.示例6.总结 1.介绍 本文介绍一款免费插件&#xff0c;加强illustrator使用人员工作效率&#xff0c;进行绘制雷达图。首先从下载网址下载这款插件 https://download.csdn.net/download/m0_67316550/87890501&…
阅读更多...
Revit-二开之创建线性尺寸标注-(5)

Revit-二开之创建线性尺寸标注-(5)

创建线性尺寸标注 对应的Revit界面的按钮 线性尺寸标注源码 本篇文章实现的逻辑是从rvt文章中拾取一面墙，然后对墙添加再水平方向上的线性尺寸标注 protected override Result OnExecute(ExternalCommandData commandData, ref string message, ElementSet elements
阅读更多...
MySQL基础-----SQL语句之DDL语句

MySQL基础-----SQL语句之DDL语句

目录 前言 开启登录数据库 一、数据库操作 1.查询所有数据库 2.切换使用数据库 3.查询当前使用的数据库 4.创建数据库 创建一个hello数据库, 使用数据库默认的字符集。 创建一个itheima数据库&#xff0c;并且指定字符集 5.删除数据库 二、表操作 1.查询当前数据库所有…
阅读更多...
UE5中实现后处理深度描边

UE5中实现后处理深度描边

后处理深度描边可以通过取得边缘深度变化大的区域进行描边&#xff0c;一方面可以用来做角色的等距内描边&#xff0c;避免了菲尼尔边缘光不整齐的问题&#xff0c;另一方面可以结合场景扫描等特效使用&#xff0c;达到更丰富的效果&#xff1a; 后来解决了开启TAA十字线和锯齿…
阅读更多...
基于ssm江苏融汇房地产营销策划有限公司的宣传网站

基于ssm江苏融汇房地产营销策划有限公司的宣传网站

目 录 目 录 I 摘 要 III ABSTRACT IV 1 绪论 1 1.1 课题背景 1 1.2 研究现状 1 1.3 研究内容 2 2 系统开发环境 3 2.1 vue技术 3 2.2 JAVA技术 3 2.3 MYSQL数据库 3 2.4 B/S结构 4 2.5 SSM框架技术 4 3 系统分析 5 3.1 可行性分析 5 3.1.1 技术可行性 5 3.1.2 操作可行性 5 3…
阅读更多...
c# 获取源码路径与当前程序所在路径

c# 获取源码路径与当前程序所在路径

获取源码路径 private static string GetFilePath([CallerFilePath] string path null) {return path;}//当程序所在路径string str67 System.Environment.CurrentDirectory;//源码路径 var path GetFilePath();var directory Path.GetDirectoryName(path);参考
阅读更多...
彻底搞懂回溯算法（例题详解）

彻底搞懂回溯算法（例题详解）

目录 什么是回溯算法&#xff1a; 子集问题&#xff1a; 子集问题II(元素可重复但不可复选): 组合问题&#xff1a; 组合问题II(元素可重复但不可复选): 排列问题&#xff1a; 排列问题II(元素可重复但不可复选): 什么是回溯算法&#xff1a; 「回溯是递归的副产品&…
阅读更多...
嵌入式学习31-指针和函数知识回顾

嵌入式学习31-指针和函数知识回顾

1.指针&#xff1a; 1.提供一种间接访问数据的方法 2.空间没有名字,只有一个地址编号 2.指针: 1.地址:区分不同内存空间的编号 2.指针:指针就是地址,地址就是指针 3.指针变量:存放指针的变量称为指针变量,简称为指针 3.指针的定义: int *p NULL; …
阅读更多...
Github 2024-02-26 开源项目日报Top10

Github 2024-02-26 开源项目日报Top10

根据Github Trendings的统计&#xff0c;今日(2024-02-26统计)共有10个项目上榜。根据开发语言中项目的数量&#xff0c;汇总情况如下&#xff1a; 开发语言项目数量Python项目4C项目1Go项目1TypeScript项目1HTML项目1Jupyter Notebook项目1Rust项目1Shell项目1JavaScript项目…
阅读更多...
keil MDK安装armcc V5编译器

keil MDK安装armcc V5编译器

不知道从什么时候开始&#xff0c;Keil MDK默认不支持V5的编译器了&#xff0c;里面默认只有V6的编译器&#xff0c;设置界面跟V5有很大的差异不太熟悉。最可怕的是&#xff0c;之前使用V5编译的工程&#xff0c;换成V6编译器后居然报错...虽然修改一下应该也可以正常编译&…
阅读更多...
IOS 发布遇到“Unable to authenticate with App Store Connect”错误咋解决？

IOS 发布遇到“Unable to authenticate with App Store Connect”错误咋解决？

问题&#xff1a; 在开发ios app后&#xff0c;先发布adhoc版本&#xff0c;测试通过后&#xff0c;再发布testflight版本测试&#xff0c;但是可能会遇到一下问题。 解决办法&#xff1a; 在Signing &Capabilities中&#xff0c;在ios下边要指定有发布权限的Team账号&a…
阅读更多...
30-k8s集群的七层代理-ingress资源（进阶知识）

30-k8s集群的七层代理-ingress资源（进阶知识）

一、ingress概述 1&#xff0c;引发问题 目前使用svc资源做网络暴露&#xff0c;使用nodeport类型&#xff0c;一个业务对应一个宿主机端口&#xff0c;那么如果业务多了&#xff0c;所占用的宿主机端口也就多了&#xff0c;虽然说宿主机端口一般情况下都是够用的&#xff0c;…
阅读更多...
《YOLOv9：从入门到实战》报错解决 专栏答疑

《YOLOv9：从入门到实战》报错解决 专栏答疑

前言&#xff1a;Hello大家好&#xff0c;我是小哥谈。《YOLOv9&#xff1a;从入门到实战》专栏上线后&#xff0c;部分同学在学习过程中提出了一些问题&#xff0c;笔者相信这些问题其他同学也有可能遇到。为了让大家可以更好地学习本专栏内容&#xff0c;笔者特意推出了该篇专…
阅读更多...
1、Linux-安装

1、Linux-安装

一、Linux和Windows的一些区别 1、Linux严格区分大小写——【Windows创建文件夹时不区分大小写】 2、Linux中所有内容都以文件形式存储&#xff0c;包括硬件 3、Linux不靠拓展名区分文件类型&#xff0c;而是可以通过读取文件开头的一些字节来区分。 但是在实际使用中一般要…
阅读更多...
《CrackCollect》

《CrackCollect》

CrackCollect 类型&#xff1a;益智学习 视角&#xff1a;2d 乐趣点&#xff1a;趣味化英语学习&#xff0c;闯关增加学习动力 时间&#xff1a;2019 个人职责&#xff1a; 1、所有功能的策划讨论 2、所有开发工作 3、所有上架工作 此游戏旨在针对英语水平处于初级阶段的人&…
阅读更多...
【Pytorch】论文复现 Vision Transformer (ViT)

【Pytorch】论文复现 Vision Transformer (ViT)

文章目录 0. 进行设置1. 获取数据2. 创建Dataset和DataLoader3. 复现 ViT 论文&#xff1a;概述4. Equation 1: 将数据拆分为 patch 并创建类、位置和 patch 嵌入5. Equation 2: Multi-Head Attention (MSA)6. Equation 3: Multilayer Perceptron (MLP)7. 创建 Transformer 编码…
阅读更多...
简单的生活案例解释：关系图卷积网络（RGCN）

简单的生活案例解释：关系图卷积网络（RGCN）

目录 1、用一个简单的生活案例来解释关系图卷积网络（RGCN）2、RGCN与FB15K-237文件格式详情数据集构成结合RGCN和FB15K-237参考文献1、用一个简单的生活案例来解释关系图卷积网络（RGCN） 假设你是一名社交媒体平台的工程师，你的任务是分析用户之间的关系，以便为他们推荐更…
阅读更多...
C++_AVL树

C++_AVL树

目录 1、AVL的概念 2、平衡因子的调整概念 3、AVL树的插入 3.1 调整平衡因子代码实现 3.2 右旋操作 3.2 左旋操作 3.3 双旋-先右旋再左旋 3.4 双旋-先左旋再右旋 3.5 旋转操作的小结 4、AVL的验证与实现 结语 前言&#xff1a; 在C中&#xff0c;AVL树是在二叉搜索…
阅读更多...
《最新出炉》系列初窥篇-Python+Playwright自动化测试-34-处理https 安全问题或者非信任站点-下篇

《最新出炉》系列初窥篇-Python+Playwright自动化测试-34-处理https 安全问题或者非信任站点-下篇

1.简介 这一篇宏哥主要介绍playwright如何在IE、Chrome和Firefox三个浏览器上处理不信任证书的情况&#xff0c;我们知道&#xff0c;有些网站打开是弹窗&#xff0c;SSL证书不可信任&#xff0c;但是你可以点击高级选项&#xff0c;继续打开不安全的链接。举例来说&#xff0c…
阅读更多...
最新文章

Copyright @ 2022~2023