2. 程式人生 > >LIS（最長上升子序列）問題的三種求解方法以及一些例題

LIS（最長上升子序列）問題的三種求解方法以及一些例題

阿新 • • 發佈：2019-01-07

摘要

本篇部落格介紹了求LIS的三種方法，分別是O(n^2)的DP，O(nlogn)的二分+貪心法，以及O(nlogn)的樹狀陣列優化的DP，後面給出了5道LIS的例題。

LIS的定義

一個數的序列bi，當b1 < b2 < … < bS的時候，我們稱這個序列是上升的。對於給定的一個序列(a1, a2, …, aN)，我們可以得到一些上升的子序列(ai1, ai2, …, aiK)，這裡1 <= i1 < i2 < … < iK <= N。比如，對於序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。這些子序列中最長的長度是4，比如子序列(1, 3, 5, 8).

LIS長度的求解方法

解法1：動態規劃

這裡寫圖片描述
這裡寫圖片描述
這裡寫圖片描述

狀態設計：F[i]代表以A[i]結尾的LIS的長度

狀態轉移：F[i]=max{F[j]+1}(1<=j< i,A[j]< A[i])

邊界處理：F[i]=1(1<=i<=n)

時間複雜度：O(n^2)

程式碼：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <cmath>
 

using namespace std;
const int maxn = 103,INF=0x7f7f7f7f;
int a[maxn],f[maxn];
int n,ans=-INF;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) 
    {
        scanf("%d",&a[i]);
        f[i]=1;
    }
    for(int i=1;i<=n;i++)
        for(int j=1;j<i;j++)
            if(a[j]<a[i]) f[i]=max(f[i],f[j]+1
 
);
    for(int i=1;i<=n;i++) 
        ans=max(ans,f[i]);
    printf("%d\n",ans);
    return 0;
}

解法2：貪心+二分

思路：

新建一個low陣列，low[i]表示長度為i的LIS結尾元素的最小值。對於一個上升子序列，顯然其結尾元素越小，越有利於在後面接其他的元素，也就越可能變得更長。因此，我們只需要維護low陣列，對於每一個a[i]，如果a[i] > low[當前最長的LIS長度]，就把a[i]接到當前最長的LIS後面，即low[++當前最長的LIS長度]=a[i]。
那麼，怎麼維護low陣列呢？
對於每一個a[i]，如果a[i]能接到LIS後面，就接上去；否則，就用a[i]取更新low陣列。具體方法是，在low陣列中找到第一個大於等於a[i]的元素low[j]，用a[i]去更新low[j]。如果從頭到尾掃一遍low陣列的話，時間複雜度仍是O(n^2)。我們注意到low陣列內部一定是單調不降的，所有我們可以二分low陣列，找出第一個大於等於a[i]的元素。二分一次low陣列的時間複雜度的O(lgn)，所以總的時間複雜度是O(nlogn)。

程式碼

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn =300003,INF=0x7f7f7f7f;
int low[maxn],a[maxn];
int n,ans;
int binary_search(int *a,int r,int x)
//二分查詢，返回a陣列中第一個>=x的位置 
{
    int l=1,mid;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(a[mid]<=x)
            l=mid+1;
        else 
            r=mid-1;
    }
    return l;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) 
    {
        scanf("%d",&a[i]); 
        low[i]=INF;//由於low中存的是最小值，所以low初始化為INF 
    }
    low[1]=a[1]; 
    ans=1;//初始時LIS長度為1 
    for(int i=2;i<=n;i++)
    {
        if(a[i]>=low[ans])//若a[i]>=low[ans]，直接把a[i]接到後面 
            low[++ans]=a[i];
        else //否則，找到low中第一個>=a[i]的位置low[j]，用a[i]更新low[j] 
            low[binary_search(low,ans,a[i])]=a[i];
    }
    printf("%d\n",ans);//輸出答案 
    return 0;
}

解法3：樹狀陣列維護

