支配树 / Dominator_Tree（待补）

最新推荐文章于 2023-10-28 09:22:13 发布
原创 最新推荐文章于 2023-10-28 09:22:13 发布 · 383 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#支配树
支配树的概念在一些算法中颇为重要，但网上的解释常有模糊之处。本文旨在通过HDU 4694和6604等题目，探讨支配树的性质，并提供模板代码。支配树的生成可通过拓扑排序结合最近公共祖先（LCA）方法，也可利用Lengauer-Tarjan算法。虽然理解难度较大，但掌握后对于解决特定类型问题非常有用。

参考博客0
参考博客1
半支配点
在这里插入图片描述
支配树的生成方法实在难懂，网上博客多少有点表述不清。暂时先只掌握支配树的性质，存下求树的模板，日后再补上求树过程。

HDU 4694
模板题，ksf代码初始化有点问题，AC代码：

#include <cstdio>
#include <algorithm>
#include <iostream>

typedef long long ll ;
using namespace std;
//DT.init(n) -> DT.add(u,v) -> DT.work(root);
//DT.idom[i] : i 的最近支配点(root 到 i 距离 i 最近的必经点)
//需要完整的支配树用 idom[i]作为 fa[i]建树即可
const int N = 50005, M = 100005; //N 点数，M 主函数中调用 add 的次数
struct Dominator_Tree{
    private: struct eg{ int v, next; }e[M*2+N];
    int tot, cnt, h[N], iw[N], li[N], fa[N], fo[N], vo[N], sdom[N], pre[N], bkt[N];
    inline void link(int h[],int u,int v){ e[++cnt] = {v,h[u]}, h[u] = cnt; }
    inline int eval(int p){ findf(p); return vo[p]; }
    int findf(int p){
        if(fo[p] == p) return p;
        int r = findf(fo[p]);
        if(sdom[vo[fo[p]]] < sdom[vo[p]]) vo[p] = vo[fo[p]];
        return fo[p] = r;
    }
    void dfs(int p){
        sdom[p] = iw[p] = ++tot, li[tot] = p;
        for(int i = h[p]; i; i = e[i].next)
        if(!iw[e[i].v]) dfs(e[i].v), fa[e[i].v] = p;
    }
    public: int idom[N];
    inline void add(int u, int v) { link(h, u, v), link(pre, v, u);}
    inline void work(int root){
        dfs(root); int p, fp;
        for(int j = tot; j >= 2; j--, bkt[fp] = 0){
            for(int i = pre[p=li[j]]; i; i=e[i].next)
                if(iw[e[i].v]) sdom[p] = min(sdom[p], sdom[eval(e[i].v)]);
            link(bkt, li[sdom[p]], p);
            for(int i = bkt[fp=fo[p]=fa[p]]; i; i=e[i].next){
                int u = eval(e[i].v);
                idom[e[i].v] = sdom[u] == sdom[e[i].v] ? fp : u;
            }
        }
        for(int i = 2; i <= tot; i++){
            p = li[i], sdom[p] = li[sdom[p]];
            if(idom[p] != sdom[p]) idom[p] = idom[idom[p]];
        }
    }
    inline void init(int n){
        tot = cnt = 0;
        for (int i = 0; i <= n; i++){
        	pre[i] = bkt[i] = h[i] = iw[i] = 0, fo[i] = vo[i] = i;
        	sdom[i] = idom[i] = 0; //原模版没有这一行
        }
        
    }
}DT;

vector<int> edge[N];
ll ans[N];

void dfs(int now,ll sum)
{
    sum+=now;
    ans[now]=sum;
    for(auto v:edge[now])
    {
        dfs(v,sum);
    }
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        DT.init(n);
        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            DT.add(u,v);
        }
        DT.work(n);
        for(int i=1;i<=n;i++)
        {
            ans[i]=0;
            edge[i].clear();
        }
        for(int i=1;i<n;i++)
        {
            edge[DT.idom[i]].push_back(i);
        }
        
        dfs(n,0);
        for(int i=1;i<=n;i++)
        {
            if(i>1)printf(" ");
            printf("%lld",ans[i]);
        }
        puts("");
    }
    return 0;
}

