43、凸多联骨牌重建与多类对象模型中的行为安全

凸多联骨牌重建与多类对象模型中的行为安全

1. 凸多联骨牌的重建

在凸多联骨牌的重建问题中，我们首先引入一些基本的定义和公式。设 (A = \sum_{j = 1}^{m} h_j = \sum_{i = 1}^{n} v_i)，这里假设 (n_2 < s_1)（(s_2 < n_1) 的情况类似，其他情况暂不考虑）。令 (W_j) 为前 (j) 列中 “1” 的集合，(N_i) 为前 (i) 行中 “1” 的集合。设 (R(u_j; j)) 和 (R(d_j; j)) 分别为第 (j) 列中包含 “1” 的最上和最下单元格。

根据相关命题和推论，我们有以下性质：
- 若 (n_2 < s_1)，对于所有 (j \in [n_2 + 1::s_1 - 1])，有 (N_{u_{j - 1}} \subset W_{j - 1}) 且 (W_{j - 1} \subset N_{d_j})，进而可得 (H_{u_{j - 1}} < V_{j - 1})，(H_{d_j} > V_j)，(A - H_{d_j} < A - V_j)，(A - H_{u_{j - 1}} > A - V_{j - 1})。
- 若 (s_2 < n_1)，对于所有 (j \in [s_2 + 1::n_1 - 1])，有 (H_{u_{j - 1}} < A - V_j)，(H_{d_j} > A - V_{j - 1})，(A - H_{d_j} < V_{j - 1})，(A - H_{u_{j - 1}} > V_j)。

这些性质将用于后续确定一些初始 “1” 的位置。

填充操作

我们在过程中使用平衡二叉树（如 AVL 树），并定义了以下操作：
| 操作 | 描述 | 复杂度 |
| ---- | ---- | ---- |
| empty(tree) | 当树为空时返回 true ，否则返回 false ，始终花费 (O(1)) 时间。 | (O(1)) |
| delete(k, tree) | 从树中删除元素 (k)，复杂度小于 (O(\log |tree|))，其中 (|tree|) 表示树的大小（树中元素的数量）。 | (< O(\log |tree|)) |
| insert(k, tree) | 将 (k) 插入树中（若 (k \notin tree)），否则不做任何操作，复杂度小于 (O(\log |tree|))。 | (< O(\log |tree|)) |
| min(tree) | 返回树中的最小元素，花费小于 (O(\log |tree|)) 时间。 | (< O(\log |tree|)) |
| max(tree) | 返回树中的最大元素，花费小于 (O(\log |tree|)) 时间。 | (< O(\log |tree|)) |

我们有两个全局变量 treecol 和 treerow 作为平衡二叉树，分别用于存储后续主循环中要检查的列和行的编号。

对于每一行 (i)（(i \in [1, \cdots, m])），我们定义以下辅助变量：(l_i)，(r_i)，(p_i)，(q_i)，(\tilde{l}_i)，(\tilde{r}_i)，(\tilde{p}_i)，(\tilde{q}_i)，(free0_i)；对于每一列 (j)（(j \in [1, \cdots, n])），类似地定义 (l_j)，(r_j)，(p_j)，(q_j)，(\tilde{l}_j)，(\tilde{r}_j)，(\tilde{p}_j)，(\tilde{q}_j)，(free0_j)。其中，(l) 是包含 “1” 的最小位置，(r) 是包含 “1” 的最大位置，(p) 是不包含 “0” 的最小位置，(q) 是不包含 “0” 的最大位置；(\tilde{l})，(\tilde{r})，(\tilde{p})，(\tilde{q}) 分别是 (l)，(r)，(p)，(q) 的临时值；(free0) 是包含在 (\tilde{p}) 和 (\tilde{q}) 之间 “0” 位置的平衡二叉树。

变量初始化如下：在行中，(l = \tilde{l} = n + 1)，(r = \tilde{r} = 0)，(p = \tilde{p} = 1)，(q = \tilde{q} = n)，(free0 = nil)；在列中，(l = \tilde{l} = m + 1)，(r = \tilde{r} = 0)，(p = \tilde{p} = 1)，(q = \tilde{q} = m)，(free0 = nil)，其中 (nil) 表示空树。

