【leetcode刷题笔记（8）】

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量228 收藏
点赞数
文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zeng_q_yan/article/details/122912882
版权

leetcode刷题笔记（8）

（1）9. 回文数

思路1：负数一定为false，小于10的正数一定为true，个位为0的数一定为false，然后将数字转化为string进行判断。

class Solution {
    public boolean isPalindrome(int x) {
        if(x < 0){
            return false;
        }
        if(x < 10){
            return true;
        }
        if(x % 10 == 0){
            return false;
        }
        String str = String.valueOf(x);
        return strPalidrome(str);  

    }
    public boolean strPalidrome(String str){
        if(str.length() <= 1){
            return true;
        }
        if(str.charAt(0) == str.charAt(str.length()-1)){
            if(str.length()==2){
                return true;
            }else{
                return strPalidrome(str.substring(1,str.length()-1));
            }
        }
        return false;
    }
}

思路2：获得x的逆序数字，判断是否与x相等。

class Solution {
    public boolean isPalindrome(int x) {
        if(x < 0){
            return false;
        }
        int temp = 0;
        int y = 0;
        int num = x;
        while(num > 0){
            temp = num % 10;
            y = y * 10 + temp;
            num = num / 10;
        }
        return x == y;

    }
}

（2）29. 两数相除

思路：使用位运算。

class Solution {
    public int divide(int dividend, int divisor) {
        if (dividend == 0) {
            return 0;
        }
        if (dividend == Integer.MIN_VALUE && divisor == -1) {
            return Integer.MAX_VALUE;
        }
        boolean negative;
        negative = (dividend ^ divisor) <0;//用异或来计算是否符号相异
        long t = Math.abs((long) dividend);
        long d= Math.abs((long) divisor);
        int result = 0;
        for (int i=31; i>=0;i--) {
            if ((t>>i)>=d) {//找出足够大的数2^n*divisor
                result+=1<<i;//将结果加上2^n
                t-=d<<i;//将被除数减去2^n*divisor
            }
        }
        return negative ? -result : result;//符号相异取反
    }
}

（3）46. 全排列（错1）

题解思路：动态规划，使用一个数组存储是否遍历到该数字。

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        int[] visited = new int[nums.length];
        
        childPermute(res, nums,new ArrayList<Integer>(),visited);
        return res;
    }
    public void childPermute(List<List<Integer>> res,int[] nums, List<Integer> temp, int[] visited){
        if(temp.size() == nums.length){
            res.add(new ArrayList<>(temp));
            return;
        }
        for(int i = 0; i < nums.length; i++){
            if(visited[i] == 1){
                continue;
            }else{
                visited[i] = 1;
                temp.add(nums[i]);

                childPermute(res, nums, temp, visited);

                visited[i] = 0;
                temp.remove(temp.size()-1);
            }
        }
    }
}

（4）131. 分割回文串（错1）

题解思路1：回溯+动态规划，

class Solution {
    boolean[][] f;
    List<List<String>> ret = new ArrayList<List<String>>();
    List<String> ans = new ArrayList<String>();
    int n;

    public List<List<String>> partition(String s) {
        n = s.length();
        f = new boolean[n][n];
        for (int i = 0; i < n; ++i) {
            Arrays.fill(f[i], true);
        }

        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                f[i][j] = (s.charAt(i) == s.charAt(j)) && f[i + 1][j - 1];
            }
        }

        dfs(s, 0);
        return ret;
    }

    public void dfs(String s, int i) {
        if (i == n) {
            ret.add(new ArrayList<String>(ans));
            return;
        }
        for (int j = i; j < n; ++j) {
            if (f[i][j]) {
                ans.add(s.substring(i, j + 1));
                dfs(s, j + 1);
                ans.remove(ans.size() - 1);
            }
        }
    }
}

题解思路2：回溯+记忆化搜索

class Solution {
    int[][] f;
    List<List<String>> ret = new ArrayList<List<String>>();
    List<String> ans = new ArrayList<String>();
    int n;

    public List<List<String>> partition(String s) {
        n = s.length();
        f = new int[n][n];

        dfs(s, 0);
        return ret;
    }

    public void dfs(String s, int i) {
        if (i == n) {
            ret.add(new ArrayList<String>(ans));
            return;
        }
        for (int j = i; j < n; ++j) {
            if (isPalindrome(s, i, j) == 1) {
                ans.add(s.substring(i, j + 1));
                dfs(s, j + 1);
                ans.remove(ans.size() - 1);
            }
        }
    }