HDU 6604
DAG还通过拓扑排序+LCA来生成支配树：
求出DAG的拓扑序后，顺序遍历拓扑序上的点；假设此时遍历到了点u，u点的最近支配点就是能到u的所有点的LCA。
GJC师兄题解 拓扑+LCA
也能用Lengauer Tarjan求出支配树后对支配树做LCA。这道题因为用tarjan离线做LCA写丑了爆T27发。。。
代码
纯套板。套了ksf的Lengauer Tarjan板子+网上随手抄的树上LCA板子

#include <bits/stdc++.h>

typedef long long ll ;
using namespace std;

inline void read(int & k)
{
	k = 0;
	int f= 1;char ch = getchar();
	while(!isdigit(ch) ){
		if(ch=='-')f =-1;
		ch = getchar();
	}
	while(isdigit(ch)){
		k = (k<<3) + (k<<1) + (ch^'0') ;
		ch = getchar();
	}
	k=k*f;
}

//DT.init(n) -> DT.add(u,v) -> DT.work(root);
//DT.idom[i] : i 的最近支配点(root 到 i 距离 i 最近的必经点)
//需要完整的支配树用 idom[i]作为 fa[i]建树即可
const int N = 200005, M = 400005; //N 点数，M 主函数中调用 add 的次数
struct Dominator_Tree{
    private: struct eg{ int v, next; }e[M*2+N];
    int tot, cnt, h[N], iw[N], li[N], fa[N], fo[N], vo[N], sdom[N], pre[N], bkt[N];
    inline void link(int h[],int u,int v){ e[++cnt] = {v,h[u]}, h[u] = cnt; }
    inline int eval(int p){ findf(p); return vo[p]; }
    int findf(int p){
        if(fo[p] == p) return p;
        int r = findf(fo[p]);
        if(sdom[vo[fo[p]]] < sdom[vo[p]]) vo[p] = vo[fo[p]];
        return fo[p] = r;
    }
    void dfs(int p){
        sdom[p] = iw[p] = ++tot, li[tot] = p;
        for(int i = h[p]; i; i = e[i].next)
        if(!iw[e[i].v]) dfs(e[i].v), fa[e[i].v] = p;
    }
    public: int idom[N];
    inline void add(int u, int v) { link(h, u, v), link(pre, v, u);}
    inline void work(int root){
        dfs(root); int p, fp;
        for(int j = tot; j >= 2; j--, bkt[fp] = 0){
            for(int i = pre[p=li[j]]; i; i=e[i].next)
                if(iw[e[i].v]) sdom[p] = min(sdom[p], sdom[eval(e[i].v)]);
            link(bkt, li[sdom[p]], p);
            for(int i = bkt[fp=fo[p]=fa[p]]; i; i=e[i].next){
                int u = eval(e[i].v);
                idom[e[i].v] = sdom[u] == sdom[e[i].v] ? fp : u;
            }
        }
        for(int i = 2; i <= tot; i++){
            p = li[i], sdom[p] = li[sdom[p]];
            if(idom[p] != sdom[p]) idom[p] = idom[idom[p]];
        }
    }
    inline void init(int n){
        tot = cnt = 0;
        for (int i = 0; i <= n; i++){
        	pre[i] = bkt[i] = h[i] = iw[i] = 0, fo[i] = vo[i] = i;
        	sdom[i] = idom[i] = 0;
        }
        
    }
}DT;

int ind[N];
vector <int> g[200010];
int father[200010][40]={0};
int depth[200010]={0};
int n,m;
bool visit[200010]={false};
//int root;

void dfs(int u)
{
    int i;
    visit[u]=true;
    for (i=0;i<g[u].size();i++)
        {
            int v=g[u][i];
            if ( !visit[v] )
             {
                    depth[v]=depth[u]+1;
                    dfs(v);
             }
        }   
}//深搜出各点的深度，存在depth中 

