专题【树】刷题日记【基础】

最新推荐文章于 2024-05-22 20:47:51 发布
最新推荐文章于 2024-05-22 20:47:51 发布
阅读量791 收藏 10
点赞数 26
分类专栏： 备战P7 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LaMole_Ryouji/article/details/138473920
版权

题目列表

144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历
102. 二叉树的层序遍历
107. 二叉树的层序遍历 II
103. 二叉树的锯齿形层序遍历
105. 从前序与中序遍历序列构造二叉树
106. 从中序与后序遍历序列构造二叉树

144. 二叉树的前序遍历

题目

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：
在这里插入图片描述

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

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

示例 4：
在这里插入图片描述

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

示例 5：
在这里插入图片描述

输入：root = [1,null,2]
输出：[1,2]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

进阶： 递归算法很简单，你可以通过迭代算法完成吗？

思路

  1. 递归
  2. 非递归

答案

// 递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        helper(result, root);
        return result;
    }

    public void helper(List<Integer> result, TreeNode root) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        helper(result, root.left);
        helper(result, root.right);
    }
}
// 非递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        List<TreeNode> stack = new LinkedList<>();
        if (root != null) {
            stack.addLast(root);
        }
        while (!stack.isEmpty()) {
            TreeNode current = stack.removeLast();
            result.add(current.val);
            if (current.right != null) {
                stack.addLast(current.right);
            }
            if (current.left != null) {
                stack.addLast(current.left);
            }
        }

    
        return result;
    }
}

94. 二叉树的中序遍历

题目

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：
在这里插入图片描述

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

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

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

思路

  1. 递归
  2. 非递归，模拟栈

答案

// 递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        helper(root, result);
        return result;
    }
    
    public void helper(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        helper(root.left, result);
        result.add(root.val);
        helper(root.right, result);
    }
}
// 非递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        List<TreeNode> stack = new LinkedList<>();

        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.add(root);
                root = root.left;
            }
            TreeNode current = stack.removeLast();

            result.add(current.val);
            if (current.right != null) {
                root = current.right;
            }

        }
        return result;
    }
    
   
}

145. 二叉树的后序遍历

题目

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：
在这里插入图片描述

输入：root = [1,null,2,3]
输出：[3,2,1]

示例 2：

输入：root = []
输出：[]

示例 3：

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

提示：

  • 树中节点的数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

进阶： 递归算法很简单，你可以通过迭代算法完成吗？

思路

  1. 递归
  2. 非递归，和之前一样

答案

// 递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        helper(root, result);
        return result;
    }
    
    public void helper(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        helper(root.left, result);
        helper(root.right, result);
        result.add(root.val);

    }
}
// 非递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        List<TreeNode> stack = new LinkedList<>();

        if (root != null) {
            stack.add(root);
        }
        while (!stack.isEmpty()) {
            TreeNode current = stack.removeLast();
            result.addFirst(current.val);
            if (current.left != null) {
                stack.addLast(current.left);
            }
            if (current.right != null) {
                stack.addLast(current.right);
            }
        }
        return result;
    }

}

102. 二叉树的层序遍历

题目

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

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

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000

思路

找个队列，用来遍历

答案

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        List<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.add(root);
        }
        while (!queue.isEmpty()) {
            List<Integer> temp = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode current = queue.removeFirst();
                temp.add(current.val);
                if (current.left != null) {
                    queue.add(current.left);
                }
                if (current.right != null) {
                    queue.add(current.right);
                }
            }
            result.add(temp);
        }
        return result;
    }
}

107. 二叉树的层序遍历 II

题目

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

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

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000

思路

和上一题一样

答案


/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        List<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.add(root);
        }
        while (!queue.isEmpty()) {
            List<Integer> temp = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode current = queue.removeFirst();
                temp.add(current.val);
                if (current.left != null) {
                    queue.add(current.left);
                }
                if (current.right != null) {
                    queue.add(current.right);
                }
            }
            result.addFirst(temp);
        }
        return result;
    }
}

103. 二叉树的锯齿形层序遍历

题目

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

示例 2：

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

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -100 <= Node.val <= 100

思路

和层序遍历的区别是，要区分奇偶，控制头插还是尾插

