format code

Author: Guhapriya01

src/main/java/com/thealgorithms/dynamicprogramming/MaximumSumOfNonAdjacentElements.java

@@ -7,81 +7,81 @@
  * For more information, refer to https://takeuforward.org/data-structure/maximum-sum-of-non-adjacent-elements-dp-5/
  */
 final class MaximumSumOfNonAdjacentElements {
-	private MaximumSumOfNonAdjacentElements() {
-	}
-
-	/**
-	 * Approach 1: Uses a dynamic programming array to store the maximum sum at each
-	 * index.
-	 * Time Complexity: O(n) - where n is the length of the input array. Space
-	 * Complexity: O(n) - due to the additional dp array.
-	 * @param arr The input array of integers.
-	 * @return The maximum sum of non-adjacent elements.
-	 */
-	public static int getMaxSumApproach1(int[] arr) {
-		int n = arr.length;
-		int[] dp = new int[n];
-
-		// Base case: Maximum sum if only one element is present.
-		dp[0] = arr[0];
-
-		for (int ind = 1; ind < n; ind++) {
-
-			// Case 1: Do not take the current element, carry forward the previous max sum.
-			int notTake = dp[ind - 1];
-
-			// Case 2: Take the current element, add it to the max sum up to two indices
-			// before.
-			int take = arr[ind];
-			if (ind > 1) {
-				take += dp[ind - 2];
-			}
-
-			// Store the maximum of both choices in the dp array.
-			dp[ind] = Math.max(take, notTake);
-		}
-
-		return dp[n - 1];
-	}
-
-	/**
-	 * Approach 2: Optimized space complexity approach using two variables instead
-	 * of an array.
-	 * Time Complexity: O(n) - where n is the length of the input array. Space
-	 * Complexity: O(1) - as it only uses constant space for two variables.
-	 * @param arr The input array of integers.
-	 * @return The maximum sum of non-adjacent elements.
-	 */
-	public static int getMaxSumApproach2(int[] arr) {
-		int n = arr.length;
-
-		// Two variables to keep track of previous two results:
-		// prev1 = max sum up to the last element (n-1)
-		// prev2 = max sum up to the element before last (n-2)
-
-		int prev1 = arr[0]; // Base case: Maximum sum for the first element.
-		int prev2 = 0;
-
-		for (int ind = 1; ind < n; ind++) {
-
-			// Case 1: Do not take the current element, keep the last max sum.
-			int notTake = prev1;
-
-			// Case 2: Take the current element and add it to the result from two steps
-			// back.
-			int take = arr[ind];
-			if (ind > 1) {
-				take += prev2;
-			}
-
-			// Calculate the current maximum sum and update previous values.
-			int current = Math.max(take, notTake);
-
-			// Shift prev1 and prev2 for the next iteration.
-			prev2 = prev1;
-			prev1 = current;
-		}
-
-		return prev1;
-	}
+  private MaximumSumOfNonAdjacentElements() {
+  }
+  
+  /** 
+   * Approach 1: Uses a dynamic programming array to store the maximum sum at each
+   * index.
+   * Time Complexity: O(n) - where n is the length of the input array. Space
+   * Complexity: O(n) - due to the additional dp array.
+   * @param arr The input array of integers.
+   * @return The maximum sum of non-adjacent elements.
+   */
+  public static int getMaxSumApproach1(int[] arr) {
+	  int n = arr.length;
+	  int[] dp = new int[n];
+
+	  // Base case: Maximum sum if only one element is present.
+	  dp[0] = arr[0];
+
+	  for (int ind = 1; ind < n; ind++) {
+
+		  // Case 1: Do not take the current element, carry forward the previous max sum.
+		  int notTake = dp[ind - 1];
+
+		  // Case 2: Take the current element, add it to the max sum up to two indices
+		  // before.
+		  int take = arr[ind];
+		  if (ind > 1) {
+			  take += dp[ind - 2];
+		  }
+
+		  // Store the maximum of both choices in the dp array.
+		  dp[ind] = Math.max(take, notTake);
+	  }
+
+	  return dp[n - 1];
+  }
+
+  /**
+   * Approach 2: Optimized space complexity approach using two variables instead
+   * of an array.
+   * Time Complexity: O(n) - where n is the length of the input array. Space
+   * Complexity: O(1) - as it only uses constant space for two variables.
+   * @param arr The input array of integers.
+   * @return The maximum sum of non-adjacent elements.
+   */
+  public static int getMaxSumApproach2(int[] arr) {
+	  int n = arr.length;
+
+	  // Two variables to keep track of previous two results:
+	  // prev1 = max sum up to the last element (n-1)
+	  // prev2 = max sum up to the element before last (n-2)
+
+	  int prev1 = arr[0]; // Base case: Maximum sum for the first element.
+	  int prev2 = 0;
+
+	  for (int ind = 1; ind < n; ind++) {
+		  
+		  // Case 1: Do not take the current element, keep the last max sum.
+		  int notTake = prev1;
+
+		  // Case 2: Take the current element and add it to the result from two steps
+		  // back.
+		  int take = arr[ind];
+		  if (ind > 1) {
+			  take += prev2;
+		  }
+
+		  // Calculate the current maximum sum and update previous values.
+		  int current = Math.max(take, notTake);
+
+		  // Shift prev1 and prev2 for the next iteration.
+		  prev2 = prev1;
+		  prev1 = current;
+	  }
+
+	  return prev1;
+  }
 }