void bz()
{
    int i,j;
    for (j=1;j<=30;j++)
        for (i=1;i<=n;i++)
            father[i][j]=father[father[i][j-1]][j-1];
}//倍增，处理father数组，详情参照上述讲解 

int LCA(int u,int v)
{
    if ( depth[u]<depth[v] ) 
    {
        int temp=u;
        u=v;
        v=temp;
    }//保证深度大的点为u，方便操作 
    int dc=depth[u]-depth[v];
    int i;
    for (i=0;i<30;i++)//值得注意的是，这里需要从零枚举 
    {
        if ( (1<<i) & dc)//一个判断，模拟一下就会很清晰 
         u=father[u][i];
    }
    //上述操作先处理较深的结点，使两点深度一致 
    if (u==v) return u;//如果深度一样时，两个点相同，直接返回 
    for (i=29;i>=0;i--)
    {
        if (father[u][i]!=father[v][i])//跳2^j步不一样，就跳，否则不跳 
        {
            u=father[u][i];
            v=father[v][i];
        }
    }
    u=father[u][0];//上述过程做完，两点都在LCA下一层，所以走一步即可 
    return u;
}
void init()
{

	memset(father,0,sizeof(father));
	memset(depth,0,sizeof(depth));
	for(int i=0;i<=n;i++)
	{
		visit[i]=false;
		ind[i]=0;
		g[i].clear();
		
	}
}
int main()
{
    int t,T;
    read(t);
    T=t;
    while(t--)
    {
    	read(n);read(m);
    	DT.init(n);
    	init();
    	int u,v;
    	for(int i=1;i<=m;i++)
    	{
    		read(u);read(v);
    		DT.add(v,u);
    		ind[u]++;
    	}
    	
    	for(int i=1;i<=n;i++)
    	{
    		if(!ind[i]){
    			DT.add(0,i);
    		}
    	}
    	DT.work(0);
    	for(int i=1;i<=n;i++)
    	{
    		g[DT.idom[i]].push_back(i);
    		father[i][0]=DT.idom[i];
    	}
    	depth[0]=0;
    	dfs(0);
    	bz();
    	int q;
    	scanf("%d",&q);
    	for(int i=1;i<=q;i++)
    	{
    		scanf("%d%d",&u,&v);
    		printf("%d\n",depth[u]+depth[v]-depth[LCA(u,v)]);
    	}
    }
    return 0;
}
hobby_Z
关注
深入探索 Android 内存优化（炼狱级别-上）
m0_75232472的博客
04-02 1412
Android 中的内存是 弹性分配 的，分配值 与 最大值 受具体设备影响。对于 OOM场景 其实可以细分为如下两种：我们需要着重注意一下这两种的区分。以Android中虚拟机的角度来说，我们要清楚 Dalvik 与 ART 区别，Dalvik 仅固定一种回收算法，而 ART 回收算法可在 运行期按需选择，并且，ART 具备 内存整理 能力，减少内存空洞。最后，LMK（Low Memory killer） 机制保证了进程资源的合理利用，它的实现原理主要是 根据进程分类和回收收益来综合决定的一套算法集。当
支配节点树及其构建算法 Dominator-tree and its Construction Algorithms
Dong_HFUT的博客
11-23 1万+
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
图论 —— 支配树
Alex_McAvoy的博客
09-27 6135
【概述】 给定一个有向图与一个起点 S，如果要去掉起点 S 到某个点 p 的中间的某个点 x后无法到达，那么称点 x 支配点 p，x 是 p 的一个支配点。 显然支配点 x 可以有多个，支配点的集合记为 {Xp}，对于起点以为的点，它们都有两个平凡的支配点，一个是其自身，一个是起点。 在支配 p 的点中，若一个支配点 i≠p，满足 i 被 p 剩下的所有非平凡的支配点支配，则称 i 为...
支配树（Dominator Tree）
霍淇滨的博客
09-20 2656
MAT中的支配树 在使用MAT分析项目的内存泄漏问题时，其中有一个支配树（Dominator）视图。如果我们把Java对象之间的引用关系看做一张有向图（可以存在环）的话，对象的支配树体现了对象之间的支配关系。如果所有指向对象B的路径都要经过对象A，则认为对象A支配对象B。如果对象A是离对象...
支配树详解
Hellsegamosken
05-14 4463
什么是支配树？ 对于一张有向图，确定一个根，如果根到 x 的每条路径都经过 y，那么称 y 是 x 支配点。求出原图的一个 dfs 树，那么 x 的支配点一定在 x 到根的链上。如果每个点向自己深度最深的支配点连边，就构成了支配树。 明确一些有向图 dfs 树的性质： 1.树边总是由 dfn 小的点指向 dfn 大的点，非树边（两端点无祖先关系）总是由 dfn 大的点指向 dfn 小的点。 2.若...
构造Dominator Tree以及Dominator Frontier
电影旅行敲代码
08-17 1万+
支配树（Dominator Tree）在生成SSA的时候，需要计算在何处插入正确的 Φ (phi-function) ，一种方法是在所有有多个前驱的Basic Block的开头插入 Φ-node，但是这种方法会插入很多的无用的 Φ-node ，有很多 Φ-node 的参数都是相同的一个定义。 The Φ-function is the most important SSA concept to...
支配树 Dominator Tree
VioletSu的博客
07-14 3036
写在前面 今天亮神花了一早上给讲了支配树，但由于今天网（没）速（人）不（跟）好（上），我们残忍地看了他一眼后掉线了，于是又用了一下午开流量重新联网并结合缓（课）存（件）学习。 就由一道题引入吧。 题目 HDU4694 Important Sisters 简单题意：一个有nnn个点，mmm条边的有向图，以nnn为起点，若去掉点bbb，nnn就不能连到aaa，则称bbb是aaa...
支配树dominator tree学习笔记
L_0_Forever_LF的专栏
02-27 2220
说实话冬令营之前我都没见过支配树的题，也不知道这是个什么东西（但是学完之后感觉这个东西已经烂大街了qaq） 支配树主要能干这么一件事： 给定起点r，对于一个终点x，如果r到x的所有路径都必须经过y，我们称y支配x 设支配x的点集S=p1,p2,p3.....pk&nbsp;&nbsp;S=p1,p2,p3.....pk&nbsp;&nbsp;S=p1,p2,p3.....pk\ \ ， 其...
支配树(dominator tree)学习笔记
GEOTCBRL
02-27 3919
抖m学抖m tree的笔记2333
【JVM笔记】支配树（Dominator Tree）
lijibai_的博客
10-16 1636
对象 A 和 B 由根对象直接支配，由于在到对象 C 的路径中，可以经过 A，也可以经过 B，因此对象 C 的直接支配者也是根对象。而到对象 D 的所有路径中，必然经过对象 C，即使是从对象 F 到对象 D 的引用，从根节点出发，也是经过对象 C 的，所以，对象 D 的直接支配者为对象 C。同理，对象 E 支配对象 G。到达对象 H 的可以通过对象 D，也可以通过对象 E，因此对象 D 和 E 都不能支配对象 H，而经过对象 C 既可以到达 D 也可以到达 E，因此对象 C 为对象 H 的直接支配者。
【图论】支配树
02-02 776
定义 支配树一般用来求有向图必经点问题， 即：给定起点S，问对于每个点i，S到i的必经点有哪些； 点i在支配树上父亲就是距离它最近的必经点， 显然的，必经点是具有一定传递性的，所以对于点i，S到i的所有必经点，就是支配树上i到根的路径上的所有点。 建树 首先，对于一棵树，它的支配树就是它本身； 对于一个DAG，它的支配树也很好求， 先排拓扑序，对于点i，它在支配树上的父亲就是所有能到达它的点在支配...
【学习笔记】支配树基础理论
cqbzlydd的博客
10-28 467
本来没想着写这么多的，结果写着写着就发现引理搞的有点多了，感觉有点冗余。
支配树
我歌月徘徊，我舞影零乱
08-06 302
首先我们要知道什么是支配树 首先明确一个概念，在图中 求支配树先要 图中有 一个源点，即规定一个源点。 图可以有环，边可以有向和无向。 如果图是有向无环图，那么可以在它的DAG上求支配树。 支配点： 一个图，有一个源点。我们从源点出发，需要到达一个点X，如果删除某个点Y，我们就不能到达X ， 则Y为X的支配点 最近支配点： 在树形图中最近支配点 就是他的父亲节点，类比推理到图中同理。...
控制流分析之构建支配树
fs3296的博客
01-05 1168
在编译器中，支配树作用显著。例如，它可以辅助我们识别函数中的循环等功能。本文将将讨论如何从一个图构建支配树？
Dominator Tree--支配树
苟为蒟蒻又何妨
06-26 856
在学习支配树之前，请保证已经会写lca（tarian求法） 简介 支配树是什么？支配树能干什么？ 对于一个DAGDAGDAG上的每个点www，都存在点ddd满足去掉ddd之后起点无法到达www，我们称作dd d支配www，ddd是www的一个支配点。TTT中节点uuu是uuu子树中所有节点的支配点（必经点）， 支配www的点可以有多个，但是至少会有一个。显然，对于起点以外的点，它们都有两个...
学习一个支配树
onepointo
10-31 960
http://blog.csdn.net/qq_35649707/article/details/64125918 http://blog.csdn.net/GEOTCBRL/article/details/57875070 http://blog.csdn.net/a710128/article/details/499135531、基本介绍 支配树 DominatorTree　　对于一个流程图
【学习笔记】支配树
cz_xuyixuan的博客
09-04 4993
【前言】 本文为博主的转载，由于博主看到的文章同样是转载的，无法注明原文出处。 博主在原文的基础上修改了格式、措辞和一些小错误，并适当添加了一些自己的理解。 【支配树简介】 对于一个单源有向图上的每个点 ww w ，都存在点 dd d 满足去掉 dd d 之后起点无法到达 ww w ，我们称作 dd d 支配 ww w ， dd d 是 ww...
静态单赋值(一)—gcc中的支配树
ashimida
08-02 1780
一、需要了解的基本概念 在gcc优化的过程中,不论是循环的优化还是数据流分析,支配树在其中都起到至关重要的作用: *对于循环来说,支配树对找出代码中的循环非常有用 *对数据流分析来说,支配树对计算SSA_NAME中的phi函数插入点十分重要 支配树中的主要概念包括: 1)必经结点(Dominator,又称支配结点):如果从(如函数的)起始节点S0到结点n的所有有效路径都经过结点d,那么结点d则成为结点n的必经结点,同时每一个结点都是自己的必经结点 简单的说,必经...
支配树学习笔记
ez_lcw的博客
11-07 361
前言 本文参考了： 2020 年信息学奥林匹克中国国家集训队论文：陈孙立，浅谈支配树及其应用 本文和上文在构建支配树的切入点上会有些许不同，尝试用更加容易理解的方式解析支配树的构建。 支配树的存在性及其定义 本文考察的是一个 nnn 个点 mmm 条边的有向图 G=(V,E)G=(V,E)G=(V,E)，设其的源为 sss，满足 sss 能到达图上的所有点。 定义 xxx 支配 yyy 当且仅当所有从 sss 到 yyy 的路径都会经过 xxx，称 xxx 为 yyy 的一个支配点。 显然我们在考察 x
Java内存分析工具MAT(Memory Analyzer Tool)安装使用实例
热门推荐
Jin_Kwok的博客
05-15 5万+
1. 前言生产环境中，尤其是吃大内存的JVM，一旦出现内存泄露等问题是非常容易引发OutofMemory的，如果没有一个好的工具提供给开发人员定位问题和分析问题，那么这将会是一场噩梦。目前JDK其实自带有一些内存泄露分析工具专门用于帮助开发人员定位内存泄露等问题，但是这些工具往往并不是能够满足一些现状，这里笔者所指的现状更多是迅速、便捷、高效的定位出问题，方便开发人员迅速进行调整。2. 目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值