44、图修改问题的新型分支策略

图修改问题的新型分支策略

在图论领域，图修改问题一直是研究的热点，旨在通过删除边或顶点，使图满足特定的性质。本文将介绍一系列针对不同图修改问题的算法，包括共图边删除、共图顶点删除以及平凡完美图边删除问题。

1. P4 - 稀疏图的共图边删除算法

对于 P4 - 稀疏图，我们可以使用 Spider 算法来解决共图边删除问题。该算法的输入是一个 P4 - 稀疏图 $G = (V, E)$，输出是一个边集 $S \subset E$。

Algorithm Spider(G):
Input: A P4 - Sparse Graph G = (V, E)
Output: A set S ⊂ E
if G (or G) is disconnected then
    Let C1, ..., Cp be the connected components of G (or G);
    Recurse on each Ci and add Spider(Ci) to the solution set S;
end
G is a spider with K = {k1, ..., k|K|} and S = {s1, ..., s|K|};
if G is a thin spider then
    Notation: ki adjacent to sj if and only if i = j;
    Add edge {ki, si} to solution set S for every i = 1, ..., |K| - 1;
end
if G is a thick spider then
    Notation: ki adjacent to sj if and only if i ≠ j;
    Add edge {ki, sj} to solution set S for every pair i < j;
end
Recurse on the head R of the spider. Return S ∪ Spider(R);

该算法的主要步骤如下：
1. 检查图的连通性 ：如果图 $G$ 或其补图不连通，将其分解为连通分量 $C_1, \cdots, C_p$，并对每个连通分量递归调用 Spider 算法，将结果添加到解集合 $S$ 中。
2. 处理蜘蛛结构 ：如果图 $G$ 是一个蜘蛛图，根据其是薄蜘蛛还是厚蜘蛛，添加相应的边到解集合 $S$ 中。
3. 递归处理头部 ：对蜘蛛图的头部 $R$ 递归调用 Spider 算法，并将结果与 $S$ 合并返回。

2. 一般图的共图边删除算法

对于一般图，我们可以使用 CographDeletion 算法，该算法将 Spider 算法作为子例程。

Algorithm CographDeletion(G, k)
Input: A Graph G = (V, E) and a positive integer k
Output: A set S of edges of G with |S| ≤ k where (V, E \ S) is a cograph if it exists, otherwise No
Initialize S = ∅;
if G is a cograph then
    Return S;
end
if k ≤ 0 then
    Return No;
end
Apply a P4 - sparse recognition algorithm;
if G is P4 - sparse then
    S ← S ∪ Spider(G);
    If |S| ≤ k, return S; Otherwise, return No.
end
else
    A forbidden graph H from Figure 1 exists;
    foreach minimal edge - deletion set E′ for H do
        Create a branch with edges from E′ deleted;
        Add the edges E′ to the solution set S;
        Apply CographDeletion to G − E′, with parameter k reduced according to the number of edges removed in the branch;
    end
end

该算法的主要步骤如下：
1. 初始化 ：初始化解集合 $S$ 为空。
2. 检查图是否为共图 ：如果图 $G$ 是共图，直接返回 $S$。
3. 检查参数 $k$ ：如果 $k \leq 0$，表示允许的边删除次数已用完，返回 No 。
4. 识别 P4 - 稀疏图 ：应用 P4 - 稀疏图识别算法，如果图 $G$ 是 P4 - 稀疏图，调用 Spider 算法并更新 $S$。
5. 处理禁止子图 ：如果图 $G$ 不是 P4 - 稀疏图，找到一个禁止子图 $H$，对其每个最小边删除集 $E’$ 进行分支处理，递归调用 CographDeletion 算法。

不同禁止子图的最小边删除集如下表所示：
| 子图 | 最小边删除集 |
| ---- | ---- |
| $C_5$ | ${a,c}, {a,d}, {b,d}, {b,e}, {c,e}$ |
| $P_5$ | ${a,d}, {b}, {c}$ |
| $\overline{P_5}$ | ${a,b}, {e,c}, {d,e}, {c,d}, {a,d,f}, {a,c,f}, {b,d,f}, {b,e,f}$ |
| 4 - pan | ${a,d}, {a,c}, {b,c}, {b,d}, {e}$ |
| co - 4 - pan | ${b,c}, {d}, {e}$ |
| fork | ${a,b}, {c}, {d}$ |
| kite | ${a,d}, {a,c,f}, {b,d,f}, {b,c}, {e}$ |

该算法的运行时间主要由分支步骤决定，不同禁止子图的运行时间分析如下：
| 子图 | 运行时间 |
| ---- | ---- |
| $C_5$ | $T(k) = 5T(k - 2)$，$T(k) \leq 2.237^k$ |
| $P_5$ | $T(k) = 2T(k - 1) + T(k - 2)$，$T(k) \leq 2.415^k$ |
| $\overline{P_5}$ | $T(k) = 4T(k - 2) + 4T(k - 3)$，$T(k) \leq 2.383^k$ |
| 4 - pan | $T(k) = T(k - 1) + 4T(k - 2)$，$T(k) \leq 2.562^k$ |
| co - 4 - pan | $T(k) = 2T(k - 1) + T(k - 2)$，$T(k) \leq 2.415^k$ |
| fork | $T(k) = 2T(k - 1) + T(k - 2)$，$T(k) \leq 2.415^k$ |
| kite | $T(k) = T(k - 1) + 2T(k - 2) + 2T(k - 3)$，$T(k) \leq 2.270^k$ |

该算法的分支过程的最坏情况由 4 - pan 子图决定，运行时间为 $O(2.562^k(n + m))$。

3. 共图顶点删除问题

共图顶点删除问题等价于寻找一个最大诱导共图子图。我们可以使用 CographVertexDeletion 算法来解决这个问题。

Algorithm CographVertexDeletion(G, k)
Input: A Graph G = (V, E) and a positive integer k
Output: A set S of vertices of G with |S| ≤ k where (V \ S, E) is a cograph if it exists, otherwise No
Initialize S = ∅;
if G is a cograph then
    Return S;
end
if k ≤ 0 then
    Return No;
end
Apply a P4 - sparse recognition algorithm;
if G is P4 - sparse then
    S ← S ∪ Spider Vertex - Deletion(G);
    If |S| ≤ k, return S; Otherwise, return No.
end
else
    A forbidden graph H from Figure 1 exists;
    foreach minimal vertex - deletion set S′ for H do
        Create a branch with vertices from S′ deleted;
        Add the vertices S′ to the solution set S;
        Apply CographVertexDeletion to G − S′, with parameter k reduced according to the number of vertices removed in the branch;
    end
end

该算法的主要步骤与共图边删除算法类似，只是将边删除改为顶点删除。不同禁止子图的最小顶点删除集如下表所示：
| 子图 | 最小顶点删除集 |
| ---- | ---- |
| $C_5$ | ${1,2}, {1,3}, {1,4}, {1,5}, {2,3}, {2,4}, {2,5}, {3,4}, {3,5}, {4,5}$ |
| $P_5$ | ${1,5}, {2}, {3}, {4}$ |
| $\overline{P_5}$ | ${1}, {3}, {4}, {2,5}$ |
| 4 - pan | ${2}, {4}, {5}, {1,3}$ |
| co - 4 - pan | ${3}, {4}, {5}, {1,2}$ |
| fork | ${3}, {4}, {5}, {1,2}$ |
| kite | ${2}, {4}, {5}, {1,3}$ |

该算法的运行时间主要由分支步骤决定，$C_5$ 子图的运行时间为 $T(k) = 10T(k - 2)$，$T(k) \leq 3.163^k$，其他子图的运行时间为 $T(k) = 3T(k - 1) + T(k - 2)$，$T(k) \leq 3.303^k$。该算法的运行时间为 $O(3.303^k(m + n))$。

下面是共图顶点删除算法的流程图：

