Activity Selection Problem | Greedy Algo-1

// Function to solve the activity selection problem
int activitySelection(int[] start, int[] finish)
{
    List<List<int>> arr = new List<List<int>>();
    for (int i = 0; i < start.Length; i++) {
        arr.Add(new List<int> { start[i], finish[i] });
    }

    // Sort activities by finish time
    arr.Sort((a, b) => a[1].CompareTo(b[1]));
    
    // At least one activity can be performed
    int count = 1;  
    
    // Index of last selected activity
    int j = 0;      

    for (int i = 1; i < arr.Count; i++) {
        
        // Check if current activity starts
        // after last selected activity finishes
        if (arr[i][0] > arr[j][1]) {
            count++;
            
            // Update last selected activity
            j = i;  
        }
    }

    return count;
}

public static void Main()
{
    int[] start = new int[] { 1, 3, 0, 5, 8, 5 };
    int[] finish = new int[] { 2, 4, 6, 7, 9, 9 };
    Console.WriteLine(activitySelection(start, finish));
}

using System;

class GfG {
    // Custom Min-Heap for sorting activities by finish time
    class MinHeap {
        private int[, ] heap;
        private int size;

        public MinHeap(int capacity)
        {
            heap
                = new int[capacity, 2]; // 2D array to store
                                        // (finish, start)
            size = 0;
        }

        // Insert (finish, start) into heap
        public void Insert(int finish, int start)
        {
            heap[size, 0] = finish;
            heap[size, 1] = start;
            size++;
            HeapifyUp(size - 1);
        }

        // Extract min (smallest finish time)
        public(int, int) ExtractMin()
        {
            if (size == 0)
                return (-1, -1); // Empty heap

            int minFinish = heap[0, 0];
            int minStart = heap[0, 1];

            // Move last element to root
            heap[0, 0] = heap[size - 1, 0];
            heap[0, 1] = heap[size - 1, 1];
            size--;

            HeapifyDown(0); // Restore heap property

            return (minFinish, minStart);
        }

        public bool IsEmpty() { return size == 0; }

        // Maintain heap property (heapify up)
        private void HeapifyUp(int index)
        {
            while (index > 0) {
                int parent = (index - 1) / 2;
                if (heap[index, 0] < heap[parent, 0]) {
                    Swap(index, parent);
                    index = parent;
                }
                else
                    break;
            }
        }

        // Maintain heap property (heapify down)
        private void HeapifyDown(int index)
        {
            while (true) {
                int left = 2 * index + 1;
                int right = 2 * index + 2;
                int smallest = index;

                if (left < size
                    && heap[left, 0] < heap[smallest, 0])
                    smallest = left;
                if (right < size
                    && heap[right, 0] < heap[smallest, 0])
                    smallest = right;

                if (smallest != index) {
                    Swap(index, smallest);
                    index = smallest;
                }
                else
                    break;
            }
        }

        // Swap elements in heap
        private void Swap(int i, int j)
        {
            int tempFinish = heap[i, 0];
            int tempStart = heap[i, 1];

            heap[i, 0] = heap[j, 0];
            heap[i, 1] = heap[j, 1];

            heap[j, 0] = tempFinish;
            heap[j, 1] = tempStart;
        }
    }

    // Function to solve the Activity Selection Problem
    // using a Priority Queue (Min-Heap)
    static int activitySelection(int[] start, int[] finish)
    {
        int n = start.Length;
        int ans = 0;

        // Create Min-Heap (acts as Priority Queue)
        MinHeap heap = new MinHeap(n);

        // Insert all activities into the Min-Heap
        for (int i = 0; i < n; i++) {
            heap.Insert(finish[i], start[i]);
        }

        // Variable to track last selected activity's finish
        // time
        int finishtime = -1;

        // Process activities in increasing order of finish
        // time
        while (!heap.IsEmpty()) {
            (int finishTime, int startTime)
                = heap.ExtractMin();

            if (startTime > finishtime) {
                finishtime = finishTime;
                ans++;
            }
        }

        return ans;
    }

    static void Main()
    {
        int[] start = { 1, 3, 0, 5, 8, 5 };
        int[] finish = { 2, 4, 6, 7, 9, 9 };

        Console.WriteLine(activitySelection(start, finish));
    }
}