我们还引入了两个辅助操作：
- 在第 (i) 行第 (j) 位置放置 “0” ：

if R[i; j] = 1 then exit( fail )
if R[i; j] != 0 then
    R[i; j] = 0
    insert( j, treecol )
    if i < ~pj + vj and i >= ~pj then
        ~pj = i + 1
        while not empty( free0j ) and (k = min( free0j )) < ~pj + vj do
            delete( k, free0j )
            ~pj = k + 1
    if i > ~qj - vj and i <= ~qj then
        ~qj = i - 1
        while not empty( free0j ) and (k = max( free0j )) > ~qj - vj do
            delete( k, free0j )
            ~qj = k - 1
    if ~pj + vj <= i <= ~qj - vj then insert( i, free0j )

• 在第 (i) 行第 (j) 位置放置 “1” ：

if R[i; j] = 0 then exit( fail )
if R[i; j] != 1 then
    R[i; j] = 1
    insert( j, treecol )
    if rj < lj then
        lj = rj = ~lj = ~rj = i
        if ~pj < i - vj + 1 then ~pj = i - vj + 1
        if ~qj < i + vj - 1 then ~qj = i + vj - 1
        while not empty( free0j ) do
            k = min( free0j )
            delete( k, free0j )
            if k < i and k + 1 > ~pj then ~pj = k + 1
            if k > i and k - 1 < ~qj then ~qj = k - 1
    else
        if i < ~lj then ~lj = i
        if i > ~rj then ~rj = i

此外，还定义了 ()、(\ominus)、(\otimes)、(\diamond) 操作，用于在矩阵 (R) 中放置 “1” 或 “0”。这些操作的具体形式如下：
- 操作 () 在第 (i) 行 ：

if ~li < li then
    for j = ~li to li - 1 do put "1" in the ith row in the jth position
    li = ~li
if ~ri > ri then
    for j = ri + 1 to ~ri do put "1" in the ith row in the jth position
    ri = ~ri

• 操作 (\ominus) 在第 (i) 行 ：

if pi < ~pi then
    for j = pi to ~pi - 1 do put "0" in the ith row in the jth position
    pi = ~pi
if qi > ~qi then
    for j = ~qi + 1 to qi do put "0" in the ith row in the jth position
    qi = ~qi

• 操作 (\otimes) 在第 (i) 行 ：

if li > ri and pi + hi - 1 >= qi - hi + 1 then
    li = ~li = qi - hi + 1
    ri = ~ri = pi + hi - 1
    for j = li to ri do put "1" in the ith row in the jth position
if li <= ri and qi - hi + 1 < li then
    for j = qi - hi + 1 to li - 1 do
        put "1" in the ith row in the jth position
    li = ~li = qi - hi + 1
if li <= ri and pi + hi - 1 > ri then
    for j = ri + 1 to pi + hi - 1 do
        put "1" in the ith row in the jth position
    ri = ~ri = pi + hi - 1

• 操作 (\diamond) 在第 (i) 行 ：

if li <= ri and pi <= ri - hi then
    for j = pi to ri - hi do put "0" in the ith row in the jth position
    pi = ~pi = ri - hi + 1
if li <= ri and qi >= li + hi then
    for j = li + hi to qi do put "0" in the ith row in the jth position
    qi = ~qi = li + hi - 1

填充操作的主循环形式如下：

repeat
    while not empty( treerow ) do
        k = min( treerow )
        delete( k, treerow )
        perform operations ; ⊖; ⊗;  in the kth row
    while not empty( treecol ) do
        k = min( treecol )
        delete( k, treecol )
        perform operations ; ⊖; ⊗;  in the kth column
until empty( treerow ) and empty( treecol )

在预处理阶段，我们不放置 “0” 或 “1”，仅在必要时修改特定行或列的变量 (\tilde{p}) 和 (\tilde{q})，并将这些行或列的编号分别放入 treerow 或 treecol 中。在执行填充操作过程中放置 “0” 或 “1”。

