子图同构之VF3

子图同构之VF3

1.子图同构问题描述

​ 首先描述一下子图同构是什么意思，一个图由一系列节点和一系列连接节点的边构成，节点和边都可以有标签，也就是可以给他们按属性分类。

​ 精确点：一个图$G=(V,E)$由集合$V$和集合$E$组成，$V$是节点(node)集合， $E$是边(edge)集合，且$E\subset V\times V$ ，用$L_v$表示节点上的标签集合，$L_e$表示边上的标签集合，那么每个节点对应的标签由函数（或者说映射）${\lambda }_v:V\to L_v$ 确定，每条边对应的标签由函数${\lambda }_e:E\to L_e$ 确定。

​ 现在给定两个图$G_1=(V_1,E_1)$, $G_2=(V_2,E_2)$ ,其中$G_1$是比较小的图(我们把它叫做pattern graph)，$G_2$是比较大的图(我们把它叫做target graph),用集合$M\subset V_1\times V_2$ 表示两个图中节点的对应关系。如果节点$u\in V_1$,则$\mu (u)\in V_2$表示与节点$u$对应的$G_2$中的节点；如果节点$v\in V_2$,则$\nu (v)\in V_1$表示与节点$v$对应的$G_1$中的节点。

	$G_1$	$G_2$
对应关系	$u$	$\mu (u)$
对应关系	${\mu }^{-1}(v)$	$v$

​ 如果以下6个条件成立，则这两个图是子图同构的。

---

1. $$\forall u\in V_1\exists \mu (u)\in V_2:(u,\mu (u))\in M$$
2. $$\forall u,u^{{}^{\prime }}\in V_{1}u\ne u^{{}^{\prime }}\Rightarrow \mu (u)\ne \mu (u^{{}^{\prime }})$$
3. $$\forall (u,u^{{}^{\prime }})\in E_1\exists (\mu (u),\mu (u^{{}^{\prime }}))\in E_2)$$
4. $$\forall u,u^{{}^{\prime }}\in V_1(\mu (u),\mu (u^{{}^{\prime }}))\in E_2\Rightarrow (u,u^{{}^{\prime }})\in E_1$$
5. $$\forall u\in V_1{\lambda }_{V_1}(u)={\lambda }_{V_2}(\mu (u))$$
6. $$\forall (u,u^{{}^{\prime }})\in E_1{\lambda }_{e_1}(u,u^{{}^{\prime }})={\lambda }_{e_2}(\mu (u),\mu (u^{{}^{\prime }}))$$

---

用人话来解释一下：

1. 对于小图中每个节点，大图中都要有一个对应的节点与之对应，并且这样一对一对的节点构成了集合$M$；

2. 小图中任意两个不一样的节点，他们对应的大图中的节点不能是同一个；

3. 小图中每条边，大图中都有一条边与之对应，并且他们两端的节点一一对应；

4. 小图中任意两个节点，如果他们对应的大图中的节点之间有一条边，那么小图中这两个节点之间也得有条边;

5. 每对对应节点的label要相同，也就是这俩节点类型或属性相同；

6. 每对对应边的label要相同，也就是说这俩边的类型或属性相同。

​ 综上所述，子图同构简单来说就是，大图中有一个子结构，长得跟小图一模一样，而且这个子结构的节点之间不能多出小图中不存在的边来，如果要去掉最后这个而且，就把上面第4个条件去掉~

2.VF3算法

​ VF3算法的目标是，给定一个小图和一个大图，找出大图中所有与小图同构的子图，这是一个NP-hard问题。整体上，VF3算法是一个树搜索算法，并且想办法去尽可能剪枝。搜索树上的每个节点都是一个状态（state)，记为$s$，每个$s$中包含一系列节点的映射关系，可以想象成一系列key-value对，key都是小图中的节点，value都是大图中的节点。搜索最开始的时候（也就是树的根节点）$s$中什么都没有，随着搜索的进行（树高度的增加），$s$中的key-value对会一对对增加，假如这个状态中所有的节点对都满足第一节中的6条约束，我们称这个状态为一致状态(consistent state)；如果一个一致状态包含的小图中所有的节点，那意味着我们找到了一个大图的子结构与小图同构，称之为目标状态(goal state)；如果一个状态是不可能再派生出一致状态的，我们称之为死亡状态（dead state)。

