LeetCode41~60题——NWU_LK

最新推荐文章于 2024-10-20 21:47:19 发布
最新推荐文章于 2024-10-20 21:47:19 发布
阅读量184 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NWU_LK/article/details/108164153
版权

LeetCode第41题

缺失的第一个正数

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n=nums.length;
        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]);
            if (num <= n) {
                nums[num - 1] = -Math.abs(nums[num - 1]);
            }
        }
        for (int i=0;i<n;i++){
            if (nums[i]>0){
                return i+1;
            }
        }
        return n+1;
    }
}

LeetCode第42题

接雨水
暴力法：

class Solution {
    public int trap(int[] height) {
        int ans = 0;
        int size = height.length;
        for (int i = 1; i < size - 1; i++) {
            int max_left = 0, max_right = 0;
            for (int j = i; j >= 0; j--) { //Search the left part for max bar size
                max_left = Math.max(max_left, height[j]);
            }
            for (int j = i; j < size; j++) { //Search the right part for max bar size
                max_right = Math.max(max_right, height[j]);
            }
            ans += Math.min(max_left, max_right) - height[i];
        }
        return ans;
    }
}

动态编程法：

class Solution {
    public int trap(int[] height) {
        int[] left=new int[height.length];
        int[] right=new int[height.length];
        Stack<Integer> stack=new Stack<>();
        int max=0;
        for (int i=0;i<height.length;i++){
            if (height[i]>height[max]){
                max=i;
            }
            left[i]=max;
        }
        max= height.length-1;
        for (int i=height.length-1;i>=0;i--){
            if (height[i]>height[max]){
                max=i;
            }
            right[i]=max;
        }
        int total=0;
        for (int i=0;i<height.length;i++){
            int h=Math.min(height[right[i]],height[left[i]]);
            total+=h-height[i];
        }
        return total;
    }
}

LeetCode第43题

字符串相乘

class Solution {
    public String multiply(String num1, String num2) {
        if (num1.equals("0") || num2.equals("0")) {
            return "0";
        }
        // 保存计算结果
        String res = "0";
        for (int i=num2.length()-1;i>=0;i--){
            int x=num2.charAt(i)-'0';
            int add=0;
            StringBuilder temp = new StringBuilder();
            for (int j=num2.length()-1;j>i;j--){
                System.out.println("asdasd");
                temp.append(0);
            }
            for (int j=num1.length()-1;j>=0||add!=0;j--){
                int y=0;
                if (j>=0)
                    y=num1.charAt(j)-'0';
                int result=x*y+add;
                temp.append(result%10);
                add=result/10;
            }
            res=addStrings(res,temp.reverse().toString());
        }
        return res;
    }
    public String addStrings(String num1, String num2) {
        int x=num1.length()-1;
        int y=num2.length()-1;
        StringBuilder sb=new StringBuilder();
        int add=0;
        while (x>=0||y>=0||add!=0){
            int xx=0,yy=0;
            if (x>=0){
                xx=num1.charAt(x)-'0';
            }
            if (y>=0){
                yy=num2.charAt(y)-'0';
            }
            int result=xx+yy+add;
            sb.append(result%10);
            add=result/10;
            x--;y--;
        }
        sb.reverse();
        return sb.toString();
    }
}

LeetCode第44题

通配符匹配：动态规划

class Solution {
    public boolean isMatch(String s, String p) {
        boolean[][] dp=new boolean[s.length()+1][p.length()+1];
        dp[0][0]=true;
        for (int i=1;i<dp[0].length;i++){
            if (p.charAt(i-1)=='*'){
                dp[0][i]=dp[0][i-1];
            }
        }
        for (int i=1;i<dp.length;i++){
            char schar=s.charAt(i-1);
            for (int j=1;j<dp[0].length;j++){
                char pchar=p.charAt(j-1);
                if (schar==pchar||pchar=='?'){
                    dp[i][j]=dp[i-1][j-1];
                }else if (pchar=='*'){
                    dp[i][j]=dp[i-1][j]==true?dp[i-1][j]:dp[i][j-1];
                }
            }
        }
        return dp[s.length()][p.length()];
    }
}

