080523

Author: aluferraz

src/Main.java

@@ -5,6 +5,7 @@
 import leetcode.editor.en.Q188.BestTimeToBuyAndSellStockIv;
 import leetcode.editor.en.Q1964.FindTheLongestValidObstacleCourseAtEachPosition;
 import leetcode.editor.en.Q2466.CountWaysToBuildGoodStrings;
+import leetcode.editor.en.Q311.SparseMatrixMultiplication;
 import leetcode.editor.en.Q354.RussianDollEnvelopes;
 import leetcode.editor.en.Q377.CombinationSumIv;
 import leetcode.editor.en.Q474.OnesAndZeroes;
@@ -24,7 +25,7 @@
 
 public class Main {
     public static void main(String[] args) throws IOException {
-        System.out.println(new DecodeWays().numDecodings("230"));
+        System.out.println(Arrays.deepToString(new SparseMatrixMultiplication().multiply(toIntMatrix("[[1,-5]]"), toIntMatrix("[[12],[-1]]"))));
 
     }
 

src/leetcode/editor/en/Q1572/MatrixDiagonalSum.java

@@ -0,0 +1,79 @@
+package leetcode.editor.en.Q1572;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//Given a square matrix mat, return the sum of the matrix diagonals. 
+//
+// Only include the sum of all the elements on the primary diagonal and all the 
+//elements on the secondary diagonal that are not part of the primary diagonal. 
+//
+// 
+// Example 1: 
+// 
+// 
+//Input: mat = [[1,2,3],
+//              [4,5,6],
+//              [7,8,9]]
+//Output: 25
+//Explanation: Diagonals sum: 1 + 5 + 9 + 3 + 7 = 25
+//Notice that element mat[1][1] = 5 is counted only once.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: mat = [[1,1,1,1],
+//              [1,1,1,1],
+//              [1,1,1,1],
+//              [1,1,1,1]]
+//Output: 8
+// 
+//
+// Example 3: 
+//
+// 
+//Input: mat = [[5]]
+//Output: 5
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// n == mat.length == mat[i].length 
+// 1 <= n <= 100 
+// 1 <= mat[i][j] <= 100 
+// 
+//
+// 👍 2392 👎 31
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int diagonalSum(int[][] mat) {
+        boolean[][] visited = new boolean[mat.length][mat[0].length];
+        return sum(mat, visited, 0, 0, 1, 1) + sum(mat, visited, 0, mat[0].length - 1, 1, -1);
+    }
+
+    private int sum(int[][] mat, boolean[][] visited, int row, int col, int rSum, int cSum) {
+        if (!isValidIdx(row, col, mat)) return 0;
+
+        if (visited[row][col]) {
+            return sum(mat, visited, row + rSum, col + cSum, rSum, cSum);
+        }
+
+        visited[row][col] = true;
+        return mat[row][col] + sum(mat, visited, row + rSum, col + cSum, rSum, cSum);
+    }
+
+    private boolean isValidIdx(int row, int col, int[][] grid) {
+        return row >= 0 && row < grid.length && col >= 0 && col < grid[row].length;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class MatrixDiagonalSum extends Solution {
+}

src/leetcode/editor/en/Q256/PaintHouse.java

@@ -0,0 +1,56 @@
+package leetcode.editor.en.Q256;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    Integer[][] cache;
+
+    public int minCost(int[][] costs) {
+        cache = new Integer[costs.length][4];
+        return minCost(0, 3, costs);
+    }
+
+    public int minCost(int i, int cantBe, int[][] costs) {
+        if (i == costs.length) return 0;
+        int red = costs[i][0];
+        int blue = costs[i][1];
+        int green = costs[i][2];
+
+        int ans = 0;
+        if (cache[i][cantBe] != null) {
+            return cache[i][cantBe];
+        }
+
+        int useRed = red + minCost(i + 1, 0, costs);
+        int useBlue = blue + minCost(i + 1, 1, costs);
+        int useGreen = green + minCost(i + 1, 2, costs);
+
+        switch (cantBe) {
+            case 0 -> {
+                ans = Math.min(useGreen, useBlue);
+            }
+            case 1 -> {
+                ans = Math.min(useRed, useGreen);
+            }
+            case 2 -> {
+                ans = Math.min(useRed, useBlue);
+            }
+            default -> {
+                ans = Math.min(useRed, useBlue);
+                ans = Math.min(ans, useGreen);
+            }
+        }
+        cache[i][cantBe] = ans;
+
+        return ans;
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class PaintHouse extends Solution {
+}

src/leetcode/editor/en/Q311/SparseMatrixMultiplication.java

@@ -0,0 +1,26 @@
+package leetcode.editor.en.Q311;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int[][] multiply(int[][] mat1, int[][] mat2) {
+        int[][] ans = new int[mat1.length][mat2[0].length];
+        for (int i = 0; i < ans.length; i++) {
+            for (int j = 0; j < ans[i].length; j++) {
+                for (int k = 0; k < mat1[0].length; k++) {
+                    ans[i][j] += (mat1[i][k] * mat2[k][j]);
+                }
+            }
+        }
+        return ans;
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class SparseMatrixMultiplication extends Solution {
+}