​ 那么现在最大的问题就是两个：

1. 这棵搜索树怎么组织?
2. 怎么设计剪枝规则？

下面逐个展开~

A. 总体流程介绍

先来介绍一些符号：

$\tilde{M}(s)$表示状态$s$中的节点映射集合，则$\tilde{M}(s)\subseteq M$；

$\widetilde{M_1}(s)$表示$\tilde{M}(s)$中属于$G_1$的节点，也就是所有的key,严格点： M 1 ~ ( s ) = { u ∈ V 1 : ∃ ( u , v ) ∈ M ~ ( s ) , v ∈ V 2 } \tilde{M_1}(s)=\{u\in V_1:\exist (u,v)\in \tilde{M}(s),v\in V_2\} M1​~​(s)={u∈V1​:∃(u,v)∈M~(s),v∈V2​}；

$\widetilde{M_2}(s)$表示$\tilde{M}(s)$中属于$G_2$的节点，也就是所有的value,严格点： M 2 ~ ( s ) = { v ∈ V 2 : ∃ ( u , v ) ∈ M ~ ( s ) , u ∈ V 1 } \tilde{M_2}(s)=\{v\in V_2:\exist (u,v)\in \tilde{M}(s),u\in V_1\} M2​~​(s)={v∈V2​:∃(u,v)∈M~(s),u∈V1​}；

${\tilde{G}}_1(s)$表示仅包含节点在$\widetilde{M_1}(s)$中的$G_1$的子图，也就是比$\widetilde{M_1}(s)$加上了边；

${\tilde{G}}_2(s)$表示仅包含节点在$\widetilde{M_2}(s)$中的$G_2$的子图，也就是比$\widetilde{M_2}(s)$加上了边;

$\tilde{\mu }(s,u)$表示$\tilde{M}(s)$中与$u$对应的节点，其中$u\in V_1$,$\tilde{\mu }(s,u)\in V_2$；

${\tilde{\mu }}^{-1}(s,v)$表示$\tilde{M}(s)$中与$v$对应的节点，其中${\tilde{\mu }}^{-1}(s,v)\in V_1$,$v\in V_2$。

	$V_1$	$V_2$
对应关系	$u$	$\mu (s,u)$
对应关系	${\mu }^{-1}(s,v)$	$v$

大致看一下整个流程，上伪代码~

---

VF3总流程

1: $functionVF3(G_1,G_2)$

2: $Solutions\leftarrow \varnothing$

3: $P_f=ComputeProbabilitys(G_1,G_2)$

4: $N_{G_1}=GenerateNodeSequence(G_1,P_{feas})$

5: $ClassifyNodes(G_1,G_2)$

6: $(s_0,Parent)=PreProcessPatternGraph(G_1,N_{G_1})$

7: $Match(s_0,G_2,G_1,N_{G_1},Parent,Solutions)$

8: $returnSolutions$

---

匹配函数

1：$functionMatch(s_0,G_2,G_1,N_{G_1},Parent,Solutions)$

2: $ifIsGoal(s_c)then$

3: $Append(M(s_c),Solutions)$

4: $returnTrue$

5: $ifIsDead(s_c)then$

6: $returnFalse$

7: $Set(u_c,v_c)=(ϵ,ϵ)$

8: $(u_n,v_n)=GetNextCandidate(s,(u_c,v_c),N_{G_1},Parent,G_1,G_2)$

9: $Result=False$

10: $while(u_c,v_c)\ne (ϵ,ϵ)do$

11: $ifIsFeasible(s_c,u_n,v_n)then$

12: $s_n=s_c\cup (u_n,v_n)$

13: $ifMatch(s_n,G_1,G_2,N_{G_1},Parent)isTruethen$

14: $Result=True$

15: $(u_n,v_n)=GetNextCandidate(s,(u_n,v_n),N_{G_1},Parent,G_1,G_2)$

16: $returnResult$

---

​ 总流程中出现了一些函数，$ComputeProbabilitys(G_1,G_2)$和$GenerateNodeSequence(G_1,P_{feas})$是为了组织搜索树，也就是搜索顺序，其中$ComputeProbabilitys(G_1,G_2)$的计算结果又是为$GenerateNodeSequence(G_1,P_{feas})$服务的，最终算出的$N_{G_1}$是小图的节点进入$s$的顺序优先级，而大图中的节点进入顺序是由$Match$流程中的$GetCandidate$函数决定的。$ClassifyNodes(G_1,G_2)$函数是对节点进行分类，是为了更好地剪枝同时也为后面的预处理做了一些准备。$PreProcessPatternGraph(G_1,N_{G_1})$为每个小图中的节点提供一个父节点，为$Match$做好准备，细节后面一一展开。

