Codeforces Round #748 (Div. 3)

DDR4内存PCB设计实战:8层板Fly-by拓扑信号完整性优化 本文深入探讨了DDR4内存条在8层PCB板上采用Fly-by拓扑时的信号完整性优化实战。文章详细解析了层叠规划、阻抗控制、电源分割、等长布线及串扰抑制等关键设计要点,并强调了仿真验证的重要性,为硬件工程师提供了从理论到实践的完整设计指南与自查清单。 阅读详情

Codeforces Round #748 (Div. 3)

A. Elections

思路分析:
  • 令当前值比最大值大即可,如果最大值是它自己,就输出000
代码
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[3];
int ans[3];
int main()
{
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        int t;
        cin >> t;
        while (t--)
        {
                for (int i = 0; i < 3; i++)
                        cin >> a[i].first, a[i].second = i;
                sort(a, a + 3);
                for (int i = 0; i < 3; i++)
                {
                        if (i == 0)
                        {
                                ans[a[i].second] = a[2].first - a[0].first + 1;
                        }
                        else if (i == 1)
                        {
                                ans[a[i].second] = a[2].first - a[1].first + 1;
                        }
                        else
                        {
                                if (a[2].first == a[1].first)
                                {
                                        ans[a[i].second] = 1;
                                }
                                else
                                        ans[a[i].second] = 0;
                        }
                }
                for (int i = 0; i < 3; i++)
                {
                        cout << ans[i] << ' ';
                }
                cout << endl;
        }
        return 0;
} 

B. Make it Divisible by 25

思路分析:
  • 一开始以为和上次make power of 2一样,然后发现不对劲,想到了结论,25是5的倍数,那么我们剩下的数最后一位必定为5或者0,所以我们一直删到最后一位为5或者0为止。
  • 然后如果为25的倍数的话,末尾两位必定是25,50,75,00,所以我们就分情况取最小值即可。
  • 其实官方题解的最简单,我就建议不要看我这个做法了。
代码
#include <bits/stdc++.h>
using namespace std;
int a[2] = {2, 7};
int main()
{
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        int t;
        cin >> t;
        while (t--)
        {
                string s;
                cin >> s;
                string c = s;
                int mincnt = 0;
                //以5为最后一位
                for (int i = s.size() - 1; i >= 0; i--)
                {
                        if (s[i] != '5')
                        {
                                s.erase(i);
                                mincnt++;
                        }
                        //找到5
                        else
                                break;
                }
                for (int i = s.size() - 2; i >= 0; i--)
                {
                        if (s[i] != '2' && s[i] != '7')
                        {
                                mincnt++;
                                s.erase(i);
                        }
                        else
                                break;
                }
                int temp = 0;
                for (int i = c.size() - 1; i >= 0; i--)
                {
                        if (c[i] != '0')
                        {
                                c.erase(i);
                                temp++;
                        }
                        //找到5
                        else
                                break;
                }
                for (int i = c.size() - 2; i >= 0; i--)
                {
                        if (c[i] != '5' && c[i] != '0')
                        {
                                temp++;
                                c.erase(i);
                        }
                        else
                                break;
                }
                cout << min(mincnt, temp) << endl;
        }
        return 0;
}

C. Save More Mice

思路分析:
  • 这题其实就是贪心吧,让离洞最近的老鼠先逃即可,因为老鼠和猫的相对速度为111。
  • 注意更新猫的位置即可。
代码
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int main()
{
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        int t;
        cin >> t;
        while (t--)
        {
                a.clear();
                int n, k;
                cin >> n >> k;
                for (int i = 0; i < k; i++)
                {
                        int x;
                        cin >> x;
                        a.push_back(x);
                }
                sort(a.begin(), a.end());
                int ans = 0;
                int x = 0;
                for (int i = a.size() - 1; i >= 0; i--)
                {
                        if (x < a[i])
                        {
                                x += (n - a[i]);
                                ans++;
                        }
                        else
                                break;
                }
                cout << ans << endl;
        }
        return 0;
}

D1. All are Same

