added problem 2462

Author: SHA65536

problems/problem2462/total_cost_hire.go

@@ -0,0 +1,97 @@
+package problem2462
+
+import (
+	"container/heap"
+)
+
+/*
+You are given a 0-indexed integer array costs where costs[i] is the cost of hiring the ith worker.
+You are also given two integers k and candidates. We want to hire exactly k workers according to the following rules:
+    You will run k sessions and hire exactly one worker in each session.
+    In each hiring session, choose the worker with the lowest cost from either the first candidates workers or the last candidates workers.
+	Break the tie by the smallest index.
+        For example, if costs = [3,2,7,7,1,2] and candidates = 2, then in the first hiring session,
+		we will choose the 4th worker because they have the lowest cost [3,2,7,7,1,2].
+        In the second hiring session, we will choose 1st worker because they have the same lowest cost as
+		4th worker but they have the smallest index [3,2,7,7,2].
+		Please note that the indexing may be changed in the process.
+    If there are fewer than candidates workers remaining, choose the worker with the lowest cost among them. Break the tie by the smallest index.
+    A worker can only be chosen once.
+Return the total cost to hire exactly k workers.
+*/
+
+func totalCost(costs []int, k, candidates int) int64 {
+	var res int64
+
+	if len(costs) == 1 {
+		return int64(costs[0])
+	}
+
+	// left and right represent the inner index of the left and right groups
+	left, right := 0, len(costs)-1
+
+	// lPq and rPq are priority que
+	lPq, rPq := MakeHeap(MinHeap), MakeHeap(MinHeap)
+	for i := 0; i < candidates && right > left; i++ {
+		heap.Push(lPq, costs[i])
+		heap.Push(rPq, costs[len(costs)-i-1])
+		left++
+		right--
+	}
+
+	for ; k > 0; k-- {
+		if lPq.Len() == 0 {
+			// If left is empty, take from right
+			res += int64(heap.Pop(rPq).(int))
+			continue
+		} else if rPq.Len() == 0 {
+			// If right is empty, take from left
+			res += int64(heap.Pop(lPq).(int))
+			continue
+		}
+
+		lTemp, rTemp := lPq.Peek(), rPq.Peek()
+		if rTemp < lTemp {
+			// Take from right
+			res += int64(heap.Pop(rPq).(int))
+			if right >= left {
+				// Only push if the groups aren't colliding
+				heap.Push(rPq, costs[right])
+				right--
+			}
+		} else {
+			// Take from left
+			res += int64(heap.Pop(lPq).(int))
+			if right >= left {
+				// Only push if the groups aren't colliding
+				heap.Push(lPq, costs[left])
+				left++
+			}
+		}
+	}
+
+	return res
+}
+
+// Priority queue implementation
+type Heap struct {
+	Values   []int
+	LessFunc func(int, int) bool
+}
+
+func (h *Heap) Less(i, j int) bool { return h.LessFunc(h.Values[i], h.Values[j]) }
+func (h *Heap) Swap(i, j int)      { h.Values[i], h.Values[j] = h.Values[j], h.Values[i] }
+func (h *Heap) Len() int           { return len(h.Values) }
+func (h *Heap) Peek() int          { return h.Values[0] }
+func (h *Heap) Pop() (v interface{}) {
+	h.Values, v = h.Values[:h.Len()-1], h.Values[h.Len()-1]
+	return v
+}
+func (h *Heap) Push(v interface{}) { h.Values = append(h.Values, v.(int)) }
+
+func MakeHeap(less func(int, int) bool) *Heap {
+	return &Heap{LessFunc: less}
+}
+
+func MaxHeap(i, j int) bool { return i > j }
+func MinHeap(i, j int) bool { return i < j }

problems/problem2462/total_cost_hire_test.go

@@ -0,0 +1,41 @@
+package problem2462
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type TestCase struct {
+	Cost         []int
+	K, Candidate int
+	Expected     int64
+}
+
+var TestCases = []TestCase{
+	{[]int{48}, 1, 1, 48},
+	{[]int{20, 10}, 2, 2, 30},
+	{[]int{30, 20, 10}, 3, 3, 60},
+	{[]int{17, 12, 10, 2, 7, 2, 11, 20, 8}, 3, 9, 11},
+	{[]int{1, 2, 4, 1}, 3, 3, 4},
+	{[]int{57, 33, 26, 76, 14, 67, 24, 90, 72, 37, 30}, 11, 2, 526},
+}
+
+func TestTotalCostToHire(t *testing.T) {
+	assert := assert.New(t)
+
+	for _, tc := range TestCases {
+		want := tc.Expected
+		got := totalCost(tc.Cost, tc.K, tc.Candidate)
+		assert.Equal(want, got, fmt.Sprintf("%+v", tc))
+	}
+}
+
+func BenchmarkTotalCostToHire(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, tc := range TestCases {
+			totalCost(tc.Cost, tc.K, tc.Candidate)
+		}
+	}
+}

readme.md

@@ -520,6 +520,7 @@ Each problem is in it's own directory, with test files. There are helper package
 | 2439 | [Minimize Maximum of Array](https://leetcode.com/problems/minimize-maximum-of-array) | [My Solution](./problems/problem2439) | ✅ |
 | 2444 | [Count Subarrays With Fixed Bounds](https://leetcode.com/problems/count-subarrays-with-fixed-bounds) | [My Solution](./problems/problem2444) | ✅ |
 | 2448 | [Minimum Cost to Make Array Equal](https://leetcode.com/problems/minimum-cost-to-make-array-equal) | [My Solution](./problems/problem2448) | ✅ |
+| 2462 | [Total Cost to Hire K Workers](https://leetcode.com/problems/total-cost-to-hire-k-workers) | [My Solution](./problems/problem2462) | ✅ |
 | 2466 | [Count Ways To Build Good Strings](https://leetcode.com/problems/count-ways-to-build-good-strings) | [My Solution](./problems/problem2466) | ✅ |
 | 2477 | [Minimum Fuel Cost to Report to the Capital](https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital) | [My Solution](./problems/problem2477) | ✅ |
 | 2492 | [Minimum Score of a Path Between Two Cities](https://leetcode.com/problems/minimum-score-of-a-path-between-two-cities) | [My Solution](./problems/problem2492) | ✅ |