计算连续子向量的最大和

题目:HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢?例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住?(子向量的长度至少是1)

package test;

import org.junit.Test;
public class FindGreatestSumOfSubArray {
    int maxNum = Integer.MIN_VALUE;

    /**
     * 基于递归写法,时间复杂度o(n)
     *
     * @param i
     * @param a
     * @return
     */
    public int FindGreatestSumOfSubArray(int i, int[] a) {
        if (i == 0)
            return a[i];
        else {
            int tmp = FindGreatestSumOfSubArray(i - 1, a) + a[i];
            if (tmp <= 0) {
                return a[i];
            }
            if (tmp <a[i]){
                tmp = a[i];
            }
            if (tmp > maxNum) {
                maxNum = tmp;
            }
            return tmp;
        }
    }

    /**
     * 递归方法的调用
     *
     * @param i
     * @param a
     * @return
     */
    public int FindGreatestSumOfSubArrayRecru(int[] a) {
        int result = FindGreatestSumOfSubArray(a.length - 1, a);
        if (result < maxNum)
            return maxNum;
        else
            return result;
    }

    /**
     * 暴力搜索的方法,时间复杂度o(n^2)
     * @param a
     * @return
     */
    public int FindGreatestSumOfSubArrayViolent(int[] a) {
        // 暴力搜索
        int max = 0;
        for (int i = 0; i < a.length; i++) {
            int result = a[i];
            for (int j = i + 1; j < a.length; j++) {
                result += a[j];
                if (result > max) {
                    max = result;
                }
            }
        }
        return max;
    }

    /**
     * 动态规划写法,时间复杂度o(n),时间复杂度O(1)
     * @param a
     * @return
     */
    public int FindGreatestSumOfSubArrayDP(int[] a) {
        //基于数组特性,也叫动态规划
             if (a == null || a.length == 0)return 0;
            int max = Integer.MIN_VALUE;
             int result = 0;
             for(int i=0;i<a.length;i++){
                /* if (result <= 0){
                     result = a[i];
                 }else{
                     result += a[i];
                 }
                 if (result > max){
                     max = result;
                 }*/
                 //if,else的另一种写法:
                 result = (result < 0)?a[i]:a[i]+result;
                 max = (result > max)?result:max;
             }
             return max;
    }

    @Test
    public void test() {
        int[] a = { 1, -2, 3, 10, -4, 7, 2, -5 };
        int result1 = FindGreatestSumOfSubArrayRecru(a);
        System.out.println(result1); //18
        int result2 = FindGreatestSumOfSubArrayDP(a);
        System.out.println(result2);//18
        int result3 = FindGreatestSumOfSubArrayViolent(a);
        System.out.println(result3);//18
    }

}
时间: 2024-10-04 03:12:26

计算连续子向量的最大和的相关文章

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢?例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组,返回它的最大连续子序列的和,你会

public class Solution { public int FindGreatestSumOfSubArray(int[] array) { int sum=0; int res=array[0]; for (int i=0;i<array.length;i++){ sum = sum + array[i]; if(sum>res){ res=sum; } if(sum<0){ sum=0; } } return res; } } 原文地址:https://www.cnblog

C++中求数组连续子向量的最大和(牛客剑指offer)

/////////////////////////////////////////////////////////////////// //HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学. //今天测试组开完会后,他又发话了:在古老的一维模式识别中, //常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决. //但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢? //例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开

一维向量中连续子向量的最大和

Q:一个一维向量:arr[n] = {i1,i2,i3,......,in} ,计算其连续子向量中最大和.(即截取连续的一段使得段中各元素和最大,元素有负值:子向量可以为空,即和最小为0) A: 最初的想法是穷举,双层循环将所有连续的元素和算出来 for [i,n){ for[j,n){ caculate sum(arr[j],arr[j]); } } 这种方式虽然有效,但显得很蠢. 这里假设截取的区间是 arr[start, end] ,那么arr[start, end+1]的连续子向量的最大

算法设计--求连续子向量的最大和问题--论想法思路的重要性

向量[31,-41,59,26,-53,58,97,-93,-23,84] 算法一:直接求解,简单粗暴,没有什么想法可言,复杂度是O(N3) // 方法一,接近O(n3) int maxsofar1=0; int count=0; for (int i = 0; i < 10; ++i) { for (int j = 0; j < 10; ++j) { int sum=0; for (int k = i; k < j; ++k) { sum+=vec[k]; count++; } max

求最大和连续子向量问题的算法分析

1 问题描述 这是从<编程珠玑(第 2 版)>的第 8 章"算法设计技术"中看到的一个问题.问题的描述是这样的, "问题的输入是具有 n 个浮点数的向量 x,输出是输入向量的任何连续子向量中的最大和.例如,如果输入向量包含下面 10个元素:(31,-41,59,26,-53,97,-93,-23,84) 那么该程序的输出为x[2...6] 的总和,即 187." 当所有的数都是正数时,问题很容易解决,此时最大的子向量就是输入向量本身.但如果输入向量中含有

连续子数组的最大和

题目描述 HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学.今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决.但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢?例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止).你会不会被他忽悠住?(子向量的长度至少是1) class Solution { public: int FindGreatestSum

【剑指Offer】连续子数组的最大和

问题描述 HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学.今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决.但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢?例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止).你会不会被他忽悠住? 算法分析 有一个temp用于探路,sum负责保存最终值,初始都为数组第一个数: 每一轮循环里, temp如果小于

面试题31 连续子数组的最大和

题目描述 HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学.今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决.但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢?例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止).你会不会被他忽悠住? 1 class Solution { 2 public: 3 vector<int> v; 4 int Fin

面试题:连续子数组的最大和

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学.今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决.但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢?例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止).你会不会被他忽悠住? class Solution { public: int FindGreatestSumOfSubArray(vector