思路分析:
  • 因为最后要把所有数变为一个数,那么肯定是把所有数变成当前数组的最小值即可。
  • 那么如何求这个减去的数的最大值呢?
  • 实际上也就是所有数和最小值的GCD了。
代码
#include <bits/stdc++.h>
using namespace std;
int main()
{
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        int t;
        cin >> t;
        while (t--)
        {
                int n;
                cin >> n;
                vector<int> a(n);
                for (int i = 0; i < n; i++)
                {
                        cin >> a[i];
                }
                sort(a.begin(), a.end());
                int x = a[0];
                int ans = 0;
                for (int i = 0; i < n; i++)
                {
                        ans = __gcd(ans, a[i] - x);
                }
                if (ans != 0)
                        cout << ans << endl;
                else
                {
                        cout << "-1" << endl;
                }
        }
        return 0;
}

D2. Half of Same

思路分析:
  • 我们可以知道当且仅当当前数组中已经有n/2n / 2n/2个数相同输出−1-1−1。
  • 我们枚举每一个数,也就是说把其他数变为它需要减去多少值保存一下,然后记录原数组中已经有多少个数与它相同,再因数分解一下这个差值,然后遍历它的差值的因数,取使得因数的个数加上原本和它一样的数的个数大于n/2n / 2n/2的最大的因数即可。
代码
#include <bits/stdc++.h>
using namespace std;
set<int> divide(int x)
{
        set<int> q;
        for (int i = 1; i * i <= x; i++)
        {
                if (x % i == 0)
                {
                        q.insert(i);
                        q.insert(x / i);
                }
        }
        return q;
}
int main()
{
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        int t;
        cin >> t;
        while (t--)
        {
                int n;
                cin >> n;
                vector<int> a(n);
                for (int i = 0; i < n; i++)
                {
                        cin >> a[i];
                }
                int k = -1;
                for (int i = 0; i < a.size(); i++)
                {
                        int minv = a[i];
                        int same = 0;
                        vector<int> d;
                        for (int j = 0; j < a.size(); j++)
                        {
                                if (a[j] == minv)
                                        same++;
                                else if (a[j] > minv)
                                {
                                        d.push_back(a[j] - minv);
                                }
                        }
                        if (same >= n / 2)
                        {
                                k = INT_MAX;
                                break;
                        }
                        map<int, int> mp;
                        for (auto x : d)
                        {
                                for (auto xx : divide(x))
                                {
                                        mp[xx]++;
                                }
                        }
                        for (auto x : mp)
                        {
                                if (x.second + same >= n / 2)
                                {
                                        k = max(k, x.first);
                                }
                        }
                }
                cout << (k == INT_MAX ? -1 : k) << endl;
        }
        return 0;
}

E. Gardener and Tree

思路分析:
  • 一开始以为暴力能过就写了个暴力然后T了。然后看了下题解,原来是反向的,也就是说我们也是模拟一下删点过程(把这棵树删完),然后统计一下是在第几轮删去的这个点,最后把删去轮数和kkk比较即可。
代码
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
int degree[maxn];
vector<int> e[maxn];
int n, k, ans;
int vis[maxn];
int dis[maxn];
int main()
{
        int t;
        cin >> t;
        while (t--)
        {
                memset(vis, 0, sizeof(vis));
                memset(degree, 0, sizeof(degree));
                memset(dis, 0, sizeof(dis));
                cin >> n >> k;
                ans = n;
                for (int i = 1; i <= n; i++)
                {
                        e[i].clear();
                }
                for (int i = 1; i < n; i++)
                {
                        int u, v;
                        cin >> u >> v;
                        e[u].push_back(v);
                        e[v].push_back(u);
                        degree[u] += 1;
                        degree[v] += 1;
                }
                queue<int> q;
                for (int i = 1; i <= n; i++)
                {
                        if (degree[i] == 1)
                        {
                                q.push(i);
                                vis[i] = 1;
                                dis[i] = 1;
                        }
                }
                while (!q.empty())
                {
                        int x = q.front();
                        q.pop();
                        for (int j = 0; j < e[x].size(); j++)
                        {
                                int u = e[x][j];
                                if (vis[u])
                                        continue;
                                degree[u]--;
                                if (degree[u] == 1)
                                {
                                        q.push(u);
                                        vis[u] = 1;
                                        dis[u] = dis[x] + 1;
                                }
                        }
                }
                int ans = 0;
                for (int i = 1; i <= n; i++)
                {
                        if (dis[i] > k)
                        {
                                ans++;
                        }
                }
                cout << ans << endl;
        }
        return 0;
}
银河麒麟V10ARM架构服务器离线安装docker\nacos【附安装包】 本文分享了在银河麒麟ARM64操作系统上安装Docker和Nacos的完整过程。首先提供了Docker的自动化安装脚本,包含服务配置、存储路径设置等关键步骤,并给出了常用维护命令。接着详细介绍了通过Docker-compose部署Nacos的方法,包括镜像导入、配置文件修改、鉴权设置等注意事项,特别强调了密钥长度必须超过32个字符的要求。文章还提供了Nacos初次登录的注意事项,并预告了后续可能推出的Redis、Nginx等安装教程。所有配置文件和脚本均可直接下载使用,适合内网环境下国产操作系统的部署 阅读详情

