面试经典150题(32-37)

leetcode 150道题 计划花两个月时候刷完，今天（第十五天）完成了6道(32-37)150：

今天刚好有点没精神的感觉，然后碰到的题也不难。。天意！！！

32.（289. 生命游戏）题目描述：

根据 百度百科 ， 生命游戏 ，简称为 生命 ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。
给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：
如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
如果死细胞周围正好有三个活细胞，则该位置死细胞复活；
下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。

第一版（这个题只需要记住他是同时发生的，不是一个变了还能影响下一个判断，然后就是模拟遍历就行了）

class Solution {
    int m;
    int n;
    public void gameOfLife(int[][] board) {
        m=board.length-1;
        n=board[0].length-1;
        int[][] res=new int[m+1][n+1];
        for(int i=0;i<=m;i++){
            for(int j=0;j<=n;j++){
                res[i][j]=genOneLife(board,i,j);
            }
        }
        for(int i=0;i<=m;i++){
            for(int j=0;j<=n;j++){
                board[i][j]=res[i][j];
            }
        }
    }
    public int genOneLife(int[][] board,int x,int y){
        int temp=board[x][y];
        int aroudLiveCount=0;
        if(x-1>=0)
        {
            aroudLiveCount+=board[x-1][y];
            if(y-1>=0){
                aroudLiveCount+=board[x-1][y-1];
            }
            if(y+1<=n){
                aroudLiveCount+=board[x-1][y+1];
            }
        }
        if(x+1<=m){
            aroudLiveCount+=board[x+1][y];
            if(y-1>=0){
                aroudLiveCount+=board[x+1][y-1];
            }
            if(y+1<=n){
                aroudLiveCount+=board[x+1][y+1];
            }
        }
        if(y-1>=0){
            aroudLiveCount+=board[x][y-1];
        }
        if(y+1<=n){
            aroudLiveCount+=board[x][y+1];
        }
        if(temp==1){
            if(aroudLiveCount<2||aroudLiveCount>3){
                return 0;
            }
            return 1;
        }else{
            if(aroudLiveCount==3){
                return 1;
            }
            return 0;
        }
    }
}

33.（383. 赎金信）题目描述：

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

第一版（就是统计）

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] letterNums=new int[26];
        for(char ch:magazine.toCharArray()){
            letterNums[ch-97]++;
        }
        for(char ch:ransomNote.toCharArray()){
            if(letterNums[ch-97]<=0){
                return false;
            }
            letterNums[ch-97]--;
        }
        return true;
    }
}

34.(205. 同构字符串) 题目描述：

给定两个字符串 s 和 t ，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

第一版（这个题我之前做过，就是必须两个map a->b 然后 b->a 判断时候 就是从两个map里面拿出的也要对上）

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int sLen=s.length();
        int tLen=t.length();
        if(sLen!=tLen){
            return false;
        }
        Map<Character,Character> s2tMap=new HashMap();
        Map<Character,Character> t2sMap=new HashMap();
        for(int i=0;i<sLen;i++){
            char sChar=s.charAt(i);
            char tChar=t.charAt(i);
            if(s2tMap.get(tChar)==null&&t2sMap.get(sChar)==null){
                s2tMap.put(tChar,sChar);
                t2sMap.put(sChar,tChar);
            }else if(s2tMap.get(tChar)==null||t2sMap.get(sChar)==null){
                return false;
            }else{
                if(!s2tMap.get(tChar).equals(sChar)||!t2sMap.get(sChar).equals(tChar)){
                    return false;
                }
            }
        }
        return true;
    }
}

35.（290. 单词规律）题目描述：

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

第一版（和上面那个题一模一样，我是直接复制过了改了一下。。。，今天这些题都感觉不是很难。。）

class Solution {
    public boolean wordPattern(String pattern, String s) {
        String[] strs=s.split(" ");
        int sLen=strs.length;
        int pLen=pattern.length();
        if(sLen!=pLen){
            return false;
        }
        Map<Character,String> ptsMap=new HashMap();
        Map<String,Character> stpMap=new HashMap();
        for(int i=0;i<pLen;i++){
            char pChar=pattern.charAt(i);
            String str=strs[i];
            if(ptsMap.get(pChar)==null&&stpMap.get(str)==null){
                ptsMap.put(pChar,str);
                stpMap.put(str,pChar);
            }else if(ptsMap.get(pChar)==null||stpMap.get(str)==null){
                return false;
            }else{
                if(!ptsMap.get(pChar).equals(str)||!stpMap.get(str).equals(pChar)){
                    return false;
                }
            } 
        }
        return true;
    }
}

36.（242. 有效的字母异位词）题目描述：

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

第一版（还是统计。。）

class Solution {
    public boolean isAnagram(String s, String t) {
    // 我感觉加了这个 最后就不需要再去遍历一遍 letterCount 了吧。。我看解题都是还遍历了一遍这个看是不是都为0
        if(s.length()!=t.length()){
            return false;
        }
        int[] letterCount=new int[26];
        for(char ch:s.toCharArray()){
            letterCount[ch-'a']++;
        }
        for(char ch:t.toCharArray()){
            if(letterCount[ch-'a']<=0){
                return false;
            }
            letterCount[ch-'a']--;
        }
        return true;
    }
}

37.（49. 字母异位词分组）题目描述：

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
示例 1:
输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

第一版（由于上一个刚做完怎么判断于是我就把上个题判断方法复制过来，然后遍历就ok，但是最后超过了6%。。）

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> res=new ArrayList();
        int len=strs.length;
        if(len==0){
            return res;
        }
        if(len==1){
            List<String> temp=new ArrayList();
            temp.add(strs[0]);
            res.add(temp);
            return res;
        }
        int[] flag=new int[len];
        for(int i=0;i<len;i++){
            if(flag[i]!=0){
                continue;
            }
            List<String> temp=new ArrayList();
            temp.add(strs[i]);
            for(int j=i+1;j<len;j++){
                if(isAnagram(strs[i],strs[j]))
                {
                    temp.add(strs[j]);
                    flag[j]=1;
                }
            }
            
            res.add(temp);
            
        }
        return res;
        
    }
    public boolean isAnagram(String s, String t) {
            if(s.length()!=t.length()){
                return false;
            }
            int[] letterCount=new int[26];
            for(char ch:s.toCharArray()){
                letterCount[ch-'a']++;
            }
            for(char ch:t.toCharArray()){
                if(letterCount[ch-'a']<=0){
                    return false;
                }
                letterCount[ch-'a']--;
            }
            return true;
    }
 }

第二版（看了解题，真的这个排序作为 key，太秀了！！！）

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String,List<String>> map=new HashMap();
        for(String str:strs){
            char[] temp=str.toCharArray();
            Arrays.sort(temp);
            String key=new String(temp);
            List<String> list=map.getOrDefault(key,new ArrayList());
            list.add(str);
            map.put(key,list);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

今天早点收工，手机瘾犯了，想刷视频。。。

加油，早日跳槽！！！