草庐IT

第十四届蓝桥杯大赛软件赛省赛 C/C++ 大学 B 组

XM.007 2023-06-23 原文

第十四届蓝桥杯大赛软件赛省赛 C/C++ 大学 B 组

注意！！！！！！！！！！这篇题解为赛时的个人做法，不代表是正确的，仅供参考。
更新：思路上应该都对，很多题都有细节错误，代码不用看了,太久没敲代码了(- -)
更新2：代码除了岛屿的都改好了，整数删除常数有点大，可能会t，赛时的代码一堆错误，还是对自己的文章负责，省赛打的太放松了，应该多自己造几组样例测得。最后两题lca，板子有一行脑抽了写错了居然没发现，然后求lca我是前一题复制到后一题，两题的样例都能过，结果两题都错了，把那一行代码改完就都a了，蓝桥杯给的样例是在是太水了。。。。。自己还是太久没敲代码，变菜了。(T . T)

试题 A: 日期统计

dfs+剪枝即可，因为前四位一定是2023，五六位一定是1-12月，七八为也要满足条件，所以实际上搜索的范围比较少

最终答案:235

#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+9;
typedef long long ll;
int a[N];
int mon[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
vector<int> now;
map<int,int> mp;
int ans = 0;
void dfs(int len,int dep){
    if(len == 8){
        int sum = 0;
        int m = now[4]*10 + now[5];
        int d = now[6]*10 + now[7];
        if(m < 1 || m > 12) return ;
        if(d < 1 || d > mon[m]) return ;
        for(int i = 0;i < 8;i++){
            sum *= 10;
            sum += now[i];
        }
        if(!mp[sum]){
            ans++;
            mp[sum] = 1;
        }
        return ;
    }
    for(int i = dep;i <= 100;i++){
        if(len == 0){
            if(a[i] == 2){
                now.push_back(a[i]);
                dfs(len+1,i+1);
                now.pop_back();
            }
        }else if(len == 1){
            if(a[i] == 0){
                now.push_back(a[i]);
                dfs(len+1,i+1);
                now.pop_back();
            }
        }else if(len == 2){
            if(a[i] == 2){
                now.push_back(a[i]);
                dfs(len+1,i+1);
                now.pop_back();
            }
        }else if(len == 3){
            if(a[i] == 3){
                now.push_back(a[i]);
                dfs(len+1,i+1);
                now.pop_back();
            }
        }else{
            now.push_back(a[i]);
            dfs(len+1,i+1);
            now.pop_back();
        }
    }
}
void sol(){
    for(int i = 1;i <= 100;i++){
        scanf("%d",&a[i]);
    }
    dfs(0,1);
    printf("%d",ans);
}
int main(){
        sol();
    return 0;
}

试题 B: 01 串的熵

枚举0的个数,因为0个数比1小，所以遍历到23333333/2即可

最终答案：11027421

#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+9;
typedef long long ll;
void sol(){
    int n = 23333333;
    for(int i = 0;i <= n/2;i++){
        double ans = -1.0*i*i/n*log2(1.0*i/n)-1.0*(n-i)*(n-i)/n*log2(1.0*(n-i)/n);
        if(abs(ans - 11625907.5798) <= 0.0001){
            printf("%d",i);
        }
    }
}
int main(){
        sol();
    return 0;
}

试题 C: 冶炼金属

数论分块知识，用二分也可以

#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+9;
typedef long long ll;
int main(){
    int n;
    scanf("%d",&n);
    int maxx = 1000000000,minn = 0;
    for(int i = 1;i <= n;i++){
        int a,b;
        scanf("%d %d",&a,&b);
        maxx = min(maxx,a/b);
        minn = max(minn,(a+b+1)/(b+1));//比赛时手快分子少加了个1，麻了(代码已改过)
    }
    printf("%d %d",minn,maxx);
    return 0;
}

试题 D: 飞机降落

因为N最多10，所以把所有飞机可能到达的顺序都检查一遍看看是否可行即可。复杂度O(T10!)

#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+9;
typedef long long ll;
struct node{
    int t,d,l;
}p[N];
int a[20];
void sol(){
    int n;
    scanf("%d",&n);
    for(int i = 1;i <= n;i++){
        scanf("%d %d %d",&p[i].t,&p[i].d,&p[i].l);
        a[i] = i;
    }
    
    do{
        int now = 0;
        int flag = 1;
        for(int i = 1;i <= n;i++){
            int t = p[a[i]].t,d = p[a[i]].d,l = p[a[i]].l;
            if(now > t + d){
                flag = 0;
                break;
            }else{
                if(t > now) now = t + l;
                else now = now + l;
            }
        }
        if(flag){
            printf("YES\n");
            return;
        }
    }while(next_permutation(a+1,a+1+n));
    printf("NO\n");
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        sol();
    }
    return 0;
}