相关推荐

智能网联汽车云控系统核心解析:车云数据交互协议设计与实践

本文深入解析了智能网联汽车云控系统的核心——车云数据交互协议的设计与实践。文章围绕“说什么”、“怎么说”及异常处理三大核心问题,详细阐述了二进制与结构体数据类型定义、TCP/UDP双通道传输机制、通用报文格式以及典型交互流程(如GLOSA车速引导),并分享了时间同步、坐标系定义等关键实战经验与避坑指南,为构建高效、可靠、安全的车云“神经系统”提供专业指导。

alice7model的博客 121

Leetcode题解-算法-栈和队列

文章目录1、用栈实现队列 1、用栈实现队列 232. Implement Queue using Stacks(Easy) Implement the following operations of a queue using stacks. push(x) – Push element x to the back of queue. pop() – Removes the element fr...

桑凯旋的博客 512

Titans:谷歌新型神经记忆架构,突破 Transformer 长序列处理的瓶颈

Titans 是谷歌推出的新型神经网络架构,通过神经长期记忆模块突破 Transformer 在处理长序列数据时的瓶颈,支持并行计算,显著提升训练效率。

士多啤梨先生の博客 991

栈学习---------------用队列实现栈

classMyStack{ public: /**Initializeyourdatastructurehere.*/ queue<int>s; queue<int>b; MyStack() { } /**Pushelementxontostack.*/ voidpush(intx) { this-&g...

c15336023的博客 168

主板USB接口全部失效解决方案(通用串行总线USB控制器有黄色叹号)保姆级教程亲测有效

通用串行总线控制器总是有叹号解决办法 办公室的崩腾时代老电脑,疫情期间没人用,来了开机之后发现鼠标键盘都用不了,本以为是主机放时间长出了问题,后来想起来就百度了“鼠标键盘都失效”的标题,结果发现了“串行总线控制器总是感叹号”的关联问题。正好办公室电脑都装有teamviwer常用来远程办公(在家偷懒)。所以通过远程发现电脑室可以运行的。并在控制面板发现:通用串行总线控制器总是感叹号,插入外设时USB无反应。如图:​ 并且右键选中其中一个,点击最后一个选项:“属性” 可以发现“设备状态”中会提示“由...

xiao_bai_0_0的博客 2万+

别再对着手册发愁了!手把手教你读懂MIPI-DSI初始化命令(以Rockchip平台为例)

本文深入解析MIPI-DSI初始化命令在Rockchip平台的应用,帮助嵌入式工程师快速掌握LCD屏幕调试技巧。从协议基础到实战指南,详细拆解命令格式、DCS与Generic命令的区别,并提供Rockchip平台的调试全流程与高级技巧,解决常见显示问题。

weixin_42519781的博客 263

Codeforces Round #748 (Div. 3)简训

Codeforces Round #748 (Div. 3)日常

C_eeking的博客 587

EMI硬件抑制八项工程对策:从回路面积到谐振规避

电磁干扰(EMI)是电子系统可靠性与EMC合规性的核心挑战,其本质源于高频电流回路产生的辐射与耦合效应。理解回路面积、共模/差模噪声、阻抗匹配等基础原理,是实施有效抑制的前提。技术价值体现在降低辐射发射(RE)、传导发射(CE)超标风险,提升产品一次通过率与长期稳定性。典型应用场景包括开关电源设计、高速数字接口布局、工业嵌入式设备及医疗电子等对EMC要求严苛的领域。本文聚焦可落地的硬件级对策,涵盖回路面积控制、屏蔽策略、变压器漏磁管理、双线传输与阻抗匹配等关键实践,深度融合电流回路物理模型与PCB工程实现。

weixin_35019679的博客 85

Editorial for Codeforces Round #748 (Div.3)

1.若存在一个数 K 能使所有数通过相减而相等,则 k 必定是这个数列相邻两项不同的数的差值的因子,这里可以使用这个数列的 最大值 和 最小值 的差值 即 K | (max - min)。有 dp[n + 1][(a * 10 + s[n] - '0') % A][b][k + 1] = dp[n][a][b][k] | ((long long)1 << n);此时考虑第 u 位情况,若最终 a = b = 0,且 1 < k < n则合法,记录 abs(n - k - k) 最小的答案序列即可。

欢迎来到我的博客 1532

深入GSConv代码:逐行解析这个混合了标准卷积与深度可分离卷积的‘新算子’

本文深入解析GSConv代码,详细介绍了这个混合标准卷积与深度可分离卷积的‘新算子’的设计哲学与实现框架。通过PyTorch代码逐行分析,揭示GSConv如何在轻量级卷积神经网络中平衡计算效率与特征表达能力,特别适用于Slim-Neck架构,显著降低计算量同时保持高精度。

weixin_29860267的博客 321

柔性电极材料新突破:清华团队实现0.1mV级脑信号采集精度

清华团队的 0.1mV 级柔性电极突破,不仅是材料科学与神经工程的跨界胜利,更标志着脑机接口从 “信号采集” 向 “神经交互” 的范式转变。当电极与脑组织实现 “柔性共生”,人类首次拥有了窥探大脑微观电活动的 “精密探头”,这既是神经疾病诊疗的里程碑,更是人机融合时代的新起点。随着技术标准化与产业生态的完善,这场始于实验室的 “柔性革命”,正加速向临床病房、智能工厂、消费电子等场景渗透,为脑机接口的大规模应用铺设 “柔性跑道”。:当柔性电极实现 “神经信号的无损捕捉”,如何平衡技术创新与伦理边界?

远程部署调试 运行安装 项目调试 二次开发 项目技术新 持续迭代 部分源码免费分享 2944

Codeforces Round #748 (Div. 3) 题解 完整A~G

Codeforces Round #748 (Div. 3) 题解 A. Elections 题意 已知竞选中三个候选人的当前得票数a,b,ca,b,ca,b,c,现在可以增加任何一个人的得票数,要求对于每个人,计算出能使得其得票数大于其余两人的最少增加票数。 思路 按照题意计算即可,假如要使得aaa的票数最高,只需让aaa加上b,cb,cb,c中票数较高的人与aaa的票数只差,再加上1即可。需要注意的是,如果某个人的得票数已经大于其余两人,应当输出0,而不是负数。 时间复杂度 O(1) O(1) O(1)

spy20051623的博客 954

Unity-Mirror网络框架-从入门到精通之MultipleMatches示例

Multiple Matches 示例主要讲述了如何在使用 Mirror 网路框架时管理多个游戏匹配。以及如何设置一个能够同时支持多个游戏会话的系统,使玩家能够加入他们所选择的比赛,而不是强制他们加入一个单一的匹配。

TxNet 964

Codeforces Round #748 (Div. 3) A. Elections

A. Elections 题目链接 题目大意: 有三个人进行选举,分别有a, b, c票,问每个人各需要多少票才能成为第一。 思路: 对于每个人,肯定要变得比其他两个人最大值还要大一才行,或者三者唯一最大就是自己本身 所以 每个人的答案就是 max(0, max(其他两人) - 自己 + 1) AC代码: #include <bits/stdc++.h> #define pii pair<int,int> #define ll long long using namespace

遗落之辉的博客 349

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Codeforces Round #748 (Div. 3) B. Make it Divisible by 25

B. Make it Divisible by 25 题目链接 题目大意: 给出一个数,你可以删除任意数位,问最少删除多少次才能使删除后的数能够被25整除 思路: 能被25整除的数的性质:最后的两位数必须是00、 25 、50、75这几个数 然后就是 模拟模拟再模拟,细心细心再细心 AC代码: #include <bits/stdc++.h> #define pii pair<int,int> #define ll long long using namespace std;

遗落之辉的博客 385

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Codeforces Round #748 (Div. 3) D2. Half of Same

D2. Half of Same 题目链接 题目大意: 有n个数,你可以使任意数减k任意次,问能使超过一半的数相等的最大的k 思路: 直接暴力枚举,细节看代码注释 AC代码: #include <bits/stdc++.h> #define pii pair<int,int> #define ll long long using namespace std; const double eps = 1e-8; const int maxn = 1e5 + 10; const in

遗落之辉的博客 325

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Codeforces Round #748 (Div. 3) C. Save More Mice

C. Save More Mice 题目链接 题目大意: 在一个坐标轴上,有 1 只猫(位于0)、k只老鼠, 还有位于n的老鼠洞, 猫和老鼠轮流行动,老鼠先,每次可以让一只老鼠移动一个单位长度,猫也是,猫抓到了老鼠会吃掉,问最多有多少只老鼠可以进老鼠洞(进了老鼠洞就不会被猫吃) 思路: 直接贪心就好,离洞进的优先,能走的步数不会发生改变,所以这样贪心最优 AC代码: #include <bits/stdc++.h> #define pii pair<int,int> #define

遗落之辉的博客 562

Codeforces Round #748 (Div. 3) A D C D1 E(持续更新中)

Codeforces Round #748 (Div. 3) A.Elections 思路:因为每个人是独立考虑,那么先从三个人中取一个MAX就好了,同时也要判断MAX的数量是不是大于1,如果大于1的话,说明如果当前数是最大他仍需要+1才能变成最大,同样如果MAX只有1个那么如果当前数是MAX那么他不需要操作。 参考code: #include<bits/stdc++.h> using namespace std; unordered_map<int,int>S; int a[5];

qq_53504307的博客 168

Codeforces Round #748 (Div. 3) E. Gardener and Tree

E. Gardener and Tree 题目链接 题目大意: 给出一棵树,问对其进行k次操作还剩多少个节点, 操作是:删除当前所有叶子结点 思路: 直接bfs模拟即可,但是要特判一个情况,只剩孤立节点的情况。 AC代码: #include <bits/stdc++.h> #define pii pair<int,int> #define ll long long using namespace std; const double eps = 1e-8; const int m

遗落之辉的博客 304

Codeforces Round #748 (Div. 3) 题解

文章目录A. ElectionsB. Make it Divisible by 25C. Save More MiceD1. All are SameD2. Half of SameE. Gardener and TreeF. Red-Black NumberG. Changing Brackets A. Elections 题意 给定数值a,b,ca,b,ca,b,c,问其中一个数大于其他两个数还需要增加多大。 解题思路 签到。 AC代码 /** *@filename:A_Electi

pursuit的博客 649

Codeforces Round #748 (Div. 3) D1. All are Same

D1. All are Same 题目链接 题目大意: 有n个数,你可以使任意数减k任意次,问能使所有数相等的最大的k 思路: 找出所有数减到最小值所需的数的gcd,然后枚举其倍数,然后枚举到第二小值减最小值这个数,再大就不可能了 相当暴力,最坏直接全枚举一遍(D2做法) AC代码: #include <bits/stdc++.h> #define pii pair<int,int> #define ll long long using namespace std; const

遗落之辉的博客 421
上一篇: AtCoder Beginner Contest 223
下一篇: AtCoder Beginner Contest 224
csu-yuuki
博客等级 码龄6年 133粉丝 64原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值