8.3 LIS LCS LCIS（完结了==！）

感觉这个专题真不好捉，伤心了，慢慢啃吧，孩纸

地址http://acm.hust.edu.cn/vjudge/contest/view.action?cid=28195#overview

密码 acmore

Problem A HDU 1159 Common Subsequence

这算是LCS里面最简单了的吧

解题方法见/article/7126176.html

下面随便贴上两段代码

#include <stdio.h>
#include <string.h>
#define MAX(a,b) (a>b?a:b)

char X[1002],Z[1002];
int Com[1002][1002];

int main()
{
memset(X,0,sizeof(X));
memset(Z,0,sizeof(Z));
while(~scanf("%s%s", X, Z))
{
memset(Com,0,sizeof(Com));
int LenX = strlen(X), LenZ = strlen(Z);
for(int i=0;i<LenX;i++)
{
for(int j=0;j<LenZ;j++)
{
if(X[i] == Z[j])Com[i+1][j+1] = Com[i][j]+1;
else Com[i+1][j+1] = MAX(Com[i][j+1], Com[i+1][j]);
}
}
printf("%d\n",Com[LenX][LenZ]);
}
return 0;
}

下面这个空间复杂度要小一些

#include <stdio.h>
#include <string.h>
#define MAX(a,b) (a>b?a:b)

char X[1002],Z[1002];
int Com[2][1002];

int main()
{
memset(X,0,sizeof(X));
memset(Z,0,sizeof(Z));
while(~scanf("%s%s", X, Z))
{
memset(Com,0,sizeof(Com));
int LenX = strlen(X), LenZ = strlen(Z);
int key = 0;
for(int i=0;i<LenX;i++)
{
key = !key;
for(int j=0;j<LenZ;j++)
{
if(X[i] == Z[j])Com[key][j+1] = Com[!key][j]+1;
else Com[key][j+1] = MAX(Com[!key][j+1], Com[key][j]);
}
}
printf("%d\n",Com[key][LenZ]);
memset(X,0,sizeof(X));
memset(Z,0,sizeof(Z));
}
return 0;
}

View Code

Problem B HDU 1513 Palindrome

这道题最开始就看到好多人MLE，就想肯定是开了5000*5000,那时候自己也还不知道可以压缩空间，况且5000*5000时限上应该也会超时才对，加上自己本来就没有看LCS和LIS的资料，就不打算做了，到后来，在网上看了O(nlogn)的解法，就想试着写写看，虽知道不尽不好写，还RE了好多次，比赛结束后才慢慢明白原来自己在吧问题转化时把数组开小了很多，至于如何转化，题解放在/article/7126176.html

后来改了半天，也想尽力把空间开小一点，最后只能是把转化后的数组开到了100 * 5000，虽然理论上应该要开5000 * 5000的，我想应该是本题数据比较水吧。最后总算是Ac了

2460 KB 109 ms

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define MAXN 5005
int A[100*MAXN];
int x[80][1005];
int num[80],d[MAXN];

int Binary_search(int l,int r,int num)
{
int mid ;
while(r-l>1)
{
mid = l+(r-l)/2;
if(d[mid]<num)l = mid;
else r = mid;
}
return l;
}

int LIS(int N)
{
memset(d,0,sizeof(d));
int len = 0;
d[len] = 0;
for(int i=0;i<N;i++)
{
if(A[i]>d[len])
{
d[++len] = A[i];
}
else
{
int j = Binary_search(0, len, A[i]);
d[j+1] = A[i];
}
}
return len;
}

int cmp(int a,int b)
{
return b<a;
}

int Record(char *str)
{
memset(num,0,sizeof(num));
int len = strlen(str)-1;
int key = len;
while(len>=0)
{
x[(int)str[len] - '0'][num[(int)str[len] - '0']++] = key-len;
len--;
}
for(int i=0;i<80;i++)if(num[i])
{
sort(x[i], x[i] + num[i], cmp);
}
len = strlen(str);
int countt = 0;
for(int i=0;i<len;i++)
{
for(int j=0;j<num[(int)str[i] - '0'];j++)
{
A[countt++] = x[(int)str[i] - '0'][j];
}
}
return countt;
}

int main()
{
int N; char str[MAXN];
while(~scanf("%d%*c", &N))
{
scanf("%s",str);
memset(A,0,sizeof(A));
int len = Record(str);
int ans = LIS(len);
printf("%d\n", N-ans);
}
return 0;
}

然后后来居然后人用n^2 才300+Ms就过了，我不得不说数据的确很水了

276 KB 375 ms

#include <stdio.h>
#include <string.h>
#define MAX(a,b) a>b?a:b

int N,f[2][5005];
char str1[5005],str2[5005];

int LCS()
{
memset(f,0,sizeof(f));
int key = 0;
for(int i=0;i<N;i++)
{
key = !key;
for(int j=0;j<N;j++)
{
if(str1[i] == str2[j])
{
f[key][j+1] = f[!key][j]+1;
}
else f[key][j+1] = MAX(f[!key][j+1], f[key][j]);
}
}
return MAX(f[0]
, f[1]
);
}

int main()
{
while(~scanf("%d", &N))
{
scanf("%s", str1);
for(int i=0;i<N;i++)
{
str2[i] = str1[N-1-i];
}
printf("%d\n", N-LCS());
}
return 0;
}

Problem C HDU 4545 魔法串

这道题我用的方法是，直接将各种变换存放在一个数组里面，并记录每个字母可以变化为其他字母的个数，这样在对a额b比较的时候，如若在a[i]之前的字母在b[j]之前都已经找到了匹配的字母，那么在比较a[i]和b[j]时，就直接现将a[i]和b[j]比较，如果相同的话那么i和j都直接挑到下一个，否者比较a[i]和可以替换b[j]的字母，如果有相同的，说明可以通过替换来让他们匹配起来，再否则，j直接跳到下一个，再和a[i]比较，直到有一个字符串找完。如果a找完了，说明匹配完了。

#include <stdio.h>
#include <string.h>
#define GetNum(b) ((int)b-'a')
#define MAX(a,b) ( (a) > (b) ? (a) : (b) )

char Xi[1001], Ming[1001], Exchange[26][100];//由于只有阿26个字母，所以前面设置大小为26
int num[26], M, Case;

int main()
{
int T=0;
while(~scanf("%d%*c", &Case))while(Case--)
{
memset(num, 0, sizeof(num));
memset(Exchange, 0, sizeof(Exchange));
scanf("%s %s",Xi,Ming);
scanf("%d%*c", &M);
char a,b;
for(int i = 0; i < M; i ++ )//直接将各种变换放在Exchange数组里面
{
scanf("%c %c%*c",&a, &b);
Exchange[ GetNum(a) ][ num[GetNum(a)] ++ ] = b;//num数组记录每个字母可以被替换的种数
}
int indexXi = 0, indexMing = 0, LenXi = strlen(Xi), LenMing = strlen(Ming);
while(indexXi < LenXi && indexMing < LenMing)
{
if(Xi[indexXi] == Ming[indexMing])//先和自身比较
{
indexXi++;
indexMing++;
continue;
}
int flag = 1;
for(int i=0;i<num[GetNum(Ming[indexMing])]; i++)//再和Ming可以被替换的字母比较
{
if(Xi[indexXi] == Exchange[GetNum(Ming[indexMing])][i])
{
flag = 0;
indexMing ++;
indexXi ++;
break;
}
}
if(flag)indexMing ++;//若都找不到，那么Ming直接跳到下一个
}
printf("Case #%d: %s\n", ++T, (LenXi == indexXi) ? "happy" : "unhappy");
}
return 0;
}

Problem D HDU 1257 最少拦截系统

题解见/article/7126179.html

Problem E HDU 1677

Nested Dolls

题目的意思是说一些娃娃有大小不同的很多个，小的可以放进大的里面，前提条件是它的宽W和高H，都比大的要小。

其实最开始看到这个题我也不会，只是在之前受人的指点说这个题和第D题一样。而他的思路就是，先将这些娃娃先按照W（H也可以的）逆序排序，这样一来的话前面对娃娃都是W比后面大的，所以我们就只需要讨论H的比较。所以这时就只需要前面的娃娃的H比后面的要大的话，那后面的娃娃也就可以放进前面的娃娃里面，也就转化为了有一个序列，求最少严格递减子序列有多少个，也就转化为了上题。

有一点需要注意的就是，如果两个娃娃他们的W一样大的话，要按照他们的H从小到大排列。举个例子来说明：序列

W 6 6 6 6 6 5 5 5 5

H 6 5 4 3 2 1 2 4 5

目前是将W由逆序排序，H不排，（其实H按逆序排序分析结果是一样的），那么由于我们此时只考虑H而不考虑W，所以按照求最长升序子序列的方法（这里需要先知道一下求最长升序子序列nlogn的解法），W为6的H为6的那个娃娃会把W为5H为1的包含进去，W为6H为5的娃娃会把W为5H为2的包含进去，而之后W为6的却都不可以把之后w为5的放在它内部了，所以此时结果就是7，而实际上6->5,5->4,4->2,3->1我们就只需要5个娃娃就行了。

而最后将H升序排序的目的就是只将W比当前小的而且保证每个都尽量去包含与他H接近的哪一个娃娃，这样贪心结果就不会有错。

W 6 6 6 6 6 5 5 5 5

H 2 3 4 5 6 1 2 4 5

这里每个W为6的都可以包含以后W为5的娃娃了。所以是最优解。

贴代码

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define MAX(a, b) ( (a) > (b) ? (a) : (b))
#define mem0(a) memset(a, 0, sizeof(a))
using namespace std;

struct node {int w,h;}Doll[20005];
int f[20005];
int N,T;