如果填充操作过程返回 fail ，则说明具有投影 (H) 和 (V)（且初始位置相同）的凸多联骨牌不存在。

当 treerow 和 treecol 为空时，有两种不同情况：
- 情况 1 ：矩阵 (R) 的每个单元格都包含 “0” 或 “1”，此时我们得到了解决方案，集合 (S) 是一个凸多联骨牌且满足 ((H, V))。
- 情况 2 ：每行至少包含一个 “1”，但矩阵 (R) 中存在一些既不包含 “0” 也不包含 “1” 的单元格。若有行或列包含这些空单元格且至少有一个 “1”，则该行或列的辅助变量满足 (l - \tilde{p} = \tilde{q} - r \neq 0)。若某列没有 “1”，则该列空单元格的数量等于可放置 “1” 数量的两倍。此外，若 (R[i; j]) 既不包含 “0” 也不包含 “1”，则存在 (R[i_0; j_0]) 也既不包含 “0” 也不包含 “1”，且满足 (i = i_0) 且 (|j - j_0| = h_i) 或 (j = j_0) 且 (|i - i_0| = v_j)。整个矩阵 (R) 中空单元格的数量等于缺失 “1” 数量的两倍。因此，这些既不包含 “0” 也不包含 “1” 的单元格形成一个或多个不相交的循环，每个循环至少包含 4 个单元格。循环中的单元格交替标记为 “0” 和 “1”，但有些循环的标记是相关的。为了正确填充这些单元格，我们构建一个合适的 2 - SAT 问题，该问题可以在线性时间内解决。由于空单元格的数量小于 (mn)，这种情况下的额外解决方案成本最多为 (O(mn))。

填充操作过程的复杂度分析如下：在每个位置 ((i; j)) 我们最多执行两次 put 操作（一次在第 (i) 行，一次在第 (j) 列）。在算法中对行或列执行 ()、(\ominus)、(\otimes)、(\diamond) 操作时，至少执行一次 put 操作。因此，我们只检查 (O(mn)) 个列和行，检查一行的成本为 (O(\log n) +) [ put 操作的成本 ]，检查一列的成本为 (O(\log m) +) [ put 操作的成本 ]。所以，算法主循环的全局成本为 (O(mn(\log m + \log n)) +) [ 所有 put 操作的成本 ]。

所有 put 操作的全局成本估计如下：在第 (i) 行执行 put 操作时，在 treecol 中最多执行 (m) 次插入操作，成本为 (O(m \log m))，所有行的成本最多为 (O(mn \log m))；在所有列中，在 treerow 中插入操作的成本最多为 (O(mn \log n))。在第 (i) 行的 free0_i 树中，每个位置的插入操作最多执行一次，删除操作也不超过 (m) 次， min 和 max 函数仅在修改 (\tilde{p}_i) 或 (\tilde{q}_i) 时执行，这些操作的数量最多为 (m) 次， free0_i 树中所有操作的成本最多为 (O(m \log m))，所有 (n) 行的成本最多为 (O(mn \log m))；在所有 (m) 列中，树操作的成本最多为 (O(mn \log n))。所有剩余操作的复杂度最多为 (O(mn))。因此，填充操作过程的成本最多为 (O(mn(\log m + \log n)))。

综上所述，填充操作过程的成本最多为 (O(mn \log mn))。

2. 多类对象模型中的行为安全

在对象 - 关系数据库模型的扩展中引入多类型对象时，我们面临着方法调度消歧的问题。这个问题与多重继承定义的类中的冲突密切相关。我们从概念建模的更广泛视角研究当前的工作，综合考虑理论和实践观点。最终，提出了基于方法重定义约束的解决方案，并使用范畴论的形式工具来呈现主要思想，这与我们之前用范畴构造描述面向对象模型的尝试一致。

引言

