621. Task Scheduler

LeetCode medium original: C# #array #csharp #hash-table #intervals #leetcode #math #medium #string

Văn bản bài toán được dịch từ tiếng Nga theo ngôn ngữ giao diện. Mã không thay đổi.

LeetCode Static

Вам дан mảng задач процессора, каждая из которых представлена буквами от A до Z, и время охлаждения, n. Каждый цикл или интервал позволяет завершить одну задачу. Задачи могут быть выполнены в любом порядке, но есть ограничение: одинаковые задачи должны быть разделены не менее чем n интервалами из-за времени охлаждения. return минимальное количество интервалов, необходимое для выполнения всех задач.

Ví dụ:

Input: tasks = ["A","A","A","B","B","B"], n = 2

Output: 8

C# lời giải

đã khớp/gốc

public class Solution {
    public int LeastInterval(char[] tasks, int n) {
        var taskCounts = new Dictionary<char, int>();
        foreach (var task in tasks) {
            if (taskCounts.ContainsKey(task)) {
                taskCounts[task]++;
            } else {
                taskCounts[task] = 1;
            }
        }
        
        int maxFreq = taskCounts.Values.Max();
        int countMaxFreq = taskCounts.Values.Count(count => count == maxFreq);
        
        return Math.Max(tasks.Length, (maxFreq - 1) * (n + 1) + countMaxFreq);
    }
}

C++ lời giải

bản nháp tự động, xem lại trước khi gửi

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public int LeastInterval(char[] tasks, int n) {
        var taskCounts = new unordered_map<char, int>();
        foreach (var task in tasks) {
            if (taskCounts.count(task)) {
                taskCounts[task]++;
            } else {
                taskCounts[task] = 1;
            }
        }
        
        int maxFreq = taskCounts.Values.Max();
        int countMaxFreq = taskCounts.Values.size()(count => count == maxFreq);
        
        return max(tasks.size(), (maxFreq - 1) * (n + 1) + countMaxFreq);
    }
}

Java lời giải

đã khớp/gốc

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public int leastInterval(char[] tasks, int n) {
        Map<Character, Integer> taskCounts = new HashMap<>();
        for (char task : tasks) {
            taskCounts.put(task, taskCounts.getOrDefault(task, 0) + 1);
        }
        
        int maxFreq = taskCounts.values().stream().max(Integer::compare).get();
        int countMaxFreq = (int) taskCounts.values().stream().filter(count -> count == maxFreq).count();
        
        return Math.max(tasks.length, (maxFreq - 1) * (n + 1) + countMaxFreq);
    }
}

JavaScript lời giải

đã khớp/gốc

function leastInterval(tasks, n) {
    const taskCounts = {};
    for (const task of tasks) {
        taskCounts[task] = (taskCounts[task] || 0) + 1;
    }
    
    const maxFreq = Math.max(...Object.values(taskCounts));
    const countMaxFreq = Object.values(taskCounts).filter(count => count === maxFreq).length;
    
    return Math.max(tasks.length, (maxFreq - 1) * (n + 1) + countMaxFreq);
}

Python lời giải

đã khớp/gốc

from collections import Counter

def leastInterval(tasks, n):
    task_counts = Counter(tasks)
    max_freq = max(task_counts.values())
    count_max_freq = list(task_counts.values()).count(max_freq)
    
    return max(len(tasks), (max_freq - 1) * (n + 1) + count_max_freq)

Go lời giải

đã khớp/gốc

package main

import (
    "fmt"
    "math"
)

func leastInterval(tasks []byte, n int) int {
    taskCounts := make(map[byte]int)
    for _, task := range tasks {
        taskCounts[task]++
    }
    
    maxFreq := 0
    for _, count := range taskCounts {
        if count > maxFreq {
            maxFreq = count
        }
    }
    
    countMaxFreq := 0
    for _, count := range taskCounts {
        if count == maxFreq {
            countMaxFreq++
        }
    }
    
    return int(math.Max(float64(len(tasks)), float64((maxFreq-1)*(n+1)+countMaxFreq)))
}

Algorithm

Подсчитайте количество каждой задачи и find максимальное количество вхождений (maxFreq).

Вычислите количество интервалов, необходимых для задач с maxFreq: (maxFreq - 1) * (n + 1) + countMaxFreq, где countMaxFreq - количество задач, имеющих maxFreq.

return максимум между вычисленным значением и длиной mảngа задач, поскольку некоторые задачи могут заполнять интервал до n.

😎

Vacancies for this task

việc làm đang hoạt động with overlapping task tags are đã hiển thị.

Tất cả việc làm

Chưa có việc làm đang hoạt động.