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

  • Người tạo chủ đề Người tạo chủ đề _Gia_Cat_Luong_
  • Ngày bắt đầu Ngày bắt đầu
Trạng thái
Không mở để trả lời thêm.
C#: 
    public int LongestSquareStreak(int[] nums) {
        Queue<Tuple<int, int>> queue = new Queue<Tuple<int, int>>();
        Array.Sort(nums);
        int maxStreak = 0;
        foreach (int element in nums)
        {
            while (queue.Count != 0 && queue.Peek().Item1 <= element)
            {
                if (queue.Peek().Item1 == element)
                {
                    Tuple<int, int> tmp = queue.Dequeue();
                    if (maxStreak <= tmp.Item2) maxStreak = tmp.Item2 + 1;
                    queue.Enqueue(new Tuple<int, int> (element * element, tmp.Item2 + 1));
                    break;
                }
                queue.Dequeue();
            }
            queue.Enqueue(new Tuple<int, int> (element * element, 1));                       
        }
        return maxStreak >= 2 ? maxStreak : -1;
    }
 
Java: 
class Solution {
    public int longestSquareStreak(int[] nums) {
        Arrays.sort(nums);
        HashMap<Integer,Integer> map = new HashMap();
        int res = -1;
        for(int i:nums){
            if(map.containsKey(i))
                res = Math.max(res,map.get(i)+1);
            map.put( i*i,map.getOrDefault(i,0)+1);
        }
        return res;
    }
}
 
Python: 
from typing import List


class Solution:
    def longestSquareStreak(self, nums: List[int]) -> int:
        longest = 1
        num_set = set(nums)
        for num in nums:
            length = 0
            init_num = num
            while init_num in num_set:
                length += 1
                init_num = init_num ** 2
                if init_num > 10**5:
                    break
            longest = max(longest, length)
        return longest if longest > 1 else -1
 
C++: 
class Solution {
public:
    int longestSquareStreak(vector<int>& nums) {
        int n = nums.size();
        unordered_map<int, int> dp;
        sort(nums.begin(), nums.end());
        int ans = -1;

        for (int num : nums) {
            dp[num] = 1;

            int tmp = sqrt(num);
            if (tmp*tmp == num && dp.count(tmp)) {
                dp[num] = dp[tmp] + 1;
            }

            if (dp[num] >= 2) {
                ans = max(ans, dp[num]);
            }
        }

        return ans;
    }
};
 
trả bài cũ mấy hôm voz sập

Java: 
class Solution {
    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
        if(root1==null && root2==null) return true;
        if((root1==null && root2!=null)|| (root1!=null && root2==null)) return false;
        if(root1.val==root2.val){
            if(root1.left!=null && root2.left!=null && root1.left.val==root2.left.val){
                return flipEquiv(root1.left,root2.left) && flipEquiv(root1.right,root2.right);
            }
            else if(root1.right!=null && root2.right!=null && root1.right.val==root2.right.val){
                return flipEquiv(root1.left,root2.left) && flipEquiv(root1.right,root2.right);
            }
            return flipEquiv(root1.left,root2.right) && flipEquiv(root1.right,root2.left);
        }
        return false;
    }
}
Java: 
class Solution {
    public class Trie{
        Trie[] child;
        boolean isEnd;
        public Trie(){
            child = new Trie[27];
            isEnd = false;
        }
        public void insert(String s){
            Trie node = this;
            for(int i =0;i<s.length();i++){
                int index = s.charAt(i)-'a';
                index = (index ==-50?26:index);
                if(node.child[index]==null) node.child[index]= new Trie();
                node = node.child[index];
            }
            node.isEnd = true;
        }
        public boolean isSubFolder(String folder){
            Trie node = this;
             for(int i =0;i<folder.length();i++){
                int index = folder.charAt(i)-'a';
                if(index == -50){
                    index =26;
                    if(node.isEnd) return true;
                }
                if(node.child[index]==null) return false;
                node = node.child[index];

              
            }
            return false;
        }

    }
    public List<String> removeSubfolders(String[] folder) {
        Trie trie = new Trie();
        List<String> res = new ArrayList();
        Arrays.sort(folder);
        for(String f:folder){
            if(!trie.isSubFolder(f)){
                trie.insert(f);
                res.add(f);
            }
        }
        return res;
    }
}
Java: 
class Solution {
    public int[] treeQueries(TreeNode root, int[] queries) {

        int[][] max_size = new int[100001][2];
        int[] res = new int[queries.length];
        dfs(root, max_size, 0);
    
        Queue<TreeNode> queue = new LinkedList();
        queue.add(root);
        int level =-1;
        while (!queue.isEmpty()) {
            List<TreeNode> list = new ArrayList(queue);
            queue = new LinkedList<TreeNode>();
            if (list.size() > 1) {
                int max = max_size[list.get(0).val][0];
                int sec = max_size[list.get(1).val][0];
              
                for (int i = 1; i < list.size(); i++) {
                    if (max < max_size[list.get(i).val][0]) {
                        sec = max;
                        max = max_size[list.get(i).val][0];
                    }else if(sec<max_size[list.get(i).val][0]){
                        sec = max_size[list.get(i).val][0];
                    }
                  
                }
                for (TreeNode node : list) {
                    if (node.left != null)
                        queue.add(node.left);
                    if (node.right != null)
                        queue.add(node.right);
                    if (max_size[node.val][0] == max) {
                        max_size[node.val][1] = sec;
                    } else
                        max_size[node.val][1] = max;
                }
            } else {
                TreeNode node = list.get(0);
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
                max_size[node.val][1] = level;
            }
            level++;
        }

        for (int i = 0; i < queries.length; i++) {
            res[i] = max_size[queries[i]][1];
        }
        return res;
    }

