【C#】優先度付きキュー（PriorityQueue）の基本的な使い方と実装例を解説

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // TElementがstring、TPriorityがintの優先度付きキューを作成
        PriorityQueue<string, int> taskQueue = new PriorityQueue<string, int>();

        // 要素の追加 (値が小さいほど優先度が高い)
        taskQueue.Enqueue("メールの返信", 3);
        taskQueue.Enqueue("緊急のシステム障害対応", 1);
        taskQueue.Enqueue("週報の作成", 5);
        taskQueue.Enqueue("会議資料の準備", 2);

        Console.WriteLine("--- タスクの処理を開始します ---");

        // キューが空になるまでループ
        while (taskQueue.Count > 0)
        {
            // 最も優先度の高い要素を取得して削除
            string task = taskQueue.Dequeue();
            Console.WriteLine($"処理中: {task}");
        }
    }
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 降順の比較器を指定してインスタンス化
        // Comparer<int>.Createを使用してラムダ式で定義
        var comparer = Comparer<int>.Create((x, y) => y.CompareTo(x));
        PriorityQueue<string, int> highScorerQueue = new PriorityQueue<string, int>(comparer);

        highScorerQueue.Enqueue("Player A", 1500);
        highScorerQueue.Enqueue("Player B", 3200);
        highScorerQueue.Enqueue("Player C", 2100);

        Console.WriteLine("--- ハイスコア順のリスト ---");
        while (highScorerQueue.TryDequeue(out string player, out int score))
        {
            Console.WriteLine($"{player}: {score} pts");
        }
    }
}

using System;
using System.Collections.Generic;

// 優先度を判定するためのカスタム構造体
public struct OrderPriority : IComparable<OrderPriority>
{
    public int Rank { get; }      // 1: VIP, 2: Regular
    public DateTime OrderedAt { get; }

    public OrderPriority(int rank, DateTime orderedAt)
    {
        Rank = rank;
        OrderedAt = orderedAt;
    }

    // IComparableを実装して比較ロジックを定義
    public int CompareTo(OrderPriority other)
    {
        // まずランクを比較
        int result = Rank.CompareTo(other.Rank);
        if (result != 0) return result;

        // ランクが同じなら注文日時が早い順
        return OrderedAt.CompareTo(other.OrderedAt);
    }
}

class Program
{
    static void Main()
    {
        var queue = new PriorityQueue<string, OrderPriority>();

        // データの追加
        queue.Enqueue("注文A (Regular, 後)", new OrderPriority(2, DateTime.Now.AddMinutes(10)));
        queue.Enqueue("注文B (VIP, 後)", new OrderPriority(1, DateTime.Now.AddMinutes(5)));
        queue.Enqueue("注文C (VIP, 前)", new OrderPriority(1, DateTime.Now));
        queue.Enqueue("注文D (Regular, 前)", new OrderPriority(2, DateTime.Now.AddMinutes(-5)));

        Console.WriteLine("--- 注文処理順序 ---");
        while (queue.TryDequeue(out string order, out OrderPriority p))
        {
            string rankLabel = p.Rank == 1 ? "VIP" : "Regular";
            Console.WriteLine($"処理: {order} [Rank: {rankLabel}, Time: {p.OrderedAt:HH:mm:ss}]");
        }
    }
}

using System;
using System.Collections.Generic;

class DijkstraExample
{
    // 隣接リスト形式のグラフ (Node, Distance)
    private static Dictionary<char, List<(char Node, int Weight)>> graph = new()
    {
        { 'A', new List<(char, int)> { ('B', 4), ('C', 2) } },
        { 'B', new List<(char, int)> { ('C', 5), ('D', 10) } },
        { 'C', new List<(char, int)> { ('D', 3) } },
        { 'D', new List<(char, int)> { } }
    };

    static void Main()
    {
        char startNode = 'A';
        var distances = SolveDijkstra(startNode);

        Console.WriteLine($"起点 {startNode} からの最短距離:");
        foreach (var kvp in distances)
        {
            Console.WriteLine($"ノード {kvp.Key}: {kvp.Value}");
        }
    }

    static Dictionary<char, int> SolveDijkstra(char start)
    {
        var distances = new Dictionary<char, int>();
        // 優先度付きキュー (Node名, 暫定の最短距離)
        var pq = new PriorityQueue<char, int>();

        pq.Enqueue(start, 0);
        distances[start] = 0;

        while (pq.Count > 0)
        {
            if (!pq.TryDequeue(out char current, out int currentDist)) continue;

            // 既に確定している距離より長い場合はスキップ
            if (distances.ContainsKey(current) && currentDist > distances[current]) continue;

            foreach (var edge in graph[current])
            {
                int newDist = currentDist + edge.Weight;
                if (!distances.ContainsKey(edge.Node) || newDist < distances[edge.Node])
                {
                    distances[edge.Node] = newDist;
                    pq.Enqueue(edge.Node, newDist);
                }
            }
        }
        return distances;
    }
}

private readonly PriorityQueue<string, int> _safeQueue = new();
private readonly object _lockObj = new();

public void SafeEnqueue(string item, int priority)
{
    lock (_lockObj)
    {
        _safeQueue.Enqueue(item, priority);
    }
}