LeetCode第45题

跳跃游戏 II：贪心算法

class Solution {
    public int jump(int[] nums) {
        int index=0;
        int count=0;
        while (index<nums.length-1){
            int x=nums[index];
            int min=1;
            for (int i=1;i<=x;i++){
                if (index+i>=nums.length-1){
                    return count+1;
                }
                if (i+nums[index+i]>=nums[index+min]+min){
                    min=i;
                }
            }
            index+=min;
            count++;
        }
        return count;
    }
}

LeetCode第46题

全排列：回溯法

class Solution {
    private List<List<Integer>> result=new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        boolean flag[]=new boolean[nums.length];
        List<Integer> tmp=new ArrayList<>();
        dfs(nums,0,flag,tmp);
        return result;
    }
    public void dfs(int[] nums,int count,boolean[] flag,List<Integer> temp){

        if (count==nums.length){
            result.add(new ArrayList<>(temp));
            return;
        }
        for (int i=0;i<nums.length;i++){
            if (!flag[i]){
                temp.add(nums[i]);
                flag[i]=true;
                dfs(nums,count+1,flag,temp);
                temp.remove(count);
                flag[i]=false;
            }
        }
    }
}

LeetCode第47题

全排列2：回溯法加剪枝条件

class Solution {
    private List<List<Integer>> result=new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        boolean flag[]=new boolean[nums.length];
        List<Integer> tmp=new ArrayList<>();
        dfs(nums,0,flag,tmp);
        return result;
    }
    public void dfs(int[] nums,int count,boolean[] flag,List<Integer> temp){
        if (count==nums.length){
            result.add(new ArrayList<>(temp));
            return;
        }
        for (int i=0;i<nums.length;i++){
            if (flag[i]){
                continue;
            }
            if(i>0 && nums[i] == nums[i-1] && flag[i-1]) break;
            temp.add(nums[i]);
            flag[i]=true;
            dfs(nums,count+1,flag,temp);
            temp.remove(count);
            flag[i]=false;
        }
    }
}

LeetCode第48题

旋转图像：方法就是四角交换

class Solution {
    public void rotate(int[][] matrix) {
        boolean[][] flag=new boolean[matrix.length][matrix[0].length];
        for (int i=0;i<matrix.length;i++){
            for (int j=0;j<matrix[i].length;j++){
                int tmp=matrix[i][j];
                int x=i,y=j;
                int count=0;
                while (!flag[x][y]){
                    if (count!=3){
                        matrix[x][y]=matrix[matrix.length-y-1][x];
                    }else {
                        matrix[x][y]=tmp;
                    }
                    count++;
                    flag[x][y]=true;
                    int change=x;
                    x=matrix.length-y-1;
                    y=change;
                }
            }
        }
    }
}

LeetCode第49题

字母异位词分词

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String,List<String>> map=new HashMap<>();
        for (int i=0;i<strs.length;i++){
            char ch[]=strs[i].toCharArray();
            Arrays.sort(ch);
            String key=new String(ch);
            if (!map.containsKey(key)){
                List<String> l=new ArrayList<>();
                l.add(strs[i]);
                map.put(key,l);
            }else {
                map.get(key).add(strs[i]);
            }
        }
        return new ArrayList<>(map.values());
    }
}

LeetCode第50题

Pow(x,y):分治算法

class Solution {
    public double myPow(double x, int n) {
        long N=n;
        return N>0?quickMul(x,N):1.0/quickMul(x,N);
    }
    public double quickMul(double x, long n) {
        if (n==0){
            return 1.0;
        }
        double y=quickMul(x,n/2);
        if (n%2==0){
            return y*y;
        }else{
            return y*y*x;
        }
    }
}

LeetCode第51题

n皇后（返回解决方案）：回溯法
在这里插入图片描述

