Question

有人可以带我了解Kadane算法中发生的事情吗？想检查我的理解。这是我如何看待它。

你循环遍历数组，每次将ans变量设置为所看到的最大值，直到该值变为负值，然后ans变为零。

同时，sum变量每次循环都会被覆盖，到之前看到的和之间的最大值或者到目前为止最大的'ans'。一旦完成循环，你将获得迄今为止最大的总和或答案！

var sumArray = function(array) {
      var ans = 0;
      var sum = 0;
      //loop through the array.


      for (var i = 0; i < array.length; i++) {
        //this is to make sure that the sum is not negative. 
        ans = Math.max(0, ans + array[i]);

        //set the sum to be overwritten if something greater appears.
        sum = Math.max(sum, ans)
      }

      return sum;

    };

Answer 1

考虑跟踪值：

var maximumSubArray = function(array) {
    var ans = 0;
    var sum = 0;

    console.log(ans, sum);
    for (var i = 0; i < array.length; i++) {

        ans = Math.max(0, ans + array[i]);
        sum = Math.max(sum, ans);
        console.log(ans, sum, array[i]);
    }
    console.log(ans, sum);
    return sum;

};

maximumSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4]);

打印：

第一列是ans，它是当前子阵列的总和。第二个是sum，代表到目前为止看到的最大值的总和。第三个是刚刚访问过的元素。您可以看到具有最大总和的连续子阵列为4, −1, 2, 1，总和为6。

示例来自Wikipedia。

以下是维基百科在以下段落中给出的代码的翻译：＆＃34;在整个数组由负数组成的情况下，不允许返回零长度子数组的问题的变体，可以用以下代码解决：＆＃34; [编辑：以下代码中修复的小错误]

var maximumSubArray = function(array) {
    var ans = array[0];
    var sum = array[0];

    console.log(ans, sum);
    for (var i = 1; i < array.length; i++) {

        ans = Math.max(array[i], ans + array[i]);
        sum = Math.max(sum, ans);
        console.log(ans, sum, array[i]);
    }
    console.log(ans, sum);
    return sum;

};

看到：

> maximumSubArray([-10, -11, -12])
-10 -10
-10 -10 -11
-10 -10 -12
-10 -10
-10

最后一个数字是预期结果。其他的与前面的例子一样。

Answer 2

这将处理混合数组和所有负数数组的情况。

＆＃13;

var maximumSubArray = function(arr) {
    var max_cur=arr[0], max_global = arr[0];
    for (var i = 1; i < arr.length; i++) {
        max_cur = Math.max(arr[i], max_cur + arr[i]);
        max_global = Math.max(max_cur, max_global);
    }  
    return max_global;
};
console.log(maximumSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4]));
console.log(maximumSubArray([-10, -11, -12]));

＆＃13;

Answer 3

查看this link，它为Kadane的算法提供了清晰的解释。

基本上，您必须查找数组的所有正连续段，并跟踪最后总和连续段直到结束。每当您找到一个新的正连续段时，它会检查当前总和是否大于max_sum到目前为止并相应地更新。

以下代码处理所有数字均为负数的情况。

int maxSubArray(int a[], int size)
{
   int max_so_far = a[0], i;
   int curr_max = a[0];

   for (i = 1; i < size; i++)
   {
        curr_max = max(a[i], curr_max+a[i]);
        max_so_far = max(max_so_far, curr_max);
   }
   return max_so_far;
}

Answer 4

我已经对Kadane的算法加强了对数组中所有负数的启发。

int maximumSubSum(int[] array){
        int currMax =0;
        int maxSum = 0;

        //To handle All negative numbers
        int max = array[0];
        boolean flag = true;
        for (int i = 0; i < array.length; i++) {

             //To handle All negative numbers to get at least one positive number
            if(array[i]<0)
                max= Math.max(max , array[i]);
            else
                flag = false;


            currMax = Math.max(0, currMax + array[i]);
            maxSum = Math.max(maxSum , currMax);
        }
        return flag?max:sum;
    }

测试用例： -30 -20 -10

-10

-10 -20 -30

-10

-2 -3 4 -1 -2 1 5 -3

7

Answer 5

    import java.io.*;  
import java.util.*; 

class Main 
{ 
    public static void main (String[] args) 
    { 
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();    //size
        int a[]=new int[n];     //array of size n
        int i;
        for(i=0;i<n;i++)
        {
            a[i]=sc.nextInt();   //array input
        }

       System.out.println("Largest Sum Contiguous Subarray using Kadane’s Algorithm"+Sum(a));
    }

        static int Sum(int a[]) 
{ 

    int max = Integer.MIN_VALUE, max_ending = 0; 

    for (int i = 0; i < size; i++) 
    { 
        max_ending_here = max_ending + a[i]; 
        if (max < max_ending) 
            max = max_ending; //updating value of max
        if (max_ending < 0) 
            max_ending= 0; 
    } 
    return max; 
} 
        }

Answer 6

我更喜欢JavaScript中更实用的方法：

Petlover<Dog>

卡丹的算法解释道

6 个答案: