算法设计与分析2 - 嵌套箱问题

二、嵌套箱问题

2 、一个d 维箱(x₁,x₂,...,x_n)嵌入另一个d 维箱 (y₁,y₂,...,y_n) 是指存在1,2,…,d 的一个排列π，使得 x_π(1)<y₁ ,x_π(2) <y₂, ... , x_π(d)<y_d 。

1)  证明上述箱嵌套关系具有传递性；

2)  试设计并实现一个贪心算法，用于确定一个d维箱是否可嵌入另一个d维箱；

3)  给定由n 个d 维箱组成的集合 { B₁,B₂,B₃,...,Bn} ，试设计并实现一个贪心算法找出这n 个d维箱中的一个最长嵌套箱序列，并用n和d 描述算法的计算时间复杂性。

 

1)  箱嵌套关系的传递性

证明：

设有 3 个 d 维箱 B₁(x₁ , x₂ , ．．． , x_d) ， B₂ (y₁ , y₂ , ．．． , y_d) ， B₃(z₁ , z₂ , ．．． , z_d) ， B₁ 可嵌入 B₂ ， B₂ 可嵌入 B₃ 。

B₁ 可嵌入 B₂ ，则存在排列π使得：

x_π(1) < y₁ ， x_π(2) < y₂ ，．．．， x_π(d) < y_d        ―― 1

B₂ 可嵌入 B₃ ，则存在排列θ使得：

y_θ(1) < z₁ ， y_θ(2) < z₂ ，．．．， y_θ(d) < z_d        ―― 2

   由 1 式可得：

x_θ(π(1)) < y_θ(1) ， x_θ(π(2)) < y_θ(2) ，．．．， x_θ(π(d)) < y_θ(d)  ―― 3

由 2 3 可得：存在排列 λ = θπ 使得：

x_λ(1) < z₁ ， x_λ(2) < z₂ ，．．．， x_λ(d) < z_d

根据d维箱的定义可得， B₁ 可嵌入 B₃ 。因此，嵌套箱关系具有传递性。

 

2)  d 维箱的嵌套关系

■   贪心选择性质 :

对于d维箱X (x₁ , x₂ , ．．． , x_d),Y (y₁ , y₂ , ．．． , y_d), 排列 π 、 θ 是分别使 X 、 Y 非递减有序的排列，有如下 结论:X→Y(表示X可嵌入Y)的充要条件是，对任意1≤i≤d有 x _π(i) < y_θ(i) 。

 

证明 :

      a. 充分性 :

当 对任意1≤i≤d有 x _π(i) < y_θ(i) 时，令 λ = πθ^-1, 那么

x _λ(i) = x _π(θ ^-1 _(i)) < y_θ(θ^-1 _(i)) = y_{i ，} 即存在一个排列 λ 使得对于 任意1≤i≤d， x _λ(i) < y_i ，所以 X →Y。

   b. 必要性:

用数学归纳法证明。

当维数为1时,X→Y 可得 x₁ < y_{1 ，} 那么 x _π(1) < y_θ(1) 成立 。

假设维数为 d 时，结论成立，即 : 当X→Y时，对于任意1≤i≤d，有 x _π(i) < y_{θ(i) 。} 那么当维数为 d + 1 时， 对于任意1≤i≤d+1，X→Y，则存在 λ 使得 :

x_λ(1) < y₁ ， x_λ(2) < y₂ ， ．．．， x_λ(d) <y_d ， x_λ(d+1) <y_d+1  ―― 1

先观察 1 式前 d 项 , x_λ(1) < y₁ ， x_λ(2) < y₂ ， ．．．， x_λ(d) <y_d 。

由假设可知，对任意1≤i≤d，有存在排列 π 、 θ 使得 x _π(i) < y_θ(i) ，

即 :

x _{π( 1)} ≤ x _{π( 2)} ≤ ．．． ≤ x _{π( d)}  ―― 2

