add 336;583;647;680;696;763;807

Author: leopsidom

336.palindrome-pairs.rs

@@ -0,0 +1,14 @@
+/*
+ * @lc app=leetcode id=336 lang=rust
+ *
+ * [336] Palindrome Pairs
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn palindrome_pairs(words: Vec<String>) -> Vec<Vec<i32>> {
+        
+    }
+}
+// @lc code=end
+

583.delete-operation-for-two-strings.rs

@@ -0,0 +1,37 @@
+/*
+ * @lc app=leetcode id=583 lang=rust
+ *
+ * [583] Delete Operation for Two Strings
+ */
+
+// @lc code=start
+use std::cmp;
+
+impl Solution {
+    pub fn min_distance(word1: String, word2: String) -> i32 {
+        let chars1 = word1.chars().collect::<Vec<char>>();
+        let chars2 = word2.chars().collect::<Vec<char>>();
+
+        let l1 = chars1.len();
+        let l2 = chars2.len();
+
+        let mut dp = vec![vec![0; l2+1]; l1+1];
+
+        for i in 0..l1+1 {
+            for j in 0..l2+1 {
+                if i == 0 || j == 0 {
+                    dp[i][j] = 0;
+                } else if chars1[i-1] == chars2[j-1] {
+                    dp[i][j] = 1 + dp[i-1][j-1];
+                } else {
+                    dp[i][j] = cmp::max(dp[i-1][j], dp[i][j-1]);
+                }
+            }
+        }
+
+        // println!("{:?}", dp);
+        (l1 + l2) as i32 - 2 * dp[l1][l2]
+    }
+}
+// @lc code=end
+

647.palindromic-substrings.rs

@@ -0,0 +1,29 @@
+/*
+ * @lc app=leetcode id=647 lang=rust
+ *
+ * [647] Palindromic Substrings
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn count_substrings(s: String) -> i32 {
+        let chars = s.chars().collect::<Vec<char>>();
+        let N = chars.len();
+
+        let mut ans = 0;
+        let mut dp = vec![vec![false; N]; N];
+
+        for j in 0..N {
+            for i in (0..j+1).rev() {
+                if chars[i] == chars[j] && (i as i32 + 1 >= j as i32 - 1 || dp[i+1][j-1]) {
+                    ans += 1;
+                    dp[i][j] = true;
+                }
+            }
+        }
+        
+        ans
+    }
+}
+// @lc code=end
+

680.valid-palindrome-ii.rs

@@ -0,0 +1,45 @@
+/*
+ * @lc app=leetcode id=680 lang=rust
+ *
+ * [680] Valid Palindrome II
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn valid_palindrome(s: String) -> bool {
+        let chars = s.chars().collect::<Vec<char>>();
+        let N = chars.len();
+
+        if N <= 1 { return true; }
+        let mut i = 0;
+
+        while i < N / 2 {
+            if chars[i] != chars[N - i - 1] {
+                return Self::is_palindrome(&chars[i..N-i-1]) || Self::is_palindrome(&chars[i+1..N-i]);
+            }
+            i += 1;
+        }
+
+        return true;
+    }
+
+    pub fn is_palindrome(chars: &[char]) -> bool {
+        // let chars = s.chars().collect::<Vec<char>>();
+        let N = chars.len();
+
+        if N <= 1 { return true; }
+
+        let mut i = 0;
+
+        while i < N / 2 {
+            if chars[i] != chars[N - i - 1] {
+                return false;
+            }
+            i += 1;
+        }
+
+        return true;
+    }
+}
+// @lc code=end
+

696.count-binary-substrings.rs

@@ -0,0 +1,35 @@
+/*
+ * @lc app=leetcode id=696 lang=rust
+ *
+ * [696] Count Binary Substrings
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn count_binary_substrings(s: String) -> i32 {
+        let chars = s.chars().collect::<Vec<char>>();
+        let N = chars.len();
+
+        if N <= 1 { return 0; }
+        let mut ans = 0;
+
+        for i in 0..N-1 {
+            if (chars[i] == '0' && chars[i+1] == '1') ||
+               (chars[i] == '1' && chars[i+1] == '0') {
+                   let mut k = 1;
+                   while i + k < N && i as i32 - k as i32 + 1 >= 0 {
+                       if chars[i+k] == chars[i+1] && chars[i-k+1] == chars[i] {
+                           k += 1;
+                           ans += 1;
+                       } else {
+                           break;
+                       }
+                   }
+               }
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

763.partition-labels.rs

@@ -0,0 +1,56 @@
+/*
+ * @lc app=leetcode id=763 lang=rust
+ *
+ * [763] Partition Labels
+ */
+
+// @lc code=start
+use std::cmp;
+
+impl Solution {
+    pub fn partition_labels(s: String) -> Vec<i32> {
+        let chars = s.chars().collect::<Vec<char>>();
+
+        let N = chars.len();
+
+        let mut ranges = vec![vec![-1, -1]; 26];
+
+        for i in 0..N {
+            let ord = chars[i] as usize - 'a' as usize;
+            if ranges[ord][0] == -1 {
+                ranges[ord][0] = i as i32;
+                ranges[ord][1] = i as i32;
+            } else {
+                ranges[ord][1] = i as i32;
+            }
+        }
+
+        ranges.sort_by_key(|k| k[0]);
+
+        let mut curr_end = -1;
+        let mut ans = vec![];
+
+        for v in ranges {
+            if v[0] >= 0 {
+                if curr_end < v[0] {
+                    ans.push(v[0]);
+                }
+                curr_end = cmp::max(curr_end, v[1]);
+            }
+        }
+
+        if ans[ans.len() - 1] < N as i32 {
+            ans.push(N as i32);
+        }
+
+        let mut ans1 = vec![];
+
+        for i in 1..ans.len() {
+            ans1.push(ans[i] - ans[i-1]);
+        }
+
+        ans1
+    }
+}
+// @lc code=end
+

807.max-increase-to-keep-city-skyline.rs

@@ -0,0 +1,38 @@
+/*
+ * @lc app=leetcode id=807 lang=rust
+ *
+ * [807] Max Increase to Keep City Skyline
+ */
+
+// @lc code=start
+use std::cmp;
+
+impl Solution {
+    pub fn max_increase_keeping_skyline(grid: Vec<Vec<i32>>) -> i32 {
+        let R = grid.len();
+        if R == 0 { return 0; }
+        let C = grid[0].len();
+
+        let mut top_bottom_view = vec![0; C];
+        let mut left_right_view = vec![0; R];
+
+        for i in 0..R {
+            for j in 0..C {
+                top_bottom_view[j] = cmp::max(top_bottom_view[j], grid[i][j]);
+                left_right_view[i] = cmp::max(left_right_view[i], grid[i][j]);
+            }
+        }
+
+        let mut ans = 0;
+
+        for i in 0..R {
+            for j in 0..C {
+                ans += cmp::min(top_bottom_view[j], left_right_view[i]) - grid[i][j];
+            }
+        }
+
+        ans
+    }
+}
+// @lc code=end
+