    public int dfs(TreeNode node, int[][] max_size, int level) {
        int left = node.left == null ? level : dfs(node.left, max_size, level + 1);
        int right = node.right == null ? level : dfs(node.right, max_size, level + 1);
        max_size[node.val][0] = Math.max(left, right);
        return max_size[node.val][0];
    }
}
07AU8lM.png
 
LmaoSuVuong đã nói:
trả bài cũ mấy hôm voz sập

Java: 
class Solution {
    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
        if(root1==null && root2==null) return true;
        if((root1==null && root2!=null)|| (root1!=null && root2==null)) return false;
        if(root1.val==root2.val){
            if(root1.left!=null && root2.left!=null && root1.left.val==root2.left.val){
                return flipEquiv(root1.left,root2.left) && flipEquiv(root1.right,root2.right);
            }
            else if(root1.right!=null && root2.right!=null && root1.right.val==root2.right.val){
                return flipEquiv(root1.left,root2.left) && flipEquiv(root1.right,root2.right);
            }
            return flipEquiv(root1.left,root2.right) && flipEquiv(root1.right,root2.left);
        }
        return false;
    }
}
Java: 
class Solution {
    public class Trie{
        Trie[] child;
        boolean isEnd;
        public Trie(){
            child = new Trie[27];
            isEnd = false;
        }
        public void insert(String s){
            Trie node = this;
            for(int i =0;i<s.length();i++){
                int index = s.charAt(i)-'a';
                index = (index ==-50?26:index);
                if(node.child[index]==null) node.child[index]= new Trie();
                node = node.child[index];
            }
            node.isEnd = true;
        }
        public boolean isSubFolder(String folder){
            Trie node = this;
             for(int i =0;i<folder.length();i++){
                int index = folder.charAt(i)-'a';
                if(index == -50){
                    index =26;
                    if(node.isEnd) return true;
                }
                if(node.child[index]==null) return false;
                node = node.child[index];

             
            }
            return false;
        }

    }
    public List<String> removeSubfolders(String[] folder) {
        Trie trie = new Trie();
        List<String> res = new ArrayList();
        Arrays.sort(folder);
        for(String f:folder){
            if(!trie.isSubFolder(f)){
                trie.insert(f);
                res.add(f);
            }
        }
        return res;
    }
}
Java: 
class Solution {
    public int[] treeQueries(TreeNode root, int[] queries) {

        int[][] max_size = new int[100001][2];
        int[] res = new int[queries.length];
        dfs(root, max_size, 0);
   
        Queue<TreeNode> queue = new LinkedList();
        queue.add(root);
        int level =-1;
        while (!queue.isEmpty()) {
            List<TreeNode> list = new ArrayList(queue);
            queue = new LinkedList<TreeNode>();
            if (list.size() > 1) {
                int max = max_size[list.get(0).val][0];
                int sec = max_size[list.get(1).val][0];
             
                for (int i = 1; i < list.size(); i++) {
                    if (max < max_size[list.get(i).val][0]) {
                        sec = max;
                        max = max_size[list.get(i).val][0];
                    }else if(sec<max_size[list.get(i).val][0]){
                        sec = max_size[list.get(i).val][0];
                    }
                 
                }
                for (TreeNode node : list) {
                    if (node.left != null)
                        queue.add(node.left);
                    if (node.right != null)
                        queue.add(node.right);
                    if (max_size[node.val][0] == max) {
                        max_size[node.val][1] = sec;
                    } else
                        max_size[node.val][1] = max;
                }
            } else {
                TreeNode node = list.get(0);
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
                max_size[node.val][1] = level;
            }
            level++;
        }

        for (int i = 0; i < queries.length; i++) {
            res[i] = max_size[queries[i]][1];
        }
        return res;
    }

