某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。 输入导弹依次飞来的高度，计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。写代码，时间复杂度O（nlongn）用C＋＋写

这是一道典型的贪心算法题目，我们可以从前往后遍历导弹高度，遇到比前面低的导弹就拦截，同时更新最高高度，遇到比前面高的导弹就不拦截，同时更新最高高度。最后我们就能得到拦截的导弹数目。

代码如下：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    int n;
    vector<int> missiles;

    while (cin >> n)
    {
        missiles.push_back(n);
    }

    int cnt = 1;
    int max_height = missiles[0];
    int n_missiles = missiles.size();

    for (int i = 1; i < n_missiles; i++)
    {
        if (missiles[i] <= max_height)
        {
            max_height = missiles[i];
        }
        else
        {
            cnt++;
            max_height = missiles[i];
        }
    }

    cout << cnt << endl;

    return 0;
}

相关问题

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。 输入导弹依次飞来的高度，计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。写代码，时间复杂度O（nlongn）

这个问题可以使用 LIS（最长上升子序列）算法来解决。因为每一发导弹的高度都不能高于前一发，所以我们可以将导弹的高度看作序列，找到这个序列的最长上升子序列，就可以找到最多能拦截多少导弹。

同时，我们可以使用二分查找来优化LIS算法，将时间复杂度降到O(nlogn)。

下面是代码实现：

def LIS(nums):
    dp = []
    for num in nums:
        if not dp or num > dp[-1]:
            dp.append(num)
        else:
            left, right = 0, len(dp) - 1
            while left < right:
                mid = (left + right) // 2
                if dp[mid] < num:
                    left = mid + 1
                else:
                    right = mid
            dp[left] = num
    return len(dp)

heights = list(map(int, input().split()))
print(LIS(heights))

对于最少需要配备多少套这种导弹拦截系统的问题，我们只需要将输入的导弹高度反转，再使用LIS算法求解即可。

heights = list(map(int, input().split()))
print(LIS(heights))  # 最多能拦截多少导弹
print(LIS(heights[::-1]))  # 最少需要配备多少套导弹拦截系统

某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统，但是这种拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，由于该系统还在试用阶段。所以一套系统有可能不能拦截所有的导弹。 输入导弹依次飞来的高度（雷达给出的高度不大于30000的正整数）。计算要拦截所有导弹最小需要配备多少套这种导弹拦截系统

你的问题很有趣！根据你的描述，我可以给出下面的解法：

我们可以使用 LIS（最长上升子序列）算法来解决这个问题。LIS算法可以用来寻找一个序列中最长的严格上升子序列，也就是说，每个元素的值都比前一个元素的值大。

我们可以将导弹的高度序列看作一个数列，然后使用LIS算法来寻找最长的严格上升子序列。我们可以将每个上升子序列都看作需要一套导弹拦截系统，这样，我们就可以得出需要的最小导弹拦截系统数。

以下是使用动态规划实现LIS算法的伪代码：

dp = [1] * n # 初始化最长上升子序列长度为1
for i in range(1, n):
    for j in range(i):
        if a[j] < a[i]:
            dp[i] = max(dp[i], dp[j] + 1)

其中，`a`是导弹高度序列，`n`是序列的长度。`dp[i]`表示以第`i`个元素结尾的最长上升子序列的长度。

最终，我们可以用最长上升子序列的长度来表示需要的最小导弹拦截系统数。

代码实现如下：