小王的Leetcode刷题日记4

最新推荐文章于 2022-09-03 19:35:26 发布

南京小汤包

最新推荐文章于 2022-09-03 19:35:26 发布

阅读量179

点赞数

分类专栏： JAVA python 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/weixin_45438446/article/details/120352903

版权

python 同时被 2 个专栏收录

10 篇文章 1 订阅

订阅专栏

JAVA

3 篇文章 0 订阅

订阅专栏

45、跳跃游戏II
在这里插入图片描述两步贪心

class Solution {
    public int jump(int[] nums) {
        int curr_max = 0;
        int next_max = 0;
        int step = 0;

        for(int i=0;i<nums.length-1;i++){
            if(i+nums[i] > next_max) next_max = i + nums[i];
            if(i==curr_max){
                step++;
                curr_max = next_max;
            }
        }
        return step;
    }
}

###################################
########################################
#############################################
###################################################
#########################################################

47、全排列II
在这里插入图片描述剪枝

DFS JAVA CODE:

class Solution {
    List<List<Integer>> res = new ArrayList<List<Integer>>();
    List<Integer> list = new ArrayList<Integer>();
    int[] visited;
    public List<List<Integer>> permuteUnique(int[] nums) {
        if(nums==null || nums.length==0) return res;
        this.visited = new int[nums.length];
        Arrays.sort(nums);
        dfs(nums);
        return res;
    }
    public void dfs(int[] nums){
        if(list.size() == nums.length){
            res.add(new ArrayList<Integer>(list));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(visited[i] == 1) continue;
            if(i>0 && nums[i] == nums[i-1] && visited[i-1] == 1) continue;
            visited[i] = 1;
            list.add(nums[i]);
            dfs(nums);
            list.remove(list.size()-1);
            visited[i] = 0;
        }
    }
}

48、旋转图像
在这里插入图片描述 gap元素之间的距离

在这里插入图片描述 python code:

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String,ArrayList<String>> result = new HashMap<>();
        for (String s:strs){
            int[] count_table = new int[26];
            for(char c:s.toCharArray()){
                count_table[c-'a']++;
            }
            //Array can not be hashable
            //so we need to make a string can be hashable
            //Connect all value with # [1,2,3] --> #1#2#3
            StringBuilder sb = new StringBuilder();
            for(int count:count_table){
                sb.append("#");
                sb.append(count);
            }
            String key = sb.toString();
            if(!result.containsKey(key)){
                result.put(key,new ArrayList<>());
            }
            result.get(key).add(s);
        }
        return new ArrayList(result.values());
    }
}

50、Pow(x,n)
在这里插入图片描述

class Solution:
    def myPow(self, x: float, n: int) -> float:
        if n<0:
            return 1/self.myPow(x,-n)
        res = 1
        track = x
        while n>0:
            if n & 1:
                res *= track
            track *= track
            n >>= 1
        return res

51、N皇后
在这里插入图片描述 JAVA CODE:

class Solution {
    public List<List<String>> solveNQueens(int n) {
        List<List<String>> res = new ArrayList<>();
        char[][] board = new char[n][n];
        init(board);
        helper(res,board,0);
        return res;
    }
    private void init(char[][] board){
        for(int i=0;i<board.length;i++){
            Arrays.fill(board[i],'.');
        }
    }
    private void helper(List<List<String>> res,char[][] board,int rowIndex){
        if(rowIndex == board.length){
            res.add(generate(board));
            return;
        }
        for(int colIndex=0;colIndex<board.length;colIndex++){
            if(isValid(board,rowIndex,colIndex)){
                board[rowIndex][colIndex] = 'Q';
                helper(res,board,rowIndex+1);
                board[rowIndex][colIndex] = '.';
            }
        }
    }
    private boolean isValid(char[][] board,int rowIndex,int colIndex){
        for(int i=0;i<rowIndex;i++){  //判断同一列是否有Q
            if(board[i][colIndex] == 'Q') return false;
        }
        for(int i=rowIndex-1,j=colIndex-1;i>=0 && j>=0;i--,j--){  //判断左上角是否有Q
            if(board[i][j] == 'Q') return false;
        }
        for(int i=rowIndex-1,j=colIndex+1;i >= 0 && j < board.length;i--,j++){
            if(board[i][j] == 'Q') return false;
        }
        return true;
    }
    private List<String> generate(char[][] board){
        List<String> list = new ArrayList<>();
        for(char[] row:board){
            StringBuilder sb = new StringBuilder();
            for(char c:row){
                sb.append(c);
            }
            list.add(sb.toString());
        }
        return list;
    }
}

