一些常见的子列问题【思维】

问题模型: 给定一连串的数(或子串),问一些关于子列(和,差,公共子串,公共子序列等)的一些问题. (数字的个数在1e5之内,每个数的范围-1000~1000)和一些常见的思想与处理.

1 : 给定一串数字，求最大连续子序和.

#include<cstdio>
const int inf=1e9;
int main(){           //在线处理法,即输入一个数就判断一个数.
int t;
scanf("%d",&t);
while(t--){
int n;
scanf("%d",&n);
int ans=0;
int res=-inf;   //找最大,先令res为最小.
for(int i=1;i<=n;i++){
int m;
scanf("%d",&m);
ans += m;
if(ans > res){
res = ans ;      //如果找到更大的值则更新res.
}
if(ans < 0)    //加到这里时,ans已经为负,也不可能使后面的和变大,故重置ans的值.
ans = 0;
}
printf("%d\n",res);
}
}

这类题的变形题 (只需加一点小小的处理即可!)

2 : 给定一串数字，求最大子项和 且要为奇数 （或偶数,单纯的求最大子项和这个是人都会做.）.

思路 ：首先考虑极端情况,全是正数,则就全部加起来,如果和为奇数的输出,否则就输出和减去序列中的最小正奇数. 其次,考虑都是负数的情况,则答案就是最大负奇数. 最后,考虑一般情况,序列中既有正又有负,所以根据前面的讨论,我们需要找到该序列中的最小正奇数和最大负奇数.然后把大于0的都加起来,如果是奇数则输出,否则输出max(sum-最小正奇数,sum+最大负奇数).

int main() {
int n;
int sum=0;
int minn=1e9;
int maxx=-1e9;
scanf("%d",&n);
while(n--){
int t;
scanf("%d",&t);
if(t>0)
sum += t;
if(t>0 && t%2 && minn>t)
minn=t;
if(t<0 && t%2 && maxx<t)
maxx=t;
}
if(sum%2)
printf("%d\n",sum);
else
printf("%d\n",max(sum+maxx,sum-minn));
}

模板题

滚动数组原理 :
这里用了滚动数组的原理,只要当前状态的决定量某些特定值位置有关,比如只与上一个状态量,左边或右边的状
态量,就可以用到滚动数组. 我们使每一次操作仅保留若干有用信息，新的元素不断循环刷新，看上去数组的空
间被滚动地利用，此模型我们称其为滚动数组. 滚动数组的优势是大大节省空间. //并且可以依次类推.

滚动数组讲的非常浅显易懂的一篇博客

3 : LCS模板最长公共子序列

const int maxn=1e6;
char a[maxn],b[maxn];
int dp[2][maxn];   //只用两行是为了节省空间,因为每个判断都只有两种状态!
//这里就用了滚动数组,因为当前状态量只由上一个状态量或左边的状态量有关.
//所以就可以用到二维滚动数组.
int LCS(){
scanf("%s",a+1);
scanf("%s",b+1);
int len1=strlen(a+1);
int len2=strlen(b+1);
for(int i=1;i<=len1;i++){
for(int j=1;j<=len2;j++){
if(a[i] == b[j]) dp[i%2][j] = dp[(i-1)%2][j-1] + 1;
else dp[i%2][j] = max(dp[i%2][j-1],dp[(i-1)%2][j]);
}
}
return dp[len1%2][len2];
}

模板题

POJ — 1159 点这里 这也是一道求LCS的题,但是你不一定看的出来用LCS来做,因为这里只有一个串,所以我们需要转换下视角,那就是把一个串倒着看,不就有两个串了吗? 这样这两个串的LCS不就是最长的回文串吗?所以学聪明点啊!

4.1 : LIS 最长上升子序列(O(n^2)算法)

基本思想: dp[i] 表示第i个元素作为最长上身子序列的最后一个元素的最长长度是多少.

所以我们需要枚举以它结尾的区间.