class Solution {
    private List<List<String>> result=new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        char[][] chars=new char[n][n];
        for (int i=0;i<n;i++){
            for (int j=0;j<n;j++){
                chars[i][j]='.';
            }
        }
        boolean col[]=new boolean[n];
        List<String> slist=new ArrayList<>();
        dfs(0,col,chars,slist);
        return result;
    }
    public void dfs(int row,boolean[] col,char[][] chars,List<String> slist){
        if (row==chars.length){
            result.add(new ArrayList<String>(slist));
            return;
        }
        for (int i=0;i<chars.length;i++){
            if (!col[i]&&valid(row,i,chars)){
                chars[row][i]='Q';
                col[i]=true;
                slist.add(new String(chars[row]));
                dfs(row+1,col,chars,slist);
                slist.remove(slist.size()-1);
                col[i]=false;
                chars[row][i]='.';
            }
        }
    }
    public boolean valid(int row,int col,char[][] chars){
        for (int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){
            if (chars[i][j]=='Q'){
                return false;
            }
        }
        for (int i=row-1,j=col+1;i>=0&&j<chars.length;i--,j++){
            if (chars[i][j]=='Q'){
                return false;
            }
        }
        return true;
    }
}

LeetCode第52题

n皇后（返回解决个数）：回溯法，同51题
在这里插入图片描述

class Solution {
    private int num=0;
    public int totalNQueens(int n) {
       char[][] chars=new char[n][n];
        for (int i=0;i<n;i++){
            for (int j=0;j<n;j++){
                chars[i][j]='.';
            }
        }
        boolean col[]=new boolean[n];
        dfs(0,col,chars);
        return num;
    }
        public void dfs(int row,boolean[] col,char[][] chars){
        if (row==chars.length){
            num++;
            return;
        }
        for (int i=0;i<chars.length;i++){
            if (!col[i]&&valid(row,i,chars)){
                chars[row][i]='Q';
                col[i]=true;
                dfs(row+1,col,chars);
                col[i]=false;
                chars[row][i]='.';
            }
        }
    }
    public boolean valid(int row,int col,char[][] chars){
        for (int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){
            if (chars[i][j]=='Q'){
                return false;
            }
        }
        for (int i=row-1,j=col+1;i>=0&&j<chars.length;i--,j++){
            if (chars[i][j]=='Q'){
                return false;
            }
        }
        return true;
    }
   
}

LeetCode第53题

最大子序和：动态规划，dp用来存储以当前字母结尾的最大子序和
在这里插入图片描述

class Solution {
    public int maxSubArray(int[] nums) {
		int[] dp = new int[nums.length];
		dp[0] = nums[0];
		int max = nums[0];
		for (int i = 1; i < nums.length; i++) {
			dp[i] = Math.max(dp[i- 1] + nums[i], nums[i]);	
			if (max < dp[i]) {
				max = dp[i];
			}
		}
		return max;
	}
}

LeetCode第54题

螺旋矩阵
在这里插入图片描述

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result=new ArrayList<Integer>();
        if (matrix.length==0){
            return result;
        }
        int i=0,j=0;
        int all=matrix.length*matrix[0].length;
        int count=0;
        boolean row=true;
        boolean right=true;
        boolean[][] flag=new boolean[matrix.length][matrix[0].length];
        boolean down=false;
        while (count<all){
            result.add(matrix[i][j]);
            flag[i][j]=true;
            if (row){
                if (right){
                    if (j==matrix[0].length-1||flag[i][j+1]){
                        down=true;
                        row=false;
                        i++;
                    }else {
                        j++;
                    }
                }else {
                    if (j==0||flag[i][j-1]){
                        down=false;
                        row=false;
                        i--;
                    }else {
                        j--;
                    }
                }
            }else {
                if (down){
                    if (i==matrix.length-1||flag[i+1][j]){
                        row=true;
                        right=false;
                        j--;
                    }else {
                        i++;
                    }
                }else {
                    if (flag[i-1][j]){
                        row=true;
                        right=true;
                        j++;
                    }else {
                        i--;
                    }
                }
            }
            count++;
        }
        return result;
    }
}

LeetCode第55题

跳跃游戏：如果已经确定能到达的最大位置没有当前位置远，那么会失败

在这里插入图片描述