    public int dfs(TreeNode node, int[][] max_size, int level) {
        int left = node.left == null ? level : dfs(node.left, max_size, level + 1);
        int right = node.right == null ? level : dfs(node.right, max_size, level + 1);
        max_size[node.val][0] = Math.max(left, right);
        return max_size[node.val][0];
    }
}
07AU8lM.png
Nhấp để mở rộng...
FY7e6U1.png
Voz sập chứ LC có sập đâu
osCpCsi.png
Phạt sao đây @freedom.9 @chiyeuemthoi @Người quan sát cô đơn
 
LmaoSuVuong đã nói:
trả bài cũ mấy hôm voz sập

Java: 
class Solution {
    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
        if(root1==null && root2==null) return true;
        if((root1==null && root2!=null)|| (root1!=null && root2==null)) return false;
        if(root1.val==root2.val){
            if(root1.left!=null && root2.left!=null && root1.left.val==root2.left.val){
                return flipEquiv(root1.left,root2.left) && flipEquiv(root1.right,root2.right);
            }
            else if(root1.right!=null && root2.right!=null && root1.right.val==root2.right.val){
                return flipEquiv(root1.left,root2.left) && flipEquiv(root1.right,root2.right);
            }
            return flipEquiv(root1.left,root2.right) && flipEquiv(root1.right,root2.left);
        }
        return false;
    }
}
Java: 
class Solution {
    public class Trie{
        Trie[] child;
        boolean isEnd;
        public Trie(){
            child = new Trie[27];
            isEnd = false;
        }
        public void insert(String s){
            Trie node = this;
            for(int i =0;i<s.length();i++){
                int index = s.charAt(i)-'a';
                index = (index ==-50?26:index);
                if(node.child[index]==null) node.child[index]= new Trie();
                node = node.child[index];
            }
            node.isEnd = true;
        }
        public boolean isSubFolder(String folder){
            Trie node = this;
             for(int i =0;i<folder.length();i++){
                int index = folder.charAt(i)-'a';
                if(index == -50){
                    index =26;
                    if(node.isEnd) return true;
                }
                if(node.child[index]==null) return false;
                node = node.child[index];

             
            }
            return false;
        }

    }
    public List<String> removeSubfolders(String[] folder) {
        Trie trie = new Trie();
        List<String> res = new ArrayList();
        Arrays.sort(folder);
        for(String f:folder){
            if(!trie.isSubFolder(f)){
                trie.insert(f);
                res.add(f);
            }
        }
        return res;
    }
}
Java: 
class Solution {
    public int[] treeQueries(TreeNode root, int[] queries) {

        int[][] max_size = new int[100001][2];
        int[] res = new int[queries.length];
        dfs(root, max_size, 0);
   
        Queue<TreeNode> queue = new LinkedList();
        queue.add(root);
        int level =-1;
        while (!queue.isEmpty()) {
            List<TreeNode> list = new ArrayList(queue);
            queue = new LinkedList<TreeNode>();
            if (list.size() > 1) {
                int max = max_size[list.get(0).val][0];
                int sec = max_size[list.get(1).val][0];
             
                for (int i = 1; i < list.size(); i++) {
                    if (max < max_size[list.get(i).val][0]) {
                        sec = max;
                        max = max_size[list.get(i).val][0];
                    }else if(sec<max_size[list.get(i).val][0]){
                        sec = max_size[list.get(i).val][0];
                    }
                 
                }
                for (TreeNode node : list) {
                    if (node.left != null)
                        queue.add(node.left);
                    if (node.right != null)
                        queue.add(node.right);
                    if (max_size[node.val][0] == max) {
                        max_size[node.val][1] = sec;
                    } else
                        max_size[node.val][1] = max;
                }
            } else {
                TreeNode node = list.get(0);
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
                max_size[node.val][1] = level;
            }
            level++;
        }

        for (int i = 0; i < queries.length; i++) {
            res[i] = max_size[queries[i]][1];
        }
        return res;
    }