我們再來回顧O(n^2)DP的狀態轉移方程：F[i]=max{F[j]+1}(1<=j< i,A[j]< A[i])
我們在遞推F陣列的時候，每次都要把F陣列掃一遍求F[j]的最大值，時間開銷比較大。我們可以藉助資料結構來優化這個過程。用樹狀陣列來維護F陣列（據說分塊也是可以的，但是分塊是O(n*sqrt(n)）的時間複雜度，不如樹狀陣列跑得快），首先把A陣列從小到大排序，同時把A[i]在排序之前的序號記錄下來。然後從小到大列舉A[i]，每次用編號小於等於A[i]編號的元素的LIS長度+1來更新答案，同時把編號小於等於A[i]編號元素的LIS長度+1。因為A陣列已經是有序的，所以可以直接更新。有點繞，具體看程式碼。

程式碼：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn =103,INF=0x7f7f7f7f;
struct Node{
    int val,num;
}z[maxn]; 
int T[maxn];
int n;
bool cmp(Node a,Node b)
{
    return a.val==b.val?a.num<b.num:a.val<b.val;
}
void modify(int x,int y)//把val[x]替換為val[x]和y中較大的數 
{
    for(;x<=n;x+=x&(-x)) T[x]=max(T[x],y);
}
int query(int x)//返回val[1]~val[x]中的最大值 
{
    int res=-INF;
    for(;x;x-=x&(-x)) res=max(res,T[x]);
    return res;
}
int main()
{
    int ans=0;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&z[i].val);
        z[i].num=i;//記住val[i]的編號，有點類似於離散化的處理，但沒有去重 
    }
    sort(z+1,z+n+1,cmp);//以權值為第一關鍵字從小到大排序 
    for(int i=1;i<=n;i++)//按權值從小到大列舉 
    {
        int maxx=query(z[i].num);//查詢編號小於等於num[i]的LIS最大長度
        modify(z[i].num,++maxx);//把長度+1，再去更新前面的LIS長度
        ans=max(ans,maxx);//更新答案
    }
    printf("%d\n",ans);
    return 0;
}

例題

Tips：例題1、4可以用來測試n^2的演算法，例題2、3、5可以用來測試nlogn的演算法

1.洛谷【p1020】導彈攔截

題目描述

某國為了防禦敵國的導彈襲擊，發展出一種導彈攔截系統。但是這種導彈攔截系統有一個缺陷：雖然它的第一發炮彈能夠到達任意的高度，但是以後每一發炮彈都不能高於前一發的高度。某天，雷達捕捉到敵國的導彈來襲。由於該系統還在試用階段，所以只有一套系統，因此有可能不能攔截所有的導彈。

輸入導彈依次飛來的高度（雷達給出的高度資料是不大於30000的正整數），計算這套系統最多能攔截多少導彈，如果要攔截所有導彈最少要配備多少套這種導彈攔截系統。

輸入輸出格式

輸入格式：
一行，若干個正整數最多100個。

輸出格式：
2行，每行一個整數，第一個數字表示這套系統最多能攔截多少導彈，第二個數字表示如果要攔截所有導彈最少要配備多少套這種導彈攔截系統。

輸入輸出樣例

輸入樣例#1：
389 207 155 300 299 170 158 65
輸出樣例#1：
6
2

題解

程式碼：

#include <iostream>//O(n^2)
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn = 103,INF=0x7f7f7f7f;
int a[maxn],f[maxn];
int n,ans,i,j;
int main()
{
    for(n=0;~scanf("%d",&a[n+1]);n++) f[n+1]=1;
    for(i=1;i<=n;i++)
        for(int j=1;j<i;j++)
            if(a[j]>a[i]) f[i]=max(f[i],f[j]+1);
    for(i=1,ans=-INF;i<=n;i++) ans=max(ans,f[i]);
    printf("%d\n",ans);
    for(i=1;i<=n;i++) f[i]=1;
    for(i=1;i<=n;i++)
        for(j=1;j<i;j++)
            if(a[j]<a[i]) f[i]=max(f[i],f[j]+1);
    for(i=1,ans=-INF;i<=n;i++) ans=max(ans,f[i]);
    printf("%d\n",ans);
    return 0;
}

2.洛谷【p2757】導彈的召喚（資料加強版）

題目描述

同導彈攔截

資料範圍

n<=300000

題解

使用O(nlogn)的演算法求解

程式碼：