y _{θ( 1)} ≤ y _{θ( 2)} ≤ ．．． ≤ y _{θ( d)} ―― 3

x _π(1) < y_θ(1) ， x _π(2) < y_θ(2) ，．．．， x _π(d) < y_θ(d)  ―― 4

此时， π 、 θ 只对 1 式前 d 项进行排列，并不包含 x_λ(d+1) 和 y_d+1 。可以将 x_λ(d+1) 按大小顺序插入到 2 式 ( 设插入位置为 j) ，从而有新的排列 π’ 使得 x_i ( 1 ≤i≤d+1 ) 非递减有序。

同理，也有 θ’ 使得 y_d+1 按大小顺序插入到 3 式后 ( 设插入位置为 k) ， y_i ( 1 ≤i≤d+1 ) 非递减有序。

因为 x_λ(d+1) <y_{d+1 ，} 易知 j ≤ k 。

当 j = k 时，因为 x _m 、 y_m ( 1 ≤m≤d+1 ) 的对应位置都没有变， 显然 x _π’(i) < y_θ’(i) ( 1 ≤i≤d+1 ) ， 所证结论成立。

当 j<k 时， x₁<y₁ ， x₂<y₂ ，．．．， x_j<x_j+1<y_j ， x_j+1<x_j+2< y_j+1 ，．．．， x_k-1<x_k< y_{k -1} ， x_k<y_{k -1} < y_k ， x_k+1<y _k+1 ，．．．， x_d+1< y _d+1 。

即 , 对任意1≤i≤d+1 x _π’(i) < y_θ’(i) ， 所证结论成立。

命题得证。

 

■   算法实现

由上面所得结论，对两个 d 维箱进行排序后，只要判断排序后两个 d 维箱的嵌套关系就可以得出结果。

-----------------------------------------------------------------------------------------

求两个箱子的嵌套关系的伪代码 :

返回 1 表示 X 嵌套 Y( 即 Y → X)

返回 �C1 表示 Y 嵌套 X( 即 X → Y)

返回 0 表示 X 和 Y 之间无嵌套关系

NEST(X , Y , d):

      Sort(X)     ▹对数组所表示的 d 维箱 X 、 Y 进行排序  

Sort(Y)

 

if X[0] > Y[0]

  then for i ← 1 to d �C 1

        do if X[i] <=Y[i]

                        then return 0

           return 1    

  else for i ← 0 to d �C 1

        do if X[i] >=Y[i]

                     then return 0

           return �C1

--------------------------------------------------------------------------------------

■   时间复杂度分析

NEST() 的主要时间消耗在于排序，使用快速排序时， NEST() 的时间复杂度为 : O(d lgd) 。

 

■   算法测试

对应的算法实现 Java 源文件为 NestedBox.java

输入： X(1,6,2,5,9) ， Y(7,4,8,19,32)

输出 :  Y 嵌套 X

 

3)  最长嵌套箱序列

■   算法思想

将 n 个 d 维箱之间的关系用一棵树来表示，其中可嵌套其它箱子的箱子为父节点，被嵌套的箱子作为孩子节点，无嵌套关系的节点为兄弟节点。这样就一个 d 维箱的深度值就是在这棵树中的深度。

深度值的递归定义如下 :

只要找出深度最大的节点，然后递归地输出它嵌套的箱子，结果就是最长嵌套箱序列。

■   贪心选择性质

假设最长 d 维箱序列的一个最优解是 B₁ , B₂ , …,B_k  (k>1), 其对应的深度值分别为 H₁, H₂ , …, H_k (H₁ > H₂…> H_k) 。

a. 若 H₁ 为最大的深度值，则说明问题的最优解以一个贪心选择开始。

b. 若 H₁ 不是最大的深度值，不妨设 H₁<H_j (1<j ≤ k) 。但 B₁ 嵌套 B_j 可得 H₁ >H_j 。与假设矛盾。所以 H₁ 为最大的深度值，这说明问题的最优解以一个贪心选择开始。

