第一天2233

最新推荐文章于 2026-01-02 10:17:02 发布
原创 最新推荐文章于 2026-01-02 10:17:02 发布 · 138 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #图论 #动态规划

1.进制转换

2.顺子日期
在这里插入图片描述
3.刷题统计
在这里插入图片描述

#include<iostream>
using namespace std;
#define ll long long
int main()
{
    ll a, b, n;
    cin >> a >> b >> n;
    ll week = a * 5 + b * 2;
    ll ans = n / week * 7;
    n %= week;
    for (int i = 1; i <= 5; i++)
    {
        if (n > 0)
            n -= a, ans++;
    }
    for (int i = 1; i <= 2; i++)
    {
        if (n > 0)
            n -= b, ans++;
    }
    cout << ans << endl;
    //system("pause");
    return 0;
}

4.修剪灌木
在这里插入图片描述

#include<iostream>
using namespace std;
int main()
{
    int n;
    cin >> n;
    int t = n * 2 - 2;
    for (int i = 1; i <= n / 2; i++)
    {
        cout << t << endl;
        t -= 2;
    }
    if ((n & 1) == 0)
        t += 2;
    for (int i = n / 2 + 1; i <= n; i++)
    {
        cout << t << endl;
        t += 2;
    }
    //system("pause");
    return 0;
}

5.X进制减法在这里插入图片描述

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
const int N = 1e6 + 7;
const int mod = 1000000007;
int n, m;
int a[N], b[N];

int main()
{
    scanf("%d%d", &n, &n);
    for (int i = n; i; i--)
        scanf("%d", a + i);
    scanf("%d", &m);
    for (int i = m; i; i--)
        scanf("%d", b + i);
    long long ans = 0;
    for (int i = n; i; i--)
    {
        ans = ans * max(2, max(a[i] + 1, b[i] + 1)) % mod;
        ans = ((ans + a[i] - b[i]) % mod + mod) % mod;
    }
    printf("%lld\n", ans);
    //system("pause");
    return 0;
}

6.统计子矩阵
在这里插入图片描述

#include <iostream>
#include <cstdio>
using namespace std;
const int N = 500 + 7;

int n, m;
int k;
int a[N][N];
int s[N][N];
signed main()
{
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            scanf("%d", &a[i][j]);
            s[i][j] = s[i - 1][j] + a[i][j];
        }
    }
    long long ans = 0;
    for (int i = 1; i <= n; i++)
    {
        for (int j = i; j <= n; j++)
        {
            for (int l = 1, r = 1, sum = 0; r <= m; r++)
            {
                sum += s[j][r] - s[i - 1][r];
                while (sum > k)
                    sum -= s[j][l] - s[i - 1][l++];
                ans += r - l + 1;
            }
        }
    }
    printf("%lld\n", ans);
    //system("pause");
    return 0;
}

思路：枚举 起始行 和 行数 ，然后遍历列，得到了一个长度为 m 的一维的数组，在这个数组中用双指针优化。

7.积木画
在这里插入图片描述

//状压DP
#include<iostream>
using namespace std;
const int mod = 1e9 + 10;
int n;
long long dp[2][4], l, now = 1;
int main()
{
    cin >> n;
    dp[l][3] = 2;
    dp[l][0] = dp[l][1] = dp[l][2] = 1;
    while (--n)
    {
        dp[now][0] = dp[l][3];
        dp[now][1] = (dp[l][0] + dp[l][2]) % mod;
        dp[now][2] = (dp[l][0] + dp[l][1]) % mod;
        dp[now][3] = (dp[l][0] + dp[l][2] + dp[l][1] + dp[l][3]) % mod;
        swap(l, now);
    }
    cout << dp[l][0] << endl;
    //system("pause");
    return 0;
}

思路：
状压：
dp[now][0]代表当前列刚好填满
dp[ now ][1]代表当前列填满并向下一列突出了上面的一格
dp[now][2] 代表当前列填满并向下一列突出了下面的一格
dp[now][3] 代表当前列填满并向下一列突出两格。
dp[la]代表上一列

