【leetcode】招商银行学习计划经典笔试题（java版本含注释）

最新推荐文章于 2024-04-04 12:37:49 发布
最新推荐文章于 2024-04-04 12:37:49 发布
阅读量1.2k 收藏 23
点赞数 24
分类专栏： 算法 文章标签： java 开发语言 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47872288/article/details/124263694
版权

目录

前言

将近两年前的学习笔记，由于一直放在草稿箱中，今天将他释放了~~

该学习计划链接如下：
招商银行信用卡的学习计划

在这里插入图片描述

以下为我的学习笔记以及汇总，也为了方便其他人更加快速的浏览

这里大部分的题目都是刷过的，本着尽职的态度再次模拟，多刷多刷(#.#)

个别题目太常见或者顺手就来，博主就不放详细题目，只放链接了

第一天

21. 合并两个有序链表（简单）

题目：leetcode：21. 合并两个有序链表

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode prehead=new ListNode(0);

        ListNode pre=prehead;
        while(list1!=null&&list2!=null){
            if(list1.val>=list2.val){
                pre.next=list2;
                list2=list2.next;
            }else {
                pre.next=list1;
                list1=list1.next;
            }
            pre=pre.next;    
        }

        pre.next=list1==null?list2:list1;
        return prehead.next;//可以直接用这个节点的next返回，不用再创建多一个节点保存了

    }
}

3. 无重复字符的最长子串（中等）

题目：leetcode：3. 无重复字符的最长子串

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Set<Character> set=new HashSet<>();
        int rk=-1,sum=0;
        for(int i=0;i<s.length();i++){
            if(i!=0){
                set.remove(s.charAt(i-1));
            }
            while(rk+1<s.length() && !set.contains(s.charAt(rk+1))){
                set.add(s.charAt(rk+1));
                rk++;
            }
            sum=Math.max(sum,rk-i+1);
        }
        return sum;

    }
}

第二天

1. 两数之和（简单）

题目：leetcode：1. 两数之和

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer>map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                return new int[]{map.get(target-nums[i]),i};
            }
            map.put(nums[i],i);
        }
        return new int[0];
     
    }
}

199. 二叉树的右视图（中等）

题目：leetcode：199. 二叉树的右视图

class Solution {
    
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer>list=new ArrayList<>();
        if(root==null) return list;

        Queue<TreeNode> que=new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int n=que.size();
            for(int i=0;i<n;i++){
                TreeNode node=que.poll();
                if(i==n-1)list.add(node.val);
                if(node.left!=null)que.offer(node.left);
                if(node.right!=null)que.offer(node.right);
            }
        }
        return list;
    }
}

124. 二叉树中的最大路径和（困难）

题目：leetcode：124. 二叉树中的最大路径和

要记住返回的值，所以使用后序递归是最合适的了

class Solution {
    int max=Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        dfs(root);
        return max;
    }   

    public int dfs(TreeNode root){
        if(root ==null)return 0;

        /*  
        int left=dfs(root.left);
        int right=dfs(root.right);
        */


        /* 
          之所以不用上面那个操作主要是，为了保证每一步都是大于0，如果小于0，直接返回0即可  
        */ 
        int left=Math.max(dfs(root.left),0);
        int right=Math.max(dfs(root.right),0);

        //计算左右边界的值，本身已经默认大于0了，所以max比较最大值，在主函数中，返回max比较即可。
        //这和递归的条件不影响，递归只是返回单边最大的值而已，条件不能弄混
        int sum=left+right+root.val;

        max=Math.max(max,sum);

        //确定递归回去的条件，只能返回单边值
        return root.val+Math.max(left,right);


    }
}

第三天

198. 打家劫舍（中等）

题目：leetcode：198. 打家劫舍