class Solution {
    public boolean canJump(int[] nums){
        int k=0;
        for (int i=0;i<nums.length;i++){
            if (k<i){
                return false;
            }
            k=Math.max(i+nums[i],k);
        }
        return true;
    }
}

LeetCode第56题

合并区间
在这里插入图片描述

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, Comparator.comparingInt(v -> v[0]));
        int[][] res = new int[intervals.length][2];
        int index=0;
        for (int[] interval:intervals){
            if (index==0||interval[0]>res[index-1][1]){
                res[index++]=interval;
            }else {
                res[index-1][1]=Math.max(res[index-1][1],interval[1]);
            }
        }
        return Arrays.copyOf(res, index);
    }
}

LeetCode第57题

插入区间
在这里插入图片描述

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        int[][] oldIntervals = Arrays.copyOf(intervals, intervals.length + 1);
        oldIntervals[oldIntervals.length-1]=newInterval;
        Arrays.sort(oldIntervals, Comparator.comparingInt(v -> v[0]));
        int[][] res = new int[oldIntervals.length][2];
        int index=0;
        for (int[] interval:oldIntervals){
            if (index==0||interval[0]>res[index-1][1]){
                res[index++]=interval;
            }else {
                res[index-1][1]=Math.max(res[index-1][1],interval[1]);
            }
        }
        return Arrays.copyOf(res, index);
    }
}

LeetCode第58题

最后一个单词的长度
在这里插入图片描述

class Solution {
    public int lengthOfLastWord(String s) {
        int start=-1,end=-1;
        boolean flag=false;
        for (int i=s.length()-1;i>=0;i--){
            char ch=s.charAt(i);
            if (ch==' '){
                if (flag){
                    start=i+1;
                    return end-start+1;
                }
            }else {
                if (!flag){
                    flag=true;
                    end=i;
                }
            }
        }
        if (!flag){
            return 0;
        }
        start=0;
        return end-start+1;
    }
}

LeetCode第59题

螺旋矩阵2
在这里插入图片描述

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] matrix=new int[n][n];
        boolean[][] flag=new boolean[n][n];
        int i=0,j=0;
        int all=matrix.length*matrix[0].length;
        int count=0;
        boolean row=true;
        boolean right=true;
        boolean down=false;
        while (count<all){
            matrix[i][j]=count+1;
            flag[i][j]=true;
            if (row){
                if (right){
                    if (j==matrix[0].length-1||flag[i][j+1]){
                        down=true;
                        row=false;
                        i++;
                    }else {
                        j++;
                    }
                }else {
                    if (j==0||flag[i][j-1]){
                        down=false;
                        row=false;
                        i--;
                    }else {
                        j--;
                    }
                }
            }else {
                if (down){
                    if (i==matrix.length-1||flag[i+1][j]){
                        row=true;
                        right=false;
                        j--;
                    }else {
                        i++;
                    }
                }else {
                    if (flag[i-1][j]){
                        row=true;
                        right=true;
                        j++;
                    }else {
                        i--;
                    }
                }
            }
            count++;
        }
        return matrix;
    }
}

LeetCode第60题

第k个排列：官方的方法看不懂，用回溯法解决效率感人
在这里插入图片描述

