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

最新推荐文章于 2022-07-22 15:19:49 发布
最新推荐文章于 2022-07-22 15:19:49 发布
阅读量792 收藏
点赞数 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 499
数据库实验二
nefu 算法设计实验-递归与分治
nefu__lian的博客
11-09 594
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 648
题集链接 目录：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 780
题集链接 目录：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 620
题集链接 目录：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 216
题集链接 目录：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语言 题目大意 给定字典，问题给字符
NEFU大一暑假集训-尺取法
Tan_Yuu的博客
07-20 1097
题集链接 目录：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大一暑假集训-矩阵连乘
Tan_Yuu的博客
08-12 650
题集链接 目录：OPA Fibonacci Numbers题目大意思路代码B How Many Fibs?题目大意思路代码C Fibonacci Again题目大意思路代码D Hat's Fibonacci题目大意思路代码E Fibonacci题目大意代码F Another kind of Fibonacci题目大意代码G Fibonacci Subsequence题目大意思路代码ED OP 感谢老师的讲解与付出； 感谢ph和zsl两位大佬的指导与讨论； 夹带私货： 此节课的代表性内容和例题也已经整理到自己
NEFU大一暑假集训-Hash（ABCDEH）
Tan_Yuu的博客
07-28 608
题集链接 目录：OPA Snowflake Snow Snowflakes题目大意思路代码B Palindrome题目大意思路代码C Squares题目大意思路代码D 对称二叉树题目大意思路代码E 企鹅QQ题目大意思路代码H Ones题目大意思路代码ED OP 感谢学长的讲解与付出； 感谢ph和zsl两位大佬的指导与讨论； 这组题做得我脑袋疼hhh； A Snowflake Snow Snowflakes 题目大意 按顺序给定 n 片雪花的每个枝的长度，判断是否有相同的雪花存在； （相同指经旋转/对称后完全
NEFU大一暑假集训-前缀和与差分（LMRSTUVXYZ）
Tan_Yuu的博客
07-24 592
题集链接 目录：OPL 字段求和题目大意代码M Alyona and a tree题目大意思路代码R 前缀和题目大意代码S 校门外的树题目大意思路代码T 激光炸弹题目大意思路代码U 天上的星星题目大意思路代码V 程序设计：蒜头君的数轴题目大意思路代码X 拍照题目大意思路代码Y Saitama Destroys Hotel题目大意思路代码Z Greg and Array题目大意思路代码ED OP 感谢老师的讲解与付出； 感谢ph和zsl两位大佬的指导与讨论； 题量好大XD； 如果用甲子命名法就可以出60道了；
NEFU 大一寒假训练 - Index
果光的博客
02-13 1844
NEFU 大一寒假训练内容汇总 本文汇总一下NEFU 大一寒假训练的所有内容，方便查找。 本人比较菜，部分题目思路方法可能很笨 (～￣(OO)￣)ブ 欢迎各位大佬们提出宝贵的意见和建议 ヾ(•ω•`)o 训练题目 NEFU 大一寒假训练一（二维数组及结构体）2019.12.31 NEFU 大一寒假集训二（排序）2020.01.01 NEFU 大一寒假集训三（暴力枚举）2020.01.02 ...
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 2905
比赛链接：这里 目录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 2489
比赛链接：这里 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 1646
目录：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 1600
比赛链接 目录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
牛客非大白月赛45（全题解）
Tan_Yuu的博客
03-04 1342
题集链接 目录：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计算机组成原理实验教程及报告汇总
资源摘要信息:"本资源为NEFU计算机组成原理实验的压缩包，包含了四个实验及其对应的实验报告。该实验包适用于希望通过实践操作加深对计算机基础组成和工作原理理解的学习者。资源利用了Logisim这一数字逻辑模拟工具...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值