最长递增子序列的潜在 O(n) 解

Posted 2023-02-23

【中文标题】最长递增子序列的潜在 O(n) 解

【英文标题】：potential O(n) solution to Longest Increasing Subsequence

【发布时间】：2014-02-25 15:36:10

【问题描述】：

我试图回答这个问题，只使用递归（动态编程） http://en.wikipedia.org/wiki/Longest_increasing_subsequence

从这篇文章中，我意识到最有效的现有解决方案是 O(nlgn)。我的解决方案是 O(N)，我找不到失败的案例。我包括了我使用的单元测试用例。

import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.Test;

public class LongestIncreasingSubseq 

    public static void main(String[] args) 
        int[] arr = 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15, 1;
        getLongestSubSeq(arr);
    

    public static List<Integer> getLongestSubSeq(int[] arr) 
        List<Integer> indices = longestRecursive(arr, 0, arr.length-1);
        List<Integer> result = new ArrayList<>();
        for (Integer i : indices) 
            result.add(arr[i]);
        

        System.out.println(result.toString());
        return result;
    

    private static List<Integer> longestRecursive(int[] arr, int start, int end) 
        if (start == end) 
            List<Integer> singleton = new ArrayList<>();
            singleton.add(start);
            return singleton;
        

        List<Integer> bestRightSubsequence = longestRecursive(arr, start+1, end); //recursive call down the array to the next start index
        if (bestRightSubsequence.size() == 1 && arr[start] > arr[bestRightSubsequence.get(0)]) 
            bestRightSubsequence.set(0, start); //larger end allows more possibilities ahead
         else if (arr[start] < arr[bestRightSubsequence.get(0)]) 
            bestRightSubsequence.add(0, start); //add to head
         else if (bestRightSubsequence.size() > 1 && arr[start] < arr[bestRightSubsequence.get(1)]) 
            //larger than head, but still smaller than 2nd, so replace to allow more possibilities ahead
            bestRightSubsequence.set(0, start); 
        

        return bestRightSubsequence;
    

    @Test
    public void test() 
        int[] arr1 = 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15, 1;
        int[] arr2 = 7, 0, 9, 2, 8, 4, 1;
        int[] arr3 = 9, 11, 2, 13, 7, 15;
        int[] arr4 = 10, 22, 9, 33, 21, 50, 41, 60, 80;
        int[] arr5 = 1, 2, 9, 4, 7, 3, 11, 8, 14, 6;
        assertEquals(getLongestSubSeq(arr1), Arrays.asList(0, 4, 6, 9, 11, 15));
        assertEquals(getLongestSubSeq(arr2), Arrays.asList(0, 2, 8));
        assertEquals(getLongestSubSeq(arr3), Arrays.asList(9, 11, 13, 15));
        assertEquals(getLongestSubSeq(arr4), Arrays.asList(10, 22, 33, 50, 60, 80));
        assertEquals(getLongestSubSeq(arr5), Arrays.asList(1, 2, 4, 7, 11, 14));
    

由于关系 T(n) = T(n-1) + O(1) => T(n) = O(n)，因此成本严格为 O(n)

任何人都可以找到失败的案例或存在任何错误吗？非常感谢。

更新： 感谢大家指出我在之前实施中的错误。下面的最终代码通过了它曾经失败的所有测试用例。

这个想法是列出（计算）所有可能的递增子序列（每个从索引 i 开始，从 0 到 N.length-1）并选择最长的子序列。我使用记忆（使用哈希表）来避免重新计算已计算的子序列 - 因此对于每个起始索引，我们只计算一次所有递增的子序列。

但是，在这种情况下，我不确定如何正式推导出 时间复杂度 - 如果有人能阐明这一点，我将不胜感激。非常感谢。

import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;

