LeetCode 806. 写字符串需要的行数 / 380. O(1) 时间插入、删除和获取随机元素 / 1672. 最富有客户的资产总量

806. 写字符串需要的行数

2022.4.12 每日一题

题目描述

我们要把给定的字符串 S 从左到右写到每一行上，每一行的最大宽度为100个单位，如果我们在写某个字母的时候会使这行超过了100 个单位，那么我们应该把这个字母写到下一行。我们给定了一个数组 widths ，这个数组 widths[0] 代表 ‘a’ 需要的单位， widths[1] 代表 ‘b’ 需要的单位，…， widths[25] 代表 ‘z’ 需要的单位。

现在回答两个问题：至少多少行能放下S，以及最后一行使用的宽度是多少个单位？将你的答案作为长度为2的整数列表返回。

示例 1:

输入:
widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
S = “abcdefghijklmnopqrstuvwxyz”
输出: [3, 60]
解释:
所有的字符拥有相同的占用单位10。所以书写所有的26个字母，
我们需要2个整行和占用60个单位的一行。

示例 2:

输入:
widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
S = “bbbcccdddaaa”
输出: [2, 4]
解释:
除去字母’a’所有的字符都是相同的单位10，并且字符串 “bbbcccdddaa” 将会覆盖 9 * 10 + 2 * 4 = 98 个单位.
最后一个字母 ‘a’ 将会被写到第二行，因为第一行只剩下2个单位了。
所以，这个答案是2行，第二行有4个单位宽度。

注:

字符串 S 的长度在 [1, 1000] 的范围。
S 只包含小写字母。
widths 是长度为 26的数组。
widths[i] 值的范围在 [2, 10]。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-lines-to-write-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

如果超过100了，增加一行

class Solution {
    public int[] numberOfLines(int[] widths, String s) {
        int sum = 0;
        int line = 1;
        for(char c : s.toCharArray()){
            sum += widths[c - 'a'];
            //如果超过了100个字符，令起一行
            if(sum > 100){
                line++;
                sum = widths[c - 'a'];
            }
        }
        return new int[]{line, sum};
    }
}

class Solution:
    def numberOfLines(self, widths: List[int], s: str) -> List[int]:
        line, sum = 1, 0
        for c in s:
            sum += widths[ord(c) - ord('a')]
            if sum > 100:
                sum = widths[ord(c) - ord('a')]
                line += 1
        return [line, sum]

380. O(1) 时间插入、删除和获取随机元素

2022.4.13 每日一题

题目描述

实现RandomizedSet 类：

• RandomizedSet() 初始化 RandomizedSet 对象
• bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
• bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
• int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。

你必须实现类的所有函数，并满足每个函数的 平均 时间复杂度为 O(1) 。

示例：

输入
[“RandomizedSet”, “insert”, “remove”, “insert”, “getRandom”, “remove”, “insert”, “getRandom”]
[[], [1], [2], [2], [], [1], [2], []]
输出
[null, true, false, true, 2, true, false, 2]
解释
RandomizedSet randomizedSet = new RandomizedSet();
randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。

提示：

-2^31 <= val <= 2^31 - 1
最多调用 insert、remove 和 getRandom 函数 2 * 10^5 次
在调用 getRandom 方法时，数据结构中 至少存在一个 元素。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/insert-delete-getrandom-o1
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

其实就是LinkedHashMap，只不过不需要排序
关键点就是删除的时候，怎么做到O1，因为删除以后列表的下标会变
所以需要替换操作来保证O1

class RandomizedSet {
    //list加map，list放元素，map放位置
    //在链表中插入和删除都是O1，随机返回也是O1
    //删除的时候需要特别注意，因为如果直接删除会导致map中元素的位置发生改变
    //而如果更改的话需要on复杂度，因此可以将链表末尾元素放到删除的位置

    List<Integer> list;
    Map<Integer, Integer> map;
    Random rd;


    public RandomizedSet() {
        list = new LinkedList<>();
        map = new HashMap<>();
        rd = new Random();
    }
    
    public boolean insert(int val) {
        if(map.containsKey(val))
            return false;
        list.add(val);
        map.put(val, list.size() - 1);
        return true;
    }
    
    public boolean remove(int val) {
        if(!map.containsKey(val))
            return false;
        int idx = map.get(val);
        //关键，取出链表最后一个数
        int last = list.get(list.size() - 1);
        list.set(idx, last);
        map.remove(val);
        list.remove(list.size() - 1);
        if(last != val)
            map.put(last, idx);
        return true;
    }
    
    public int getRandom() {
        int t = rd.nextInt(list.size());
        return list.get(t);
    }
}

/**
 * Your RandomizedSet object will be instantiated and called as such:
 * RandomizedSet obj = new RandomizedSet();
 * boolean param_1 = obj.insert(val);
 * boolean param_2 = obj.remove(val);
 * int param_3 = obj.getRandom();
 */

看着答案写了一下python的

class RandomizedSet:
    def __init__(self):
        self.nums = []
        self.idx = {}

    def insert(self, val: int) -> bool:
        if val in self.idx:
            return False
        self.idx[val] = len(self.nums)
        self.nums.append(val)
        return True 

    def remove(self, val: int) -> bool:
        if val not in self.idx:
            return False
        loc = self.idx[val]
        last = self.nums[-1]
        self.nums[loc] = last
        self.idx[last] = loc
        del self.idx[val]
        self.nums.pop()
        return True  

    def getRandom(self) -> int:
        return choice(self.nums)


# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()

1672. 最富有客户的资产总量

2022.4.14 每日一题

题目描述

给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i​​​​​​​​​​​​ 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。

客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。

示例 1：

输入：accounts = [[1,2,3],[3,2,1]]
输出：6
解释：
第 1 位客户的资产总量 = 1 + 2 + 3 = 6
第 2 位客户的资产总量 = 3 + 2 + 1 = 6
两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。

示例 2：

输入：accounts = [[1,5],[7,3],[3,5]]
输出：10
解释：
第 1 位客户的资产总量 = 6
第 2 位客户的资产总量 = 10
第 3 位客户的资产总量 = 8
第 2 位客户是最富有的，资产总量是 10

示例 3：

输入：accounts = [[2,8,7],[7,1,3],[1,9,5]]
输出：17

提示：

m == accounts.length
n == accounts[i].length
1 <= m, n <= 50
1 <= accounts[i][j] <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/richest-customer-wealth
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

没想明白这个题的意义何在

class Solution {
    public int maximumWealth(int[][] accounts) {
        int max = 0;
        for(int[] p : accounts){
            int temp = 0;
            for(int t : p){
                temp += t;
            }
            max = Math.max(max, temp);
        }
        return max;
    }
}

用流可能写的更快一点

class Solution {
    public int maximumWealth(int[][] accounts) {
        int maxWealth = Integer.MIN_VALUE;
        for (int[] account : accounts) {
            maxWealth = Math.max(maxWealth, Arrays.stream(account).sum());
        }
        return maxWealth;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/richest-customer-wealth/solution/zui-fu-you-ke-hu-de-zi-chan-zong-liang-b-8p06/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

python这个看不懂，需要继续学习

class Solution:
    def maximumWealth(self, accounts: List[List[int]]) -> int:
        return max(map(sum, accounts))

class Solution:
    def maximumWealth(self, accounts: List[List[int]]) -> int:
        return max(sum(accounts[i])  for i in range(len(accounts)))