[Swift]LeetCode1090. 受标签影响的最大值 | Largest Values From Labels

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/11014404.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

We have a set of items: the i-th item has value values[i] and label labels[i].

Then, we choose a subset S of these items, such that:

• |S| <= num_wanted
• For every label L, the number of items in S with label L is <= use_limit.

Return the largest possible sum of the subset S. 

Example 1:

Input: values = [5,4,3,2,1], labels = [1,1,2,2,3], num_wanted = 3, use_limit = 1
Output: 9
Explanation: The subset chosen is the first, third, and fifth item.

Example 2:

Input: values = [5,4,3,2,1], labels = [1,3,3,3,2], num_wanted = 3, use_limit = 2
Output: 12
Explanation: The subset chosen is the first, second, and third item.

Example 3:

Input: values = [9,8,8,7,6], labels = [0,0,0,1,1], num_wanted = 3, use_limit = 1
Output: 16
Explanation: The subset chosen is the first and fourth item.

Example 4:

Input: values = [9,8,8,7,6], labels = [0,0,0,1,1], num_wanted = 3, use_limit = 2
Output: 24
Explanation: The subset chosen is the first, second, and fourth item. 

Note:

1. 1 <= values.length == labels.length <= 20000
2. 0 <= values[i], labels[i] <= 20000
3. 1 <= num_wanted, use_limit <= values.length

---

我们有一个项的集合，其中第 i 项的值为 values[i]，标签为 labels[i]。

我们从这些项中选出一个子集 S，这样一来：

• |S| <= num_wanted
• 对于任意的标签 L，子集 S 中标签为 L 的项的数目总满足 <= use_limit。

返回子集 S 的最大可能的 和。 

示例 1：

输入：values = [5,4,3,2,1], labels = [1,1,2,2,3], num_wanted = 3, use_limit = 1
输出：9
解释：选出的子集是第一项，第三项和第五项。

示例 2：

输入：values = [5,4,3,2,1], labels = [1,3,3,3,2], num_wanted = 3, use_limit = 2
输出：12
解释：选出的子集是第一项，第二项和第三项。

示例 3：

输入：values = [9,8,8,7,6], labels = [0,0,0,1,1], num_wanted = 3, use_limit = 1
输出：16
解释：选出的子集是第一项和第四项。

示例 4：

输入：values = [9,8,8,7,6], labels = [0,0,0,1,1], num_wanted = 3, use_limit = 2
输出：24
解释：选出的子集是第一项，第二项和第四项。 

提示：

1. 1 <= values.length == labels.length <= 20000
2. 0 <= values[i], labels[i] <= 20000
3. 1 <= num_wanted, use_limit <= values.length

---

188ms

class Solution
{
    struct LabelMap
    {
        let val: Int
        let label: Int
    }
    
    func largestValsFromLabels(_ values: [Int], _ labels: [Int], _ num_wanted: Int, _ use_limit: Int) -> Int
    {
        var data:[LabelMap] = []
        var usedLabel: [Int: Int] = [:]
        
        // form data list
        for i in 0..<values.count
        {
            let label = labels[i]
            data.append(LabelMap(val: values[i], label: label))
            
            if let _ = usedLabel[label] {
                // do nothing
            } else {
                usedLabel[label] = use_limit
            }
        }
        
        // sort by value
        data.sort(by: { (a, b) in
            return a.val > b.val
        })
        
        // iterate
        var sum = 0
        var count = 0
        for i in 0..<data.count
        {
            let d = data[i]
            
            let remindCount = usedLabel[d.label] ?? 0
            if  remindCount > 0
            {
                sum += d.val
                usedLabel[d.label] = remindCount - 1
                
                count += 1
                if count == num_wanted { break }
            }
        }
        
        return sum
    }
}

---

192ms

struct Info {
    var value: Int
    var label: Int
}