class Solution {
    public int rob(int[] nums) {
        //因为创建了dp数组，前面两个数组的个数要做一个判断比较
        
        //为空或者长度为0，都返回为0
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int n=nums.length;
        //如果数组长为1，则返回第一个
        if (n == 1) {
            return nums[0];
        }
        
        int []dp=new int [n];
        dp[0]=nums[0];
        //返回最大的那个，初始条件如果只有两个房屋，返回最大的那个
        dp[1]=Math.max(nums[0],nums[1]);

        //通过动态规划的公式，相邻两间屋的最大值
        for(int i=2;i<n;i++){
            dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);
        }

        //输出动态规划数组的最后一个值，即可为最大
        return dp[n-1];


    }
}

15. 三数之和（中等）

题目：leetcode：15. 三数之和

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list =new ArrayList<List<Integer>>();
        

        int n=nums.length;
        Arrays.sort(nums);
        for(int i=0;i<n-2;i++){//    < nums.length - 2是为了保证后面还能存在两个数字
            
            if(nums[i]>0)break;//大于0，则后面的数字也是大于零（排序后是递增的）
            if(i!=0 && nums[i] == nums[i-1])continue;// 代表第一个值重复了，去重

            int left=i+1;
            int right=n-1;
            while(left<right){
                int sum=nums[left]+nums[right]+nums[i];

                if(sum==0){
                    //创建一个空的列表

                    /*
                    List<Integer>sonlist=new ArrayList<>();
                    sonlist.add(nums[i]);
                    sonlist.add(nums[left]);
                    sonlist.add(nums[right]);
                    
                    list.add(sonlist);
                    */

                    // 将其数组转换为列表，二者选择其一，跟上面的代码
                    list.add(new ArrayList<>(Arrays.asList(nums[i],nums[left],nums[right])));
                    
                    while(left<right && nums[left]==nums[++left]);//左指针前进并去重
                    while(left<right && nums[right] == nums[--right]);//右指针前进并去重

                }else if(sum<0){
                    while(left<right && nums[left]==nums[++left]);//左指针前进并去重
                }else if(sum>0){
                    while(left<right && nums[right] == nums[--right]);//右指针前进并去重
                }
            }
            
        }

        return list;

    }
}

第四天

53. 最大子数组和（简单）

题目：leetcode：53. 最大子数组和

class Solution {
    public int maxSubArray(int[] nums) {
        
        int n=nums.length;
        int pre=0;
        int max=Integer.MIN_VALUE;
        // 或者使用 int max=nums[0];
        for(int i=0;i<n;i++){
            pre=Math.max(pre+nums[i],nums[i]);
            max=Math.max(pre,max);
        }
        return max;

    }
}

7. 整数反转（中等）*

题目：leetcode：7. 整数反转

大致题目意思是：
给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

核心代码主要是这一块：

// 弹出 x 的末尾数字 rev
rev = x % 10;
x /= 10;

// 将数字 rev 推入 res 末尾
res = res * 10 + rev;

最主要是数字会溢出，所以数字的判断条件比较关键：

class Solution {
    public int reverse(int x) {

        //返回最后的总数
        int res=0;
        
        while(x!=0){
            
            //因为反转的时候res会慢慢开始越界，所以在此处进行判断 倒数第二个数
            if(res>Integer.MAX_VALUE/10 || res<Integer.MIN_VALUE/10)return 0;

            //求余判断条件
            int rev=x%10;
            //除数判断的条件
            x=x/10;

            res=res*10+rev;
        
        }
        return res;

    }
}

33. 搜索旋转排序数组（中等）*

题目：leetcode：33. 搜索旋转排序数组

class Solution {
    public int search(int[] nums, int target) {

        int n=nums.length;
        int left=0,right=nums.length-1;
        //等于号不要漏掉
        while(left<=right){
            int mid=left+(right-left)/2;
            //不要少掉这个条件
            if(nums[mid]==target)return mid;
            //注意初值条件，左边界此处都是等于号，而且和nums【mid】作比较，target嵌入其中
            if(nums[0]<=nums[mid]){

                if(nums[0]<=target && target<nums[mid]){
                    right=mid-1;
                }else {
                    left=mid+1;
                }

            }else {
                //此处的等于号是在nums【n-1】作比较，
                if(nums[mid]<target && target<=nums[n-1]){
                    left=mid+1;
                }else {
                    right=mid-1;
                }

            }
        }
        //如果循环结束后条件不满足 则返回-1
        return -1;

    }
}