试题 E: 接龙数列

dp,dp[i]表示以i为结尾最长可以组成多长，那么答案就是n-max(dp[0-9])

复杂度O(n)

#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+9;
typedef long long ll;
struct node{
    int t,w;
}p[N];
int dp[20];
void sol(){
    int n;
    scanf("%d",&n);
    for(int i = 1;i <= n;i++){
        int x;
        scanf("%d",&x);
        p[i].w = x % 10;
        while(x >= 10){
            x/=10;
        }
        p[i].t = x;
    }
    // for(int i = 1;i <= n;i++){
    //     printf("%d %d\n",p[i].t,p[i].w);
    // }
    for(int i = 1;i <= n;i++){
        dp[p[i].w] = max(dp[p[i].w],dp[p[i].t] + 1);
    }
    int ans = 1000000000;
    for(int i = 0;i <= 9;i++){
        ans = min(ans,n-dp[i]);
    }
    printf("%d",ans);
}
int main(){
        sol();
    return 0;
}

试题 F: 岛屿个数

首先dfs一次，把所有相连的岛屿都标上号。

一个个判断某一个岛屿是否被围住，如何判断，枚举所有的岛屿作为墙，当你从一个岛屿存在一个点，可以搜索走出n*m的棋盘就证明没有被围住，当所有其他岛屿作为墙，你都可以走出地图，那么这个岛屿就没有被围住。

复杂度O(n^4)

#include<bits/stdc++.h>
using namespace std;
const int N = 2e3+9;
typedef long long ll;
int a[59][59];
int vis[59][59];
int dx[] = {0,0,1,-1};
int dy[] = {1,-1,0,0};
int fobid = 0;
int n,m;
int ans[N];
int nc = 0;
void dfs(int x,int y,int co){
    vis[x][y] = co;
    for(int i = 0;i <= 3;i++){
        int xx = x + dx[i];
        int yy = y + dy[i];
        if(xx < 1 || xx > n || yy < 1 || yy > m) continue;
        if(vis[xx][yy]||a[xx][yy] == 0){
            continue;
        }
        dfs(xx,yy,co);
    }
}
int v[59][59];
void dfs2(int x,int y,int co){
    v[x][y] = 1;
    for(int i = 0;i <= 3;i++){
        int xx = x + dx[i];
        int yy = y + dy[i];
        if(xx < 1 || xx > n || yy < 1 || yy > m){
            ans[co] = 1;
            continue;
        } 
        if(v[xx][yy] || vis[xx][yy] == fobid){
            continue;
        }
        dfs2(xx,yy,co);
    }
}
void sol(){
    memset(vis,0,sizeof(vis));
    memset(ans,0,sizeof(ans));
    nc = 0;
    scanf("%d %d",&n,&m);
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= m;j++){
            scanf("%1d",&a[i][j]);
        }
    }
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= m;j++){
            if(a[i][j]){
                if(!vis[i][j]){
                    dfs(i,j,++nc);
                }
            }
        }
    }
    for(fobid = 1;fobid <= nc;fobid++){
        for(int i = 1;i <= n;i++){
            for(int j = 1;j <= m;j++){
                if(vis[i][j] && fobid != vis[i][j]){
                    if(ans[vis[i][j]]) continue;
                    memset(v,0,sizeof(v));
                    dfs2(i,j,vis[i][j]);
                }
            }
        }
    }
    
    int num = 0;
    for(int i = 1;i <= nc;i++){
        num += ans[i];
    }
    printf("%d\n",num);
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--)
        sol();
    return 0;
}

试题 G: 子串简写

对结尾字符出现次数做前缀和，枚举a字符开头的位置，假设s[i]是a字符，那么i+k-1以后的出现的b都可以作为答案。

复杂度O(n)

