小王的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];
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;
}
}