云智计划_数据结构_并查集

     算法介绍

其实没什么好说的

注意几个点

1.fa[i]=i;

2.按秩合并(亦称启发式合并)与路径优化可以同时存在,只有一个复杂度为O(nlog n),两个都用就是O(nα(n)),相当于O(n)

α()在1e6的数据下,也只有5,比常数还常数

代码

/* by 01022.hk - online tools website : 01022.hk/zh/blood.html */ int find(int x){return(fa[x]==x?x:fa[x]=find(fa[x]));}

/* by 01022.hk - online tools website : 01022.hk/zh/blood.html */
void marge(int a,int b)
{
    x=find(x);y=find(y);
    if(a==b)return ;
    else fa[a]=b;//实在复杂度就是差一点,可以写个按秩排序
}

 基础例题

1.P1111 修复公路 - 洛谷

其实就是板子

并查集特征:只关心谁与谁在同一集合

知识点:离线处理

然后就没辣

Talk is cheap,show me the code
//https://www.luogu.com.cn/problem/P1111
//P1111 修复公路
#include<iostream>
#include<algorithm>
#define maxm 100010
#define maxn 1010
using namespace std;
struct EDGE
{
    int u,v,tim;
}edge[maxm];
int tot;
void add(int u,int v,int tim)
{
    edge[++tot].v=v;
    edge[tot].tim=tim;
    edge[tot].u=u;
}
bool rule(EDGE a,EDGE b)
{
    return a.tim<b.tim;
}
int fa[maxn];
int fd(int x){return(fa[x]==x?x:fa[x]=fd(fa[x]));}
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
    }
    sort(edge+1,edge+tot+1,rule);
    for(int i=1;i<=n;i++)fa[i]=i;
    int ans=0;
    for(int i=1;i<=m;i++)
    {
        int u=edge[i].u,v=edge[i].v;
        if(fd(u)==fd(v))continue;
        ans=edge[i].tim;
        fa[fd(u)]=fd(v);
    }
    int root=fd(1);
    for(int i=2;i<=n;i++)if(fd(i)!=root)return cout<<-1,0;
    cout<<ans;
    return 0;
}

我这个做法没写按秩还是AC了

然后就是我这个无论如何都等到了m条边遍历完

如果是在循环中统计集合个数,==1直接return输出,循环出来-1会更快

2.P1955 [NOI2015] 程序自动分析 - 洛谷

这道题其实特别简单

最开始我以为只需要半离线

把≠先离线(其实就相当于讯问了)

然后=具有传递性,直接放在同一集合

最后看看离线下来那些≠

在同一集合直接X

但是!!

1i,j1e9

看到这玩意直接吓哭孩子了

证据:#define maxi 1000000010

其实仔细一想,最多只会用到2n个数,其他的都没意义

(于是我开始尝试在不知道有“离散化”这个东西的情况下,手搓离散化)

(最开始想的是结构体存储对应关系,后来想到要1~tot循环查找2n次)

(时间复杂度直接飙升n^2,直接放弃了)

(看了题解才知道——啥玩意?有专门的算法?叫“离散化”?)

离散化

总得来说离散化有三步走战略:

1.去重(可以用到unique去重函数)排序

2.

3.二分索引(可以用到lower_bound函数)

(摘自 追梦_Chen)

见这篇博客

举例:

a:{1,100,10,10000,1000,100}——原数组

t:{1,100,10,10000,1000,100}——复制

t:{1,10,100,100,1000,10000}——排序

t:{1,10,100,1000,1000}——unique//若有不需去重的,有更好做法,还是见那篇博客

去重后不相同元素的个数:就是函数返回值减去集合的初始位置。

  • a 这里的删除不是真的delete,而是将重复的元素放到容器末尾
  • b 一定要先对数组进行排序才可以使用unique函数
  • c unique函数的返回值是去重之后的尾地址

(引自 博客)

a:{1,3,2,5,4,5}——lower_bound

具体解释最后一行

a[1]:1//我喜欢从1开始

在t里找到1的下标——1

a[1]=1

a[2]:100

在t里找到100的下标——3

a[2]=3

以此类推

 

因为要离散化,所以必然先离线

剩下的就最开始说的就行了

进士侯人!!

fa数组和离散化数组这些同时涉及到等号左右两个数的这些数组