近期在信息系统设计和概念建模的研究揭示了面向对象范式的一些实际局限性。例如，面向对象模型通常假设对象在其整个生命周期内只获取一种类型，但在现实世界中这种假设常常被打破。为此，提出了一个角色模型，定义了两种操作来获取和丢弃类型。此外，还有其他解决该问题的方法。

进一步的研究发现，在扩展了角色的面向对象模型中，属性访问和方法调度存在潜在的复杂性，这与多重继承带来的冲突密切相关。对象在运行时可以获取多种类型，这与多重继承定义的类型等效，从而导致对象的状态和行为可能出现冲突。虽然研究表明多重类型对象的结构冲突可以通过静态类型（或引用属性的上下文）解决，但上下文信息不足以消除方法调度的歧义。针对这个问题，提出了两种方法并讨论了它们的优缺点。

多类对象模型

面向对象范式的发展旨在支持对现实世界实体的直接表示，但通常假设对象在其整个生命周期内结构固定，这违背了这一原则。例如，考虑人员、学生和读者的例子，假设尚未定义通过多重继承构造的类型 SR 。在这样的数据库中，我们可以使用类型 S 和 R 来建模人员的角色，但无法表示一个既在大学学习又在大学图书馆数据库中作为读者的人。这种情况很常见，因为信息系统通常由多个共享数据的模块组成，每个模块从其特定的角度看待数据。

在这种情况下，面向对象范式提供了多重继承来建模这种语义。我们可以通过定义新类型 student - reader 来组合学生和读者的属性。然而，这种技术仅适用于处理临时对象的语言，因为临时对象的生命周期受创建它们的应用程序进程的限制。在数据库应用中，对象是持久的，独立于创建它们的进程存在。实际经验表明，预先推测实体可能具有的所有类型组合是很困难的，随着数据库应用的复杂性增加，这个问题会更加严重，可能导致多重继承定义的类型组合爆炸。

为了避免这个问题，我们引入了所谓的多类型对象，并定义了两种操作来获取和丢弃类型。这个概念可以避免构建所有通过多重继承定义的所需类型，并使对象能够根据现实世界的需求扮演不同的角色。这种对面向对象模型的扩展在相关研究中进行了形式语义的阐述。

在之前的研究中，我们使用范畴论来处理多类对象上下文中的属性访问问题，该方法非常有用。在本文中，范畴论将帮助我们使用简单的积符号来描述多重继承定义的类的结构。在范畴框架中，我们可以使用积的概念来描述继承的语义：
定义 1（积） ：在一个范畴中有两个对象 (S) 和 (T)，我们将积定义为一个对象 (S \times T)，以及投影 (\pi_s : S \times T \to S) 和 (\pi_t : S \times T \to T)，使得对于任何对象 (V) 和箭头 (q_s : V \to S) 以及 (q_t : V \to T)，存在唯一的箭头 (q : V \to S \times T) 使以下图交换：

graph LR
    S -->|πs| SxT
    T -->|πt| SxT
    V -->|qs| S
    V -->|qt| T
    V -->|q| SxT

然而，为了描述多重继承的语义，需要一些额外的交换条件。特别是，使用拉回的概念来表达虚拟基类型的语义。例如，我们展示如何定义学生类型 S 和读者类型 R 的类型层次结构，它们有共同的祖先人员类型 P ，以及一个通过多重继承从 S 和 R 继承的类型 SR 。这个简单的大学数据库与图书馆模块的示例如下：

graph LR
    P -->|πS:P| S
    P -->|πR:P| R
    SR -->|πSR:S| S
    SR -->|πSR:R| R
    R -->|πR| R+
    S -->|πS| S+
    SR -->|πSR| SR+

虚拟基类型的语义可以表示为一个对象 SRp 的构造，使得上述图交换，并且对于每个满足此条件的可能的 SR0 ，都有一个唯一的箭头指向 SRp 。这个构造称为拉回，是更一般极限构造的一个特定情况。可以等价地说， SR 满足定义 1 中 (S \times R) 的条件，但这里的交换条件扩展到了多重继承的整个菱形图。

通过这种方式，我们利用范畴论的工具，更清晰地描述了多类对象模型中多重继承的语义，为解决方法调度消歧问题提供了理论基础。