第五天

41. 缺失的第一个正数

题目：leetcode：41. 缺失的第一个正数

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n=nums.length;

        //将其小于等于0的数都变为n+1，因为之后用不到
        for(int i=0;i<n;i++){
            if(nums[i]<=0)nums[i]=n+1;
        }

        // 再一次遍历，类似哈希，将其元素标记在数组下标中
        // 置为负值，为了不让负变正，每次都是取绝对值，在变负，解决上面的疑惑
        for(int i=0;i<n;i++){
            int num=Math.abs(nums[i]);
            //此处判断的数字都是小于等于n的，也就是【1，n】
            if(num<=n)nums[num-1]=-Math.abs(nums[num-1]);
        }

        //如果遇到正数，说明其下标还未被标记，所以是i+1
        for(int i=0;i<n;i++){
            if(nums[i]>0)return i+1;
        }

        //如果没有被标记到，则将其n+1

        return n+1;
    }
}

置换的做法：

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n=nums.length;

        //将其数组值对应放到数组下标中
        for(int i=0;i<n;i++){
            //无限在这里置换 只有不等的时候才需要操作置换
            while(nums[i]>0 && nums[i]<=n && nums[nums[i]-1]!=nums[i]){
                int temp=nums[nums[i]-1];
                nums[nums[i]-1]=nums[i];
                nums[i]=temp;
            }
        }

        //类似哈希的存储，如果不等于i+1的时候 就返回第一个正数
        for(int i=0;i<n;i++){
            if(nums[i]!=i+1)return i+1;
        }

        return n+1;
    }
}

20. 有效的括号（简单）*

题目：leetcode：20. 有效的括号

class Solution {
    public boolean isValid(String s) {
        //临界条件 奇数个数排除
        if(s.length()%2!=0)return false;
        
        int n=s.length();
        Map<Character,Character>map=new HashMap<>(){
            {
                //注意此处为put而不是map.put函数
                put(')','(');
                put(']','[');
                put('}','{');
            }
        };
        
        Stack<Character>stack=new Stack<>();

        for(int i=0;i<n;i++){
            //此处的条件是如果包含了这个key，也就是可能栈中有左括号
            if(map.containsKey(s.charAt(i))){
                //判断栈如果为空或者是获取这个节点对应的value中不是等于peek值，说明为false
                //之所以判断false条件是 因为如果不是可以直接返回结果
                if(stack.isEmpty() || map.get(s.charAt(i))!=stack.peek()){
                    return false;
                }
                stack.pop();
            }else{
                //如果没有包含则进栈
                stack.push(s.charAt(i));
            }
        }

        //最后的返回条件是栈是否为空
        return stack.isEmpty();



    }
}

103. 二叉树的锯齿形层序遍历（中等）

题目：leetcode：103. 二叉树的锯齿形层序遍历

class Solution {
    
    
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {

        List<List<Integer>> list=new ArrayList<List<Integer>>();
        if(root==null) return list;


        Queue<TreeNode> que=new LinkedList<>();
        que.offer(root);
        int ans=0;
        while(!que.isEmpty()){
            int n=que.size();
            List<Integer>sonlist=new ArrayList<>();
            for(int i=0;i<n;i++){
                TreeNode node=que.poll();
                sonlist.add(node.val);
                if(node.left!=null)que.offer(node.left);
                if(node.right!=null)que.offer(node.right);
            }
            ans++;
            if(ans%2==0)Collections.reverse(sonlist);
            list.add(sonlist);
        }
        return list;
        

    }
}

第六天

415. 字符串相加（简单）

题目：leetcode：415. 字符串相加

