杭电oj1257最少拦截系统—贪心/dp最大递增子序列

附上题目链接：杭电oj1257

这个题目有动态规划和贪心两种解决方式。
贪心法1：
对于导弹我们知道只可以从大到小的反导，一个系统必须从大到小排列。那么我们就可以选择从最高的那个导弹入手，往右找仅次于最高的那个导弹，标记（可使用boolean），一直找到最后一个导弹形成系统1。在重复找未被标记的最大往右找，形成系统二，一直到全被标记为止。代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/*
 * 贪心算法
 * 思路：将导弹从大到小排序，另计数组标记原始数据。循环查找导弹右侧的第一个比导弹低的是否在右侧；如果右侧，继续后面比较第二个导弹
 * 如果不在右侧，继续往下找到最大的在右侧的那个导弹。找过的导弹全部标记。形成一个系统
 * 循环从下一个系统开始找未标记的导弹。
 */
public class 杭电1257 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int n = sc.nextInt();
			int a[] = new int[n];// 原始数据
			int b[] = new int[n];// 原始数据对应的序号。方便排序后知道原来排序
			boolean c[] = new boolean[n];
			int count = 0;

			for (int i = 0; i < n; i  ) {
				a[i] = sc.nextInt();
				b[i] = i;

			}
			for (int i = 0; i < n; i  )// 将导弹从大到小排序
			{
				for (int j = i; j < n; j  ) {
					if (a[i] < a[j]) {
						int t = a[i];
						a[i] = a[j];
						a[j] = t;
						t = b[i];
						b[i] = b[j];
						b[j] = t;
					}
				}
			}
			for (int i = 0; i < n; i  ) {
				if (c[i] == false) {

					int s = b[i];// 序号
					for (int j = i; j < n; j  ) {
						if (b[j] >= s && c[j] == false) {
							c[j] = true;
							s = b[j];
						}
					}
					count  ;
				}
			}
			System.out.println(count);
		}
	}
}

贪心法二：学习恶狼干爹方法

算法思想：
建立足够大的系统数，导弹从左到右一个一个来。
第一个形成系统1.
第二个看看是否比第一个小，如果小，则进入系统1.如果比第一个大，则新建系统二。
若完成拦截，则此拦截系统的最大拦截变为这个高度
若未拦截成功，则新建系统，最高拦截度为这个数
核心是使用数组储存数据。

import java.util.*;  

class 杭电1257{  
    public static void main(String[] args){  
        int n,i,x,numb,m,k;  
        int[] system=new int[100000];//记录所有系统中能截的最大高度  
        Scanner sc=new Scanner(System.in);  
        boolean haveSystem;//记录在已有的系统只是否找到能截的系统  
        while(sc.hasNext()){  
            numb=0;//表示系统的个数  
            n=sc.nextInt();  
            for(i=0;i<n;i  ){  
                m=sc.nextInt();  
                haveSystem=false;  
                for(k=0;k<=numb;k  ){//先找再已有的系统只是否有能截的系统  
                    if(m<=system[k]){  
                        system[k]=m;  
                        haveSystem=true;  
                        break;  
                    }  
                }  
                if(!haveSystem){//若没有能截的系统，则重新配一套系统  
                    system[  numb]=m;  
                }  
            }  
            System.out.println(numb);  
        }  
    }  
}  

动态规划法：
求最大递增子序列

import java.util.Scanner;

public class 杭电1257 {
	public static void main(String[] args)
	{
		
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext())
		{
			int max=0;//最大数列长度
		int n=sc.nextInt();
		int dp[]=new int[n];//以第i个元素结尾的最大子数列。（最后一个一定是a[i]的）	
		int a[]=new int[n];
		for(int i=0;i<n;i  )
		{
			a[i]=sc.nextInt();
		}
		dp[0]=1;//第一元素构成1
		
		for(int i=1;i<n;i  )
		{//计算dp[i];
			int m=0;//每次都要初始化计算;m的实际意义为临时变量，为了找比自己小的元素的最大数列，然后拼凑成为第i个最大。
			for(int j=0;j<i;j  )//从0到当前元素循环
			{
				if(dp[j]>m&&a[j]<a[i])
				{
					m=dp[j];	//这样做为了找到最大的那个dp【j】，并且那个a[j]<a[i];则j的那串加上i就构成以i结尾的最大递增数列
				}
				dp[i]=m 1;//相当于最大的第J串后面接了一个元素。
				if(max<dp[i])
				{
					max=dp[i];
				}
			
			}
		}
		System.out.println(max);
		
		}
	}

}