thảo luận Leetcode mỗi ngày

Dạo này em cũng có nghịch LC, các bác có thể cho em hỏi là nếu muốn improve khả năng giải thuật thì mình nên follow topic theo thứ tự ntn ạ? Trước mắt thì em đang nghịch gần xong topic arrays 101.
 

Attachments

  • Screen Shot 2022-06-27 at 11.22.12.png
    Screen Shot 2022-06-27 at 11.22.12.png
    317.3 KB · Views: 46
Dạo này em cũng có nghịch LC, các bác có thể cho em hỏi là nếu muốn improve khả năng giải thuật thì mình nên follow topic theo thứ tự ntn ạ? Trước mắt thì em đang nghịch gần xong topic arrays 101.

Cứ filter theo mức Easy rồi nhấn Pick One để nó random ra 1 bài làm thôi thím. Đừng làm theo topic, vì làm được 1 bài qua bài sau nó sẽ ná ná như vậy => chưa chắc sẽ giúp thím nhớ lâu
 
Có 1 bài cũng trick tương tự như bài hôm nay nè, tôi đánh giá khá hay, nếu đem đi PV có thể test ứng viên từ mức độ dễ nâng dần đến mức độ khó
https://leetcode.com/problems/remove-palindromic-subsequences/

Mặc dù bài này Easy, các thím có thể mở rộng ra:
  • Nếu chuỗi s có 3 ký tự a, b, c
  • Nếu chuỗi s có 4 ký tự a, b, c, d
  • Néu chuỗi s có K ký tự a, b, c, d, ..., k
Screen Shot 2022-06-27 at 16.34.49.png

Java ảo vãi cả nồi
Ý tưởng là:
  • Nếu rỗng, return 0
  • Tạo StringBuilder để reverse string input
Nếu bằng thì return 1, không thì return 2 :p

Bài này same same bài số 5 và 9, xài lại
 
Last edited:
27/6/2022:
  • 1 bài khá xàm lol
  • Vì số n là tổng các số nhị phân nên cứ mỗi lần ta giảm 1 đơn vị cho 1 chữ số, nếu là chữ số 0 thì ko giảm -> mỗi lần giảm sẽ tạo đc 1 số nhị phân, giảm cho đến khi ra số 0 -> số lần giảm ít nhất là chữ số lớn nhất
  • VD: số "5213"
"5241" -> "4130" + "1111"
"4130" -> "3010" + "1110"
"3010" -> "2000"+ "1010"
"2000"-> "1000" +"1000"
"1000"-> "0000" +"1000"
Ơ bài này trước pvan ở cty ở HCM nè :LOL:))
Java:
public int minPartitions(String n) {
        int max = -1;
        int length = n.length();
        for (int i = 0; i < length; i++) {
            // Check the gaps
            int tempNumWithCharAt = n.charAt(i) - '0';
            max = Math.max(tempNumWithCharAt, max);
        }
        return max;
    }
 
28/6/2022:
  • 1 câu medium nhẹ nhàng
  • 1 string tốt khi ko có 2 kí tự nào cùng tần số, bỏ ít nhất các kí tự để string thành 1 string tốt -> chỉ cần quan tâm số lần lặp của mỗi kí tự.
  • tạo 1 mảng lưu số lần lặp các kí tự, vì kí tự thường nên mảng chỉ cần 26 phần tử
  • Như vậy thấy lúc này đề bài tương đương số lần giảm 1 đơn vị cho mỗi số sao cho dãy ko có 2 số nào giống nhau. Dãy ở đây chính là dãy lưu các lần lặp của kí tự
  • VD {4, 2, 5, 4, 2} -> {3, 1, 5, 4, 2}, cần giảm 2 đơn vị
  • Để làm vậy, sort mảng: {4, 2, 5, 4, 2} -> {5, 4, 4, 2, 2}
  • xét từ lớn nhất -> bé nhất, giảm số tại vị trí i sao cho nó phải nhỏ hơn số trước, lấy cái số giảm đó cộng vào result
