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

func zeroFilledSubarray(nums []int) int64 {
    var count, total uint
    for _, num := range nums {
        if num != 0 {
            count = 0
        } else {
            count += 1
        }
        total += count
    }
    return int64(total)
}

/**
 * @param {number[]} nums
 * @return {number}
 */
var zeroFilledSubarray = function(nums) {
  let n = 0;
  let lt = 1;
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] == 0) {
      n += lt;
      lt++;
    }
    else {
      lt = 1;
    }
  }
  return n;
};

/**
 * @param {number[]} nums
 * @return {number}
 */
var findPeakElement = function(nums) {
    let max = nums[0];
    let node = 0;
    if(nums.length > 0){
        for(let i = 1; i< nums.length; i++){
            if(max < nums[i]){
                max = nums[i];
                node = i;
            }
        }
    }
    return node
};

#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[101][50001];
const int mod = 1e9 + 7;
ll countRec(int n, int sum)
{
    if (!sum)
        return 0;
    if (n == 1)
        return 1;
    if (dp[n][sum] != -1)
        return dp[n][sum];
    ll ans = 0;
    for (int i = 0; i < 10; i++)
    {
        if (sum - i >= 0)
        {
            ans += (countRec(n - 1, sum - i)) % mod;
        }
    }
    dp[n][sum] = ans;
    return ans;
}
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        memset(dp, -1, 50001 * 101 * sizeof(ll));
        int n, sum;
        cin >> n >> sum;
        ll ans = 0;
        for (int i = 0; i < 10; i++)
        {
            if (sum - i >= 0)
            {
                ans += (countRec(n - 1, sum - i)) % mod;
            }
        }
        cout << ans << endl;
    }
}

function countIntegers(N: number, K: number): number {
  let count = 0, modulo = Math.pow(10,9) + 7;
  for (let i = Math.pow(10, N - 1); i < Math.pow(10, N); i++) {
    let sum = 0, num = i;
    while (num > 0) {
      sum += num % 10;
      num = Math.floor(num / 10);
    }
    if (sum === K) {
      count = (count + 1) % modulo;
    }
  }
  return count;
}

/**
 * @param {number[]} nums
 * @return {number}
 */
var zeroFilledSubarray = function(nums) {
    let c = 0, ans = 0;
    for (const n of nums) {
        if (!n) {
            ans += ++c;
        } else {
            c = 0;
        }
    }

    return ans;
};

var zeroFilledSubarray = nums => nums.reduce(([a, c], it) => [a+(it?c=0:++c), c], [0, 0])[0];

class Solution:
    def minScore(self, n: int, roads: List[List[int]]) -> int:
        self.adj = defaultdict(list)
        self.n = n
        
        roads.sort(key=lambda x: x[2])
        
        for a, b, dist in roads:
            self.adj[a].append(b)
            self.adj[b].append(a)
        
        self.visited = set()
        self.found1 = False
        self.foundN = False
        for a, _, dist in roads:
            self.dfs(a)
            if self.found1 or self.foundN:
                return dist
            
    def dfs(self, node):
        if node == 1:
            self.found1 = True
        elif node == self.n:
            self.foundN = True
        
        if node in self.visited:
            return
        
        self.visited.add(node)
        
        for neigh in self.adj[node]:
            self.dfs(neigh)

class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        n = len(nums)
        left = 0
        right = n
       
        while left < right:
            mid = left + (right - left) // 2
           
            leftMidVal = -float('inf') if (mid - 1) < 0 else nums[mid-1]
            rightMidVal = -float('inf') if (mid + 1) >= n else nums[mid+1]
            midVal = nums[mid]
           
            if midVal > leftMidVal and midVal > rightMidVal:
                return mid
         
            if midVal > leftMidVal and midVal < rightMidVal:
                left = mid + 1
            else:
                right = mid - 1
               
        return left

function minScore(n: number, roads: number[][]): number {
    const map: Map<number, number[][]> = new Map();
    for (const road of roads) {
        if (map.has(road[0])) {
            const val = map.get(road[0]);
            val.push([road[1], road[2]])
            map.set(road[0], val)
        } else {
            map.set(road[0], [[road[1], road[2]]])
        }

        if (map.has(road[1])) {
            const val = map.get(road[1]);
            val.push([road[0], road[2]])
            map.set(road[1], val)
        } else {
            map.set(road[1], [[road[0], road[2]]])
        }
    }
    let ans = Number.MAX_SAFE_INTEGER;
    const queue: number[] = [];
    const visited = new Array(n + 1).fill(false);
    queue.push(1);
    visited[1] = true;
    while (queue.length) {
        const item = queue.shift();
        for (const [first, second] of map.get(item)) {
            ans = Math.min(ans, second)
            if (!visited[first]) {
                visited[first] = true;
                queue.push(first)
            }
        }
    }
    return ans;


};

class Solution {
    public class Data {
        int node;
        int dis;
        
        public Data(int node, int dis) {
            this.node = node;
            this.dis = dis;
        }
    }
    
    public int minScore(int n, int[][] roads) {
        Map<Integer, List<Data>> adjList = new HashMap();
        
        for (int[] road : roads) {
            int src = road[0];
            int dest = road[1];
            int dis = road[2];
            
            adjList.putIfAbsent(src, new ArrayList<>());
            adjList.putIfAbsent(dest, new ArrayList<>());
            
            adjList.get(src).add(new Data(dest, dis));
            adjList.get(dest).add(new Data(src, dis));
        }
        
        int min = Integer.MAX_VALUE;
        
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        Set<Integer> visited = new HashSet<>();
        visited.add(1);
        
        while(!queue.isEmpty()){
            Queue<Integer> nextQueue = new LinkedList<>();
            while (!queue.isEmpty()) {
                int cur = queue.poll();
                List<Data> list = adjList.get(cur);
                for (Data data : list) {
                    min = Math.min(min, data.dis);
                    if (!visited.contains(data.node)) nextQueue.add(data.node);
                }
                visited.add(cur);   
            }
            
            queue = nextQueue;
        }
        
        return min;
    }
}

/**
 * @param {number} n
 * @param {number[][]} roads
 * @return {number}
 */
var minScore = function(n, roads) {
    let ans = +Infinity;
    const nb = [], visited = {};
    roads.forEach(([u, v, d]) => {
        nb[u] ??= [];
        nb[u].push([v, d]);
        nb[v] ??= [];
        nb[v].push([u, d]);
    });
    const q = new Queue();
    q.enqueue(1);
    visited[1] = true;

    while (!q.isEmpty()) {
        const current = q.dequeue();
        for (const [next, dist] of nb[current]) {
            ans = Math.min(ans, dist);
            if (!visited[next]) {
                q.enqueue(next);
                visited[next] = true;
            }
        }
    }

    return ans;
};