graph TD;
    A[开始] --> B{G是否为共图};
    B -- 是 --> C[返回S];
    B -- 否 --> D{k是否小于等于0};
    D -- 是 --> E[返回No];
    D -- 否 --> F{G是否为P4 - 稀疏图};
    F -- 是 --> G[S = S ∪ Spider Vertex - Deletion(G)];
    G --> H{|S|是否小于等于k};
    H -- 是 --> C;
    H -- 否 --> E;
    F -- 否 --> I[找到禁止子图H];
    I --> J[对H的每个最小顶点删除集S'分支];
    J --> K[删除S'中的顶点];
    K --> L[更新S和k];
    L --> M[递归调用CographVertexDeletion];
    M --> N[合并结果];
    N --> C;

4. 平凡完美图边删除问题

一个图是平凡完美图，如果它没有与 $P_4$ 或 $C_4$ 同构的诱导子图。我们可以使用 TriviallyPerfectEdgeDeletion 算法来解决平凡完美图边删除问题。

Algorithm TriviallyPerfectEdgeDeletion(G, k)
Input: A Graph G = (V, E) and a positive integer k
Output: A set S of edges of G with |S| ≤ k where (V, E \ S) is trivially perfect if it exists, otherwise No
Initialize S = ∅;
if G is a trivially perfect then
    Return S;
end
if k ≤ 0 then
    Return No;
end
while There exists H isomorphic to C4 do
    Create 6 branches corresponding to the possible ways of removing any 2 edges in H
end
Apply a P4 - sparse recognition algorithm;
if G is P4 - sparse then
    S ← S ∪ Spider Vertex - Deletion(G);
    If |S| ≤ k, return S; Otherwise, return No.
end
else
    A forbidden graph H from Figure 1 exists;
    foreach minimal vertex - deletion set S′ for H do
        Create a branch with vertices from S′ deleted;
        Add the vertices S′ to the solution set S;
        Apply TriviallyPerfectEdgeDeletion to G − S′, with parameter k reduced according to the number of vertices removed in the branch;
    end
end

该算法的主要步骤如下：
1. 初始化 ：初始化解集合 $S$ 为空。
2. 检查图是否为平凡完美图 ：如果图 $G$ 是平凡完美图，直接返回 $S$。
3. 检查参数 $k$ ：如果 $k \leq 0$，表示允许的边删除次数已用完，返回 No 。
4. 处理 $C_4$ 子图 ：如果图 $G$ 中存在与 $C_4$ 同构的子图，对其进行 6 种可能的 2 边删除分支处理。
5. 识别 P4 - 稀疏图 ：应用 P4 - 稀疏图识别算法，如果图 $G$ 是 P4 - 稀疏图，调用 Spider Vertex - Deletion 算法并更新 $S$。
6. 处理禁止子图 ：如果图 $G$ 不是 P4 - 稀疏图，找到一个禁止子图 $H$，对其每个最小顶点删除集 $S’$ 进行分支处理，递归调用 TriviallyPerfectEdgeDeletion 算法。

该算法的运行时间主要由分支步骤决定，遇到 $C_4$ 子图时，运行时间为 $T(k) = 6T(k - 2)$，$T(k) \leq 2.450^k$。删除所有 $C_4$ 子图后，不再考虑 $\overline{P_5}$ 和 4 - pan 子图，其他子图的运行时间分析不变。该算法的运行时间为 $O(2.450^k(n + m))$。

下面是平凡完美图边删除算法的流程图：

graph TD;
    A[开始] --> B{G是否为平凡完美图};
    B -- 是 --> C[返回S];
    B -- 否 --> D{k是否小于等于0};
    D -- 是 --> E[返回No];
    D -- 否 --> F{是否存在C4子图};
    F -- 是 --> G[对C4子图进行6种2边删除分支];
    G --> F;
    F -- 否 --> H{G是否为P4 - 稀疏图};
    H -- 是 --> I[S = S ∪ Spider Vertex - Deletion(G)];
    I --> J{|S|是否小于等于k};
    J -- 是 --> C;
    J -- 否 --> E;
    H -- 否 --> K[找到禁止子图H];
    K --> L[对H的每个最小顶点删除集S'分支];
    L --> M[删除S'中的顶点];
    M --> N[更新S和k];
    N --> O[递归调用TriviallyPerfectEdgeDeletion];
    O --> P[合并结果];
    P --> C;

综上所述，我们介绍了一系列针对不同图修改问题的算法，这些算法通过分支策略和递归调用，有效地解决了共图边删除、共图顶点删除以及平凡完美图边删除问题。这些算法的运行时间都与参数 $k$ 相关，并且在不同的图结构下有不同的表现。未来，我们可以进一步研究如何优化这些算法的运行时间，以及将这些算法应用到更多的图修改问题中。

图修改问题的新型分支策略

5. 算法总结与对比

为了更清晰地了解各个算法的特点和性能，我们对上述介绍的算法进行总结和对比，如下表所示：
| 算法名称 | 问题类型 | 输入 | 输出 | 运行时间 |
| ---- | ---- | ---- | ---- | ---- |
| Spider | 共图边删除（P4 - 稀疏图） | 一个 P4 - 稀疏图 $G = (V, E)$ | 一个边集 $S \subset E$ | - |
| CographDeletion | 共图边删除（一般图） | 一个图 $G = (V, E)$ 和正整数 $k$ | 边集 $S$，$|S| \leq k$ 使 $(V, E \setminus S)$ 为共图，否则 No | $O(2.562^k(n + m))$ |
| CographVertexDeletion | 共图顶点删除 | 一个图 $G = (V, E)$ 和正整数 $k$ | 顶点集 $S$，$|S| \leq k$ 使 $(V \setminus S, E)$ 为共图，否则 No | $O(3.303^k(m + n))$ |
| TriviallyPerfectEdgeDeletion | 平凡完美图边删除 | 一个图 $G = (V, E)$ 和正整数 $k$ | 边集 $S$，$|S| \leq k$ 使 $(V, E \setminus S)$ 为平凡完美图，否则 No | $O(2.450^k(n + m))$ |

从运行时间来看，不同算法在处理不同类型的图修改问题时表现各异。 CographDeletion 算法处理一般图的共图边删除问题，其运行时间受 4 - pan 子图的分支情况影响； CographVertexDeletion 算法在共图顶点删除问题上，运行时间主要由分支步骤决定； TriviallyPerfectEdgeDeletion 算法在处理平凡完美图边删除问题时，由于对 $C_4$ 子图的特殊处理，运行时间得到了优化。

6. 算法正确性与关键引理

在解决图修改问题的过程中，一些关键引理保证了算法的正确性。

6.1 蜘蛛图的边性质引理

引理 5：设 $G$ 是一个（薄或厚）蜘蛛图，$R$ 是 $G$ 的头部，$K$ 是 $G$ 的主体。那么，对于任意边 $e = {r, k}$，其中 $r \in R$ 且 $k \in K$，该边不在 $G$ 的任何 $C_4$ 中。此外，对于任意腿部边和头部边的子集 $E’$，边 $e = {r, k}$ 不在 $G - E’$ 的任何 $P_4$ 中。

证明：在蜘蛛图中，注意到即使在删除腿部边和头部边之后，任何 $C_4$ 都不能包含来自 $S$ 的顶点 $s$，因为 $s$ 的邻域诱导出一个团。由于 $K$ 是一个团，并且每个 $k \in K$ 都与每个 $r \in R$ 相邻，显然，除非 $C_4$ 完全包含在 $R$ 中，否则在 $K \cup R$ 中不可能存在 $C_4$。因此，没有 $C_4$ 包含从 $R$ 到 $K$ 的边。

这个引理表明，在分支阶段销毁所有 $C_4$ 后，当我们得到一个无 $C_4$ 的蜘蛛图时，可以放心地删除腿部边，而不用担心会创建新的 $C_4$。当对头部 $R$ 进行递归并发现其蜘蛛结构时，移动这些边也不会创建 $C_4$，因为它们在子蜘蛛中是腿部边，在原始图中是头部边。

6.2 无 $C_4$ 图的共连通分量引理

引理 6：如果一个图 $G$ 是无 $C_4$ 的，并且其补图是不连通的，那么 $G$ 恰好有两个共连通分量 $C_1$ 和 $C_2$，其中一个是团，另一个不是。

证明：如果 $C_1$ 不是团，它有两个不相邻的顶点 $u$ 和 $v$。现在，$u$ 和 $v$ 都与 $G \setminus C_1$ 中的所有顶点相邻，所以如果 $G \setminus C_1$ 中有一条非边 ${w, x}$，那么 ${u, v, w, x}$ 将诱导出一个 $C_4$。因此，$G \setminus C_1$ 是一个团。

这个引理解决了一个潜在的担忧，即在 Spider(G) 子例程中，从 $R$ 的不同共连通分量中删除边可能会创建 $C_4$。实际上，由于无 $C_4$ 图的特殊结构，这种情况不会发生。

7. 算法的应用与拓展

这些图修改算法在实际应用中有广泛的用途，例如在社交网络分析、电路设计等领域。在社交网络中，我们可能需要通过删除一些边或顶点来使网络结构更符合某种特定的模式，如共图或平凡完美图，以更好地分析网络的性质和功能。

此外，这些算法还可以进行拓展。例如，通过将边删除算法应用于输入图的补图，共图边删除问题可以转化为共图边完成问题，平凡完美图边删除问题可以转化为余平凡完美图边完成问题。

未来的研究方向可以包括进一步优化算法的运行时间。例如，考虑更一般的图类，如半 P4 - 稀疏图，通过改进分支规则和递归策略，有望进一步提高算法的效率。还可以探索将这些算法应用于更多类型的图修改问题，如 $P_3$ 自由图的边删除问题（即聚类删除问题），利用平凡完美图作为 $P_3$ 自由图的超类，开发新的算法。

8. 总结

本文介绍了一系列针对图修改问题的算法，包括共图边删除、共图顶点删除以及平凡完美图边删除问题。这些算法通过分支策略和递归调用，利用图的特殊结构（如蜘蛛图）和关键引理，有效地解决了不同类型的图修改问题。

不同算法在运行时间和处理方式上各有特点。 CographDeletion 算法适用于一般图的共图边删除，通过识别 P4 - 稀疏图和处理禁止子图来实现； CographVertexDeletion 算法在共图顶点删除问题上，通过对禁止子图的顶点删除分支来寻找解决方案； TriviallyPerfectEdgeDeletion 算法在处理平凡完美图边删除问题时，对 $C_4$ 子图的特殊处理优化了运行时间。

关键引理如引理 5 和引理 6 保证了算法的正确性，解决了在算法执行过程中可能出现的问题。这些算法不仅在理论上具有重要意义，而且在实际应用中也有广泛的用途，未来还有很大的拓展和优化空间。

通过对这些算法的研究和应用，我们可以更好地理解图的结构和性质，为解决各种实际问题提供有力的工具。

下面是一个总结算法流程的流程图：

graph LR;
    A[输入图G和参数k] --> B{选择算法类型};
    B -- 共图边删除（一般图） --> C[CographDeletion算法];
    B -- 共图顶点删除 --> D[CographVertexDeletion算法];
    B -- 平凡完美图边删除 --> E[TriviallyPerfectEdgeDeletion算法];
    C --> F[识别P4 - 稀疏图];
    F -- 是 --> G[调用Spider算法];
    F -- 否 --> H[处理禁止子图分支];
    D --> I[识别P4 - 稀疏图];
    I -- 是 --> J[调用Spider Vertex - Deletion算法];
    I -- 否 --> K[处理禁止子图顶点删除分支];
    E --> L{是否存在C4子图};
    L -- 是 --> M[对C4子图进行6种2边删除分支];
    M --> L;
    L -- 否 --> N[识别P4 - 稀疏图];
    N -- 是 --> O[调用Spider Vertex - Deletion算法];
    N -- 否 --> P[处理禁止子图顶点删除分支];
    G --> Q[合并结果];
    H --> Q;
    J --> R[合并结果];
    K --> R;
    O --> S[合并结果];
    P --> S;
    Q --> T[输出结果];
    R --> T;
    S --> T;

这个流程图展示了不同算法在处理图修改问题时的主要步骤和分支情况，帮助我们更直观地理解算法的执行过程。