class Solution {
    func largestValsFromLabels(_ values: [Int], _ labels: [Int], _ num_wanted: Int, _ use_limit: Int) -> Int {
        let count = values.count
        var array = [Info]()
        for index in 0..<count {
            let info = Info(value: values[index], label: labels[index])
            array.append(info)
        }
        array.sort { $0.value > $1.value }
        var index = 0
        var nums = 0
        var sum = 0
        var dict = [Int: Int]()
        while index < count && nums < num_wanted {
            let item = array[index]
            if let uses = dict[item.label] {
                if uses + 1 > use_limit {
                    index += 1
                    continue
                } else {
                    dict[item.label] = uses + 1
                }
            } else {
                dict[item.label] = 1
            }
            sum += item.value
            nums += 1
            index += 1
        }
        return sum
    }
}

---

200ms

class Solution {
    struct Item {
        var value:Int
        var label:Int
        init(_ value:Int = 0, _ label: Int = 0) {
            self.value = value
            self.label = label
        }
    }
    func largestValsFromLabels(_ values: [Int], _ labels: [Int], _ num_wanted: Int, _ use_limit: Int) -> Int {
        var items = [Item]()
        var dict = [Int: Int]()
        for i in values.indices {
            items.append(Item(values[i], labels[i]))
            dict[labels[i], default: 0] = use_limit
        }
        items.sort(by: { $0.value > $1.value })
        // print(items)
        var count = num_wanted
        var result = 0
        for item in items {
            if count > 0 && dict[item.label]! > 0 {
                result += item.value
                dict[item.label]! -= 1
                count -= 1
            }
            
            if count == 0 {
                return result
            }
        }
        return result
    }
}

---

216ms

class Solution {
    func largestValsFromLabels(_ values: [Int], _ labels: [Int], _ num_wanted: Int, _ use_limit: Int) -> Int {
        var pairs = (0..<values.count).map { (values[$0], labels[$0] ) }
        pairs.sort { $0.0 > $1.0 }
        var num_left = num_wanted
        var selected = [Int:Int]()
        var res = 0
        for (value, label) in pairs where num_left > 0 && (selected[label] ?? 0) < use_limit {
            selected[label] = (selected[label] ?? 0) + 1
            res += value
            num_left -= 1
        }
        return res
    }
}

---

228ms

class Solution {
    func largestValsFromLabels(_ values: [Int], _ labels: [Int], _ num_wanted: Int, _ use_limit: Int) -> Int {
    let zipped = zip(values, labels).sorted{a,b in
        return a.0 > b.0
    }    
    var used: [Int: Int] = [:] // label: times
    var idx = 0
    var numChosen = 0
    var sum = 0
    while idx < values.count {
        if used[zipped[idx].1, default: 0] < use_limit {
            used[zipped[idx].1, default: 0] += 1
            sum += zipped[idx].0
            numChosen += 1
            if numChosen == num_wanted {
                return sum
            }
        }
        
        idx += 1
    }
    
    return sum
    }
}

---

Runtime: 236 ms

Memory Usage: 21.6 MB

class Solution {
    func largestValsFromLabels(_ values: [Int], _ labels: [Int], _ num_wanted: Int, _ use_limit: Int) -> Int {
        var labels = labels
        var num_wanted = num_wanted
        var v:[[Int]] = [[Int]]()
        for i in 0..<values.count
        {
            v.append([values[i], labels[i]])
        }
        v = v.sorted(by:{
            if $0[0] == $1[0]
            {
                return $0[1] >= $1[1]
            }
            else
            {
                return $0[0] >= $1[0]
            }
        })
        
        var ret:Int = 0
        var f:[Int] = [Int](repeating:0,count:20002)
        for i in 0..<v.count
        {
            if num_wanted == 0 {break}
            if f[v[i][1]] < use_limit
            {
                f[v[i][1]] += 1
                num_wanted -= 1
                ret += v[i][0]
            }
        }
        return ret
    }
}