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

class Solution:
    def minOrAfterOperations(self, nums: List[int], k: int) -> int:
        n = len(nums)

        def can_off(mask):
            # check xem mask hiện tại có thể được xóa không
            cur = (1 << 30) - 1
            
            # giả định rằng ban đầu ta cần nối tất cả các phần tử lại với nhau và nối thêm 1 số 0 để
            # chắc chắn mask biến mất => cần n - 1 + 1 = n thao tác
            need = n
            
            # ta chỉ quan tâm đến các bit 1 trong mask
            tmp = [x & mask for x in nums]
            
            for x in tmp:
                cur = cur & x
                
                if cur == 0:
                    cur = (1 << 30) - 1
                    need -= 1 # ta không cần nối i với i + 1 nữa
            
            return need <= k
        
        mask = 0
        
        #tham lam, nếu thêm được bit nào vào mask thì ta sẽ thêm theo thứ tự ưu tiên 29 xuống 0
        for i in range(29,-1,-1):
            if can_off(mask | (1 << i)):
                mask |= 1 << i
        
        return (1 << 30) - 1 - mask

public class Solution {
    public int MaximumLength(int[] nums) {
        Dictionary<int,int> dic = new Dictionary<int,int>();
        HashSet<int> hash = new HashSet<int>();
        for(int i = 0; i < nums.Length;i++)
        {
            if(dic.ContainsKey(nums[i]))
            {
                dic[nums[i]]++;
            }
            else
            {
                dic.Add(nums[i], 1);
            }
        }
        int ans = 1;
        foreach (var item in dic)
        {
            if(hash.Contains(item.Key))
                continue;
            int ans1 = 0;
            int key = item.Key;
            bool hasMid = false;
            while (dic.ContainsKey(key))
            {
                if (key == 1)
                {
                    ans1 = (dic[key] / 2) * 2;
                    if (dic[key] % 2 == 1) 
                        hasMid = true;
                    break;
                }
                if (dic[key] > 1)
                {
                    hash.Add(key);
                    ans1 += 2;
                    key *= key;
                }
                else
                {
                    hasMid = true;
                    break;
                }
            }
            ans1 += hasMid ? 1 : -1;
            ans = Math.Max(ans, ans1);
        }
        return ans;
    }
}
}

class Solution:
    def maximumLength(self, nums: List[int]) -> int:
        counts = {}
        def getLength(counts, num):
            if num == 1:
                if counts[1]%2 == 0:
                    return counts[1] - 1
                else:
                    return counts[1]
           
            length = 1
            previousNum = num
            num = int(math.sqrt(num))
            while counts.get(num, 0) >= 2 and num > 1 and num*num == previousNum:
                previousNum = num
                num = int(math.sqrt(num))
                length += 2
               
            return length
     
        for num in nums:
            counts[num] = counts.get(num, 0) + 1
       
        ans = 0
        for num in nums:
            ans = max(ans, getLength(counts, num))
           
        return ans

class Solution:
    def flowerGame(self, n: int, m: int) -> int:
        mNumOdds = 0
        mNumEvens = 0
        for num in range(1, m + 1):
            if num%2 == 0:
                mNumEvens +=1
            else: mNumOdds +=1
       
        ans = 0
        for num in range(1, n + 1):
            if num%2 == 0:
                ans += mNumOdds
            else: ans += mNumEvens
           
        return ans