POJ 1836--Alignment(LIS,LCS)

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

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

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

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

知道LCS算法求递增子序列是显然的，因为最长递增子序列必定是原序列与对原序列（剔除出重复元素）作升序后的LCS。
然后对于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

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

初始化，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
);
L[1]
= 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;
}