Java--最大子序列和实现

package com.dongbin.test;

/**
 * 最大子序列和 --分治法
 *
 * @author dongbin
 *
 */
public class MaxSubListSum {

    /**
     * 最大子序列的实现方法
     *
     * @param arr
     *            --数组
     * @param left
     * @param right
     * @return
     */
    public static int maxsubListSum(int arr[], int left, int right) {

        if (left == right) {// arr.length==1
            if (arr[left] > 0) {
                return arr[left];
            } else {
                return 0;
            }
        }

        // 划分数组
        int center = (left + right) / 2;
        int maxLeftSum = maxsubListSum(arr, left, center);// 左边最大值
        int maxRightSum = maxsubListSum(arr, center + 1, right);// 右边最大值

        // 左边求和
        int maxLeftBorderSum = 0, leftBorderSum = 0;
        for (int i = center; i >= left; i--) {
            leftBorderSum += arr[i];
            if (leftBorderSum > maxLeftBorderSum) {
                maxLeftBorderSum = leftBorderSum;
            }
        }

        // 右边求和
        int maxRightBorderSum = 0, rightBorderSum = 0;
        for(int i = center+1;i<=right;i++){
            rightBorderSum += arr[i];
            if(rightBorderSum>maxRightBorderSum){
                maxRightBorderSum = rightBorderSum;
            }
        }

        return maxList(maxLeftSum,maxRightSum,maxLeftBorderSum+maxRightBorderSum);

    }

    /**
     * 获取 多个Id 的最大值
     * @param elements
     * @return
     */
    private static  int maxList(int... elements){
        int max = 0;
        for(int i = 0;i<elements.length;i++){
            if(elements[i]>max){
                max = elements[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        int[] a = {4,-3,5,-2,-1,2,6,-2};
        System.out.println(maxsubListSum(a, 0, a.length-1));
    }
}
/**
     * 优化最大子序列
     * @param arr
     * @return
     */
    public static int optMaxSubListSum(int [] arr){
        int maxSum = 0,temp = 0;
        for(int i=0;i<arr.length;i++){
            temp += arr[i];
            if(temp>maxSum){
                maxSum = temp;
            }

            if(temp<0){
                temp = 0;
            }
        }

        return maxSum;
    }
时间: 2024-11-08 21:57:32

Java--最大子序列和实现的相关文章

最长递增子序列 LIS 时间复杂度O(nlogn)的Java实现

关于最长递增子序列时间复杂度O(n^2)的实现方法在博客http://blog.csdn.net/iniegang/article/details/47379873(最长递增子序列 Java实现)中已经做了实现,但是这种方法时间复杂度太高,查阅相关资料后我发现有人提出的算法可以将时间复杂度降低为O(nlogn),这种算法的核心思想就是替换(二分法替换),以下为我对这中算法的理解: 假设随机生成的一个具有10个元素的数组arrayIn[1-10]如[2, 3, 3, 4, 7, 3, 1, 6,

HDU-1231-最大连续子序列(Java+DP动态规划)

最大连续子序列 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 21101    Accepted Submission(s): 9361 Problem Description 给定K个整数的序列{ N1, N2, ..., NK },其任意连续子序列可表示为{ Ni, Ni+1, ..., Nj },其中 1 <= i <= j

poj 2757 : 最长上升子序列(JAVA)

总时间限制:  2000ms 内存限制: 65536kB 描述 一个数的序列bi,当b1 < b2 < ... < bS的时候,我们称这个序列是上升的.对于给定的一个序列(a1, a2, ..., aN),我们可以得到一些上升的子序列(ai1, ai2, ..., aiK),这里1 <= i1 < i2 < ... < iK <= N.比如,对于序列(1, 7, 3, 5, 9, 4, 8),有它的一些上升子序列,如(1, 7), (3, 4, 8)等等.这

“最大子序列和”算法 java

maxSubSum分别是最大子序列和的4中java算法实现. 第一种算法运行时间为O(N^3),第二种算法运行时间为O(N^2),第三种算法运行时间为O(nlogn),第四种算法运行时间为线性N public class Test { public static void main(String[] args) { int[] a = {-2, 11, -4, 13, -5, -2};//最大子序列和为20 int[] b = {-6, 2, 4, -7, 5, 3, 2, -1, 6, -9,

java最长升序子序列

最长升序子序列是最长公共子序列的变形. 只要将字符串升序排序后与原字符串求最长公共子序列即可. 以下提供一个工具类可以传入任何形式的数组.(添加新类型的数组时构造方法要自己加). package com.leejuen.string; import java.lang.reflect.Array; import java.util.Arrays; public class LCS { private Integer len; private Object str1; private Object

最长公共子串、最长公共子序列的Java实现与NLP应用

前言以前HanLP使用"最短编辑距离"来做推荐器,效果有待提高,主要缺点是根据拼音序列的编辑距离推荐的时候,同音字交错很常见,而编辑距离却不那么大.这时我就在寻求一种补充的评分算法,去评判两个句子在拼音这一维度上的相似程度.区别最长公共子串(Longest Common Substring)指的是两个字符串中的最长公共子串,要求子串一定连续.最长公共子序列(Longest Common Substring)指的是两个字符串中的最长公共子串,不要求子串连续.求解两者的求解与编辑距离一样,

(Java) LeetCode 334. Increasing Triplet Subsequence —— 递增的三元子序列

Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array. Formally the function should: Return true if there exists i, j, k such that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 else return

(Java) LeetCode 152. Maximum Product Subarray —— 乘积最大子序列

Given an integer array nums, find the contiguous subarray within an array (containing at least one number) which has the largest product. Example 1: Input: [2,3,-2,4] Output: 6 Explanation: [2,3] has the largest product 6. Example 2: Input: [-2,0,-1]

LeetCode 300. Longest Increasing Subsequence最长上升子序列 (C++/Java)

题目: Given an unsorted array of integers, find the length of longest increasing subsequence. Example: Input: [10,9,2,5,3,7,101,18] Output: 4 Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4. Note: There may be

LeetCode 673. Number of Longest Increasing Subsequence 最长递增子序列的个数 (C++/Java)

题目: Given an unsorted array of integers, find the number of longest increasing subsequence. Example 1: Input: [1,3,5,4,7] Output: 2 Explanation: The two longest increasing subsequence are [1, 3, 4, 7] and [1, 3, 5, 7]. Example 2: Input: [2,2,2,2,2] O