Day28:回溯法 491.递增子序列 46.全排列 47.全排列 II 332.重新安排行程 51. N皇后 37. 解数独

news2024/11/24 15:47:02

491. 非递减子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]

提示：

  • 1 <= nums.length <= 15
  • -100 <= nums[i] <= 100

思路:

本题和求子集相似,要求取有序子集,但子集不能重复,所以就不能将原数组排序后取子集实现去重,本题也是同一父节点下的同层上使用过的元素就不能再使用了

递归三部曲:

1.确定返回值和参数的类型

定义两个全局变量

List<List<Integer>> result;记录所有结点
    List<Integer> node;记录当前结点

返回值为void,在递归过程中更高全局变量

2.确定递归结束条件

本题其实类似求子集问题，也是要遍历树形结构找每一个节点,但本题收集结果有所不同，题目要求递增子序列大小至少为2

  if(startIndex>nums.length)
        return;
这行代码可以省略,因为startIndex在递归过程中会加1,不会无限递归下去(进不去for循环) 

3.确定单层逻辑

 同一父节点下的同层上使用过的元素就不能再使用了,我们使用set对本层元素去重,注意set只负责本层,所以进入下一层需要清空

将个数大于1的node加入到result

对本层元素去重

递归找到所有node

代码参考:
 

class Solution {
    List<List<Integer>> result = new  LinkedList<>();
    List<Integer> path = new LinkedList<>(); 
   
    public List<List<Integer>> findSubsequences(int[] nums) {
        backTracking(nums,0);
        return result;
    }
    public void backTracking(int[] nums,int startIndex){
                   if(path.size()>1)
            result.add(new LinkedList<>(path));
        if(startIndex == nums.length){
            return;
        }
         Set<Integer> hashSet= new HashSet<>();
        for(int i=startIndex;i<nums.length;i++){
         if(!path.isEmpty()&&nums[i]<path.get(path.size()-1)||hashSet.contains(nums[i])){
            continue;}     
            hashSet.add(nums[i]);
            path.add(nums[i]);
       
            backTracking(nums,i+1);
            path.removeLast();
         
        }
        
    }

}

46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

提示：

  • 1 <= nums.length <= 6
  • -10 <= nums[i] <= 10
  • nums 中的所有整数 互不相同

思路:

思路:用回溯法收集叶节点,用uesd数组记录路径上哪些数字已经使用,实现路径去重,这里就不是树层去重了

递归三部曲:

1.确定返回值和参数的类型

定义两个全局变量List<List<Integer>> result=new ArrayList<>();记录结果集
    List<Integer>path=new LinkedList<>();记录递归路径,也就是全排列的过程

返回值为void,传入需要排列 的数组nums,和数组used(记录递归过程中哪些数被用掉了,实现路径去重)

2.确定递归结束条件

  if(nums.length==path.size()){
            result.add(new ArrayList<>(path));
            return;
        }

nums.length==path.size()时到达叶节点,也就是找到一组全排列了

3.确定单层逻辑

将路径上没用过的数加入路径

代码:

class Solution {
     List<List<Integer>>  result = new LinkedList<>();
     List<Integer> path = new LinkedList<>();

    public List<List<Integer>> permute(int[] nums) {
       boolean[] used = new boolean[nums.length];
         backTracking(nums,used);
   return result;
    }
    public void backTracking(int[] nums,boolean[] used){
        if(path.size()==nums.length){
            result.add(new LinkedList(path));
        }
     for(int i=0;i<nums.length;i++){
        if(used[i]){
            continue;
        }
        path.add(nums[i]);
        used[i]=true;
        backTracking(nums,used);
        used[i]=false;
        path.removeLast();
     }

    }
}

47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示：

  • 1 <= nums.length <= 8
  • -10 <= nums[i] <= 10

思路:本题与上一题区别在于,序列nums包含重复数字, 本题该如何去重 呢?

先将数组排序,让相同的数字排在一起,实现树层去重,利用used数组实现路径去重