#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+9;
typedef long long ll;
char s[N];
char a,b;
ll sum[N];
void sol(){
    int k,n;
    scanf("%d",&k);
    scanf("%s",s+1);
    n = strlen(s+1);
    scanf(" %c",&a);
    scanf(" %c",&b);
    for(int i = 1;i <= n;i++){
        if(s[i] == b) sum[i] = sum[i-1]+1;
        else sum[i] = sum[i-1];
    }
    ll ans = 0;
    for(int i = 1;i <= n;i++){
        if(s[i] == a && i + k - 2 <= n){
            ans += (sum[n] - sum[i+k-2]);
        }
    }
    printf("%lld",ans);
}
int main(){
        sol();
    return 0;
}

试题 H: 整数删除

维护两个set，一个set先对值再对位置大小排序，另一个则相反。然后模拟即可。

复杂度O(nlogn+klogn)

#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+9;
typedef long long ll;
struct nodevp{
    int pos;
    ll val;
    bool operator < (const nodevp &p) const{
        if(val == p.val) return pos < p.pos;
        else return val < p.val;
    }
    bool operator == (const nodevp &p) const{
        return pos == p.pos && val == p.val;
    }
};
struct nodepv{
    int pos;
    ll val;
    bool operator < (const nodepv &p) const{
        if(pos == p.pos) return val < p.val;
        else return pos < p.pos;
    }
    bool operator == (const nodepv &p) const{
        return pos == p.pos && val == p.val;
    }
};
ll a[N];
set<nodevp> svp;
set<nodepv> spv;
int n,k;
void changepv(nodepv a,nodepv b){
    spv.erase(a);
    spv.insert(b);
}
void changevp(nodevp a,nodevp b){
    svp.erase(a);
    svp.insert(b);
}
void sol(){
    scanf("%d %d",&n,&k);
    for(int i = 1;i <= n;i++){
        scanf("%d",&a[i]);
        nodevp v;
        v.val = a[i];
        v.pos = i;
        svp.insert(v);
        nodepv p;
        p.val = a[i];
        p.pos = i;
        spv.insert(p);
    }
    for(int i = 1;i <= k;i++){
        nodevp v = *svp.begin();
        // svp.erase(v);
        ll add = v.val;
        nodepv p;
        p.val = v.val;
        p.pos = v.pos;
        auto apv = spv.find(p);
        if(apv != spv.begin()){
            apv--;
            nodepv temp,nex;
            temp.pos = apv->pos;
            temp.val = apv->val;
            nex.pos = temp.pos;
            nex.val = temp.val + add;

            nodevp temp2,nex2;
            temp2.pos = apv->pos;
            temp2.val = apv->val;
            nex2.pos = temp2.pos;
            nex2.val = temp2.val + add;
            changepv(temp,nex);
            changevp(temp2,nex2);
            // apv++;
        }
        apv = spv.find(p);
        apv++;
        if(apv == spv.end()){
            spv.erase(p);
            svp.erase(v);
            continue;
        }
        nodepv temp,nex;
        temp.pos = apv->pos;
        temp.val = apv->val;
        nex.pos = temp.pos;
        nex.val = temp.val + add;

        nodevp temp2,nex2;
        temp2.pos = apv->pos;
        temp2.val = apv->val;
        nex2.pos = temp2.pos;
        nex2.val = temp2.val + add;
        changepv(temp,nex);
        changevp(temp2,nex2);
        spv.erase(p);
        svp.erase(v);
    }
    while(spv.size()){
        nodepv p = *spv.begin();
        printf("%lld ",p.val);
        spv.erase(p);
    }
}
int main(){
        sol();
    return 0;
}
// 5 3
// 4 1 2 8 7
// 5 4
// 1 4 2 8 7

试题 I: 景区导游

树上前缀和+lca。先算出不删除走完全称所需要的时间假设为asum。如何算，sum[i]代表从根走到i节点需要花多少时间，那么从u到v(后文表示为dis(u,v))则需要花sum[u]+sum[v]-sum[lca(u,v)]*2这么多时间，如果删去一个点i后，全程答案为 asum - dis(a[i],a[i+1]) - dis(a[i],a[i-1]) + dis(a[i-1],a[i+1]),删掉开头和结尾特判，入代码所示。

