POJ 1836 Alignment (线性dp LIS的两种姿势)

 

                                   Alignment

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 13818		Accepted: 4470

 

Description

In the army, a platoon is composed by n soldiers. During the morning inspection, the soldiers are aligned in a straight line in front of the captain. The captain is not satisfied with the way his soldiers are aligned; it is true that the soldiers are aligned in order by their code number: 1 , 2 , 3 , . . . , n , but they are not aligned by their height. The captain asks some soldiers to get out of the line, as the soldiers that remain in the line, without changing their places, but getting closer, to form a new line, where each soldier can see by looking lengthwise the line at least one of the line's extremity (left or right). A soldier see an extremity if there isn't any soldiers with a higher or equal height than his height between him and that extremity.

Write a program that, knowing the height of each soldier, determines the minimum number of soldiers which have to get out of line.

Input

On the first line of the input is written the number of the soldiers n. On the second line is written a series of n floating numbers with at most 5 digits precision and separated by a space character. The k-th number from this line represents the height of the soldier who has the code k (1 <= k <= n).

There are some restrictions:
• 2 <= n <= 1000
• the height are floating numbers from the interval [0.5, 2.5]

Output

The only line of output will contain the number of the soldiers who have to get out of the line.

Sample Input

8
1.86 1.86 1.30621 2 1.4 1 1.97 2.2

Sample Output

4

Source

Romania OI 2002

题目链接：http://poj.org/problem?id=1836

题目大意：求删除最少的数，使得从序列中任取一个数h[i]，有h[1] ~ h[i]严格单增，或h[i] ~ h[n]严格单减

题目分析：分别从左向右，从右向左求LIS，然后枚举最长合法序列in，则n－in就是最少需要删除的数
简单介绍一下LIS，LIS有两种姿势，一种是O(n^2)的一种是O(nlogn)的

O(n^2)
dp[i]表示从1到i的最长上升子序列的长度，dp[i]初始化为1，第一层循环枚举i，第二层循环j从1到i-1，如果h[j] < h[i]表示出现了一个上升关系，则此时若h[j] + 1 >
h[i]则更新h[i]的值，最长下降也一样

#include <cstdio>
#include <algorithm>
using namespace std;
int const MAX = 1e3 + 5;
int const INF = 0x3fffffff;
int l[MAX], r[MAX];
double h[MAX];

int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
        scanf("%lf", &h[i]);
    for(int i = 1; i <= n; i++)
        l[i] = r[i] = 1;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j < i; j++)
            if(h[i] > h[j])
                l[i] = max(l[i], l[j] + 1);
    for(int i = n; i >= 1; i--)
        for(int j = n; j > i; j--)
            if(h[i] > h[j])
                r[i] = max(r[i], r[j] + 1);
    int in = 0;
    for(int i = 1; i < n; i++)
        for(int j = i + 1; j <= n; j++)
            in = max(in, (l[i] + r[j]));
    printf("%d\n", n - in);
}

O(nlogn)
该方法是维护一个单调栈，栈顶为目前最大的元素，如果当前数字比栈顶元素大，则将其入栈，否则二分查找这个单调栈中第一个比当前数字大的数字，并更新它，每次插入或修改完毕，栈的大小就是当前序列的LIS值，由于本题n很小，只有1e3，所以并看不出n^2和nlogn的时间差别

#include <cstdio>
#include <algorithm>
using namespace std;
int const MAX = 1e3 + 5;
int const INF = 0x3fffffff;
int l[MAX], r[MAX];
double lstk[MAX], rstk[MAX];
double h[MAX];

int main()
{
    int n, ltop = 0, rtop = 0;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        scanf("%lf", &h[i]);
        if(h[i] > lstk[ltop])
            lstk[++ ltop] = h[i];
        else
        {
            int low = 1, high = ltop, mid;
            while(low <= high)
            {
                mid = (low + high) >> 1;
                if(h[i] > lstk[mid])
                    low = mid + 1;
                else
                    high = mid - 1;
            }
            lstk[low] = h[i];
    
        }
       l[i] = ltop;
    }
    for(int i = n; i >= 1; i--)
    {
        if(h[i] > rstk[rtop])
            rstk[++ rtop] = h[i];
        else
        {
            int low = 1, high = rtop, mid;
            while(low <= high)
            {
                mid = (low + high) >> 1;
                if(h[i] > rstk[mid])
                    low = mid + 1;
                else
                    high = mid - 1;
            }
            rstk[low] = h[i];
        }
        r[i] = rtop;   
    }
    int in = 0;
    for(int i = 1; i < n; i++)
        for(int j = i + 1; j <= n; j++)
            in = max(in, (l[i] + r[j]));
    printf("%d\n", n - in);
}

#include <cstdio>
#include <algorithm>
using namespace std;
int const MAX = 1e3 + 5;
double a[MAX], lstk[MAX], rstk[MAX];
int l[MAX], r[MAX], n;

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%lf", &a[i]);
    }
    int top = 0;
    for (int i = 0; i < n; i++) {
        if (top == 0 || lstk[top] < a[i]) {
            lstk[++top] = a[i];
        } else {
            int pos = lower_bound(lstk, lstk + top, a[i]) - lstk;
            lstk[pos] = a[i];
        }
        l[i] = top;
    }
    top = 0;
    for (int i = n - 1; i >= 0; i--) {
        if (top == 0 || rstk[top] < a[i]) {
            rstk[++top] = a[i];
        } else {
            int pos = lower_bound(rstk, rstk + top, a[i]) - rstk;
            rstk[pos] = a[i];
        }
        r[i] = top;
    }
    int ma = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            ma = max(ma, l[i] + r[j]);
        }
    }
    printf("%d\n", n - ma);
}