状态转移：
当前列填满：上一列填满并向下一列（当前列）填两格。
当前列填满并上凸一格：上一列填满加上上一列填满并下凸。
当前列填满并下凸一格：上一列填满加上上一列填满并上凸。
当前列填满并向下一列突出两格：所有情况相加。

8.扫雷
（可恶的卡常）

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <unordered_map>
using namespace std;
 
const int maxn=50010;
struct Node
{
    int x,y,r;
    int cnt;
 
    Node (int _x,int _y) : x(_x),y(_y){}
    Node (int _x,int _y,int _r) : x(_x),y(_y),r(_r){}
    Node (int _x,int _y,int _r,int _cnt) :x(_x),y(_y),r(_r),cnt(_cnt){}
    Node()=default;
    bool operator < (Node const & a) const
    {
        if(x!=a.x)
            return x<a.x;
        return y<a.y;
    }
}cir[maxn];
struct comp
{
    int operator()(const std::pair<int, int>& p) const {
        return p.first ^ p.second;  //返回值为bool，比较符为&，|都比这一个慢，
    }
};
typedef long long LL;
LL squ(int x)
{
    return (LL) x*x;
}
vector<int> adj[maxn];
unordered_map<pair<int,int> ,int,comp> ump;
bool vis[maxn]={false};
int n,m;
int dfs_Trave(int x,int y,int r);
int dfs(int index);
void add(int index);
int main()
{
    scanf("%d%d",&n,&m);
    int x,y,r;
    for(int i=1;i<=n;++i)
    {
        scanf("%d%d%d",&x,&y,&r);
        auto temp=ump[{x,y}];
        if(temp!=0)
        {
           cir[temp].r=max(cir[temp].r,r);
           cir[temp].cnt++;
        }
        else
        {
            cir[i]={x,y,r,1};   
            ump[{x,y}]=i;      
        }
    }
    sort(cir+1,cir+n+1);
 
    for(int i=1;i<=n;++i)
    {
        add(i);
    }
    int res=0;
    for(int i=0;i<m;++i)
    {
        scanf("%d%d%d",&x,&y,&r);
        res+=dfs_Trave(x,y,r);
    }
 
    printf("%d\n",res);
    system("pause");
    return 0;
}
 
void add(int index)
{
    for(int i=index-1;i>0;--i)
    {
        if(squ(cir[index].r)<squ(cir[i].x-cir[index].x))
            break;
        if(squ(cir[index].r)>=squ(cir[i].x-cir[index].x)+squ(cir[i].y-cir[index].y))
            adj[index].push_back(i);
    }
 
    for(int i=index+1;i<=n;++i)
    {
        if(squ(cir[index].r) < squ(cir[i].x-cir[index].x))
           break;
        if(squ(cir[index].r) >= squ(cir[i].x-cir[index].x)+squ(cir[i].y-cir[index].y))
            adj[index].push_back(i);
    }
}
 
int dfs(int index)
{
    int sum=cir[index].cnt;
    vis[index]=1;
    for(int i=0;i<adj[index].size();++i)
    {
        int v=adj[index][i];
        if(vis[v]==0)
            sum+=dfs(v);
    }
    return sum;
 
}
 
int dfs_Trave(int x,int y,int r)
{
    Node e1={x-r,y,r},e2={x+r,y,r};
    int l=lower_bound(cir+1,cir+n+1,e1)-cir;
    int ri=lower_bound(cir+1,cir+n+1,e2)-cir;
    l=min(l,n),ri=min(ri,n);
    int sum=0;
    for(int i=l;i<=ri;++i)
    {
        if(i==0)
            continue;
        if((squ(r)>=squ(cir[i].x-x)+squ(cir[i].y-y))&&vis[i]==0)
            sum+=dfs(i);
    }
    return sum;
}

思路：转换成有向图的遍历问题，（在爆炸范围内就建一条单边，遍历有向图，判断点上有没有雷），要用哈希。

9.李白打酒加强版
在这里插入图片描述