复杂度:O(nlogn)

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+9;
typedef long long ll;
int n,k;
int f[N][29];
int dep[N];
int a[N];
ll sum[N];
ll ans[N];
struct edge{
    ll dis;
    int to;
};
vector<edge> g[N];
int lca(int u,int v){
    if(dep[u] < dep[v]) swap(u,v);
    for(int i = 20;i >= 0;i--){
        if(dep[f[u][i]] >= dep[v]) u = f[u][i];
    }
    if(u == v) return u;
    for(int i = 20;i >= 0;i--){
        if(f[u][i] != f[v][i]){
            u = f[u][i];
            v = f[v][i];
        }
    }
    return f[u][0];
}
ll dis(int u,int v){
    return (sum[u] + sum[v] - sum[lca(u,v)]*2);
}
void dfs(int now,int fa){
    // sum[now] = sum[now] + sum[fa];
    f[now][0] = fa;
    dep[now] = dep[fa] + 1;
    for(int i = 1;i <= 20;i++){
        if(f[now][i-1]) f[now][i] = f[f[now][i-1]][i-1];
        else break;
    }
    for(auto j : g[now]){
        if(j.to == fa) continue;
        sum[j.to] += sum[now] + j.dis;
        dfs(j.to,now);
    }
}
void sol(){
    scanf("%d %d",&n,&k);
    for(int i = 1;i <= n-1;i++){
        int u,v;
        ll dis;
        scanf("%d %d %lld",&u,&v,&dis);
        edge p;
        p.dis = dis;p.to = v;
        g[u].push_back(p);
        p.to = u;
        g[v].push_back(p);
    }
    dfs(1,0);
    ll asum = 0;
    for(int i = 1;i <= k;i++){
        scanf("%d",&a[i]);
    }
    for(int i = 2;i <= k;i++){
        asum += (sum[a[i-1]] + sum[a[i]] - sum[lca(a[i-1],a[i])]*2);
    }
    for(int i = 1;i <= k;i++){
        if(i == 1){
            ans[i] = asum - dis(a[i],a[i+1]);
        }else if(i == k){
            ans[i] = asum - dis(a[i],a[i-1]);
        }else{
            ans[i] = asum - dis(a[i],a[i+1]) - dis(a[i],a[i-1]) + dis(a[i-1],a[i+1]);
        }
    }
    for(int i = 1;i <= k;i++){
        printf("%lld ",ans[i]);
    }

}
int main(){
        sol();
    return 0;
}

试题 J: 砍树

树上差分+lca。如果u到v想要断开，那么u到v路径上的任何一条边断开都可以，所以把u到v所经过的边权值加1，最后看那一条边的权值等于给出的无序对的个数，输出序号最大的那条边即可。

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+9;
typedef long long ll;
int n,m;
int f[N][29];
int dep[N];
ll sum[N];
int ans = -1;
int fnum[N];
struct edge{
    ll dis;
    int to;
};
vector<edge> g[N];
int lca(int u,int v){
    if(dep[u] < dep[v]) swap(u,v);
    for(int i = 20;i >= 0;i--){
        if(dep[f[u][i]] >= dep[v]) u = f[u][i];
    }
    if(u == v) return u;
    for(int i = 20;i >= 0;i--){
        if(f[u][i] != f[v][i]){
            u = f[u][i];
            v = f[v][i];
        }
    }
    return f[u][0];
}

void dfs(int now,int fa){
    // sum[now] = sum[now] + sum[fa];
    f[now][0] = fa;
    dep[now] = dep[fa] + 1;
    for(int i = 1;i <= 20;i++){
        if(f[now][i-1]) f[now][i] = f[f[now][i-1]][i-1];
        else break;
    }
    for(auto j : g[now]){
        if(j.to == fa) continue;
        fnum[j.to] = j.dis;
        dfs(j.to,now);
    }
}
void dfs2(int now,int fa){
    for(auto j : g[now]){
        if(j.to == fa) continue;
        dfs2(j.to,now);
        sum[now] += sum[j.to];
    }
    if(sum[now] == m){
        ans = max(ans,fnum[now]);
    }
}
void sol(){
    scanf("%d %d",&n,&m);
    for(int i = 1;i <= n-1;i++){
        int u,v;
        scanf("%d %d",&u,&v);
        edge p;
        p.dis = i;p.to = v;
        g[u].push_back(p);
        p.to = u;
        g[v].push_back(p);
    }
    dfs(1,0);
    for(int i = 1;i <= m;i++){
        int u,v;
        scanf("%d %d",&u,&v);
        sum[u]++;
        sum[v]++;
        sum[lca(u,v)]-=2;
    }
    dfs2(1,0);
    printf("%d",ans);
}
int main(){
        sol();
    return 0;
}
蓝桥第spanclasstoken蓝桥杯c++c语言