接下来，我们将继续探讨在这个多类对象模型中如何具体应用方法重定义约束来解决方法调度的问题，以及如何结合凸多联骨牌重建的相关算法思想，在不同的领域中实现更高效、准确的计算和建模。

在后续的研究中，我们可以进一步探索如何优化这些算法和模型，以适应更复杂的实际应用场景。例如，在凸多联骨牌重建中，可以研究如何减少不必要的计算步骤，提高算法的效率；在多类对象模型中，可以考虑如何更好地处理方法重定义约束，避免潜在的冲突和错误。同时，我们还可以将这些理论和方法应用到其他相关领域，如计算机图形学、数据挖掘等，以拓展其应用范围和影响力。

总之，通过对凸多联骨牌重建和多类对象模型中行为安全问题的研究，我们不仅解决了当前面临的具体问题，还为相关领域的发展提供了新的思路和方法。未来的研究将继续深入探索这些领域的潜力，为推动计算机科学和相关学科的发展做出贡献。

3. 凸多联骨牌重建的主算法

主算法的核心思想是测试 “1” 在第一行和最后一行的所有可能位置，即所谓的 “脚” 位置。当我们固定上下行的初始位置后，就可以利用之前提到的推论 1 来计算 “脚” 位置之间列中一些 “1” 的位置。在开始第 3 节中描述的填充过程时，我们希望每行至少有一个 “1”，这能确保填充过程的正确执行。

具体步骤如下：
1. 根据 “脚” 位置计算相关值 ：
- 若 “脚” 位置为 (\langle n_1, n_2\rangle) 和 (\langle s_1, s_2\rangle) 且 (n_2 < s_1)，对于所有 (j \in [n_2 + 1::s_1 - 1])，计算：
- (D_j = \min{i \in [1::m - 1] : A - H_i < A - V_j})
- (U_j = \max{i \in [2::m] : H_{i - 1} < V_{j - 1}})
- 若 (n_1 > s_2)，对于所有 (j \in [s_2 + 1::n_1 - 1])，计算：
- (D_j = \min{i \in [1::m - 1] : A - H_i < V_{j - 1}})
- (U_j = \max{i \in [2::m] : H_{i - 1} < A - V_j})
2. 确定 “1” 和 “0” 的放置位置 ：
- 容易验证，始终有 (U_j \leq D_j)，并且在第一种情况下 (D_j + 1 \geq U_{j + 1})，在第二种情况下 (U_j + 1 \geq D_{j + 1})。
- 在第 (j) 列中，我们可以在 (U_j) 和 (D_j) 之间的所有单元格中放置 “1”，在 (D_j - v_j + 1) 以上和 (U_j + v_j - 1) 以下的单元格中放置 “0”。
- 此外，“脚” 位置指定的列中所有 “1” 和 “0” 都已确定。最终，每行至少有一个 “1”。
3. 处理 “脚” 位置有公共列的情况 ：
- 如果两个 “脚” 位置有一个公共列，那么该列必须只包含 “1”，因为该列的第一个和最后一个位置都有 “1”，且 “1” 的区域是相连的。在这种情况下，每行同样至少有一个 “1”。

整个预处理过程的成本最多为 (O(m + n))。

假设存在满足 ((H, V)) 的凸多联骨牌 (S)。由于我们测试了所有 “脚” 位置，必然能正确猜出 (S) 的 “脚” 位置。此时，我们能确定列 (n_1\cdots n_2) 和 (s_1\cdots s_2) 中的所有 “1” 和 “0”，并且 “脚” 位置之间的每列至少有一个 “1”，最终每行也至少有一个 “1”。因此，填充过程不会返回 fail ，而是会返回正确的多联骨牌。

如果对于向量 ((H, V)) 不存在满足条件的凸多联骨牌 (S)，填充过程将返回 fail 。

所有 “脚” 位置测试的数量最多为 (n^2)，即 (\min(m, n)^2)。预处理和填充过程的成本最多为 (O(mn \log mn))。因此，重建具有垂直和水平投影的凸多联骨牌的成本最多为 (O(\min(m, n)^2 \cdot mn \log mn))。