大小要开2*n!!!

因为n条(不)等式会最多有2*n个数

Talk is cheap , show me the code
//https://www.luogu.com.cn/problem/P1955
//P1955 [NOI2015] ³ÌÐò×Ô¶¯·ÖÎö
#include<iostream>
#include<algorithm>
#include<cstring>
#define maxn 100010
using namespace std;
struct REQU
{
    int x,y,relation;
}a[maxn];
int cre[2*maxn];//一定别忘了开二倍!!!!因为每条指令两个数字
int tot,u[maxn],v[maxn];//赛博半离线
int fa[2*maxn];
int find(int x){return (fa[x]==x?x:fa[x]=find(fa[x]));}
void marge(int x,int y)
{
    x=find(x);y=find(y);
    if(x==y)return;
    fa[x]=y;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        tot=0;
        memset(a,0,sizeof(a));
        memset(cre,0,sizeof(cre));
        cin>>n;
        for(int i=1;i<=n;i++)cin>>a[i].x>>a[i].y>>a[i].relation;

        //*+*+*+*+*+*+*离散化Discretization*+*+*+*+*+*+*
        for(int i=1;i<=n;i++)cre[i]=a[i].x;
        for(int i=1;i<=n;i++)cre[i+n]=a[i].y;
        sort(cre+1,cre+n+n+1);
        int m=unique(cre+1,cre+n+n+1)-cre-1;
        //其实unique是有返回值的,返回值是去重之后的尾地址,减去头地址就是个数
        for(int i=1;i<=n;i++)a[i].x=lower_bound(cre+1,cre+m+1,a[i].x)-cre;//是m不是n+n
        for(int i=1;i<=n;i++)a[i].y=lower_bound(cre+1,cre+m+1,a[i].y)-cre;
        //lower:大于等于,upper:大于
        //我们这里是找等于
        //*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*

        for(int i=1;i<=m;i++)fa[i]=i;
        for(int i=1;i<=n;i++)
        {
            if(a[i].relation==0)
            {
                u[++tot]=a[i].x;
                v[tot]=a[i].y;
                continue;
            }
           marge(a[i].x,a[i].y);
        }
        bool yes=1;
        for(int i=1;i<=tot;i++)
            if(find(u[i])==find(v[i]))
                yes=0;
        if(yes==1)cout<<"YES\n";
        else cout<<"NO\n";
    }
    return 0;
}

然后补充一点:lower_bound那一行,要的就是把数字替换成下标,所以a[i].xy就是直接等于下标

3.P1197 [JSOI2008] 星球大战 - 洛谷

刚开始看这道题,我的第一反应是:

因为这个需要考虑连边方式了,所以感觉就不像是并查集能做出来的题啊

果然:老师:断边维护联通块数量是困难的

我:离线化处理,从最后删的边一条一条加(时光倒流)

被自己的想法吓了一跳

竟然对了!

我的思路:先离线,然后遍历所有删除的点标vis

然后建图,遇到vis=1时,把这条边先存在vis=1的点(可能两个都是)里

可以开一个vector

然后时光倒流,把当前点所有边所指向的联通块的根节点的父亲设置为这个边

最后,完全正确

Talk is cheap , show me the code.
//https://www.luogu.com.cn/problem/P1197
//P1197 [JSOI2008] ÐÇÇò´óÕ½
#include<iostream>
#include<vector>
#define maxm 200010
#define maxn 400020
using namespace std;
int n,m,k;
int u[maxm],v[maxm];
bool vis[maxn];
int a[maxn];
int fa[maxn];
int ans[maxn];
vector <int> mp[maxn];
int find(int x){return (fa[x]==x?x:fa[x]=find(fa[x]));}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)cin>>u[i]>>v[i];
    cin>>k;
    for(int i=1;i<=k;i++)cin>>a[i];
    for(int i=1;i<=k;i++)vis[a[i]]=1;
    for(int i=0;i<n;i++)fa[i]=i;
    int block=n-k;
    for(int i=1;i<=m;i++)
    {
        int x=u[i],y=v[i];
        if(vis[x]==1)
        {
            mp[x].push_back(y);
        }
        if(vis[y]==1)
        {
            mp[y].push_back(x);
        }
        if(vis[x]==0&&vis[y]==0)
        {
            x=find(x);y=find(y);
            if(x!=y)
            {
                block--;
                fa[y]=x;
            }
        }
    }
    ans[k+1]=block;
    for(int i=k;i>=1;i--)
    {
        int p=a[i];
        vis[p]=0;
        block++;
        for(auto to:mp[p])
        {
            if(vis[to]==1)continue;
            if(find(to)!=find(p))
            {
                block--;
                fa[find(to)]=find(p);
            }
        }
        ans[i]=block;
    }
    for(int i=1;i<=k+1;i++)cout<<ans[i]<<"\n";
    return 0;
}

总结:正难则反

常见类型:时间倒流


带权并查集

额外支持操作:

1.给某个元素所在集合当前时刻所在这个集合的所有元素加一个值

2.查询某个元素的值

暴力/朴素操作:

每个点有一个值tag,代表当前点所在子树内,所有的点都要加上这个值

加一个值的时候,加到这个点所在集合代表元素(根)的tag上

查询一个值时,查询的是从根节点到该节点路径上所有tag和

进行集合合并时,把a指向b时,a要减去b的tag

因为b的tag本来只分给b所在子树

结果先a所在子树也在b所在子树内了

如果不做减法操作,那么b的tag就会分给a所在子树

但其实a所在子树并没有这个tag

有点抽象,举个例子

带权并查集详细图解

三个点123(红色代表实际值,方便观察与理解,黄色代表要记录的tag)

image

先将2+1,表现为代表元素(2)的tag+1

image

再将2和3合并(2指向3)

所以2的tag要减3的tag,1-0=1

image

然后再将2+2,表现为代表元素(3)的tag+2

image

此时,查询2的值,从2的tag一路加到树根3的tag

1+2=3

而查询3的值,就是3的tag本身,为2

再将1的值+1

image

1指向3

此时,1的tag要减去3的tag,1-2=-1

image

什么?竟然可以出现负数?我一直在加正权值啊

别急,tag并不是-1的值

此时,查询1的值,会发现是1与3的tag相加

-1+2=1

现在好懂多了吧

优化

按秩合并还是那个样,记录size,size小的的fa设置为大的那个

然后大的size+=小的size,这样优化完O(n logn)

但是我们亲爱敬爱的路径压缩就有问题了

因为我们的真实值是要计算一路到达根节点的所有tag的

你这样直接接到根节点上肯定不行

难道你那一路上的所有tag都不要了?

那么,路径压缩,路径压缩

压缩路径不就完事了

把从根节点

(根节点不计入内,因为你接入根节点后,还是要加根节点的tag)

到这个点的路径上的权值加起来

作为这个点新的tag

即新tag=真实值-根节点tag

(根节点tag其实就是根节点真实值)

复杂度也是O(n logn)

P1196 [NOI2002] 银河英雄传说 - 洛谷

这道题其实挺简单的

tag[a]=sz[b];
sz[b]+=sz[a];
fa[a]=b;

这可以算是这道题的状态转移方程吧……

推了有一段时间才推出来的

特点就是需要单独维护一个sz数组,其他的就是带权并查集模板

这是带权并查集的路径压缩
嘻嘻

由于这道题,易证根节点tag恒为0

所以孩子节点路径压缩可以多次加根节点的值

压缩后的孩子节点tag-根节点tag=孩子节点tag-0=孩子节点tag=实际值(前面还有几个战舰)

因为在输出答案之前,肯定事先跑过一遍find,压缩完了

所以输出答案时可以不用算,直接用tag就行

其余的横看竖看也没看出来啥特别的

毕竟只是绿题

那就这样吧

Talk is cheap, show me the code
//https://www.luogu.com.cn/problem/P1196
//P1196 [NOI2002] ÒøºÓÓ¢ÐÛ´«Ëµ
#include<iostream>
#define maxn 30010
using namespace std;
int fa[maxn],sz[maxn],tag[maxn];
int find(int x)
{
    if(fa[x]==x)return x;//递归·终止条件
    int f=find(fa[x]);//先全部跑一遍,让每一个递归嵌套内的f=根节点
    tag[x]+=tag[fa[x]];//从根节点往下一层一层累加
    return fa[x]=f;//最后直接指向根节点
}
int main()
{
    for(int i=1;i<=30000;i++)fa[i]=i,sz[i]=1;
    int t;
    cin>>t;
    while(t--)
    {
        int a,b;
        char c;
        cin>>c>>a>>b;
        if(c=='M')
        {
            a=find(a);
            b=find(b);
            tag[a]=sz[b];
            sz[b]+=sz[a];
            fa[a]=b;
        }
        else
        {
            if(find(a)!=find(b))cout<<-1<<"\n";
            else
            {
                int x=tag[a],y=tag[b];
                if(x>y)swap(x,y);
                cout<<y-x-1<<"\n";
            }
        }
    }
    return 0;
}