PYTHON CODE:

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        self.res = []
        trans = lambda path: ['.'*i+'Q'+'.'*(len(path)-1-i) for i in path]
        def recursion(path,pos):
            if len(path) == n:
                self.res.append(trans(path))
                return
            l,r = pos
            l,r = [i-1 for i in l],[i+1 for i in r]
            total = l+r+path
            for cand in range(n):
                if cand in total:
                    continue
                recursion(path+[cand],[l+[cand],r+[cand]])
        
        recursion([],[[],[]])
        return self.res

#######################################
#######################################
#######################################
#######################################
#######################################
52、N皇后II
在这里插入图片描述 PYTHON CODE:

class Solution:
    def totalNQueens(self, n: int) -> int:
        self.res = 0
        trans = lambda path: ['.'*i+'Q'+'.'*(len(path)-1-i) for i in path]
        def recursion(path,pos):
            if len(path) == n:
                self.res += 1
                return
            l,r = pos
            l,r = [i-1 for i in l],[i+1 for i in r]
            total = l+r+path
            for cand in range(n):
                if cand in total:
                    continue
                recursion(path+[cand],[l+[cand],r+[cand]])
        for i in range(n//2):
            recursion([i],[[i],[i]])
        self.res *= 2
        if n%2:
            recursion([n//2],[[n//2],[n//2]])
        return self.res

######################################################
########################################################
######################################################
########################################################
##################################################

54、螺旋矩阵
在这里插入图片描述 JAVA CODE:

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int[] dx = {0,1,0,-1};  //x上方向
        int[] dy = {1,0,-1,0};  //y上方向
        int m = matrix.length;
        if(m == 0) return new ArrayList<>();
        int n = matrix[0].length;
        int d = 0;
        boolean[][] visited = new boolean[m][n];  //判断是否访问过了
        int x = 0;
        int y = 0;
        List<Integer> res = new ArrayList<>();
        while(res.size() < n*m){
            res.add(matrix[x][y]);
            visited[x][y] = true;
            int nx = x + dx[d];
            int ny = y + dy[d];
            if(nx < m && nx >= 0 && ny < n && ny >= 0 && !visited[nx][ny]){
                x = nx;
                y = ny;
                continue;
            }else{   //位置不在棋盘内，或者访问过了，换个方向
                d = (d+1) % 4;
                nx = x + dx[d];
                ny = y + dy[d];
                x = nx;
                y = ny;
            }
        }
        return res;
    }
}

#############################################
####################################################
################################################
####################
###########################################

55、跳跃游戏
在这里插入图片描述 JAVA CODE:

class Solution {
    public boolean canJump(int[] nums) {
        int n = nums.length;
        boolean[] can = new boolean[n];
        can[n-1] = true;
        for(int i=n-2;i>=0;i--){
            can[i] = false;
            for(int j=i+1;j<=i+nums[i]&&j<n;j++){
                if(can[j]){
                    can[i] = true;
                    break;
                }
            }
        }
        return can[0];
    }
}

在这里插入图片描述贪心算法：局部最优解---->整体最优解

JAVA CODE:

class Solution {
    public boolean canJump(int[] nums) {
        int max_i = 0;
        for(int i=0;i<nums.length;i++){

            if(i > max_i) return false;

            int curr_max = i + nums[i];
            max_i = Math.max(max_i,curr_max)
        }
        return max_i >= nums.length-1;
    }
}

###################################
###########################################
##################################################
#########################################################
##################################################################

58、最后一个单词的长度
在这里插入图片描述 JAVA CODE:

class Solution {
    public int lengthOfLastWord(String s) {
        int res = 0;  //当前长度
        int last = 0;  //上一个非空字母长度
        for(int i=0;i<s.length();i++){
            if(s.charAt(i) == ' '){   //通过 ‘ ’判断单词 遇到一个空格就将res清0
                if(res != 0) last = res;  //如果res不等于0，就把其赋给上一个
                res = 0;  
            }
            else res++;
        }
        return res == 0 ? last:res;
    }
}

JAVA CODE:
通过split截取成一个一个字符串，读最后一个字符长度

class Solution {
    public int lengthOfLastWord(String s) {
        if(s.length() == 0) return 0;
        String[] sp = s.split(" ");
        if(sp.length == 0) return 0;
        return sp[sp.length-1].length();
    }
}

#############################
#################################################
#################################################################
###############################################
################################

59、螺旋矩阵II
在这里插入图片描述 JAVA CODE:

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];
        int top = 0;
        int bottom = n-1;
        int left = 0;
        int right = n-1;
        int cur = 1;
        while(top <= bottom && left <= right){
            for(int j=left;j<=right;j++){
                res[top][j] = cur++;
            }
            top++;
            if(top > bottom) break;
            for(int i=top;i<=bottom;i++){
                res[i][right] = cur++;
            }
            right--;
            if(left > right) break;
            for(int j=right;j>=left;j--){
                res[bottom][j] = cur++;
            }
            bottom--;
            if(top > bottom) break;
            for(int i=bottom;i>=top;i--){
                res[i][left] = cur++;
            }
            left++;
            if(left > right) break;
        }
        return res;
    }
}