#include<iostream>
#include<cstdio>
using namespace std;
#define ll long long
const int mod = 1e9 + 7;
ll dp[110][110][110];
int t;
int main()
{
    cin>>t;
    while(t--){
        int n, m;
        scanf("%d%d", &n, &m);
        dp[n][m][2] = 1;
        for (int i = n; i >= 0; i--)
        {
            for (int j = m; j >= 0; j--)
            {
                for (int k = 0; k <= m; k++)
                {
                    if (i && k*2 <= m)
                        dp[i - 1][j][k*2] = (dp[i - 1][j][k*2] + dp[i][j][k]) % mod;
                    if (k && j)
                        dp[i][j - 1][k - 1] = (dp[i][j - 1][k - 1] + dp[i][j][k]) % mod;
                }
            }
        }
        printf("%lld\n", dp[0][1][1]);
        for(int i=0;i<110;i++)
            for(int j=0;j<110;j++)
                 for(int k=0;k<110;k++)
                    dp[i][j][k] = 0;
    }
    //system("pause");
    return 0;
}

思路：dp
状态表示：
dp[i][j][k]代表 有 i 家店没有遇到，j 朵花没有看，壶中有 k 斗酒的方案数.
转移方程：
if (i && k2 <= m)
dp[i - 1][j][k2] = (dp[i - 1][j][k*2] + dp[i][j][k]) % mod;
if (k && j)
dp[i][j - 1][k - 1] = (dp[i][j - 1][k - 1] + dp[i][j][k]) % mod;
10.砍竹子

在这里插入图片描述

#include<iostream>
#include<cmath>
#include<cstdio>
#include<vector>
using namespace std;
long long msq(long long x) // 手写开根
{
    long long  r = sqrt(x) + 10;
    for (long long  i = max(0ll, r - 20); i <= r; i++)
    {
        if (i * i > x)
            return i - 1;
    }
    return r - 10;
}
int main()
{
    int n;
    scanf("%d", &n);
    vector<long long> v[2];
    int now = 0, la = 1;
    long long  ans = 0;
    while (n--)
    {
        long long t;
        scanf("%lld", &t);
        v[now].clear();
        while (t > 1)
        {
            v[now].push_back(t);
            t = msq(t / 2 + 1);
        }
        ans += v[now].size();
        for (int i = 0; i < v[now].size(); i++)
        {
            for (int j = 0; j < v[la].size(); j++)
            {
                if (v[now][i] == v[la][j])
                {
                    ans -= v[now].size() - i;
                    goto g;
                }
            }
        }
    g:
        swap(now, la);
    }
    printf("%lld\n", ans);
    //system("pause");
    return 0;
}

思路：贪心，枚举
核心结论：使用魔法来砍所减少的次数就是每对相邻竹子的公共的路程 , 枚举每个相邻的竹子所到的点即可