i>0&&nums[i-1]==nums[i]&&!used[i-1]:说明在同一层使用了,注意这里的used[i-1]必须为false,只有这样两个相同的数才会出现在同一层

used[i]:说明该数在路径中已经使用了,不能再使用了

代码:

 if(i>0&&nums[i-1]==nums[i]&&!used[i-1]||used[i]){
                continue;
            }

代码参考:

class Solution {
    List<List<Integer>> result= new LinkedList<>();
    List<Integer> path= new LinkedList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
   backTracking(nums,used);
   return result;
    }
    public void backTracking(int[] nums,boolean[] used){
        if(nums.length==path.size()){
            result.add(new LinkedList<>(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(i>0&&nums[i-1]==nums[i]&&!used[i-1]||used[i]){
                continue;
            }
            used[i]=true;
            path.add(nums[i]);
            backTracking(nums,used);
            used[i]=false;
            path.removeLast();
        }
    }
}

332. 重新安排行程

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

  • 例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

示例 1：

输入：tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]
输出：["JFK","MUC","LHR","SFO","SJC"]

示例 2：

输入：tickets = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
输出：["JFK","ATL","JFK","SFO","ATL","SFO"]
解释：另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"] ，但是它字典排序更大更靠后。

提示：

  • 1 <= tickets.length <= 300
  • tickets[i].length == 2
  • fromi.length == 3
  • toi.length == 3
  • fromi 和 toi 由大写英文字母组成
  • fromi != toi

思路:

本题用回溯法,遍历所有的票的使用顺序,由于所有机票至少存在一种合理的行程,我们先将票按照起始位置的开头字母小的排序,递归过程中找到其中一种合理行程就返回,该行程一定是字典排序更小的行程。

递归三部曲:

1.确定返回值和参数的类型

使用全局变量保存结果 ,参数传入所有的票(List<List<String>> tickets),和每张票的使用情况(used[])

由于只取第一个结果,所有返回值类型设置为boolean类型,当找到第一个结果时,就返回true

 List<String> path=new LinkedList<>();
    List<String> result;
boolean travel(List<List<String>> tickets,boolean used[])
2.确定递归结束条件

当记录路径的数组的长度==票的长度+1,说明合理用完了所有票,找到了合理旅游路径,结束递归

   if(path.size()==tickets.size()+1){
            result=new ArrayList<>(path);
            return true;
        }
3.单层递归逻辑

递归找到所有方案

 for(int i=0;i<tickets.size();i++){
            if(!used[i]&&path.get(path.size()-1).equals(tickets.get(i).get(0))){
              path.add(tickets.get(i).get(1));
              used[i]=true;
              //找到第一个方案,结束递归
            if( travel(tickets,used))return true;
              path.remove(path.size()-1);
              used[i]=false;
            }
 
        }
        return false;
总体代码:

class Solution {
    List<String> path=new LinkedList<>();
    List<String> result;
    public List<String> findItinerary(List<List<String>> tickets) {
       boolean[] used=new boolean[tickets.size()];
       //给票排序
       Collections.sort(tickets,(a,b)->a.get(1).compareTo(b.get(1)));
       path.add("JFK");
       travel(tickets,used);
       return result;
    }
    boolean travel(List<List<String>> tickets,boolean used[]){
        if(path.size()==tickets.size()+1){
            result=new ArrayList<>(path);
            return true;
        }
        for(int i=0;i<tickets.size();i++){
            if(!used[i]&&path.get(path.size()-1).equals(tickets.get(i).get(0))){
              path.add(tickets.get(i).get(1));
              used[i]=true;
              //找到第一个方案,结束递归
            if( travel(tickets,used))return true;
              path.remove(path.size()-1);
              used[i]=false;
            }
 
        }
        return false;
    }
}


使用本方法因为排序的原因会出现超时 

改进方法:

用Map<出发机场, Map<到达机场, 航班次数>> map来记录车票,Map<到达机场, 航班次数>为升序TreeMap

