Question

如果子序列单调增加然后单调减少，或者如果它可以循环移位到单调增加然后单调减少，则子序列是偶像的。

给定一个序列，我如何有效地确定最长的比特子序列？

编辑：编辑标题到子序列

Answer 1

这里包括一个完整的可编译算法示例：

import java.util.Arrays;

public class LBS {

public static int binarySearchBetween(int[] arr, int end, int val) {
    int low = 0, high = end;
    if (val < arr[0]) {
        return 0;
    }
    if (val > arr[end]) {
        return end + 1;
    }
    while (low <= high) {
        int mid = (low + high) / 2;
        if (low == high) {
            return low;
        } else {
            if (arr[mid] == val) {
                return mid;
            }
            if (val < arr[mid]) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
    }
    return -1;
}

/**
 * Returns an array of LIS results such that arr[i] holds the result of the 
 * LIS calculation up to that index included.
 * @param arr The target array.
 * @return An array of LIS results.
 */
public static int[] lisArray(int[] arr) { // O(n*logn) 
    /* Regular LIS */
    int size = arr.length;
    int[] t = new int[size]; 
    t[0]=arr[0];
    int end = 0;

    /* LIS ARRAY */
    int[] lis = new int[size]; // array for LIS answers.
     // Start at 1 (longest sub array of a single element is 1)
    lis[0]=1; 

    for (int i=1; i<size; i++) { // O(n) * O(logn) 
        int index = binarySearchBetween(t, end, arr[i]);
        t[index] = arr[i];
        if (index > end) {
            end++;
        }
        lis[i]=end+1; // saves the current calculation in the relevant index
    }
    return lis;
}

/*
* Input:  {1, 11, 2, 10, 4, 5, 2, 1}
* Output: {1,  2, 2,  3, 3, 4, 4, 4}
* Each index in output contains the LIS calculation UP TO and INCLUDING that 
* index in the original array.
*/

public static int[] ldsArray(int[] arr) { // O(n*logn)
    int size = arr.length;
    int t[] = new int[size];
    for (int i = 0; i < size; i++) {
        t[i] = -arr[i];
    }
    int ans[] = lisArray(t);
    return ans;
}

public static int lbs(int[] arr) { // O(n*logn)
    int size = arr.length;
    int[] lis = lisArray(arr); // O(n*logn)
    int[] lds = ldsArray(arr); // O(n*logn)
    int max = lis[0]+lds[size-1]-1;
    for (int i=1; i<size; i++) { // O(n)
        max = Math.max(lis[i]+lds[size-i]-1, max);
    }
    return max;
}

public static void main (String[] args)
{
        int arr[] = {1,11,2,10,4,5,2,1};
        System.out.println(Arrays.toString(arr));
        System.out.println(lbs(arr));
}
}

解释：

首先，二进制搜索使用O（logn）的复杂度，它是给定的，我不会在这个帖子中解释这个。

此方法使用LIS的动态编程版本，其使用O（n * logn）的复杂度（也是给定的，此处不再解释）动态LIS算法返回最长子阵列的长度。略微修改后，我们将数据保存为n个最长子数组长度的数组，直到并包括该索引。

所以在每个索引中我们知道＆＃34;最大长度到索引＆＃34; 接下来我们为LDS做同样的事情。这将为我们提供＆＃34;索引＆＃34;

的最大长度值

之后我们交叉组合这些值，这给了我们＆＃34;最大索引的最大长度+索引的最大长度＆＃34;

现在由于索引中的元素被计算两次，我们删除一个。从而产生公式：

对于n＆gt; = 1;

，

lbs[i] = lis[i]+lds[n-i]-1

至于复杂性以下命令：

int[] lis = lisArray(arr); // O(n*logn)
int[] lds = ldsArray(arr); // O(n*logn)

每项工作O(n*logn)复杂性

和for循环：

for (int i=1; i<size; i++) { // O(n)
        max = Math.max(lis[i]+lds[size-i]-1, max);
    }

以O(n)复杂度工作所以总数是O(n*logn)+O(n*logn)+O(n) = O(n*logn)

O（n * logn）复杂度中最长的比特子序列

1 个答案: