算法训练 拦截导弹

算法训练 拦截导弹

@蓝桥杯 算法训练 ALGO-13
@洛谷 P1020

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

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

389 207 155 300 299 170 158 65

样例输出

6
2

数据规模与约定

蓝桥爬

洛谷：
高度数据是 ≤ 50000 的正整数
个数 ≤ 100000

AC code (洛谷) ：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        StreamTokenizer in = new StreamTokenizer( new BufferedReader(new InputStreamReader(System.in)));
        int LI = 0, HI = 0, LQ[] = new int[100001], HQ[] = new int[100001];
        LQ[0] = Integer.MAX_VALUE; HQ[0] = Integer.MIN_VALUE;
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            int now = (int)in.nval;
            if (now <= LQ[LI]) LQ[++LI] = now;
            else {
                int low = 1, high = LI;
                while (low < high) {
                    int mid = (low + high) >> 1;
                    if (now <= LQ[mid]) low = mid + 1;
                    else high = mid;
                }
                LQ[low] = now;
            }
            if (now > HQ[HI]) HQ[++HI] = now;
            else {
                int low = 1, high = HI;
                while (low < high) {
                    int mid = (low + high) >> 1;
                    if (now > HQ[mid]) low = mid + 1;
                    else high = mid;
                }
                HQ[low] = now;
            }
        }
        System.out.print(LI + "\n" + HI);
    }
}

这算单调栈吧，不是很懂

---

很久以前

源码:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(reader.readLine(), " \n");
        int n = in.countTokens(), max = 0, min = 0;
        int[] line = new int[n], dpH = new int[n], dpL = new int[n];
        for (int i = 0, now; i < n; i++) {
            now = line[i] = Integer.parseInt(in.nextToken(), 10);
            for (int j = 0; j < i; j++)
                if (line[j] >= now) dpH[i] = max(dpH[i], dpH[j]);
                else dpL[i] = max(dpL[i], dpL[j]);
            max = max(max, ++dpH[i]);
            min = max(min, ++dpL[i]);
        }
        System.out.print(max + "\n" + min);
    }

    static int max(int a, int b) { return a > b? a: b; }
}

相比于老版性能提升巨大，拼性能能不用 Scanner 就不用 Scanner，反正
动态规划参考

老版：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] put = sc.nextLine().split(" ");
        int i = put.length, j = i, max = 0, min = 0;
        int[] array = new int[i],
              MaxDp = new int[i],
              MinDp = new int[i];
        while (--i >= 0)
            array[i] = Integer.parseInt(put[i]);
        while (++i < j) {
            for (int l = i, temp = array[i]; l > 0;)
                if (temp < array[--l]) MaxDp[i] = Math.max(MaxDp[i], MaxDp[l]);
                else MinDp[i] = Math.max(MinDp[i], MinDp[l]);
            max = Math.max(max, ++MaxDp[i]);
            min = Math.max(min, ++MinDp[i]);
        }
        System.out.println(max + "\n" + min);
    }
}