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

1709973770081.png

K làm live contest được, nay rảnh ngồi làm hết mấy bài trong 2 contest gần đây.
Cái bài 3068 làm mãi không ra đọc solution muốn đập bàn, :ah:
 
Cứu với ae :ah: sao cách giải của mình nó TLE nhỉ, rõ ràng code chỉ có O 5*n mà ta :ah:
Python:
class Solution:
    def placedCoins(self, edges: List[List[int]], cost: List[int]) -> List[int]:
        n = len(edges) + 1
        coins = [1] * n
        graph = defaultdict(list)
      
        for edge in edges:
            graph[edge[0]].append(edge[1])
            graph[edge[1]].append(edge[0])
          
        def dfs(node, parent):
            def getCoins(items):
                min1 = inf
                min2 = inf
                max1 = -inf
                max2 = -inf
                max3 = -inf
                for item in items:
                    if item >= max1:
                        max3 = max2
                        max2 = max1
                        max1 = item
                    elif item >= max2:
                        max3 = max2
                        max2 = item
                    elif item >= max3:
                        max3 = item

                    if item <= min1:
                        min2 = min1
                        min1 = item
                    elif item <= min2:
                        min2 = item

                return [min2, min1, max3, max2, max1]
          
            items = [cost[node]]
            for neighbor in graph[node]:
                if neighbor != parent:
                    items += dfs(neighbor, node)

            if len(items) >= 3:
                ans = getCoins(items)
                coins[node] = max(ans[0] * ans[1] * ans[4], ans[2] * ans[3] * ans[4], 0)

            return items

        dfs(0, -1)
        return coins
À hiểu rồi, chắc concat nó lại thành ra On^2 cmnr, cay thật để optimize lại
Viết kiểu này lại pass ko hiểu kiểu gì ta? sao hàm sort lại nhanh hơn O(n) nhỉ, hay là do merge sort Ologn nhanh hơn

Python:
from collections import defaultdict
from math import inf
from typing import List

class Solution:
    def placedCoins(self, edges: List[List[int]], cost: List[int]) -> List[int]:
        n = len(edges) + 1
        coins = [1] * n
        graph = defaultdict(list)
        
        for edge in edges:
            graph[edge[0]].append(edge[1])
            graph[edge[1]].append(edge[0])
            
        def dfs(node, parent):
            items = [cost[node]]
            for neighbor in graph[node]:
                if neighbor != parent:
                    items += dfs(neighbor, node)
            
            items = sorted(items)
            if len(items) >= 3:
                coins[node] = max(0, items[-1] * max(items[0] * items[1], items[-3] * items[-2]))

            return items

        dfs(0, -1)
        return coins
 
Last edited:
Câu cuối Gang vcl, n*k < 10^6 nhưng mà phải làm là disjoin sub array thì sao mà làm dp =((
Có trick gì ở đây à ta =(( khó ăn vl huhu
 
1710042339074.png

Thôi rank này tạm hài lòng, câu 3 đáng lẽ làm rất nhanh mà debug tào lao quá =(( câu 4 bỏ cuộc rồi chịu thua
 
Câu cuối Gang vcl, n*k < 10^6 nhưng mà phải làm là disjoin sub array thì sao mà làm dp =((
Có trick gì ở đây à ta =(( khó ăn vl huhu
em ms nghĩ đến đoạn tách ra các mảng toàn dương và toàn âm. nhưng mà lúc sau lại sai logic nên thôi :sweat:
 
em ms nghĩ đến đoạn tách ra các mảng toàn dương và toàn âm. nhưng mà lúc sau lại sai logic nên thôi :sweat:
Mình tính làm kiểu quy hoạch động (k, nums.size()). Nhưng nếu làm thế thì Time complexity : O(n* nums.size() * nums.size()) thì sẽ bị TLE ngay cả khi đã tính prefix sum. Mình cố nghĩ cách để optimize mà không ra.
 
Mình tính làm kiểu quy hoạch động (k, nums.size()). Nhưng nếu làm thế thì Time complexity : O(n* nums.size() * nums.size()) thì sẽ bị TLE ngay cả khi đã tính prefix sum. Mình cố nghĩ cách để optimize mà không ra.
Nếu như DP k, nums.size() thì vô tư vì constrain nói rõ là <= 10^6
Nhưng mà ko tìm ra state transition thôi fence ơi =((
 
Back
Top