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

Nếu anh em nào code C++ quen thì sẽ k cần implement lại cái binary search nữa, cái đó có sẵn trong standard library rồi. Việc cần làm là xác định cận trên, cận dưới, và check function thôi.

Như dưới đây là lời giả cho bài: https://leetcode.com/problems/minimum-time-to-repair-cars/
K cần phải implement lại binary search nữa, :ah:
C++:
#include <ranges>
class Solution {
public:
    long long repairCars(vector<int>& ranks, int cars) {
        auto range = ranges::iota_view{0ll, (long long)cars*cars*(*ranges::min_element(ranks))};
        return *ranges::lower_bound(range, cars, [&ranks] (auto i, auto target) {
            auto ret = accumulate(ranks.begin(), ranks.end(), 0ll, [i] (auto acc, auto x) { return acc + sqrt(i/x); });
            return ret < target;
        });
    }
};
 
:confident:
có thấy khó hơn chút nào đâu fen
Java:
class Solution {
    public long repairCars(int[] ranks, int cars) { 
        long left = 1;
        long right = 0;
        for(int rank:ranks){
            right = Math.max(right,(long) rank * cars * cars);
        }
        while(left<right){
            long mid = left +(right-left)/2;
            if(condition(ranks, cars,mid)){
                right =mid;
            }
            else{
                left = mid+1;
            }
        }
        return left;
    }
    private boolean condition(int [] ranks, int cars, long time){
        for(int rank:ranks){
            cars-=(int)Math.sqrt((double)time/rank);
            if(cars<=0) return true;
        }
        return false;
    }
}
Trình khủng thật, mới đó mà giải BS như thái rau chém dưa rồi, để fen này trưởng thành thì khủng phải biết.

Ê mà từ khi chơi với fen reaction của mình từ 400 mấy xuống còn 140 cmnr :eek:
 
Trình khủng thật, mới đó mà giải BS như thái rau chém dưa rồi, để fen này trưởng thành thì khủng phải biết.

Ê mà từ khi chơi với fen reaction của mình từ 400 mấy xuống còn 140 cmnr :eek:
Chiều ngồi đọc cái còm ăn 1 rổ gạch của fen bên thớt mấy đứa nhỏ trong aeonmall mà cười ẻ. Đúng kiếm ưng 3 năm ăn gạch 1 giờ :v
 
Trình khủng thật, mới đó mà giải BS như thái rau chém dưa rồi, để fen này trưởng thành thì khủng phải biết.

Ê mà từ khi chơi với fen reaction của mình từ 400 mấy xuống còn 140 cmnr :eek:
:sweat: voz nhiều fen tàu ngầm lắm, contest 4q đều như vắt tranh ấy, đi khoe giải bài BS medium ngta còn đánh cho :beat_brick:
 
Code:
class Solution:
    def minDays(self, bloomDay: List[int], m: int, k: int) -> int:
        if m * k > len(bloomDay): return -1

        def isEnough(x):
            cnt = 0
            res = 0
            for i in range(len(bloomDay)):
                if x >= bloomDay[i]: cnt += 1
                else:
                    res += cnt // k
                    cnt = 0

            if cnt >= k : res += cnt // k

            return res >= m
        
        # find in (min , max)
        l , r = min(bloomDay) , max(bloomDay)
        res = -1
        while l <= r:
            mid = (l + r) // 2
            if isEnough(mid):
                res = mid
                r = mid - 1
            else: l = mid + 1
        
        return res
clm làm 30p mới xog trình cùi quá :ah:
 
Xin post vô gạch nó cái :sweet_kiss:


via theNEXTvoz for iPhone
 
Vl
ME1tJB0.gif
đi đâu cũng đừng nhận là member của topic nha @billy_don
zFNuZTA.gif



via theNEXTvoz for iPhone
 
Nếu anh em nào code C++ quen thì sẽ k cần implement lại cái binary search nữa, cái đó có sẵn trong standard library rồi. Việc cần làm là xác định cận trên, cận dưới, và check function thôi.

Như dưới đây là lời giả cho bài: https://leetcode.com/problems/minimum-time-to-repair-cars/
K cần phải implement lại binary search nữa, :ah:
C++:
#include <ranges>
class Solution {
public:
    long long repairCars(vector<int>& ranks, int cars) {
        auto range = ranges::iota_view{0ll, (long long)cars*cars*(*ranges::min_element(ranks))};
        return *ranges::lower_bound(range, cars, [&ranks] (auto i, auto target) {
            auto ret = accumulate(ranks.begin(), ranks.end(), 0ll, [i] (auto acc, auto x) { return acc + sqrt(i/x); });
            return ret < target;
        });
    }
};
Python cũng có lib cho BS ấy bác, dùng quen tay thấy tiện phết.

Python:
class Solution:
    def repairCars(self, ranks: List[int], cars: int) -> int:
        def check(time):
            return sum(int(math.sqrt(time / rank)) for rank in ranks) >= cars
        
        return bisect.bisect_left(range(max(ranks) * cars ** 2 + 1), x=True, key=check)
 
Mấy bài implement BS, lúc nào cũng thấy câu comment này:
"NEVER UNDERESTIMATE BINARY SEARCH !!!"
Đúng kiểu implement thì dễ, nhưng nghĩ ra được thì không phải dễ.
 
Python cũng có lib cho BS ấy bác, dùng quen tay thấy tiện phết.

Python:
class Solution:
    def repairCars(self, ranks: List[int], cars: int) -> int:
        def check(time):
            return sum(int(math.sqrt(time / rank)) for rank in ranks) >= cars
       
        return bisect.bisect_left(range(max(ranks) * cars ** 2 + 1), x=True, key=check)
Ngon đấy. Acc t k thả ưng đc, :ah:
 
Python:
class Solution:
    def maxDistance(self, position: List[int], m: int) -> int:
        position = sorted(position)
        n = len(position)
        def good(minimum):
            count = 0
            prev = position[0]
            for i in range(1, n):
                if position[i] - prev >= minimum:
                    count += 1
                    prev = position[i]

                if count + 1 == m:
                    return True

            return False
        
        left = 0
        right = position[-1] - position[0]

        ans = 0
        while left <= right:
            mid = left + (right - left)//2
            if good(mid):
                ans = mid
                left = mid + 1
            else:
                right = mid - 1

        return ans
 
Back
Top