int cmp(node a,node b)
{
if(a.w != b.w)return a.w > b.w;
return a.h < b.h;
}

int main()
{
while(~scanf("%d", &T))while(T--)
{
scanf("%d", &N);
mem0(Doll);  mem0(f);
for(int i=1;i<=N;i++)
{
scanf("%d%d", &Doll[i].w,&Doll[i].h);
}
sort(Doll+1, Doll+1+N,cmp);
int ans = 0;
for(int i=1;i<=N;i++)
{
int l = 0, r = ans, mid;
while(l<r)
{
mid = (l+r)/2;
if(f[mid] <= Doll[i].h) l = mid + 1;
else r = mid;
}
f[l] = Doll[i].h;
if(l == ans) ans ++;
}
printf("%d\n", ans);
}
return 0;
}

Problem F HDU 1423

Greatest Common Increasing Subsequence

裸的LCIS，百度之或见/article/7126176.html

#include <stdio.h>
#include <string.h>
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
int T, n1, n2, a, f[505], b[505];
int main()
{
while(~scanf("%d", &T))while(T--)
{
memset(f,0,sizeof(f));
scanf("%d", &n2);
for(int i=1;i<=n2;i++) scanf("%d", &b[i]);
scanf("%d", &n1);
for(int i=1;i<=n1;i++)
{
scanf("%d", &a);
int maxx = 0;
for(int j=1;j<=n2;j++)
{
if(a > b[j] && maxx < f[j]) maxx = f[j];
if(a == b[j]) f[j] = maxx + 1;
}
}
int ans = 0;
for(int i=1;i<=n2;i++) ans = MAX(ans, f[i]);
printf("%d\n", ans);
if(T)printf("\n");
}
return 0;
}

Problem G HDU 4512

吉哥系列故事――完美队形I

题目大意就不介绍了。感觉这道题挺不错的。

这道题还是求最长公共上升子序列有多长，只是比上题复杂了一点点。

由于是要求两端相等但也要使得序列升序且最长，那我们就枚举中点mid（1~N），这样的话那我们就只需要比较a[1~mid]和a[N~mid]这两个区间的最升序长公共子序列的长度，再找到他们最长的长度。见代码：

/*
只有注释位置与普通的LCIS略有改动，其他都一样
*/
int Max = 0;
for(int mid = 1; mid <= N;mid ++)//枚举中点
{
mem0(f);
int key=0,ans = 0;
for(int i=1;i<=mid;i++)//左边区间从1~mid
{
int Maxx = 0;
for(int j=N;j>=mid;j--)//右边区间从N~mid
{
if(a[i] > a[j] && Maxx < f[j])Maxx = f[j];
if(a[i] == a[j])
{
f[j] = Maxx+1;
if(ans < f[j]*2)//如果更优，更新
{
ans = f[j]*2;
if(j == mid)ans --;//如果j==mid,也就是说此时,而此时更优，也就是说mid更优，
//说明mid被计算在了最长的序列当中，那它就在*2时被计算了2次,所以-1
}
}
}
}
Max = MAX(Max, ans);//找出最大的解
}
printf("%d\n", Max);

我们再看看上面的代码：

for(int mid = 1;mid <= N; mid ++ )

{

　　for(int i = 1 ; i <= mid ; i ++ ) {

　　}

}

可以注意到在计算mid的时候，i从1~mid循环了一次，而计算mid+1时i从1~mid又计算了一次，而实际上这两次计算的结果f[N~(mid+1)]都是一样的（因为相当于a序列是a[1~mid],b序列是a[N~mid+1],两次计算他们的最长公共升序子序列的长度肯定是一样的），那么为了免去这个重复的计算，在mid取到mid+1的时候，i便直接从mid+1开始，就可以直接使用前面已经计算出来的mid的所有的值，而省去x从1~mid的重复计算。

所以这时我们就只需要两个循环，i表示的便是枚举的中点mid。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define MAX(a, b) ( (a) > (b) ? (a) : (b))
#define mem0(a) memset(a, 0, sizeof(a))
using namespace std;

int a[205], f[205];
int Case, N;

int main()
{
while(~scanf("%d", &Case))while(Case--)
{
mem0(a);  mem0(f);
scanf("%d", &N);
for(int i=1;i<=N;i++)
{
scanf("%d", &a[i]);
}
int ans = 0;
for(int i=1;i<=N;i++)//i表示的是mid的值
{
int Max = 0, key = 0;
for(int j=N;j>=i;j--)//j依然从N取到mid(i)
{
if(a[i] > a[j] && Max < f[j])Max = f[j];
if(a[i] == a[j])
{
f[j] = Max+1;
if(ans < f[j]*2)
{
ans = f[j]*2;
key = j;//记录两个序列最后一次有元素相同的时候的j的值
}
}
}
if(key == i)ans --;//如果“b”序列最后一次和“a”序列相同的时候是出现在“mid”的位置，长度-1
}
printf("%d\n", ans);
}
return 0;
}