洛谷 P1020 导弹拦截(dp+最长上升子序列变形)

传送门

懵懂的题解

深入理解

参考资料：

　　[1]:LIS详解1

　　[2]:LIS详解2

相关概念解释：

　　1.串 & 子序列

　　　　一个串的子串是指该串的一个连续的局部。

　　　　如果不要求连续，则可称为它的子序列。

　　　　比如对串： "abcdefg" 而言，"ab","abd","bdef" 等都是它的子序列。　　

　　　　特别地，一个串本身，以及空串也是它的子序列。

　　2.最长上升子序列 & 最长不下降子序列

　　　　最长上升子序列（Longest Increasing Subsequence，LIS），在计算机科学上是指一个序列中最长的单调递增的子序列。

　　　　而最长不下降子序列则不一定要保证单调递增，只要保证  a[ i ] <= a[ j ] ( j > i , 且在序列范围内)即可。

现在开始回归主题：

题意：

　　中文题意，不再赘述；

题解：

　　第一问求最长不上升子序列的长度；

　　第二问求这个序列里面最少有多少最长不上升子序列。

　　难点就在与第二问，如何求呢？

　　看大佬博客说“求一个序列里面最少有多少最长不上升序列等于求这个序列里最长上升序列的长度”，我也不懂为啥 /小纠结，或许，这就是大佬吧。

废话少说，上AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 #define INF 0x3f3f3f3f
 const int maxn=1e5+;

 int n;
 int a[maxn];
 int dp[maxn];

 void Solve()
 {
     int len=;
     dp[len]=INF;
     for(int i=;i <= n;++i)
     {
         if(a[i] <= dp[len])
             dp[++len]=a[i];
         else
         {
             int l=,r=len+;
             while(r-l > )//二分出最后一个不小于 a[i] 的下标
             {
                 int mid=(l+r)/;
                 if(dp[mid] >= a[i])//注意，此处取到"=="判给了 l
                     l=mid;
                 else
                     r=mid;
             }
             dp[r]=a[i];
         }
     }
     printf("%d\n",len);
     len=;
     dp[len]=-;
     for(int i=;i <= n;++i)//求最长上升子序列
     {
         if(a[i] > dp[len])
             dp[++len]=a[i];
         else
         {
             int t=lower_bound(dp+,dp+len+,a[i])-dp;
             dp[t]=a[i];
         }
     }
     printf("%d\n",len);
 }

 int main()
 {
     while(~scanf("%d",&a[++n]))//以回车结束输入的输入方式
         continue;
     n--;
     Solve();
 }

bug：

　　(1):输入方式

　　正确的输入方式：

 while(~scanf("%d",&a[++n]))//以回车结束输入的输入方式
     continue;
 n--;//最后一个 n 接受的是 '\n' ，所以需要减去

　　错误的输入方式，返回 RE，至今不知道为啥，有知道的大佬可否告知一二%%%%%%%%

 do
 {
     scanf("%d",&a[++n]);
 }while(getchar() != '\n');

　　第一种输入方式在本地无法测试，但 OJ 可以。

　　第二种输入方式，虽然本地可以测试，但提交后返回 RE，应该是输入停不下来的吧。

---

分割线：2019.6.3

对第二问有了深一步的理解；

第二问求得是最少需要多少导弹拦截系统，根据贪心的思想，每个导弹系统都希望可以拦截尽可能多的导弹；

那么第一个导弹拦截系统最多可以拦截 cnt₁ 个，cnt₁ = 最长不上升子序列的长度；

第二个导弹拦截系统最多可拦截 cnt₂ 个，cnt₂ = 去掉第一次拦截的导弹后的最长不上升子序列的长度；

.............

第x个导弹拦截系统最多可拦截 cnt_x 个，cnt_x = 去掉前(x-1)次拦截的导弹后的最长不上升子序列长度；

假设第一次拦截的最低的导弹高度为 a₁；

第二次拦截的最低的导弹高度为 a₂;

..............

第x次拦截的最低导弹高度为 a_x；

那么，a₁ < a₂ < ... < a_x；

用反证法证明：

　　假设 a_i > a_j ( i<j )；

　　那么，在第 i 次拦截中结尾的不应该是 ai，而应该是比 a_i 还小的 a_j；

　　但已经假设 a_i 是第 i 次拦截中的最低导弹高度，与假设矛盾；

所以，第二问求的是最长上升子序列；

AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 #define INF 0x3f3f3f3f
 const int maxn=1e5+;

 int n;
 int a[maxn];
 int tmp[maxn];
 int d[maxn];

 void Solve()
 {
     int k=n;
     for(int i=;i <= n;++i)
         tmp[i]=a[k--];

     int cnt=;
     d[cnt]=-;
     for(int i=;i <= n;++i)
     {
         if(tmp[i] >= d[cnt])
             d[++cnt]=tmp[i];
         else
         {
             int t=upper_bound(d+,d+cnt+,tmp[i])-d;
             d[t]=tmp[i];
         }
     }
     printf("%d",cnt);

     cnt=;
     for(int i=;i <= n;++i)
     {
         if(a[i] > d[cnt])
             d[++cnt]=a[i];
         else
         {
             int t=lower_bound(d+,d+cnt+,a[i])-d;
             d[t]=a[i];
         }
     }
     printf(" %d\n",cnt);

     return ;
 }
 int main()
 {
 //    freopen("C:/Users/14685/Desktop/stdin&&stdout/contest","r",stdin);
     n=;
     while(~scanf("%d",&a[++n]));
     n--;
     Solve();

     return ;
 }