class Solution {
    public String addStrings(String num1, String num2) {
        int l1=num1.length()-1;
        int l2=num2.length()-1;

        int add=0;
        StringBuilder sb=new StringBuilder();
        while(l1>=0||l2>=0|add!=0){
            //判断格式是这样的
            int x=l1>=0?num1.charAt(l1)-'0':0;
            int y=l2>=0?num2.charAt(l2)-'0':0;
            int sum=x+y+add;

            sb.append(sum%10);
            add=sum/10;
            l1--;
            l2--;
        }

        sb.reverse();
        return sb.toString();
    }
}

64. 最小路径和

题目：leetcode：64. 最小路径和

class Solution {
    public int minPathSum(int[][] grid) {
        //初始值判断
        if (grid == null || grid.length == 0||grid[0].length==0) {
            return 0;
        }
        
        int m=grid.length;
        int n=grid[0].length;

        int [][]dp=new int [m][n];
        //赋值一个值，主要用来求边界想加点
        dp[0][0]=grid[0][0];
        
        //边界处理
        for(int i=1;i<m;i++){
            dp[i][0]=dp[i-1][0]+grid[i][0];
        }
        for(int i=1;i<n;i++){
            dp[0][i]=dp[0][i-1]+grid[0][i];
        }

        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                //需求最小的边界，而且是邻接边
                dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j])+grid[i][j];
            }
        }

        return dp[m-1][n-1];

    }
}

第六天

88. 合并两个有序数组（简单）