夜辰沉
关注
100天精通Python（可视化篇）——第110天：Pyecharts绘制可视化大屏项目（附上完整源码）
努力让自己发光，对的人才能迎着光而来
12-11 7万+
100天精通Python（可视化篇）——第110天：Pyecharts绘制可视化大屏项目（附上完整源码）
平台总线第一天①
qq_26139997的博客
07-14 145
驱动层 #include <linux/init.h> #include <linux/module.h> #include <linux/platform_device.h> int led_pdrv_probe(struct platform_device *pdev)//匹配成功之后调用这个函数，默认传参匹配成功之后的pdev { struct resource * addr_res1, *addr_res2; struct resource * irq_re
平台总线第一天②
qq_26139997的博客
07-14 148
app代码： #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <stdlib.h> int main(void) { int fd; int on; fd = open("/dev/led_plat",O_RDWR);//led_palt在驱动层创建设备
平台总线第一天③
qq_26139997的博客
07-14 147
app代码： #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <stdlib.h> int main(void) { int fd; int on; fd = open("/dev/led_plat",O_RDWR); if(fd < 0) {
hcie第三天总结
qq_45964162的博客
01-14 245
从集线器到交换机跨越了两个阶段，实现软交换，通过内存的方式避免内存的冲突 进化到第三代，矩阵式交换机 mac表会实时同步cam表 mac表自学习叫动态表项，人工输入叫静态表项，黑洞表项相当于空接口（黑洞比拒绝快） 动态表项 由接口通过报文中的源mac地址先学习获得，表项可老化，默认老化时间为300秒。 在系统复位，接口板热插拔或接口复位后，动态表会消失 生成树的tc报文，初始化等会使得mac地址表老化 静态表项 由用户手工配置，并下发到各接口板，表项不可老化 在系统复位，接口板热插拔或接口复位后，以保存表项
C语言笔记第八天
szplzx1314的博客
09-08 221
强制类型转换 要求取一个字节后的两个字节(0x11223344,要取0x2233) #include <stdio.h> int main(int argc,char** argv) { int num = 0x11223344; //指针与变量建立链接 int* p = &num; //指针p强转成char*步长为一个字节,加一向前走一个字节 //强转成short*步长为两个字节 //最后在对其解引用,得到地址的内容 printf("%#x\n", *((sh
HCIE第三天总结
yangcx01的博客
07-12 533
HCIE 第三天总结 1.MAC地址表的组成 动态表项： 由接口通过报文中的源MAC地址学习获得,表项可者化,默认老化时间300秒。 在系统复位、接口板热插拔或接口板复位后,动态表项会丢失。 静态表项： 由用户手工配置,并下发到各接口板,表项不可老化。 在系统复位、接口板热插拔或接口板复位后,保存的表项不会丢失。 黑洞表项： 由用户手工配置,并下发到各接口板,表项不可老化。 配置黑洞MAC地址后,源MAC地址或目的MAC地址是该MAC的报文将会被丢弃。 配置黑洞表项的原因时比直接拒绝流量速度快 1.查看
20天 力扣 算法 刷题计划-第一天 二分查找
aiqq136的博客
09-17 480
算法 力扣 (LeetCode) 深度优先搜索 双指针 二分查找 在数学和计算机科学之中，算法是一个被定义好的、计算机可施行之指示的有限步骤或次序，常用于计算、数据处理和自动推理。作为一个有效方法，算法被用于计算函数，它包含了一系列定义清晰的指令，并可于有限的时间及空间内清楚的表述出来。 ...
python编程100+题1—10（第一天）
Jefferymeng的博客
03-16 1196
自学python提高编程能力（第一天） 以下为python编程100题，来自github，原文链接如下： https://github.com/zhiwehu/Python-programming-exercises/blob/master/100%2B%20Python%20challenging%20programming%20exercises.txt 完成这些题目的基础上，添加了自己理解的注释和出过的错误，请同样学习的朋友们指正！ QUESTION1 ''' Question 1 Level 1
HCIP第十二天笔记
weixin_53283593的博客
08-05 220
3.本地始发的BGP路由优于从其他对等体学习到的路由，本地始发的路由优先级:优选手动聚合>自动聚合>networkoimport>从对等体学到的。5.优选Origin属性最优的路由。[r3-bgp]peer 4.4.4.4 as -number 64513 — 联邦的EBGP对等体关系使用。[r3-bgp]confederation peer-as 64513 —在需要建立联邦的EBGP对等。[r3-bgp]peer 4.4.4.4 ebgp-max-hop — 因为联邦的EBGP对等体关系之。...
ClickHouse 查询优化实用指南：第一部分
ClickHouseDB的博客
12-29 1402
ClickHouse Playground 中的一个数据集是 NYC Taxi 数据集，其中包含纽约市出租车行程的详细数据。在没有进行任何优化的情况下，我们已经将这个数据集导入。以下是创建表并从 S3 存储桶导入数据的命令。为了方便操作，我们直接从数据中推断表结构。SELECT *接下来，我们先看一下 ClickHouse 自动生成的表结构。识别慢查询。
蓝桥云课第23场小白入门赛题解
2301_80221401的博客
12-01 1420
1. 三体时间【算法赛】
matlab第八章概率计算ppt,Matlab来解决概率统计学ppt
weixin_28996083的博客
03-23 2103
PPT内容这是一个关于Matlab来解决概率统计学ppt，主要介绍将利用Matlab来解决概率统计学中的概率分布、数字特征、参数估计以及假设检验等问题。欢迎点击下载哦。本章将利用Matlab来解决概率统计学中的概率分布、数字特征、参数估计以及假设检验等问题。Matlab可以实现的内容概率分布数字特征参数估计假设检验1.1、离散型随机变量的概率及概率分布(1)分布律二项分布的概率值格式 binopd...
01_树的 dfs 序
2403_88695928的博客
12-31 912
本文介绍了算法竞赛中树的DFS序（dfn序）这一重要概念。文章首先讲解了基于先序遍历的dfn序定义及其代码实现，通过深度优先遍历为树节点编号。随后阐述了dfn序的三个关键性质：子树dfn序的连续性、祖先节点编号小于子孙节点、子树编号区间计算公式。文章重点展示了dfn序的两个应用：高效判断节点是否在子树中（时间复杂度从O(nq)优化到O(n+q)），以及将树上问题转化为序列问题以便使用线段树等数据结构处理。最后提供了两道模板题（DFS序1和DFS序2）的完整代码实现，演示了如何利用树状数组和线段树来维护dfn
【算法基础篇】（四十）数论之算术基本定理深度剖析：从唯一分解到阶乘分解
2301_79248256的博客
12-30 1104
本文围绕算术基本定理展开，详解其 “大于 1 的自然数可唯一分解为质数乘积” 的核心内涵及在算法竞赛中的应用。先介绍质因数分解的试除法实现与优化技巧，包括枚举范围优化、溢出防护，以及结合线性筛的高效分解方法；再聚焦阶乘分解这一高频考点，拆解核心公式与两种解法（试除法累加、线性筛 + 公式），并通过洛谷经典例题演示实战；最后延伸讲解约数个数、约数和、gcd/lcm 等衍生应用，搭配避坑指南，助力快速掌握数论基础核心技能。
【AI称重算法落地指南】实施步骤、多算法方案与避坑手册
昔时扬尘处
12-27 96
AI称重算法的落地核心是“硬件精准采样+数据高质量标注+轻量化模型适配”，结合STM32G4的算力优势与NanoEdge AI Studio的低代码开发能力，可快速实现100克级精度的称重方案。在算法选型上，静态场景优先DNN（资源占用低、精度高），动态/噪声场景优先CNN（抗干扰强），时序依赖场景优先RNN（快速响应）。实际应用中需重点解决数据分布、噪声干扰、硬件适配三大核心问题，通过样本扩充、软硬件协同优化、现场自学习等手段，确保方案的可靠性与量产适配性。
基于扩展的增量流形学习算法IMM-ISOMAP的方案
aini_lovee的博客
12-30 321
基于 扩展的增量流形学习算法IMM-ISOMAP 的方案，结合 动态邻域更新 和 切空间扩展 策略，解决传统ISOMAP在增量数据和多流形场景下的局限性
csp信奥赛C++标准模板库STL案例应用25
王老师青少年编程
12-30 674
csp信奥赛C++标准模板库STL案例应用25
算法——模拟
最新发布
abjgdgf的博客
01-02 333
紧跟一个正整数，表示此项系数的绝对值（如果一个高于 0 次的项，其系数的绝对值为 1，则无需输出 1）。如果 x 的指数大于 1，则接下来紧跟的指数部分的形式为“xb”，其中 b 为 x 的指数；如果 x 的指数为 1，则接下来紧跟的指数部分形式为 x；第二行有 n+1 个整数，其中第 i 个整数表示第 n−i+1 次项的系数，每两个整数之间用空格隔开。给出一个不大于 9 的正整数 n，输出 n×n 的蛇形方阵。号，如果多项式 n 次项系数为负，则多项式以。第一行 1 个整数，n，表示一元多项式的次数。
蓝桥杯省赛电子类第一轮客观试题解析
资源摘要信息:"蓝桥杯第十三届蓝桥杯省赛第一轮相关知识点" 蓝桥杯是全国高校计算机及相关专业学科竞赛之一，主要面向中国高校的在校学生，旨在提高学生的工程实践能力和创新能力。在蓝桥杯的省赛中，第一轮通常会...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值