#include <iostream>//O(nlogn)
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn =300003,INF=0x7f7f7f7f;
int f1[maxn],low1[maxn],f2[maxn],low2[maxn],a[maxn];
int n,ans;
int bs1(int *a,int r,int x)//返回a陣列中第一個小於等於x的位置
{
    int l=1,mid;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(a[mid]>=x)
            l=mid+1;
        else
            r=mid-1;
    }
    return l;
}
int bs2(int *a,int r,int x)//返回a陣列中第一個大於x的位置
{
    int l=1,mid;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(a[mid]<x)
            l=mid+1;
        else 
            r=mid-1;
    }
    return l;
}
int main()
{
    for(n=0;~scanf("%d",&a[n+1]);n++) 
    {
        f2[n+1]=f1[n+1]=1;
        low1[n+1]=-INF;
        low2[n+1]=INF;
    }
    low1[1]=a[1];//low[i]表示長度為i的最長下降子序列末尾的最大值 
    ans=1;
    for(int i=2;i<=n;i++)
    {
        if(a[i]<=low1[ans]) low1[++ans]=a[i];//如果a[i]比當前最長下降子序列的末尾小，直接接到後面 
        else low1[bs1(low1,ans,a[i])]=a[i];//否則，在low1陣列中找到第一個小於等於a[i]的位置，用a[i]替換 
    }
    printf("%d\n",ans);
    low2[1]=a[1];
    ans=1;
    for(int i=2;i<=n;i++)
    {
        if(a[i]>low2[ans]) low2[++ans]=a[i];
        else low2[bs2(low2,ans,a[i])]=a[i];
    }
    printf("%d\n",ans);
    return 0;
}

3.POJ1631 Bridging signals

題目大意

有p條線路，它們有可能相交。現在讓你去掉一些線路，使得剩下的線不相交且線最多（p<40000）。
這裡寫圖片描述
輸入格式：On the first line of the input, there is a single positive integer n, telling the number of test scenarios to follow. Each test scenario begins with a line containing a single positive integer p < 40000, the number of ports on the two functional blocks. Then follow p lines, describing the signal mapping:On the i:th line is the port number of the block on the right side which should be connected to the i:th port of the block on the left side.
輸入n個序列，每個序列有p項，每個序列的第i個數ai代表左邊的 i 號接到了右邊的ai號。

題解

對輸入的序列求LIS即可，由於p<40000而且是多組測試資料，要用nlogn的演算法。

4.洛谷【p1091】合唱隊形

題目描述

N位同學站成一排，音樂老師要請其中的(N-K)位同學出列，使得剩下的K位同學排成合唱隊形。

合唱隊形是指這樣的一種隊形：設K位同學從左到右依次編號為1，2…，K，他們的身高分別為T1，T2，…，TK， 則他們的身高滿足T1<…Ti+1>…>TK(1<=i<=K)。

你的任務是，已知所有N位同學的身高，計算最少需要幾位同學出列，可以使得剩下的同學排成合唱隊形。

輸入輸出格式

輸入格式：
輸入檔案chorus.in的第一行是一個整數N(2<=N<=100)，表示同學的總數。第一行有n個整數，用空格分隔，第i個整數Ti(130<=Ti<=230)是第i位同學的身高(釐米)。

輸出格式：
輸出檔案chorus.out包括一行，這一行只包含一個整數，就是最少需要幾位同學出列。

輸入輸出樣例

輸入樣例#1：
8
186 186 150 200 160 130 197 220
輸出樣例#1：
4

資料範圍

對於50％的資料，保證有n<=20；

對於全部的資料，保證有n<=100。

題解

合唱隊形要求的是先上升，再下降的最長子序列，如圖:

狀態設計：F[i]表示以i結尾的最長上升子序列，G[i]代表從i開始的最長下降子序列。
狀態轉移：F[i]=max{F[j+1]}(1<=j < i,A[j]< A[i]),G[i]=max{G[j]+1}(i< j<=n,A[j]< A[i])
邊界處理：F[i]=1,G[i]=1(1<=i<=n)
最後的答案是ans=max{F[i]+G[i]-1}(1<=i<=n)
減1的原因是i重複算了兩遍

程式碼：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn =1001;
int a[maxn],f[maxn],g[maxn];
int n;
int main()
{
    int ans=0,l;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        g[i]=f[i]=1;
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=i-1;j++)
            if(a[j]<a[i]&&f[i]<f[j]+1)
                f[i]=f[j]+1;
    }
    for(int i=n;i>=1;i--){
        for(int j=n;j>=i+1;j--)
            if(a[j]<a[i]&&g[i]<g[j]+1)
                g[i]=g[j]+1;
    }
    for(int i=1;i<=n;i++)
        ans=max(ans,f[i]+g[i]-1);
    printf("%d\n",n-ans);
    return 0;
}

5.洛谷【p1439】排列LCS問題

題目描述

給出1-n的兩個排列P1和P2，求它們的最長公共子序列。

輸入輸出格式

輸入格式：
第一行是一個數n，

接下來兩行，每行為n個數，為自然數1-n的一個排列。

輸出格式：
一個數，即最長公共子序列的長度

輸入輸出樣例

輸入樣例#1：
5
3 2 1 4 5
1 2 3 4 5
輸出樣例#1：
3

【資料規模】

對於50%的資料，n≤1000

對於100%的資料，n≤100000

題解

50分做法：直接跑LCS（最長公共子序列）
滿分做法：

注意到題目中的兩個序列都是1~n的一個排列。若其中一個排列是1,2,3…n，那麼他們的LCS（最長公共子序列）就是就是另一個序列的LIS（最長上升子序列）。如果兩個序列的排列都不是1,2,3…n，那麼我們可以認為其中一個序列是1,2,3..n，然後把第一個序列的a[1]對映到1，a[2]對映到2，a[n]對映到n，對b序列也按照a序列的對映規則處理，這樣再求b序列的LIS即可。
程式碼：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn =100003,INF=0x7f7f7f7f;
int low[maxn];
int a[maxn],b[maxn];
int main()
{
    int n,ans=1;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) 
    {
        int x;
        scanf("%d",&x);
        a[x]=i;//把a[i]對映到i
    }
    for(int i=1;i<=n;i++)
    {
        int x;
        scanf("%d",&x);
        b[i]=a[x];//把b陣列按照a陣列的對映規則進行對映
    }
    for(int i=1;i<=n;i++) low[i]=INF;//初始化
    low[1]=b[1];
    for(int i=2;i<=n;i++)
    {
        if(b[i]>=low[ans]) 
            low[++ans]=b[i];
        else
            low[lower_bound(low+1,low+ans+1,b[i])-low]=b[i];//利用STL的lower_bound減少碼量
    }
    printf("%d\n",ans);
    return 0;
}

後記

本人水平有限，本文如有錯誤，歡迎指正：）

相關推薦

HDU1257 最少攔截系統 —— 貪心 or LIS（最長上升子序列）

ret pre key ear out hide 裏來 程序 http 題目鏈接：http://acm.split.hdu.edu.cn/showproblem.php?pid=1257 最少攔截系統 Time Limit: 2000/1000 MS (Java/Oth

LIS（最長上升子序列）問題的三種求解方法以及一些例題

摘要 本篇部落格介紹了求LIS的三種方法，分別是O(n^2)的DP，O(nlogn)的二分+貪心法，以及O(nlogn)的樹狀陣列優化的DP，後面給出了5道LIS的例題。 LIS的定義 一個數的序列bi，當b1 < b2 < … <

【dp優化】LIS（最長上升子序列）長度的nlogn演算法

這道題第一反應就想到了 [CEOI96]渡輪問題 就是一個非常裸的求最長上升子序列的長度，還不要方案，非常的水。然而，常規的dp複雜度是 O(n^2) ,這道題會愉快地TLE，所以要進行nlogn級別的優化。 //O(n^2) TLE #include

uva 10635（最長上升子序列）

正是太蠢了，我做這道題居然做了幾天 一道經典的LCS，但也可以轉化成LIS 將A中的資料重新編排成{1,2,3,....}，然後將B中的元素與A一一對應，如果B中的元素在A中沒有出現，就直接刪除。

HDU 5256 序列變換（最長上升子序列）

Problem Description 我們有一個數列A1,A2…An，你現在要求修改數量最少的元素，使得這個數列嚴格遞增。其中無論是修改前還是修改後，每個元素都必須是整數。 請輸出最少需要修改多少個元素。 Input 第一行輸入一個T(1≤T≤10)，

最長上升子序列的兩種演算法（LIS）

最長上升子序列就是求：給定的一串數字中 找出不斷上升的最長那一串（該串不一定相連，只保證遞增即可）。就比如下面這個例子   其最長上升子序列為2 3 4 7或2 3 4 6  數串長度為4 那麼具體怎麼求的呢 我們拿一個最簡單的例子講： 【題目描述】 給定N個數，求這N