class Solution {
    private Deque<String> path = new LinkedList<>();//双端队列,用来存储飞行路径
    private Map<String,Map<String,Integer>> map = new HashMap<>();//hashmap存储一个其他到其他地方的票数
    public List<String> findItinerary(List<List<String>> tickets) {
    for(int i=0;i<tickets.size();i++){
        //统计每个出发地到目的地的票数
        if(map.containsKey(tickets.get(i).get(0))){
            Map<String,Integer> temp= map.get(tickets.get(i).get(0));//获取目的地们与其对应的票数
            temp.put(tickets.get(i).get(1),temp.getOrDefault(tickets.get(i).get(1),0)+1);
            map.put(tickets.get(i).get(0),temp);
        }else{
            Map temp = new TreeMap<>();
            temp.put(tickets.get(i).get(1),1);
          map.put(tickets.get(i).get(0),temp);
        }
    }
  path.add("JFK");
       backTracking(tickets.size());
     return new LinkedList( path);
    }

    public boolean backTracking(int tickets){
       if(path.size()==tickets+1){
        return true;
       }
      String start =  path.getLast();
      //取出同一出发地点的各个机票的目的地和对应的票数
      if(map.get(start)!=null)
       for(Map.Entry<String, Integer> target : map.get(start).entrySet()){
         int  times= target.getValue();
         if(times>0){
            path.add(target.getKey());
            target.setValue(times-1);
           if( backTracking(tickets)){
                    return true;
           }
           path.removeLast();
           target.setValue(times);
         }
       }
       return false;
    }
}

51. N 皇后

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

示例 1：

输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。

示例 2：

输入：n = 1
输出：[["Q"]]

提示：

  • 1 <= n <= 9

皇后们的约束条件：

  1. 不能同行
  2. 不能同列
  3. 不能同斜线

 思路:用回溯法,遍历出所有可以放置的可能性

递归三部曲:

1.确定返回值和参数类型

要把所有能摆放的位置都得出,用全局变量public List<List<String>> result=new ArrayList<>();记录所有合理的棋盘,返回值为void,传入棋盘(char[][] chessboard),要放置的皇后在哪一行(int row),棋盘的宽度(n);

 public void backTracking(int n,int row,char[][] chessboard)

2.确定递归结束条件

当row==n时,说明所有行都放置了皇后,找到了一种合理放法,将该棋盘存入result中,递归结束

 if(row==n){
           List<String> temp= array2List(chessboard);
           result.add(temp);
           return;
       }

3.确定单层递归逻辑

遍历该行的每一个位置并检查其合理性,如果合理,进入下一行棋盘的摆放

for(int i=0;i<n;i++){
        //如果当前位置合法,就递归放下一行
        if(isVaild(chessboard,row,i,n)){
        chessboard[row][i]='Q';
        backTracking(n,row+1,chessboard);
        chessboard[row][i]='.';
        }
       }

class Solution {
    List<List<String>> result = new LinkedList<>();
    List<String> board = new LinkedList<>();
    public List<List<String>> solveNQueens(int n) {
          char[][] chessboard = new char[n][n];
         for(char[] c:chessboard){
        Arrays.fill(c,'.');
         }
         backTracking(n,0,chessboard);
         return result;


    }

    public void backTracking(int n,int row,char[][] chessboard){
        if(row==chessboard.length){
             List<String> temp= array2List(chessboard);
           result.add(temp);
            return;
        }
        for(int i=0;i<chessboard.length;i++){
            if(isVaild(n,chessboard,row,i)){
                chessboard[row][i]='Q';
                backTracking(n,row+1,chessboard);
                chessboard[row][i]='.';
            }
        }

    }
      //将数组转为list
    List<String> array2List(char[][] chessboard){
        List<String> result=new ArrayList<>();
        for(int i=0;i<chessboard.length;i++){
             StringBuilder temp=new StringBuilder();
        for(int j=0;j<chessboard[0].length;j++){
           temp.append(chessboard[i][j]);
        }
        result.add(temp.toString());
        }
        return result;
    }