■   最优子结构性质

设嵌套序列 B₁ , B₂ , …,B_k  (k>1) 是问题的一个最优解，各个箱子的深度值为 H₁, H₂ , …, H_k (H₁ > H₂…> H_k) 。由贪心选择性质可知 H₁ 为最大深度值，其余箱子组成的序列 B₂ ,B₃ , …,B_k  (k>1) 是在所有箱子中去掉 B₁ 及与其具有相同深度值的箱子后，在剩下的箱子中查找最长嵌套箱序列的一个最优解。因此，最长嵌套箱序列问题具有最优子结构性质。

■   算法实现

--------------------------------------------------------------------------------------

求最长嵌套箱序列的伪代码 :

B 为存放 n 个 d 维箱的二维数组

Longest(B , n , d):

▹ A 存放各箱子嵌套关系的二维数组 , 下标从 0 开始 , 列数为 n+1.

▹ A[i,n] 表示箱子 i 的深度值

 

      ▹ 初始化 A 数组

      for i ← 0 to n

           do A[i , n] ← 0

      ▹ 计算嵌套关系

      for i ← 0 to n �C 1

           do for j ← i+1 to n �C 1

                    do A[i , j] ← nest(B[i] , B[j] , d)

                        A[j , i] ← �C A[i , j]

     ▹ 递归地修改嵌套的深度值

      for i ← 0 to n �C 1

           do for j ← 0 to n �C 1

                  if A[i , j] = �C 1

                    then addHeight(A , n , i , j)

      ▹ 查找深度值最大的箱子作为首嵌套箱

      maxBoxIndex ← findMax()

      ▹ 输出最长嵌套箱序列

      trace(maxBoxIndex)

--------------------------------------------------------------------------------------

递归地修改嵌套箱的深度值

addHeight(A , n , i , j):

      if A[i , n] = A[j , n]

        then A[j , n] ← A[j , n] + 1

                 for k ← 0 to n �C 1

                   do if A[j , k] = �C 1

                          then addHeight(A , n , j , k)

--------------------------------------------------------------------------------------

查找深度值最大的箱子作为首嵌套箱

findMax(A , n):

      max ← A[0 , n]

      maxBoxIndex ← 0

     

      for i ← 0 to n �C 1

        do if A[i , n] > max

               then max ← A[i , n]

                        maxBoxIndex ← i

      return maxBoxIndex

--------------------------------------------------------------------------------------

根据深度值最大的箱子 , 输出最长嵌套箱序列

trace(n , maxIndex):

      while A[max][n] > 0

        do seq ← (max+1) + “ → ” + seq

             m ← 0

             for i ← 0 to n �C 1

               do if A[max , i] = 1 and A[i , n] >=m

                       then m ← A[i , n]

                                   temp ← i

             max ← temp

      seq ← (max+1) + “ → ” + seq

      print seq

--------------------------------------------------------------------------------------

■   时间复杂度分析 :

     算法的主要时间消耗在于 Longest() 中 计算嵌套关系的时候，其中 nest() 算法的时间复杂度为 O(d lgd) 。所以总时间复杂度为 : O(n² d lgd) 。

 

■   算法测试 :

相应的算法实现文件为 LongestNestedBox.java

输入数据 : (8 个 6 维箱 )

{5, 2, 20, 1, 30, 10},{23, 15, 7, 9 ,11, 3},

{40 ,50 ,34 ,24, 14, 4},{9 ,10, 11 ,12, 13, 14},

{31, 4 ,18, 8 ,27, 17},{44, 32, 13, 19 ,41, 19},

{1 ,2, 3 ,4 ,5, 6},{80, 37 ,47 ,18 ,21, 9}

输出数据 : ( 输出数据中的数字代表按顺序输入的箱子，编号从 1 开始 )

最长嵌套箱序列 :7 → 2 → 5 → 6   

本文出自 “wintysのブログ” 博客，请务必保留此出处http://wintys.blog.51cto.com/425414/100701