4. 多类对象模型中方法调度问题的解决

在多类对象模型中，我们已经明确了多重继承的语义，接下来将重点关注如何利用方法重定义约束来解决方法调度的消歧问题。

方法重定义约束的引入

为了消除方法调度的歧义，我们引入方法重定义约束。其核心思想是，在多类型对象获取多种类型时，对方法的重定义进行限制，确保在调用方法时能够明确知道应该执行哪个具体的方法实现。

具体来说，当一个对象具有多种类型，并且这些类型中存在同名方法时，我们通过定义约束条件来确定在不同情况下应该调用哪个方法。例如，我们可以根据对象当前所处的上下文、调用方法时的参数类型等因素来设置约束。

结合范畴论的实现

我们继续利用范畴论的工具来实现方法重定义约束。在范畴框架中，我们可以将方法调用看作是范畴中的箭头，而对象的类型则是范畴中的对象。通过范畴论的性质和规则，我们可以更精确地描述方法重定义约束的语义。

例如，我们可以定义一个范畴，其中对象是不同的类型，箭头是方法调用。对于多重继承的情况，我们可以利用拉回等构造来确保方法调用的一致性和正确性。当一个对象调用某个方法时，我们可以通过范畴中的交换图来验证该调用是否满足方法重定义约束。

具体操作步骤

下面是一个简单的操作步骤示例，展示如何在多类对象模型中应用方法重定义约束：
1. 定义方法重定义规则 ：在类的定义阶段，明确规定当存在方法重定义时的优先级规则。例如，我们可以规定某个基类的方法具有更高的优先级，或者根据方法的参数类型来确定优先级。
2. 记录对象类型信息 ：在对象获取多种类型时，记录下这些类型的信息。可以使用一个数据结构（如列表或集合）来存储对象当前的所有类型。
3. 方法调用时的检查 ：当对象调用某个方法时，首先检查该方法在对象的所有类型中是否存在重定义。如果存在，根据预先定义的规则确定应该调用哪个方法实现。
4. 利用范畴论验证 ：在确定调用的方法后，利用范畴论的工具（如交换图）验证该调用是否满足多重继承的语义和方法重定义约束。

通过以上步骤，我们可以在多类对象模型中有效地解决方法调度的消歧问题，确保对象的行为具有确定性和一致性。

5. 总结与展望

本文围绕凸多联骨牌重建和多类对象模型中的行为安全问题展开了深入研究。

在凸多联骨牌重建方面，我们提出了一种基于测试 “脚” 位置的主算法。通过利用相关性质和推论，我们能够确定列中 “1” 和 “0” 的位置，确保每行至少有一个 “1”，从而保证填充过程的正确性。整个重建过程的成本在可接受的范围内，为解决凸多联骨牌重建问题提供了一种有效的方法。

在多类对象模型中，我们从概念建模的角度出发，引入了多类型对象和方法重定义约束。利用范畴论的形式工具，我们清晰地描述了多重继承的语义，并提出了一套解决方法调度消歧问题的操作步骤。这不仅解决了面向对象范式在实际应用中的局限性，还为多类对象模型的进一步发展提供了理论支持。

未来的研究方向可以从以下几个方面展开：
- 算法优化 ：在凸多联骨牌重建算法中，进一步探索如何减少不必要的计算步骤，提高算法的效率。例如，可以研究更高效的数据结构来存储和处理相关信息。
- 模型扩展 ：在多类对象模型中，考虑如何扩展模型以支持更复杂的场景。例如，引入更多的类型操作或约束条件，以满足不同应用的需求。
- 跨领域应用 ：将凸多联骨牌重建和多类对象模型的相关方法应用到其他领域，如计算机图形学、数据挖掘等。通过跨领域的应用，拓展这些理论和方法的影响力。

通过不断的研究和探索，我们有望在这些领域取得更深入的成果，为计算机科学和相关学科的发展做出更大的贡献。