    public boolean isVaild(int n,char[][] chessboard,int row,int col){
        //检查列
        for(int i=row;i>=0;i--){
            if(chessboard[i][col]=='Q'){
                return false;
            }
        }
        //45°角
        for(int i=row-1,j=col+1;i>=0&&j<n;i--,j++){
            
            if(chessboard[i][j]=='Q'){
                return false;
            }
        }
        //135°
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){
              if(chessboard[i][j]=='Q'){
                return false;
            }
        }
     return true;
    }
}

37. 解数独

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

提示：

  • board.length == 9
  • board[i].length == 9
  • board[i][j] 是一位数字或者 '.'
  • 题目数据 保证 输入数独仅有一个解

37. 解数独

已解答

困难

相关标签

相关企业

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

提示：

  • board.length == 9
  • board[i].length == 9
  • board[i][j] 是一位数字或者 '.'
  • 题目数据 保证 输入数独仅有一个解

思路:n皇后问题一行只需要放一个皇后,本题一行可能填好几个数,所以本题是二维递归 ,

一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！

判断棋盘是否合法
判断棋盘是否合法有如下三个维度：

同行是否重复
同列是否重复
9宫格里是否重复

递归三部曲:

1.确定返回值和参数类型

只有一个解,只需要找一个解,返回类型为boolean,当回溯返回true时,结束当前递归

 Boolean backTracking(char[][] board)

当有多个解时,返回类型为void,需要找遍所有可能

传入棋盘char[][] board

2.确定递归结束条件

本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。

递归的下一层的棋盘一定比上一层的棋盘多一个数，等数填满了棋盘自然就终止（填满当然好了，说明找到结果了），所以不需要终止条件！

3.确定当层逻辑

一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！

class Solution {
    public void solveSudoku(char[][] board) {
    backTracking(board);
    }
public Boolean backTracking(char[][] board){
    for(int i=0;i<9;i++){
    for(int j=0;j<9;j++){
        if(board[i][j]!='.')
        continue;
       for(char c='1';c<='9';c++){
         if(isVaild(i,j,c,board)){
           board[i][j]=c;
        if( backTracking(board)) return true;;
           board[i][j]='.';
         }
       }
       return false;
    }
    }
    return true;
}


