thảo luận Leetcode contest, đường tới Guardian

  • Người tạo chủ đề Người tạo chủ đề freedom.9
  • Ngày bắt đầu Ngày bắt đầu
Trạng thái
Không mở để trả lời thêm.
Leetcode contest lần này được 3Q, còn Q4 thì bí rồi, không nghĩ ra được cách nào nhanh hơn O(n^2) hết :|
 
1729395447505.png

4Q 1 bug do lỡ thêm cái cache ko cần thiết ăn cái MLE :ah: đã quá pepsi ơi
 
Em cũng thế, làm Sàng nguyên tố 10^6 mà toàn TLE mấy TC bé tý. Mãi mới nghĩ chắc LC tính TLE dựa vào tổng thời gian chạy các TC, nên đến phần tử nào thì tìm cái proper divisor của nó luôn.
Ở mỗi số mình tìm max factor luôn, time complexity đoạn này là sqrt(num). Mình ko nghĩ tới xài sieve gì cả vì ko thấy usecases chỗ prime factor
 
Ở mỗi số mình tìm max factor luôn, time complexity đoạn này là sqrt(num). Mình ko nghĩ tới xài sieve gì cả vì ko thấy usecases chỗ prime factor
Đúng rồi bác, tại em làm theo lối mòn cứ có nguyên tố là bê cái sieve ra dùng thôi. Nay bác làm được Q4 thì lại gỡ được contest tuần trước.
 
Nay code ẩu ăn 2 con bọ không đáng có :(
Python:
class Solution:
    def findAnswer(self, parent: List[int], s: str) -> List[bool]:
        n = len(parent)
        children = defaultdict(list)

        base = 31
        MOD = 10 ** 9 + 7
        p = [1] * (n + 1)
        children_count = [0] * n

        

        for i in range(1, n+1):
            p[i] = (p[i-1] * base) % MOD
        

        for i, p_node in enumerate(parent):
            if p_node == -1:
                continue
            children[p_node].append(i)
        
        def count_children(node):
            children_count[node] = 1
            for child in children[node]:
                count_children(child)
                children_count[node] += children_count[child]
        count_children(0)
        
        hash_array = [0] * (n + 1)
        reversed_hash_array = [0] * (n + 1)

        def dfs(node):
            for child in children[node]:
                dfs(child)
                hash_array[node] = (hash_array[node] * p[children_count[child]] + hash_array[child]) % MOD
            hash_array[node] = (hash_array[node] * base + ord(s[node]) - ord('a')) % MOD

        def reverse_dfs(node):
            
            reversed_hash_array[node] = (ord(s[node]) - ord('a')) % MOD
            for child in reversed(children[node]):
                reverse_dfs(child)
                reversed_hash_array[node] = (reversed_hash_array[node] * p[children_count[child]] + reversed_hash_array[child]) % MOD
            
        dfs(0)
        reverse_dfs(0)

        # print(hash_array)
        # print(reversed_hash_array)

        return [hash_array[i] == reversed_hash_array[i] for i in range(n)]
 
mình xin điểm nhé bác :big_smile:
Câu 4 hay thật nhỉ, đi cái hash ngược left right top đi về top right left là ngon. Thấy học thêm được 1 cái variant mới ko đến nỗi khó lắm :beauty:

Đúng rồi bác, tại em làm theo lối mòn cứ có nguyên tố là bê cái sieve ra dùng thôi. Nay bác làm được Q4 thì lại gỡ được contest tuần trước.
Chắc mình bị rejudge rồi fence nhưng chắc vẫn cộng được mấy chục điểm, may làm q3 nhanh tay. Bài 4 hôm nay tính sai TC nữa rồi rút kinh nghiệm :too_sad:
via theNEXTvoz for iPhone
 
Giờ mình mới hiểu tại sao tụi nó hay random cái base cho rolling hash, lí do là để tránh gặp các anti testcases tạo ra các hash collision :sweat:
Hèn gì tụi nó xài rolling hash mượt mà ko sợ bị đụng

via theNEXTvoz for iPhone
 
Trạng thái
Không mở để trả lời thêm.

Thống kê chủ đề

Ngày tạo
freedom.9,
Người trả lời cuối
freedom.9,
Trả lời
2.480
Lượt xem
130.111
Quay lại
Lên đầu trang