高效算法与数据结构应用-优快云博客

本文链接：https://blog.youkuaiyun.com/hcwzq/article/details/6768490

本文深入探讨了算法优化及数据结构应用的核心概念，详细介绍了O(n^2)、O(n*log2n)复杂度算法及其改进方法，包括双向LIS问题解决策略，并通过实例分析了算法在实际问题中的应用，如导弹拦截、轮船航线规划等场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转自：http://blog.youkuaiyun.com/designer_/article/details/5457836

这是O（n^2）的算法：

 
   view plain
  

     ·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
   
 #include<stdio.h>  
 int main()  
 {  
     int n,i,k,max,lis[1001],num[1001];  
     while(scanf("%d",&n)!=EOF)  
     {     
         for(i=0;i<n;i++)  
         {  
             scanf("%d",&num[i]);  
             lis[i]=1;  
         }  
         for(i=1;i<n;i++)  
             for(k=0;k<i;k++)  
                 if(num[k]<=num[i]&&lis[i]<lis[k]+1)   //当前数比之前数大&&当前记录值≤之前记录值，这样，把当前记录值加一  
                     lis[i]++;  
         max=1;  
         for(i=0;i<n;i++)  
             if(max<lis[i])  
                 max=lis[i];  
         printf("%d/n",max);  
     }  
     return 0;  
 }  

O（n*log₂n）的算法：用到二分

此时以lis的下标值表示以当前下标对应的lis值为结尾的递增序列的长度

 
   view plain
  

     ·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
   
 //最长不下降子序列  
 #include<stdio.h>   
 int lis[1001];   
 int binarysearch(int left,int right,int number)   
 {   
     int mid;   
     while(left<=right)   
     {   
         mid=left+(right-left)/2;   
         if(lis[mid]<=number)    left=mid+1;  /*最长不下降子序列 O（nlog2（n）） <改成≤*/  
         else    right=mid-1;   
     }   
     return right;   
 }   
 int main()   
 {   
     int n,tot,num,meet;   
     while(scanf("%d%d",&n,&lis[0])!=EOF)   
     {   
         tot=1;   
         while(--n)   
         {   
             scanf("%d",&num);   
             if(num>=lis[tot-1])    lis[tot++]=num; /*＜改成≤*/  
             else if(num<lis[tot-1])   
             {   
                 meet=binarysearch(0,tot-1,num);   
                 lis[++meet]=num;  
             }   
         }   
         printf("%d/n",tot);   
     }   
     return 0;   
 }  

双向LIS问题：

题意：一次给出n个士兵的高度，要求去掉几个人以保证剩余的每个人都满足：

向左或者右其中一个方向上，所有人比他低。

比如 1 2 3 2 1 就是一种满足条件的情况。

要求求出要满足条件的至少去掉多少人。

题解：首先要理解LIS最长上升子序列的求法

最长上升子序列顾名思义就是求一个数列中保证严格上升的序列个数最大值

如 4 1 2 3 6 5 7 这个数列的LIS 就是 5 （即 1 2 3 5 7）

用状态转移方程 b[i] = max{b[k]+1} (k<i && a[k]<a[i]) 实现LIS求解

求法详见各种百科。

其次因为是要双向单调，所有对原有身高数列进行从前到后从后到前两次LIS ，分别存入数组b[i] c[i]中

然后枚举每个身高，他之前的升序最大值和他之后的降序最大值即为所求，为节省时间，再次dp

用mi[i]（mfi[i]）分别表示到i为止前面（后边）的最大上升（下降）子序列。

状态转移方程 mi[i] = max (mi[i-1],b[i])

以上求法存在一个问题就是如果输入形如 1 2 3 3 2 1

用上面的方法得到的结果是 1 2 3 2 1 其实 1 2 3 3 2 1 本身就是满足条件的，所有还要考虑枚举的那个身高是否加入接下来的下降序列。

再次 rans[i] = max (mi[i]+mfi[i]-1, mi[i]+mfi[i+1])

即当前最优解为以枚举点为中心向两边递减或者以枚举点为和右边某点为两个中心向两边递减中的最大值。

ans = max(rans[i]) 1<=i<=n

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int n,l,r,rans,ans,b[1001],c[1001],mi[1001],mfi[1001],p;
double a[1001];
void lis()
{
    int i,j,max,max2=0;
    b[1] = 1;
    for (i=2;i<=n;i++)
    {
        max = 0;
        for (j=1;j<i;j++)
        {
            if (a[j]<a[i] && b[j]>max)
            {
                 max = b[j];
            }
        }
        b[i] = max + 1;
    } 
}
void flis()
{
    int i,j,max,max2=0;
    c[n] = 1;
    for (i=n-1;i>=1;i--)
    {
        max = 0;
        
        for (j=n;j>i;j--)
        {
            if (a[j]<a[i] && c[j]>max)
            {
                max = c[j];
            }
        }
        c[i] = max + 1;
    }
}
int maxn(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    int i,j,max;
    ans = 0;
    scanf("%d", &n);
    for (i=1;i<=n;i++)
    {
        scanf("%lf", &a[i]);
    }
    lis();
    flis();
    mi[1] = b[1];
    mfi[n] = c[n];
    for (i=2;i<=n;i++)
    {
        mi[i] = maxn(mi[i-1], b[i]);
    }
    for (i=n-1;i>=1;i--)
    {
        mfi[i] = maxn(mfi[n+1], c[i]);
    }
    for (i=1;i<=n;i++)
    {
        rans = maxn(mi[i]+mfi[i]-1,mi[i]+mfi[i+1]);
        if (rans>ans)
        ans = rans;
        
    }
    printf("%d\n", n-ans);
    system("pause");
}

扩展：

拦截导弹(missile.pas)

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

输入导弹依次飞来的高度（雷达给出的高度数据是不大于30000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

【样例输入】 missile.in

389 207 155 300 299 170 158 65

【输出样例】missile.out

6（最多能拦截的导弹数）

2（要拦截所有导弹最少要配备的系统数）

该问题也是寻找序列的递减序列，即为LIS算法
寻找最长的序列，从集合中删除，再次寻找，直到集合为空，寻找次数即为需要系统数

轮船问题(ship.pas)

【问题描述】

某国家被一条河划分为南北两部分，在南岸和北岸总共有N对城市，每一城市在对岸都有唯一的友好城市，任何两个城市都没有相同的友好城市。每一对友好城市都希望有一条航线来往，于是他们向政府提出了申请。由于河终年有雾。政府决定允许开通的航线就互不交叉（如果两条航线交叉，将有很大机会撞船）。兴建哪些航线以使在安全条件下有最多航线可以被开通。

【输入格式】

输入文件(ship.in):包括了若干组数据，每组数据格式如下：

第一行两个由空格分隔的整数x，y，10〈=x〈=6000，10〈=y〈=100。x表示河的长度而y表示宽。第二行是一个整数N(1<=N<=5000)，表示分布在河两岸的城市对数。接下来的N行每行有两个由空格分隔的正数C，D（C、D〈=x〉，描述每一对友好城市与河起点的距离，C表示北岸城市的距离而D表示南岸城市的距离。在河的同一边，任何两个城市的位置都是不同的。

【输出格式】

输出文件(ship.out)：要在连续的若干行里给出每一组数据在安全条件下能够开通的最大航线数目。

【输入输出样例】

Ship.in

30 4

4 5

2 4

5 2

1 3

3 1

Ship.out