-> ra đáp án
  • Time: O(n) + O(26log26)
  • Code: https://leetcode.com/submissions/detail/732992116/
  • Hôm qua thức đến 1h30 sáng nên sáng dậy hơi bê, mất 10p để nghĩ ra ý tưởng, lúc đầu còn đọc đề sai, mất thêm 10p nữa để code và 1 lần submit sai :tire::tire:
 
Cũng làm gần giống như thím Violet nhưng dùng HashSet để check cho nó nhẹ nhàng đơn giản:sweet_kiss:

C#:
public class Solution {
    public int MinDeletions(string s) {
        int[] count = new int['z'-'a'+1];
        foreach (char c in s)
            count[c-'a']++;
        Array.Sort(count);
        HashSet<int> frequency = new ();
        int ret = 0;
        for (var i = 0; i < count.Length; i++)
        {
            while (count[i] > 0 && frequency.Contains(count[i]))
            {
                count[i]--;
                ret++;
            }
            frequency.Add(count[i]);
        }
        return ret;
    }
}
 
Cũng làm gần giống như thím Violet nhưng dùng HashSet để check cho nó nhẹ nhàng đơn giản:sweet_kiss:

C#:
public class Solution {
    public int MinDeletions(string s) {
        int[] count = new int['z'-'a'+1];
        foreach (char c in s)
            count[c-'a']++;
        Array.Sort(count);
        HashSet<int> frequency = new ();
        int ret = 0;
        for (var i = 0; i < count.Length; i++)
        {
            while (count[i] > 0 && frequency.Contains(count[i]))
            {
                count[i]--;
                ret++;
            }
            frequency.Add(count[i]);
        }
        return ret;
    }
}
cùng idea với thím :byebye:
 
Cũng làm gần giống như thím Violet nhưng dùng HashSet để check cho nó nhẹ nhàng đơn giản:sweet_kiss:

C#:
public class Solution {
    public int MinDeletions(string s) {
        int[] count = new int['z'-'a'+1];
        foreach (char c in s)
            count[c-'a']++;
        Array.Sort(count);
        HashSet<int> frequency = new ();
        int ret = 0;
        for (var i = 0; i < count.Length; i++)
        {
            while (count[i] > 0 && frequency.Contains(count[i]))
            {
                count[i]--;
                ret++;
            }
            frequency.Add(count[i]);
        }
        return ret;
    }
}
Em thấy cái của bác không cần phải sort ấy :p
em cũng tương tự bác, Java 100% https://leetcode.com/submissions/detail/733055071/ :love:
 
Nhưng trong trường hợp n nhỏ thì dùng HashSet sẽ đỡ phải sort cái mảng 26 phần tử có khi sẽ tốt hơn.
  • dùng hashset chỉ tốt hơn khi ít các phần tử trùng lặp, vd mảng 26 số 100 -> mất 100*99/2 lần đếm-> còn cách sort thì time luôn luôn là 26log26 lần.
  • câu này cx khá giống câu hôm nay, nhưng giá trị phần tử lớn hơn và size cx lớn hơn: https://leetcode.com/problems/minimum-increment-to-make-array-unique/.
 
Instead of learning solutions of LeetCode questions, understand patterns! 🙂

For ex.

If input array is sorted then
  • Binary search
  • Two pointers

If asked for all permutations/subsets then
- Backtracking

If given a tree then
  • DFS
  • BFS

If given a graph then
  • DFS
  • BFS

If given a linked list then
- Two pointers

If recursion is banned then
- Stack

If must solve in-place then
  • Swap corresponding values
  • Store one or more different values in the same pointer

If asked for maximum/minimum subarray/subset/options then
- Dynamic programming

If asked for top/least K items then
- Heap

If asked for common strings then
  • Map
  • Trie

Else
  • Map/Set for O(1) time & O(n) space
  • Sort input for O(nlogn) time and O(1) space
 
Back
Top