单调递增子序列(二)_hdu_214(dp).java

单调递增子序列(二)

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 4

描述

给定一整型数列{a₁,a₂...,a_n}（0<n<=100000），找出单调递增最长子序列，并求出其长度。

如：1 9 10 5 11 2 13的最长单调递增子序列是1 9 10 11 13，长度为5。

输入

有多组测试数据（<=7）
每组测试数据的第一行是一个整数n表示序列中共有n个整数，随后的下一行里有n个整数，表示数列中的所有元素.每个整形数中间用空格间隔开（0<n<=100000）。
数据以EOF结束 。
输入数据保证合法（全为int型整数）！

输出

对于每组测试数据输出整形数列的最长递增子序列的长度，每个输出占一行。

样例输入

7
1 9 10 5 11 2 13
2
2 -1

样例输出

5
1

import java.util.Scanner;

public class Main{//DP
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		while(input.hasNext()){
			int n=input.nextInt();
			int a[]=new int[n+5];
			int top=0;
			a[0]=Integer.MIN_VALUE;
			for(int i=0;i<n;i++){
				
				int e=input.nextInt();
				if(e>a[top]){
					top++;
					a[top]=e;
				}
				else{
					int low=1;
					int high=top;
					while(low<=high){
						int mid=(low+high)/2;
						if(e>a[mid]){
							low=mid+1;
						}
						else
							high=mid-1;
					}
					a[low]=e;
				}
			}
			System.out.println(top);
		}
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {
	public static void main(String[] args) {
		BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
		try {
			while(true){
				String s=bf.readLine();
				if(s.length()==0)
					break;
				int n=Integer.parseInt(s);
				int a[]=new int[n];
				String b1[]=bf.readLine().split(" ");
				int b[]=new int[n];
				for(int i=0;i<n;i++){
					b[i]=Integer.parseInt(b1[i]);
				}
				Arrays.fill(a, 1);
				for(int i=n-2;i>=0;i--){
					for(int j=i+1;j<n;j++){
						if(b[i]<b[j]&&a[i]<a[j]+1)
							a[i]=a[j]+1;
					}
				}
				int max=0;
				for(int i=0;i<n;i++)
					if(max<a[i])
						max=a[i];
				System.out.println(max);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}