答案

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        List<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.add(root);
        }
        boolean order = true;
        while (!queue.isEmpty()) {
            List<Integer> temp = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode current = queue.removeFirst();
                if (order) {
                    temp.addLast(current.val);
                } else {
                    temp.addFirst(current.val);
                }

                if (current.left != null) {
                    queue.add(current.left);
                }
                if (current.right != null) {
                    queue.add(current.right);
                }
            }
            order = !order;
            result.add(temp);
        }
        return result;
    }
}

105. 从前序与中序遍历序列构造二叉树

题目

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:
在这里插入图片描述

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

  • 1 <= preorder.length <= 3000 inorder.length == preorder.length
  • -3000 <= preorder[i], inorder[i] <= 3000
  • preorder 和 inorder 均 无重复 元素
  • inorder 均出现在 preorder
  • preorder 保证 为二叉树的前序遍历序列
  • inorder 保证 为二叉树的中序遍历序列

思路

递归构建，只要搞清楚，每个部分由先序和中序的哪个部分构成就行了

答案

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return buildTree(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1);
    }
    
    public TreeNode buildTree(int[] preorder, int[] inorder, int preStart, int preEnd, int inStart, int inEnd) {
    	// 结束条件
        if (preStart > preEnd || inStart > inEnd) {
            return null;
        }
      	// 找到本次的根
        int value = preorder[preStart];
        // 找到根在中序的坐标，根据中序的特性，坐标的左边是左子树，右边是右子树
        int inOrderIndex = findIndexInorder(inorder, value);
        // 算一下左子树有几个元素，方便在先序中确认左子树的结束坐标
        int leftNodeSize = inOrderIndex - inStart;
        
        // 看着例一写就行了
        int leftNextPreStart = preStart + 1;
        int leftNextPreEnd = leftNextPreStart + leftNodeSize - 1;

        int rightNextPreStart = leftNextPreEnd + 1;
        int rightNextPreEnd = preEnd;

        int leftNextInStart = inStart;
        int leftNextInEnd = inOrderIndex - 1;

        int rightNextInStart = inOrderIndex + 1;
        int rightNextInEnd = inEnd;

        TreeNode left = buildTree(preorder, inorder, leftNextPreStart, leftNextPreEnd, leftNextInStart, leftNextInEnd);
        TreeNode right = buildTree(preorder, inorder, rightNextPreStart, rightNextPreEnd, rightNextInStart, rightNextInEnd);

        return new TreeNode(value, left, right);
    }

    public int findIndexInorder(int[] inorder, int target) {
        for (int i = 0; i < inorder.length; i++) {
            if (inorder[i] == target) {
                return i;
            }
        }
        return -1;
    }
}

106. 从中序与后序遍历序列构造二叉树

题目

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:
在这里插入图片描述

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

示例 2:

输入：inorder = [-1], postorder = [-1]
输出：[-1]

提示:

  • 1 <= inorder.length <= 3000
  • postorder.length == inorder.length
  • -3000 <= inorder[i], postorder[i] <= 3000
  • inorder 和 postorder 都由 不同 的值组成
  • postorder 中每一个值都在 inorder 中
  • inorder 保证是树的中序遍历
  • postorder 保证是树的后序遍历

思路

和之前一样