const int maxn=1005;
int a[maxn];
int maxlen[maxn];    //maxlen[k]表示存放以ak作为"终点"的最长上升子序列的长度.
int main()
{
int n;
cin >> n;
for(int i=1;i<=n;i++){
cin >> a[i];
maxlen[i]=1;
}
for(int i=2;i<=n;i++){   //每次求以第i个数为终点的最长上升子序列的长度.
for(int j=1;j < i;j++){  //查看以第j个数为起点的最长上升子序列的长度.
if(a[i] > a[j])   //把每一个都找一遍,则最后一定可以找到更长的.接下来更新就是了.
maxlen[i] = max(maxlen[i],maxlen[j]+1);
//然后更新时,因为是从第一个开始找过来的.
}       //所以maxnlen[i] 可能大于 maxlen[j]+1 所以取两者中较大的那个.
}
sort(maxlen,maxlen+n+1);  //然后排个序,输出最大的那个值即可.
printf("%d\n",maxlen
);
}

但是O(n^2)始终太慢, 还是需要更快的. 那就是O(nlogn), g[i]表示d值为i的最小状态编号.(不存在就为inf)

例题POJ—3903

const int maxn=1e5+5;
int n;
int a[maxn], g[maxn];
//num为所给数字串. g[i]表示d值为i的最小状态编号.(不存在就为inf)
// 这个是求严格上升的, 如果是求不降子序列的话改成upper_bound即可
void LIS() {
Fill(g, inf);
int ans = 0;
for(int i=1;i<=n;i++){
int pos = lower_bound(g+1, g+1+n, a[i]) - g;
g[pos] = a[i];
ans = max(ans, pos);
}
printf("%d", ans);
}

原理讲解:

定义d[k]:长度为k的上升子序列的最末元素，若有多个长度为k的上升子序列，则记录最小的那个最末元素。
注意d中元素是单调递增的，下面要用到这个性质。
首先len = 1,d[1] = a[1],然后对a[i]:若a[i]>d[len]，那么len++，d[len] = a[i];
否则，我们要从d[1]到d[len-1]中找到一个j，满足d[j-1]<a[i]<d[j],则根据D的定义，
我们需要更新长度为j的上升子序列的最末元素（使之为最小的）即 d[j] = a[i];
最终答案就是len
利用d的单调性，在查找j的时候可以二分查找，从而时间复杂度为nlogn.
因为使当前LIS的最末元素最小才有可能是这个最长变得更长....(如 1 3 5 4 5)..

4.2 : 最长下降子序列

O(n^2)和最长上身子序列是相同的, 也是dp做法, dp[i] 代表a[i]作为最长下降子序列的最后一个的最优值, 同样是枚举以i结尾的区间. 代码就不给出了, 把上面的改成 < 即可.

主要说说O(nlogn)的做法, 因为我们要找的是第一个小于等于的, 此时就没有库函数可以用, 所以需要自己手写二分来找. 原理一样, 因为是找小于的, 所以g数组初始化为-inf.

模板: (这个也是求严格小于的, 如果是最长不上升子序列，那么同样的二分出改成 < 不取等)

const int maxn = 1e5+5;
int g[maxn], a[maxn];
int cas = 1, n;
int Bsearch(int x) {
int l = 1, r = n, mid, ans;
while(l <= r) {
mid = (l + r) >> 1;
if (g[mid] <= x) { // 严格小于
r = mid - 1;
ans = mid;
}
else l = mid + 1;
}
return ans;
}
int cal() {
Fill(g, -inf);
int ans = 0;
for (int i = 1 ; i <= n ; i ++) {
int pos = Bsearch(a[i]);
g[pos] = a[i];
ans = max(ans, pos);
}
return ans;
}
void solve()
{
while(~scanf("%d", &a[1]) && a[1] != -1) {
n = 1;
for (int i = 2 ; ; i ++) {
scanf("%d", &a[i]);
if (a[i] == -1) break;
++ n;
}
printf("Test #%d:\n", cas++);
printf("  maximum possible interceptions: %d\n\n", cal());
}
}

板子对应题目POS -1887

HDU — 1025 点这里 这个也是一道变形LIS题,且数据范围比较大,要用NlogN的算法来做,否则会T,关键是你能否转换成来求LIS！只要这点想到了,这道题就是一个水题!!!

想提醒的是不要认为一定是给了什么字符串才想到用这些算法去做,而是也有许多变形题,思维要开阔,不要形成定式思维.!!!

