Java 最长递增子序列的势O(n)解
我试图用递归(动态编程)来回答这个问题 从这篇文章中,我意识到最有效的现有解决方案是O(nlgn)。我的解决方案是O(N),我找不到它失败的案例。我包括我使用的单元测试用例Java 最长递增子序列的势O(n)解,java,algorithm,time-complexity,dynamic-programming,memoization,Java,Algorithm,Time Complexity,Dynamic Programming,Memoization,我试图用递归(动态编程)来回答这个问题 从这篇文章中,我意识到最有效的现有解决方案是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 Lon
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));
}
}
导入静态org.junit.Assert.assertEquals;
导入java.util.ArrayList;
导入java.util.array;
导入java.util.List;
导入org.junit.Test;
公共类LongestIncreasingSubseq{
公共静态void main(字符串[]args){
int[]arr={0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15,1};
getLongestSubSeq(arr);
}
公共静态列表getLongestSubSeq(int[]arr){
列表索引=longestrecurive(arr,0,arr.length-1);
列表结果=新建ArrayList();
for(整数i:索引){
结果。添加(arr[i]);
}
System.out.println(result.toString());
返回结果;
}
私有静态列表longestrecurive(int[]arr,int start,int end){
如果(开始==结束){
List singleton=new ArrayList();
singleton.add(开始);
返回单身;
}
List bestRightSubsequence=longestrecurive(arr,start+1,end);//递归调用数组到下一个开始索引
if(bestRightSubsequence.size()==1&&arr[start]>arr[bestRightSubsequence.get(0)]){
bestRightSubsequence.set(0,开始);//更大的结束允许更多的可能性
}else if(arr[start]1&&arr[start]
由于T(n)=T(n-1)+O(1)=>T(n)=O(n)的关系,成本严格为O(n)
有人能找到一个失败的案例,或者有任何bug吗?非常感谢
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));
}
}
更新:
感谢大家指出我在以前的实现中的错误。下面的最终代码通过了它曾经失败的所有测试用例
其思想是列出(计算)所有可能的递增子序列(每个从索引i开始,从0到N.length-1),并选择最长的子序列。我使用memonization(使用哈希表)来避免重新计算已经计算的子序列——因此对于每个起始索引,我们只计算一次所有递增的子序列
然而,在这种情况下,我不确定如何正式推导出时间复杂性,如果有人能解释这一点,我将不胜感激。非常感谢
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));
}
}
导入静态org.junit.Assert.assertEquals;
导入java.util.ArrayList;
导入java.util.array;
导入java.util.HashMap;
导入java.util.List;
导入java.util.Map;
导入org.junit.Test;
公共类longestincreatingsubsequence{
公共静态列表getLongestSubSeq(int[]arr){
列表最长=新的ArrayList();
对于(int i=0;ilongestOnRight.size()){
最长=最长或最短;
}
}
}
最长。添加(0,startIndex);
List cloneOfLongest=新数组列表(最长);
//必须始终缓存克隆,否则对象共享会把事情搞砸
cache.put(startIndex,cloneOfLongest);//还记得这个子序列吗
返回时间最长;
}
@试验
公开无效测试(){
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,1,1,1,1,2,3,0,0,0,1,1,1,0,0,3};
int[]arr7={0,1,2,0,1,3};
int[]
@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));
}
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
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))