POJ 1836--Alignment(LIS,LCS)

• 题意：要求一给定序列的子序列，使其中的士兵至少能向左或向右看到最边上的士兵。
• 首先假设士兵高度分别为S1：3 4 5 1 2 5 4 3(discuss的神举例)，我们先不管高度1,2,3,4,5的相对位置，看看有哪几种满足要求的排列：

1. 单调递增子序列：1 2 3 4 5
2. 单调递减子序列：5 4 3 2 1
3. 双峰值子序列：3 4 5 5 4 3

其实第三种序列就是我们要求出的子序列，显然我们可以通过正序求一遍LIS，再逆序求一遍LIS，再对数据进行组合求得最少出队人数。

• LCS算法：O(n^2) 47ms   参考算法导论

1. 知道LCS算法求递增子序列是显然的，因为最长递增子序列必定是原序列与对原序列（剔除出重复元素）作升序后的LCS。
2. 然后对于LCS算法其实我们都不需要求两遍，可以直接把升序后的序列再逆序接到升序序列后面。如上例，即生成一序列S2：1 2 3 4 5 5 4 3 2 1。

(1) 首先不管高度元素的相对位置，士兵高度的任何一个符合题意的排列都在S2的子序列中。

(2) 然后可知S2的任何一个子序列也都是符合题意的排列，又考虑到S1中所确定的高度的相对位置，求S1和S2的LCS即为题目要求的子序列。

• 因为S1当中的信息，生成的S2是有很多冗余的。

• LIS算法：O(n*logn) 0ms

1. 首先从基本的转移方程出发，设L[i]为以a[i]结尾的LIS的长度，则有转移方程：L[i] = max{L[k]+1,0 <k < i且a[k] < a[i]} 
2. 根据上述方程，我们可以枚举小于i的k的元素，但是不能改善复杂度，换种思路我们枚举L[k]怎么样，假设前i-1个元素能形成的LIS的长度为maxL(maxL < i)，显然有maxL种L[k]，此时我们就要考虑如何更好地选取a[k]来减少复杂度。
3. 算法导论上的提示：一个长度为L1的候选子序列的尾元素肯定不小于一个长度为L1-1的候选子序列的尾元素。这是显然的，若长度为L1的候选子序列的尾元素小于长度为L1-1的候选子序列的尾元素，则长度为L1的子序列是一个更优的选择，我们也就只需要用a[i]去比较前者的尾元素。其实上面的结论还可以更强，即肯定大于的。
4. 打表d[j]：长度为j的子序列的最小尾元素。
5. 则根据3中的结论，有：d[1] < d[2] < .... < d[maxL]。
6. 具体算法：

• 初始化，d[1] = a[1],L[1] = 1。归纳法：假设前i-1次对d表和L表成功维持其性质。
• 输入a[i]时，我们首先更新d表

(1) 若d[j] == a[i]，则d表不用变，L[i] = j。

(2) 若d[j] < a[i] < d[j+1]，因为长度为j+1的子串最小尾元素d[j+1] > a[i],所以a[i]不可能为长度为j+2的子串的尾元素，同理也不可能是大于j+2的长度的子串的尾元素。所以大于j+2的d表不需要更新，并且得到一个信息L[i] <= j+1。显然，L[i] = j+1时存在的，我们把a[i]接在以d[j]为尾元素的长度为j的子串后面即可得到，所以L[i] = j+1，d[j+1] = a[i]。并且a[i] > d[j]，所以长度为j的子串最小元素还是d[j]，同理小于j的d表也不需要更新。

(3) 以上都未提到怎么找到a[i]在d表中的相互关系，因为d表升序，可以用二分查找提高效率，这也是logn的由来。

• 本题还有一个地方容易出错，若只有一个主峰，即”中点“只有一个极大值，则我们用正序逆序的两个L表即可求得解，但如果有两个主峰的情况，即最开始的例子，则我们又需要一个frontAdj[k]来表示等于a[k]在a[k]前面离其最近的士兵的下标，因为高度值范围较大，可以用hash表散列处理。

LIS&Hash：

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define maxN 1002
#define _max(x,y) ((x)>(y)?(x):(y))
#define maxP 3469

struct node
{
    int height;
    short adjPos;
    node* next;
}* hashTab[maxP];

short findLen(int* val,int height,int left,int right)
{
    int mid;
    while(left <= right)
    {
        mid = (left+right)/2;
        if(height == val[mid])
            return mid;
        else if(height > val[mid])
            left = mid+1;
        else
            right = mid-1;
    }
    return left;
}

int InitMinHeight(int* x,int N,int headVal)
{
    for(int i = 2;i < N;i++)
        x[i] = 100;
    x[1] = headVal;
    return 0;
}

short hashInsert(int height,int pos)
{
    int adjPos;
    int slot = height&maxP;
    node* tmpNode;
    for(tmpNode = hashTab[slot];tmpNode != NULL;tmpNode = tmpNode->next)
    {
        if(tmpNode->height == height)
        {
            adjPos = tmpNode->adjPos;
            tmpNode->adjPos = pos;
            return adjPos;
        }
    }
    tmpNode = new node;
    tmpNode->height = height;
    tmpNode->adjPos = pos;
    tmpNode->next = hashTab[slot];
    hashTab[slot] = tmpNode;
    return 0;
}

int str2int(char* height,int len)
{
    int x = 0;
    int k = 0;
    int base[6] = {100000,10000,1000,100,10,1};
    for(int i = 0;i < len;i++)
    {
        if(height[i] != '.')
            x += (height[i]-'0')*base[k++];
    }
    return x;
}

int main()
{
    int i,j,N;
    short maxLis;
    short tmpL,maxL;
    char tmpHeight[9];
    int height[maxN];
    short frontAdj[maxN];
    int minHeight[maxN];     //minHeight[i]表示长度为i的子序列最小尾元素
    short L[2][maxN];
    while(~scanf("%d",&N))
    {
        memset(hashTab,0,sizeof(hashTab));
        maxLis = 0;
        getchar();
        for(i = 1;i <= N;i++)
        {
            j = 0;
            while((tmpHeight[j++] = getchar()) != ' '&&tmpHeight[j-1] != '\n');
            height[i] = str2int(tmpHeight,j-1);
            frontAdj[i] = hashInsert(height[i],i);
        }
        /***Forward LIS***/
        InitMinHeight(minHeight,maxN,height[1]);
        L[0][1] = 1;
        maxL = 1;
        for(i = 2;i <= N;i++)
        {
            tmpL = findLen(minHeight,height[i],1,maxL);
            minHeight[tmpL] = height[i];
            L[0][i] = tmpL;
            maxL = _max(maxL,tmpL);
        }
        /***Backfward LIS***/
        InitMinHeight(minHeight,maxN,height[N]);
        L[1][N] = 1;
        maxL = 1;
        for(i = N-1;i >= 1;i--)
        {
            tmpL = findLen(minHeight,height[i],1,maxL);
            minHeight[tmpL] = height[i];
            L[1][i] = tmpL;
            maxL = _max(maxL,tmpL);
        }
        /***find the longest s***/
        for(i = 1;i <= N;i++)
        {
            if(L[0][i]+L[1][i]-1 > maxLis)        //只有一个峰值
                maxLis = L[0][i]+L[1][i]-1;
            if(frontAdj[i]&&L[1][i]+L[0][frontAdj[i]] > maxLis)   //有两个相邻的峰值
                maxLis = L[1][i]+L[0][frontAdj[i]];
        }
        printf("%d\n",N-maxLis);
    }
    return 0;
}