答案

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        return buildTree(inorder, postorder, 0, inorder.length - 1, 0, postorder.length - 1);
    }

    public TreeNode buildTree(int[] inorder, int[] postorder, int inOrderStart, int inOrderEnd, int postOrderStart, int postOrderEnd) {
        if (inOrderStart > inOrderEnd || postOrderStart > postOrderEnd) {
            return null;
        }
        int value = postorder[postOrderEnd];
        int inOrderIndex = find(inorder, value);

        int leftNodeSize = inOrderIndex - inOrderStart;

        int leftInOrderStart = inOrderStart;
        int leftInOrderEnd = inOrderStart + leftNodeSize - 1;
        int rightInOrderStart = inOrderIndex + 1;
        int rightInOrderEnd = inOrderEnd;

        int leftPostOrderStart = postOrderStart;
        int leftPostOrderEnd = leftPostOrderStart + leftNodeSize - 1;
        int rightPostOrderStart = leftPostOrderEnd + 1;
        int rightPostOrderEnd = postOrderEnd - 1;

        TreeNode left = buildTree(inorder, postorder, leftInOrderStart, leftInOrderEnd, leftPostOrderStart, leftPostOrderEnd);
        TreeNode right = buildTree(inorder, postorder, rightInOrderStart, rightInOrderEnd, rightPostOrderStart, rightPostOrderEnd);

        return new TreeNode(value, left, right);
    }

    public int find(int[] inorder, int target) {
        for (int i = 0; i < inorder.length; i++) {
            if (inorder[i] == target) {
                return i;
            }
        }
        return -1;
    }
}
LaMole_Ryouji
关注
  • 26
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zhmeng的刷题打卡
zhmeng
09-12 304
冲鸭！ ˙Ꙫ˙
LeetCode刷题日记精选例题（代码+链接
q16974058的博客
04-09 703
Java面试核心知识点一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！Java面试核心知识点已经有读者朋友靠着这一份Java面试知识点指导拿到不错的offer了《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />[外链图片转存中…(img-LRGinIQW-1712644950281)]Java面试核心知识点一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！
2017年9月10日训练日记
Orz
09-10 410
这个周末比了两场赛，都是5个小时，但是两场比赛都坚持下来了，看到与高手的差距还是那样不可逾越，还是只能A出一两道题，比赛下来对自己的感觉就是思维迟钝，这两个比赛很多题目题意都很简单，但是就是做不出来或没有思路，这就是比赛与平时练习的区别，首先比赛时你不会提前知道这题用什么算法来做，然后就是一道题目可能觉着这样做也行，那样做也行，可是做出来就TLE或WA，也就是看到题目根本还找不到一个正确的思路。看
2017年11月26日训练总结
LSD20164388的博客
11-26 249
这次训练总结是11月24日-11月26日。 树形DP专题结束了。。。 嗯，做的太快，现在都快忘了。。。幸好老师正好留出一天时间让我们复习。赶紧回顾一下数位DP专题和树形DP专题。 现总结一下这三天的情况：简单预习了状压DP的知识，看了一部分资料。思想倒是不难理解，就是利用二进制01表示状态，用&|来判断状态进行DP。但是一看题目和代码，一脸懵逼，还需要时间来揣摩思考。 cf打了一场比赛，题
【十一日记】 清北学堂酱油记
Loi_MeiCo の 博客
10-01 1764
Day 0 五点起床 困~ 喜闻乐见的六点集合 嗯我们出发的时候迟到了四分钟（ 06：26 第一次出去怎么多人 啧啧啧 @57的熊孩子们好多啊qwq 十分钟到一中 果然老司机233 嗯 目睹他们放学吃早饭真开心233 感觉没有过年的时候气氛爽啊 还想着40人一起在车上打游戏呢 结果睡了一片233 才到天津就已经11：30了么QAQ 难道真的要6个+hours QAQ （来吧帝都 从南
『ACM』ACM部分训练日记（以此纪念和队友与FLS一起度过的快乐时光）
日拱一卒,功不唐捐
05-26 6930
2020-03-09 终于痛定思痛的决定放弃了，遭不住了。 想说的很多，对不起的人，也有很多，我想继续逃避下去，我不想在面对了，也有想骂的人，总之要走了，ACM真的是非常好的地方，不得不说再见了，再见了赛场。 别人是退役，而我是太菜了，自己都不想看到自己。 再见！ 退役博客以后再写吧，最近挺烦的。 2020.2.28总结 最近做题的感觉又回来了，等我长长情绪就回去接着甘数学，最近做DP的感觉很好，可能是因为学数学的思维有所提升的原因，但是做数学之后因为代码敲得少了，导致签到题一直调不出来，思路倒是挺快的，然
【Java基础总结】类加载顺序，new关键字，访问权限修饰符与方法重载等【二】_java 类的方法体有new 会导致类加载吗
2401_84519663的博客
04-21 704
最近再回头过来看Java基础知识，以不同的角度再去看，收获良多，特记之。在学习过程中，我们通常纠结于要不要深入钻研，结合本人的学习过程最近再回头反省。我觉得学习初期，还是应该在大的体系上去学习，不要卡进度，但是也不可盲目追求进度，一旦自欺欺人盲目追求速度。久而久之自己都怀疑自己了。不如脚踏实地的系统学习，打扎实基础逐步推进。只有系统学习才能学到真东西！其中尤其忌讳无论什么东西，第一遍看不懂，也不仔细钻研，便将不懂的问题逐渐搁置一旁，久而久之，积累的多了，蚁多尚能噬象，何况基础不牢呢？必然是地动山摇！
2017/8/25 训练总结（最终版QAQ）
胖亚亚的小酒馆
08-25 307
虽然说不上时光飞逝，但是暑假集训确实很快就过去了。 这次暑假集训从7月31日到现在，每天从早上八点到晚上八九点钟都待在实验室，坐在电脑前，开始不停的看题，码代码，学习新的知识，总结，写训练日记。说实话过的很累，但也很充实很开心。但我觉得这就够了，能够有兴趣的学习一门自己想学的知识，比被强制灌输一些根本用不到的知识要强很多而且学习的效率也会有很大的不同。 还记得刚开始接触acm的时候，大概是在大
一个动态更新的洛谷综合题单（原版）
yfdai8的专栏
01-26 1054
洛谷试炼场的题目确实很具有代表性，但是近几年以来，又有许多经典题目出现在 OI 界中，这个大题单就是作为洛谷试炼场的扩展和补充。
2022年1月20日刷题日记
01-21
刷题
[宫水三叶的刷题日记]：数学1
08-03
2. 从侧边栏的类别目录找到「数学」 3. 按照「推荐指数」从大到小进行刷题，「推荐指数」相同，则按照「难度」从易到 4. 拿到题号之后，回到本合集进行检索 1
[宫水三叶的刷题日记]：线段树1
08-03
2. 从侧边栏的类别目录找到「线段树」 3. 按照「推荐指数」从大到小进行刷题，「推荐指数」相同，则按照「难度」从易到 4. 拿到题号之后，回到本合集进行检索
[宫水三叶的刷题日记]：括号问题1
08-03
2. 从侧边栏的类别目录找到「括号问题」 3. 按照「推荐指数」从大到小进行刷题，「推荐指数」相同，则按照「难度」从易到 4. 拿到题号之后，回到本合集进行检索
[宫水三叶的刷题日记]：字典树1
08-03
2. 从侧边栏的类别目录找到「字典树」 3. 按照「推荐指数」从大到小进行刷题，「推荐指数」相同，则按照「难度」从易到 4. 拿到题号之后，回到本合集进行检索
乘法逆元算法
最新发布
2302_81590667的博客
05-22 608
有些云里雾里的那个取正整数的地方，好多地方都是公式推理和验证定理的正确性，看不懂，初等数论再说！乘法逆元的意思就是给出两个数a，b如果a，b互质（就是两个数的最大公约数是1）那么就有。1(mod 5)，x=2,7,12.....x的每个值都差5；可以用费马小定理来推导乘法逆元我就不细讲了想知道可以看这个博客。这个题必须用scanf和printf要不然超时。就是必有a*x%b==1；
BERT系列算法解读
qq_52053775的博客
05-19 213
从而提高模型在SQuAD、MNLI和SST-2数据集上的性能。总的来看，这些优化措施显著增强了模型的表现。
【力扣一轮】454.四数之和 && 383.赎金信
诚。
05-22 281
为什么能想到这里，注意到它的和是0，（和可以是任何数）这样就相当于两两数组为一对，看其中一对数组中的元素，在另外一对数组中是否出现了相反数。这里的一对说的是A+B或其他组合方式，（不重要，因为都是随机的）然而以上想法截止到第二句，都没问题，需要注意的是，不是全对应。A2：因为在存储时，不仅要存储对应的元素，也要存储元素出现的次数，所以用到map。结合之前的有效字母异位符，数组，set，map，使用数组即可。也就是说如果一对数组中有两个-2，另一对数组中只有一个2，那么计算为0的次数为2。
每日一题（PTA Advanced1003）：Emergency-dfs
m0_75015083的博客
05-22 189
【代码】每日一题（PTA Advanced1003）：Emergency-dfs。
java 刷题语法基础
09-19
Java刷题的语法基础包括以下内容： 1. 输入输出：可以使用Scanner类或BufferedReader类进行输入。Scanner类可以使用nextInt()方法读取单个整数，使用nextLine()方法读取整行输入。BufferedReader类需要使用readLine...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值