thảo luận Leetcode + Codeforces, Competitive programming contest. Đường tới Guardian + Candidate Master.

  • Người tạo chủ đề Người tạo chủ đề freedom.9
  • Ngày bắt đầu Ngày bắt đầu
Cũng tại cơm áo gạo tiền, thấy mấy thằng khác giải nhanh quá mà nhìn ra cái trick kia nên chạy đi search solution, đoán kiểu gì cũng có sẵn trên google :doubt:
Gặp bài 3 constructive programming nhìn là thấy đái ra quần rồi =(( ghét mấy bài phong cách codeforces này quá
em đái ra máu luôn bác :v
 
Thì nó là đại số tuyến tính rồi chứ k còn là giải thuật nữa nên nếu k nhớ hoặc đã làm thì chịu chết. Tương tự các bài đếm mod 10 (cần dùng định lý lucas).
Mô hình hóa từ xor -> cộng vector F2 -> span tuyến tính mà. Nói chung k nhớ đstt là oẳng (nếu chưa từng làm)
 
:v ai cho em xin Q3 với, gap quá, làm không, không nhìn ra được cách chọn :(
  • 4 đội trở xuống: Không thể tạo lịch thỏa mãn đề bài, return mảng rỗng
  • 5 đội trở lên: Duyệt qua từng trường hợp: (away_team - home_team) % k = 1,2,3,..., n-1. home_team chạy vòng tròn từ 0 đến n-1. Trận nào có đội vừa đá trận trước thì tạm bỏ qua, nếu không thì thêm vào lịch. Khi nào đã thêm đủ các trận trong trường hợp thì chuyển sang trường hợp tiếp theo.
Python:
class Solution:
    def generateSchedule(self, n: int) -> List[List[int]]:
        if n <= 4:
            return []

        schedule = []
        for phase in range (1,n):
            played_home_matches = [False] * n
            remaining_matches = n

            home_team = 0
            while (remaining_matches > 0):
                if played_home_matches[home_team] == False:
                    away_team = (home_team + phase) % n
                    if len(schedule) == 0 or (home_team not in schedule[-1] and away_team not in schedule[-1]):
                        schedule.append([home_team, away_team])
                        played_home_matches[home_team] = True
                        remaining_matches -= 1

                home_team = (home_team + 1) % n

        return schedule
 
Xong 4Q :byebye:
1757820151259.png
 
Q3 quá dễ đi mà làm ẩu thật, đọc lộn đề nữa chứ cay quá :ah:
Q3 e thử DP mà fail từ test 200 =((
Python:
class Solution:
    def subsequenceSumAfterCapping(self, nums: List[int], k: int) -> List[bool]:
        n = len(nums)
        c = Counter(nums)
        res = [False] * n
        a = [False] * (k + 1)
        a[0] = True
        s = n
    
        for x in range(1, n + 1):
          t = s
          temp = False
    
          for s in range(k + 1):
            if a[s] and k - s >= 0 and (k - s) % x == 0 and (k - s) // x <= t:
                temp = True
                break
          res[x - 1] = temp
          s -= c.get(x, 0)
    
          if c.get(x, 0) > 0:
            for _ in range(c.get(x, 0)):
              for s in range(k, x - 1, -1):
                a[s] = a[s] or a[s - x]
                
        return res
cao nhân đây có hướng giải khác ko ạ?
 
Q3 e thử DP mà fail từ test 200 =((
Python:
class Solution:
    def subsequenceSumAfterCapping(self, nums: List[int], k: int) -> List[bool]:
        n = len(nums)
        c = Counter(nums)
        res = [False] * n
        a = [False] * (k + 1)
        a[0] = True
        s = n
    
        for x in range(1, n + 1):
          t = s
          temp = False
    
          for s in range(k + 1):
            if a[s] and k - s >= 0 and (k - s) % x == 0 and (k - s) // x <= t:
                temp = True
                break
          res[x - 1] = temp
          s -= c.get(x, 0)
    
          if c.get(x, 0) > 0:
            for _ in range(c.get(x, 0)):
              for s in range(k, x - 1, -1):
                a[s] = a[s] or a[s - x]
                
        return res
cao nhân đây có hướng giải khác ko ạ?
Bài này dễ thôi fen, brute force từ 0 đến n-1 cho mỗi answer, với mỗi số x thì sẽ phải capitalize tất cả số lớn hơn hoặc bằng x, dùng bisect để tìm tổng số num lớn hơn và bằng x.
Vì tổng của element phải bằng K, nên nếu mình có 1 possible sum thì phần còn lại remaining là k - possible sum, thì cái phần thừa này nó phải chia hết cho x và nhỏ hơn hoặc bằng số elements >= x thì mình sẽ chọn 1 cái sum thỏa mãn.
Fen xem solution của mình ở đây, làm ko ra trong contest mà bài thì quá dễ, trong contest tâm lí hơi yếu
 
Bài này dễ thôi fen, brute force từ 0 đến n-1 cho mỗi answer, với mỗi số x thì sẽ phải capitalize tất cả số lớn hơn hoặc bằng x, dùng bisect để tìm tổng số num lớn hơn và bằng x.
Vì tổng của element phải bằng K, nên nếu mình có 1 possible sum thì phần còn lại remaining là k - possible sum, thì cái phần thừa này nó phải chia hết cho x và nhỏ hơn hoặc bằng số elements >= x thì mình sẽ chọn 1 cái sum thỏa mãn.
Fen xem solution của mình ở đây, làm ko ra trong contest mà bài thì quá dễ, trong contest tâm lí hơi yếu
Ồ nhưng mà solution của mình hình như n^2k mà sao vẫn pass nhỉ?

via theNEXTvoz for iPhone
 
Bài này dễ thôi fen, brute force từ 0 đến n-1 cho mỗi answer, với mỗi số x thì sẽ phải capitalize tất cả số lớn hơn hoặc bằng x, dùng bisect để tìm tổng số num lớn hơn và bằng x.
Vì tổng của element phải bằng K, nên nếu mình có 1 possible sum thì phần còn lại remaining là k - possible sum, thì cái phần thừa này nó phải chia hết cho x và nhỏ hơn hoặc bằng số elements >= x thì mình sẽ chọn 1 cái sum thỏa mãn.
Fen xem solution của mình ở đây, làm ko ra trong contest mà bài thì quá dễ, trong contest tâm lí hơi yếu
Q3 nay khó mà bác, accepted ít hơn cả Q4
 
Sửa lần cuối:
Q3 e thử DP mà fail từ test 200 =((
Python:
class Solution:
    def subsequenceSumAfterCapping(self, nums: List[int], k: int) -> List[bool]:
        n = len(nums)
        c = Counter(nums)
        res = [False] * n
        a = [False] * (k + 1)
        a[0] = True
        s = n
 
        for x in range(1, n + 1):
          t = s
          temp = False
 
          for s in range(k + 1):
            if a[s] and k - s >= 0 and (k - s) % x == 0 and (k - s) // x <= t:
                temp = True
                break
          res[x - 1] = temp
          s -= c.get(x, 0)
 
          if c.get(x, 0) > 0:
            for _ in range(c.get(x, 0)):
              for s in range(k, x - 1, -1):
                a[s] = a[s] or a[s - x]
           
        return res
cao nhân đây có hướng giải khác ko ạ?
tôi cũng dùng DP.
  • sort lại mảng input
  • dp[x] là có thể tạo sum subsequence = x từ index trong khoảng [0,j) hay không?
  • loop ans từ 1 tới n: tăng index j khi a[j] <= i rồi chỉnh lại giá trị mảng dp
  • các index từ [j,n) thì sẽ có giá trị = i nên check xem nếu có bất kì dp[k - i * t] nào là true thì sẽ chỉnh ans là true.


C++:
class Solution
{
public:
    vector<bool> subsequenceSumAfterCapping(vector<int> &a, int k)
    {
        sort(a.begin(), a.end());
        int n = a.size();

        vector<bool> dp(k + 1, false);
        dp[0] = true;

        vector<bool> ans(n, false);
        int j = 0;

        for (int i = 1; i <= n; ++i)
        {
            while (j < n && a[j] <= i)
            {
                for (int t = k; t - a[j] >= 0; t--)
                {
                    if (dp[t - a[j]])
                    {
                        dp[t] = true;
                    }
                }
                j++;
            }
            if (dp[k])
            {
                ans[i - 1] = true;
                continue;
            }
            for (int t = 0; j + t <= n && k - t * i >= 0; t++)
            {
                if (dp[k - t * i])
                {
                    ans[i - 1] = true;
                    break;
                }
            }
        }

        return ans;
    }
};
 
Sửa lần cuối:
DNA issue :v nhìn mãi chả có ý tưởng gì để xử Q3 cả
Mình dùng DP + Bit + Early Exist may là vẫn qua :v

Python:
class Solution:
    def subsequenceSumAfterCapping(self, nums: List[int], k: int) -> List[bool]:
        n = len(nums)
        nums.sort()
        res = []
        for i in range(n):
            x = i + 1
            curr = 1
            flag = False
            if min(nums[0], x) > k:
                break
            for num in nums:
                if num > x:
                    num = x
                curr |= curr << num
                curr |= 1
                if curr & (1 << k):
                    res.append(True)
                    flag = True
                    break
            if not flag:
                res.append(False)
        if len(res) < n:
            res = res + [False] * (n - len(res))
        return res
 
DP Sum of Subset à bác?
Mình dùng DP + Bit + Early Exist may là vẫn qua :v

Python:
class Solution:
    def subsequenceSumAfterCapping(self, nums: List[int], k: int) -> List[bool]:
        n = len(nums)
        nums.sort()
        res = []
        for i in range(n):
            x = i + 1
            curr = 1
            flag = False
            if min(nums[0], x) > k:
                break
            for num in nums:
                if num > x:
                    num = x
                curr |= curr << num
                curr |= 1
                if curr & (1 << k):
                    res.append(True)
                    flag = True
                    break
            if not flag:
                res.append(False)
        if len(res) < n:
            res = res + [False] * (n - len(res))
        return res
 

Thống kê chủ đề

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