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

use std::collections::*;

impl Solution {
    pub fn min_k_bit_flips(nums: Vec<i32>, k: i32) -> i32 {
        let (n, uk) = (nums.len(), k as usize);

        let (mut flip_queue, mut flip_state, mut result) = (VecDeque::new(), 0, 0);

        for (i, num) in nums.into_iter().enumerate() {
            if i >= uk {
                flip_state ^= flip_queue[0];
            }

            if flip_state == num {
                if i + uk > n {
                    return - 1;
                }

                flip_queue.push_back(1);
                flip_state ^= 1;
                result += 1;
            } else {
                flip_queue.push_back(0);
            }

            if flip_queue.len() > uk {
                flip_queue.pop_front();
            }
        }

        result
    }
}

use std::rc::Rc;
use std::cell::RefCell;

impl Solution {
    pub fn bst_to_gst(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
        type Tree = Rc<RefCell<TreeNode>>;

        fn build_and_sum(node_option: Option<&Tree>, top_right_sum: i32) -> (Option<Tree>, i32) {
            match node_option {
                Some(node) => {
                    let val = node.borrow().val;

                    let mut new_node = TreeNode::new(val);

                    let (new_right, right_sum) =
                        build_and_sum(node.borrow().right.as_ref(), top_right_sum);

                    let (new_left, left_sum) =
                        build_and_sum(node.borrow().left.as_ref(), val + right_sum + top_right_sum);

                    new_node.val += right_sum + top_right_sum;
                    new_node.left = new_left;
                    new_node.right = new_right;

                    (
                        Some(Rc::new(RefCell::new(new_node))),
                        val + left_sum + right_sum
                    )
                },
                None => (None, 0)
            }
        }

        build_and_sum(root.as_ref(), 0).0
    }
}

use std::rc::Rc;
use std::cell::RefCell;

impl Solution {
    pub fn balance_bst(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
        type Tree = Rc<RefCell<TreeNode>>;
        fn flatten(node_option: Option<&Tree>, vals: &mut Vec<i32>) {
            match node_option {
                Some(node) => {
                    flatten(node.borrow().left.as_ref(), vals);
                    vals.push(node.borrow().val);
                    flatten(node.borrow().right.as_ref(), vals);
                },
                None => ()
            }
            
        }

        fn build_balanced(vals: &[i32]) -> Option<Tree> {
            if vals.len() == 0 {
                return None;
            }

            let mid = vals.len() / 2;

            Some(Rc::new(RefCell::new(TreeNode {
                val: vals[mid],
                left: build_balanced(&vals[..mid]),
                right: build_balanced(&vals[(mid + 1)..])
            })))
        }

        let mut vals = vec![];
        flatten(root.as_ref(), &mut vals);

        build_balanced(&vals)
    }
}

use std::collections::*;

impl Solution {
    pub fn find_center(edges: Vec<Vec<i32>>) -> i32 {
        let mut edge_map = HashMap::new();

        for edge in edges {
            let u = edge[0];
            let v = edge[1];

            edge_map.entry(u).and_modify(|count| *count += 1).or_insert(1);

            edge_map.entry(v).and_modify(|count| *count += 1).or_insert(1);
        }

        let n = edge_map.len();

        for (vertex, count) in edge_map {
            if count == n - 1 {
                return vertex;
            }
        }

        -1
    }
}

impl Solution {
    pub fn find_center(edges: Vec<Vec<i32>>) -> i32 {
        return if edges[0][0] == edges[1][0] || edges[0][0] == edges[1][1] {
            edges[0][0]
        } else {
            edges[0][1]
        }
    }
}

class Solution:
    def findCenter(self, edges: List[List[int]]) -> int:
        for e in edges[0]:
            if e in edges[1]:
                return e

public class Solution {
    public int FindCenter(int[][] edges) {
        int max = 0;
        int result = 0;
        Dictionary<int, int> dict = new Dictionary<int, int>();
        for(int i = 0; i < edges.Length/2 + 1; i++)
        {
            for(int j = 0; j<2; j++)
            {
                if(dict.ContainsKey(edges[i][j]))
                {
                    dict[edges[i][j]]++;
                    if(dict[edges[i][j]] > max)
                        result = edges[i][j];
                }
                else
                {
                    dict.Add(edges[i][j], 1);
                }
            }
        }
        return result;
    }
}

class Solution:
    def findCenter(self, edges: List[List[int]]) -> int:
        mp = {}
        for [s , e] in edges:
            mp[s] = mp.get(s , 0) + 1
            mp[e] = mp.get(e , 0) + 1
       
        for k in mp:
            if mp[k] == len(edges): return k
       
        return -1

class Solution {
    public int findCenter(int[][] edges) {
        int n = edges.length;
        int [] vertexFreq = new int[n+2];
        for(int[] edge:edges){
            vertexFreq[edge[0]]++;
            vertexFreq[edge[1]]++;
        }
        for(int i =1 ; i < n+2;i++){
            if(vertexFreq[i]==n) return i;
        }
        return 1;
    }
}

class Solution {
    public int findJudge(int n, int[][] trust) {
        int[] credit = new int[n + 1];

        for (int[] tr: trust) {
            credit[tr[0]]--;
            credit[tr[1]]++;
        }

        for (int i = 1; i <= credit.length - 1; i++) {
            if (credit[i] == n - 1) return i;
        }

        return -1;
    }
}

class Solution {
    func findCenter(_ edges: [[Int]]) -> Int {
        let num0 = edges[0][0]
        for num1 in edges[1] {
            if num0 == num1 {
                return num0
            }
        }
        return edges[0][1]
    }
}