class Solution {
    StringBuilder sb=new StringBuilder();
    public int num=0;
    boolean flag=false;
    String re="";
    public String getPermutation(int n, int k) {
        boolean[] visited=new boolean[n];
        dfs(n,k,0,visited);
        return re;
    }
    public void dfs(int n,int k,int length,boolean[] visited){
        if (length==n){
            num++;
            if (num==k){
                flag=true;
                re=sb.toString();
                return;
            }
        }
        for (int i=1;i<=n;i++){
            if (!flag){
                if (!visited[i-1]){
                    visited[i-1]=true;
                    sb.append(i);
                    dfs(n,k,length+1,visited);
                    sb.deleteCharAt(length);
                    visited[i-1]=false;
                }
            }else {
                break;
            }

        }
    }
}
NWU_LK
关注
专栏目录
【LeetCode】第292题——Nim游戏（难度：简单）
Se7en_Dayz的博客
01-06 2885
【LeetCode】第292题——Nim游戏（难度：简单）题目描述解题思路代码详解注意点 题目描述 你和你的朋友，两个人一起玩 Nim 游戏： 桌子上有一堆石头。 你们轮流进行自己的回合，你作为先手。 每一回合，轮到的人拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。 假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢，返回 true；否则，返回 false 。 示例 1： 输入：n = 4 输出：false 解释：如果堆中有 4
【LeetCode】第409题——最长回文串（难度：简单）
Se7en_Dayz的博客
01-19 1万+
【LeetCode】第409题——最长回文串（难度：简单）题目描述解题思路代码详解注意点 题目描述 给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。 在构造过程中，请注意区分大小写。比如 “Aa” 不能当做一个回文字符串。 注意: 假设字符串的长度不会超过 1010。 示例 1: 输入:“abccccdd” 输出:7 解释: 我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。 来源：力扣（LeetCode） 链接：https://leetcode-cn.co
【LeetCode】每日一题——475. 供暖器
heart_6662的博客
12-20 2100
目录 题目： 思路： 方法一：二分查找 方法二：排序 + 双指针 题目： 思路： 其实就是要找每个房子落在哪个加热器之间，然后比较他们俩这种更近的那一侧。可以使用二分，也可以使用双指针，从头开始一起移动。 方法一：二分查找 class Solution: def findRadius(self, houses: List[int], heaters: List[int]) -> int: ans = 0 hea...
【LeetCode】每日一题——630. 课程表 III
heart_6662的博客
12-14 2408
目录 题目： ​分析： 方法：优先队列 + 贪心 参考文章 题目： 分析： 结束时间越早的课程先排，每次排都紧前排，空闲时间都让给后面。 如果排完一个课程后发现课程总时长超过了最晚的结束时间，说明课程有重叠，删除掉时长最长的课程再继续排。注意这个最长时长课程可能是当前课程 方法：优先队列 + 贪心 解析看注解 class Solution: def scheduleCourse(self, courses: List[Li...
【LeetCode】每日一题——686. 重复叠加字符串匹配
heart_6662的博客
12-22 2536
目录 题目： 思路： 代码： 代码解读 ​参考链接： 题目： 686. 重复叠加字符串匹配 思路： 刚刚好字符覆盖，或者差一个a字符 代码： class Solution: def repeatedStringMatch(self, a: str, b: str) -> int: return l if (a * (l:=ceil(len(b)/len(a)))).find(b) != -1 else l + 1 if...
【LeetCode】每日一题——1610. 可见点的最大数目
heart_6662的博客
12-16 2841
目录 题目: ​思路： 代码: 分析： 题目: 力扣 思路： 我想先算出每个点和定点和x轴的角度 然后这些角度排序 然后将最小的加90度看有 这些角度有多少在这个区间 依次这样下去 然后去最大的 这个90度 （就是那个angle） 代码: class Solution: def visiblePoints(self, points: List[List[int]], angle: int, location: List[int]) -...
LeetCode 1402. 做菜顺序——呱呱的每日一题
热门推荐
concyclics的博客
05-25 3万+
@[TOC](LeetCode 1402. 做菜顺序——呱呱的每日一题(水)) 一、题目 链接 LeetCode 1402. 做菜顺序. 题面 一个厨师收集了他 n 道菜的满意程度 satisfaction ，这个厨师做出每道菜的时间都是 1 单位时间。 一道菜的 「喜爱时间」系数定义为烹饪这道菜以及之前每道菜所花费的时间乘以这道菜的满意程度，也就是 time[i]*satisfaction[i] 。 请你返回做完所有菜 「喜爱时间」总和的最大值为多少。 你可以按 任意 顺序安排做菜的顺序，你也可以选择放
关于leetcode插件 leetcode editor的cookie登录——idea
m0_58275619的博客
09-06 2万+
关于leetcode插件 leetcode editor的cookie登录——idea 装好该插件后，可以查看leetcode的题目，但是还不能提交，要先登录 在settings >>Tools >> leetcode plugin设置登录地址URL是美国(leetcode.com)还是中国(leetcode-cn.com),登录账号loginName 和密码password 点击sign in 第一次点击会让你输入cookie ...
Leetcode高频算法题——字节跳动篇
Erazer_Control
04-15 6093
众所周知，字节跳动面试非常喜欢考算法题。 Leetcode官方的企业题库不仅付费，而且题量非常大。 因此，我从20年7月开始，手动整理牛客面经涉及的Leetcode算法题，并按照频度由高到低进行了排列。以下列出的250多道高频题目。 如果你想查看按部门、岗位查看高频算法题，或者查看其他大厂的题库，可以使用我开发的CodeTop：https://codetop.cc 字节跳动题库已覆盖抖音、飞书、架构、data、商业变现、懂车帝、电商、今日头条等20多个部门。 字节跳动高频题（更新至2021年4.10日）
【C语言刷题——Leetcode10道简单题】
weixin_60478154的博客
06-11 2721
C语言——Leetcode10道简单题
leetcode题库-LeetCode_Daily_Problem:LeetCode_Daily_Problem
06-29
本资源包——"LeetCode_Daily_Problem"，就是这样一个专为提升编程能力而设计的题库，它包含了LeetCode的部分题目及其解决方案，是编程爱好者们日常练习、挑战自我的宝贵资料。 "LeetCode_Daily_Problem"这个名字寓...
lrucacheleetcode-leetcode:记录自己的leetcode解题历程~Welcomeeveryonetocomment:grinning_face:~
06-29
———————————————————————————————————————————————————————— ——————————————————————————————————————————...
leetcode怎么配置环境变量-leetcode_score_monitoring:leetcode_score_monitoring
07-07
leetcode怎么配置环境变量Leetcode 评分监控项目建立 步骤 0 - 项目环境设置 设置 Python 环境并获取它 mkdir ~/python-virtual-environments cd ~/python-virtual-environments python3 -m venv env source ~/...
leetcode题库-LeetCode_LocalDebug_Cpp:在clion中本地调试LeetCode
06-29
在leetcode上做题调试起来总有些不方便，所以查阅了一些资料后，按以下配置，自我感觉效率还行，分享给大家。祝大家刷题愉快。 参考： 源码： 依赖Clion插件 使用方法 1.安装上述插件 打开CLion设置，在Plugins 搜索...
leetcode全ac-leetcode_locked_problems:leetcode_locked_problems
06-30
leetcode ac leetcode_locked_problems 这是我最近购买的锁定leetcode问题的代码摘要。 我只是给出了问题定义和详细的cpp解决方案，希望可以帮助你深入了解相关问题。 此外，我将上传所有 leetcode 问题的所有 ONE-...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 553
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
leetcode389:赎金信
最新发布
D2510466299的博客
10-20 391
ransomNote和magazine，判断ransomNote能不能由magazine里面的字符构成。如果可以，返回true；否则返回false。magazine中的每个字符只能在ransomNote中使用一次。
Leetcode 1168. 水资源分配优化
m0_51437455的博客
10-14 496
对于每个房子 i，我们有两种可选的供水方案：一种是直接在房子内建造水井，成本为 wells[i – 1] （注意 -1 ，因为 索引从0开始 ）；另一种是从另一口井铺设管道引水，数组 pipes 给出了在房子间铺设管道的成本，其中每个 pipes[j] = [house1_j, house2_j, cost_j] 代表用管道将 house1_j 和 house2_j连接在一起的成本。第二步，使用Prim算法模板或者Kruskal算法模板解除最小生成树的权值和（详情可以看下代码的注释）
【力扣 | SQL题 | 每日4题】力扣1164，3293，1308，1270
2301_80912559的博客
10-17 992
4 mid，四题都比较简单，没什么难度。
微软数据结构与算法面试题41-60答案解析
"微软等数据结构+算法面试100题[第41-60题答案]" 在软件开发领域，尤其是面试过程中，数据结构和算法是衡量候选人技术能力的重要标准。微软等顶级科技公司在面试时，常常会设计一系列涵盖各种数据结构和算法的问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值