如何找到最长约束的子序列

Question

给定一个包含N个不同整数的数组，找到满足以下条件的最长子序列：

1. 子序列的start元素是子序列中最小的。
2. 子序列的结束元素是子序列中最大的元素。

例如：8,1,9,4,7。 答案是1,4,7。

2,6,5,4,9,8。 答案是2,6,5,4,9或2,6,5,4,8。

这是一个O(N^2)算法：

• 设X是数字数组。
• 迭代X 假设我们在索引i 。 令Y为其中Y [j]是(j, i]中小于X [j]的元素数的数组。令z为[j, i]中小于X [i [j, i]的元素数如果X [j]小于X [i]，我们可以得到满足约束的长度为zY [j]的子序列。

• 将z设置为1 。 循环j从i-1下降到0 。

  if X[j] < X[i]: z++; ans = max(ans, z - Y[j]); else Y[j]++;

我们可以做得更好吗？ 我认为应该有一个O(NlogN)算法来找到最大长度。

Answer 1

让我重做这个O（n log n）算法的解释。

将输入序列的元素解释为2D中的点，其中x坐标是索引，y坐标是值。 我们正在寻找包含最多输入点的矩形，受左下角和右上角为输入点的约束。 在通常的分量部分顺序下，最佳矩形的左下角是最小的，右上角是最大的。

进行两次线性扫描以找到最小和最大点。 创建由前者键控的整数值段树，其操作为（i）接受键的间隔并递增/递减相关值，并且（ii）计算最大值。 该算法是通过最大点从左到右迭代，使用分段树来跟踪每个最小点和当前最大点之间（相对于部分顺序）有多少输入点。

当我们从左向右移动时，最小点和最大点都会下降。 那么假设我们正在从最大点（x，y）移动到下一个最大点（x'，y'）。 我们有x <x'和y'<y。 段树中的值如何变化？ 由于x <x'，x，x']中x坐标的点不属于右上角（x，y）的矩形，但可能属于右上角（x'，y'）的矩形。 相反，由于y'<y，y坐标为y'，y]的点可以属于右上角（x，y）的矩形，但不属于右上角（x'，y'）的矩形。 所有其他点都不受影响。

----+                   empty
    |
----+---------+ (x, y)
      removed |
--------------+-------+ (x', y')
              | added |
              |       +----+
              |       |    |

我们逐个浏览可能受影响的点，更新段树。 点数按x排序; 如果我们在初始化期间制作副本并按y排序，那么我们可以有效地枚举可能受影响的点。 请注意，随着时间的推移，x区间是成对不相交的，y区间也是如此，因此我们可以在每个可能受影响的点上花费对数时间。 给定一个点（x''，y''）使得x''in] x，x']（注意在这种情况下y''<= y'），我们需要在最小点处增加分段树其x坐标位于] inf，x'']，其y坐标位于] inf，y'']。 这可能看起来不是一维的，但实际上，x坐标上的排序和y坐标上的排序对于最小点是相反的，因此这组键是间隔。 类似地，给定一个点（x'''，y'''）y'''in y'，y]（注意x'''在这种情况下是<= x），我们需要递减这些值按键间隔。

这是Java中的“神奇”段树数据结构。

public class SegmentTree {
    private int n;
    private int m;
    private int[] deltaValue;
    private int[] deltaMax;

    private static int nextHighestPowerOfTwoMinusOne(int n) {
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return n;
    }

    public SegmentTree(int n) {
        this.n = n;
        m = nextHighestPowerOfTwoMinusOne(n) + 1;
        deltaValue = new int[m];
        deltaMax = new int[m];
    }

    private static int parent(int i) {
        int lob = i & -i;
        return (i | (lob << 1)) - lob;
    }

    private static int leftChild(int i) {
        int lob = i & -i;
        return i - (lob >>> 1);
    }

    private static int rightChild(int i) {
        int lob = i & -i;
        return i + (lob >>> 1);
    }

    public int get(int i) {
        if (i < 0 || i > n) {
            throw new IllegalArgumentException();
        }
        if (i == 0) {
            return 0;
        }
        int sum = 0;
        do {
            sum += deltaValue[i];
            i = parent(i);
        } while (i < m);
        return sum;
    }

    private int root() {
        return m >>> 1;
    }

    private int getMax(int i) {
        return deltaMax[i] + deltaValue[i];
    }

    public void addToSuffix(int i, int delta) {
        if (i < 1 || i > n + 1) {
            throw new IllegalArgumentException();
        }
        if (i == n + 1) {
            return;
        }
        int j = root();
        outer:
        while (true) {
            while (j < i) {
                int k = rightChild(j);
                if (k == j) {
                    break outer;
                }
                j = k;
            }
            deltaValue[j] += delta;
            do {
                int k = leftChild(j);
                if (k == j) {
                    break outer;
                }
                j = k;
            } while (j >= i);
            deltaValue[j] -= delta;
        }
        while (true) {
            j = parent(j);
            if (j >= m) {
                break;
            }
            deltaMax[j] =
                Math.max(0,
                         Math.max(getMax(leftChild(j)),
                                  getMax(rightChild(j))));
        }
    }

    public int maximum() {
        return getMax(root());
    }
}