- 题意:要求一给定序列的子序列,使其中的士兵至少能向左或向右看到最边上的士兵。
- 首先假设士兵高度分别为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
- 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表
(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;
}