    // 记忆化搜索中，f[i][j] = 0 表示未搜索，1 表示是回文串，-1 表示不是回文串
    public int isPalindrome(String s, int i, int j) {
        if (f[i][j] != 0) {
            return f[i][j];
        }
        if (i >= j) {
            f[i][j] = 1;
        } else if (s.charAt(i) == s.charAt(j)) {
            f[i][j] = isPalindrome(s, i + 1, j - 1);
        } else {
            f[i][j] = -1;
        }
        return f[i][j];
    }
}

（5）38. 外观数列

思路：使用一个函数生成对前一项数字的描述，for循环逐次生成。

class Solution {
    public String countAndSay(int n) {
        String str = "1";
        if(n == 1){
            return str;
        }
        for(int i = 2; i <= n; i++){
            str = transfer(str);
        }
        return str;
    }

    public String transfer(String str){
        String res = "";
        int left = 0;
        int right = 1;
        char temp = str.charAt(0);
        while(right <= str.length()){
            while(right < str.length() && str.charAt(right) == temp){
                right++;
            }
            res += (String.valueOf(right - left) + String.valueOf(temp));
            if(right < str.length()){
                temp = str.charAt(right);
            }
            left = right;
            right++;
        }
        return res;
    }
}

（6）132. 分割回文串 II

class Solution {
    public int minCut(String s) {
        int n = s.length();
        boolean[][] g = new boolean[n][n];
        for (int i = 0; i < n; ++i) {
            Arrays.fill(g[i], true);
        }

        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                g[i][j] = s.charAt(i) == s.charAt(j) && g[i + 1][j - 1];
            }
        }

        int[] f = new int[n];
        Arrays.fill(f, Integer.MAX_VALUE);
        for (int i = 0; i < n; ++i) {
            if (g[0][i]) {
                f[i] = 0;
            } else {
                for (int j = 0; j < i; ++j) {
                    if (g[j + 1][i]) {
                        f[i] = Math.min(f[i], f[j] + 1);
                    }
                }
            }
        }

        return f[n - 1];
    }
}

（7）59. 螺旋矩阵 II

思路：模拟，flag表示当前方向，对于每种方向而言，发生转向所转的方向是固定的，故只需考虑到各种发生转向的情形。

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] matrix = new int[n][n];
        if(n == 1){
            matrix[0][0] = 1;
            return matrix;
        }
        int flag = 1;
        int cur = 1;
        int i = 0;
        int j = 0;
        while(cur <= n*n){
            matrix[i][j] = cur;
            cur++;
            if(flag == 1){
                if(j < n-1 && matrix[i][j+1] == 0){
                    j++;
                }else{
                    if(matrix[i+1][j] == 0){
                        flag = 2;
                        i++;
                    }else{
                        break;
                    }
                }
            }else if(flag == 2){
                if(i < n-1 && matrix[i+1][j] == 0){
                    i++;
                }else{
                    if(matrix[i][j-1] == 0){
                        flag = 3;
                        j--;
                    }else{
                        break;
                    }
                }
            }else if(flag == 3){
                if(j > 0 && matrix[i][j-1] == 0){
                    j--;
                }else{
                    if(matrix[i-1][j] == 0){
                        flag = 4;
                        i--;
                    }else{
                        break;
                    }
                }
            }else{
                if(i > 0 && matrix[i-1][j] == 0){
                    i--;
                }else{
                    if(matrix[i][j+1] == 0){
                        flag = 1;
                        j++;
                    }else{
                        break;
                    }
                }
            }
        }
        return matrix;
    }
 }

思路2：

class Solution {
    public int[][] generateMatrix(int n) {
        int ub = 0;
        int lb = n-1;
        int left = 0;
        int right = n-1;
        int[][] matrix = new int[n][n];
        int cur = 1;
        while(cur <= n*n){
            if(ub <= lb){
                for(int i = left; i <= right; i++){
                    matrix[ub][i] = cur;
                    cur++;
                }
                ub++;
            }
            if(left <= right){
                for(int i = ub; i <= lb; i++){
                    matrix[i][right] = cur;
                    cur++;
                }
                right--;
            }
            if(ub <= lb){
                for(int i = right; i >= left; i--){
                    matrix[lb][i] = cur;
                    cur++;
                }
                lb--;
            }
            if(left <= right){
                for(int i = lb; i >= ub; i--){
                    matrix[i][left] = cur;
                    cur++;
                }
                left++;
            }
        }
        return matrix;
    }
}

（8）48. 旋转图像

思路：先将矩阵对称，再对矩阵的每一行进行reverse。

class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        int temp;
        for(int i = 0; i < n; i++){
            for(int j = i; j < n; j++){
                temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }

        for(int i = 0; i < n; i++){
            int left = 0;
            int right = n-1;
            while(left < right){
                temp = matrix[i][left];
                matrix[i][left] = matrix[i][right];
                matrix[i][right] = temp;
                left++;
                right--;
            }
        }
    }
}

（9）54. 螺旋矩阵

思路1：模拟，flag表示当前方向，对于每种方向而言，发生转向所转的方向是固定的，故只需考虑到各种发生转向的情形。对于已经遍历过的位置，将其置为不可能的数，用以标记。

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int n = matrix.length;
        int m = matrix[0].length;
        
        List<Integer> res = new ArrayList<Integer>();
        if(n == 1 && m == 1){
            res.add(matrix[0][0]);
            return res;
        }
        int flag = 1;
        int count = 1;
        int i = 0;
        int j = 0;
        while(count <= n*m){
            res.add(matrix[i][j]);
            matrix[i][j] = 1000;
            count++;
            if(flag == 1){
                if(j < m-1 && matrix[i][j+1] != 1000){
                    j++;
                }else{
                    if(i < n-1 && matrix[i+1][j] != 1000){
                        flag = 2;
                        i++;
                    }else{
                        break;
                    }
                }
            }else if(flag == 2){
                if(i < n-1 && matrix[i+1][j] != 1000){
                    i++;
                }else{
                    if(j > 0 && matrix[i][j-1] != 1000){
                        flag = 3;
                        j--;
                    }else{
                        break;
                    }
                }
            }else if(flag == 3){
                if(j > 0 && matrix[i][j-1] != 1000){
                    j--;
                }else{
                    if(i > 0 && matrix[i-1][j] != 1000){
                        flag = 4;
                        i--;
                    }else{
                        break;
                    }
                }
            }else{
                if(i > 0 && matrix[i-1][j] != 1000){
                    i--;
                }else{
                    if(j < m-1 && matrix[i][j+1] != 1000){
                        flag = 1;
                        j++;
                    }else{
                        break;
                    }
                }
            }
        }
        return res;

    }
}

思路2：方向变化的规律是一致的，故可以不需要对方向进行标记，在进行遍历的过程中，不断缩小矩阵的范围。

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int n = matrix.length;
        int m = matrix[0].length;
        int up = 0;
        int down = n-1;
        int left = 0;
        int right = m-1;

        List<Integer> res = new ArrayList<Integer>();
        int count = 0;
        while(count < n*m){
            if(up <= down){
                for(int i = left; i <= right; i++){
                    res.add(matrix[up][i]);
                    count++;
                }
                up++;
            }

            if(left <= right){
                for(int i = up; i <= down; i++){
                    res.add(matrix[i][right]);
                    count++;
                }
                right--;
            }

            if(up <= down){
                for(int i = right; i >= left; i--){
                    res.add(matrix[down][i]);
                    count++;
                }
                down--;
            }

            if(left <= right){
                for(int i = down; i >= up; i--){
                    res.add(matrix[i][left]);
                    count++; 
                }
                left++;
            }
        }
        return res;
    }
}

（10）1288. 删除被覆盖区间

思路：两两区间进行比较，使用一个数组记录是否被删除，遍历完成后，统计没有被删除的数组数量。

class Solution {
    public int removeCoveredIntervals(int[][] intervals) {
        int n = intervals.length;
        int[] deleted = new int[n];
        for(int i = 0; i < n; i++){
            for(int j = i+1; j < n; j++){
                if(deleted[i] == 0 && deleted[j] == 0){
                    int[] temp1 = intervals[i];
                    int[] temp2 = intervals[j];
                    if(temp1[0] <= temp2[0] && temp1[1] >= temp2[1]){
                        deleted[j] = 1;
                    }else if(temp1[0] >= temp2[0] && temp1[1] <= temp2[1]){
                        deleted[i] = 1;
                    }
                }
            }
        }
        int res = 0;
        for(int i = 0; i < n; i++){
            if(deleted[i] == 0){
                res++;
            }
        }
        return res;
    }
}

思路2：贪心算法，

class Solution {
  public int removeCoveredIntervals(int[][] intervals) {
    Arrays.sort(intervals, new Comparator<int[]>() {
      @Override
      public int compare(int[] o1, int[] o2) {
        return o1[0] == o2[0] ? o2[1] - o1[1]: o1[0] - o2[0];
      }
    });

    int count = 0;
    int end, prev_end = 0;
    for (int[] curr : intervals) {
      end = curr[1];
      if (prev_end < end) {
        ++count;
        prev_end = end;
      }
    }
    return count;
  }
}
eyeyeyyyyys
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode - 按标签分类刷题（字符串题解）——回文串系列
your_棒棒糖的博客
04-20 306
回文数 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。 示例 1: 输入: 121 输出: true 复制代码 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。 复制代码 示例 3: 输入: 10 输出: false 解释: 从右向左读, 为 01 。因此它不是一个回文数。 普通解法 先将 整数转为字符串 ，然后将字符串分割为数组，只需要循环数组的一半长度进行
leetcode刷题笔记
m0_58600477的博客
12-31 1491
这里写目录标题剑指offer1.整数除法2.二进制加法3.前 n 个数字二进制中 1 的个数4.只出现一次的数字5.单词长度的最大乘积6.排序数组中两个数字之和7.数组中和为 0 的三个数8.和大于等于 target 的最短子数组9.乘积小于 K 的子数组10.和为 k 的子数组11.0 和 1 个数相同的子数组12.左右两边子数组的和相等反转链表 剑指offer.....................
LeetCode - 9.回文数 -简单
weixin_42374413的博客
06-26 139
基于Java的一些结题总结。 一、题目描述 二、解题思路 先把整数转化为字符串，然后从两端向中间逐一比较字符。 三、自写代码 class Solution { public boolean isPalindrome(int x) { if(x < 0) return false; String str = String.valueOf(x); int length = str.length(); i
【leetcode】数学 - 回文数
码农研究僧的博客
10-30 2447
题目： 给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。 回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。 示例 1： 输入：x = 121 输出：true 示例 2： 输入：x = -121 输出：false 解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。 示例 3： 输入：x = 10 输出：false 解释：从右向左读, 为 01 。因此它不是一个回文数
每日一道算法（判断是否是回文数）
weixin_44912627的博客
01-07 261
JAVA解答 ： class Solution { public boolean isPalindrome(int x) { //思路：//如果是负数的话肯定不是回文数了,如果末尾数字是0 也不是回文数 if( x < 0 || ( x % 10 == 0 && x != 0 ) ){ return false; } //反转一半，进行比较 int reverseNumber = 0; ..
LeetCode刷题笔记
m0_73731708的博客
06-12 911
第二遍重新遍历链表，同时记录前缀和 sum，哈希表中对应 sum 的节点是最后一次出现相同前缀和的节点，我们将这个节点的下一个节点，赋值给当前节点的下一个节点，中间跳过的部分总和即为 0。给你一个链表的头节点 head，反复删去链表中总和值为 0 的连续节点组成的序列。遍历一遍链表，同时记录前缀和，以当前前缀和为 key，当前节点为，存入哈希表中。简单来说就是，在原来链表基础上，头部添加0，利用前缀和的性质，前轴和相同时，两者之间的和为0(包括后一个)；两数之和梦开始的地方，让我们开始追逐自己的梦想吧！
Leetcode刷题笔记
qq_40636667的博客
03-17 160
1,首先从后向前查找第一个顺序对（i,i+1），满足a[i] < a[i+1] ,(后一个元素比前一个元素大，从i开始就不满足降序序列了)，比如例子中的4，从4开始不满足关系式a[i] < a[i+1]2.找到了顺序对，在区间[ i+1,n)中从后向前查找第一个元素j满足a[i] < a[j]. 较大数即为 a[j]， 比如例子中的5.3.交换a[i] 和a[j], 则【i+1,n)必定是降序。下一个排列 举例：1，2，3，4，5 -> 1，2，3，5，4。对于长度为n的排列a,
LeetCode刷题笔记 --- python
纸短情长的博客
01-21 2189
Leecode刷题笔记
leetcode刷题笔记目录
timoraty的博客
09-27 159
leetcode刷题笔记目录，持续更新 按题号 题号 题目 题解 难度 标签 445 分发饼干 c++ 贪心算法 按算法
阿里大神的Leetcode刷题笔记.PDF
涛哥聊Python
03-28 1159
点击上方蓝色小字，关注“涛哥聊Python”重磅干货，第一时间送达今天推荐一个阿里朋友的算法刷题的开源项目。截至 2020 年 11 月，该开源项目配套的网站已经有一百二十万的访问量，在 ...
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
谷歌高畅Leetcode刷题笔记.pdf
08-04
谷歌高畅leetcode刷题笔记
【Leetcode刷题笔记】栈
12-22
【栈在LeetCode中的应用】 在LeetCode等算法题库中，栈是一种非常常见的数据结构，用于解决多种问题。本文将深入探讨栈在处理有效括号问题中的应用，即LeetCode第20题《有效的括号》。 1. **有效的括号问题**： -...
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 142
C语言 | Leetcode C语言题解之第337题打家劫舍III
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 211
【代码】【长度最小的子数组】python刷题记录。
Java | Leetcode Java题解之第337题打家劫舍III
m0_57195758的博客
08-15 231
Java | Leetcode Java题解之第337题打家劫舍III
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 201
C++ | Leetcode C++题解之第337题打家劫舍III
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值