web-dev-qa-db-ja.com

カダネのアルゴリズムの説明

誰かがここカダネのアルゴリズムで何が起こっているのかを教えてもらえますか？私の理解を確認したかった。これが私の見方です。

配列をループしていて、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;

    };
javascriptalgorithmkadanes-algorithm
12
devdropper87

値をトレースすることを検討してください。

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]);

プリント：

0 0
0 0 -2
1 1 1
0 1 -3
4 4 4
3 4 -1
5 5 2
6 6 1
1 6 -5
5 6 4
5 6

最初の列はansで、これは現在のサブ配列の合計です。 2番目はsumで、これまでに見られた最大の合計を表します。 3つ目は、訪問したばかりの要素です。合計が最大の連続したサブ配列は4, −1, 2, 1であり、合計は6であることがわかります。

例は ウィキペディア からです。

以下は、ウィキペディアの段落の下にあるコードの翻訳です。「配列全体が負の数で構成されている場合、長さゼロのサブ配列を返すことができない問題のバリエーションは、次のコード： "[編集：以下のコードで修正された小さなバグ]

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

最後の数字は期待される結果です。その他は前例と同じです。

12
Dan D.

これにより、混合配列とすべての負の数配列の両方の状況が処理されます。

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]));
5
Vinayak Sakhare

このリンク を見てください。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;
}
3
akashrajkn

配列内のすべての負の数についても、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

1
amoljdv06
    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; 
} 
        }
0
28rox