题目：leetcode：88. 合并两个有序数组

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {

        //逆序存放主要是不会被覆盖
        //a b都是有效数组下标开始
        int a = m - 1, b = n - 1;
        int tail = m + n - 1;

        //有效数组的个数大于等于0开始
        while(a>=0 ||b>=0) {
            //如果数组下标等于-1，既越界，直接tail--存放b数组或者对应的a数组
            if (a == -1) {
               nums1[tail--] = nums2[b--];
            } else if (b == -1) {
                nums1[tail--] = nums1[a--];
            } else if (nums1[a] > nums2[b]) {
                nums1[tail--] = nums1[a--];
            } else {
                nums1[tail--] = nums2[b--];
            }
        }
    }
}
码农研究僧
关注
  • 24
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
面试考题（腾讯,招行等等）
尘埃的博客
04-11 569
偶然的一个下午 我接到qqmm的电话 通知我于后天下午3点半的时候去面试 接到电话以后 我高兴不已。三个人问同样的问题 累不累啊你 他的面试题目大致是 你所经历过的最难的项目是什么 怎么个难法？一路问的我好郁闷 怎么不考技术 他们都是做纯粹的测试的吗？好象和计算机底层的东西一点关系都没有 出来以后我看看表快6点了 我当时的感叹就是 测试的理论体系没有好好研究过 不然肯定能过腾讯的面试关。经过个人的回忆整理了下，以下是我面试的时候的部分笔试和面试题目 供大家交流 我也希望有过大公司。
招银网络-测开笔试-数据库查询大题
yishi_c的博客
07-02 8464
数据库中有如下四个表： 【1】Student（Sno，Sname，Sage，Ssex）学生表。 Sno学号；Sname学生姓名；Sage学生年龄；Ssex学生性别。 【2】Course（Cno，Cname，Tno）课程表。 Cno课程编号；Cname课程名字；Tno教师编号。 【3】SC（Sno，Cno，Score）成绩表。 Sno学号；Cno课程编号；Score成绩。 【4】Teacher（Tno，Tname）教师表。 Tno教师编号；Tname教师姓名。 请根据要求写出响应的SQL语句： （1）查询“J
2020年8月3日招商银行软件笔试题
wwxy1995的博客
08-03 1634
第一题：三位数转 逆序的二进制编码 小招喵是一个商业巨腕，手下有n个公司，每-一个公司他 都对其有一个三位数编码，但是他现在想到了一种新的 编码方式。 即原来的三位数的每一位数字0~9， 对应成4位二进制编 码，例如1对应0001, 2对应0010， 5对应0101, 9对应1001. 那么三位数(可能小于百， 默认前导为0) 例如: 123对应000100100011 891对应100010010001 76对应00001110110 5对应00000000101 小招喵为了让别人不觉得他的新编码太没新
笔试招商银行软件中心软件测试笔试试题.pdf
10-01
笔试招商银行软件中心软件测试笔试试题.pdf
Mysql常用的维护SQL，中信银行Java笔试题库
2401_84023579的博客
04-04 789
一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算。
招行笔试java编程
hgg923的专栏
03-25 2388
题1： 题2： public static void main(String[] args) throws InterruptedException { //题1 // String str = "abbcbccacbbcbaaba"; // int len = str.length(); // StringBuilder ans = new StringBuilder(str.substring(len-1)); ...
招银网络Java后端笔试题
web18484626332的博客
04-12 5976
1、MySQL的索引有什么数据结构？Hash与B+tree有什么区别 2、Spring MVC的执行流程是怎样的，请详述一下 3、怎样实现分布式锁？有哪些方式实现？ 4、实现线程有什么方式？线程有哪些状态？状态之间是怎样转换的？ 5、如何优化SQL、优化数据库 6、redis的数据过期过期策略是怎样的 7、nginx用来做什么？请大概说下 8、MyBatis的#与$有什么区别，returnType和returnMap的区别 9、springboot原理是什么？starter是提供的是什么？有什么优势？ 10
java-leetcode题解之第165题比较版本号.zip
最新发布
05-29
java java_leetcode题解之第165题比较版本号
leetcode题库-leetcode-java:LeetcodeJava代码
06-29
leetcode题库 leetcode solutions in java 本仓库内包含了java实现的leetcode解法，代码规范，可读性良好，其中的解法思想并不受语言限制。 BFS(Breath First Search) bfs能解决什么样的问题 图遍历中是否可达、最短...
java面试题-leetcode题解之第278题第一个错误的版本.zip
05-23
java面试题 java面试题_leetcode题解之第278题第一个错误的版本
leetcode-java:leetcode算法题学习
03-30
leetcode-java 刷LeetCode算法的题解仓库，算法题解以issue形式记录。 我个人比较喜欢使用问题记录一些知识点，因为问题的功能比较丰富，可以很方便的进行分类，修改，补充。 个人刷题标准 将标准写到这里，是为了...
招商银行软件中心软件测试笔试试题-key(1).pdf
09-30
招商银行软件中心软件测试笔试试题-key(1).pdf
招商银行java笔试试题-mobile_flutter:mobile_flutter
06-13
招商银行java笔误题Flutter 插件 Flutter 官方 Jumio Mobile SDK 插件 兼容性 兼容性已经通过 Flutter 2.0.1 和 Dart 2.12 版本测试 设置 创建 Flutter 项目并将 Jumio Mobile SDK 模块添加到其中。 flutter create MyProject 将 Jumio Mobile SDK 作为依赖项添加到您的pubspec.yaml文件： dependencies : flutter : sdk : flutter jumio_mobile_sdk_flutter : ^3.9.1 并安装依赖项： cd MyProject flutter pub get 一体化 IOS 将“ NSCameraUsageDescription ”键添加到您的 Info.plist 文件中。 您的应用程序的部署目标必须至少为 iOS 10.0 安卓 打开您的 AndroidManifest.xml 文件并将 allowBackup 更改为 false。 < application ... android:allowBackup
2018招商银行软件测试笔试
10-24
2018年招商银行软件测试岗位的部分笔试题，机试，相对来说整份题目比较简单，文档包括部分选择题，以及全部简单和编程题
中国银行软件测试笔试试题
04-14
使用瀑布模型术语，在软件测试V模型中，对应“需求分析”的测试阶段是（）(该题为必答题) 1 　　系统测试 　　集成测试 　　用户验收测试 　　单元测试
LeetCode面试笔试题
03-10
LeetCode面试笔试题
JAVA字母的大小写转换
我想做阿信的博客
10-11 1328
toLowerCase()方法将String转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回，否则返回一个新的字符串。 语法：str.toLowerCase() toUpperCase()方法将Srtring转换为大写。如果字符串中没有应该转换的字符，则将原字符串返回，否则返回一个新的字符串。 语法：str.toUpperCase() 说明:使用toLowerCase()方法和toUpperCase()方法进行大小写转换时，数字或非字符不受影响。 1 2 ...
招商银行信用卡中心2019秋招IT笔试(AI、开发、测试开发方向)第三批
FlushHip
11-19 5836
员工考勤记录 题目 给定一个字符串来代表一个员工的考勤纪录，这个纪录仅包含以下两个字符： ‘A’ : Absent，缺勤 ‘P’ : Present，到场 如果一个员工的考勤纪录中不超过两个’A’(缺勤),那么这个员工会被奖赏。 如果你作为一个员工，想在连续N天的考勤周期中获得奖赏，请问有多少种考勤的组合能够满足要求 输入描述： 考勤周期的天数N（正整数） 输出描述： 这N天里能获得奖赏的考勤组合...
写一个leetcode第1515题的java版本的题解
03-05
题目描述： 给定一个由 n 个节点组成的树，每个节点都有一个权值。定义一个节点的权值为其子树中所有节点的权值之和。请你返回所有满足下列条件的节点的权值之和： 该节点位于树的重心以上，即如果将该节点删除后，剩余各个连通分量的节点权值最大值最小。 如果节点数为偶数，则要求上述节点在剩余节点中，左右两部分节点数目相同；如果节点数为奇数，则要求左部分节点数目比右部分节点数目多一。 示例 1： 输入：edges = [[1,2],[1,3],[1,4],[4,5]], weight = [2,3,1,4] 输出：15 解释：树上的节点权值为 [,2,3,1,4] 。重心是节点 1 ，删除后为两个子树 [2,3,4] 和 [5] 。剩余节点权值分别为 9 和 4，均最小化。 示例 2： 输入：edges = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9]], weight = [1,2,3,4,5,6,7,8,9] 输出：31 解释：树上的节点权值为 [,1,2,3,4,5,6,7,8,9] 。重心是节点 5 ，删除后为两个子树 [1,2,3,4,6,7,8,9] 和 [] 。剩余节点权值分别为 33 和 ，均最小化。 提示： 1 <= n <= 10^5 edges.length == n - 1 edges[i].length == 2 1 <= edges[i][], edges[i][1] <= n 1 <= weight.length <= n 1 <= weight[i] <= 10^5 解题思路： 题目要求我们找到树的重心，然后删除重心以上的节点，使得剩余各个连通分量的节点权值最大值最小。 首先，我们需要知道什么是树的重心。树的重心是指树上的一个节点，如果将该节点删除后，剩余各个连通分量的节点数最大值最小，那么这个节点就是树的重心。 我们可以使用两次 DFS 来解决这个问题。第一次 DFS 用来求出树的重心，第二次 DFS 用来计算删除重心以上的节点后，剩余各个连通分量的节点权值之和。 具体来说，我们可以先从任意一个节点开始，进行一次 DFS，求出以该节点为根的子树中的节点数和子树中所有节点的权值之和。然后，我们可以再进行一次 DFS，求出以该节点为根的子树中，删除该节点后，剩余各个连通分量的节点数最大值。我们可以使用一个数组 subsize 来记录每个节点的子树大小，使用一个数组 sum 来记录每个节点的子树中所有节点的权值之和。我们可以使用一个变量 ans 来记录删除重心以上的节点后，剩余各个连通分量的节点权值之和的最小值。 在第一次 DFS 中，我们可以使用一个变量 maxsubsize 来记录以当前节点为根的子树中，最大的子树大小。我们可以使用一个变量 totsize 来记录以当前节点为根的子树中，所有节点的总数。我们可以使用一个变量 cursum 来记录以当前节点为根的子树中，所有节点的权值之和。我们可以使用一个变量 curans 来记录删除当前节点后，剩余各个连通分量的节点数最大值。具体来说，我们可以枚举当前节点的每个子节点，然后递归地计算以该子节点为根的子树中，最大的子树大小。我们可以使用一个变量 cursize 来记录以该子节点为根的子树中，所有节点的总数。我们可以使用一个变量 subsum 来记录以该子节点为根的子树中，所有节点的权值之和。然后，我们可以使用 maxsubsize 来更新以当前节点为根的子树中，最大的子树大小。我们可以使用 totsize 来更新以当前节点为根的子树中，所有节点的总数。我们可以使用 cursum 来更新以当前节点为根的子树中，所有节点的权值之和。最后，我们可以使用一个变量 maxsize 来记录当前节点的父节点到当前节点这条路径上，最大的子树大小。我们可以使用一个变量 parentsize 来记录当前节点的父节点的子树大小。然后，我们可以使用 maxsize 和 totsize - cursize 来计算删除当前节点后，剩余各个连通分量的节点数最大值。最后，我们可以使用 curans 来更新 ans。 在第二次 DFS 中，我们可以使用一个变量 maxsubsize 来记录以当前节点为根的子树中，最大的子树大小。我们可以使用一个变量 totsize 来记录以当前节点为根的子树中，所有节点的总数。我们可以使用一个变量 cursum 来记录以当前节点为根的子树中，所有节点的权值之和。我们可以使用一个变量 parentsize 来记录当前节点的父节点的子树大小。具体来说，我们可以枚举当前节点的每个子节点，然后递归地计算以该子节点为根的子树中，最大的子树大小。我们可以使用一个变量 cursize 来记录以该子节点为根的子树中，所有节点的总数。我们可以使用一个变量 subsum 来记录以该子节点为根的子树中，所有节点的权值之和。然后，我们可以使用 maxsubsize 来更新以当前节点为根的子树中，最大的子树大小。我们可以使用 totsize 来更新以当前节点为根的子树中，所有节点的总数。我们可以使用 cursum 来更新以当前节点为根的子树中，所有节点的权值之和。最后，我们可以使用 parentsize 和 totsize - cursize 来计算删除当前节点后，剩余各个连通分量的节点数最大值。如果当前节点不是树的重心，那么我们可以使用 ans 来更新剩余各个连通分量的节点权值之和的最小值。 最后，我们可以返回 ans。 Java 代码： class Solution { int[] subsize; int[] sum; int ans = Integer.MAX_VALUE; public int getCenter(int[][] edges, int[] weight) { int n = weight.length; subsize = new int[n]; sum = new int[n]; dfs1(, -1, edges, weight); dfs2(, -1, edges, weight); return ans; } private void dfs1(int u, int p, int[][] edges, int[] weight) { subsize[u] = 1; sum[u] = weight[u]; int maxsubsize = ; int totsize = 1; int cursum = weight[u]; int curans = ; for (int v : edges[u]) { if (v == p) { continue; } dfs1(v, u, edges, weight); int cursize = subsize[v]; int subsum = sum[v]; subsize[u] += cursize; sum[u] += subsum; maxsubsize = Math.max(maxsubsize, cursize); totsize += cursize; cursum += subsum; int maxsize = Math.max(cursize, subsize[u] - cursize); int parentsize = totsize - cursize; curans = Math.max(curans, Math.min(maxsize, parentsize)); } int maxsize = Math.max(maxsubsize, totsize - maxsubsize); if (maxsize < ans) { ans = maxsize; } } private void dfs2(int u, int p, int[][] edges, int[] weight) { subsize[u] = 1; sum[u] = weight[u]; int maxsubsize = ; int totsize = 1; int cursum = weight[u]; int parentsize = p == -1 ? : subsize[p]; for (int v : edges[u]) { if (v == p) { continue; } int cursize = subsize[v]; int subsum = sum[v]; subsize[u] += cursize; sum[u] += subsum; maxsubsize = Math.max(maxsubsize, cursize); totsize += cursize; cursum += subsum; int maxsize = Math.max(cursize, subsize[u] - cursize); int childsize = totsize - cursize; int curans = Math.max(Math.min(maxsize, parentsize + childsize), Math.min(subsize[v], totsize - subsize[v])); if (curans < ans) { ans = curans; } dfs2(v, u, edges, weight); } } }

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农研究僧

你的鼓励将是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值