[微软][笔试] 找出最大序列对

对于一个数组，找出这样一个序列对(i, j)，满足A[i] < A[j]，且使 j - i的值最大，输出j - i的值。

这道题最初想到的是O(n^2)的解答，后来想到了用MergeSort时来记录最大序列对的方法，也可以用一个队列来做。总之解法还挺多。

最后和http://ac.jobdu.com/problem.php?cid=1039&pid=19何海涛的这题非常相似。

方法1：MergeSort，数组的元素需要记录原始的元素索引。

#include <iostream>
using namespace std;

struct Node
{
    int val;
    int index;
};
Node b[1000];

int mergeSort(Node a[], int left, int right)
{
    if (left > right)
        return -1;

    if (left == right)
        return 0;

    int mid = left + (right - left) / 2;

    int leftRes = mergeSort(a, left, mid);
    int rightRes = mergeSort(a, mid + 1, right);

    int res = max(leftRes, rightRes);

    int i = left;
    int j = mid + 1;
    int minIndex = INT_MAX;
    int index = i;

    while(i <= mid && j <= right)
    {
        if (a[i].val <= a[j].val)
            b[index] = a[i++];
        else
            b[index] = a[j++];

        if (minIndex != INT_MAX)
            res = max(b[index].index - minIndex, res);

        minIndex = min(b[index].index, minIndex);

        index++;
    }

    while(i <= mid)
    {
        b[index] = a[i++];

        if (minIndex != INT_MAX)
            res = max(b[index].index - minIndex, res);

        minIndex = min(b[index].index, minIndex);

        index++;
    }

    while(j <= right)
    {
        b[index] = a[j++];

        if (minIndex != INT_MAX)
            res = max(b[index].index - minIndex, res);

        minIndex = min(b[index].index, minIndex);

        index++;
    }

    return res;
}

int main()
{
    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    int aSize = sizeof(a) / sizeof(int);

    Node *c = new Node[aSize];

    for(int i = 0; i < aSize; i++)
    {
        c[i].val = a[i];
        c[i].index = i;
    }

    cout << mergeSort(c, 0, aSize - 1) << endl;
}

方法2：用一个队列保存递减序列，从数组的第一个数开始，不断放入，当当前数小于队列的尾元素则放入。这样就构成了一个递减序列。当有新元素时查找队列中第一个小于新元素的数，然后就能得出一个j-i的值，如此就能得出解。由于队列有序，所以用二分查找的变形O(logn)。最后总的复杂度O(nlogn)

#include <iostream>
#include <vector>
using namespace std;

struct Node
{
    int index;
    int val;
    Node(){}
    Node(int idx, int v):index(idx), val(v){}
};

int findIndex(vector<Node> &a, int left, int right, int key)
{
    if (left > right)
        return -1;

    int mid = left + (right - left) / 2;

    if (a[mid].val < key)
    {
        int index = findIndex(a, left, mid - 1, key);
        return (index == -1 ? a[mid].index : index);
    }
    else
    {
        return findIndex(a, mid + 1, right, key);
    }
}

int solve(int a[], int aSize)
{
    if (aSize == 0)
        return 0;

    vector<Node> q;

    int res = 0;
    for(int i = 0; i < aSize; i++)
    {
        if (q.size() == 0)
            q.push_back(Node(i, a[i]));
        else if (q[q.size() - 1].val > a[i])
            q.push_back(Node(i, a[i]));

        int index = findIndex(q, 0, q.size() - 1, a[i]);

        if (index != -1)
            res = max(res, i - index);
    }

    return res;
}

int main()
{
    int a[] = {9, 8, 7, 6, 5, 4, 3, 2, 9};
    int aSize = sizeof(a) / sizeof(int);
    cout << solve(a, aSize) << endl;

    int b[] = {1, 2, 3};
    int bSize = sizeof(b) / sizeof(int);
    cout << solve(b, bSize) << endl;

    int c[] = {3, 2, 1};
    int cSize = sizeof(c) / sizeof(int);
    cout << solve(c, cSize) << endl;
}