​ 搜索过程从$s_0$开始，这时$\tilde{M}(s_0)=\varnothing$,把一对对的$(u_n,v_n)$往里面加，$(u_n,v_n)$由$GetCandidate$函数决定，每加一对都会判断加了这对节点后一步(1-lookahead)和两步(2-lookahead)是否可行，如果不可行就剪枝，不再从这个状态往下搜。为什么没有3-lookahead，n-lookahead？因为往后考虑n步本身就需要计算量，这是判断一枝的效率和剪枝质量之间的博弈。

B 可行集合

​ 这一节主要是介绍一些集合的概念，为理解后面的算法做铺垫。

​ 首先集合粗略地分为${\tilde{P}}_1$,${\tilde{S}}_1$,${\tilde{V}}_1$${\tilde{P}}_2$,${\tilde{S}}_2$,${\tilde{V}}_2$ ,其中下标1代表是属于小图$G_1$的节点子集，下标2代表是属于大图$G_2$的节点子集，$P$是predecessor，意思是前驱节点，具体讲是至少有一条边连接到已经匹配的$\tilde{M}(s)$集合中节点的所有节点构成的集合，好拗口…重来：一个predecessor节点就是有边指向$\tilde{M}(s)$里面的节点；$S$与$P$相对，是successor,即后继节点，是从$\tilde{M}(s)$中出来被指向的节点构成的集合；最后$V$是这个图中既不在$M$中，又不在$P$和$S$中的节点构成的集合。综上，$M$是已经匹配的节点集合，$P$和$S$是直接和已经匹配的节点相连的节点集合，即1-lookahead要用到的集合，V是更外圈的节点集合，至少得是2-lookahead才够得到,下面严格定义一下~

---

1. P ~ 1 ( s ) = { u ∈ V 1 − M ~ 1 ( s ) : ∃ u ′ ∈ M ~ 1 ( s ) : ( u , u ′ ) ∈ E 1 } \tilde P_1(s)=\{u\in V_1-\tilde M_1(s):\exist u^{'}\in \tilde M_1(s):(u,u^{'})\in E_1 \} P~1​(s)={u∈V1​−M~1​(s):∃u′∈M~1​(s):(u,u′)∈E1​}
2. S ~ 1 ( s ) = { u ∈ V 1 − M ~ 1 ( s ) : ∃ u ′ ∈ M ~ 1 ( s ) : ( u ′ , u ) ∈ E 1 } \tilde S_1(s)=\{u\in V_1-\tilde M_1(s):\exist u^{'}\in \tilde M_1(s):(u^{'},u)\in E_1 \} S~1​(s)={u∈V1​−M~1​(s):∃u′∈M~1​(s):(u′,u)∈E1​}
3. ${\tilde{V}}_1(s)=V_1-{\tilde{M}}_1(s)-{\tilde{P}}_1(s)-{\tilde{S}}_1(s)$
4. P ~ 2 ( s ) = { v ∈ V 2 − M ~ 2 ( s ) : ∃ v ′ ∈ M ~ 2 ( s ) : ( v , v ′ ) ∈ E 2 } \tilde P_2(s)=\{v\in V_2-\tilde M_2(s):\exist v^{'}\in \tilde M_2(s):(v,v^{'})\in E_2 \} P~2​(s)={v∈V2​−M~2​(s):∃v′∈M~2​(s):(v,v′)∈E2​}
5. S ~ 2 ( s ) = { v ∈ V 2 − M ~ 2 ( s ) : ∃ v ′ ∈ M ~ 2 ( s ) : ( v ′ , v ) ∈ E 2 } \tilde S_2(s)=\{v\in V_2-\tilde M_2(s):\exist v^{'}\in \tilde M_2(s):(v^{'},v)\in E_2 \} S~2​(s)={v∈V2​−M~2​(s):∃v′∈M~2​(s):(v′,v)∈E2​}
6. ${\tilde{V}}_2(s)=V_2-{\tilde{M}}_2(s)-{\tilde{P}}_2(s)-{\tilde{S}}_2(s)$

---

几个集合的关系如下图所示~~~

​ 这样还不够，在这基础上，我们还要为节点分组，最常见的就是按节点的类型或属性分组，如果分别属于小图和大图的两个节点属于不同组，即类型不同，那他们不可能对应上，也就不可能作为一对节点进入一致状态$s$。

​ 于是我们把两个图中所有的节点合起来，一起按照类型分组，分组函数：$\psi :V_1\cup V_2\to C$,给每个节点分一个组别 c i ∈ C = { c 1 , c 2 , . . . c q } c_i\in C=\{c_1,c_2,...c_q \} ci​∈C={c1​,c2​,...cq​}，因为匹配上的节点类型必须相同，因此有$(u,v)\in M\Rightarrow \psi (u)=\psi (v)$。

​ 在给节点分组之后，我们又可以将上面6个集合分得更细，分成6q个，q是分组的数量。具体如下：

---

1. P ~ 1 c i ( s ) = { u ∈ P ~ 1 ( s ) : ψ ( u ) = c i } \tilde P_1^{c_i}(s)=\{u\in \tilde P_1(s):\psi(u)=c_i \} P~1ci​​(s)={u∈P~1​(s):ψ(u)=ci​}
2. S ~ 1 c i ( s ) = { u ∈ S ~ 1 ( s ) : ψ ( u ) = c i } \tilde S_1^{c_i}(s)=\{u\in \tilde S_1(s):\psi(u)=c_i \} S~1ci​​(s)={u∈S~1​(s):ψ(u)=ci​}
3. V ~ 1 c i ( s ) = { u ∈ V ~ 1 ( s ) : ψ ( u ) = c i } \tilde V_1^{c_i}(s)=\{u\in \tilde V_1(s):\psi(u)=c_i \} V~1ci​​(s)={u∈V~1​(s):ψ(u)=ci​}
4. P ~ 2 c i ( s ) = { v ∈ P ~ 2 ( s ) : ψ ( v ) = c i } \tilde P_2^{c_i}(s)=\{v\in \tilde P_2(s):\psi(v)=c_i \} P~2ci​​(s)={v∈P~2​(s):ψ(v)=ci​}
5. S ~ 2 c i ( s ) = { v ∈ S ~ 2 ( s ) : ψ ( v ) = c i } \tilde S_2^{c_i}(s)=\{v\in \tilde S_2(s):\psi(v)=c_i \} S~2ci​​(s)={v∈S~2​(s):ψ(v)=ci​}
6. V ~ 2 c i ( s ) = { v ∈ V ~ 2 ( s ) : ψ ( v ) = c i } \tilde V_2^{c_i}(s)=\{v\in \tilde V_2(s):\psi(v)=c_i \} V~2ci​​(s)={v∈V~2​(s):ψ(v)=ci​}

---

​

C 组织小图中节点的匹配顺序

​ 简单计算，假如一个状态$s$对应的匹配集合$M(s)$中已经有k对节点，那么到达这个状态共有$k!$种不同的路径，为了避免如此繁重的计算，我们将状态空间组织成一颗树，而不是原来的图，实则是避免同样的状态$s$在一次搜索中访问多次。

​ 在这一步中，我们要组织的是小图中的节点进入匹配的顺序，大图中节点的进入顺序在后面，为了给小图中节点排一个进入匹配的优先级序列（也就是$N_{G_1}$)，要同时用到小图和大图的一些结构信息，原则是优先考虑有更多约束的节点，具体讲有两点：一是在大图中找到对应节点的可能性比较小的应该优先，二是跟已经匹配上的节点的连接比较多的应该优先。这样可以更早地剪掉大分支~

​ 实现上述目的的是总流程中3、4行的两个函数：

• $P_f=ComputeProbabilitys(G_1,G_2)$

• $N_{G_1}=GenerateNodeSequence(G_1,P_{feas})$

​ 首先，$P_f(u)$是在大图中找到一个节点$v$可以跟小图节点$u$匹配上的概率，当然这个概率是估算，因为精确计算过于困难而且需要花很大的计算量，这里没必要这么精确。

​ 我们这样估计这个概率：

​ $P_f(u)=P_r({\lambda }_{v_2}(v)={\lambda }_{v_1}(u),d^{in}(v)\ge d^{in}(u),d^{out}(v)\ge d^{out}(u))$，其中$d^{in}$是入度，$d^{out}$是出度。

​ 很自然，想要在大图中找到一个节点$v$跟小图节点$u$匹配，必须满足三个条件：

​ 1.两个节点的label相同；

​ 2.大图节点$v$的入度不小于小图节点$u$；

​ 3.大图节点$v$的出度不小于小图节点$u$。

​ 我们用同时满足这三个条件的节点概率来估计$P_f(u)$~但是在最差的情况下，计算这个概率的时间复杂度为$O(N^3)$，于是我们进一步假设这三个条件是独立的，于是可以这样估算这个概率：

​ $P_f(u)=P_l({\lambda }_{v_1}(u)).{\sum }_{d^{\prime }\ge d^{in}(u)}{P}_d^{in}(d^{\prime }).{\sum }_{d^{\prime }\ge d^{out}(u)}{P}_d^{out}(d^{\prime })$，其中$P_l(l)$是节点$v$的label是$l$的概率。

​ 用人话解释一下，因为假设三个条件独立，因此可以把三个条件各自满足的可能性相乘来估算同时满足三个条件的概率。第一个概率是节点$v$拥有跟节点$u$相同标签的概率；第二个概率：假设$u$节点的入度为3，那么$d^{\prime }$是3，4，5，6…把$v$的入度为这些值的概率全部加起来；第三个概率：假设$u$节点的出度为4，那么$d^{\prime }$是4，5，6，7…把$v$的出度为这些值的概率全部加起来。这个计算的复杂度仅为$O(N)$.

​ 除了考虑以上概率以外，我们还要考虑已经在$N_{G_1}$里的节点的结构，定义$d_M$为一个节点与已经在$N_{G_1}$里的节点相连的数量，即节点度的一部分。

​ 总体上，$GenerateNodeSequence(G_1,P_{feas})$函数首先考虑$d_M$，$d_M$大的节点与已经匹配上的节点的连接比较多，优先级高；如果几个节点的$d_M$相同，则按上面计算出的$P_f$排序，$P_f$小的节点优先级高；如果$P_f$也相同，则再考虑节点的度，度大的节点优先级高；最后如果前面三者全部相等，那就随机排~这样我们就把小图的节点匹配顺序排好了，得到了$N_{G_1}$。

D 预处理

​ 每一个状态$s$在搜索树中的高度与它包含的节点对数相同，而小图节点进入$s$的优先级由$N_{G_1}$确定，树中高度相同的状态$s$的小图节点$u$都相同，而大图节点$v$是动态选择的，每一种$v$的可能都造成了树在这个高度上的一个分支。上图助理解~

​

​ 作为正式匹配前的最后一步，预处理函数$PreProcessPatternGraph(G_1,N_{G_1})$为每个小图节点提供一个父节点，这是为了后面真正选候选节点对做准备的，而节点对的选择也就是选择上图中$???$位置的$v$节点，因为$u$已经被确定了。这里的父节点并不是一个指向它的节点，而是在它之前进入$s$的且与它有连接的节点中优先级最高的那个，第一个$u$没有父节点。

伪代码如下：

---

1： $functionPreProcessPatternGraph(G_1,N_{G_1},T_1)$

2: $i=0$

3: $forallu\in N_{G_1}do$

4: $forall{u}^{\prime }\in P_1(u)\cup S_1(u)do$

5: $c_i=\psi (u^{\prime })$

6: $if{u}^{\prime }\in P_1(u)\wedge u^{\prime }\notin {\tilde{P}}_1^{c_i}then$

7: $Put{u}^{\prime }in{\tilde{P}}_{1}atleveli$

8: $Parent(u^{\prime })=u$

9: $if{u}^{\prime }\in S_1(u)\wedge u^{\prime }\notin {\tilde{S}}_1^{c_i}then$

10: $Put{u}^{\prime }in{\tilde{S}}_{1}atleveli$

11: $Parent(u^{\prime })=u$

12: $i=i+1$

13: $returnParent$

---

E 选择候选节点对

​ 前面做了那么多准备，可以说大多数都是为了给这一步做准备的。

​ $(u_n,v_n)=GetNextCandidate(s,(u_c,v_c),N_{G_1},Parent,G_1,G_2)$这个函数在匹配过程中为每一个状态$s$选择下一对候选节点，$（u_c,v_c）$是当前状态$s$中最后进入的一对节点。对于小图而言，$u_n$节点是$N_{G_1}$序列中，跟在$u_c$后面的节点；所以接下来的关键工作就是选择大图中的节点$v_n$来与$u_n$对应。

​ 首先，$v_n$必须与$u_n$的组别相同，我们把与$u_n$同组的还没匹配上的节点集合记为$R_2(s_c,\psi (u_n))$。

---

​ R 2 ( s c , ψ ( u n ) ) = { v n ∈ V 2 : v n ∉ M ~ 2 ( s c ) ∧ ψ ( v n ) = ψ ( u n ) } R_2(s_c,\psi (u_n))=\{v_n\in V_2:v_n\notin \tilde M_2(s_c)\land \psi(v_n)=\psi (u_n) \} R2​(sc​,ψ(un​))={vn​∈V2​:vn​∈/M~2​(sc​)∧ψ(vn​)=ψ(un​)}

---

​ 更进一步，$v_n$与它的父节点${\tilde{v}}_n$之间的关系得和$u_n$与它的父节点${\tilde{u}}_n$之间的关系相同。具体来说，如果$u_n$是${\tilde{u}}_n$的后继节点，那么$v_n$也得是${\tilde{v}}_n$的后继节点；如果$u_n$是${\tilde{u}}_n$的前驱节点，那么$v_n$也得是${\tilde{v}}_n$的前驱节点。

​ 因此最终$v_n$的候选集如下：

---

​ R 2 S ( s c , ψ ( u n ) , v ~ ) = { v n ∈ V 2 : v n ∈ S 2 ( v ~ ) ∩ R 2 ( s c , u n ) } R_2^S(s_c,\psi(u_n),\tilde v)=\{v_n\in V_2:v_n\in S_2(\tilde v)\cap R_2(s_c,u_n) \} R2S​(sc​,ψ(un​),v~)={vn​∈V2​:vn​∈S2​(v~)∩R2​(sc​,un​)}

​ R 2 P ( s c , ψ ( u n ) , v ~ ) = { v n ∈ V 2 : v n ∈ P 2 ( v ~ ) ∩ R 2 ( s c , u n ) } R_2^P(s_c,\psi(u_n),\tilde v)=\{v_n\in V_2:v_n\in P_2(\tilde v)\cap R_2(s_c,u_n) \} R2P​(sc​,ψ(un​),v~)={vn​∈V2​:vn​∈P2​(v~)∩R2​(sc​,un​)}

---

​ 上面两条规则很大程度地缩小了可以考虑的$v_n$的范围，根据$u_n$与它的父节点${\tilde{u}}_n$之间的关系，可以知道该从上面哪个集合中选取$v_n$，然后就取这个集合中的第一个节点当作$v_n$,与$u_n$组成节点对准备进入状态$s$，当然是否真的能进入还要看是否满足可行规则，很有可能被剪枝掉~

​ 选取候选节点对伪代码如下：

---

1: $functionGetNextCandidate(s,(u_c,v_c),N_{G_1},Parent,G_1,G_2)$

2: $if{u}_c=ϵthen$

3: $u_n=GetNextInSequence(N_{G_1},s_c)$

4: $if{u}_n=ϵthen$ //这个序列结束

5: $return(ϵ,ϵ)$

6: $else$

7: $u_n=u_c$

8: $ifParent(u_n)=ϵthen$ //$u_n$没有父节点

9: $v_n=GetNextNode(v_c,R_2(s_c,\psi (u_n)))$

10: $return(u_n,v_n)$

11: $else$

12: $\tilde{v}=\tilde{u}(s_c,Parent(u_n))$ //获取跟$u_n$的父节点对应的节点

13: $if{u}_{n}in{P}_1(Parent(u_n))$ //$u_n$是其父节点的前驱节点