######################################
####################
######################################
####################
######################################

60、排列序列
在这里插入图片描述 JAVA CODE:

class Solution {
    public String getPermutation(int n, int k) {
        char[] result = new char[n];
        ArrayList<Integer> nums = new ArrayList<>();
        int[] factorial = new int[n];
        factorial[0] = 1;
        for(int i=1;i<n;i++){
            factorial[i] = factorial[i-1] * i;
        }
        for(int j=1;j<=n;j++){
            nums.add(j);
        }
        k--;
        for(int p=0;p<n;p++){
            result[p]=Character.forDigit(nums.remove(k/factorial[n-1-p]),16);
            //nums.remove 移除表中指定位置的元素，并返回被删元素
            //确定在指定基数中的一个特定数字的字符表示 返回指定基数数字的字符表示 按16进制显示
            k = k%factorial[n-1-p];
        }
        return new String(result);
    }
}

#######################################
####################################################
#########################################
################################################
##################################################################

61、旋转链表
在这里插入图片描述 JAVA CODE:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == null) return head;
        int sz = 0;
        ListNode last = null;
        ListNode cur = head;
        while(cur != null){
            sz++;
            last = cur;
            cur = cur.next;
        }
        k %= sz;
        if(k==0) return head;
        int mv = sz - k;
        cur = head;
        for(int i=1;i<mv;i++){
            cur = cur.next;
        }
        last.next = head;
        head = cur.next;
        cur.next = null;
        return head;
    }
}

###################################
##########################################3
#################################
#############3
#############################################################

62、不同路径
在这里插入图片描述 PYTHON CODE:

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if m == 0 or n == 0:
            return 1
        cache = [[1]*n for _ in range(m)] #放中间的过程
        for i in range(1,m):
            for j in range(1,n):
                cache[i][j] = cache[i-1][j] + cache[i][j-1]
        return cache[-1][-1]

在这里插入图片描述
PYTHON CODE:

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        res = 1
        div = 1
        for i in range(m,m+n-1):
            res *= i
            div *= (i-m+1)
        return res//div

############################
#######################################
#############################################
######################################################
#################################################################