POJ 1836 Alignment（DP max（最長上升子序列 + 最長下降子序列））

mission weight ring limit problem stream [0 sin ++ Alignment Time Limit: 1000MS Memory Limit: 30000K Total Submissions: 14486

動態規劃-導彈攔截（求最長不上升子序列和最長上升子序列）

lower_bound(a,a+n,i)函式 返回從陣列a到a+n中第一個>=i的元素地址 upper_bound(a,a+n,i)函式 返回從陣列a到a+n中第一個>i的元素地址 #include<cstdio> #include<algorithm> #i

101889F Fundraising （二維帶權最長上升子序列）

題意：二維帶權最長上升子序列。 解題思路：先對一維排序，然後在第二維做最長上升子序列的NlogN做法，同時維護好權值即可。記得離散化。 這裡相同的點最好合並一下，方便處理。 #incl

CSU 1225: ACM小組的佇列（最長上升子序列的個數）

題目：DescriptionACM小組每次出去活動都要排隊，但是大家總是不想按照任何規則來排好這個隊伍（大概是因為每個人都比較有個性，例如Gestapolur），所以每次隊 伍都是亂的，不過Samsar

1836 Alignment （最長上升子序列 O(nlogn））

解題思路：是POJ2533的擴充套件題。 題意不難，令到原佇列的最少士兵出列後，使得新佇列任意一個士兵都能看到左邊或者右邊的無窮遠處。就是使新佇列呈三角形分佈就對了。 但這裡有一個陷阱，看了一些別人的解題報告說“任一士兵旁邊不能存在等高的士兵”，然後又舉了一個例

藍橋杯 攔截導彈 動態規劃（最長下降子序列+最長上升子序列）

/* 思路： 1.要求後面炮彈不高於前面，最大可以攔截多少導彈， 就是求最長下降子序列 dp[i]=max(dp[i],d[j]+1) (j=1到i-1) 對於每個節點，掃面他前面i-1個節點，如果比我的大或等於我， 就考慮用不用他的 用他的話就是他的dp[j]+1，不用的話就我自己來dp[i]

HDU-1905-Bridging signals（二分求最長上升子序列）

Bridging signals Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 1167    Ac

最長不下降子序列（可以改成最長上升子序列）

#include<bits/stdc++.h> #define maxn 101111 using namespace std; int a[maxn],b[maxn]; int Sear

HDU 1513 Palindrome：LCS（最長公共子序列）or 記憶化搜索

ble urn size rom str 個數 blog using reverse 題目鏈接：http://acm.hdu.edu.cn/showproblem.php?pid=1513 題意： 　　給你一個字符串s，你可以在s中的任意位置添加任意字符，問你將s變成一個回

POJ 1458 - Common Subsequence（最長公共子序列） 題解

void 方式 mem strong 輸出 inline ron eof init 此文為博主原創題解，轉載時請通知博主，並把原文鏈接放在正文醒目位置。 題目鏈接：http://poj.org/problem?id=1458 題目大意： 有若幹組數據，每組給出兩個字符

LCS（最長公共子序列）

rdquo 工作 dna abc sub 動態規劃 != 給定 似的 　　這個問題很有意思，在生物應用中，經常需要比較兩個（或多個）不同生物體的DNA片段。例如，某種生物的DNA可能為S1 = ACCGGTCGAGTGCGCGGAAGCCGGCCGAA，S2 = GTCGT

poj 3616 Milking Time(dp,類似於最長上升子序列）

題意：給奶牛擠奶,共m次可以擠,給出每次開始擠奶的時間st,結束擠奶的時間ed,還有擠奶的量ef, 每次擠完奶要休息r時間,問最大擠奶量. 題解：此題靈感來自於最長上升子序列的做法 #include <iostream> #include <cstring>

【ZOJ1108】FatMouse's Speed（最長下降子序列）

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1108 FatMouse's Speed Time Limit: 2 Seconds      Memo

小樂樂匹配字串 （最長公共子序列）

連結：https://ac.nowcoder.com/acm/contest/301/E 來源：牛客網   小樂樂匹配字串 時間限制：C/C++ 1秒，其他語言2秒 空間限制：C/C++ 32768K，其他語言65536K 64bit IO Format: %lld 題目描述