      Boolean isVaild(int row,int col,char val,char[][] board){
        //同行是否重复
        for(int i=0;i<9;i++){
            if(board[row][i]==val){
                return false;
            }
        }
        //同列是否重复
        for(int i=0;i<9;i++){
            if(board[i][col]==val){
                return false;
            }
        }
        //9宫格内是否重复
        int startRow=row/3*3;
        int startCol=col/3*3;
        for(int i=startRow;i<startRow+3;i++){
            for(int j=startCol;j<startCol+3;j++){
        if(board[i][j]==val){
            return false;
              }
            }
        }
      return true;
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1852897.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

设计模式学习之——单例模式

设计模式学习之——单例模式

文章目录 单例模式什么叫做单例模式单例模式的动机 单例模式的引入思考 饿汉式单例和懒汉式单例饿汉式单例懒汉式单例 单例模式总结1&#xff0e;主要优点2&#xff0e;主要缺点3&#xff0e;适用场景 单例模式 什么叫做单例模式 顾名思义&#xff0c;简单来说&#xff0c;单…
阅读更多...
（南京观海微电子）——TFT LCD压合技术

（南京观海微电子）——TFT LCD压合技术

TFT-LCD TFT-LCD open cell后段制程主要指的是将驱动IC和PCB压合至液晶板上&#xff0c;这个制程主要由三个步骤组成&#xff1a; 1.ACF (Anisotropic Conductive Film)的涂布。 在液晶板需要压合驱动IC的地方涂布ACF&#xff0c;ACF又称异方性导电胶膜&#xff0c;特点是上下…
阅读更多...
如何看待鸿蒙HarmonyOS？

如何看待鸿蒙HarmonyOS？

鸿蒙系统&#xff0c;自2019年8月9日诞生就一直处于舆论风口浪尖上的系统&#xff0c;从最开始的“套壳”OpenHarmony安卓的说法&#xff0c;到去年的不再兼容安卓的NEXT版本的技术预览版发布&#xff0c;对于鸿蒙到底是什么&#xff0c;以及鸿蒙的应用开发的讨论从来没停止过。…
阅读更多...
贪心算法——最少跳跃步数（C++）

贪心算法——最少跳跃步数（C++）

未来&#xff0c;未来。 ——2024年6月17日 题目描述 给定一个含n&#xff08;1≤n≤1000&#xff09;个非负整数数组nums&#xff08;0≤nums[i]≤1000&#xff09;&#xff0c;数组中的每个元素表示在该位置可以跳跃的最大长度&#xff0c;假设总是可以从初始位置0到达最后一…
阅读更多...
网络文化经营许可证(文网文)办理全面讲解

网络文化经营许可证(文网文)办理全面讲解

随着互联网时代的飞速发展&#xff0c;互联网早已渗透到人们的生活中&#xff0c;各类直播、短视频成为大家生活娱乐必不可少的一部分。注册一家从事互联网行业的企业是一个不错的选择。那互联网企业需要办理什么证件资质呢&#xff1f;在互联网行业从事盈利文化活动必须持有网…
阅读更多...
红队内网攻防渗透：内网渗透之内网对抗：横向移动篇WinRS命令WinRM管理RDP终端密码喷射点CrackMapExec

红队内网攻防渗透：内网渗透之内网对抗：横向移动篇WinRS命令WinRM管理RDP终端密码喷射点CrackMapExec

红队内网攻防渗透 1. 内网横向移动1.1 内网横向移动方法分类1.2 WinRM&WinRS1.2.1 利用条件1.2.1.1 探针可用1.2.1.2 连接执行1.2.1.3 CS上线利用1.2.1.3.1 反向连接上线1.2.1.4 CS内置模块1.2.1.5 其他解决1.3 RDP1.3.1 探针连接1.3.2 连接执行1.3 CrackMapExec-密码喷射1…
阅读更多...
vue3封装菜树，递归展示只显示第一层

vue3封装菜树，递归展示只显示第一层

问题描述 vue3封装菜树&#xff0c;递归展示只显示第一层 解决 需要在递归的组件中导出自己给自己使用
阅读更多...
搜索引擎数据库介绍

搜索引擎数据库介绍

搜索引擎数据库的定义 搜索引擎数据库是一类专门用于数据内容搜索的NoSQL数据库&#xff0c;是非结构化大数据处理分析领域中重要的角色。搜索引擎数据库使用索引对数据中的相似特征进行归类&#xff0c;并提高搜索能力。通过对索引和检索过程的优化&#xff0c;以处理大量文本…
阅读更多...
【进阶篇-Day5：JAVA常用API的使用（Math、BigDecimal、Object、包装类等）】

【进阶篇-Day5：JAVA常用API的使用（Math、BigDecimal、Object、包装类等）】

目录 1、API的概念2、Object类2.1 Object类的介绍2.2 Object的toString()方法2.3 Object的equals()方法2.4 Objects概述 3、Math类4、System类5、BigDecimal类6、包装类6.1 包装类的概念6.2 几种包装类&#xff08;1&#xff09;手动转换包装类&#xff1a;&#xff08;2&#…
阅读更多...
Java项目：基于SSM框架实现的人事管理系统【ssm+B/S架构+源码+数据库+开题报告+毕业论文】

Java项目：基于SSM框架实现的人事管理系统【ssm+B/S架构+源码+数据库+开题报告+毕业论文】

一、项目简介 本项目是一套基于SSM框架实现的人事管理系统 包含&#xff1a;项目源码、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都经过严格调试&#xff0c;eclipse或者idea 确保可以运行&#xff01; 该系统功能完善、界面美观、操作简单、功能齐全…
阅读更多...
RocketMQ 和 Kafka 关于消息队列的推拉模式是怎么做的？

RocketMQ 和 Kafka 关于消息队列的推拉模式是怎么做的？

引言&#xff1a;在当今的大数据和分布式系统中&#xff0c;消息队列扮演着至关重要的角色&#xff0c;它们作为系统之间通信和数据传输的媒介&#xff0c;为各种场景下的数据流动提供了可靠的基础设施支持。在消息队列的设计中&#xff0c;推拉模式是两种常见的消息传递机制&a…
阅读更多...
自制HTML5游戏《贪吃蛇》

自制HTML5游戏《贪吃蛇》

一、游戏简介 贪吃蛇是一款经典的电子游戏&#xff0c;最早在1976年由Gremlin公司推出&#xff0c;名为"Blockade"。游戏的玩法简单却富有挑战性&#xff0c;玩家控制一条蛇在封闭的场地内移动&#xff0c;通过吃食物增长身体&#xff0c;同时避免撞到自己的身体或场…
阅读更多...
webpack处理html资源11--webpack入门学习

webpack处理html资源11--webpack入门学习

处理 Html 资源 1. 下载包 npm i html-webpack-plugin -D 2. 配置 webpack.config.js const path require("path"); const ESLintWebpackPlugin require("eslint-webpack-plugin"); const HtmlWebpackPlugin require("html-webpack-plugin"…
阅读更多...
图解注意力

图解注意力

图解注意力 Part #2: The Illustrated Self-Attention 在文章前面的部分&#xff0c;我们展示了这张图片来展示自注意力被应用于正在处理单词"it"的一层中&#xff1a; 在本节中&#xff0c;我们将看看这是如何完成的。请注意&#xff0c;我们将以一种试图理解单…
阅读更多...
JAVA期末复习2

JAVA期末复习2

目录 一、Java基础知识 1. 下面几个标识符中&#xff0c;哪些是命名正确的 (A) 2. 分析以下代码&#xff0c;哪些是合法的 (C) 3. 以下代码的执行结果是&#xff08; B &#xff09; 4. 下面哪个不是java中的关键字&#xff1f;&#xff08; B &#xff09; 5. 下面对数组…
阅读更多...
编译原理期末复习

编译原理期末复习

BUCT往年试题为导向的复习 标*的为往年真题 目录 1.基本概念 *例题&#xff08;编译主要阶段&#xff09; 编译程序与解释性程序区别 LL(1)概念 2.正则表达式转DFA (1)正则表达式转NFA 第一种方法(编程时常用) 第二种&#xff08;考试时常用&#xff09; &#xff08…
阅读更多...
19 Shell编程之条件语句

19 Shell编程之条件语句

目录 19.1 条件测试操作 19.1.1 文件测试 19.1.1 整数值比较 19.1.3 字符串比较 19.1.4 逻辑测试 19.2 if条件语句 19.2.1 if语句的结构 19.2.2 if语句应用示例 19.3 case分支语句 19.3.1 case语句的结构 19.3.2 case语句应用示例 19.1 条件测试操作 Shell环境根据命令执行后…
阅读更多...
Agile Software Development

Agile Software Development

Individuals and interactions over processes and tools.(个人和协作超过过程和工具) working software over comprehensive documentation.(工作软件超过完全文档) Customer collaboration over contract negotiation.(客户协作超过合同谈判) Responding to change over f…
阅读更多...
数据结构与算法笔记：基础篇 - 初始动态规划：如何巧妙解决“双十一”购物时的凑单问题？

数据结构与算法笔记：基础篇 - 初始动态规划：如何巧妙解决“双十一”购物时的凑单问题？

概述 淘宝的 “双十一” 购物节有各种促销活动&#xff0c;比如 “满 200 元减 50元”。假设你女朋友购物车中有 n 个&#xff08;n > 100&#xff09;想买的商品&#xff0c;它希望从里面选几个&#xff0c;在凑够满减条件的前提下&#xff0c;让选出来的商品价格总和最长…
阅读更多...
urfread刷算法题day4|27. 移除元素+复习

urfread刷算法题day4|27. 移除元素+复习

27. 移除元素 题目描述 给你一个数组 nums 和一个值 val&#xff0c;你需要 原地 移除所有数值等于 val 的元素。 元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。假设 nums 中不等于 val 的元素数量为 k&#xff0c;要通过此题&#xff0c;您需要执行以…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023