【数据结构与算法】leetcode刷题记录(字母异位分组+单调递增的数字)------＞遍历,hashmap

字母异位分组

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"]
输出:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

java

比较思想: char数组排序

统计思想: hashmap

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> l = new LinkedList<>();
        Map<String,List<String>> mmp = new HashMap();
        for (int j = 0; j < strs.length; j++) {
            char[] item1 =  strs[j].toCharArray();
            Arrays.sort(item1);
            if(!mmp.containsKey(new String(item1))){
                List<String> li = new LinkedList<>();
                li.add(strs[j]);
                mmp.put(new String(item1),li);
            }else{
                mmp.get(new String(item1)).add(strs[j]);
            }
        }
        for(List item:mmp.values()){
            l.add(item);
        }
        return l;
    }
}

python

字典模拟hashmap

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        dict1 = {}
        for i in range(0, len(strs)):
            str_in = list(strs[i])
            li = []
            str_in.sort()
            str_on = str(str_in)
            if (str_on not in dict1.keys()):
                li.append(strs[i])
                dict1[ str_on] = li
            else:
                dict1[ str_on].append(strs[i])
        li = []
        for i in dict1.values():
            li.append(i)
        return li

单调递增的数字

给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。

（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）

示例 1:

        输入: N = 10
        输出: 9
示例 2:

        输入: N = 1234
        输出: 1234
示例 3:

        输入: N = 332
        输出: 299

java

从后向前比较,当 i - 1< i 的时候, i -1位的数 减一 , 只到k前的数位单调递增 , 包括后面 i -1 位的也小于 i -2

则记录下k的位置,把该位置以后的数全部替换成 ‘9’

class Solution {
    public int monotoneIncreasingDigits(int N) {
        char[] c1 = String.valueOf(N).toCharArray();
        int n = c1.length;
        int k = n;
        for (int i = n-1; i > 0 ; i--) {
            if(c1[i]<c1[i-1]){
                c1[i-1] -=1;
                k = i;
            }
        }
        for (int i = k; i < n ; i++) {
            c1[i] = '9';
        }
        return Integer.parseInt(new String(c1));
    }
}

python

class Solution:
    def monotoneIncreasingDigits(self, N: int) -> int:
        s = str(N)
        n = len(s)
        char1 = list(s)
        k = n
        i = n-1
        while(i>0):
            if(char1[i]<char1[i-1]):
                char1[i-1] = str(int(char1[i-1])-1)
                k = i
            i-=1
        for i in range(k,n):
            char1[i] = '9'
        a = 0
        for i in char1:
            a = a * 10 + int(i)
        return a