Sponsored
Sponsored
In this approach, we'll use dynamic programming (DP) to achieve the solution. We'll start from the bottom of the triangle and minimize the sum path to the top. We'll keep updating the path sum in a DP array as we move to the top row.
Time Complexity: O(n^2), where n is the number of rows in the triangle.
Space Complexity: O(n), due to the use of the array dp.
1import java.util.List;
2
3class Solution {
4 public int minimumTotal(List<List<Integer>> triangle) {
5 int[] dp = new int[triangle.size()];
6 for (int i = 0; i < triangle.get(triangle.size() - 1).size(); i++) {
7 dp[i] = triangle.get(triangle.size() - 1).get(i);
8 }
9 for (int row = triangle.size() - 2; row >= 0; row--) {
10 for (int col = 0; col < triangle.get(row).size(); col++) {
11 dp[col] = triangle.get(row).get(col) + Math.min(dp[col], dp[col + 1]);
12 }
13 }
14 return dp[0];
15 }
16
17 public static void main(String[] args) {
18 Solution sol = new Solution();
19 List<List<Integer>> triangle = List.of(
20 List.of(2), List.of(3, 4), List.of(6, 5, 7), List.of(4, 1, 8, 3)
21 );
22 System.out.println(sol.minimumTotal(triangle));
23 }
24}The Java solution iterates from the triangle's bottom row to the top, minimizing path sums. We store temporary results in a 1D array dp, updating values based on current and next possibilities.
This approach uses a top-down strategy with memoization to store already computed results, avoiding redundant calculations. Each recursive call stores the minimum path sum starting from the current index down to the base of the triangle.
Time Complexity: O(n^2) (due to memoization)
Space Complexity: O(n^2) for memoization storage.
1#include <vector>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int memo[201][201];
class Solution {
public:
int dfs(int row, int col, vector<vector<int>>& triangle) {
if (row == triangle.size()) return 0;
if (memo[row][col] != -1) return memo[row][col];
int left = dfs(row + 1, col, triangle);
int right = dfs(row + 1, col + 1, triangle);
memo[row][col] = triangle[row][col] + min(left, right);
return memo[row][col];
}
int minimumTotal(vector<vector<int>>& triangle) {
memset(memo, -1, sizeof(memo));
return dfs(0, 0, triangle);
}
};
int main() {
Solution sol;
vector<vector<int>> triangle = {{2}, {3, 4}, {6, 5, 7}, {4, 1, 8, 3}};
cout << sol.minimumTotal(triangle) << endl;
return 0;
}C++ implementation uses recursion with memoization to compute minimum path sums from top to leaf nodes. dfs efficiently computes in bottom paths using the array memo to eliminate redundant calculations.