14: $v_n=GetNextNode(v_c,R_2^P(s_c,\psi (u_n),\tilde{v})$

15: $return(u_n,v_n)$

16: $if{u}_{n}in{S}_1(Parent(u_n))$ //$u_n$是其父节点的后继节点

17: $v_n=GetNextNode(v_c,R_2^S(s_c,\psi (u_n),\tilde{v})$

18: $return(u_n,v_n)$

19: $return(ϵ,ϵ)$ //$u_n$没有对应的候选节点

---

F 可行规则

​ 在匹配过程中，每一步选取的节点对$(u_n,v_n)$加入到状态$s$不一定合适，要么加入后新的状态$s^{\prime }$不是一致状态(consistent state)，要么加入后未来几步不可能达到一致状态，因此这一搜索分支就可以被砍掉，不再往下搜索，并且回溯到上一状态$s$并选取下一节点对。我们要用一系列的可行规则来判断当前选出的候选节点对是否可以加入状态$s$达到$s^{\prime }$。

​ 我们用可行函数$IsFeasible(s_c,u_n,v_n)$来判断在当前状态$s_c$下，加入节点对$(u_n,v_n)$是否可行。判断规则主要分为两类，一类是基于节点和边的标签（label)，记作$F_s$，另一类基于图的拓扑结构，记作$F_t$。两类规则都得满足，因此有：

---

$IsFeasible(s_c,u_n,v_n)=F_s(s_c,u_n,v_n)\wedge F_t(s_c,u_n,v_n)$

---

​ $F_s$的规则很简单，就是要保证新加入节点对后，对应节点和边的label要全部相同：

---

1. $\forall u\in V_1{\lambda }_{V_1}(u)={\lambda }_{V_2}(\mu (u))$
2. $\forall (u,u^{{}^{\prime }})\in E_1{\lambda }_{e_1}(u,u^{{}^{\prime }})={\lambda }_{e_2}(\mu (u),\mu (u^{{}^{\prime }}))$

---

​ 而$F_t$的规则就复杂一些，当然这也是本算法剪枝的精髓所在~这部分规则又可以分为三个小部分，第一：将新节点对加入状态$s$后，检查新的状态$s^{\prime }$还是一致状态,记作$F_c$；第二，考虑1-lookahead，判断未来一步是否可能构成一致状态$s^{\prime \prime }$记作$F_{la1}$；第三，考虑2-lookahead,判断未来两步是否可能构成一致状态$s^{\prime \prime \prime }$,记作$F_{la2}$。

---

$F_t(s_c,u_n,v_n)=F_c(s_c,u_n,v_n)\wedge F_{la1}(s_c,u_n,v_n)\wedge F_{la2}(s_c,u_n,v_n)$

---

下面逐个展开~

第一类规则$F_c$：

当$s_c$已经是一个一致状态，判断要新加入的候选节点对$(u_n,v_n)$是否可行，需要满足$s_c\cup (u_n,v_n)$依然是一致状态。

---

$$\begin{gathered} F_c(S_c,u_n,v_n)= \\ \forall u^{\prime }\in S_1(u_n)\cap {\tilde{M}}_1(s_c)\exists v^{\prime }=\tilde{\mu }(s_c,u^{\prime })\in S_2(v_n) \\ \wedge \forall u^{\prime }\in P_1(u_n)\cap {\tilde{M}}_1(s_c)\exists v^{\prime }=\tilde{\mu }(s_c,u^{\prime })\in P_2(v_n) \\ \wedge \forall v^{\prime }\in S_2(v_n)\cap {\tilde{M}}_2(s_c)\exists u^{\prime }={\tilde{\mu }}^{-1}(s_c,v^{\prime })\in S_1(u_n) \\ \wedge \forall v^{\prime }\in P_2(v_n)\cap {\tilde{M}}_2(s_c)\exists u^{\prime }={\tilde{\mu }}^{-1}(s_c,v^{\prime })\in P_1(u_n) \end{gathered}$$

---

人话解释一下：

​ $S_1(u_n)$是$u_n$节点的所有后继节点构成的集合；$P_1(u_n)$是$u_n$节点的所有前驱节点构成的集合；

​ $S_2(v_n)$是$v_n$节点的所有后继节点构成的集合；$P_2(v_n)$是$v_n$节点的所有前驱节点构成的集合。

​ 4条规则就说了一件事：新的节点$u_n$与已经匹配上的${\tilde{M}}_1(s_c)$中节点的关系 和 新的节点$v_n$与已经匹配上的${\tilde{M}}_2(s_c)$中节点的关系 要一模一样！不能左边有右边没有或右边有左边没有，也不能乱了顺序和边的方向。

​ 补充：有的问题需求是，小图中有的边大图中必须有，而大图中有的边小图可以没有，也就是小于等于的关系，那么就把后两条规则删除，也就是最右边的两个图的情况可以被容许。

第二类规则$F_{la1}$：

---

$$\begin{gathered} F_{la1}(s_c,u_n,v_n)=F_{la1}^1(s_c,u_n,v_n)\wedge F_{la1}^2(s_c,u_n,v_n)\wedge ...\wedge F_{la1}^q(s_c,u_n,v_n) \\ {F}_{la1}^i(s_c,u_n,v_n)= \\ |P_1(u_n)\cap {\tilde{P}}_1^{c_i}(s_c)|\le |P_2(v_n)\cap {\tilde{P}}_2^{c_i}(s_c)| \\ \wedge |P_1(u_n)\cap {\tilde{S}}_1^{c_i}(s_c)|\le |P_2(v_n)\cap {\tilde{S}}_2^{c_i}(s_c)| \\ \wedge |S_1(u_n)\cap {\tilde{P}}_1^{c_i}(s_c)|\le |S_2(v_n)\cap {\tilde{P}}_2^{c_i}(s_c)| \\ \wedge |S_1(u_n)\cap {\tilde{S}}_1^{c_i}(s_c)|\le |S_2(v_n)\cap {\tilde{S}}_2^{c_i}(s_c)| \end{gathered}$$

---

​ 这一类约束主要考虑与当前状态$s_c$中的节点直接相连的节点($P,S$集合)与新的节点对$(u_n,v_n)$间的关系。现在考虑的是3部分节点，1是已经在$M(s_c)$中的节点，即已经匹配了的；2是新的候选节点；3是$P,S$集合中的节点。3的节点中，与1和2的关系可以分成四类，分别对应上述4条规则，然后每一大类还可以按之前的分组分开，一共4q类关系，每一类关系的节点数量都要满足：小图节点数量不大于大图节点数量，若小图某一类的节点数大于大图了，说明未来不可能形成一致状态，因为未来必然会有小图中边，在大图中找不到。

第三类规则$F_{la2}$：

---

$$\begin{gathered} F_{la2}(s_c,u_n,v_n)=F_{la2}^1(s_c,u_n,v_n)\wedge F_{la2}^2(s_c,u_n,v_n)\wedge ...\wedge F_{la2}^q(s_c,u_n,v_n) \\ {F}_{la2}^i(s_c,u_n,v_n)= \\ |P_1(u_n)\cap {\tilde{V}}_1^{c_i}(s_c)|\le |P_2(v_n)\cap {\tilde{V}}_2^{c_i}(s_c)| \\ \wedge |S_1(u_n)\cap {\tilde{V}}_1^{c_i}(s_c)|\le |S_2(v_n)\cap {\tilde{V}}_2^{c_i}(s_c)| \end{gathered}$$

---

​ 这一类约束主要考虑与当前状态$s_c$中的节点不直接相连的节点($V$集合)与新的节点对$(u_n,v_n)$间的关系。现在考虑的是3部分节点，1是已经在$M(s_c)$中的节点，即已经匹配了的；2是新的候选节点；3是$V$集合中的节点。3的节点中，与1和2的关系可以分成2类，分别对应上述2条规则，然后每一大类还可以按之前的分组分开，一共2q类关系，每一类关系的节点数量都要满足：小图节点数量不大于大图节点数量，若小图某一类的节点数大于大图了，说明未来不可能形成一致状态，因为未来必然会有小图中边，在大图中找不到。

​

​ 上述三类规则其实是把新节点对$(u_n,v_n)$的度分成三部分，第一部分是与$M(s)$中节点的连接；第二部分是与$P(s)、V(s)$中节点的连接，即1-lookahead；第三部分是与$V(s)$中节点的连接，即2-lookahead。这三类连接又可以分为入度和出度，与其连接的节点又可以按分组分开，其中第一部分$M(s)$中已经匹配上的节点分组一定相同，因此可以不考虑分组。这样分类后，每一类度的数量都要满足，小图不大于大图，否则将不可能同构，其中第一类比较特殊，必须完全相同才能同构，当然也有只需要小于等于的需求，这类需求严格意义上已经不是子图同构了。

3 结语

​ 终于写完了，太不好描述了~~~这是近期做的一个复杂网络相关项目中用到的算法，学习实现后记录一下~如果有不对的地方望大佬们指正！