good problem

Author: dingjikerbo

README.md

@@ -393,5 +393,6 @@
 |703|[Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/)|[Java](leetcode/solution/src/KthLargestElementInAStream.java)|100||
 |771|[Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/)|[Java](leetcode/solution/src/JewelsAndStones.java)|100||
 |819|[Most Common Word](https://leetcode.com/problems/most-common-word/)|[Java](leetcode/solution/src/MostCommonWord.java)|85||
+|857|[Minimum Cost to Hire K Workers](https://leetcode.com/problems/minimum-cost-to-hire-k-workers/)|[Java](leetcode/solution/src/MinimumCostToHireKWorkers.java|70||
 |904|[Fruit Into Baskets](https://leetcode.com/problems/fruit-into-baskets/)|[Java](leetcode/solution/src/FruitIntoBaskets.java)|90||
 |929|[Unique Email Addresses](https://leetcode.com/problems/unique-email-addresses/)|[Java](leetcode/solution/src/UniqueEmailAddresses.java)|90||

leetcode/solution/src/MinimumCostToHireKWorkers.java

@@ -0,0 +1,55 @@
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+public class MinimumCostToHireKWorkers {
+
+    class Man {
+        int quality;
+        int wage;
+
+        Man(int a, int b) {
+            quality = a;
+            wage = b;
+        }
+
+        double ratio() {
+            return (double) wage / quality;
+        }
+    }
+
+    /**
+     * 这题意思是选取K个工人，保证付给他们的工资和quality的比例都是一样的，且不低于他们的期望工资，问最少付的工资是多少
+     * 定义性价比为wage/quality，这个值越小表示性价比越高
+     * 将所有工人按性价比排序，显然要少付工资，当然尽可能选取更多的高性价比工人
+     * 为了满足所有人工资和quality比例都一样，这个比例显然是所选的K个工人中性价比最低的那个
+     * 不能完全按性价比来，因为可能存在的情况是高性价比quality也高，在ratio一定的情况下，要付出的总工资也多
+     * 所以要对性价比从高到低地遍历工人，边遍历边当满足K个人数的时候计算要付出的工资，人数超的时候踢掉quality最高的那个人，因为越往后遍历ratio越大，那么总体的quality
+     * 要尽可能小才行
+     */
+    public double mincostToHireWorkers(int[] quality, int[] wage, int K) {
+        Queue<Man> queue = new PriorityQueue<>(new Comparator<Man>() {
+            @Override
+            public int compare(Man o1, Man o2) {
+                return o1.ratio() > o2.ratio() ? 1 : -1;
+            }
+        });
+        for (int i = 0; i < quality.length; i++) {
+            queue.offer(new Man(quality[i], wage[i]));
+        }
+        double money = Integer.MAX_VALUE, qsum = 0;
+        Queue<Integer> queue2 = new PriorityQueue<>(Comparator.reverseOrder());
+        while (!queue.isEmpty()) {
+            Man man = queue.poll();
+            qsum += man.quality;
+            queue2.offer(man.quality);
+            if (queue2.size() > K) {
+                qsum -= queue2.poll();
+            }
+            if (queue2.size() == K) {
+                money = Math.min(money, qsum * man.ratio());
+            }
+        }
+        return money;
+    }
+}

leetcode/src/Main.java

@@ -4,43 +4,57 @@
 
 public class Main {
 
-    public static class Solution {
+    static class Man {
+        int quality;
+        int wage;
 
-        public int kEmptySlots(int[] flowers, int k) {
-            int[] days = new int[flowers.length];
-            for (int i = 0; i < flowers.length; i++) days[flowers[i] - 1] = i + 1;
-            int left = 0, right = k + 1, res = Integer.MAX_VALUE;
-            for (int i = left + 1; i <= right && right < days.length; i++) {
-                if (i == right) {
-                    res = Math.min(res, Math.max(days[left], days[right]));
-                }
+        Man(int a, int b) {
+            quality = a;
+            wage = b;
+        }
 
-                if (days[i] < days[left] || days[i] < days[right]) {
-                    left = i;
-                    right = k + 1 + i;
+        double ratio() {
+            return (double) wage / quality;
+        }
+    }
+
+    public static class Solution {
+        public double mincostToHireWorkers(int[] quality, int[] wage, int K) {
+            Queue<Man> queue = new PriorityQueue<>(new Comparator<Man>() {
+                @Override
+                public int compare(Man o1, Man o2) {
+                    return o1.ratio() > o2.ratio() ? 1 : -1;
                 }
+            });
+            for (int i = 0; i < quality.length; i++) {
+                queue.offer(new Man(quality[i], wage[i]));
             }
-            return (res == Integer.MAX_VALUE) ? -1 : res;
+            double money = Integer.MAX_VALUE, qsum = 0;
+            Queue<Integer> queue2 = new PriorityQueue<>(Comparator.reverseOrder());
+            while (!queue.isEmpty()) {
+                Man man = queue.poll();
+                qsum += man.quality;
+                queue2.offer(man.quality);
+                if (queue2.size() > K) {
+                    qsum -= queue2.poll();
+                }
+                if (queue2.size() == K) {
+                    money = Math.min(money, qsum * man.ratio());
+                }
+            }
+            return money;
         }
-
     }
 
     public static void main(String[] args) {
         Solution solution = new Solution();
 
-        TreeMap<Integer, Boolean> map = new TreeMap<>();
-        int[] nums = {4, 1, 7, 5, 2, 8, 10, 0};
-        for (int n : nums) {
-            map.put(n, true);
-        }
-        for (int k : map.keySet()) {
-            System.out.print(k + " ");
-        }
-
-        int n = solution.kEmptySlots(new int[]{
-                1, 2, 3
-        }, 1);
-        System.out.println(n);
+        double s = solution.mincostToHireWorkers(new int[] {
+                3,1,10,10,1
+        }, new int[] {
+                4,8,2,2,7
+        },3);
 
+        System.out.println(s);
     }
 }