< Summary

Information
Class: LeetCode.Algorithms.DesignTaskManager.DesignTaskManagerDictionaryWithPriorityQueue
Assembly: LeetCode
File(s): D:\a\LeetCode-CS\LeetCode-CS\source\LeetCode\Algorithms\DesignTaskManager\DesignTaskManagerDictionaryWithPriorityQueue.cs
Line coverage
91%
Covered lines: 57
Uncovered lines: 5
Coverable lines: 62
Total lines: 148
Line coverage: 91.9%
Branch coverage
90%
Covered branches: 9
Total branches: 10
Branch coverage: 90%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%22100%
Add(...)100%11100%
Edit(...)100%11100%
Rmv(...)100%11100%
ExecTop()100%66100%
get_UserId()100%11100%
get_TaskId()100%11100%
get_Priority()100%11100%
.ctor(...)100%11100%
CompareTo(...)50%2271.42%
CompareToPriority(...)100%11100%
CompareToTaskId(...)100%210%

File(s)

D:\a\LeetCode-CS\LeetCode-CS\source\LeetCode\Algorithms\DesignTaskManager\DesignTaskManagerDictionaryWithPriorityQueue.cs

#LineLine coverage
 1// --------------------------------------------------------------------------------
 2// Copyright (C) 2026 Eugene Eremeev (also known as Yevhenii Yeriemeieiv).
 3// All Rights Reserved.
 4// --------------------------------------------------------------------------------
 5// This software is the confidential and proprietary information of Eugene Eremeev
 6// (also known as Yevhenii Yeriemeieiv) ("Confidential Information"). You shall not
 7// disclose such Confidential Information and shall use it only in accordance with
 8// the terms of the license agreement you entered into with Eugene Eremeev (also
 9// known as Yevhenii Yeriemeieiv).
 10// --------------------------------------------------------------------------------
 11
 12namespace LeetCode.Algorithms.DesignTaskManager;
 13
 14/// <inheritdoc />
 15public sealed class DesignTaskManagerDictionaryWithPriorityQueue : IDesignTaskManager
 16{
 517    private readonly PriorityQueue<TaskIdPriority, TaskIdPriority> _taskIdPriorityQueue = new();
 518    private readonly Dictionary<int, UserIdPriority> _taskIdToUserIdPriorityDictionary = [];
 19
 20    /// <summary>
 21    ///     Time complexity - O(n log n)
 22    ///     Space complexity - O(n)
 23    /// </summary>
 24    /// <param name="tasks"></param>
 525    public DesignTaskManagerDictionaryWithPriorityQueue(IList<IList<int>> tasks)
 526    {
 527        var n = tasks.Count;
 28
 2829        for (var i = 0; i < n; i++)
 930        {
 931            var userId = tasks[i][0];
 932            var taskId = tasks[i][1];
 933            var priority = tasks[i][2];
 34
 935            _taskIdToUserIdPriorityDictionary.Add(taskId, new UserIdPriority(userId, priority));
 36
 937            var taskIdPriority = new TaskIdPriority(taskId, priority);
 38
 939            _taskIdPriorityQueue.Enqueue(taskIdPriority, taskIdPriority);
 940        }
 541    }
 42
 43    /// <summary>
 44    ///     Time complexity - O(log n)
 45    ///     Space complexity - O(1)
 46    /// </summary>
 47    /// <param name="userId"></param>
 48    /// <param name="taskId"></param>
 49    /// <param name="priority"></param>
 50    public void Add(int userId, int taskId, int priority)
 351    {
 352        _taskIdToUserIdPriorityDictionary[taskId] = new UserIdPriority(userId, priority);
 53
 354        var taskIdPriority = new TaskIdPriority(taskId, priority);
 55
 356        _taskIdPriorityQueue.Enqueue(taskIdPriority, taskIdPriority);
 357    }
 58
 59    /// <summary>
 60    ///     Time complexity - O(log n)
 61    ///     Space complexity - O(1)
 62    /// </summary>
 63    /// <param name="taskId"></param>
 64    /// <param name="newPriority"></param>
 65    public void Edit(int taskId, int newPriority)
 266    {
 267        var userIdPriority = _taskIdToUserIdPriorityDictionary[taskId];
 268        var editedUserIdPriority = userIdPriority with { Priority = newPriority };
 69
 270        _taskIdToUserIdPriorityDictionary[taskId] = editedUserIdPriority;
 71
 272        var taskIdPriority = new TaskIdPriority(taskId, newPriority);
 73
 274        _taskIdPriorityQueue.Enqueue(taskIdPriority, taskIdPriority);
 275    }
 76
 77    /// <summary>
 78    ///     Time complexity - O(1)
 79    ///     Space complexity - O(1)
 80    /// </summary>
 81    /// <param name="taskId"></param>
 82    public void Rmv(int taskId)
 883    {
 884        _taskIdToUserIdPriorityDictionary.Remove(taskId);
 885    }
 86
 87    /// <summary>
 88    ///     Time complexity - O(log n)
 89    ///     Space complexity - O(1)
 90    /// </summary>
 91    /// <returns></returns>
 92    public int ExecTop()
 793    {
 994        while (_taskIdPriorityQueue.Count > 0)
 895        {
 896            var taskIdPriority = _taskIdPriorityQueue.Dequeue();
 97
 898            if (!_taskIdToUserIdPriorityDictionary.TryGetValue(taskIdPriority.TaskId, out var userIdPriority) ||
 899                userIdPriority.Priority != taskIdPriority.Priority)
 2100            {
 2101                continue;
 102            }
 103
 6104            Rmv(taskIdPriority.TaskId);
 105
 6106            return userIdPriority.UserId;
 107        }
 108
 1109        return -1;
 7110    }
 111
 15112    private readonly record struct UserIdPriority(int UserId, int Priority);
 113
 114    private readonly struct TaskIdPriority : IComparable<TaskIdPriority>
 115    {
 14116        public int TaskId { get; }
 117
 45118        public int Priority { get; }
 119
 120        public TaskIdPriority(int taskId, int priority)
 14121        {
 14122            TaskId = taskId;
 14123            Priority = priority;
 14124        }
 125
 126        public int CompareTo(TaskIdPriority taskPriority)
 19127        {
 19128            var priorityCompare = CompareToPriority(taskPriority.Priority);
 129
 19130            if (priorityCompare == 0)
 0131            {
 0132                return CompareToTaskId(taskPriority.TaskId);
 133            }
 134
 19135            return priorityCompare;
 19136        }
 137
 138        private int CompareToPriority(int priority)
 19139        {
 19140            return priority.CompareTo(Priority);
 19141        }
 142
 143        private int CompareToTaskId(int taskId)
 0144        {
 0145            return taskId.CompareTo(TaskId);
 0146        }
 147    }
 148}
Generated by: ReportGenerator 5.5.4.0
4/15/2026 - 11:20:12 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.Collections.Generic.IList`1<System.Collections.Generic.IList`1<System.Int32>>)
Add(System.Int32,System.Int32,System.Int32)
Edit(System.Int32,System.Int32)
Rmv(System.Int32)
ExecTop()
get_UserId()
get_TaskId()
get_Priority()
.ctor(System.Int32,System.Int32)
CompareTo(LeetCode.Algorithms.DesignTaskManager.DesignTaskManagerDictionaryWithPriorityQueue/TaskIdPriority)
CompareToPriority(System.Int32)
CompareToTaskId(System.Int32)