【华为OJ】【054-Redraiment的走法】

【华为OJ】【算法总篇章】

【华为OJ】【054-Redraiment的走法】

【工程下载】

题目描述

Redraiment是走梅花桩的高手。Redraiment总是起点不限，从前到后，往高的桩子走，但走的步数最多，不知道为什么？
你能替Redraiment研究他最多走的步数吗？

样例输入
6
2 5 1 5 4 5

样例输出
3

提示
Example:
6个点的高度各为 2 5 1 5 4 5
如从第1格开始走,最多为3步, 2 4 5
从第2格开始走,最多只有1步,5
而从第3格开始走最多有3步,1 4 5
从第5格开始走最多有2步,4 5
所以这个结果是3。

输入描述

输入多行，先输入数组的个数，再输入相应个数的整数

输出描述

输出结果

输入例子

6
2
5
1
5
4
5

输出例子

3

算法实现

import java.util.Scanner;

/**
* Author: 王俊超
* Date: 2015-12-27 15:25
* Declaration: All Rights Reserved !!!
*/
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//        Scanner scanner = new Scanner(Main.class.getClassLoader().getResourceAsStream("data.txt"));
while (scanner.hasNext()) {
int n = scanner.nextInt();
int[] a = new int
;
for (int i = 0; i < n; i++) {
a[i] = scanner.nextInt();
}

System.out.println(lsiEnhance(a));
}

scanner.close();
}

/**
* 设f(i)表示L中以ai为末元素的最长递增子序列的长度。则有如下的递推方程：
* 这个递推方程的意思是，在求以ai为末元素的最长递增子序列时，找到所有序
* 号在L前面且小于ai的元素aj，即j<i且aj<ai。如果这样的元素存在，那么对
* 所有aj,都有一个以aj为末元素的最长递增子序列的长度f(j)，把其中最大的
* f(j)选出来，那么f(i)就等于最大的f(j)加上1，即以ai为末元素的最长递增
* 子序列，等于以使f(j)最大的那个aj为末元素的递增子序列最末再加上ai；如
* 果这样的元素不存在，那么ai自身构成一个长度为1的以ai为末元素的递增子序列。
*
* @param a 待处理的数组
* @return 最长递增子序列长度
*/
private static int lisSimple(int[] a) {
int n = a.length;
// 用于存放f(i)值；
int[] f = new int
;
// 以第a1为末元素的最长递增子序列长度为1；
f[0] = 1;

for (int i = 1; i < n; i++) {// 循环n-1次
// f[i]的最小值为1；
f[i] = 1;
for (int j = 0; j < i; j++) {// 循环i次
if (a[j] < a[i] && f[j] > f[i] - 1) {
// 更新f[i]的值。
f[i] = f[j] + 1;
}
}
}
// 这个算法有两层循环，外层循环次数为n-1次，内层循环次数为i次，
// 算法的时间复杂度所以T(n)=O(n2)。
return f[n - 1];
}

/**
* 在上一种算法中，在计算每一个f(i)时，都要找出最大的f(j)(j < i)来，由于f(j)没有顺序，
* 只能顺序查找满足aj < ai最大的f(j)，如果能将让f(j)有序，就可以使用二分查找，这样算
* 法的时间复杂度就可能降到O(nlogn)。于是想到用一个数组B来存储“子序列的”最大递增子
* 序列的最末元素，即有B[f(j)] = aj在计算f(i)时，在数组B中用二分查找法找到满足
* j < i且B[f(j)] = aj < ai的最大的j,并将B[f[j]+1]置为ai。
*
* @param a
* @return
*/
private static int lsiEnhance(int[] a) {

int n = a.length;
// 数组B；
float[] B = new float[n + 1];
// 把B[0]设为最小
B[0] = Integer.MIN_VALUE;
// 初始时，最大递增子序列长度为1的最末元素为a1
B[1] = a[0];
// Len为当前最大递增子序列长度，初始化为1；
int len = 1;
// p,r,m分别为二分查找的上界，下界和中点；
int p, r, m;

for (int i = 1; i < n; i++) {
p = 0;
r = len;

// 二分查找最末元素小于ai+1的长度最大的最大递增子序列；
while (p <= r) {
m = (p + r) / 2;
if (B[m] < a[i]) {
p = m + 1;
} else {
r = m - 1;
}
}

// 将长度为p的最大递增子序列的当前最末元素置为ai+1;
B[p] = a[i];
if (p > len) {
// 更新当前最大递增子序列长度；
len++;
}

}

return len;
}
}