Kadanes algoritm är en dynamisk programmeringsmetod som används för att lösa problemet med den maximala subarrayen, vilket innebär att hitta den sammanhängande subarrayen med den maximala summan i en matris av tal. Algoritmen föreslogs av Jay Kadane 1984 och har en tidskomplexitet på O(n).
Historien om Kadanes algoritm:
Kadanes algoritm är uppkallad efter dess uppfinnare, Jay Kadane, en professor i datavetenskap vid Carnegie Mellon University. Han beskrev först algoritmen i en artikel med titeln 'Maximum Sum Subarray Problem' publicerad i Journal of the Association for Computing Machinery (ACM) 1984.
Problemet med att hitta den maximala subarrayen har studerats av datavetare sedan 1970-talet. Det är ett välkänt problem inom området algoritmdesign och analys och har tillämpningar inom ett brett spektrum av områden, inklusive signalbehandling, ekonomi och bioinformatik.
hög sort
Före Kadanes algoritm hade andra algoritmer föreslagits för att lösa problemet med den maximala subarrayen, såsom brute-force-metoden som kontrollerar alla möjliga subarrayer och divide-and-conquer-algoritmen. Dessa algoritmer har dock högre tidskomplexitet och är mindre effektiva än Kadanes algoritm.
Kadanes algoritm används flitigt inom datavetenskap och har blivit ett klassiskt exempel på dynamisk programmering. Dess enkelhet, effektivitet och elegans har gjort det till en populär lösning på problemet med maximal subarray och ett värdefullt verktyg i algoritmdesign och analys.
Kadenes algoritm fungerar:
Algoritmen fungerar genom att iterera över arrayen och hålla reda på den maximala summan av subarrayen som slutar vid varje position. Vid varje position i har vi två alternativ: antingen lägga till elementet i position i till den nuvarande maximala subarrayen eller starta en ny subarray vid position i. Det maximala av dessa två alternativ är den maximala undermatrisen som slutar vid position i.
Vi bibehåller två variabler, max_so_far och max_ending_here, för att hålla reda på den maximala summan som setts hittills respektive den maximala summan som slutar på den aktuella positionen. Algoritmen börjar med att ställa in båda variablerna till det första elementet i arrayen. Sedan itererar vi över arrayen från det andra elementet till slutet.
java-operatörsföreträde
Vid varje position i uppdaterar vi max_ending_here genom att ta det maximala av det aktuella elementet och det aktuella elementet som läggs till den föregående maxundermatrisen. Vi uppdaterar sedan max_so_far till max_so_far och max_ending_here.
Algoritmen returnerar max_so_far, vilket är den maximala summan av varje delmatris i matrisen.
Här är steg-för-steg-processen för Kadanes algoritm:
1. Initiera två variabler, max_hittills och max_ending_här , till det första elementet i arrayen.
max_so_far = arr[0]
max_ending_here = arr[0]
2. Iterera över arrayen från det andra elementet till slutet:
för i från 1 till n-1 gör:
t flip flop
3. Beräkna den maximala summan som slutar på den aktuella positionen:
max_ending_here = max(arr[i], max_ending_here + arr[i])
4. Uppdatera max_so_far till max_so_far och max_ending_here:
max_so_far = max(max_so_far, max_ending_here)
5. Returnera max_so_far som den maximala summan av någon delmatris i matrisen.
Tidskomplexiteten för Kadanes algoritm är O(n), där n är längden på inmatningsmatrisen. Detta gör det till en mycket effektiv lösning på problemet med maximal subarray.
konvertera ett java-objekt till json
Exempel:
Låt oss se ett exempel på hur Kadanes algoritm fungerar:
Anta att vi har följande array av heltal:
arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
Vi vill hitta den maximala delmatrissumman för denna matris. Vi kan använda Kadanes algoritm för att lösa detta problem.
Vi börjar med att initiera två variabler:
max_so_far = INT_MIN; max_ending_here = 0;
Sedan itererar vi genom arrayen, med början från det andra elementet:
for i in range(1, len(arr)):
Uppdatera den aktuella summan genom att lägga till det aktuella elementet till föregående summa:
max_ending_here = max(arr[i], max_ending_here + arr[i])
Uppdatera den maximala summan som har setts hittills:
sql välj från flera tabeller
max_so_far = max(max_so_far, max_ending_here)
Vid varje iteration uppdaterar vi den aktuella summan genom att antingen lägga till det aktuella elementet till den föregående summan eller starta en ny undermatris vid det aktuella elementet. Vi uppdaterar sedan den maximala summan vi sett hittills genom att jämföra den med den aktuella summan.
Efter att ha itererat genom hela arrayen kommer värdet för max_so_far att vara den maximala subarraysumman för den givna arrayen.
I det här exemplet är den maximala delmatrissumman 6, vilket motsvarar delmatrisen [4, -1, 2, 1].
Kodimplementering i Java:
import java.io.*; import java.util.*; public class Main { public static void main(String[] args) { Scanner sc=new Scanner(System.in); System.out.print('Enter the size of the array : '); int n=sc.nextInt(); int[] arr=new int[n]; System.out.println('Enter the elements of the array : '); for(int i=0;i<n;i++){ arr[i]="sc.nextInt();" } int max_so_far="Integer.MIN_VALUE,max_ending_here=0;" for(int i="0;i<n;i++)" { max_ending_here+="arr[i];" if(max_so_far<max_ending_here){ if(max_ending_here<0){ max_ending_here="0;" system.out.print('the maximum contiguous sum in the array is : '+max_so_far); < pre> <p> <strong>Output</strong> </p> <pre> Enter the size of the array : 9 Enter the elements of the array : -2 1 -3 4 -1 2 1 -5 4 The Maximum contiguous sum in the array is : 6 </pre> <h3>Code Implementation in C++:</h3> <pre> #include using namespace std; int main() { int a[] = { -2, -3, 4, -1, -2, 1, 5, -3 }; int n = sizeof(a) / sizeof(a[0]); // Kadane's algorithm int max_so_far = INT_MIN, max_ending_here = 0; for (int i = 0; i <n; i++) { max_ending_here="max_ending_here" + a[i]; if (max_so_far < max_ending_here) max_so_far="max_ending_here;" (max_ending_here 0) } cout << 'maximum contiguous sum in the array is : '<<max_so_far<<endl; return 0; pre> <p> <strong>Output</strong> </p> <pre> Maximum contiguous sum in the array is : 7 </pre> <h2>Advantages and Disadvantages of Kadane's algorithm:</h2> <h3>Advantages of Kadane's Algorithm:</h3> <ul> <tr><td>Efficiency:</td> Kadane's Algorithm has a time complexity of O(n), which makes it very efficient for solving the maximum subarray problem. This makes it a great solution for large datasets. </tr><tr><td>Simplicity:</td> Kadane's Algorithm is relatively easy to understand and implement compared to other algorithms for solving the maximum subarray problem, such as the divide-and-conquer algorithm. </tr><tr><td>Space Complexity:</td> Kadane's Algorithm has a space complexity of O(1), which means it uses a constant amount of memory irrespective of the size of the input array. </tr><tr><td>Dynamic Programming:</td> Kadane's Algorithm is a classic example of dynamic programming, a technique that breaks down a problem into smaller subproblems and stores the solutions to these subproblems to avoid redundant computation. </tr></ul> <h3>Disadvantages of Kadane's Algorithm:</h3> <ul> <tr><td>Only finds sum and not the subarray itself:</td> Kadane's Algorithm only finds the maximum sum of the subarray and not the actual subarray itself. If you need to find the subarray that has the maximum sum, you will need to modify the algorithm accordingly. </tr><tr><td>Does not handle negative numbers well:</td> If an input array has only negative numbers, the algorithm will return the maximum negative number instead of 0. This can be overcome by adding an additional step to the algorithm to check if the array has only negative numbers. </tr><tr><td>Not suitable for non-contiguous subarrays:</td> Kadane's Algorithm is specifically designed for contiguous subarrays and may not be suitable for solving problems that involve non-contiguous subarrays. </tr></ul> <h2>Applications of Kadane's algorithm:</h2> <p>There are some of its applications like the following:</p> <ul> <tr><td>Maximum subarray sum:</td> As we saw in the example above, Kadane's algorithm is used to find the maximum subarray sum of an array of integers. This is a common problem in computer science and has applications in data analysis, financial modeling, and other fields. </tr><tr><td>Stock trading:</td> Kadane's algorithm can be used to find the maximum profit that can be made by buying and selling a stock on a given day. The input to the algorithm is an array of stock prices, and the output is the maximum profit that can be made by buying and selling the stock at different times. </tr><tr><td>Image processing:</td> Kadane's algorithm can be used in image processing applications to find the largest contiguous area of pixels that meet a certain condition, such as having a certain color or brightness. This can be useful for tasks such as object recognition and segmentation. </tr><tr><td>DNA sequencing:</td> Kadane's algorithm can be used in bioinformatics to find the longest subsequence of DNA that meets certain conditions. For example, it can be used to find the longest common subsequence between two DNA sequences or to find the longest subsequence that does not contain certain patterns. </tr><tr><td>Machine learning:</td> Kadane's algorithm can be used in some machine learning applications, such as reinforcement learning and dynamic programming, to find the optimal policy or action sequence that maximizes a reward function. </tr></ul> <p>Therefore, we can say the advantages of Kadane's Algorithm make it a great solution for solving the maximum subarray problem, especially for large datasets. However, its limitations must be considered when using it for specific applications.</p> <hr></n;></pre></n;i++){> Kodimplementering i C++:
#include using namespace std; int main() { int a[] = { -2, -3, 4, -1, -2, 1, 5, -3 }; int n = sizeof(a) / sizeof(a[0]); // Kadane's algorithm int max_so_far = INT_MIN, max_ending_here = 0; for (int i = 0; i <n; i++) { max_ending_here="max_ending_here" + a[i]; if (max_so_far < max_ending_here) max_so_far="max_ending_here;" (max_ending_here 0) } cout << \'maximum contiguous sum in the array is : \'<<max_so_far<<endl; return 0; pre> <p> <strong>Output</strong> </p> <pre> Maximum contiguous sum in the array is : 7 </pre> <h2>Advantages and Disadvantages of Kadane's algorithm:</h2> <h3>Advantages of Kadane's Algorithm:</h3> <ul> <tr><td>Efficiency:</td> Kadane's Algorithm has a time complexity of O(n), which makes it very efficient for solving the maximum subarray problem. This makes it a great solution for large datasets. </tr><tr><td>Simplicity:</td> Kadane's Algorithm is relatively easy to understand and implement compared to other algorithms for solving the maximum subarray problem, such as the divide-and-conquer algorithm. </tr><tr><td>Space Complexity:</td> Kadane's Algorithm has a space complexity of O(1), which means it uses a constant amount of memory irrespective of the size of the input array. </tr><tr><td>Dynamic Programming:</td> Kadane's Algorithm is a classic example of dynamic programming, a technique that breaks down a problem into smaller subproblems and stores the solutions to these subproblems to avoid redundant computation. </tr></ul> <h3>Disadvantages of Kadane's Algorithm:</h3> <ul> <tr><td>Only finds sum and not the subarray itself:</td> Kadane's Algorithm only finds the maximum sum of the subarray and not the actual subarray itself. If you need to find the subarray that has the maximum sum, you will need to modify the algorithm accordingly. </tr><tr><td>Does not handle negative numbers well:</td> If an input array has only negative numbers, the algorithm will return the maximum negative number instead of 0. This can be overcome by adding an additional step to the algorithm to check if the array has only negative numbers. </tr><tr><td>Not suitable for non-contiguous subarrays:</td> Kadane's Algorithm is specifically designed for contiguous subarrays and may not be suitable for solving problems that involve non-contiguous subarrays. </tr></ul> <h2>Applications of Kadane's algorithm:</h2> <p>There are some of its applications like the following:</p> <ul> <tr><td>Maximum subarray sum:</td> As we saw in the example above, Kadane's algorithm is used to find the maximum subarray sum of an array of integers. This is a common problem in computer science and has applications in data analysis, financial modeling, and other fields. </tr><tr><td>Stock trading:</td> Kadane's algorithm can be used to find the maximum profit that can be made by buying and selling a stock on a given day. The input to the algorithm is an array of stock prices, and the output is the maximum profit that can be made by buying and selling the stock at different times. </tr><tr><td>Image processing:</td> Kadane's algorithm can be used in image processing applications to find the largest contiguous area of pixels that meet a certain condition, such as having a certain color or brightness. This can be useful for tasks such as object recognition and segmentation. </tr><tr><td>DNA sequencing:</td> Kadane's algorithm can be used in bioinformatics to find the longest subsequence of DNA that meets certain conditions. For example, it can be used to find the longest common subsequence between two DNA sequences or to find the longest subsequence that does not contain certain patterns. </tr><tr><td>Machine learning:</td> Kadane's algorithm can be used in some machine learning applications, such as reinforcement learning and dynamic programming, to find the optimal policy or action sequence that maximizes a reward function. </tr></ul> <p>Therefore, we can say the advantages of Kadane's Algorithm make it a great solution for solving the maximum subarray problem, especially for large datasets. However, its limitations must be considered when using it for specific applications.</p> <hr></n;> Fördelar och nackdelar med Kadanes algoritm:
Fördelar med Kadanes algoritm:
Nackdelar med Kadanes algoritm:
Tillämpningar av Kadanes algoritm:
Det finns några av dess applikationer som följande:
Därför kan vi säga att fördelarna med Kadanes algoritm gör den till en utmärkt lösning för att lösa problemet med maximal subarray, speciellt för stora datamängder. Dess begränsningar måste dock beaktas när den används för specifika applikationer.