NEFU大一暑假集训-并查集（ABCDEFGIJ）

最新推荐文章于 2022-08-08 19:59:59 发布
最新推荐文章于 2022-08-08 19:59:59 发布
阅读量777 收藏
点赞数 1
分类专栏： # 比赛与题集 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tan_Yuu/article/details/119725281
版权

题集链接

目录：

OP

感谢ph和zsl两位大佬的指导与讨论；

A 食物链

思路

查看PDF即可~
两种做法，下面代码中选择了扩展域；

代码
#include <stdio.h>
#include<iostream>
using namespace std;
typedef long long ll;
int fa[150004];
int find(int x)
{
    if (fa[x] == x)
        return x;
    else
        return find(fa[x]);
}
int main()
{
    int n, k, ans = 0, o, a, b, i;
    cin >> n >> k;
    for (i = 1; i <= 3 * n; i++)
        fa[i] = i;
    while (k--)
    {
        scanf("%d%d%d", &o, &a, &b);
        if (a > n || b > n)
        {
            ans++;
            continue;
        }
        if (o == 1) //同类
        {
            if (find(a + n) == find(b) || find(a + 2 * n) == find(b))
                ans++;
            else
            {
                fa[find(a)] = find(b);
                fa[find(a + n)] = find(b + n);
                fa[find(a + 2 * n)] = find(b + 2 * n);
                //按同类维护
            }
        }
        else if (o == 2) //a吃b
        {
            if (find(a) == find(b) || find(a) == find(b + n))
                ans++;
            else
            {
                fa[find(a + n)] = find(b);
                fa[find(a + 2 * n)] = find(b + n);
                fa[find(a)] = find(b + 2 * n);
            }
        }
    }
    cout << ans;
}

B 关押罪犯

思路

详见PDF~；

贪心，优先分配矛盾最严重的，直到无法分配；

代码
#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const ll N = 100005;
int fa[N] = {0};
struct dat
{
    int a, b, c;
} da[N];
bool cmp(dat a, dat b)
{
    return a.c > b.c;
}
int find(int x)
{
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
int main()
{
    int n, m, i;
    cin >> n >> m;
    for (i = 1; i <= m; i++)
        scanf("%d%d%d", &da[i].a, &da[i].b, &da[i].c);
    sort(da + 1, da + 1 + m, cmp);
    for (i = 1; i <= 2 * n; i++)
        fa[i] = i;           //初始化
    for (i = 1; i <= m; i++) //贪心，从大到小找到第一个发生冲突的
    {
        if (find(da[i].a) == find(da[i].b)) //存在冲突
        {
            printf("%d", da[i].c);
            return 0;
        }
        else
        {
            fa[find(da[i].a)] = find(da[i].b + n);
            fa[find(da[i].b)] = find(da[i].a + n);
            //把一个加入另一个的扩展域，代表放入相异的集合
        }
    }
    printf("0");
    return 0;
}

C 程序自动分析

思路

详见PDF~；

先把要求相同的放在同一集合中，再查看要求不同的是否有冲突；

代码
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
typedef long long ll;
int fa[200005]; //fa数组
pair<int, int> e0[200005];
//存储需要不同值的数对，统一判冲
map<int, int> mp; //映射表
int c, ce0;
int find(int x)
{
    if (fa[x] == x)
        return x;
    return fa[x] = find(fa[x]);
}
int main()
{
    int t, n, a, b, e;
    cin >> t;
    while (t--)
    {
        mp.clear();
        c = 1, ce0 = 0; //初始化
        scanf("%d", &n);
        int f = 1;
        for (int i = 1; i <= 200000; i++) //初始化
        {
            fa[i] = i;
        }
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%d%d", &a, &b, &e);
            if (!mp[a])
                mp[a] = c++;
            if (!mp[b])
                mp[b] = c++;
            //若值不存在，则为其分配哈希值
            a = mp[a], b = mp[b];
            if (!e)
            {
                e0[ce0++] = {a, b};
            }
            else
            {
                fa[find(a)] = find(b); //合并
            }
        }
        for (int i = 0; i < ce0 && f; i++) //处理需要不同值的值对
        {
            if (find(e0[i].first) == find(e0[i].second))
                f = 0;
        }
        if (f)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}

D 最小生成树

思路

最小生成树板题~

这里是直接用天空之城代码改的；

代码
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int fa[200005], cnt[200005];
ll len[200005];
struct road
{
    int fr, to;
    ll lrd;
} rod[500005];
bool cmp(road a, road b)
{
    return a.lrd < b.lrd;
}
int find(int x)
{
    if (fa[x] != x)
        fa[x] = find(fa[x]);
    return fa[x];
}
int main()
{
    int n, q, i;
    while (~scanf("%d%d", &n, &q))
    {
        int g1,g2,glen;
        for (i = 1; i <= q; i++)
        {
            cin >> g1;
            cin >> g2;
            scanf("%d", &glen);
            rod[i].fr = g2, rod[i].to = g1, rod[i].lrd = glen; //存路
        }
        sort(rod + 1, rod + 1 + q, cmp);
        for (i = 1; i <= n; i++)
            fa[i] = i, cnt[i] = 1, len[i] = 0; //初始化并查集
        for (i = 1; i <= q; i++)
        {
            int frn = rod[i].fr, ton = rod[i].to;
            if (find(frn) != find(ton))
            {
                if (find(frn) > find(ton))
                    swap(frn, ton);
                cnt[find(frn)] += cnt[find(ton)];
                len[find(frn)] += len[find(ton)] + rod[i].lrd;
                fa[find(ton)] = find(frn);
            }
        }
        if (cnt[1] == n)
            printf("%lld\n", len[1]);
        /* else
            printf("No!\n"); */
    }
    return 0;
}

E Lomsat gelral

按秩合并思想

题目大意

给出树状结构和每个节点的颜色编号，输出以每个节点为根的子树出现次数最多的若干颜色编号之和；

思路

在dfs搜索时，对某节点下每个子树的颜色需要单独维护，如果对每一子树都重复进行维护和撤销，显然在处理以该节点为根的子树时又需要把这些子树再维护；
我们可以保留权重最大的子树，最后处理，处理后再维护其他子树的值，直接作为以该节点为根的整个子树的颜色统计；

对于颜色统计，我们可以用桶来维护，在搜索最大颜色时不必扫描整个桶数组，以子树的根节点进行dfs即可；

代码
#include <iostream>
#include <algorithm>
#include <string.h>
#include <math.h>
#include <map>
#include <vector>
using namespace std;

const int N = 1e5 + 10;

vector<int> E[N];
int col[N];
long long ans[N];
int tmp[N];
bool is[N];
int sz[N];
long long mxtmp, astmp;

void get_inf(int u, int fa = -1)
{
    int it;
    int maxx = -1;
    for (auto t : E[u])
    {
        if (t == fa)
            continue;
        get_inf(t, u);
        sz[u] += sz[t];
        if (sz[t] > maxx)
        {
            maxx = sz[t];
            it = t;
        }
    }
    if (maxx != -1)
        is[it] = true;
}

void clear(int u, int fa = -1)
{
    tmp[col[u]]--;
    for (auto t : E[u])
    {
        if (t == fa)
            continue;
        clear(t, u);
    }
}

void get_ans(int u, int fa, int p = -1)
{
    tmp[col[u]]++;
    if (tmp[col[u]] > mxtmp)
    {
        mxtmp = tmp[col[u]];
        astmp = col[u];
    }
    else if (tmp[col[u]] == mxtmp)
    {
        astmp += col[u];
    }
    for (auto t : E[u])
    {
        if (t == fa || t == p)
            continue;
        get_ans(t, u);
    }
}

void dfs(int u, int fa = -1)
{
    int p = 0;
    for (auto t : E[u])
    {
        if (t == fa)
            continue;
        if (is[t])
        {
            p = t;
            continue;
        }
        dfs(t, u);
        clear(t, u);
        mxtmp = astmp = 0;
    }
    if (p)
        dfs(p, u);
    get_ans(u, fa, p);
    ans[u] = astmp;
}

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
        scanf("%d", &col[i]), sz[i] = 1;
    for (int i = 1, u, v; i < n; i++)
    {
        scanf("%d%d", &u, &v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    get_inf(1);
    dfs(1);
    for (int i = 1; i <= n; i++)
        printf("%lld ", ans[i]);
    return 0;
}

F 修复公路

思路

最小生成树~

只不过这里求的是生成树中最大边权；

同样改自天空之城；

代码
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int fa[200005], cnt[200005]; //fa存该城所在集合的根节点（城市），cnt存以该城为根的集合城市数
ll len[200005]; //len存以该城为根的集合内部的连通代价
struct road
{
    int fr, to;
    ll lrd;
} rod[500005];
bool cmp(road a, road b)
{
    return a.lrd < b.lrd;
}
int find(int x)
{
    if (fa[x] != x)
        fa[x] = find(fa[x]);
    return fa[x];
}
int main()
{
    int n, q, i;
    while (~scanf("%d%d", &n, &q))
    {
        int g1,g2,glen;
        for (i = 1; i <= q; i++)
        {
            cin >> g1;
            cin >> g2;
            scanf("%d", &glen);
            rod[i].fr = g2, rod[i].to = g1, rod[i].lrd = glen; //存路
        }
        sort(rod + 1, rod + 1 + q, cmp);
        for (i = 1; i <= n; i++)
            fa[i] = i, cnt[i] = 1, len[i] = 0; //初始化并查集
        for (i = 1; i <= q; i++)
        {
            int frn = rod[i].fr, ton = rod[i].to;
            if (find(frn) != find(ton))
            {
                if (find(frn) > find(ton))
                    swap(frn, ton);
                cnt[find(frn)] += cnt[find(ton)];
                len[find(frn)] = max(len[find(ton)] , rod[i].lrd); //处理连通代价
                fa[find(ton)] = find(frn);
            }
        }
        if (cnt[1] == n)
            printf("%lld\n", len[1]);
        else
            printf("-1\n"); 
    }
    return 0;
}

G 奶酪

思路

这里用的是BFS；

代码
#include <queue>
#include <stdio.h>
#include <iostream>
#include <string.h>
using namespace std;
typedef long long ll;

struct ball
{
    double x,y,z;
} bll[1003];
int n;
double h,r;
bool gt[1003];
queue<int>que;

bool dis(int i,int j)
{
    return (bll[i].x-bll[j].x)*(bll[i].x-bll[j].x)+
            (bll[i].y-bll[j].y)*(bll[i].y-bll[j].y)+
             (bll[i].z-bll[j].z)*(bll[i].z-bll[j].z)<=4*r*r;
}

bool bfs()
{
    int f=0;
    while(!que.empty())
    {
        int now=que.front();
        if(h-bll[now].z<=r)
        {
            f=1;
            break;
        }
        que.pop();
        for(int i=1;i<=n;i++)
        {
            if(!gt[i]&&dis(i,now))
            {
                gt[i]=1;
                que.push(i);
            }
        }
    }
    if(f)
    {
        while(!que.empty())que.pop();
    }
    return f;
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        memset(gt,0,sizeof gt);
        scanf("%d%lf%lf",&n,&h,&r);
        for(int i=1;i<=n;i++)
        {
            scanf("%lf%lf%lf",&bll[i].x,&bll[i].y,&bll[i].z);
            if(bll[i].z<=r)
            {
                gt[i]=1;
                que.push(i);
            }
        }
        if(bfs())printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

I City

题目大意

给出城市，道路和道路强度，求问在不同强度的攻击下，有多少城市对之间仍有通路；

思路

显然，若对于每一次攻击重新进行搜索是不实际的；

由于高强度攻击下剩余的道路一定是低强度攻击下剩余道路的子集，所以我们可以从高到低处理询问，逐步添加道路；

代码
#include <queue>
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;
typedef long long ll;

struct road
{
    int a,b,z;
} rod[200005];
pair<pair<int,int> ,ll>tt[200005];
int fa[200005];
ll cnt[200005];
bool cmpr(road A,road B)
{
    return A.z>B.z;
}
bool cmpt(pair<pair<int,int> ,ll> A,pair<pair<int,int> ,ll> B)
{
    return A.first.second>B.first.second;
}
bool cmptt(pair<pair<int,int> ,ll> A,pair<pair<int,int> ,ll> B)
{
    return A.first.first<B.first.first;
}
int find(int x)
{
    return fa[x]==x?x:fa[x]=find(fa[x]);
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n,m,q;
        scanf("%d%d%d",&n,&m,&q);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&rod[i].a,&rod[i].b,&rod[i].z);
        }
        for(int i=1;i<=q;i++)
        {
            scanf("%d",&tt[i].first.second);
            tt[i].first.first=i;
        }
        sort(rod+1,rod+1+m,cmpr);
        sort(tt+1,tt+1+q,cmpt);
        for(int i=1;i<=n;i++)
        {
            fa[i]=i;
            cnt[i]=1;
        }
        int j=1;
        ll ans=0;
        for(int i=1;i<=q;i++)
        {
            //if(rod[j].z>=tt[i].first.second)
            for(j;rod[j].z>=tt[i].first.second;j++)
            {
                int faa=find(rod[j].a),fab=find(rod[j].b);
                if(faa!=fab)
                {
                    ans+=cnt[faa]*cnt[fab];
                    fa[faa]=fab;
                    cnt[fab]+=cnt[faa];
                }
            }
            tt[i].second=ans;
        }
        sort(tt+1,tt+1+q,cmptt);
        for(int i=1;i<=q;i++)
        {
            printf("%lld\n",tt[i].second);
        }
    }
    return 0;
}

J The Child and Zoo

“最大生成树”

题目大意

给定每一个节点的权重和网状结构，定义 f ( i , j ) f(i,j) f(i,j)为 i 到 j 的所有简单路径中，途径节点最小值的最大值；
求
在这里插入图片描述

思路

对于每条道路，道路的权值即可认为是道路两端节点权值的最小值；

从大到小排列所有道路，生成“最大生成树”，对于每次连接操作，即可认为道路一段所在区块与另一端所在区块的元素两两之间的 f 值均为此道路的权值；

代码

代码依然修改自天空之城；

#include <iostream>
#include <algorithm>
#include <string.h>
#include <math.h>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
int fa[200005], cnt[200005],qu[200005];
ll len[200005];              //len存以该城为根的集合内部的连通代价
struct road
{
    int fr, to;
    ll lrd;
} rod[500005];
bool cmp(road a, road b)
{
    return a.lrd > b.lrd;
}
int find(int x)
{
    if (fa[x] != x)
        fa[x] = find(fa[x]);
    return fa[x];
}
int main()
{
    int n, q, i;
    scanf("%d%d", &n, &q);
    for(int i=1;i<=n;i++)scanf("%d",&qu[i]);
    int g1, g2, glen;
    for (i = 1; i <= q; i++)
    {
        cin >> g1;
        cin >> g2;
        //scanf("%d", &glen);
        rod[i].fr = g2, rod[i].to = g1, rod[i].lrd = min(qu[g1],qu[g2]); //存路
    }
    sort(rod + 1, rod + 1 + q, cmp);
    for (i = 1; i <= n; i++)
        fa[i] = i, cnt[i] = 1, len[i] = 0; //初始化并查集
    ll ans=0;
    for (i = 1; i <= q; i++)
    {
        int frn = rod[i].fr, ton = rod[i].to;
        if (find(frn) != find(ton))
        {
            if (find(frn) > find(ton))
                swap(frn, ton);
            ans+=(ll)rod[i].lrd*cnt[find(frn)]*cnt[find(ton)];
            cnt[find(frn)] += cnt[find(ton)];
            len[find(frn)] += len[find(ton)] + rod[i].lrd;
            fa[find(ton)] = find(frn);
        }
    }
    printf("%.6lf\n", 1.0*ans/(1.0*n*(n-1)/2));

    return 0;
}

ED

\

Tan_Yuu
关注
专栏目录
nefu-数据库实验-数据查询和视图操作
God_linlin的博客
11-21 482
数据库实验二
nefu 算法设计实验-递归与分治
nefu__lian的博客
11-09 579
1.递归与分治 2. 动态规划 3. 贪心算法 4. 回溯算法 文章目录1. 棋盘覆盖问题2、合并排序问题3、集合最大元问题4、循环赛日程表 1. 棋盘覆盖问题 在一个2k×2k 个方格组成的棋盘中，恰有一个方格与其它方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。在棋盘覆盖问题中，要用4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。 #include <iostream> #include <bits/stdc++
NEFU大一暑假集训-树状数组
Tan_Yuu的博客
08-19 635
题集链接 目录：OPA Ultra-QuickSort题目大意思路代码B Stars题目大意思路代码C Mobile phones题目大意思路代码D Cows题目大意思路代码E Get Many Persimmon Trees题目大意思路代码F Matrix题目大意思路代码G MooFest题目大意思路代码H Disharmony Trees思路代码I KiKi's K-Number题目大意思路代码J Reverse Prime题目大意思路代码ED OP 感谢学长的讲解与付出； 感谢ph和zsl两位大佬的指
NEFU大一暑假集训-KMP
Tan_Yuu的博客
08-02 768
题集链接 目录：OPA 剪花布条题目大意思路代码B Power Strings题目大意思路代码C Radio Transmission题目大意思路代码D OKR-Periods of Words题目大意思路代码E 似乎在梦中见过的样子题目大意思路代码F Censoring题目大意思路代码G Compress Words题目大意思路代码ED OP 感谢学长的讲解与付出； 感谢ph和zsl两位大佬的指导与讨论； KMP可以在线性复杂度内求出给定字符串任意前 i 个元素构成字串的最长相等前后缀，并可以以此进一步进
NEFU大一暑假集训-同余
Tan_Yuu的博客
08-05 606
题集链接 目录：OPA Relatives题目大意思路代码B Brute-force Algorithm题目大意思路代码C Sum题目大意思路代码D 同余方程思路代码E SHUFFLE 洗牌思路代码F 树的计数思路代码G AquaMoon and Chess题目大意思路代码ED OP 感谢学长的讲解与付出； 感谢ph和zsl两位大佬的指导与讨论； 夹点私货： 这些题涉及到的内容都已经更新到自己的笔记中： 数学（快速幂，欧拉函数，欧拉定理，扩展欧里几得算法，逆元） 树与图论（Prufer数列） 排列组合（lu
NEFU大一暑假集训-字典树
Tan_Yuu的博客
07-29 202
题集链接 目录：OPA L语言题目大意思路代码B Secret Message 秘密信息题目大意思路代码C The XOR-longest Path题目大意思路代码D The XOR Largest Pair题目大意思路代码E Phone List题目大意思路代码F Xor sum题目大意思路代码ED OP 感谢学长的讲解与付出； 感谢ph和zsl两位大佬的指导与讨论； 目前来看，字典树主要用于线性复杂判断给定字符串与字典有没有前缀关系，和给定目标下异或值的求取； A L语言 题目大意 给定字典，问题给字符
2022-nefu-数据结构课设完整版本
最新发布
09-27
在这个“2022-nefu-数据结构课设完整版本”中，我们可以看到一个针对东北林业大学（NEFU）学生的数据结构课程设计项目。这个项目的完整版本包括了源码，这意味着我们可以深入学习和理解每个数据结构的实现细节。 ...
nefu-Web：WEB课程设计-----软件工程专业网站
02-02
nefu-Web 一个WEB课设 功能 主要板块内容：专业介绍，新闻，公告，实验室，教师队伍，优秀毕业生等 管理员登录后，可在后台对新闻公告信息进行增删改改查 过滤器，非管理员无法使用管理功能 主页列出最近4个新闻与...
nefu-开源
05-15
"nefu-开源"是一个专为网络服务监控设计的实用工具，名为Network Fidelity Utility。这个项目遵循开源软件的理念，允许用户查看、分析并管理网络的稳定性和性能。开源软件的核心价值在于其开放源代码，这意味着任何...
2021年东北林业大学蓝桥杯选拔赛（软件类）（A B C D F G H）
Tan_Yuu的博客
03-13 2866
比赛链接：这里 目录OPA 股神思路代码B 酒馆决斗思路代码C 求 k 整除最大元素和思路代码D 取快递思路代码F 幸运数字思路代码G 有限小数H 子数组和思路代码ED OP A 股神 贪心 / DP 思路 朴素的贪心思想： 次日若比此日股价高，且没有买入，则所有金币买入； 次日若比此日股价低，且有买入，则全部卖出； 注意输出时转换成金币输出； 注意浮点误差； 注意第0天也可以进行买入操作。 代码 #include <bits/stdc++.h> using namespace std; typ
NEFU 2021大一寒假集训总结赛 全题解
Tan_Yuu的博客
02-05 2432
比赛链接：这里 OP 肝了两个半小时A，没过…… sl大佬也写题解了 A SET 最大公约数 思路 任选两数 a,b 做 2*a-b 运算，可以理解成 a + a - b ，即 a 加上两数的差； 如果我们现在有 2 * a - b , a 即可通过 2 * ( 2 * a - b ) - a 得到 a + 2 * ( a - b )，即 a 加上两数差的二倍； 那所有可能被加入集合的元素即满足 ai+mj∗(ai−aj)a_i+ m_j * ( a_i - a_j )ai​+mj​∗(ai​−aj​) 枚
2022牛客暑期多校训练营1（ACDGIJ）
Tan_Yuu的博客
07-22 1610
目录：A Villages: Landlines C Grab the Seat! D Mocha and Railgun G Lexicographical Maximum I Chiitoitsu J Serval and Essay ED
2021年度训练联盟热身训练赛第五场（A B C E F G H I）
Tan_Yuu的博客
04-11 1583
比赛链接 目录OPA Binary Seating思路代码B Cutting Corners思路代码C Ducky Debugging思路代码E Figure Skating思路代码F Group Project思路代码H In-place Sorting思路代码I Jam-packed二分解法思路代码O(1)解法思路代码ED OP 前面几道题还是比较快乐的，后面就开始日常罚坐了； A Binary Seating 概率 思路 求离场时间的期望； 离场时间只与本考场考试用时最长的学生有关; 假设参加考试共n
长沙学院飞腾迈创杯2022年新生赛（全题解）
Tan_Yuu的博客
05-07 1311
题集链接 目录：OPA 小贪一手思路代码B A+B Problem (very easy)思路代码C Alice and Bob思路代码D 进化思路代码E 防疫物资思路代码F 有挂思路代码G思路代码H 爱美之心人皆有之思路代码I 签签签到思路代码 OP 标准的新生赛，所以补得比较快~ 下次出题的时候结构可以参考一下这场，难度分布还比较适用； A 小贪一手 贪心 思路 出于取模的性质，我们可以直接构造~ 由于保证了解一定存在，也不需要担心无解的问题； 代码 #include <bits/stdc++.h
牛客非大白月赛45（全题解）
Tan_Yuu的博客
03-04 1307
题集链接 目录：OPA 悬崖思路代码B 数数思路代码C 山楂思路代码D 切糕思路代码E 筑巢思路代码F 交换思路代码ED OP A 悬崖 思路 只需要特殊考虑第一次跳不到对面的情况，此时总距离为 x ； 其余情况共可跳 n 次，每次距离 x ； 代码 #include <bits/stdc++.h> using namespace std; typedef long long ll; int main() { ll n,x; cin>>x>>n;
NEFU大一省赛训练1（全题解）
Tan_Yuu的博客
05-03 1297
目录OPA 哪些数不在思路代码B 闹钟思路代码C 减法思路代码D 隧道思路代码ED OP 一个半小时七道题，两个小时一道题555； G题鲨我； A 哪些数不在 前缀差分？（好像是叫这个） 思路 即在区间左端点标记+1，右端点标记-1； 遍历所有可行范围，遇到+1即计数值+1，-1亦然； 处理好开闭问题后，计数值为0的位置即没有被线段覆盖； 代码 #include<bits/stdc++.h> using namespace std; typedef long long ll; int main
2022牛客暑期多校训练营6（ABGIJM）
Tan_Yuu的博客
08-08 1273
A Array B Eezie and Pie G Icon Design I Line J Number Game M Game on grid
NEFU大一暑假集训-尺取法
Tan_Yuu的博客
07-20 1083
题集链接 目录：OPA Subsequence题目大意思路代码B Jessica's Reading Problem题目大意思路代码C Bound Found题目大意思路代码D Sum of Consecutive Prime Numbers题目大意思路代码E NanoApe Loves Sequence Ⅱ题目大意思路代码F They Are Everywhere题目大意代码G Graveyard Design题目大意思路代码H Xor Sum 2题目大意思路代码I Petya and Array题目大意
nefu数字逻辑系统设计
05-21
东北林业大学（NEFU）的数字逻辑系统设计课程主要涉及数字电路的基础理论和设计方法，包括数字信号的表示和处理、逻辑门电路的设计、组合逻辑电路和时序逻辑电路的设计等。 在该课程中，你将学习数字电路的基本概念、布尔代数、Karnaugh图、编码器和解码器、多路选择器和多路译码器、触发器和计数器、寄存器和存储器等内容。你还将学习使用Verilog HDL语言进行数字电路的设计与仿真。 通过学习NEFU数字逻辑系统设计课程，你将掌握数字电路的设计方法和实现技术，能够独立设计和实现数字电路系统，从而为你的未来职业发展打下坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值