public class LongestIncreasingSubsequence 

    public static List<Integer> getLongestSubSeq(int[] arr) 
        List<Integer> longest = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) 
            List<Integer> candidate = longestSubseqStartsWith(arr, i);
            if (longest.size() < candidate.size()) 
                longest = candidate;
            
        

        List<Integer> result = new ArrayList<>();
        for (Integer i : longest) 
            result.add(arr[i]);
        

        System.out.println(result.toString());
        cache = new HashMap<>(); //new cache otherwise collision in next use - because object is static
        return result;
    

    private static Map<Integer, List<Integer>> cache = new HashMap<>();
    private static List<Integer> longestSubseqStartsWith(int[] arr, int startIndex) 
        if (cache.containsKey(startIndex))  //check if already computed
            //must always return a clone otherwise object sharing messes things up
            return new ArrayList<>(cache.get(startIndex)); 
        

        if (startIndex == arr.length-1) 
            List<Integer> singleton = new ArrayList<>();
            singleton.add(startIndex);
            return singleton;
        

        List<Integer> longest = new ArrayList<>();
        for (int i = startIndex + 1; i < arr.length; i++) 
            if (arr[startIndex] < arr[i]) 
                List<Integer> longestOnRight = longestSubseqStartsWith(arr, i);
                if (longestOnRight.size() > longest.size()) 
                    longest = longestOnRight;
                
            
        

        longest.add(0, startIndex);
        List<Integer> cloneOfLongest = new ArrayList<>(longest);
        //must always cache a clone otherwise object sharing messes things up
        cache.put(startIndex, cloneOfLongest); //remember this subsequence
        return longest;
    

    @Test
    public void test() 
        int[] arr1 = 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15, 1;
        int[] arr2 = 7, 0, 9, 2, 8, 4, 1;
        int[] arr3 = 9, 11, 2, 13, 7, 15;
        int[] arr4 = 10, 22, 9, 33, 21, 50, 41, 60, 80;
        int[] arr5 = 1, 2, 9, 4, 7, 3, 11, 8, 14, 6;
        int[] arr6 = 0,0,0,0,0,0,1,1,1,1,2,3,0,0,0,1,1,0,1,1,0,1,0,3;
        int[] arr7 = 0,1,2,0,1,3;
        int[] arr8 = 0,1,2,3,4,5,1,3,8;
        assertEquals(getLongestSubSeq(arr1), Arrays.asList(0, 4, 6, 9, 13, 15));
        assertEquals(getLongestSubSeq(arr2), Arrays.asList(0, 2, 8));
        assertEquals(getLongestSubSeq(arr3), Arrays.asList(9, 11, 13, 15));
        assertEquals(getLongestSubSeq(arr4), Arrays.asList(10, 22, 33, 50, 60, 80));
        assertEquals(getLongestSubSeq(arr5), Arrays.asList(1, 2, 4, 7, 11, 14));
        assertEquals(getLongestSubSeq(arr6), Arrays.asList(0,1,2,3));
        assertEquals(getLongestSubSeq(arr7), Arrays.asList(0,1,2,3));
        assertEquals(getLongestSubSeq(arr8), Arrays.asList(0, 1, 2, 3, 4, 5, 8));
    

    public static void main(String[] args) 
        int[] arr1 = 7, 0, 9, 2, 8, 4, 1;
        System.out.println(getLongestSubSeq(arr1));
    

【问题讨论】：

为什么要投反对票和接近投票？这个问题非常有意义，显示了研究成果，而且绝对有用。

您可能会更幸运地找到带有模糊/随机测试的反例。实现一个已知正确的算法，生成随机序列，并比较两种实现的结果。

@kba 既不赞成也不反对，但它看起来像一个典型的 find-the-bug-in-my-code ，它经常被相当严重地反对（而且不是那么有用）（我是无法看到这些和这之间的显着差异，但选票却大不相同）。此外，一般来说，除了实际代码之外，伪代码 / 高级描述而不是 / 可以更容易地看到发生了什么。

查看您链接的***页面，引用了一篇论文的Omega(nlogn) 下限。我自己没有验证它，但我认为Omega(nlogn) 确实是常见计算模型的下限。引用链接到这里，您可以在此处下载 pdf：sciencedirect.com/science/article/pii/0012365X7590103X

"""构建软件设计有两种方式：一种是简单到没有明显的缺陷，另一种是复杂到没有明显的缺陷。第一种方法要困难得多。"""

【参考方案1】：

这是我在 python3.x 中的潜在 O(N) 解决方案：

l = list(map(int,input().split()))
t = []
t2 = []
m = 0
for i in l:
    if(len(t)!=0):
        if(t[-1]<=i):
            if(t[-1]!=1):
                 t.append(i)
        else:
            if(len(t)>m):
                t2 = t
                m = len(t)
            t = [i]
    else:
        t.append(i)
print(t2,len(t2))

【参考方案2】：

这是一个 O(n^2) 算法。因为有两个循环。第二个循环隐藏在方法调用中。

这是第一个循环：for (int i = 0; i < arr.length; i++)。在这个循环中，您调用了 longestSubseqStartsWith(arr, i); 。查看longestSubseqStartWith实现我们看到for (int i = startIndex + 1; i < arr.length; i++)

【参考方案3】：

很抱歉成为坏消息的承担者，但这实际上是 O(n²)。我不确定你是否有更正式的想法，但这是我的分析：

consider the case when the input is sorted in descending order
  (longestRecursive is never executed recursively, and the cache has no effect)

getLongestSubSeq iterates over the entire input -> 1:n
  each iteration calls longestRecursive
  longestRecursive compares arr[startIndex] < arr[i] for startIndex+1:n -> i - 1

因此，比较 arr[startIndex] 2 ）。您可以通过发送按升序排序的输入来强制使用最大缓存。在这种情况下，getLongestSubSeq 将调用longestRecursive n 次；其中第一个将触发 n - 1 次递归调用，每个调用都会导致缓存未命中并运行 i - 1 次比较 arr[startIndex]

【参考方案4】：

刚才我使用以下测试用例尝试了您的算法：

 @Test
    public void test() 

      int[] arr1 = 0,1,2,3,4,5,1,3,8;
      assertEquals(getLongestSubSeq(arr1), Arrays.asList(0, 1, 2, 3, 4, 5, 8));
    

它失败了，因为它给出了输出 1, 3, 8 根据您的评论编辑。

【讨论】：

您的测试用例的预期结果应该是Arrays.asList(0, 1, 2, 3, 4, 5, 8)。

【参考方案5】：

你的程序在这个测试用例中失败了

int[] arr5 = 0,0,0,0,0,0,1,1,1,1,2,3,0,0,0,1,1,0,1,1,0,1,0,3;

您的结果[0, 1, 3] 不应该是[0,1,2,3]

【讨论】：

好收获。 0,1,2,0,1,3

甚至失败