    public int dfs(TreeNode node, int[][] max_size, int level) {
        int left = node.left == null ? level : dfs(node.left, max_size, level + 1);
        int right = node.right == null ? level : dfs(node.right, max_size, level + 1);
        max_size[node.val][0] = Math.max(left, right);
        return max_size[node.val][0];
    }
}
07AU8lM.png
Nhấp để mở rộng...
Code trâu zữ vậy :beat_brick: refactor lại đi bác :ROFLMAO:
 
Java: 
class Solution {
    private int MAX_ARRAY = 100001;
    public int longestSquareStreak(int[] nums) {
        int max = -1;
        int n = nums.length;
        int[] dp = new int[MAX_ARRAY];
        TreeSet<Integer> treeSet = new TreeSet();
        for(int num : nums) {
            treeSet.add(num);
            dp[num] = 1;
        }
        for(int num : treeSet) {
            if(Math.pow(num,2) <= MAX_ARRAY && dp[num*num] != 0) {
                dp[num*num] += dp[num];       
            }
            max = Math.max(max,dp[num]);
        }
        return max <= 1 ? -1 : max;
    }
}
 
C++: 
class Solution {
public:
    int longestSquareStreak(vector<int> const& nums) {
        vector<bool> table(100'001, false);
        for (int e : nums) table[e] = true;
        int res = 0;
        for (int e : nums) {
            if (e > 316) continue;
            int cnt = 1, prev = e * e;
            while (true) {
                if (table[prev]) {
                    cnt++;
                    if (prev > 316) break;
                    prev *= prev;
                } else break;
            }
            res = max(res, cnt);
        }
        return res <= 1 ? -1 : res;
    }
};
 
Python: 
class Solution:
    def longestSquareStreak(self, nums: List[int]) -> int:
        rs = -1
        num_set = set(nums)
        num_sort = sorted(nums)

        for num in num_sort:
            count = 0
            cur = num

            while cur in num_set:
                num_set.remove(cur)
                cur = cur * cur
                count += 1

            rs = max(rs, count)

        return rs if rs > 1 else -1
 
C-like: 
use std::collections::*;

impl Solution {
    pub fn longest_square_streak(mut nums: Vec<i32>) -> i32 {
        fn shit_streak(num: i64, presence: &HashSet<i64>, longest_streak: &mut HashMap<i64, i32>) -> i32 {
            if !presence.contains(&num) {
                return 0;
            }

            if longest_streak.contains_key(&num) {
                return longest_streak[&num];
            }

            let streak = shit_streak(num * num, presence, longest_streak) + 1;
            longest_streak.insert(num, streak);

            streak
        }

        let nums: Vec<i64> =
            nums.into_iter().map(|num| num as i64).collect();

        let mut presence: HashSet<i64> =
            nums.iter().copied().map(|num| num).collect();

        let mut longest_streak = HashMap::new();

        let mut max_streak = 1;
        for num in nums {
            let streak = shit_streak(num, &presence, &mut longest_streak);
            max_streak = max_streak.max(streak);
        }

        if max_streak < 2 {
            return -1;
        }

        max_streak
    }
}
 
Trạng thái
Không mở để trả lời thêm.

Chủ đề tương tự

Thach Sanh Mat Riu
Điều gì xảy ra nếu bạn uống nước chè xanh mỗi ngày?
2
Trả lời
22
Lượt xem
1K
dattenmoi
D
megume
thảo luận Hôm nay, buổi bình minh của AI robot đã đến
Trả lời
4
Lượt xem
1K
Toc Hong
Toc Hong
Lộc Tục
(Dịch) Cuộc điều tra của CBC/Radio-Canada tiết lộ công ty Việt Nam nhắm vào người Canada bằng tin giả AI để kiếm lời
2
Trả lời
30
Lượt xem
5K
dukeng995
dukeng995
Ti Amo
[Dịch] Công ty Việt Nam dùng tin giả do AI tạo ra để kiếm tiền — nhắm vào độc giả Canada
Trả lời
0
Lượt xem
1K
Ti Amo
Ti Amo
Gấu Ted
Độc giả ngày càng tin nhà báo hơn thương hiệu báo chí
Trả lời
10
Lượt xem
862
giayasics
giayasics

Thống kê chủ đề

Ngày tạo
_Gia_Cat_Luong_,
Người trả lời cuối
Vipluckystar,
Trả lời
17.755
Lượt xem
1.213.602

Chia sẻ trang này

Quay lại
Lên đầu trang