本文来自博客园,作者:永韶,转载请注明原文链接:https://www.cnblogs.com/yongshao/p/19234879

内容概要:本文系统研究了电力系统短期负荷预测问题,提出并实现了基于极限学习机(ELM)及其智能优化改进模型的预测方法。研究涵盖标准ELM、白鲸优化算法(BWO)优化ELM和鹭鹰优化算法(IBOA)优化ELM三种模型,重点通过智能优化算法对ELM的输入权重与偏置参数进行全局寻优,有效克服了传统ELM因参数随机初始化导致的不稳定性和泛化能力不足的问题。文章完整呈现了从数据预处理、特征选择、模型构建、参数优化到预测结果对比分析的全流程,利用Matlab编程实现各模型的仿真验证,显著提升了预测精度与模型鲁棒性,为电力系统调度决策提供了可靠的技术支撑。; 适合人群:具备电力系统基础知识、时间序列预测理论及Matlab编程能力的高校研究生、科研机构研究人员以及电力公司从事负荷预测、电网调度与规划工作的技术人员。; 使用场景及目标:①应用于实际电力系统短期负荷预测业务中,提升电网运行调度的精细化与智能化水平;②作为智能优化算法与神经网络融合的经典案例,服务于学术论文撰写、科研项目申报及算法性能对比研究;③应对新能源大规模接入背景下负荷波动加剧的挑战,为构建高精度、强鲁棒性的现代负荷预测体系提供解决方案。; 阅读建议:建议读者结合所提供的Matlab代码进行动手实践,深入理解ELM网络结构与优化算法的集成机制,重点对比分析不同优化策略在收敛速度、预测误差(如MAE、RMSE、MAPE)等方面的性能差异,进而掌握智能优化技术在提升预测模型性能方面的关键作用。
内容概要:本文研究了基于Benders分解与输电网运营商(TSO)和配电网运营商(DSO)协调机制的不确定环境下输配电网双层优化模型,旨在提升高比例可再生能源接入背景下电网系统的协调性与鲁棒性。模型上层以系统整体经济性为目标进行优化调度,下层采用Benders分解实现TSO与DSO之间的信息交互与协同决策,通过引入割平面迭代机制保障求解的收敛性与全局最优性。研究充分考虑新能源出力与负荷需求的不确定性,构建了具有强适应性的双层优化框架,并基于Matlab完成了模型的编程实现与仿真验证,有效解决了多主体、多层级、多不确定性因素耦合下的电力系统优化调度难题。; 适合人群:具备电力系统分析、运筹学与优化理论基础,熟悉Matlab编程环境,从事智能电网、能源互联网、分布式能源集成、电力市场等方向的研究生、科研人员及工程技术人员。; 使用场景及目标:①研究高渗透率可再生能源条件下输配电网协同优化调度策略;②掌握Benders分解在电力系统双层优化建模中的应用方法与实现技巧;③构建TSO-DSO多主体协调机制,实现跨层级电网资源的高效互动与决策解耦;④提升对不确定性建模、分解算法设计及大规模优化问题求解能力。; 阅读建议:建议读者结合Matlab代码逐模块剖析模型构建流程,重点理解Benders割的生成逻辑、主从问题的信息传递机制及收敛判据设定,推荐在标准IEEE测试系统上复现实验以深入掌握模型特性与算法性能。
内容概要:本文提出了一种基于断线解环思想的配电网辐射状拓扑约束建模方法,旨在通过Matlab代码实现确保配电网在重构或运行过程中始终保持辐射状结构,防止环路形成,从而提升系统的安全性与稳定性。该方法通过系统性地识别网络中的潜在环路,并依据拓扑规则自动切断特定支路,有效处理配电网在优化调度、故障恢复及网络重构中的拓扑约束问题。文中详细阐述了算法的核心逻辑、数学模型构建过程、实现步骤及关键判据,并结合标准测试系统进行了仿真验证,充分证明了该方法在复杂配电网络中的有效性与实用性,尤其适用于含分布式电源接入的智能配电网场景。; 适合人群:具备一定电力系统分析基础和Matlab编程能力的高校研究生、科研人员,以及从事配电网自动化、智能电网优化、电力系统运行与控制等相关领域的工程技术人员。; 使用场景及目标:①解决配电网重构过程中的辐射状拓扑可行性验证与约束建模问题;②支撑含高比例分布式电源的配电网在故障恢复、动态重构中的安全运行分析;③为相关高水平EI期刊论文的模型复现、算法验证及科研项目申报提供可靠的代码实现与技术参考。; 阅读建议:建议读者结合Matlab代码与电力网络拓扑理论进行同步学习,重点理解断线解环的图论基础、环路搜索算法及支路断开逻辑的实现机制,并尝试在不同规模的测试系统(如IEEE 33节点系统)上进行仿真调试,以深入掌握该方法的应用技巧与优化潜力。
内容概要:本文围绕基于元模型优化算法的主从博弈多虚拟电厂动态定价与能量管理展开研究,提出了一种结合主从博弈理论与元模型优化方法的协同决策框架,通过Matlab代码实现,旨在解决高比例可再生能源接入背景下多虚拟电厂在复杂电力市场环境中的协调优化难题。研究构建了上层领导者(如主网或运营商)与下层跟随者(各虚拟电厂)之间的非对称互动模型,实现了动态电价制定与多主体能量调度的联合优化,有效提升了系统整体运行效率、经济收益与市场公平性。文中详细阐述了模型构建过程、算法设计思路及仿真验证方案,重点突出了元模型在降低计算复杂度、处理不确定性因素以及加速求解收敛方面的优势,具有较强的工程复现价值与理论参考意义。; 适合人群:具备一定电力系统运行、博弈论基础、优化建模能力及Matlab编程技能的研究生、科研人员,以及从事虚拟电厂运营、能源互联网规划、智能电网调度等相关领域的技术人员。; 使用场景及目标:①用于多主体能源系统中市场机制设计与竞价策略分析;②支撑含分布式能源的主动配电网协同优化调度研究;③为虚拟电厂参与电力市场的动态定价、需求响应与能量管理提供仿真验证平台与解决方案参考。; 阅读建议:建议读者结合Matlab代码逐模块理解算法实现流程,重点关注主从博弈架构的数学建模方式与元模型近似优化技巧的应用细节,同时可通过调整市场参数、负荷场景或可再生能源出力数据进行拓展性实验,以深化对模型鲁棒性与泛化能力的理解。
内容概要:本文围绕列车-轨道-桥梁耦合系统开展动力学交互仿真研究,基于Matlab平台构建多体动力学数值模型,综合考虑列车移动荷载、轨道结构特性与桥梁动态响应之间的耦合作用,实现对列车通过桥梁过程中振动传递规律、结构受力特性和动力响应行为的精确模拟。研究涵盖系统建模、运动方程求解、关键参数设定及仿真结果分析全过程,提供完整的Matlab代码实现方案,有助于深入理解轨道交通基础设施在运营条件下的动力性能,为桥梁结构安全性评估、轨道平顺性优化及减振设计提供理论支持和技术手段。; 适合人群:具备一定结构动力学、振动力学基础知识及Matlab编程能力的研究生、高校教师、科研机构研究人员以及从事铁路与桥梁工程设计、运维的工程技术人才。; 使用场景及目标:①用于高速铁路桥梁在列车荷载作用下的动力响应仿真与安全评估;②支撑轨道-桥梁系统减振降噪设计与结构优化;③作为高等教学与科研中的典型案例,辅助讲授多体系统动力学建模与数值仿真方法; 阅读建议:建议读者结合结构动力学相关理论教材,逐步运行并调试所提供的Matlab代码,重点关注质量-刚度-阻尼矩阵的构建、轮轨接触关系处理、时间积分算法实现等核心模块,深入理解仿真结果的物理含义及其工程应用价值。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值