63、不同路径II
在这里插入图片描述
如果障碍物在上方的话，把dp[i-1][j]去掉，如果障碍物在左侧的话，把dp[i][j-1]去掉
JAVA CODE:

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        //创建一个DP数组
        int[][] dp = new int[obstacleGrid.length][obstacleGrid[0].length];
        for(int i=0;i<dp.length;i++){
            for(int j=0;j<dp[0].length;j++){
                if(obstacleGrid[i][j] == 1) continue;
                //当前左边和上面有障碍，无论如何到不了，到不了就是0
                if(i-1 >= 0 && j-1>=0 && obstacleGrid[i][j-1] == 1 && obstacleGrid[i-1][j] == 1){
                    dp[i][j] = 0;
                //上面是障碍
                }else if(i-1 >= 0 && obstacleGrid[i-1][j] == 1){
                    dp[i][j] = j-1 >= 0 ? dp[i][j-1] : 0;
                }else if(j-1 >= 0 && obstacleGrid[i][j-1] == 1 ){
                    dp[i][j] = i-1 >= 0 ? dp[i-1][j] : 0;
                }else{
                    dp[i][j] = ((i-1)>=0?dp[i-1][j]:0) + ((j-1)>=0?dp[i][j-1]:0);
                }
                dp[0][0] = 1;
            }
        }
        return dp[dp.length-1][dp[0].length-1];
    }
}

##############################################
#######################################################
############################
#######################################
#####################################################
64、最小路径和
在这里插入图片描述
JAVA CODE:

class Solution {
    public int minPathSum(int[][] grid) {
        int rows = grid.length;
        int cols = grid[0].length;
        int[][] dp = new int[rows+1][cols+1];
        for(int[] line:dp)   //把dp数组填为最大值
            Arrays.fill(line,Integer.MAX_VALUE);
        
        dp[rows-1][cols] = 0;  //最后一个位置的下方和右边设置为0，这样，最右下角的值就是其本身
        dp[rows][cols-1] = 0;

        for(int x = rows-1;x>=0;x--){ //从下往上、从右往左推
            for(int y = cols-1;y>=0;y--){
                dp[x][y] = Math.min(dp[x+1][y],dp[x][y+1])+grid[x][y];
            }
        }
        return dp[0][0];
    }
}

####################################
################################################
########################################
##############################################
##########################################################

65、有效数字
在这里插入图片描述 PYTHON CODE:
只有一个不能通过

class Solution:
    def isNumber(self, s: str) -> bool:
        s = s.strip()
        if not s: return False
        valid = '.e+-1234567890'
        Exp = Sym = Dec = Num = False
        for c in s:
            if c not in valid:
                return False
            if c == 'e':
                if(not Num) or Exp:
                    return False
                Exp,Num,Sym = True,False,False
            elif c == '.':
                if Exp or Dec:
                    return False
                Dec = True
            elif c in '+-':
                if Sym or Num or (Dec and not Exp):
                    return False
                Sym = True
            else:
                Num = True
        return Num

#########################
#####################################################
##############
##########################################################
#####################################################################

66、加一
在这里插入图片描述 python code:

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        return [int(i) for i in str(int(''.join(str(j) for j in digits))+1)]
        #''.join(str(j) for j in digits)将数组里的字符串合成一个整数

python code：

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for idx in reversed(range(len(digits))): #reversed将正序数组逆序排列
            digits[idx] += 1
            if digits[idx] < 10:
                break
            digits[idx] = 0
        else:
             return [1]+digits
        return digits
        #如果for循环正常结束，else中语句执行。如果break的，则不执行

#############################
##############################
################################
#################################
######################################
68、文本左右对齐
在这里插入图片描述 python code：

class Solution:
    def fullJustify(self, words: List[str], maxWidth: int) -> List[str]:
        res,line,counter = [],[],0  #counter 当前word的长度
        for word in words:
            if counter+len(word)+len(line) > maxWidth:
                for i in range(maxWidth - counter):
                    line[i%max(len(line)-1,1)]+=' '
                res.append(''.join(line))
                line,counter = [],0
            line += [word]
            counter += len(word)
        return res + [' '.join(line).ljust(maxWidth)]    
#python ljust()方法返回一个原字符串左对齐，并使用空格填充至指定长度的新字符串
#str.ljust(width[,fillchar]) 1-指定字符串长度 2-填充字符，默认为空格

############################
####################################
##############################################
###################################################
############################################################
69、Sqrt(x)
在这里插入图片描述 Brute Force JAVA CODE:

class Solution {
    public int mySqrt(int x) {
        if(x<=1) return x;
        for(long s=1;s<=x;++s){
            if(s*s>x) return (int)s-1;
        }
        return -1;
    }
}

Bruet Force Python code:

class Solution:
    def mySqrt(self, x: int) -> int:
        if x <= 1:return x
        s = 1
        while True:
            if s*s > x : return s-1
            s += 1
        return -1

Binary search java code:

class Solution {
    public int mySqrt(int x) {
        int l = 1;
        int r = x;
        while(l <= r){
            int m = l + (r-l)/2;
            if(m > x/m){
                r= m-1;
            }else{
                l= m+1;
            }
        }
        return r;
    }
}

Binary search python code:

class Solution:
    def mySqrt(self, x: int) -> int:
        l = 1
        r = x
        while(l<=r):
            m = l+(r-l)//2
            if m*m > x:
                r = m-1
            else:
                l = m+1
        return r

在这里插入图片描述 Newton java code:

class Solution {
    public int mySqrt(int x) {
        long x1 = x;
        while(x1*x1 > x) x1 = (x1+x/x1)/2;
        return (int)x1;
    }
}

Newton python code:

class Solution:
    def mySqrt(self, x: int) -> int:
        x1 = x
        while x1*x1 > x:
            x1 = (x1 + x // x1) // 2
        return x1

#############################
################################################
#########################################
##############################
#######################################################3
71、简化路径
在这里插入图片描述 python code:

class Solution:
    def simplifyPath(self, path: str) -> str:
        stack = []
        for s in path.split('/'):
            if s == '' or s == '.' or (s == '..' and not stack):
                continue
            if s == '..':
                stack.pop()
            else:
                stack.append(s)
        return '/'+'/'.join(stack)

######################
##########
#########
########################################################
####################################
72、编辑距离
在这里插入图片描述

JAVA CODE:

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        w1,w2,opened = word1,word2,set()
        topens = [(w1,w2,0)]
        while True:
            (w1,w2,value) = topens.pop(0)
            if (w1,w2) in opened:
                continue
            if w1 == w2:
                return value
            opened.add((w1,w2))
            while w1 and w2 and w1[0] == w2[0]:
                w1,w2 = w1[1:],w2[1:]
            value += 1
            topens += [(w1[1:],w2,value),(w1,w2[1:],value),(w1[1:],w2[1:],value)]
        return -1 #Just in case

################
##################
#######################
################
########################
73、矩阵置零
在这里插入图片描述 Python code:

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        self.rows, self.cols = len(matrix), len(matrix[0])
        def modify(x,y):
            for i in range(self.rows):
                if matrix[i][y] != 0:
                    matrix[i][y] = 'm'
            for j in range(self.cols):
                if matrix[x][j] != 0:
                    matrix[x][j] = 'm'
            
        for i in range(self.rows):
            for j in range(self.cols):
                if matrix[i][j] == 0:
                    modify(i,j)
        for i in range(self.rows):
            for j in range(self.cols):
                if matrix[i][j] == 'm':
                    matrix[i][j] = 0
        return

#################
###################
#######################
###########
#####################
74、搜索二维矩阵
在这里插入图片描述
Python code:

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        if not matrix or not matrix[0]:
            return False
        from bisect import bisect_right
        r_idx = bisect_right([x[0] for x in matrix],target) - 1
        c_idx = bisect_right(matrix[r_idx],target) - 1
        return matrix[r_idx][c_idx] == target

#################
############
##################################
########################
##############################

75、颜色分类
在这里插入图片描述
问题关键：找这两条线
java code:

class Solution {
    public void sortColors(int[] nums) {
        int left = 0;
        int right = nums.length-1;  //定义左右两条线
        for(int i=0;i<=right;i++){  //指针从0往右走
            if(nums[i]==0) swap(i,left++,nums);  //如果当前位置为0,将A线往右移
            else if(nums[i] == 2) swap(right--,i--,nums);  //如果当前位置为2,将right位置与i位置互换，再-1,将B线向左移
        }
    }
    public void swap(int i,int j,int[] nums){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

南京小汤包

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
小王的Leetcode刷题日记4

45、跳跃游戏II两步贪心class Solution { public int jump(int[] nums) { int curr_max = 0; int next_max = 0; int step = 0; for(int i=0;i<nums.length-1;i++){ if(i+nums[i] > next_max) next_max = i + nums[i];
复制链接

扫一扫