5 : LCIS 最长公共上升子序列

int dp[maxn];
int LCIS(int n, int m)
{
memset(dp, 0, sizeof(dp));
for(int i=1;i<=n;i++){
int tmp=0;
for(int j=1;j<=m;j++){
if(a[i]>b[j] && dp[j]>tmp)  //以两个串中短的那个作为基准.
tmp = dp[j];   //当前上升的最大长度.
else if(a[i]==b[j])
dp[j]=tmp+1;   //为了如果当前相等的话就可以使最长的长度加一加.
}
}
int ans = 0;
for(int i = 1; i <= m; i++)
ans = max(ans, dp[i]);
return ans;
}

6 ： 最长公共子串

int dp[maxn][maxn];
int LCSTR(int n, int m)
{
int res=-1;
memset(dp, 0, sizeof(dp));
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(a[i] == b[j]){
dp[i][j] = dp[i-1][j-1] + 1 ;
//由状态转移方程可知,可以用滚动数组来做.(即第一维只用开 2 )
res = max(res,dp[i][j]);
}
else
dp[i][j] = 0;   //因为是子串,所以在不等时直接清零,而不再是子序列中的去最优.
}
}
return res;
}

7 ： 最大子矩阵和

思想 : 动态规划

状态dp[i][j]代表长i宽j的矩阵的元素和。

（dp[i][j]+=dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]）

假设要求找出x长y宽的最大子矩阵

在i>=x且j>=y的矩阵中找的话，

dp[i][j]就是包含a[i][j]元素的子矩阵的元素和，

则dp[i][j]-dp[i][j-y]-dp[i-x][j]+dp[i-x][j-y]就是

dp[i][j]中x长y宽的子矩阵的元素和（右下角元素为a[i][j]）

然后暴力循环比较一遍即可.复杂度 O(n^2).

int dp[maxn][maxn];
memset(dp,0,sizeof(dp));
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
scanf("%d",&dp[i][j]);
dp[i][j]+=dp[i-1][j]+dp[i][j-1]-dp[i-1][j- 1];  //减去多加了的那部分.
if(i>=x&&j>=y)
maxx = max(maxx,dp[i][j]-dp[i][j-y]-dp[i-x][j]+dp[i-x][j-y]);
//每次都判的右下角那个矩阵.画个图就懂了.
}
}

模板题

8 : 最小正序列和(O(n^2)) 直接暴力 (不过网上也有NlogN的算法,相对于比较麻烦)

for (int i = 0; i != N; ++i) {
ThisSum = 0;
for (int j = i; j != N; ++j) {
ThisSum += A[j];
if (MinSum > ThisSum && ThisSum > 0)
MinSum = ThisSum;
}
}

9 : 最大子序列乘积

思想 :

遍历数组中每一个数 :

I : a
> 0 (或者有精度问题)

pos
= max{pos[n-1] * a
, a
}

max_value = max{max_value, pos
}

若n-1位置存在最小负数, 更新 nag
= nag[n-1] * a

II : a
< 0

pos
= max{nag[n-1] * a
, 0.0}

max_value = max{max_value, pos
}

更新 nag
= min{pos[n-1] * a
, a
}

III : a
==0:

清空 nag
与 pos

const double eps=1e-6;
int MAX(int *a,int n)   //如果有精度问题,则把有关的int改为double就行.
{
int maxx=0,pos=0,old=0,nag=1;
for(int i=0;i<n;i++){
if(a[i]>0){
pos = max(old * a[i] , a[i]);
maxx = max(maxx,pos);
if(nag<0)//如果nag还是大于0,则保持这样才可能是最后答案变大.
//否则乘a[i]后是nag更小,这样它乘负数时才可能使答案变更大.
//其实这一步就是整个程序中最为关键的一步!!!
nag*=a[i];
}
else if(a[i]<0){
pos = max(0,nag*a[i]);
maxx = max(maxx,pos);
nag = (old * a[i] > a[i]) ? a[i] : old * a[i] ;  //nag保存着最小的那个数.
}
old = maxx ;
//保证两个数之间最大值可以连续,所以需要把上一个的最大值保存下来,才能有最大的答案.
}
return maxx;
}