有关第十四届蓝桥杯大赛软件赛省赛 C/C++ 大学 B 组的更多相关文章

  1. 软件测试基础 - 2

    Ⅰ软件测试基础一、软件测试基础理论1、软件测试的必要性所有的产品或者服务上线都需要测试2、测试的发展过程3、什么是软件测试找bug，发现缺陷4、测试的定义使用人工或自动的手段来运行或者测试某个系统的过程。目的在于检测它是否满足规定的需求。弄清预期结果和实际结果的差别。5、测试的目的以最小的人力、物力和时间找出软件中潜在的错误和缺陷6、测试的原则28原则：20%的主要功能要重点测（eg：支付宝的支付功能，其他功能都是次要的）80%的错误存在于20%的代码中7、测试标准8、测试的基本要求功能测试性能测试安全性测试兼容性测试易用性测试外观界面测试可靠性测试二、质量模型衡量一个优秀软件的维度①功能性功

  2. 网站日志分析软件--让网站日志分析工作变得更简单 - 2

    网站的日志分析，是seo优化不可忽视的一门功课，但网站越大，每天产生的日志就越大，大站一天都可以产生几个G的网站日志，如果光靠肉眼去分析，那可能看到猴年马月都看不完，因此借助网站日志分析工具去分析网站日志，那将会使网站日志分析工作变得更简单。下面推荐两款网站日志分析软件。第一款：逆火网站日志分析器逆火网站日志分析器是一款功能全面的网站服务器日志分析软件。通过分析网站的日志文件，不仅能够精准的知道网站的访问量、网站的访问来源，网站的广告点击，访客的地区统计，搜索引擎关键字查询等，还能够一次性分析多个网站的日志文件，让你轻松管理网站。逆火网站日志分析器下载地址：https://pan.baidu.

  3. 蓝桥杯备赛（二） - 2

    目录前言： 一、ASC分析代码实现二、 卡片分析代码实现三、 直线分析代码实现四、货物摆放分析代码实现小结：前言：  在刷题的过程中，发现蓝桥杯的题目和力扣的差别很大。让人有一种不一样的感觉，蓝桥杯题目偏向对于实际问题用编程去的解决，而力扣给人感觉很锻炼自己的编程思维，逻辑能力。两者结合去刷，相信会有不一样的收获。 一、ASC  已知大写字母A的ASCII码为65，请问大写字母L的ASCII码是多少？分析  这道题目看上去很简单，我们需确定自己计算的准确，所以我建议用编程去解决。代码实现publicclassTest8{publicstaticvoidmain(String[]args){Sy

  4. 【血泪建议】软件测试岗位现状，可惜之前没人告诉我，肠子都晦青了.... - 2

    谈到现状，国内的软件测试行情目前呈现了两极分化的极端情况。一个是早期的手工测试人员吐槽工作不好做，即使有工作也是外包，而且薪资太低；一方面是很多互联网企业感叹自动化测试人才难找，有技术的自动化测试工程师，高薪难聘。这两者其实并不矛盾。手工测试工作难找也确实是目前真实的行情早期从事功能测试的手工测试人员，在测试方面大多采用手动、人工执行的方式查找软件缺陷和BUG，用行业术语来描述就是“点点点”。这种测试方式耗费大量人力和资源，工作效率却十分低下。在早期软件复杂和迭代程度不高的情况下，有资本的企业会“供养”一批这样的手工测试人员。但对测试员本身来讲，毫无技术难度的工作，和几乎没有保障的薪资水平，直

  5. 蓝桥杯C/C++VIP试题每日一练之报时助手 - 2

    ?作者主页：静Yu?简介：CSDN全栈优质创作者、华为云享专家、阿里云社区博客专家，前端知识交流社区创建者?社区地址：前端知识交流社区?博主的个人博客：静Yu的个人博客?博主的个人笔记本：前端面试题个人笔记本只记录前端领域的面试题目，项目总结，面试技巧等等。接下来会更新蓝桥杯官方系统基础练习的VIP试题，依然包括解题思路，源代码等等。问题描述：给定当前的时间，请用英文的读法将它读出来。时间用时h和分m表示，在英文的读法中，读一个时间的方法是：　　如果m为0，则将时读出来，然后加上“o’clock”，如3:00读作“threeo’clock”。　　如果m不为0，则将时读出来，然后将分读出来，如5

  6. 0基础学习软件测试有哪些建议 - 2

    其实现在基础的资料和视频到处都是，就是看你有没有认真的去找学习资源了，去哪里学习都是要看你个人靠谱不靠谱，再好的教程和老师，你自己学习不进去也是白搭在正式选择之前，大可以在各种学习网站里面找找学习资源先自己学习一下为什么选择学软件测试？同学们理由众多！大概分这几类：①不受开发语言、行业产品变化限制；②入门更简单，对零基础、女生都友好；③软件项目都需要测试人员，职业生涯稳；④学习周期短，但薪资并不低。要想“肩扛”一条线？需掌握三大技能：技能1：掌握测试流程，熟悉系统框架能提前与开发人员一起制定测试计划，通过测试左移，推动代码评审，代码审计，单元测试，自动化冒烟测试，来保证研发阶段的质量。技能2：

  7. “网安三人行”盘点：软件供应链安全的那些事儿 - 2

    2022年伊始，默安科技联合数世咨询举办以“软件供应链安全的时与势”为主题的访谈活动，由数世咨询创始人李少鹏主持，邀请贝壳安全研发负责人李文鹏、北京邮电大学副教授张文博、默安科技副总裁沈锡镛三位行业大咖做客网安小酒馆，从产业、企业、学术的不同维度，共同探讨软件供应链安全建设的新思路，为业界呈现了一场开年网安盛宴。随着全球软件供应链安全事件频发，软件供应链安全逐渐成为业界关注焦点，也成为影响国家重要信息系统安全与关键信息基础设施安全的重要因素，以及网络安全保障体系和能力建设的重要环节。嘉宾们围绕软件供应链安全发展的主要驱动力、关基行业中的实施现状和落地难点、产学研成果转化、软件供应链安全的重要性

  8. 十四届蓝桥青少组模拟赛Python-20221108 - 2

    十四届蓝桥青少组模拟赛Python-20221108T1.二进制位数十进制整数2在十进制中是1位数，在二进制中对应10，是2位数。十进制整数22在十进制中是2位数，在二进制中对应10110，是5位数。请问十进制整数2022在二进制中是几位数？print(len(bin(2022))-2)#运行结果：11T2.晨跑小蓝每周六、周日都晨跑，每月的1、11、21、31日也晨跑。其它时间不晨跑。已知2022年1月1日是周六，请问小蓝整个2022年晨跑多少天？#样例代码1ls=[0,31,28,31,30,31,30,31,31,30,31,30,31]ans=0k=6foriinrange(1,13)

  9. 蓝桥杯 stm32 MCP4017 - 2

    本文代码使用HAL库。文章目录前言一、MCP4017的重要特性二、MCP4017计算RBW阻值三、MCP4017地址四、MCP4017读写函数五、CubeMX创建工程（利用ADC测量MCP4017电压）、对应代码：总结前言一、MCP4017的重要特性蓝桥杯板子上的是MCP4017T-104ELT，如图1。MCP4017是一个可编程电阻，通过写入的数值可以改变电阻的大小。重点在于6引脚（W），5引脚（B&#

  10. [蓝桥杯单片机]学习笔记——串口通信的基本原理与应用 - 2

    目录一、原理部分1、什么是串行通信（1）并行通信与串行通信（2）串行通信的制式（3）串行通信的主要方式  2、配置串口（1）SCON和PCON：串行口1的控制寄存器（2）SBUF：串行口数据缓冲寄存器 （3）AUXR：辅助寄存器​编辑（4）ES、PS：与串行口1中断相关的寄存器（5）波特率设置  3、串口框架编写二、程序案例一、原理部分1、什么是串行通信（1）并行通信与串行通信微控制器与外部设备的数据通信，根据连线结构和传送方式的不同，可以分为两种：并行通信和串行通信。并行通信：数据的各位同时发送与接收，每个数据位使用一条导线，这种方式传输快，但是需要多条导线进行信号传输。串行通信：数据一位一

随机推荐